xml-sax-ts 0.1.0

package/dist/index.js

@@ -0,0 +1,718 @@
+// src/assert.ts
+var DEV = typeof process !== "undefined" ? process.env.NODE_ENV !== "production" : true;
+function assert(condition, message) {
+  if (!DEV) {
+    return;
+  }
+  if (!condition) {
+    throw new Error(`Invariant failed: ${message}`);
+  }
+}
+
+// src/errors.ts
+var XmlSaxError = class extends Error {
+  constructor(message, offset, line, column) {
+    super(`${message} at ${line}:${column}`);
+    this.name = "XmlSaxError";
+    this.offset = offset;
+    this.line = line;
+    this.column = column;
+  }
+};
+
+// src/entities.ts
+var NAMED_ENTITIES = {
+  lt: "<",
+  gt: ">",
+  amp: "&",
+  quot: '"',
+  apos: "'"
+};
+function decodeEntities(input, onError) {
+  let output = "";
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch !== "&") {
+      output += ch;
+      i += 1;
+      continue;
+    }
+    const semi = input.indexOf(";", i + 1);
+    if (semi === -1) {
+      const err = new XmlSaxError("Unterminated entity", i, 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);
+    } else {
+      decoded = NAMED_ENTITIES[entity];
+    }
+    if (decoded === void 0) {
+      const err = new XmlSaxError(`Unknown entity: &${entity};`, i, 0, 0);
+      onError?.(err);
+      throw err;
+    }
+    output += decoded;
+    i = semi + 1;
+  }
+  return output;
+}
+function decodeCodePoint(codePoint) {
+  if (!Number.isFinite(codePoint)) {
+    return void 0;
+  }
+  if (codePoint < 0 || codePoint > 1114111) {
+    return void 0;
+  }
+  if (codePoint >= 55296 && codePoint <= 57343) {
+    return void 0;
+  }
+  return String.fromCodePoint(codePoint);
+}
+function splitTextForEntities(text) {
+  const lastAmp = text.lastIndexOf("&");
+  if (lastAmp === -1) {
+    return { emit: text, carry: "" };
+  }
+  const nextSemi = text.indexOf(";", lastAmp + 1);
+  if (nextSemi === -1) {
+    return {
+      emit: text.slice(0, lastAmp),
+      carry: text.slice(lastAmp)
+    };
+  }
+  return { emit: text, carry: "" };
+}
+
+// src/parser.ts
+var DEFAULT_OPTIONS = {
+  xmlns: true,
+  includeNamespaceAttributes: false,
+  allowDoctype: true
+};
+var XML_NAMESPACE_URI = "http://www.w3.org/XML/1998/namespace";
+var XMLNS_NAMESPACE_URI = "http://www.w3.org/2000/xmlns/";
+var XmlSaxParser = class {
+  constructor(options = {}) {
+    this.buffer = "";
+    this.offset = 0;
+    this.line = 1;
+    this.column = 1;
+    this.elementStack = [];
+    this.nsStack = [
+      Object.assign(/* @__PURE__ */ Object.create(null), {
+        xml: XML_NAMESPACE_URI,
+        xmlns: XMLNS_NAMESPACE_URI
+      })
+    ];
+    this.closed = false;
+    this.pendingCR = false;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  feed(chunk) {
+    if (this.closed) {
+      this._error("Parser is closed");
+    }
+    if (!chunk) {
+      return;
+    }
+    this.buffer += chunk;
+    this._parseBuffer(false);
+  }
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this._parseBuffer(true);
+    this._flushPendingCR();
+    if (this.buffer.length > 0) {
+      this._error("Unexpected end of input");
+    }
+    if (this.elementStack.length > 0) {
+      this._error("Unclosed tag(s) remaining");
+    }
+    this.closed = true;
+  }
+  _parseBuffer(final) {
+    let i = 0;
+    while (i < this.buffer.length) {
+      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);
+        }
+        this.buffer = split.carry;
+        return;
+      }
+      if (lt > i) {
+        const text = this.buffer.slice(i, lt);
+        if (text.length > 0) {
+          this._emitText(text, false);
+          this._advance(text);
+        }
+        i = lt;
+      }
+      const consumed = this._parseMarkupFrom(lt, final);
+      if (consumed === null) {
+        break;
+      }
+      const markup = this.buffer.slice(lt, lt + consumed);
+      this._advance(markup);
+      i = lt + consumed;
+    }
+    this.buffer = this.buffer.slice(i);
+    if (final && this.buffer.length > 0) {
+      this._error("Unexpected end of input");
+    }
+  }
+  _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)) {
+      const end = this.buffer.indexOf("?>", start + 2);
+      if (end === -1) {
+        if (final) {
+          this._error("Unterminated processing instruction");
+        }
+        return null;
+      }
+      const body = this.buffer.slice(start + 2, end).trim();
+      const split = body.search(/\s/);
+      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);
+      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");
+        }
+        return null;
+      }
+      if (!this.options.allowDoctype) {
+        this._error("Doctype is not allowed");
+      }
+      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)) {
+      const end = this.buffer.indexOf(">", start + 2);
+      if (end === -1) {
+        if (final) {
+          this._error("Unterminated closing tag");
+        }
+        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) {
+        this._error("Invalid closing tag");
+      }
+      this._handleCloseTag(parsed.name);
+      return end + 1 - start;
+    }
+    const tagEnd = this._findTagEnd(start + 1);
+    if (tagEnd === -1) {
+      if (final) {
+        this._error("Unterminated start tag");
+      }
+      return null;
+    }
+    const content = this.buffer.slice(start + 1, tagEnd);
+    this._handleStartTag(content);
+    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);
+      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;
+        }
+      }
+    }
+    const resolvedName = this._resolveName(parsed.name, ns);
+    const attributes = {};
+    for (const attr of parsed.attributes) {
+      if (this.options.xmlns && !this.options.includeNamespaceAttributes) {
+        if (attr.name === "xmlns" || attr.name.startsWith("xmlns:")) {
+          continue;
+        }
+      }
+      const resolvedAttr = this._resolveAttributeName(attr.name, ns);
+      attributes[resolvedAttr.name] = {
+        name: resolvedAttr.name,
+        value: attr.value,
+        prefix: resolvedAttr.prefix,
+        local: resolvedAttr.local,
+        uri: resolvedAttr.uri
+      };
+    }
+    const tag = {
+      name: resolvedName.name,
+      prefix: resolvedName.prefix,
+      local: resolvedName.local,
+      uri: resolvedName.uri,
+      attributes,
+      isSelfClosing: selfClosing
+    };
+    this.options.onOpenTag?.(tag);
+    if (selfClosing) {
+      const closeTag = {
+        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.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);
+    i = parsedName.end;
+    const attributes = [];
+    while (i < length) {
+      i = this._skipWhitespace(body, i, length);
+      if (i >= length) {
+        break;
+      }
+      const attrName = this._parseName(body, i, length);
+      i = attrName.end;
+      i = this._skipWhitespace(body, i, length);
+      if (body[i] !== "=") {
+        this._error("Attribute without '='");
+      }
+      i += 1;
+      i = this._skipWhitespace(body, i, length);
+      const quote = body[i];
+      if (quote !== '"' && quote !== "'") {
+        this._error("Attribute value must be quoted");
+      }
+      i += 1;
+      const valueEnd = body.indexOf(quote, i);
+      if (valueEnd === -1) {
+        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);
+      attributes.push({ name: attrName.name, value });
+      i = valueEnd + 1;
+    }
+    return { name: parsedName.name, attributes };
+  }
+  _emitText(text, allowPendingCR) {
+    const normalized = this._normalizeText(text, allowPendingCR);
+    if (normalized.length === 0) {
+      return;
+    }
+    const decoded = decodeEntities(normalized, this.options.onError);
+    if (decoded.length > 0) {
+      this.options.onText?.(decoded);
+    }
+  }
+  _resolveName(rawName, ns) {
+    if (!this.options.xmlns) {
+      const split2 = rawName.indexOf(":");
+      if (split2 === -1) {
+        return { name: rawName, prefix: "", local: rawName, uri: "" };
+      }
+      return {
+        name: rawName,
+        prefix: rawName.slice(0, split2),
+        local: rawName.slice(split2 + 1),
+        uri: ""
+      };
+    }
+    const split = rawName.indexOf(":");
+    if (split === -1) {
+      return {
+        name: rawName,
+        prefix: "",
+        local: rawName,
+        uri: ns[""] ?? ""
+      };
+    }
+    const prefix = rawName.slice(0, split);
+    const local = rawName.slice(split + 1);
+    const uri = ns[prefix];
+    if (uri === void 0) {
+      this._error(`Undeclared namespace prefix: ${prefix}`);
+    }
+    return {
+      name: rawName,
+      prefix,
+      local,
+      uri
+    };
+  }
+  _resolveAttributeName(rawName, ns) {
+    if (!this.options.xmlns) {
+      return this._resolveName(rawName, ns);
+    }
+    if (rawName === "xmlns") {
+      return {
+        name: rawName,
+        prefix: "",
+        local: rawName,
+        uri: ns.xmlns ?? XMLNS_NAMESPACE_URI
+      };
+    }
+    const split = rawName.indexOf(":");
+    if (split === -1) {
+      return {
+        name: rawName,
+        prefix: "",
+        local: rawName,
+        uri: ""
+      };
+    }
+    const prefix = rawName.slice(0, split);
+    const local = rawName.slice(split + 1);
+    const uri = ns[prefix];
+    if (uri === void 0) {
+      this._error(`Undeclared namespace prefix: ${prefix}`);
+    }
+    return {
+      name: rawName,
+      prefix,
+      local,
+      uri
+    };
+  }
+  _findTagEnd(start) {
+    let quote = null;
+    for (let i = start; i < this.buffer.length; i += 1) {
+      const ch = this.buffer[i];
+      if (quote) {
+        if (ch === quote) {
+          quote = null;
+        }
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        quote = ch;
+        continue;
+      }
+      if (ch === ">") {
+        return i;
+      }
+    }
+    return -1;
+  }
+  _findDoctypeEnd(start) {
+    let quote = null;
+    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;
+        }
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        quote = ch;
+        continue;
+      }
+      if (ch === "[") {
+        bracketDepth += 1;
+        continue;
+      }
+      if (ch === "]") {
+        bracketDepth = Math.max(0, bracketDepth - 1);
+        continue;
+      }
+      if (ch === ">" && bracketDepth === 0) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  _parseName(input, start, end) {
+    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}'`);
+    }
+    let i = start + 1;
+    while (i < end) {
+      const ch = input[i];
+      if (ch === void 0 || !this._isNameChar(ch)) {
+        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)) {
+        break;
+      }
+      i += 1;
+    }
+    return i;
+  }
+  _currentNs() {
+    return this.nsStack[this.nsStack.length - 1] ?? /* @__PURE__ */ Object.create(null);
+  }
+  _advance(text) {
+    this.offset += text.length;
+    const lastNewline = text.lastIndexOf("\n");
+    if (lastNewline === -1) {
+      this.column += text.length;
+      return;
+    }
+    const newlineCount = text.split("\n").length - 1;
+    this.line += newlineCount;
+    this.column = text.length - lastNewline;
+  }
+  _normalizeText(text, allowPendingCR) {
+    if (!text) {
+      return "";
+    }
+    let value = text;
+    let prefix = "";
+    if (this.pendingCR) {
+      prefix = "\n";
+      if (value.startsWith("\n")) {
+        value = value.slice(1);
+      }
+      this.pendingCR = false;
+    }
+    if (allowPendingCR && value.endsWith("\r")) {
+      this.pendingCR = true;
+      value = value.slice(0, -1);
+    }
+    const normalized = value.replace(/\r\n?/g, "\n");
+    return `${prefix}${normalized}`;
+  }
+  _flushPendingCR() {
+    if (!this.pendingCR) {
+      return;
+    }
+    this.pendingCR = false;
+    this.options.onText?.("\n");
+  }
+  _error(message) {
+    const error = new XmlSaxError(message, this.offset, this.line, this.column);
+    this.options.onError?.(error);
+    throw error;
+  }
+};
+
+// src/tree.ts
+var TreeBuilder = class {
+  constructor() {
+    this.stack = [];
+    this.root = null;
+    this.onOpenTag = (tag) => {
+      const node = {
+        name: tag.name,
+        attributes: Object.fromEntries(
+          Object.entries(tag.attributes).map(([key, attr]) => [key, attr.value])
+        ),
+        children: []
+      };
+      const parent = this.stack[this.stack.length - 1];
+      if (parent) {
+        parent.children?.push(node);
+      } else {
+        this.root = node;
+      }
+      this.stack.push(node);
+    };
+    this.onText = (text) => {
+      if (!this.stack.length) {
+        return;
+      }
+      const node = this.stack[this.stack.length - 1];
+      if (!node) {
+        return;
+      }
+      const children = node.children ?? [];
+      const last = children[children.length - 1];
+      if (typeof last === "string") {
+        children[children.length - 1] = last + text;
+      } else {
+        children.push(text);
+      }
+      node.children = children;
+    };
+    this.onCdata = (text) => {
+      this.onText(text);
+    };
+    this.onCloseTag = () => {
+      this.stack.pop();
+    };
+  }
+  getRoot() {
+    if (!this.root) {
+      throw new Error("No root element found");
+    }
+    return this.root;
+  }
+};
+function parseXmlString(xml, options = {}) {
+  const builder = new TreeBuilder();
+  const parser = new XmlSaxParser({
+    ...options,
+    onOpenTag: builder.onOpenTag,
+    onText: builder.onText,
+    onCdata: builder.onCdata,
+    onCloseTag: builder.onCloseTag
+  });
+  parser.feed(xml);
+  parser.close();
+  return builder.getRoot();
+}
+
+// src/serializer.ts
+var DEFAULT_OPTIONS2 = {
+  pretty: false,
+  indent: "  ",
+  newline: "\n",
+  xmlDeclaration: false
+};
+function serializeXml(node, options = {}) {
+  const settings = { ...DEFAULT_OPTIONS2, ...options };
+  const body = serializeNode(node, settings, 0);
+  if (!settings.xmlDeclaration) {
+    return body;
+  }
+  return `<?xml version="1.0" encoding="UTF-8"?>${settings.newline}${body}`;
+}
+function serializeNode(node, options, depth) {
+  const attrs = serializeAttributes(node.attributes);
+  const tagOpen = `<${node.name}${attrs}>`;
+  const tagClose = `</${node.name}>`;
+  const children = node.children ?? [];
+  if (!children.length) {
+    if (!options.pretty) {
+      return `<${node.name}${attrs}/>`;
+    }
+    const indent2 = options.indent.repeat(depth);
+    return `${indent2}<${node.name}${attrs}/>`;
+  }
+  if (!options.pretty) {
+    const inner2 = children.map((child) => serializeChild(child, options, depth + 1)).join("");
+    return `${tagOpen}${inner2}${tagClose}`;
+  }
+  const indent = options.indent.repeat(depth);
+  const innerIndent = options.indent.repeat(depth + 1);
+  const prettyOpen = `${indent}${tagOpen}`;
+  const prettyClose = `${indent}${tagClose}`;
+  const inner = children.map(
+    (child) => typeof child === "string" ? `${innerIndent}${escapeText(child)}` : serializeNode(child, options, depth + 1)
+  ).join(options.newline);
+  return `${prettyOpen}${options.newline}${inner}${options.newline}${prettyClose}`;
+}
+function serializeChild(child, options, depth) {
+  if (typeof child === "string") {
+    return escapeText(child);
+  }
+  return serializeNode(child, options, depth);
+}
+function serializeAttributes(attrs) {
+  if (!attrs) {
+    return "";
+  }
+  return Object.entries(attrs).map(([key, value]) => ` ${key}="${escapeAttribute(value)}"`).join("");
+}
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeAttribute(value) {
+  return escapeText(value).replace(/"/g, "&quot;");
+}
+
+export { TreeBuilder, XmlSaxError, XmlSaxParser, parseXmlString, serializeXml };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map