;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



#@44 What to substitute for undefined entities.
(defconst xml-undefined-entity "?" (#$ . 84))
#@53 Alist mapping default XML namespaces to their URIs.
(defconst xml-default-ns '((#1="" . #1#) ("xml" . "http://www.w3.org/XML/1998/namespace") ("xmlns" . "http://www.w3.org/2000/xmlns/")) (#$ . 179))
#@55 Alist mapping XML entities to their replacement text.
(defvar xml-entity-alist '(("lt" . "<") ("gt" . ">") ("apos" . "'") ("quot" . "\"") ("amp" . "&")) (#$ . 384))
#@293 The maximum size of entity reference expansions.
If the size of the buffer increases by this many characters while
expanding entity references in a segment of character data, the
XML parser signals an error.  Setting this to nil removes the
limit (making the parser vulnerable to XML bombs).
(defvar xml-entity-expansion-limit 20000 (#$ . 564))
#@43 Alist of defined XML parametric entities.
(defvar xml-parameter-entity-alist nil (#$ . 915))
#@57 Non-nil when the XML parser is parsing an XML fragment.
(defvar xml-sub-parser nil (#$ . 1014))
#@42 Set to non-nil to get validity checking.
(defvar xml-validating-parser nil (#$ . 1116))
#@393 Return the tag associated with NODE.
Without namespace-aware parsing, the tag is a symbol.

With namespace-aware parsing, the tag is a cons of a string
representing the uri of the namespace with the local name of the
tag.  For example,

    <foo>

would be represented by

    ("" . "foo").

If you'd just like a plain symbol instead, use `symbol-qnames' in
the PARSE-NS argument.

(fn NODE)
(defalias 'xml-node-name #[257 "\211@\207" [] 2 (#$ . 1211)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put xml-node-name speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@72 Return the list of attributes of NODE.
The list can be nil.

(fn NODE)
(defalias 'xml-node-attributes #[257 "\211A@\207" [] 2 (#$ . 1810)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put xml-node-attributes speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@93 Return the list of children of NODE.
This is a list of nodes, and it can be nil.

(fn NODE)
(defalias 'xml-node-children #[257 "\211AA\207" [] 2 (#$ . 2101)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put xml-node-children speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@139 Return the children of NODE whose tag is CHILD-NAME.
CHILD-NAME should match the value returned by `xml-node-name'.

(fn NODE CHILD-NAME)
(defalias 'xml-get-children #[514 "\300\211AA\262
\211\203(\211@\211<\203!\211\211@\262
\232\203!\211B\262
A\266\202\202\210\211\237\207" [nil] 7 (#$ . 2410)])
#@134 Get from NODE the value of ATTRIBUTE.
Return nil if the attribute was not found.

See also `xml-get-attribute'.

(fn NODE ATTRIBUTE)
(defalias 'xml-get-attribute-or-nil #[514 "\300
\211A@\262
\"A\207" [assoc] 6 (#$ . 2724)])
#@158 Get from NODE the value of ATTRIBUTE.
An empty string is returned if the attribute was not found.

See also `xml-get-attribute-or-nil'.

(fn NODE ATTRIBUTE)
(defalias 'xml-get-attribute #[514 "\300\"\206\301\207" [xml-get-attribute-or-nil ""] 5 (#$ . 2957)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put xml-get-attribute speed -1 put byte-optimizer byte-compile-inline-expand] 5)
(defconst xml-name-start-char-re "[[:word:]:_]")
(defconst xml-name-char-re "[[:word:]:_.0-9·̀-ͯ‿⁀-]")
(defconst xml-name-re (concat xml-name-start-char-re xml-name-char-re "*"))
(defconst xml-names-re (concat xml-name-re "\\(?: " xml-name-re "\\)*"))
(defconst xml-nmtoken-re (concat xml-name-char-re "+"))
(defconst xml-nmtokens-re (concat xml-nmtoken-re "\\(?: " xml-name-re "\\)*"))
(defconst xml-char-ref-re "\\(?:&#[0-9]+;\\|&#x[[:xdigit:]]+;\\)")
(defconst xml-entity-ref (concat "&" xml-name-re ";"))
(defconst xml-entity-or-char-ref-re (concat "&\\(?:#\\(x\\)?\\([[:xdigit:]]+\\)\\|\\(" xml-name-re "\\)\\);"))
(defconst xml-pe-reference-re (concat "%\\(" xml-name-re "\\);"))
(defconst xml-reference-re (concat "\\(?:" xml-entity-ref "\\|" xml-char-ref-re "\\)"))
(defconst xml-att-value-re (concat "\\(?:\"\\(?:[^&\"]\\|" xml-reference-re "\\)*\"\\|'\\(?:[^&']\\|" xml-reference-re "\\)*'\\)"))
(defconst xml-tokenized-type-re "\\(?:ID\\|IDREF\\|IDREFS\\|ENTITY\\|ENTITIES\\|NMTOKEN\\|NMTOKENS\\)")
(defconst xml-notation-type-re (concat "\\(?:NOTATION\\s-+(\\s-*" xml-name-re "\\(?:\\s-*|\\s-*" xml-name-re "\\)*\\s-*)\\)"))
(defconst xml-enumeration-re (concat "\\(?:(\\s-*" xml-nmtoken-re "\\(?:\\s-*|\\s-*" xml-nmtoken-re "\\)*\\s-+)\\)"))
(defconst xml-enumerated-type-re (concat "\\(?:" xml-notation-type-re "\\|" xml-enumeration-re "\\)"))
(defconst xml-att-type-re (concat "\\(?:CDATA\\|" xml-tokenized-type-re "\\|" xml-enumerated-type-re "\\)"))
(defconst xml-default-decl-re (concat "\\(?:#REQUIRED\\|#IMPLIED\\|\\(?:#FIXED\\s-+\\)*" xml-att-value-re "\\)"))
(defconst xml-att-def-re (concat "\\(?:\\s-*" xml-name-re #1="\\s-*" xml-att-type-re #1# xml-default-decl-re "\\)"))
(defconst xml-entity-value-re (concat "\\(?:\"\\(?:[^%&\"]\\|" xml-pe-reference-re #1="\\|" xml-reference-re "\\)*\"\\|'\\(?:[^%&']\\|" xml-pe-reference-re #1# xml-reference-re "\\)*'\\)"))
#@147 Syntax table used by the XML parser.
In this syntax table, the XML space characters [ \t\r\n], and
only those characters, have whitespace syntax.
(defvar xml-syntax-table (byte-code "\300\301\302\"\303\211\203\211@\304
\305#\210
A\266\202\202\210\304\306\307#\210\304\310\307#\210\304\311\307#\210\304\312\307#\210\304\313\307#\210\304\314\307#\210\304\315\307#\210\304\316\307#\210\304\317\307#\210\304\320\307#\210\304\321\307#\210\304\322\307#\210\304\323\307#\210\304\324\307#\210\207" [make-char-table syntax-table (3) (32 9 13 10) modify-syntax-entry " " (65 . 90) "w" (97 . 122) (192 . 214) (216 . 246) (248 . 767) (880 . 893) (895 . 8191) (8204 . 8205) (8304 . 8591) (11264 . 12271) (12289 . 55295) (63744 . 64975) (65008 . 65533) (65536 . 983039)] 7) (#$ . 5265))
#@688 Parse the well-formed XML file FILE.
Return the top node with all its children.
If PARSE-DTD is non-nil, the DTD is parsed rather than skipped.

If PARSE-NS is non-nil, then QNAMES are expanded.  By default,
the variable `xml-default-ns' is the mapping from namespaces to
URIs, and expanded names will be returned as a cons

  ("namespace:" . "foo").

If PARSE-NS is an alist, it will be used as the mapping from
namespace to URIs instead.

If it is the symbol `symbol-qnames', expanded names will be
returned as a plain symbol `namespace:foo' instead of a cons.

Both features can be combined by providing a cons cell

  (symbol-qnames . ALIST).

(fn FILE &optional PARSE-DTD PARSE-NS)
(defalias 'xml-parse-file #[769 "\300\301\302\"r\211q\210\303\304\"\216\305!\210\306\"*\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents xml--parse-buffer] 7 (#$ . 6064)])
#@917 Parse the region from BEG to END in BUFFER.
Return the XML parse tree, or raise an error if the region does
not contain well-formed XML.

If BEG is nil, it defaults to `point-min'.
If END is nil, it defaults to `point-max'.
If BUFFER is nil, it defaults to the current buffer.
If PARSE-DTD is non-nil, parse the DTD and return it as the first
element of the list.
If PARSE-NS is non-nil, then QNAMES are expanded.  By default,
the variable `xml-default-ns' is the mapping from namespaces to
URIs, and expanded names will be returned as a cons

  ("namespace:" . "foo").

If PARSE-NS is an alist, it will be used as the mapping from
namespace to URIs instead.

If it is the symbol `symbol-qnames', expanded names will be
returned as a plain symbol `namespace:foo' instead of a cons.

Both features can be combined by providing a cons cell

  (symbol-qnames . ALIST).

(fn &optional BEG END BUFFER PARSE-DTD PARSE-NS)
(defalias 'xml-parse-region #[1280 "\204p\262\300\301\302\"r\211q\210\303\304\"\216\305#\210\306\"*\207" [generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] insert-buffer-substring-no-properties xml--parse-buffer] 10 (#$ . 7024)])
#@27 

(fn PARSE-DTD PARSE-NS)
(defalias 'xml--parse-buffer #[514 "\305 p\306\307#\216\310!\210\311	\n\311\211\211eb\210m\204{\312\313\311\314#\203u\315u\210\316\n\n\"\262
\204Am\204\317u\210\202\203P\f\204P\320\321!\210\202
@<\203m	\203m
@\262

A\203
AB\262\202
B\262\202db\210\202	\203\207\211\237B\202\211\237+\266\206)\207" [xml-syntax-table xml-entity-alist xml-parameter-entity-alist case-fold-search xml-sub-parser syntax-table make-closure #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table nil search-forward "<" t -1 xml-parse-tag-1 1 error "XML: (Not Well-Formed) Only one root tag allowed"] 14 (#$ . 8250)])
#@600 Perform any namespace expansion.
NAME is the name to perform the expansion on.
DEFAULT is the default namespace.  XML-NS is a cons of namespace
names to uris.  When namespace-aware parsing is off, then XML-NS
is nil.

During namespace-aware parsing, any name without a namespace is
put into the namespace identified by DEFAULT.  nil is used to
specify that the name shouldn't be given a namespace.
Expanded names will by default be returned as a cons.  If you
would like to get plain symbols instead, provide a cons cell

  (symbol-qnames . ALIST)

in the XML-NS argument.

(fn NAME DEFAULT XML-NS)
(defalias 'xml-maybe-do-ns #[771 "\211:\203l\211\242\300=\301\302\"\211\203\303\225\304O\202
\203&\303\211\224O\202'
\305\230\205/\211?\306
\2038\305\2029\203DA\202F\"A\206L\307\203`
\204`\305\230\204`\310
P!\207\211\203i\307\202jB\207\310!\207" [symbol-qnames string-match ":" 0 nil "xmlns" assoc "" intern] 12 (#$ . 8941)])
#@418 Parse the tag at point.
If PARSE-DTD is non-nil, the DTD of the document, if any, is parsed and
returned as the first element in the list.
If PARSE-NS is non-nil, expand QNAMES; for further details, see
`xml-parse-region'.

Return one of:
 - a list : the matching node
 - nil    : the point is not looking at a tag.
 - a pair : the first element is the DTD, the second is the node.

(fn &optional PARSE-DTD PARSE-NS)
(defalias 'xml-parse-tag #[512 "\304	\np`\305\306\307\"r\211q\210\310\311\"\216\312 p\310\313#\216\314!\210\315\"\210eb\210\316\")\266\202*\262
+\207" [case-fold-search xml-entity-alist xml-parameter-entity-alist xml-syntax-table nil generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] syntax-table #[0 "r\301q\210\302\300!)\207" [V0 V1 set-syntax-table] 2] set-syntax-table insert-buffer-substring-no-properties xml-parse-tag-1] 11 (#$ . 9909)])
#@104 Like `xml-parse-tag', but possibly modify the buffer while working.

(fn &optional PARSE-DTD PARSE-NS)
(defalias 'xml-parse-tag-1 #[512 "
\206\211\304=\203\304	B\202.\211\242:\204%\211\242\304=\203)\211A<\203)\211\202.\211\205.	\305\306\307
!)\262
\203I\310\311!\210\312\313!\210\314\"\202\366
\307\315!\203j\316\225\310\317\320\306#\204]\321\322!\210\323
\316\224\"\324 P\262
\202\366
\325\306\307
!)\262
\203\223\326!\312\313!\210\203\212\211\314\320\"B\202\216\314\320\"\262
\202\366
\327\306\307
!)\262
\203\266\310\330!\210\312\313!\210m?\205\366
\306\314\")\202\366
\331\306\307
!)\262
\203\306\320\202\366
\307\332!\203\326
\333\225b\210\334\333!\335!\320:\203

\211\203
\211@\211@:\203
\211@@\336\232\203
\211@A
AB@9\203

AB\241\266\202
\211B\262\210
A\266\202\202\335\210
\337\340#D\262
\341\306\307
!)\262
\203:
\342u\210\211\237\266\203\202\366
\320f\343=\203\307
\333u\210\331\344Q\307
!\204\272
m\203Z
\321\345\"\210\202H
\331\306\307
!)\262
\203\205
\342u\210\321\346`\211\347\344\320\306#\203z
\316\224\202{
d{\262
#\210\202H
\320f\350U\203\236
\314\320\"\211\203\232
\211B\262\210\202H
\324 @;\203\261
\211A\262\242
P\202\262
\211B\262\210\202H
\316\225b\210
\237\262
\266\203\202\366
\321\351\323`\352Z`T\"\"\266\203\202\366
\204\336
\321\353!\210\324 \211G\316U\203\363
\321\354\323``\352\\d^\"\"\210\211\262
)\207" [xml-validating-parser xml-default-ns inhibit-changing-match-data xml-sub-parser symbol-qnames "<\\?" t looking-at search-forward "?>" skip-syntax-forward " " xml-parse-tag-1 "<!\\[CDATA\\[" 0 "]]>" nil error "XML: (Not Well Formed) CDATA section does not end anywhere in the document" buffer-substring-no-properties xml-parse-string "<!DOCTYPE[ 	\n
]" xml-parse-dtd "<!--" "-->" "</" "<\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)" 1 match-string-no-properties xml-parse-attlist "http://www.w3.org/2000/xmlns/" xml-maybe-do-ns "" "/>" 2 62 "\\s-*>" "XML: (Not Well-Formed) End of document while reading element `%s'" "XML: (Not Well-Formed) Invalid end tag `%s' (expecting `%s')" re-search-forward 60 "XML: (Well-Formed) Couldn't parse tag: %s" 10 "XML: (Well-Formed) Invalid character" "XML: (Not Well-Formed) Could not parse: %s"] 15 (#$ . 10853)])
#@195 Parse character data at point, and return it as a string.
Leave point at the start of the next thing to parse.  This
function can modify the buffer by expanding entity and character
references.
(defalias 'xml-parse-string #[0 "`\306 `Z\307\211m\204\255\310\311\312
!)\262
\204\255\313\307w\210\307f\314=\203\312	!\204,\315\316!\210\317\320!\211\262\203p\321 \322\323\"\216\324\325\326\317\327!\205G\330\"\")\262
\262
\211\204]\n\203]\315\331\317\332!\"\210\333
\203h\334!\202i\311\211#\210\202\227\317\335!\262\336\f\"\262
\211\204\210\n\203\210\315\337\"\210\333
A\206\217\311\211#\210\332\224b\210
\203\306 `Z
\\V\203\315\340!\210\202\341 b\210\342\343\311#\203\303\333\344\311\211#\210\202\262\211b\210`{\207" [inhibit-changing-match-data xml-entity-or-char-ref-re xml-validating-parser xml-undefined-entity xml-entity-alist xml-entity-expansion-limit buffer-size nil "<" t looking-at "^<&" 38 error "XML: (Not Well-Formed) Invalid entity reference" match-string 2 match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] decode-char ucs string-to-number 1 16 "XML: (Validity) Invalid character reference `%s'" 0 replace-match string 3 assoc "XML: (Validity) Undefined entity `%s'" "XML: Entity reference expansion surpassed `xml-entity-expansion-limit'" point-marker re-search-forward "
\n?" "\n"] 11 (#$ . 13122)])
#@123 Return the attribute-list after point.
Leave point at the first non-blank character after the tag.

(fn &optional XML-NS)
(defalias 'xml-parse-attlist #[256 "\300\211\211\301\302!\210\303\304!\203o\305\225\262\306\307\310!\300#\262

b\210\303\311!\203+\305\225\262\202<\303\312!\2038\305\225\262\202<\313\314!\210\315
\"\203G\313\316!\210\307\310!\317\320\302#\210\321
!\211;\204\\\313\322!\210
BB\262\266
b\210\301\302!\210\202\237\207" [nil skip-syntax-forward " " looking-at "\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)\\s-*=\\s-*" 0 xml-maybe-do-ns match-string-no-properties 1 "\"\\([^\"]*\\)\"" "'\\([^']*\\)'" error "XML: (Not Well-Formed) Attribute values must be given between quotes" assoc "XML: (Not Well-Formed) Each attribute must be unique within an element" replace-regexp-in-string "\\s-\\{2,\\}" xml-substitute-special "XML: (Not Well-Formed) Entities in attributes cannot expand into elements"] 9 (#$ . 14511)])
#@78 Skip the DTD at point.
This follows the rule [28] in the XML specifications.
(defalias 'xml-skip-dtd #[0 "\301\302 )\207" [xml-validating-parser nil xml-parse-dtd] 1 (#$ . 15474)])
#@50 Parse the DTD at point.

(fn &optional PARSE-NS)
(defalias 'xml-parse-dtd #[256 "\305u\210\306\307!\210\310\311\312
!)\262
\203	\203\313\314!\210\312\n!\210\315\316!\317D\320
\316\225b\210\306\307!\210\312\321!\203w\316\225b\210\322\323\320\311#\204N\322\324\320\311#\204N\313\325!\210\315\326!\306\307!\210\322\327\320\311#\204i\322\330\320\311#\204i\313\331!\210\211\315\326!\332EB\262\210\202\236\312\333!\203\236\316\225b\210\322\327\320\311#\204\225\322\330\320\311#\204\225\313\331!\210\315\326!\334DB\262\306\307!\210\320f\335=\203\257\320u\210\202s\320f\336=\204\272\313\337!\210\320u\210\212\322\f\320\311#\205\310\316\224)\262
\340\311\312
!)\262
\204i\306\307!\210m\203\346\313\341!\210\202\313\312\342!\203u
\211\203\367\316\225
X\203u
\315\326!\315\343!\316\225\344\320\311\345#)\266\203\203
\346\262\202U
\347\320\311\345#)\266\203\203+
\350\262\202U
\345\351\"\203=
\352\315\326\"!\262\202U
\353\320\311\345#)\266\203\204U
	\203U
\313\354!\210\355\"\203f
	\203f
\313\356\"\210DB\262\211b\266\202\313\312\357!\203\215
\211\203\206
\316\225
X\203\215
\316\225b\210\202\313\360\311\312
!)\262
\203\270
\361\362!\210\211\203\313`
V\203\313\212\322\f\320\311#\205\262
\316\224)\262
\202\313\312\363!\203\371
\211\203\311
\316\225
X\203\371
\315\343!\316\225b\210\364\326!\203\332
\303\202\333
\365\366\315\367!\326\370O!\355J\"\204\364

BJBL\210\266\202\313\312\371!\204\312\372!\203\211\203\316\225
X\203\316\225b\210\202\313\211\203W\212\211b\210\312\f!\204)\313\373!\210\364\326!\355
\"\211\203B\374
A\311\211#\210b\266\202G\316\225b\266\322\f\320\311#\205Q\316\224\262
)\202\313	\203b\313\375!\210\202\313\376\320w\210\202\313\312\377!\203s\316\225b\210\237)\207" [inhibit-changing-match-data xml-validating-parser xml-name-re xml-parameter-entity-alist xml-pe-reference-re 9 skip-syntax-forward " " ">" t looking-at error "XML: (Validity) Invalid DTD (expecting name of the document)" match-string-no-properties 0 dtd nil "PUBLIC\\s-+" re-search-forward "\\=\"\\([[:space:][:alnum:]'()+,./:=?;!*#@$_%-]*\\)\"" "\\='\\([[:space:][:alnum:]()+,./:=?;!*#@$_%-]*\\)'" "XML: Missing Public ID" 1 "\\='\\([^']*\\)'" "\\=\"\\([^\"]*\\)\"" "XML: Missing System ID" public "SYSTEM\\s-+" system 62 91 "XML: Bad DTD" "\\s-*\\]" "XML: (Well-Formed) End of document while reading DTD" "<!ELEMENT\\s-+\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)\\s-+\\([^>]+\\)>" 2 "\\`EMPTY\\s-*\\'" string-match empty "\\`ANY\\s-*$" any "\\`(\\(.*\\))\\s-*\\'" xml-parse-elem-type "^%[^;]+;[ 	\n
]*\\'" "XML: (Validity) Invalid element type in the DTD" assoc "XML: (Validity) DTD element declarations must be unique (<%s>)" "<!ATTLIST[ 	\n
]*\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)[ 	\n
]*\\(\\(?:\\s-*[[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\s-*\\(?:CDATA\\|\\(?:ID\\|IDREF\\|IDREFS\\|ENTITY\\|ENTITIES\\|NMTOKEN\\|NMTOKENS\\)\\|\\(?:\\(?:NOTATION\\s-+(\\s-*[[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\(?:\\s-*|\\s-*[[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)*\\s-*)\\)\\|\\(?:(\\s-*[[:word:]:_.0-9·̀-ͯ‿⁀-]+\\(?:\\s-*|\\s-*[[:word:]:_.0-9·̀-ͯ‿⁀-]+\\)*\\s-+)\\)\\)\\)\\s-*\\(?:#REQUIRED\\|#IMPLIED\\|\\(?:#FIXED\\s-+\\)*\\(?:\"\\(?:[^&\"]\\|\\(?:&[[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*;\\|\\(?:&#[0-9]+;\\|&#x[[:xdigit:]]+;\\)\\)\\)*\"\\|'\\(?:[^&']\\|\\(?:&[[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*;\\|\\(?:&#[0-9]+;\\|&#x[[:xdigit:]]+;\\)\\)\\)*'\\)\\)\\)\\)*[ 	\n
]*>" "<!--" search-forward "-->" "<!ENTITY[ 	\n
]+\\(%[ 	\n
]+\\)?\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)[ 	\n
]*\\(\\(?:\"\\(?:[^%&\"]\\|%\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\);\\|\\(?:&[[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*;\\|\\(?:&#[0-9]+;\\|&#x[[:xdigit:]]+;\\)\\)\\)*\"\\|'\\(?:[^%&']\\|%\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\);\\|\\(?:&[[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*;\\|\\(?:&#[0-9]+;\\|&#x[[:xdigit:]]+;\\)\\)\\)*'\\)\\)[ 	\n
]*>" match-string xml-entity-alist xml--entity-replacement-text 3 -1 "<!ENTITY[ 	\n
]+\\(%[ 	\n
]+\\)?\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)[ 	\n
]+SYSTEM[ 	\n
]+\\(\"[^\"]*\"\\|'[^']*'\\)[ 	\n
]*>" "<!ENTITY[ 	\n
]+\\(%[ 	\n
]+\\)?\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)[ 	\n
]+PUBLIC[ 	\n
]+\"[- 
\na-zA-Z0-9'()+,./:=?;!*#@$_%]*\"\\|'[- 
\na-zA-Z0-9()+,./:=?;!*#@$_%]*'[ 	\n
]+\\(\"[^\"]*\"\\|'[^']*'\\)[ 	\n
]*>" "XML: Internal error" replace-match "XML: (Validity) Invalid DTD item" "^]" "\\s-*]>"] 14 (#$ . 15662)])
#@171 Return the replacement text for the entity value STRING.
The replacement text is obtained by replacing character
references and parameter-entity references.

(fn STRING)
(defalias 'xml--entity-replacement-text #[257 "\303\304\305\"\203\213
\306\211\224O
B\262

\306\225\303O\303\211\307\310\"\211\262\2039\311\312\313!\"\262
\211\203\203\314
!B\262\202\203\307\315\"\211\262\203[\311\312\313\316\"\"\262
\211\203\203\314
!B\262\202\203\307\317\"\211\262\203\203\320\"\262
\211\204y	\203y\321\322\"\210\211A\206\nB\262\262\266\202
\323\324B\237\325#\207" [xml-parameter-entity-alist xml-validating-parser xml-undefined-entity nil string-match "\\(?:&#\\([0-9]+\\)\\|&#x\\([[:xdigit:]]+\\)\\|%\\([[:word:]:_][[:word:]:_.0-9·̀-ͯ‿⁀-]*\\)\\);" 0 match-string 1 decode-char ucs string-to-number string 2 16 3 assoc error "XML: (Validity) Undefined parameter entity `%s'" mapconcat identity ""] 10 (#$ . 20188)])
#@65 Convert element type STRING into a Lisp structure.

(fn STRING)
(defalias 'xml-parse-elem-type #[257 "\300\211\301\302\"\203?\303\304\"\262\303\305\"\262
\306\307\"\203*\310\311\312\313\307\"\"B\262\202R\306\314\"\203R\315\311\312\313\314\"\"B\262\202R\301\316\"\203R\303\304\"\262\303\305\"\262

;\203`
\317\230\203`\320\262\211\321\230\203j\322D\207\211\323\230\203t\324D\207\211\325\230\203~\326D\207
\207" [nil string-match "(\\([^)]+\\))\\([+*?]?\\)" match-string-no-properties 1 2 string-search "|" choice mapcar xml-parse-elem-type split-string "," seq "[ 	\n
]*\\([^+*?]+\\)\\([+*?]?\\)" "#PCDATA" pcdata "+" + "*" * "?" \?] 9 (#$ . 21146)])
#@135 Return STRING, after substituting entity and character references.
STRING is assumed to occur in an XML attribute value.

(fn STRING)
(defalias 'xml-substitute-special #[257 "\211G\305\306\"\203\217\307\211\224O
B\262
\307\225\305O\310\311\"\310\312\"\211\203W\313\314\315\205.\316\"\"\211\203:\317
!\202F	\203E\320\321\"\202F\nB\262\262G\262\266\202\310\322\"\262
\323
\"A\206r	\203q\320\324\"\202r\n\211P\262\210\f\203\212G\f\\V\203\212\320\325\"\210\266\202\326\327B\237\330#\207" [xml-entity-or-char-ref-re xml-validating-parser xml-undefined-entity xml-entity-alist xml-entity-expansion-limit nil string-match 0 match-string 1 2 decode-char ucs string-to-number 16 string error "XML: (Validity) Undefined character `x%s'" 3 assoc "XML: (Validity) Undefined entity `%s'" "XML: Passed `xml-entity-expansion-limit' while expanding `&%s;'" mapconcat identity ""] 11 (#$ . 21832)])
#@219 Substitute SGML numeric entities by their respective utf characters.
This function replaces numeric entities in the input STRING and
returns the modified string.  For example "&#42;" gets replaced
by "*".

(fn STRING)
(defalias 'xml-substitute-numeric-entities #[257 "\211\2059\211;\2059\300\301\302#\2036\3031-\304\305\306\307\224\307\225O!!\310\211$\211\2620\210\202.\210\300\224T\262
\202\n
\262
\207" [0 string-match "&#\\([0-9]+\\);" (error) replace-match string read 1 nil] 8 (#$ . 22767)])
#@172 Outputs the XML in the current buffer.
XML can be a tree or a list of nodes.
The first line is indented with the optional INDENT-STRING.

(fn XML &optional INDENT-STRING)
(defalias 'xml-debug-print #[513 "\211\206\300\262

\211\205\211@\301
\"\210
A\266\202\202\207" ["" xml-debug-print-internal] 7 (#$ . 23282)])
(defalias 'xml-print 'xml-debug-print)
(defconst xml-invalid-characters-re "[^	\n
 -퟿-�𐀀-􏿿]")
#@677 Convert STRING into a string containing valid XML character data.
Replace occurrences of &<>\='" in STRING with their default XML
entity references (e.g., replace each & with &amp;).

XML character data must not contain & or < characters, nor the >
character under some circumstances.  The XML spec does not impose
restriction on " or \=', but we just substitute for these too
(as is permitted by the spec).

If STRING contains characters that are invalid in XML (as defined
by https://www.w3.org/TR/xml/#charsets), operate depending on the
value of NOERROR: if it is non-nil, remove them; else, signal an
error of type `xml-invalid-character'.

(fn STRING &optional NOERROR)
(defalias 'xml-escape-string #[513 "\301\302\303\"r\211q\210\304\305\"\216c\210eb\210\306\307\303#\2033
\203&\310\311!\210\202\312\313`Sf\314\224D\"\210\202\315\211\203X\211@eb\210\316
@\307\303#\203Q\310
A\303\211\307$\210\202=
A\266\202\2024\210\317 *\207" [xml-invalid-characters-re generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] re-search-forward nil replace-match "" signal xml-invalid-character 0 (("&" . "&amp;") ("<" . "&lt;") (">" . "&gt;") ("'" . "&apos;") ("\"" . "&quot;")) search-forward buffer-string] 10 (#$ . 23717)])
(define-error 'xml-invalid-character "Invalid XML character" 'wrong-type-argument)
#@116 Outputs the XML tree in the current buffer.
The first line is indented with INDENT-STRING.

(fn XML INDENT-STRING)
(defalias 'xml-debug-print-internal #[514 "
\300\301\302\211@\262
!\261\210\211A@\262
\262
\211\2032\303\302@@!\304\305@A!\306\261\210\211A\262
\202\211AA\262
\262
\204C\307\310\261\207\310c\210
\211\203x\211@\211<\203`\311c\210\312
\313P\"\210\202q\211;\203m\305
!c\210\202q\314\315!\210
A\266\202\202G\210
A\204\204
@;\204\211\311\261\210\301\307\302\211@\262
!\310\261\207" [nil 60 symbol-name 32 "=\"" xml-escape-string 34 47 62 10 xml-debug-print-internal "  " error "Invalid XML tree"] 10 (#$ . 25095)])
#@134 Remove XML/HTML comments in the region between BEG and END.
All text between the <!-- ... --> markers will be removed.

(fn BEG END)
(defalias 'xml-remove-comments #[514 "\212\214

}\210
b\210\300\301\302\303#\205#\304\224\300\305\302\303#\203\211`|\210\210\202	*\207" [search-forward "<!--" nil t 0 "-->"] 7 (#$ . 25757)])
(provide 'xml)