@rgrove/parse-xml 4.0.1 → 4.1.0

package/dist/browser.js

@@ -1,4 +1,4 @@
-/*! @rgrove/parse-xml v4.0.1 | ISC License | Copyright Ryan Grove */
+/*! @rgrove/parse-xml v4.1.0 | ISC License | Copyright Ryan Grove */
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -23,8 +23,11 @@ var src_exports = {};
 __export(src_exports, {
   XmlCdata: () => XmlCdata,
   XmlComment: () => XmlComment,
+  XmlDeclaration: () => XmlDeclaration,
   XmlDocument: () => XmlDocument,
+  XmlDocumentType: () => XmlDocumentType,
   XmlElement: () => XmlElement,
+  XmlError: () => XmlError,
   XmlNode: () => XmlNode,
   XmlProcessingInstruction: () => XmlProcessingInstruction,
   XmlText: () => XmlText,
@@ -37,125 +40,200 @@ var emptyString = "";
 var surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
 var StringScanner = class {
   constructor(string) {
-    this.h = this.m(string, true);
+    this.k = this.q(string, true);
     this.d = 0;
     this.length = string.length;
-    this.j = this.h !== this.length;
-    this.string = string;
-    if (this.j) {
+    this.n = this.k !== this.length;
+    this.m = string;
+    if (this.n) {
       let charsToBytes = [];
-      for (let byteIndex = 0, charIndex = 0; charIndex < this.h; ++charIndex) {
+      for (let byteIndex = 0, charIndex = 0; charIndex < this.k; ++charIndex) {
         charsToBytes[charIndex] = byteIndex;
         byteIndex += string.codePointAt(byteIndex) > 65535 ? 2 : 1;
       }
-      this.x = charsToBytes;
+      this.y = charsToBytes;
     }
   }
-  get y() {
-    return this.d >= this.h;
-  }
-  n(charIndex = this.d) {
-    var _a;
-    return this.j ? (_a = this.x[charIndex]) != null ? _a : Infinity : charIndex;
-  }
-  m(string, multiByteSafe = this.j) {
+  /**
+   * Whether the current character index is at the end of the input string.
+   */
+  get z() {
+    return this.d >= this.k;
+  }
+  // -- Protected Methods ------------------------------------------------------
+  /**
+   * 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) {
     return multiByteSafe ? string.replace(surrogatePair, "_").length : string.length;
   }
-  f(count = 1) {
-    this.d = Math.min(this.h, this.d + count);
+  // -- Public Methods ---------------------------------------------------------
+  /**
+   * Advances the scanner by the given number of characters, stopping if the end
+   * of the string is reached.
+   */
+  g(count = 1) {
+    this.d = Math.min(this.k, this.d + count);
   }
-  D(count = 1) {
-    let chars = this.g(count);
-    this.f(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) {
+    var _a;
+    return this.n ? (_a = this.y[charIndex]) != null ? _a : Infinity : charIndex;
+  }
+  /**
+   * Consumes and returns the given number of characters if possible, advancing
+   * the scanner and stopping if the end of the string is reached.
+   *
+   * If no characters could be consumed, an empty string will be returned.
+   */
+  F(count = 1) {
+    let chars = this.h(count);
+    this.g(count);
     return chars;
   }
-  s(regex) {
+  /**
+   * Consumes a match for the given sticky regex, advances the scanner, updates
+   * the `lastIndex` property of the regex, and returns the matching string.
+   *
+   * 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.
+   *
+   * Returns the consumed string, or an empty string if nothing was consumed.
+   */
+  G(regex) {
     if (!regex.sticky) {
       throw new Error('`regex` must have a sticky flag ("y")');
     }
-    regex.lastIndex = this.n();
-    let result = regex.exec(this.string);
+    regex.lastIndex = this.i();
+    let result = regex.exec(this.m);
     if (result === null || result.length === 0) {
       return emptyString;
     }
     let match = result[0];
-    this.f(this.m(match));
+    this.g(this.q(match));
     return match;
   }
-  t(fn) {
+  /**
+   * 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.
+   */
+  v(fn) {
     let char;
     let match = emptyString;
-    while ((char = this.g()) && fn(char)) {
+    while ((char = this.h()) && fn(char)) {
       match += char;
-      this.f();
+      this.g();
     }
     return match;
   }
-  N(stringToConsume) {
+  /**
+   * Consumes the given string if it exists at the current character index, and
+   * advances the scanner.
+   *
+   * 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.j) {
+    if (this.n) {
       let { length } = stringToConsume;
-      let charLengthToMatch = this.m(stringToConsume);
-      if (charLengthToMatch !== length && stringToConsume === this.g(charLengthToMatch)) {
-        this.f(charLengthToMatch);
+      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.g(length) === stringToConsume) {
-      this.f(length);
+    if (this.h(length) === stringToConsume) {
+      this.g(length);
       return stringToConsume;
     }
     return emptyString;
   }
-  E(regex) {
-    let restOfString = this.string.slice(this.n());
+  /**
+   * Consumes characters until the given global regex is matched, advancing the
+   * scanner up to (but not beyond) the beginning of the match. If the regex
+   * doesn't match, nothing will be consumed.
+   *
+   * 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.f(this.m(result));
+    this.g(this.q(result));
     return result;
   }
-  p(searchString) {
-    let { string } = this;
-    let byteIndex = this.n();
+  /**
+   * Consumes characters until the given string is found, advancing the scanner
+   * up to (but not beyond) that point. If the string is never found, nothing
+   * will be consumed.
+   *
+   * 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.f(this.m(result));
+    this.g(this.q(result));
     return result;
   }
-  g(count = 1) {
-    let { d: charIndex, j: multiByteMode, string } = this;
+  /**
+   * 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.h) {
+      if (charIndex >= this.k) {
         return emptyString;
       }
       return string.slice(
-        this.n(charIndex),
-        this.n(charIndex + count)
+        this.i(charIndex),
+        this.i(charIndex + count)
       );
     }
     return string.slice(charIndex, charIndex + count);
   }
+  /**
+   * Resets the scanner position to the given character _index_, or to the start
+   * of the input string if no index is given.
+   *
+   * 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) {
-    this.d = index >= 0 ? Math.min(this.h, index) : Math.max(0, this.d + index);
+    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 attValueNormalizedWhitespace = /[\t\n]/g;
+var attValueNormalizedWhitespace = /\r\n|[\n\r\t]/g;
 var endCharData = /<|&|]]>/;
 var predefinedEntities = Object.freeze(Object.assign(/* @__PURE__ */ Object.create(null), {
   amp: "&",
@@ -186,24 +264,70 @@ function getCodePoint(char) {
 }
 
 // src/lib/XmlNode.ts
-var XmlNode = class {
+var _XmlNode = class {
   constructor() {
+    /**
+     * Parent node of this node, or `null` if this node has no parent.
+     */
     this.parent = null;
-  }
+    /**
+     * Starting byte offset of this node in the original XML string, or `-1` if
+     * the offset is unknown.
+     */
+    this.start = -1;
+    /**
+     * Ending byte offset of this node in the original XML string, or `-1` if the
+     * offset is unknown.
+     */
+    this.end = -1;
+  }
+  /**
+   * Document that contains this node, or `null` if this node is not associated
+   * with a document.
+   */
   get document() {
     var _a, _b;
     return (_b = (_a = this.parent) == null ? void 0 : _a.document) != null ? _b : null;
   }
+  /**
+   * Whether this node is the root node of the document (also known as the
+   * document element).
+   */
   get isRootNode() {
-    return this.parent !== null && this.parent === this.document;
-  }
+    return this.parent !== null && this.parent === this.document && this.type === _XmlNode.TYPE_ELEMENT;
+  }
+  /**
+   * Whether whitespace should be preserved in the content of this element and
+   * its children.
+   *
+   * This is influenced by the value of the special `xml:space` attribute, and
+   * will be `true` for any node whose `xml:space` attribute is set to
+   * "preserve". If a node has no such attribute, it will inherit the value of
+   * the nearest ancestor that does (if any).
+   *
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-white-space
+   */
   get preserveWhitespace() {
     var _a;
-    return Boolean((_a = this.parent) == null ? void 0 : _a.preserveWhitespace);
-  }
+    return !!((_a = this.parent) == null ? void 0 : _a.preserveWhitespace);
+  }
+  /**
+   * Type of this node.
+   *
+   * The value of this property is a string that matches one of the static
+   * `TYPE_*` properties on the `XmlNode` class (e.g. `TYPE_ELEMENT`,
+   * `TYPE_TEXT`, etc.).
+   *
+   * The `XmlNode` class itself is a base class and doesn't have its own type
+   * name.
+   */
   get type() {
     return "";
   }
+  /**
+   * Returns a JSON-serializable object representing this node, minus properties
+   * that could result in circular references.
+   */
   toJSON() {
     let json = {
       type: this.type
@@ -214,15 +338,46 @@ var XmlNode = class {
     if (this.preserveWhitespace) {
       json.preserveWhitespace = true;
     }
+    if (this.start !== -1) {
+      json.start = this.start;
+      json.end = this.end;
+    }
     return json;
   }
 };
+var XmlNode = _XmlNode;
+/**
+ * Type value for an `XmlCdata` node.
+ */
 XmlNode.TYPE_CDATA = "cdata";
+/**
+ * Type value for an `XmlComment` node.
+ */
 XmlNode.TYPE_COMMENT = "comment";
+/**
+ * Type value for an `XmlDocument` node.
+ */
 XmlNode.TYPE_DOCUMENT = "document";
+/**
+ * Type value for an `XmlDocumentType` node.
+ */
+XmlNode.TYPE_DOCUMENT_TYPE = "doctype";
+/**
+ * Type value for an `XmlElement` node.
+ */
 XmlNode.TYPE_ELEMENT = "element";
+/**
+ * Type value for an `XmlProcessingInstruction` node.
+ */
 XmlNode.TYPE_PROCESSING_INSTRUCTION = "pi";
+/**
+ * Type value for an `XmlText` node.
+ */
 XmlNode.TYPE_TEXT = "text";
+/**
+ * Type value for an `XmlDeclaration` node.
+ */
+XmlNode.TYPE_XML_DECLARATION = "xmldecl";
 
 // src/lib/XmlText.ts
 var XmlText = class extends XmlNode {
@@ -263,6 +418,29 @@ var XmlComment = class extends XmlNode {
   }
 };
 
+// src/lib/XmlDeclaration.ts
+var XmlDeclaration = class extends XmlNode {
+  constructor(version, encoding, standalone) {
+    super();
+    this.version = version;
+    this.encoding = encoding != null ? encoding : null;
+    this.standalone = standalone != null ? standalone : null;
+  }
+  get type() {
+    return XmlNode.TYPE_XML_DECLARATION;
+  }
+  toJSON() {
+    let json = XmlNode.prototype.toJSON.call(this);
+    json.version = this.version;
+    for (let key of ["encoding", "standalone"]) {
+      if (this[key] !== null) {
+        json[key] = this[key];
+      }
+    }
+    return json;
+  }
+};
+
 // src/lib/XmlElement.ts
 var XmlElement = class extends XmlNode {
   constructor(name, attributes = /* @__PURE__ */ Object.create(null), children = []) {
@@ -271,6 +449,9 @@ var XmlElement = class extends XmlNode {
     this.attributes = attributes;
     this.children = children;
   }
+  /**
+   * Whether this element is empty (meaning it has no children).
+   */
   get isEmpty() {
     return this.children.length === 0;
   }
@@ -284,6 +465,9 @@ var XmlElement = class extends XmlNode {
     }
     return false;
   }
+  /**
+   * Text content of this element and all its descendants.
+   */
   get text() {
     return this.children.map((child) => "text" in child ? child.text : "").join("");
   }
@@ -308,6 +492,9 @@ var XmlDocument = class extends XmlNode {
   get document() {
     return this;
   }
+  /**
+   * Root element of this document, or `null` if this document is empty.
+   */
   get root() {
     for (let child of this.children) {
       if (child instanceof XmlElement) {
@@ -316,6 +503,9 @@ var XmlDocument = class extends XmlNode {
     }
     return null;
   }
+  /**
+   * Text content of this document and all its descendants.
+   */
   get text() {
     return this.children.map((child) => "text" in child ? child.text : "").join("");
   }
@@ -329,6 +519,71 @@ var XmlDocument = class extends XmlNode {
   }
 };
 
+// src/lib/XmlDocumentType.ts
+var XmlDocumentType = class extends XmlNode {
+  constructor(name, publicId, systemId, internalSubset) {
+    super();
+    this.name = name;
+    this.publicId = publicId != null ? publicId : null;
+    this.systemId = systemId != null ? systemId : null;
+    this.internalSubset = internalSubset != null ? internalSubset : null;
+  }
+  get type() {
+    return XmlNode.TYPE_DOCUMENT_TYPE;
+  }
+  toJSON() {
+    let json = XmlNode.prototype.toJSON.call(this);
+    json.name = this.name;
+    for (let key of ["publicId", "systemId", "internalSubset"]) {
+      if (this[key] !== null) {
+        json[key] = this[key];
+      }
+    }
+    return json;
+  }
+};
+
+// src/lib/XmlError.ts
+var XmlError = class extends Error {
+  constructor(message, charIndex, xml) {
+    let column = 1;
+    let excerpt = "";
+    let line = 1;
+    for (let i = 0; i < charIndex; ++i) {
+      let char = xml[i];
+      if (char === "\n") {
+        column = 1;
+        excerpt = "";
+        line += 1;
+      } else {
+        column += 1;
+        excerpt += char;
+      }
+    }
+    let eol = xml.indexOf("\n", charIndex);
+    excerpt += eol === -1 ? xml.slice(charIndex) : xml.slice(charIndex, eol);
+    let excerptStart = 0;
+    if (excerpt.length > 50) {
+      if (column < 40) {
+        excerpt = excerpt.slice(0, 50);
+      } else {
+        excerptStart = column - 20;
+        excerpt = excerpt.slice(excerptStart, column + 30);
+      }
+    }
+    super(
+      `${message} (line ${line}, column ${column})
+  ${excerpt}
+` + " ".repeat(column - excerptStart + 1) + "^\n"
+    );
+    this.column = column;
+    this.excerpt = excerpt;
+    this.line = line;
+    this.name = "XmlError";
+    this.pos = charIndex;
+  }
+};
+
 // src/lib/XmlProcessingInstruction.ts
 var XmlProcessingInstruction = class extends XmlNode {
   constructor(name, content = "") {
@@ -350,45 +605,76 @@ var XmlProcessingInstruction = class extends XmlNode {
 // src/lib/Parser.ts
 var emptyString2 = "";
 var Parser = class {
+  /**
+   * @param xml XML string to parse.
+   * @param options Parser options.
+   */
   constructor(xml, options = {}) {
-    this.document = new XmlDocument();
-    this.i = this.document;
-    this.options = options;
-    this.c = new StringScanner(normalizeXmlString(xml));
-    this.F();
-    if (!this.z()) {
+    let doc = this.document = new XmlDocument();
+    let scanner = this.c = new StringScanner(xml);
+    this.l = doc;
+    this.f = options;
+    if (this.f.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.u()) {
+    while (this.w()) {
     }
-    if (!this.c.y) {
+    if (!scanner.z) {
       throw this.a("Extra content at the end of the document");
     }
   }
-  k(node) {
-    node.parent = this.i;
-    this.i.children.push(node);
+  /**
+   * 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();
+    }
+    this.l.children.push(node);
+    return true;
   }
-  v(text) {
-    let { children } = this.i;
+  /**
+   * 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.
+   */
+  x(text, charIndex) {
+    let { children } = this.l;
     let { length } = children;
+    text = normalizeLineBreaks(text);
     if (length > 0) {
       let prevNode = children[length - 1];
-      if (prevNode instanceof XmlText) {
-        prevNode.text += text;
-        return;
+      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();
+        }
+        return true;
       }
     }
-    this.k(new XmlText(text));
+    return this.j(new XmlText(text), charIndex);
   }
-  G() {
+  /**
+   * Consumes element attributes.
+   *
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-starttags
+   */
+  I() {
     let attributes = /* @__PURE__ */ Object.create(null);
     while (this.e()) {
-      let attrName = this.q();
+      let attrName = this.r();
       if (!attrName) {
         break;
       }
-      let attrValue = this.r() && this.H();
+      let attrValue = this.u() && this.J();
       if (attrValue === false) {
         throw this.a("Attribute value expected");
       }
@@ -400,7 +686,7 @@ var Parser = class {
       }
       attributes[attrName] = attrValue;
     }
-    if (this.options.sortAttributes) {
+    if (this.f.sortAttributes) {
       let attrNames = Object.keys(attributes).sort();
       let sortedAttributes = /* @__PURE__ */ Object.create(null);
       for (let i = 0; i < attrNames.length; ++i) {
@@ -411,30 +697,40 @@ var Parser = class {
     }
     return attributes;
   }
-  H() {
+  /**
+   * Consumes an `AttValue` (attribute value) if possible.
+   *
+   * @returns
+   *   Contents of the `AttValue` minus quotes, or `false` if nothing was
+   *   consumed. An empty string indicates that an `AttValue` was consumed but
+   *   was empty.
+   *
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-AttValue
+   */
+  J() {
     let { c: scanner } = this;
-    let quote = scanner.g();
+    let quote = scanner.h();
     if (quote !== '"' && quote !== "'") {
       return false;
     }
-    scanner.f();
+    scanner.g();
     let chars;
     let isClosed = false;
     let value = emptyString2;
     let regex = quote === '"' ? attValueCharDoubleQuote : attValueCharSingleQuote;
     matchLoop:
-      while (!scanner.y) {
-        chars = scanner.s(regex);
+      while (!scanner.z) {
+        chars = scanner.G(regex);
         if (chars) {
-          this.l(chars);
+          this.p(chars);
           value += chars.replace(attValueNormalizedWhitespace, " ");
         }
-        switch (scanner.g()) {
+        switch (scanner.h()) {
           case quote:
             isClosed = true;
             break matchLoop;
           case "&":
-            value += this.A();
+            value += this.C();
             continue;
           case "<":
             throw this.a("Unescaped `<` is not allowed in an attribute value");
@@ -445,105 +741,166 @@ var Parser = class {
     if (!isClosed) {
       throw this.a("Unclosed attribute");
     }
-    scanner.f();
+    scanner.g();
     return value;
   }
-  I() {
+  /**
+   * Consumes a CDATA section if possible.
+   *
+   * @returns Whether a CDATA section was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-cdata-sect
+   */
+  K() {
     let { c: scanner } = this;
+    let startIndex = scanner.d;
     if (!scanner.b("<![CDATA[")) {
       return false;
     }
-    let text = scanner.p("]]>");
-    this.l(text);
+    let text = scanner.t("]]>");
+    this.p(text);
     if (!scanner.b("]]>")) {
       throw this.a("Unclosed CDATA section");
     }
-    if (this.options.preserveCdata) {
-      this.k(new XmlCdata(text));
-    } else {
-      this.v(text);
-    }
-    return true;
-  }
-  J() {
+    return this.f.preserveCdata ? this.j(new XmlCdata(normalizeLineBreaks(text)), startIndex) : this.x(text, startIndex);
+  }
+  /**
+   * Consumes character data if possible.
+   *
+   * @returns Whether character data was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#dt-chardata
+   */
+  L() {
     let { c: scanner } = this;
-    let charData = scanner.E(endCharData);
+    let startIndex = scanner.d;
+    let charData = scanner.A(endCharData);
     if (!charData) {
       return false;
     }
-    this.l(charData);
-    if (scanner.g(3) === "]]>") {
+    this.p(charData);
+    if (scanner.h(3) === "]]>") {
       throw this.a("Element content may not contain the CDATA section close delimiter `]]>`");
     }
-    this.v(charData);
-    return true;
-  }
-  B() {
+    return this.x(charData, startIndex);
+  }
+  /**
+   * Consumes a comment if possible.
+   *
+   * @returns Whether a comment was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Comment
+   */
+  D() {
     let { c: scanner } = this;
+    let startIndex = scanner.d;
     if (!scanner.b("<!--")) {
       return false;
     }
-    let content = scanner.p("--");
-    this.l(content);
+    let content = scanner.t("--");
+    this.p(content);
     if (!scanner.b("-->")) {
-      if (scanner.g(2) === "--") {
+      if (scanner.h(2) === "--") {
         throw this.a("The string `--` isn't allowed inside a comment");
       }
       throw this.a("Unclosed comment");
     }
-    if (this.options.preserveComments) {
-      this.k(new XmlComment(content.trim()));
-    }
-    return true;
-  }
-  K() {
-    let ref = this.A();
-    if (ref) {
-      this.v(ref);
-      return true;
-    }
-    return false;
-  }
-  L() {
+    return this.f.preserveComments ? this.j(new XmlComment(normalizeLineBreaks(content)), startIndex) : true;
+  }
+  /**
+   * Consumes a reference in a content context if possible.
+   *
+   * This differs from `consumeReference()` in that a consumed reference will be
+   * added to the document as a text node instead of returned.
+   *
+   * @returns Whether a reference was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#entproc
+   */
+  M() {
+    let startIndex = this.c.d;
+    let ref = this.C();
+    return ref ? this.x(ref, startIndex) : false;
+  }
+  /**
+   * Consumes a doctype declaration if possible.
+   *
+   * This is a loose implementation since doctype declarations are currently
+   * discarded without further parsing.
+   *
+   * @returns Whether a doctype declaration was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#dtd
+   */
+  N() {
     let { c: scanner } = this;
-    if (!scanner.b("<!DOCTYPE") || !this.e()) {
+    let startIndex = scanner.d;
+    if (!scanner.b("<!DOCTYPE")) {
       return false;
     }
-    scanner.s(/[^[>]+/y);
-    if (scanner.s(/\[[\s\S]+?\][\x20\t\r\n]*>/y)) {
-      return true;
+    let name = this.e() && this.r();
+    if (!name) {
+      throw this.a("Expected a name");
+    }
+    let publicId;
+    let systemId;
+    if (this.e()) {
+      if (scanner.b("PUBLIC")) {
+        publicId = this.e() && this.O();
+        if (publicId === false) {
+          throw this.a("Expected a public identifier");
+        }
+        this.e();
+      }
+      if (publicId !== void 0 || scanner.b("SYSTEM")) {
+        this.e();
+        systemId = this.s();
+        if (systemId === false) {
+          throw this.a("Expected a system identifier");
+        }
+        this.e();
+      }
+    }
+    let internalSubset;
+    if (scanner.b("[")) {
+      internalSubset = scanner.A(/\][\x20\t\r\n]*>/);
+      if (!scanner.b("]")) {
+        throw this.a("Unclosed internal subset");
+      }
+      this.e();
     }
     if (!scanner.b(">")) {
       throw this.a("Unclosed doctype declaration");
     }
-    return true;
-  }
-  z() {
+    return this.f.preserveDocumentType ? this.j(new XmlDocumentType(name, publicId, systemId, internalSubset), startIndex) : true;
+  }
+  /**
+   * Consumes an element if possible.
+   *
+   * @returns Whether an element was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-element
+   */
+  B() {
     let { c: scanner } = this;
-    let mark = scanner.d;
+    let startIndex = scanner.d;
     if (!scanner.b("<")) {
       return false;
     }
-    let name = this.q();
+    let name = this.r();
     if (!name) {
-      scanner.o(mark);
+      scanner.o(startIndex);
       return false;
     }
-    let attributes = this.G();
-    let isEmpty = Boolean(scanner.b("/>"));
+    let attributes = this.I();
+    let isEmpty = !!scanner.b("/>");
     let element = new XmlElement(name, attributes);
-    element.parent = this.i;
+    element.parent = this.l;
     if (!isEmpty) {
       if (!scanner.b(">")) {
         throw this.a(`Unclosed start tag for element \`${name}\``);
       }
-      this.i = element;
+      this.l = element;
       do {
-        this.J();
-      } while (this.z() || this.K() || this.I() || this.C() || this.B());
+        this.L();
+      } while (this.B() || this.M() || this.K() || this.E() || this.D());
       let endTagMark = scanner.d;
       let endTagName;
-      if (!scanner.b("</") || !(endTagName = this.q()) || endTagName !== name) {
+      if (!scanner.b("</") || !(endTagName = this.r()) || endTagName !== name) {
         scanner.o(endTagMark);
         throw this.a(`Missing end tag for element ${name}`);
       }
@@ -551,12 +908,17 @@ var Parser = class {
       if (!scanner.b(">")) {
         throw this.a(`Unclosed end tag for element ${name}`);
       }
-      this.i = element.parent;
+      this.l = element.parent;
     }
-    this.k(element);
-    return true;
-  }
-  r() {
+    return this.j(element, startIndex);
+  }
+  /**
+   * Consumes an `Eq` production if possible.
+   *
+   * @returns Whether an `Eq` production was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Eq
+   */
+  u() {
     this.e();
     if (this.c.b("=")) {
       this.e();
@@ -564,22 +926,40 @@ var Parser = class {
     }
     return false;
   }
-  u() {
-    return this.B() || this.C() || this.e();
-  }
-  q() {
-    return isNameStartChar(this.c.g()) ? this.c.t(isNameChar) : emptyString2;
-  }
-  C() {
+  /**
+   * Consumes `Misc` content if possible.
+   *
+   * @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();
+  }
+  /**
+   * Consumes one or more `Name` characters if possible.
+   *
+   * @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;
+  }
+  /**
+   * Consumes a processing instruction if possible.
+   *
+   * @returns Whether a processing instruction was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-pi
+   */
+  E() {
     let { c: scanner } = this;
-    let mark = scanner.d;
+    let startIndex = scanner.d;
     if (!scanner.b("<?")) {
       return false;
     }
-    let name = this.q();
+    let name = this.r();
     if (name) {
       if (name.toLowerCase() === "xml") {
-        scanner.o(mark);
+        scanner.o(startIndex);
         throw this.a("XML declaration isn't allowed here");
       }
     } else {
@@ -587,38 +967,73 @@ var Parser = class {
     }
     if (!this.e()) {
       if (scanner.b("?>")) {
-        this.k(new XmlProcessingInstruction(name));
-        return true;
+        return this.j(new XmlProcessingInstruction(name), startIndex);
       }
       throw this.a("Whitespace is required after a processing instruction name");
     }
-    let content = scanner.p("?>");
-    this.l(content);
+    let content = scanner.t("?>");
+    this.p(content);
     if (!scanner.b("?>")) {
       throw this.a("Unterminated processing instruction");
     }
-    this.k(new XmlProcessingInstruction(name, content));
-    return true;
-  }
-  F() {
+    return this.j(new XmlProcessingInstruction(name, normalizeLineBreaks(content)), startIndex);
+  }
+  /**
+   * Consumes a prolog if possible.
+   *
+   * @returns Whether a prolog was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#sec-prolog-dtd
+   */
+  H() {
     let { c: scanner } = this;
-    let mark = scanner.d;
-    this.M();
-    while (this.u()) {
+    let startIndex = scanner.d;
+    this.P();
+    while (this.w()) {
     }
-    if (this.L()) {
-      while (this.u()) {
+    if (this.N()) {
+      while (this.w()) {
       }
     }
-    return mark < scanner.d;
+    return startIndex < scanner.d;
+  }
+  /**
+   * Consumes a public identifier literal if possible.
+   *
+   * @returns
+   *   Value of the public identifier literal minus quotes, or `false` if
+   *   nothing was consumed. An empty string indicates that a public id literal
+   *   was consumed but was empty.
+   *
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-PubidLiteral
+   */
+  O() {
+    let startIndex = this.c.d;
+    let value = this.s();
+    if (value !== false && !/^[-\x20\r\na-zA-Z0-9'()+,./:=?;!*#@$_%]*$/.test(value)) {
+      this.c.o(startIndex);
+      throw this.a("Invalid character in public identifier");
+    }
+    return value;
   }
-  A() {
+  /**
+   * Consumes a reference if possible.
+   *
+   * This differs from `consumeContentReference()` in that a consumed reference
+   * will be returned rather than added to the document.
+   *
+   * @returns
+   *   Parsed reference value, or `false` if nothing was consumed (to
+   *   distinguish from a reference that resolves to an empty string).
+   *
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-Reference
+   */
+  C() {
     let { c: scanner } = this;
     if (!scanner.b("&")) {
       return false;
     }
-    let ref = scanner.t(isReferenceChar);
-    if (scanner.D() !== ";") {
+    let ref = scanner.v(isReferenceChar);
+    if (scanner.F() !== ";") {
       throw this.a("Unterminated reference (a reference must end with `;`)");
     }
     let parsedValue;
@@ -637,7 +1052,7 @@ var Parser = class {
         let {
           ignoreUndefinedEntities,
           resolveUndefinedEntity
-        } = this.options;
+        } = this.f;
         let wrappedRef = `&${ref};`;
         if (resolveUndefinedEntity) {
           let resolvedValue = resolveUndefinedEntity(wrappedRef);
@@ -658,42 +1073,70 @@ var Parser = class {
     }
     return parsedValue;
   }
-  w() {
+  /**
+   * Consumes a `SystemLiteral` if possible.
+   *
+   * A `SystemLiteral` is similar to an attribute value, but allows the
+   * characters `<` and `&` and doesn't replace references.
+   *
+   * @returns
+   *   Value of the `SystemLiteral` minus quotes, or `false` if nothing was
+   *   consumed. An empty string indicates that a `SystemLiteral` was consumed
+   *   but was empty.
+   *
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-SystemLiteral
+   */
+  s() {
     let { c: scanner } = this;
     let quote = scanner.b('"') || scanner.b("'");
     if (!quote) {
       return false;
     }
-    let value = scanner.p(quote);
-    this.l(value);
+    let value = scanner.t(quote);
+    this.p(value);
     if (!scanner.b(quote)) {
       throw this.a("Missing end quote");
     }
     return value;
   }
+  /**
+   * Consumes one or more whitespace characters if possible.
+   *
+   * @returns Whether any whitespace characters were consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#white
+   */
   e() {
-    return Boolean(this.c.t(isWhitespace));
-  }
-  M() {
+    return !!this.c.v(isWhitespace);
+  }
+  /**
+   * Consumes an XML declaration if possible.
+   *
+   * @returns Whether an XML declaration was consumed.
+   * @see https://www.w3.org/TR/2008/REC-xml-20081126/#NT-XMLDecl
+   */
+  P() {
     let { c: scanner } = this;
+    let startIndex = scanner.d;
     if (!scanner.b("<?xml")) {
       return false;
     }
     if (!this.e()) {
       throw this.a("Invalid XML declaration");
     }
-    let version = Boolean(scanner.b("version")) && this.r() && this.w();
+    let version = !!scanner.b("version") && this.u() && this.s();
     if (version === false) {
       throw this.a("XML version is missing or invalid");
     } else if (!/^1\.[0-9]+$/.test(version)) {
       throw this.a("Invalid character in version number");
     }
+    let encoding;
+    let standalone;
     if (this.e()) {
-      let encoding = Boolean(scanner.b("encoding")) && this.r() && this.w();
+      encoding = !!scanner.b("encoding") && this.u() && this.s();
       if (encoding) {
         this.e();
       }
-      let standalone = Boolean(scanner.b("standalone")) && this.r() && this.w();
+      standalone = !!scanner.b("standalone") && this.u() && this.s();
       if (standalone) {
         if (standalone !== "yes" && standalone !== "no") {
           throw this.a('Only "yes" and "no" are permitted as values of `standalone`');
@@ -704,49 +1147,24 @@ var Parser = class {
     if (!scanner.b("?>")) {
       throw this.a("Invalid or unclosed XML declaration");
     }
-    return true;
-  }
+    return this.f.preserveXmlDeclaration ? this.j(new XmlDeclaration(
+      version,
+      encoding || void 0,
+      standalone || void 0
+    ), startIndex) : true;
+  }
+  /**
+   * Returns an `XmlError` for the current scanner position.
+   */
   a(message) {
-    let { d: charIndex, string: xml } = this.c;
-    let column = 1;
-    let excerpt = "";
-    let line = 1;
-    for (let i = 0; i < charIndex; ++i) {
-      let char = xml[i];
-      if (char === "\n") {
-        column = 1;
-        excerpt = "";
-        line += 1;
-      } else {
-        column += 1;
-        excerpt += char;
-      }
-    }
-    let eol = xml.indexOf("\n", charIndex);
-    excerpt += eol === -1 ? xml.slice(charIndex) : xml.slice(charIndex, eol);
-    let excerptStart = 0;
-    if (excerpt.length > 50) {
-      if (column < 40) {
-        excerpt = excerpt.slice(0, 50);
-      } else {
-        excerptStart = column - 20;
-        excerpt = excerpt.slice(excerptStart, column + 30);
-      }
-    }
-    let err = new Error(
-      `${message} (line ${line}, column ${column})
-  ${excerpt}
-` + " ".repeat(column - excerptStart + 1) + "^\n"
-    );
-    Object.assign(err, {
-      column,
-      excerpt,
-      line,
-      pos: charIndex
-    });
-    return err;
+    let { c: scanner } = this;
+    return new XmlError(message, scanner.d, scanner.m);
   }
-  l(string) {
+  /**
+   * Throws an invalid character error if any character in the given _string_
+   * isn't a valid XML character.
+   */
+  p(string) {
     let { length } = string;
     for (let i = 0; i < length; ++i) {
       let cp = string.codePointAt(i);
@@ -760,11 +1178,12 @@ var Parser = class {
     }
   }
 };
-function normalizeXmlString(xml) {
-  if (xml[0] === "\uFEFF") {
-    xml = xml.slice(1);
+function normalizeLineBreaks(text) {
+  let i = 0;
+  while ((i = text.indexOf("\r", i)) !== -1) {
+    text = text[i + 1] === "\n" ? text.slice(0, i) + text.slice(i + 1) : text.slice(0, i) + "\n" + text.slice(i + 1);
   }
-  return xml.replace(/\r\n?/g, "\n");
+  return text;
 }
 
 // src/index.ts