@rgrove/parse-xml 4.1.0 → 4.2.1

package/dist/browser.js

@@ -1,4 +1,4 @@
-/*! @rgrove/parse-xml v4.1.0 | ISC License | Copyright Ryan Grove */
+/*! @rgrove/parse-xml v4.2.1 | ISC License | Copyright Ryan Grove */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -40,24 +40,24 @@ var emptyString = "";
 var surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
 var StringScanner = class {
   constructor(string) {
-    this.k = this.q(string, true);
+    this.k = this.u(string, true);
     this.d = 0;
     this.length = string.length;
-    this.n = this.k !== this.length;
-    this.m = string;
-    if (this.n) {
+    this.l = this.k !== this.length;
+    this.h = string;
+    if (this.l) {
       let charsToBytes = [];
       for (let byteIndex = 0, charIndex = 0; charIndex < this.k; ++charIndex) {
         charsToBytes[charIndex] = byteIndex;
         byteIndex += string.codePointAt(byteIndex) > 65535 ? 2 : 1;
       }
-      this.y = charsToBytes;
+      this.A = charsToBytes;
     }
   }
   /**
    * Whether the current character index is at the end of the input string.
    */
-  get z() {
+  get B() {
     return this.d >= this.k;
   }
   // -- Protected Methods ------------------------------------------------------
@@ -65,7 +65,7 @@ var StringScanner = class {
    * Returns the number of characters in the given string, which may differ from
    * the byte length if the string contains multibyte characters.
    */
-  q(string, multiByteSafe = this.n) {
+  u(string, multiByteSafe = this.l) {
     return multiByteSafe ? string.replace(surrogatePair, "_").length : string.length;
   }
   // -- Public Methods ---------------------------------------------------------
@@ -73,16 +73,16 @@ var StringScanner = class {
    * Advances the scanner by the given number of characters, stopping if the end
    * of the string is reached.
    */
-  g(count = 1) {
+  p(count = 1) {
     this.d = Math.min(this.k, this.d + count);
   }
   /**
    * Returns the byte index of the given character index in the string. The two
    * may differ in strings that contain multibyte characters.
    */
-  i(charIndex = this.d) {
+  f(charIndex = this.d) {
     var _a;
-    return this.n ? (_a = this.y[charIndex]) != null ? _a : Infinity : charIndex;
+    return this.l ? (_a = this.A[charIndex]) != null ? _a : Infinity : charIndex;
   }
   /**
    * Consumes and returns the given number of characters if possible, advancing
@@ -90,46 +90,53 @@ var StringScanner = class {
    *
    * If no characters could be consumed, an empty string will be returned.
    */
-  F(count = 1) {
-    let chars = this.h(count);
-    this.g(count);
+  G(charCount = 1) {
+    let chars = this.m(charCount);
+    this.p(charCount);
     return chars;
   }
   /**
-   * Consumes a match for the given sticky regex, advances the scanner, updates
-   * the `lastIndex` property of the regex, and returns the matching string.
+   * Consumes and returns the given number of bytes if possible, advancing the
+   * scanner and stopping if the end of the string is reached.
    *
-   * The regex must have a sticky flag ("y") so that its `lastIndex` prop can be
-   * used to anchor the match at the current scanner position.
+   * It's up to the caller to ensure that the given byte count doesn't split a
+   * multibyte character.
    *
-   * Returns the consumed string, or an empty string if nothing was consumed.
+   * If no bytes could be consumed, an empty string will be returned.
    */
-  G(regex) {
-    if (!regex.sticky) {
-      throw new Error('`regex` must have a sticky flag ("y")');
-    }
-    regex.lastIndex = this.i();
-    let result = regex.exec(this.m);
-    if (result === null || result.length === 0) {
-      return emptyString;
-    }
-    let match = result[0];
-    this.g(this.q(match));
-    return match;
+  v(byteCount) {
+    let byteIndex = this.f();
+    let result = this.h.slice(byteIndex, byteIndex + byteCount);
+    this.p(this.u(result));
+    return result;
   }
   /**
-   * Consumes and returns all characters for which the given function returns a
-   * truthy value, stopping on the first falsy return value or if the end of the
-   * input is reached.
+   * Consumes and returns all characters for which the given function returns
+   * `true`, stopping when `false` is returned or the end of the input is
+   * reached.
    */
-  v(fn) {
-    let char;
-    let match = emptyString;
-    while ((char = this.h()) && fn(char)) {
-      match += char;
-      this.g();
+  w(fn) {
+    let { length, l: multiByteMode, h: string } = this;
+    let startByteIndex = this.f();
+    let endByteIndex = startByteIndex;
+    if (multiByteMode) {
+      while (endByteIndex < length) {
+        let char = string[endByteIndex];
+        let isSurrogatePair = char >= "\uD800" && char <= "\uDBFF";
+        if (isSurrogatePair) {
+          char += string[endByteIndex + 1];
+        }
+        if (!fn(char)) {
+          break;
+        }
+        endByteIndex += isSurrogatePair ? 2 : 1;
+      }
+    } else {
+      while (endByteIndex < length && fn(string[endByteIndex])) {
+        ++endByteIndex;
+      }
     }
-    return match;
+    return this.v(endByteIndex - startByteIndex);
   }
   /**
    * Consumes the given string if it exists at the current character index, and
@@ -138,29 +145,11 @@ var StringScanner = class {
    * If the given string doesn't exist at the current character index, an empty
    * string will be returned and the scanner will not be advanced.
    */
-  Q(stringToConsume) {
-    if (this.b(stringToConsume)) {
-      return stringToConsume;
-    }
-    if (this.n) {
-      let { length } = stringToConsume;
-      let charLengthToMatch = this.q(stringToConsume);
-      if (charLengthToMatch !== length && stringToConsume === this.h(charLengthToMatch)) {
-        this.g(charLengthToMatch);
-        return stringToConsume;
-      }
-    }
-    return emptyString;
-  }
-  /**
-   * Does the same thing as `consumeString()`, but doesn't support consuming
-   * multibyte characters. This can be faster if you only need to match single
-   * byte characters.
-   */
   b(stringToConsume) {
     let { length } = stringToConsume;
-    if (this.h(length) === stringToConsume) {
-      this.g(length);
+    let byteIndex = this.f();
+    if (stringToConsume === this.h.slice(byteIndex, byteIndex + length)) {
+      this.p(length === 1 ? 1 : this.u(stringToConsume));
       return stringToConsume;
     }
     return emptyString;
@@ -172,15 +161,9 @@ var StringScanner = class {
    *
    * Returns the consumed string, or an empty string if nothing was consumed.
    */
-  A(regex) {
-    let restOfString = this.m.slice(this.i());
-    let matchByteIndex = restOfString.search(regex);
-    if (matchByteIndex <= 0) {
-      return emptyString;
-    }
-    let result = restOfString.slice(0, matchByteIndex);
-    this.g(this.q(result));
-    return result;
+  x(regex) {
+    let matchByteIndex = this.h.slice(this.f()).search(regex);
+    return matchByteIndex > 0 ? this.v(matchByteIndex) : emptyString;
   }
   /**
    * Consumes characters until the given string is found, advancing the scanner
@@ -189,34 +172,19 @@ var StringScanner = class {
    *
    * Returns the consumed string, or an empty string if nothing was consumed.
    */
-  t(searchString) {
-    let { m: string } = this;
-    let byteIndex = this.i();
-    let matchByteIndex = string.indexOf(searchString, byteIndex);
-    if (matchByteIndex <= 0) {
-      return emptyString;
-    }
-    let result = string.slice(byteIndex, matchByteIndex);
-    this.g(this.q(result));
-    return result;
+  s(searchString) {
+    let byteIndex = this.f();
+    let matchByteIndex = this.h.indexOf(searchString, byteIndex);
+    return matchByteIndex > 0 ? this.v(matchByteIndex - byteIndex) : emptyString;
   }
   /**
    * Returns the given number of characters starting at the current character
    * index, without advancing the scanner and without exceeding the end of the
    * input string.
    */
-  h(count = 1) {
-    let { d: charIndex, n: multiByteMode, m: string } = this;
-    if (multiByteMode) {
-      if (charIndex >= this.k) {
-        return emptyString;
-      }
-      return string.slice(
-        this.i(charIndex),
-        this.i(charIndex + count)
-      );
-    }
-    return string.slice(charIndex, charIndex + count);
+  m(count = 1) {
+    let { d: charIndex, h: string } = this;
+    return this.l ? string.slice(this.f(charIndex), this.f(charIndex + count)) : string.slice(charIndex, charIndex + count);
   }
   /**
    * Resets the scanner position to the given character _index_, or to the start
@@ -225,14 +193,14 @@ var StringScanner = class {
    * If _index_ is negative, the scanner position will be moved backward by that
    * many characters, stopping if the beginning of the string is reached.
    */
-  o(index = 0) {
+  n(index = 0) {
     this.d = index >= 0 ? Math.min(this.k, index) : Math.max(0, this.d + index);
   }
 };
 
 // src/lib/syntax.ts
-var attValueCharDoubleQuote = /[^"&<]+/y;
-var attValueCharSingleQuote = /[^'&<]+/y;
+var attValueCharDoubleQuote = /["&<]/;
+var attValueCharSingleQuote = /['&<]/;
 var attValueNormalizedWhitespace = /\r\n|[\n\r\t]/g;
 var endCharData = /<|&|]]>/;
 var predefinedEntities = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
@@ -243,28 +211,25 @@ var predefinedEntities = Object.freeze(Object.assign(/* @__PURE__ */ Object.crea
   quot: '"'
 }));
 function isNameChar(char) {
-  let cp = getCodePoint(char);
-  return cp >= 97 && cp <= 122 || cp >= 65 && cp <= 90 || cp >= 48 && cp <= 57 || cp === 45 || cp === 46 || cp === 183 || cp >= 768 && cp <= 879 || cp >= 8255 && cp <= 8256 || isNameStartChar(char, cp);
+  let cp = char.codePointAt(0);
+  return cp >= 97 && cp <= 122 || cp >= 65 && cp <= 90 || cp >= 48 && cp <= 57 || cp === 45 || cp === 46 || cp === 183 || cp >= 768 && cp <= 879 || cp === 8255 || cp === 8256 || isNameStartChar(char, cp);
 }
-function isNameStartChar(char, cp = getCodePoint(char)) {
-  return cp >= 97 && cp <= 122 || cp >= 65 && cp <= 90 || cp === 58 || cp === 95 || cp >= 192 && cp <= 214 || cp >= 216 && cp <= 246 || cp >= 248 && cp <= 767 || cp >= 880 && cp <= 893 || cp >= 895 && cp <= 8191 || cp >= 8204 && cp <= 8205 || cp >= 8304 && cp <= 8591 || cp >= 11264 && cp <= 12271 || cp >= 12289 && cp <= 55295 || cp >= 63744 && cp <= 64975 || cp >= 65008 && cp <= 65533 || cp >= 65536 && cp <= 983039;
+function isNameStartChar(char, cp = char.codePointAt(0)) {
+  return cp >= 97 && cp <= 122 || cp >= 65 && cp <= 90 || cp === 58 || cp === 95 || cp >= 192 && cp <= 214 || cp >= 216 && cp <= 246 || cp >= 248 && cp <= 767 || cp >= 880 && cp <= 893 || cp >= 895 && cp <= 8191 || cp === 8204 || cp === 8205 || cp >= 8304 && cp <= 8591 || cp >= 11264 && cp <= 12271 || cp >= 12289 && cp <= 55295 || cp >= 63744 && cp <= 64975 || cp >= 65008 && cp <= 65533 || cp >= 65536 && cp <= 983039;
 }
 function isReferenceChar(char) {
   return char === "#" || isNameChar(char);
 }
 function isWhitespace(char) {
-  let cp = getCodePoint(char);
+  let cp = char.codePointAt(0);
   return cp === 32 || cp === 9 || cp === 10 || cp === 13;
 }
 function isXmlCodePoint(cp) {
-  return cp === 9 || cp === 10 || cp === 13 || cp >= 32 && cp <= 55295 || cp >= 57344 && cp <= 65533 || cp >= 65536 && cp <= 1114111;
-}
-function getCodePoint(char) {
-  return char.codePointAt(0) || -1;
+  return cp >= 32 && cp <= 55295 || cp === 10 || cp === 9 || cp === 13 || cp >= 57344 && cp <= 65533 || cp >= 65536 && cp <= 1114111;
 }
 
 // src/lib/XmlNode.ts
-var _XmlNode = class {
+var _XmlNode = class _XmlNode {
   constructor() {
     /**
      * Parent node of this node, or `null` if this node has no parent.
@@ -345,39 +310,39 @@ var _XmlNode = class {
     return json;
   }
 };
-var XmlNode = _XmlNode;
 /**
  * Type value for an `XmlCdata` node.
  */
-XmlNode.TYPE_CDATA = "cdata";
+_XmlNode.TYPE_CDATA = "cdata";
 /**
  * Type value for an `XmlComment` node.
  */
-XmlNode.TYPE_COMMENT = "comment";
+_XmlNode.TYPE_COMMENT = "comment";
 /**
  * Type value for an `XmlDocument` node.
  */
-XmlNode.TYPE_DOCUMENT = "document";
+_XmlNode.TYPE_DOCUMENT = "document";
 /**
  * Type value for an `XmlDocumentType` node.
  */
-XmlNode.TYPE_DOCUMENT_TYPE = "doctype";
+_XmlNode.TYPE_DOCUMENT_TYPE = "doctype";
 /**
  * Type value for an `XmlElement` node.
  */
-XmlNode.TYPE_ELEMENT = "element";
+_XmlNode.TYPE_ELEMENT = "element";
 /**
  * Type value for an `XmlProcessingInstruction` node.
  */
-XmlNode.TYPE_PROCESSING_INSTRUCTION = "pi";
+_XmlNode.TYPE_PROCESSING_INSTRUCTION = "pi";
 /**
  * Type value for an `XmlText` node.
  */
-XmlNode.TYPE_TEXT = "text";
+_XmlNode.TYPE_TEXT = "text";
 /**
  * Type value for an `XmlDeclaration` node.
  */
-XmlNode.TYPE_XML_DECLARATION = "xmldecl";
+_XmlNode.TYPE_XML_DECLARATION = "xmldecl";
+var XmlNode = _XmlNode;
 
 // src/lib/XmlText.ts
 var XmlText = class extends XmlNode {
@@ -442,7 +407,7 @@ var XmlDeclaration = class extends XmlNode {
 };
 
 // src/lib/XmlElement.ts
-var XmlElement = class extends XmlNode {
+var XmlElement = class _XmlElement extends XmlNode {
   constructor(name, attributes = /* @__PURE__ */ Object.create(null), children = []) {
     super();
     this.name = name;
@@ -457,7 +422,7 @@ var XmlElement = class extends XmlNode {
   }
   get preserveWhitespace() {
     let node = this;
-    while (node instanceof XmlElement) {
+    while (node instanceof _XmlElement) {
       if ("xml:space" in node.attributes) {
         return node.attributes["xml:space"] === "preserve";
       }
@@ -611,70 +576,68 @@ var Parser = class {
    */
   constructor(xml, options = {}) {
     let doc = this.document = new XmlDocument();
-    let scanner = this.c = new StringScanner(xml);
-    this.l = doc;
-    this.f = options;
-    if (this.f.includeOffsets) {
+    this.j = doc;
+    this.g = options;
+    this.c = new StringScanner(xml);
+    if (this.g.includeOffsets) {
       doc.start = 0;
       doc.end = xml.length;
     }
-    scanner.b("\uFEFF");
-    this.H();
-    if (!this.B()) {
-      throw this.a("Root element is missing or invalid");
-    }
-    while (this.w()) {
-    }
-    if (!scanner.z) {
-      throw this.a("Extra content at the end of the document");
-    }
+    this.parse();
   }
   /**
    * Adds the given `XmlNode` as a child of `this.currentNode`.
    */
-  j(node, charIndex) {
-    node.parent = this.l;
-    if (this.f.includeOffsets) {
-      node.start = this.c.i(charIndex);
-      node.end = this.c.i();
+  i(node, charIndex) {
+    node.parent = this.j;
+    if (this.g.includeOffsets) {
+      node.start = this.c.f(charIndex);
+      node.end = this.c.f();
     }
-    this.l.children.push(node);
+    this.j.children.push(node);
     return true;
   }
   /**
    * Adds the given _text_ to the document, either by appending it to a
    * preceding `XmlText` node (if possible) or by creating a new `XmlText` node.
+   *
+   * When _normalize_ is `true` (the default), line breaks in _text_ are
+   * normalized per section 2.11 of the XML spec. This must be `false` for text
+   * that comes from a character or entity reference, since references aren't
+   * subject to line break normalization.
    */
-  x(text, charIndex) {
-    let { children } = this.l;
+  y(text, charIndex, normalize = true) {
+    let { children } = this.j;
     let { length } = children;
-    text = normalizeLineBreaks(text);
+    if (normalize) {
+      text = normalizeLineBreaks(text);
+    }
     if (length > 0) {
       let prevNode = children[length - 1];
       if ((prevNode == null ? void 0 : prevNode.type) === XmlNode.TYPE_TEXT) {
         let textNode = prevNode;
         textNode.text += text;
-        if (this.f.includeOffsets) {
-          textNode.end = this.c.i();
+        if (this.g.includeOffsets) {
+          textNode.end = this.c.f();
         }
         return true;
       }
     }
-    return this.j(new XmlText(text), charIndex);
+    return this.i(new XmlText(text), charIndex);
   }
   /**
    * Consumes element attributes.
    *
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-starttags
    */
-  I() {
+  H() {
     let attributes = /* @__PURE__ */ Object.create(null);
     while (this.e()) {
-      let attrName = this.r();
+      let attrName = this.q();
       if (!attrName) {
         break;
       }
-      let attrValue = this.u() && this.J();
+      let attrValue = this.t() && this.I();
       if (attrValue === false) {
         throw this.a("Attribute value expected");
       }
@@ -686,7 +649,7 @@ var Parser = class {
       }
       attributes[attrName] = attrValue;
     }
-    if (this.f.sortAttributes) {
+    if (this.g.sortAttributes) {
       let attrNames = Object.keys(attributes).sort();
       let sortedAttributes = /* @__PURE__ */ Object.create(null);
       for (let i = 0; i < attrNames.length; ++i) {
@@ -707,41 +670,40 @@ var Parser = class {
    *
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-AttValue
    */
-  J() {
+  I() {
     let { c: scanner } = this;
-    let quote = scanner.h();
+    let quote = scanner.m();
     if (quote !== '"' && quote !== "'") {
       return false;
     }
-    scanner.g();
+    scanner.p();
     let chars;
     let isClosed = false;
     let value = emptyString2;
     let regex = quote === '"' ? attValueCharDoubleQuote : attValueCharSingleQuote;
-    matchLoop:
-      while (!scanner.z) {
-        chars = scanner.G(regex);
-        if (chars) {
-          this.p(chars);
-          value += chars.replace(attValueNormalizedWhitespace, " ");
-        }
-        switch (scanner.h()) {
-          case quote:
-            isClosed = true;
-            break matchLoop;
-          case "&":
-            value += this.C();
-            continue;
-          case "<":
-            throw this.a("Unescaped `<` is not allowed in an attribute value");
-          case emptyString2:
-            break matchLoop;
-        }
+    matchLoop: while (!scanner.B) {
+      chars = scanner.x(regex);
+      if (chars) {
+        this.o(chars);
+        value += chars.replace(attValueNormalizedWhitespace, " ");
       }
+      switch (scanner.m()) {
+        case quote:
+          isClosed = true;
+          break matchLoop;
+        case "&":
+          value += this.C();
+          continue;
+        case "<":
+          throw this.a("Unescaped `<` is not allowed in an attribute value");
+        default:
+          break matchLoop;
+      }
+    }
     if (!isClosed) {
       throw this.a("Unclosed attribute");
     }
-    scanner.g();
+    scanner.p();
     return value;
   }
   /**
@@ -750,18 +712,18 @@ var Parser = class {
    * @returns Whether a CDATA section was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-cdata-sect
    */
-  K() {
+  J() {
     let { c: scanner } = this;
     let startIndex = scanner.d;
     if (!scanner.b("<![CDATA[")) {
       return false;
     }
-    let text = scanner.t("]]>");
-    this.p(text);
+    let text = scanner.s("]]>");
+    this.o(text);
     if (!scanner.b("]]>")) {
       throw this.a("Unclosed CDATA section");
     }
-    return this.f.preserveCdata ? this.j(new XmlCdata(normalizeLineBreaks(text)), startIndex) : this.x(text, startIndex);
+    return this.g.preserveCdata ? this.i(new XmlCdata(normalizeLineBreaks(text)), startIndex) : this.y(text, startIndex);
   }
   /**
    * Consumes character data if possible.
@@ -769,18 +731,18 @@ var Parser = class {
    * @returns Whether character data was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#dt-chardata
    */
-  L() {
+  K() {
     let { c: scanner } = this;
     let startIndex = scanner.d;
-    let charData = scanner.A(endCharData);
+    let charData = scanner.x(endCharData);
     if (!charData) {
       return false;
     }
-    this.p(charData);
-    if (scanner.h(3) === "]]>") {
+    this.o(charData);
+    if (scanner.m(3) === "]]>") {
       throw this.a("Element content may not contain the CDATA section close delimiter `]]>`");
     }
-    return this.x(charData, startIndex);
+    return this.y(charData, startIndex);
   }
   /**
    * Consumes a comment if possible.
@@ -794,15 +756,15 @@ var Parser = class {
     if (!scanner.b("<!--")) {
       return false;
     }
-    let content = scanner.t("--");
-    this.p(content);
+    let content = scanner.s("--");
+    this.o(content);
     if (!scanner.b("-->")) {
-      if (scanner.h(2) === "--") {
+      if (scanner.m(2) === "--") {
         throw this.a("The string `--` isn't allowed inside a comment");
       }
       throw this.a("Unclosed comment");
     }
-    return this.f.preserveComments ? this.j(new XmlComment(normalizeLineBreaks(content)), startIndex) : true;
+    return this.g.preserveComments ? this.i(new XmlComment(normalizeLineBreaks(content)), startIndex) : true;
   }
   /**
    * Consumes a reference in a content context if possible.
@@ -813,10 +775,10 @@ var Parser = class {
    * @returns Whether a reference was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#entproc
    */
-  M() {
+  L() {
     let startIndex = this.c.d;
     let ref = this.C();
-    return ref ? this.x(ref, startIndex) : false;
+    return ref ? this.y(ref, startIndex, false) : false;
   }
   /**
    * Consumes a doctype declaration if possible.
@@ -827,13 +789,13 @@ var Parser = class {
    * @returns Whether a doctype declaration was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#dtd
    */
-  N() {
+  M() {
     let { c: scanner } = this;
     let startIndex = scanner.d;
     if (!scanner.b("<!DOCTYPE")) {
       return false;
     }
-    let name = this.e() && this.r();
+    let name = this.e() && this.q();
     if (!name) {
       throw this.a("Expected a name");
     }
@@ -841,7 +803,7 @@ var Parser = class {
     let systemId;
     if (this.e()) {
       if (scanner.b("PUBLIC")) {
-        publicId = this.e() && this.O();
+        publicId = this.e() && this.N();
         if (publicId === false) {
           throw this.a("Expected a public identifier");
         }
@@ -849,7 +811,7 @@ var Parser = class {
       }
       if (publicId !== void 0 || scanner.b("SYSTEM")) {
         this.e();
-        systemId = this.s();
+        systemId = this.r();
         if (systemId === false) {
           throw this.a("Expected a system identifier");
         }
@@ -858,7 +820,7 @@ var Parser = class {
     }
     let internalSubset;
     if (scanner.b("[")) {
-      internalSubset = scanner.A(/\][\x20\t\r\n]*>/);
+      internalSubset = scanner.x(/\][\x20\t\r\n]*>/);
       if (!scanner.b("]")) {
         throw this.a("Unclosed internal subset");
       }
@@ -867,7 +829,7 @@ var Parser = class {
     if (!scanner.b(">")) {
       throw this.a("Unclosed doctype declaration");
     }
-    return this.f.preserveDocumentType ? this.j(new XmlDocumentType(name, publicId, systemId, internalSubset), startIndex) : true;
+    return this.g.preserveDocumentType ? this.i(new XmlDocumentType(name, publicId, systemId, internalSubset), startIndex) : true;
   }
   /**
    * Consumes an element if possible.
@@ -875,42 +837,42 @@ var Parser = class {
    * @returns Whether an element was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-element
    */
-  B() {
+  E() {
     let { c: scanner } = this;
     let startIndex = scanner.d;
     if (!scanner.b("<")) {
       return false;
     }
-    let name = this.r();
+    let name = this.q();
     if (!name) {
-      scanner.o(startIndex);
+      scanner.n(startIndex);
       return false;
     }
-    let attributes = this.I();
+    let attributes = this.H();
     let isEmpty = !!scanner.b("/>");
     let element = new XmlElement(name, attributes);
-    element.parent = this.l;
+    element.parent = this.j;
     if (!isEmpty) {
       if (!scanner.b(">")) {
         throw this.a(`Unclosed start tag for element \`${name}\``);
       }
-      this.l = element;
+      this.j = element;
       do {
-        this.L();
-      } while (this.B() || this.M() || this.K() || this.E() || this.D());
+        this.K();
+      } while (this.E() || this.L() || this.J() || this.F() || this.D());
       let endTagMark = scanner.d;
       let endTagName;
-      if (!scanner.b("</") || !(endTagName = this.r()) || endTagName !== name) {
-        scanner.o(endTagMark);
+      if (!scanner.b("</") || !(endTagName = this.q()) || endTagName !== name) {
+        scanner.n(endTagMark);
         throw this.a(`Missing end tag for element ${name}`);
       }
       this.e();
       if (!scanner.b(">")) {
         throw this.a(`Unclosed end tag for element ${name}`);
       }
-      this.l = element.parent;
+      this.j = element.parent;
     }
-    return this.j(element, startIndex);
+    return this.i(element, startIndex);
   }
   /**
    * Consumes an `Eq` production if possible.
@@ -918,7 +880,7 @@ var Parser = class {
    * @returns Whether an `Eq` production was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Eq
    */
-  u() {
+  t() {
     this.e();
     if (this.c.b("=")) {
       this.e();
@@ -932,8 +894,8 @@ var Parser = class {
    * @returns Whether anything was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Misc
    */
-  w() {
-    return this.D() || this.E() || this.e();
+  z() {
+    return this.D() || this.F() || this.e();
   }
   /**
    * Consumes one or more `Name` characters if possible.
@@ -941,8 +903,8 @@ var Parser = class {
    * @returns `Name` characters, or an empty string if none were consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Name
    */
-  r() {
-    return isNameStartChar(this.c.h()) ? this.c.v(isNameChar) : emptyString2;
+  q() {
+    return isNameStartChar(this.c.m()) ? this.c.w(isNameChar) : emptyString2;
   }
   /**
    * Consumes a processing instruction if possible.
@@ -950,16 +912,16 @@ var Parser = class {
    * @returns Whether a processing instruction was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-pi
    */
-  E() {
+  F() {
     let { c: scanner } = this;
     let startIndex = scanner.d;
     if (!scanner.b("<?")) {
       return false;
     }
-    let name = this.r();
+    let name = this.q();
     if (name) {
       if (name.toLowerCase() === "xml") {
-        scanner.o(startIndex);
+        scanner.n(startIndex);
         throw this.a("XML declaration isn't allowed here");
       }
     } else {
@@ -967,16 +929,16 @@ var Parser = class {
     }
     if (!this.e()) {
       if (scanner.b("?>")) {
-        return this.j(new XmlProcessingInstruction(name), startIndex);
+        return this.i(new XmlProcessingInstruction(name), startIndex);
       }
       throw this.a("Whitespace is required after a processing instruction name");
     }
-    let content = scanner.t("?>");
-    this.p(content);
+    let content = scanner.s("?>");
+    this.o(content);
     if (!scanner.b("?>")) {
       throw this.a("Unterminated processing instruction");
     }
-    return this.j(new XmlProcessingInstruction(name, normalizeLineBreaks(content)), startIndex);
+    return this.i(new XmlProcessingInstruction(name, normalizeLineBreaks(content)), startIndex);
   }
   /**
    * Consumes a prolog if possible.
@@ -984,14 +946,14 @@ var Parser = class {
    * @returns Whether a prolog was consumed.
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-prolog-dtd
    */
-  H() {
+  O() {
     let { c: scanner } = this;
     let startIndex = scanner.d;
     this.P();
-    while (this.w()) {
+    while (this.z()) {
     }
-    if (this.N()) {
-      while (this.w()) {
+    if (this.M()) {
+      while (this.z()) {
       }
     }
     return startIndex < scanner.d;
@@ -1006,11 +968,11 @@ var Parser = class {
    *
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-PubidLiteral
    */
-  O() {
+  N() {
     let startIndex = this.c.d;
-    let value = this.s();
+    let value = this.r();
     if (value !== false && !/^[-\x20\r\na-zA-Z0-9'()+,./:=?;!*#@$_%]*$/.test(value)) {
-      this.c.o(startIndex);
+      this.c.n(startIndex);
       throw this.a("Invalid character in public identifier");
     }
     return value;
@@ -1032,8 +994,8 @@ var Parser = class {
     if (!scanner.b("&")) {
       return false;
     }
-    let ref = scanner.v(isReferenceChar);
-    if (scanner.F() !== ";") {
+    let ref = scanner.w(isReferenceChar);
+    if (scanner.G() !== ";") {
       throw this.a("Unterminated reference (a reference must end with `;`)");
     }
     let parsedValue;
@@ -1052,7 +1014,7 @@ var Parser = class {
         let {
           ignoreUndefinedEntities,
           resolveUndefinedEntity
-        } = this.f;
+        } = this.g;
         let wrappedRef = `&${ref};`;
         if (resolveUndefinedEntity) {
           let resolvedValue = resolveUndefinedEntity(wrappedRef);
@@ -1067,7 +1029,7 @@ var Parser = class {
         if (ignoreUndefinedEntities) {
           return wrappedRef;
         }
-        scanner.o(-wrappedRef.length);
+        scanner.n(-wrappedRef.length);
         throw this.a(`Named entity isn't defined: ${wrappedRef}`);
       }
     }
@@ -1086,14 +1048,14 @@ var Parser = class {
    *
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-SystemLiteral
    */
-  s() {
+  r() {
     let { c: scanner } = this;
     let quote = scanner.b('"') || scanner.b("'");
     if (!quote) {
       return false;
     }
-    let value = scanner.t(quote);
-    this.p(value);
+    let value = scanner.s(quote);
+    this.o(value);
     if (!scanner.b(quote)) {
       throw this.a("Missing end quote");
     }
@@ -1106,7 +1068,7 @@ var Parser = class {
    * @see https://www.w3.org/TR/2008/REC-xml-20081126/#white
    */
   e() {
-    return !!this.c.v(isWhitespace);
+    return !!this.c.w(isWhitespace);
   }
   /**
    * Consumes an XML declaration if possible.
@@ -1123,7 +1085,7 @@ var Parser = class {
     if (!this.e()) {
       throw this.a("Invalid XML declaration");
     }
-    let version = !!scanner.b("version") && this.u() && this.s();
+    let version = !!scanner.b("version") && this.t() && this.r();
     if (version === false) {
       throw this.a("XML version is missing or invalid");
     } else if (!/^1\.[0-9]+$/.test(version)) {
@@ -1132,11 +1094,14 @@ var Parser = class {
     let encoding;
     let standalone;
     if (this.e()) {
-      encoding = !!scanner.b("encoding") && this.u() && this.s();
+      encoding = !!scanner.b("encoding") && this.t() && this.r();
       if (encoding) {
+        if (!/^[A-Za-z][\w.-]*$/.test(encoding)) {
+          throw this.a("Invalid character in encoding name");
+        }
         this.e();
       }
-      standalone = !!scanner.b("standalone") && this.u() && this.s();
+      standalone = !!scanner.b("standalone") && this.t() && this.r();
       if (standalone) {
         if (standalone !== "yes" && standalone !== "no") {
           throw this.a('Only "yes" and "no" are permitted as values of `standalone`');
@@ -1147,7 +1112,7 @@ var Parser = class {
     if (!scanner.b("?>")) {
       throw this.a("Invalid or unclosed XML declaration");
     }
-    return this.f.preserveXmlDeclaration ? this.j(new XmlDeclaration(
+    return this.g.preserveXmlDeclaration ? this.i(new XmlDeclaration(
       version,
       encoding || void 0,
       standalone || void 0
@@ -1158,18 +1123,33 @@ var Parser = class {
    */
   a(message) {
     let { c: scanner } = this;
-    return new XmlError(message, scanner.d, scanner.m);
+    return new XmlError(message, scanner.d, scanner.h);
+  }
+  /**
+   * Parses the XML input.
+   */
+  parse() {
+    this.c.b("\uFEFF");
+    this.O();
+    if (!this.E()) {
+      throw this.a("Root element is missing or invalid");
+    }
+    while (this.z()) {
+    }
+    if (!this.c.B) {
+      throw this.a("Extra content at the end of the document");
+    }
   }
   /**
    * Throws an invalid character error if any character in the given _string_
    * isn't a valid XML character.
    */
-  p(string) {
+  o(string) {
     let { length } = string;
     for (let i = 0; i < length; ++i) {
       let cp = string.codePointAt(i);
       if (!isXmlCodePoint(cp)) {
-        this.c.o(-([...string].length - i));
+        this.c.n(-([...string].length - i));
         throw this.a("Invalid character");
       }
       if (cp > 65535) {