xml-sax-ts 0.2.0 → 0.4.0

package/dist/index.js

@@ -21,49 +21,125 @@ var XmlSaxError = class extends Error {
 };
 
 // src/entities.ts
-var NAMED_ENTITIES = {
-  lt: "<",
-  gt: ">",
-  amp: "&",
-  quot: '"',
-  apos: "'"
-};
 function decodeEntities(input, onError) {
-  let output = "";
+  const firstAmp = input.indexOf("&");
+  if (firstAmp === -1) {
+    return input;
+  }
+  let result = "";
   let i = 0;
   while (i < input.length) {
-    const ch = input[i];
-    if (ch !== "&") {
-      output += ch;
-      i += 1;
-      continue;
+    const amp = input.indexOf("&", i);
+    if (amp === -1) {
+      if (i === 0) {
+        return input;
+      }
+      return i < input.length ? result + input.slice(i) : result;
     }
-    const semi = input.indexOf(";", i + 1);
+    if (amp > i) {
+      result += input.slice(i, amp);
+    }
+    const semi = input.indexOf(";", amp + 1);
     if (semi === -1) {
-      const err = new XmlSaxError("Unterminated entity", i, 0, 0);
+      const err = new XmlSaxError("Unterminated entity", amp, 0, 0);
       onError?.(err);
       throw err;
     }
-    const entity = input.slice(i + 1, semi);
     let decoded;
-    if (entity.startsWith("#x") || entity.startsWith("#X")) {
-      const codePoint = Number.parseInt(entity.slice(2), 16);
-      decoded = decodeCodePoint(codePoint);
-    } else if (entity.startsWith("#")) {
-      const codePoint = Number.parseInt(entity.slice(1), 10);
-      decoded = decodeCodePoint(codePoint);
+    const marker = input[amp + 1];
+    if (marker === "#") {
+      const numeric = parseNumericEntity(input, amp + 2, semi);
+      decoded = numeric === void 0 ? void 0 : decodeCodePoint(numeric);
     } else {
-      decoded = NAMED_ENTITIES[entity];
+      decoded = decodeNamedEntity(input, amp + 1, semi);
     }
     if (decoded === void 0) {
-      const err = new XmlSaxError(`Unknown entity: &${entity};`, i, 0, 0);
+      const entity = input.slice(amp + 1, semi);
+      const err = new XmlSaxError(`Unknown entity: &${entity};`, amp, 0, 0);
       onError?.(err);
       throw err;
     }
-    output += decoded;
+    result += decoded;
     i = semi + 1;
   }
-  return output;
+  return result;
+}
+function decodeNamedEntity(input, start, end) {
+  const len = end - start;
+  if (len === 2) {
+    if (input[start] === "l" && input[start + 1] === "t") {
+      return "<";
+    }
+    if (input[start] === "g" && input[start + 1] === "t") {
+      return ">";
+    }
+    return void 0;
+  }
+  if (len === 3) {
+    if (input[start] === "a" && input[start + 1] === "m" && input[start + 2] === "p") {
+      return "&";
+    }
+    return void 0;
+  }
+  if (len === 4) {
+    const maybeQuot = input[start] === "q" && input[start + 1] === "u" && input[start + 2] === "o" && input[start + 3] === "t";
+    if (maybeQuot) {
+      return '"';
+    }
+    const maybeApos = input[start] === "a" && input[start + 1] === "p" && input[start + 2] === "o" && input[start + 3] === "s";
+    if (maybeApos) {
+      return "'";
+    }
+  }
+  return void 0;
+}
+function parseNumericEntity(input, start, end) {
+  if (start >= end) {
+    return void 0;
+  }
+  let i = start;
+  let radix = 10;
+  const marker = input[i];
+  if (marker === "x" || marker === "X") {
+    radix = 16;
+    i += 1;
+  }
+  if (i >= end) {
+    return void 0;
+  }
+  let value = 0;
+  for (; i < end; i += 1) {
+    const ch = input[i];
+    if (ch === void 0) {
+      return void 0;
+    }
+    const digit = radix === 16 ? hexDigit(ch) : decimalDigit(ch);
+    if (digit === -1) {
+      return void 0;
+    }
+    value = value * radix + digit;
+  }
+  return value;
+}
+function decimalDigit(ch) {
+  const code = ch.charCodeAt(0) - 48;
+  if (code < 0 || code > 9) {
+    return -1;
+  }
+  return code;
+}
+function hexDigit(ch) {
+  const code = ch.charCodeAt(0);
+  if (code >= 48 && code <= 57) {
+    return code - 48;
+  }
+  if (code >= 65 && code <= 70) {
+    return code - 55;
+  }
+  if (code >= 97 && code <= 102) {
+    return code - 87;
+  }
+  return -1;
 }
 function decodeCodePoint(codePoint) {
   if (!Number.isFinite(codePoint)) {
@@ -82,8 +158,7 @@ function splitTextForEntities(text) {
   if (lastAmp === -1) {
     return { emit: text, carry: "" };
   }
-  const nextSemi = text.indexOf(";", lastAmp + 1);
-  if (nextSemi === -1) {
+  if (!text.includes(";", lastAmp + 1)) {
     return {
       emit: text.slice(0, lastAmp),
       carry: text.slice(lastAmp)
@@ -96,10 +171,32 @@ function splitTextForEntities(text) {
 var DEFAULT_OPTIONS = {
   xmlns: true,
   includeNamespaceAttributes: false,
-  allowDoctype: true
+  allowDoctype: true,
+  coalesceText: false,
+  trackPosition: true
 };
 var XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
 var XMLNS_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";
+var WHITESPACE_RE = /\s/;
+var CRLF_RE = /\r\n?/g;
+var NAME_START_TABLE = new Uint8Array(128);
+var NAME_CHAR_TABLE = new Uint8Array(128);
+for (let code = 65; code <= 90; code += 1) {
+  NAME_START_TABLE[code] = 1;
+  NAME_CHAR_TABLE[code] = 1;
+}
+for (let code = 97; code <= 122; code += 1) {
+  NAME_START_TABLE[code] = 1;
+  NAME_CHAR_TABLE[code] = 1;
+}
+for (let code = 48; code <= 57; code += 1) {
+  NAME_CHAR_TABLE[code] = 1;
+}
+NAME_START_TABLE[95] = 1;
+NAME_CHAR_TABLE[95] = 1;
+NAME_CHAR_TABLE[58] = 1;
+NAME_CHAR_TABLE[45] = 1;
+NAME_CHAR_TABLE[46] = 1;
 var XmlSaxParser = class {
   constructor(options = {}) {
     this.buffer = "";
@@ -115,7 +212,22 @@ var XmlSaxParser = class {
     ];
     this.closed = false;
     this.pendingCR = false;
-    this.options = { ...DEFAULT_OPTIONS, ...options };
+    this.pendingTextParts = [];
+    this._rawAttrs = [];
+    const resolved = { ...DEFAULT_OPTIONS, ...options };
+    this.xmlns = resolved.xmlns;
+    this.includeNamespaceAttributes = resolved.includeNamespaceAttributes;
+    this.allowDoctype = resolved.allowDoctype;
+    this.coalesceText = resolved.coalesceText;
+    this.trackPosition = resolved.trackPosition;
+    this.onOpenTag = resolved.onOpenTag;
+    this.onCloseTag = resolved.onCloseTag;
+    this.onText = resolved.onText;
+    this.onCdata = resolved.onCdata;
+    this.onComment = resolved.onComment;
+    this.onProcessingInstruction = resolved.onProcessingInstruction;
+    this.onDoctype = resolved.onDoctype;
+    this.onError = resolved.onError;
   }
   feed(chunk) {
     if (this.closed) {
@@ -133,6 +245,7 @@ var XmlSaxParser = class {
     }
     this._parseBuffer(true);
     this._flushPendingCR();
+    this._flushTextBuffer();
     if (this.buffer.length > 0) {
       this._error("Unexpected end of input");
     }
@@ -147,12 +260,21 @@ var XmlSaxParser = class {
       const lt = this.buffer.indexOf("<", i);
       if (lt === -1) {
         const tail = this.buffer.slice(i);
-        const split = splitTextForEntities(tail);
-        if (split.emit.length > 0) {
-          this._emitText(split.emit, true);
-          this._advance(split.emit);
+        if (!tail.includes("&")) {
+          if (tail.length > 0) {
+            this._emitText(tail, true);
+            this._advance(tail);
+          }
+        } else {
+          const split = splitTextForEntities(tail);
+          if (split.emit.length > 0) {
+            this._emitText(split.emit, true);
+            this._advance(split.emit);
+          }
+          this.buffer = split.carry;
+          return;
         }
-        this.buffer = split.carry;
+        this.buffer = "";
         return;
       }
       if (lt > i) {
@@ -167,8 +289,7 @@ var XmlSaxParser = class {
       if (consumed === null) {
         break;
       }
-      const markup = this.buffer.slice(lt, lt + consumed);
-      this._advance(markup);
+      this._advanceSpan(lt, lt + consumed);
       i = lt + consumed;
     }
     this.buffer = this.buffer.slice(i);
@@ -178,35 +299,9 @@ var XmlSaxParser = class {
   }
   _parseMarkupFrom(start, final) {
     assert(this.buffer[start] === "<", "Markup must start with '<'");
-    this._flushPendingCR();
-    if (this.buffer.startsWith("<!--", start)) {
-      const end = this.buffer.indexOf("-->", start + 4);
-      if (end === -1) {
-        if (final) {
-          this._error("Unterminated comment");
-        }
-        return null;
-      }
-      const comment = this.buffer.slice(start + 4, end);
-      this.options.onComment?.(comment);
-      return end + 3 - start;
-    }
-    if (this.buffer.startsWith("<![CDATA[", start)) {
-      const end = this.buffer.indexOf("]]>", start + 9);
-      if (end === -1) {
-        if (final) {
-          this._error("Unterminated CDATA section");
-        }
-        return null;
-      }
-      const cdata = this.buffer.slice(start + 9, end);
-      const normalized = this._normalizeText(cdata, false);
-      if (normalized.length > 0) {
-        this.options.onCdata?.(normalized);
-      }
-      return end + 3 - start;
-    }
-    if (this.buffer.startsWith("<?", start)) {
+    if (this.pendingCR) this._flushPendingCR();
+    const secondCode = this.buffer.charCodeAt(start + 1);
+    if (secondCode === 63) {
       const end = this.buffer.indexOf("?>", start + 2);
       if (end === -1) {
         if (final) {
@@ -215,30 +310,64 @@ var XmlSaxParser = class {
         return null;
       }
       const body = this.buffer.slice(start + 2, end).trim();
-      const split = body.search(/\s/);
+      const split = body.search(WHITESPACE_RE);
       const target = split === -1 ? body : body.slice(0, split);
       const data = split === -1 ? "" : body.slice(split).trim();
       const pi = { target, body: data };
-      this.options.onProcessingInstruction?.(pi);
+      this._flushTextBuffer();
+      this.onProcessingInstruction?.(pi);
       return end + 2 - start;
     }
-    if (this.buffer.startsWith("<!DOCTYPE", start)) {
-      const end = this._findDoctypeEnd(start + 9);
-      if (end === -1) {
-        if (final) {
-          this._error("Unterminated doctype declaration");
+    if (secondCode === 33) {
+      const thirdCode = this.buffer.charCodeAt(start + 2);
+      if (thirdCode === 45 && this.buffer.charCodeAt(start + 3) === 45) {
+        const end = this.buffer.indexOf("-->", start + 4);
+        if (end === -1) {
+          if (final) {
+            this._error("Unterminated comment");
+          }
+          return null;
         }
-        return null;
+        const comment = this.buffer.slice(start + 4, end);
+        this._flushTextBuffer();
+        this.onComment?.(comment);
+        return end + 3 - start;
       }
-      if (!this.options.allowDoctype) {
-        this._error("Doctype is not allowed");
+      if (thirdCode === 91 && this.buffer.startsWith("<![CDATA[", start)) {
+        const end = this.buffer.indexOf("]]>", start + 9);
+        if (end === -1) {
+          if (final) {
+            this._error("Unterminated CDATA section");
+          }
+          return null;
+        }
+        const cdata = this.buffer.slice(start + 9, end);
+        const normalized = this._normalizeText(cdata, false);
+        if (normalized.length > 0) {
+          this._flushTextBuffer();
+          this.onCdata?.(normalized);
+        }
+        return end + 3 - start;
+      }
+      if (thirdCode === 68 && this.buffer.startsWith("<!DOCTYPE", start)) {
+        const end = this._findDoctypeEnd(start + 9);
+        if (end === -1) {
+          if (final) {
+            this._error("Unterminated doctype declaration");
+          }
+          return null;
+        }
+        if (!this.allowDoctype) {
+          this._error("Doctype is not allowed");
+        }
+        const raw = this.buffer.slice(start + 9, end).trim();
+        const doctype = { raw };
+        this._flushTextBuffer();
+        this.onDoctype?.(doctype);
+        return end + 1 - start;
       }
-      const raw = this.buffer.slice(start + 9, end).trim();
-      const doctype = { raw };
-      this.options.onDoctype?.(doctype);
-      return end + 1 - start;
     }
-    if (this.buffer.startsWith("</", start)) {
+    if (secondCode === 47) {
       const end = this.buffer.indexOf(">", start + 2);
       if (end === -1) {
         if (final) {
@@ -246,12 +375,13 @@ var XmlSaxParser = class {
         }
         return null;
       }
-      const raw = this.buffer.slice(start + 2, end).trim();
-      const parsed = this._parseName(raw, 0, raw.length);
-      if (raw.slice(parsed.end).trim().length > 0) {
+      let i = this._skipWhitespace(this.buffer, start + 2, end);
+      const parsed = this._parseName(this.buffer, i, end);
+      i = this._skipWhitespace(this.buffer, parsed.end, end);
+      if (i !== end) {
         this._error("Invalid closing tag");
       }
-      this._handleCloseTag(parsed.name);
+      this._handleCloseTag(parsed.name, parsed.end);
       return end + 1 - start;
     }
     const tagEnd = this._findTagEnd(start + 1);
@@ -261,30 +391,54 @@ var XmlSaxParser = class {
       }
       return null;
     }
-    const content = this.buffer.slice(start + 1, tagEnd);
-    this._handleStartTag(content);
+    this._handleStartTagRange(start + 1, tagEnd);
     return tagEnd + 1 - start;
   }
-  _handleStartTag(content) {
-    const trimmed = content.trim();
-    const selfClosing = trimmed.endsWith("/");
-    const body = selfClosing ? trimmed.slice(0, -1).trim() : trimmed;
-    const parsed = this._parseTagBody(body);
-    let ns = this._currentNs();
-    if (this.options.xmlns) {
-      ns = Object.create(ns);
+  _handleStartTagRange(start, end) {
+    this._flushTextBuffer();
+    const parsed = this._parseStartTagRange(start, end);
+    const selfClosing = parsed.selfClosing;
+    if (!this.xmlns) {
+      const plainName = parsed.name;
+      const attributes2 = /* @__PURE__ */ Object.create(null);
       for (const attr of parsed.attributes) {
-        if (attr.name === "xmlns") {
-          ns[""] = attr.value;
-        } else if (attr.name.startsWith("xmlns:")) {
-          ns[attr.name.slice(6)] = attr.value;
+        attributes2[attr.name] = attr.value;
+      }
+      const tag2 = {
+        name: plainName,
+        attributes: attributes2,
+        isSelfClosing: selfClosing
+      };
+      this.onOpenTag?.(tag2);
+      if (selfClosing) {
+        this.onCloseTag?.({ name: plainName });
+        return;
+      }
+      this.elementStack.push({
+        rawName: parsed.name,
+        closeTag: { name: plainName }
+      });
+      return;
+    }
+    const parentNs = this._currentNs();
+    let ns = parentNs;
+    for (const attr of parsed.attributes) {
+      if (attr.name === "xmlns") {
+        if (ns === parentNs) {
+          ns = Object.create(parentNs);
         }
+        ns[""] = attr.value;
+      } else if (attr.name.startsWith("xmlns:")) {
+        if (ns === parentNs) {
+          ns = Object.create(parentNs);
+        }
+        ns[attr.name.slice(6)] = attr.value;
       }
     }
     const resolvedName = this._resolveName(parsed.name, ns);
-    const attributes = {};
+    const attributes = /* @__PURE__ */ Object.create(null);
     for (const attr of parsed.attributes) {
-      if (this.options.xmlns && !this.options.includeNamespaceAttributes) {
+      if (!this.includeNamespaceAttributes) {
         if (attr.name === "xmlns" || attr.name.startsWith("xmlns:")) {
           continue;
         }
@@ -306,86 +460,118 @@ var XmlSaxParser = class {
       attributes,
       isSelfClosing: selfClosing
     };
-    this.options.onOpenTag?.(tag);
+    this.onOpenTag?.(tag);
     if (selfClosing) {
-      const closeTag = {
+      this.onCloseTag?.({
         name: resolvedName.name,
         prefix: resolvedName.prefix,
         local: resolvedName.local,
         uri: resolvedName.uri
-      };
-      this.options.onCloseTag?.(closeTag);
+      });
       return;
     }
-    this.elementStack.push({ rawName: parsed.name, resolved: resolvedName, ns });
+    this.elementStack.push({
+      rawName: parsed.name,
+      closeTag: {
+        name: resolvedName.name,
+        prefix: resolvedName.prefix,
+        local: resolvedName.local,
+        uri: resolvedName.uri
+      }
+    });
     this.nsStack.push(ns);
   }
-  _handleCloseTag(rawName) {
-    const entry = this.elementStack.pop();
-    const ns = this.nsStack.pop();
-    if (!entry || !ns) {
-      this._error("Closing tag without matching start tag");
-    }
-    if (entry.rawName !== rawName) {
-      this._error(`Mismatched closing tag: expected </${entry.rawName}>`);
-    }
-    const closeTag = {
-      name: entry.resolved.name,
-      prefix: entry.resolved.prefix,
-      local: entry.resolved.local,
-      uri: entry.resolved.uri
-    };
-    this.options.onCloseTag?.(closeTag);
-  }
-  _parseTagBody(body) {
-    let i = 0;
-    const length = body.length;
-    i = this._skipWhitespace(body, i, length);
-    const parsedName = this._parseName(body, i, length);
+  _parseStartTagRange(start, end) {
+    let i = this._skipWhitespace(this.buffer, start, end);
+    const parsedName = this._parseName(this.buffer, i, end);
     i = parsedName.end;
-    const attributes = [];
-    while (i < length) {
-      i = this._skipWhitespace(body, i, length);
-      if (i >= length) {
+    const attributes = this._rawAttrs;
+    attributes.length = 0;
+    let selfClosing = false;
+    while (i < end) {
+      i = this._skipWhitespace(this.buffer, i, end);
+      if (i >= end) {
+        break;
+      }
+      if (this.buffer.charCodeAt(i) === 47) {
+        i += 1;
+        i = this._skipWhitespace(this.buffer, i, end);
+        if (i !== end) {
+          this._error("Invalid self-closing tag");
+        }
+        selfClosing = true;
         break;
       }
-      const attrName = this._parseName(body, i, length);
+      const attrName = this._parseName(this.buffer, i, end);
       i = attrName.end;
-      i = this._skipWhitespace(body, i, length);
-      if (body[i] !== "=") {
+      i = this._skipWhitespace(this.buffer, i, end);
+      if (this.buffer.charCodeAt(i) !== 61) {
         this._error("Attribute without '='");
       }
       i += 1;
-      i = this._skipWhitespace(body, i, length);
-      const quote = body[i];
-      if (quote !== '"' && quote !== "'") {
+      i = this._skipWhitespace(this.buffer, i, end);
+      const quoteCode = this.buffer.charCodeAt(i);
+      if (quoteCode !== 34 && quoteCode !== 39) {
         this._error("Attribute value must be quoted");
       }
+      const quote = String.fromCharCode(quoteCode);
       i += 1;
-      const valueEnd = body.indexOf(quote, i);
-      if (valueEnd === -1) {
+      const valueEnd = this.buffer.indexOf(quote, i);
+      if (valueEnd === -1 || valueEnd >= end) {
         this._error("Unterminated attribute value");
       }
-      const rawValue = body.slice(i, valueEnd);
-      const normalized = rawValue.replace(/\r\n?/g, "\n");
-      const value = decodeEntities(normalized, this.options.onError);
+      const rawValue = this.buffer.slice(i, valueEnd);
+      const normalized = rawValue.includes("\r") ? rawValue.replace(CRLF_RE, "\n") : rawValue;
+      const value = !normalized.includes("&") ? normalized : decodeEntities(normalized, this.onError);
       attributes.push({ name: attrName.name, value });
       i = valueEnd + 1;
     }
-    return { name: parsedName.name, attributes };
+    return { name: parsedName.name, attributes, selfClosing };
+  }
+  _handleCloseTag(rawName, _nameEnd) {
+    this._flushTextBuffer();
+    const entry = this.elementStack.pop();
+    const ns = this.xmlns ? this.nsStack.pop() : this._currentNs();
+    if (!entry || !ns) {
+      this._error("Closing tag without matching start tag");
+    }
+    if (entry.rawName !== rawName) {
+      this._error(`Mismatched closing tag: expected </${entry.rawName}>`);
+    }
+    this.onCloseTag?.(entry.closeTag);
   }
   _emitText(text, allowPendingCR) {
     const normalized = this._normalizeText(text, allowPendingCR);
     if (normalized.length === 0) {
       return;
     }
-    const decoded = decodeEntities(normalized, this.options.onError);
+    if (!normalized.includes("&")) {
+      this._emitDecodedText(normalized);
+      return;
+    }
+    const decoded = decodeEntities(normalized, this.onError);
     if (decoded.length > 0) {
-      this.options.onText?.(decoded);
+      this._emitDecodedText(decoded);
+    }
+  }
+  _emitDecodedText(text) {
+    if (!this.coalesceText) {
+      this.onText?.(text);
+      return;
+    }
+    this.pendingTextParts.push(text);
+  }
+  _flushTextBuffer() {
+    if (!this.coalesceText || this.pendingTextParts.length === 0) {
+      return;
     }
+    const first = this.pendingTextParts[0];
+    const text = this.pendingTextParts.length === 1 && first !== void 0 ? first : this.pendingTextParts.join("");
+    this.pendingTextParts.length = 0;
+    this.onText?.(text);
   }
   _resolveName(rawName, ns) {
-    if (!this.options.xmlns) {
+    if (!this.xmlns) {
       const split2 = rawName.indexOf(":");
       if (split2 === -1) {
         return { name: rawName, prefix: "", local: rawName, uri: "" };
@@ -420,7 +606,7 @@ var XmlSaxParser = class {
     };
   }
   _resolveAttributeName(rawName, ns) {
-    if (!this.options.xmlns) {
+    if (!this.xmlns) {
       return this._resolveName(rawName, ns);
     }
     if (rawName === "xmlns") {
@@ -454,49 +640,59 @@ var XmlSaxParser = class {
     };
   }
   _findTagEnd(start) {
-    let quote = null;
+    const quickEnd = this.buffer.indexOf(">", start);
+    if (quickEnd === -1) {
+      return -1;
+    }
+    const firstDoubleQuote = this.buffer.indexOf('"', start);
+    const firstSingleQuote = this.buffer.indexOf("'", start);
+    const firstQuote = firstDoubleQuote === -1 ? firstSingleQuote : firstSingleQuote === -1 ? firstDoubleQuote : Math.min(firstDoubleQuote, firstSingleQuote);
+    if (firstQuote === -1 || firstQuote > quickEnd) {
+      return quickEnd;
+    }
+    let quoteCode = 0;
     for (let i = start; i < this.buffer.length; i += 1) {
-      const ch = this.buffer[i];
-      if (quote) {
-        if (ch === quote) {
-          quote = null;
+      const code = this.buffer.charCodeAt(i);
+      if (quoteCode) {
+        if (code === quoteCode) {
+          quoteCode = 0;
         }
         continue;
       }
-      if (ch === '"' || ch === "'") {
-        quote = ch;
+      if (code === 34 || code === 39) {
+        quoteCode = code;
         continue;
       }
-      if (ch === ">") {
+      if (code === 62) {
         return i;
       }
     }
     return -1;
   }
   _findDoctypeEnd(start) {
-    let quote = null;
+    let quoteCode = 0;
     let bracketDepth = 0;
     for (let i = start; i < this.buffer.length; i += 1) {
-      const ch = this.buffer[i];
-      if (quote) {
-        if (ch === quote) {
-          quote = null;
+      const code = this.buffer.charCodeAt(i);
+      if (quoteCode) {
+        if (code === quoteCode) {
+          quoteCode = 0;
         }
         continue;
       }
-      if (ch === '"' || ch === "'") {
-        quote = ch;
+      if (code === 34 || code === 39) {
+        quoteCode = code;
         continue;
       }
-      if (ch === "[") {
+      if (code === 91) {
         bracketDepth += 1;
         continue;
       }
-      if (ch === "]") {
+      if (code === 93) {
         bracketDepth = Math.max(0, bracketDepth - 1);
         continue;
       }
-      if (ch === ">" && bracketDepth === 0) {
+      if (code === 62 && bracketDepth === 0) {
         return i;
       }
     }
@@ -506,34 +702,25 @@ var XmlSaxParser = class {
     if (start >= end) {
       this._error("Expected name");
     }
-    const first = input[start];
-    if (first === void 0) {
-      this._error("Expected name");
-    }
-    if (!this._isNameStart(first)) {
-      this._error(`Invalid name start: '${first}'`);
+    const firstCode = input.charCodeAt(start);
+    if (firstCode !== firstCode || firstCode >= 128 || NAME_START_TABLE[firstCode] === 0) {
+      this._error(`Invalid name start: '${input[start] ?? ""}'`);
     }
     let i = start + 1;
     while (i < end) {
-      const ch = input[i];
-      if (ch === void 0 || !this._isNameChar(ch)) {
+      const code = input.charCodeAt(i);
+      if (code >= 128 || NAME_CHAR_TABLE[code] === 0) {
         break;
       }
       i += 1;
     }
     return { name: input.slice(start, i), end: i };
   }
-  _isNameStart(ch) {
-    return /[A-Za-z_]/.test(ch);
-  }
-  _isNameChar(ch) {
-    return /[A-Za-z0-9_:\-.]/.test(ch);
-  }
   _skipWhitespace(input, start, end) {
     let i = start;
     while (i < end) {
-      const ch = input[i];
-      if (ch === void 0 || !/\s/.test(ch)) {
+      const code = input.charCodeAt(i);
+      if (code !== 32 && code !== 9 && code !== 10 && code !== 13) {
         break;
       }
       i += 1;
@@ -545,12 +732,21 @@ var XmlSaxParser = class {
   }
   _advance(text) {
     this.offset += text.length;
-    const lastNewline = text.lastIndexOf("\n");
-    if (lastNewline === -1) {
+    if (!this.trackPosition) {
+      return;
+    }
+    let pos = text.indexOf("\n");
+    if (pos === -1) {
       this.column += text.length;
       return;
     }
-    const newlineCount = text.split("\n").length - 1;
+    let newlineCount = 0;
+    let lastNewline = -1;
+    while (pos !== -1) {
+      newlineCount += 1;
+      lastNewline = pos;
+      pos = text.indexOf("\n", pos + 1);
+    }
     this.line += newlineCount;
     this.column = text.length - lastNewline;
   }
@@ -558,32 +754,58 @@ var XmlSaxParser = class {
     if (!text) {
       return "";
     }
+    if (!this.pendingCR && !text.includes("\r")) {
+      return text;
+    }
     let value = text;
     let prefix = "";
     if (this.pendingCR) {
       prefix = "\n";
-      if (value.startsWith("\n")) {
+      if (value.charCodeAt(0) === 10) {
         value = value.slice(1);
       }
       this.pendingCR = false;
     }
-    if (allowPendingCR && value.endsWith("\r")) {
+    if (allowPendingCR && value.charCodeAt(value.length - 1) === 13) {
       this.pendingCR = true;
       value = value.slice(0, -1);
     }
-    const normalized = value.replace(/\r\n?/g, "\n");
-    return `${prefix}${normalized}`;
+    const normalized = !value.includes("\r") ? value : value.replace(CRLF_RE, "\n");
+    return prefix ? `${prefix}${normalized}` : normalized;
+  }
+  _advanceSpan(start, end) {
+    const length = end - start;
+    this.offset += length;
+    if (!this.trackPosition) {
+      return;
+    }
+    let pos = this.buffer.indexOf("\n", start);
+    if (pos === -1 || pos >= end) {
+      this.column += length;
+      return;
+    }
+    let newlineCount = 0;
+    let lastNewline = -1;
+    while (pos !== -1 && pos < end) {
+      newlineCount += 1;
+      lastNewline = pos;
+      pos = this.buffer.indexOf("\n", pos + 1);
+    }
+    this.line += newlineCount;
+    this.column = end - lastNewline;
   }
   _flushPendingCR() {
     if (!this.pendingCR) {
       return;
     }
     this.pendingCR = false;
-    this.options.onText?.("\n");
+    this._emitDecodedText("\n");
   }
   _error(message) {
-    const error = new XmlSaxError(message, this.offset, this.line, this.column);
-    this.options.onError?.(error);
+    const line = this.trackPosition ? this.line : 0;
+    const column = this.trackPosition ? this.column : 0;
+    const error = new XmlSaxError(message, this.offset, line, column);
+    this.onError?.(error);
     throw error;
   }
 };
@@ -597,7 +819,7 @@ var TreeBuilder = class {
       const node = {
         name: tag.name,
         attributes: Object.fromEntries(
-          Object.entries(tag.attributes).map(([key, attr]) => [key, attr.value])
+          Object.entries(tag.attributes).map(([key, attr]) => [key, typeof attr === "string" ? attr : attr.value])
         ),
         children: []
       };
@@ -737,11 +959,13 @@ function stripNamespace(name) {
 }
 function resolveName(value) {
   if (typeof value !== "string") {
+    const prefix = value.prefix ?? "";
+    const local = value.local ?? (prefix ? value.name.slice(prefix.length + 1) : value.name);
     return {
       name: value.name,
-      localName: value.local,
-      prefix: value.prefix,
-      uri: value.uri
+      localName: local,
+      prefix,
+      uri: value.uri ?? ""
     };
   }
   const index = value.indexOf(":");
@@ -759,6 +983,16 @@ function buildObject(root, options = {}) {
   const settings = buildSettings(options);
   return buildNode(root, settings, []);
 }
+function buildXmlNode(obj, options = {}) {
+  const settings = buildXmlSettings(options);
+  const root = resolveRoot(obj, settings);
+  const rootName = normalizeName(root.name, settings);
+  return buildElement(rootName, root.value, settings, []);
+}
+function objectToXml(obj, options = {}) {
+  const node = buildXmlNode(obj, options);
+  return serializeXml(node, options);
+}
 var ObjectBuilder = class {
   constructor(options = {}) {
     this.stack = [];
@@ -821,6 +1055,9 @@ var ObjectBuilder = class {
 function buildSettings(options) {
   return { ...DEFAULT_OBJECT_OPTIONS, ...options };
 }
+function buildXmlSettings(options) {
+  return { ...DEFAULT_OBJECT_OPTIONS, ...options };
+}
 function buildNode(node, options, path) {
   const name = normalizeName(node.name, options);
   const attributes = normalizeAttributeMap(node.attributes ?? {}, options);
@@ -849,11 +1086,17 @@ function normalizeName(name, options) {
   }
   return name;
 }
+function normalizeXmlName(name, options) {
+  if (options.stripNamespaces) {
+    return stripNamespace(name);
+  }
+  return name;
+}
 function normalizeAttributes(attributes, options) {
   const result = /* @__PURE__ */ Object.create(null);
   for (const [key, attr] of Object.entries(attributes)) {
     const name = normalizeName(key, options);
-    result[name] = attr.value;
+    result[name] = typeof attr === "string" ? attr : attr.value;
   }
   return result;
 }
@@ -888,6 +1131,151 @@ function shouldForceArray(name, path, options) {
   }
   return rule(name, path);
 }
+function resolveRoot(obj, options) {
+  if (isRecord(obj)) {
+    const keys = Object.keys(obj);
+    if (keys.length === 1) {
+      const name = keys[0] ?? "";
+      return { name, value: obj[name] };
+    }
+  }
+  if (!options.rootName) {
+    throw new Error("Root element name is required when object has multiple keys");
+  }
+  return { name: options.rootName, value: obj };
+}
+function buildElement(name, value, options, path) {
+  const attributes = /* @__PURE__ */ Object.create(null);
+  const children = [];
+  const nextPath = [...path, name];
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      appendContent(children, item, options, nextPath);
+    }
+    return finalizeNode(name, attributes, children);
+  }
+  if (isPrimitive(value)) {
+    const text = coerceText(value);
+    if (text !== null) {
+      children.push(text);
+    }
+    return finalizeNode(name, attributes, children);
+  }
+  if (isRecord(value)) {
+    for (const [key, entryValue] of Object.entries(value)) {
+      if (isAttributeKey(key, options)) {
+        const attrName = normalizeXmlName(key.slice(options.attributePrefix.length), options);
+        const attrValue = coerceText(entryValue);
+        if (attrValue !== null) {
+          attributes[attrName] = attrValue;
+        }
+        continue;
+      }
+      if (key === options.textKey) {
+        appendText(children, entryValue, options);
+        continue;
+      }
+      const childName = normalizeXmlName(key, options);
+      addChildElements(children, childName, entryValue, options, nextPath);
+    }
+  }
+  return finalizeNode(name, attributes, children);
+}
+function addChildElements(children, name, value, options, path) {
+  const forcedArray = shouldForceArray(name, path, options);
+  const items = Array.isArray(value) ? value : forcedArray ? [value] : [value];
+  for (const item of items) {
+    if (item === void 0 || item === null) {
+      children.push({ name });
+      continue;
+    }
+    children.push(buildElement(name, item, options, path));
+  }
+}
+function appendContent(children, value, options, path) {
+  if (value === void 0 || value === null) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      appendContent(children, item, options, path);
+    }
+    return;
+  }
+  if (isPrimitive(value)) {
+    const text = coerceText(value);
+    if (text !== null) {
+      children.push(text);
+    }
+    return;
+  }
+  if (isRecord(value)) {
+    for (const [key, entryValue] of Object.entries(value)) {
+      const childName = normalizeXmlName(key, options);
+      addChildElements(children, childName, entryValue, options, path);
+    }
+  }
+}
+function appendText(children, value, options) {
+  if (value === void 0 || value === null) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    const parts = value.map((item) => coerceText(item)).filter((item) => item !== null);
+    if (parts.length === 0) {
+      return;
+    }
+    if (options.coalesceText) {
+      children.push(parts.join(""));
+      return;
+    }
+    for (const part of parts) {
+      children.push(part);
+    }
+    return;
+  }
+  const text = coerceText(value);
+  if (text !== null) {
+    children.push(text);
+  }
+}
+function finalizeNode(name, attributes, children) {
+  const node = { name };
+  if (Object.keys(attributes).length > 0) {
+    node.attributes = attributes;
+  }
+  if (children.length > 0) {
+    node.children = children;
+  }
+  return node;
+}
+function isAttributeKey(key, options) {
+  if (!options.attributePrefix) {
+    return false;
+  }
+  return key.startsWith(options.attributePrefix) && key.length > options.attributePrefix.length;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPrimitive(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function coerceText(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return null;
+}
 function finalizeElement(state, options) {
   const hasAttributes = Object.keys(state.attributes).length > 0;
   const hasChildren = Object.keys(state.children).length > 0;
@@ -912,6 +1300,6 @@ function finalizeElement(state, options) {
   return result;
 }
 
-export { ObjectBuilder, TreeBuilder, XmlSaxError, XmlSaxParser, buildObject, parseXmlString, resolveName, serializeXml, stripNamespace };
+export { ObjectBuilder, TreeBuilder, XmlSaxError, XmlSaxParser, buildObject, buildXmlNode, objectToXml, parseXmlString, resolveName, serializeXml, stripNamespace };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map