@bpmnkit/core 0.1.1 → 0.2.0

package/dist/xml/xml-parser.js

@@ -1,153 +1,375 @@
 // ---------------------------------------------------------------------------
-// Parser
+// Event scanner
 // ---------------------------------------------------------------------------
+/** What a sink wants the scanner to do with an element after its start tag. */
+export const Visit = {
+    /** Report child elements and character data. */
+    All: 0,
+    /**
+     * Skip the element's content: the scanner fast-forwards past the matching
+     * end tag without building attributes or decoding text for anything inside,
+     * and `end` is not called for it.
+     */
+    Skip: 1,
+    /** Report child elements but drop character data without decoding it. */
+    ElementsOnly: 2,
+};
+/**
+ * Scan an XML document, reporting the root element and everything inside it to
+ * `sink`. Returns false when the document has no root element. Content after
+ * the root element is ignored.
+ */
+export function scanXml(xml, sink) {
+    return new XmlScanner(xml).scan(sink);
+}
 /**
  * Parse an XML string into an XmlElement tree.
  * Returns the root element with all namespace prefixes preserved.
  * @throws Error if the XML has no root element.
  */
 export function parseXml(xml) {
-    const p = new XmlReader(xml);
-    const root = p.parseDocument();
-    if (!root)
+    const builder = new TreeBuilder();
+    if (!scanXml(xml, builder) || builder.root === undefined) {
         throw new Error("Failed to parse XML: no root element found");
-    return root;
+    }
+    return builder.root;
+}
+/** Sink that materialises the document as an XmlElement tree. */
+class TreeBuilder {
+    root;
+    stack = [];
+    start(name, _local, attributes) {
+        const el = { name, attributes, children: [] };
+        const parent = this.stack[this.stack.length - 1];
+        if (parent)
+            parent.children.push(el);
+        else
+            this.root = el;
+        this.stack.push(el);
+        return Visit.All;
+    }
+    text(text) {
+        const el = this.stack[this.stack.length - 1];
+        el.text = el.text === undefined ? text : el.text + text;
+    }
+    end() {
+        this.stack.pop();
+    }
 }
-class XmlReader {
+// Character codes the scanner switches on. Comparing codes avoids allocating a
+// one-character string for every position visited.
+const LT = 0x3c; // <
+const GT = 0x3e; // >
+const SLASH = 0x2f; // /
+const EQ = 0x3d; // =
+const QUESTION = 0x3f; // ?
+const BANG = 0x21; // !
+const DQUOTE = 0x22; // "
+const SQUOTE = 0x27; // '
+const COLON = 0x3a; // :
+const SPACE = 0x20;
+const TAB = 0x09;
+const LF = 0x0a;
+const CR = 0x0d;
+class XmlScanner {
     s;
+    n;
     i = 0;
+    /** Index of the first ":" in the name most recently read, or -1. */
+    colon = -1;
+    /** Position of the next "&" at or after the last place we looked, or -1 for none. */
+    nextAmp = 0;
     constructor(source) {
         this.s = source;
+        this.n = source.length;
     }
-    parseDocument() {
-        let root;
-        while (this.i < this.s.length) {
+    scan(sink) {
+        while (this.i < this.n) {
             this.skipWhitespace();
-            if (this.i >= this.s.length)
+            if (this.i >= this.n)
                 break;
-            if (this.s[this.i] !== "<") {
+            if (this.s.charCodeAt(this.i) !== LT) {
                 // text outside root — skip
                 this.i++;
                 continue;
             }
-            if (this.startsWith("<?")) {
+            const next = this.s.charCodeAt(this.i + 1);
+            if (next === QUESTION) {
                 this.skipPi();
             }
-            else if (this.startsWith("<!--")) {
-                this.skipComment();
+            else if (next === BANG) {
+                if (this.s.startsWith("<!--", this.i))
+                    this.skipComment();
+                else
+                    this.skipBang();
             }
-            else if (this.startsWith("<!")) {
-                this.skipBang();
+            else {
+                this.element(sink);
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Scan the element starting at `i` (which is "<") and everything inside it. */
+    element(sink) {
+        const s = this.s;
+        // Open elements, innermost last, with whether each one wants character data.
+        const open = [];
+        const wantText = [];
+        if (this.openTag(sink, open, wantText) === 0)
+            return;
+        while (open.length > 0) {
+            if (this.i >= this.n)
+                throw new Error(`Expected "</" at position ${this.i}`);
+            const c = s.charCodeAt(this.i);
+            if (c !== LT) {
+                if (wantText[wantText.length - 1])
+                    sink.text(this.readText());
+                else
+                    this.skipText();
+                continue;
+            }
+            const next = s.charCodeAt(this.i + 1);
+            if (next === SLASH) {
+                this.i += 2;
+                const closing = this.readName();
+                const name = open[open.length - 1];
+                if (closing !== name) {
+                    throw new Error(`Mismatched closing tag: expected </${name}>, got </${closing}>`);
+                }
+                this.skipWhitespace();
+                this.expectChar(GT, ">");
+                open.pop();
+                wantText.pop();
+                sink.end(name);
+            }
+            else if (next === BANG) {
+                if (s.startsWith("<!--", this.i)) {
+                    this.skipComment();
+                }
+                else if (s.startsWith("<![CDATA[", this.i)) {
+                    if (wantText[wantText.length - 1])
+                        sink.text(this.readCData());
+                    else
+                        this.skipCData();
+                }
+                else {
+                    // Unknown declaration inside content — treat it as an element and
+                    // let the name reader fail on it, as before.
+                    this.openTag(sink, open, wantText);
+                }
+            }
+            else if (next === QUESTION) {
+                this.skipPi();
             }
             else {
-                root = this.parseElement();
-                break;
+                this.openTag(sink, open, wantText);
             }
         }
-        return root;
     }
-    parseElement() {
-        this.expect("<");
+    /**
+     * Read a start tag at `i`, report it, and push it onto `open` unless it was
+     * self-closing or the sink skipped it. Returns the new depth of `open`.
+     */
+    openTag(sink, open, wantText) {
+        const s = this.s;
+        this.i++; // <
         const name = this.readName();
+        const local = this.colon >= 0 ? s.substring(this.colon + 1, this.i) : name;
         const attributes = {};
         this.readAttributes(attributes);
         this.skipWhitespace();
-        if (this.s[this.i] === "/" && this.s[this.i + 1] === ">") {
-            // self-closing
+        if (s.charCodeAt(this.i) === SLASH && s.charCodeAt(this.i + 1) === GT) {
             this.i += 2;
-            return { name, attributes, children: [] };
+            if (sink.start(name, local, attributes, true) !== Visit.Skip)
+                sink.end(name);
+            return open.length;
         }
-        this.expect(">");
-        const children = [];
-        let text;
-        while (this.i < this.s.length) {
-            if (this.startsWith("</"))
-                break;
-            if (this.s[this.i] === "<") {
-                if (this.startsWith("<!--")) {
-                    this.skipComment();
-                }
-                else if (this.startsWith("<![CDATA[")) {
-                    const cd = this.readCData();
-                    text = text === undefined ? cd : text + cd;
-                }
-                else if (this.startsWith("<?")) {
-                    this.skipPi();
+        this.expectChar(GT, ">");
+        const visit = sink.start(name, local, attributes, false);
+        if (visit === Visit.Skip) {
+            this.skipContent(name);
+            return open.length;
+        }
+        open.push(name);
+        wantText.push(visit === Visit.All);
+        return open.length;
+    }
+    /**
+     * Fast-forward past the content and end tag of the element `name` whose
+     * start tag was just consumed, validating nesting but allocating nothing.
+     */
+    skipContent(name) {
+        const s = this.s;
+        // Open elements below `name`, as (start, length) spans into the source.
+        const spans = [];
+        let depth = 1;
+        while (depth > 0) {
+            const lt = s.indexOf("<", this.i);
+            if (lt === -1)
+                throw new Error(`Expected "</" at position ${this.n}`);
+            this.i = lt;
+            const next = s.charCodeAt(lt + 1);
+            if (next === SLASH) {
+                this.i += 2;
+                const start = this.i;
+                this.skipName();
+                const length = this.i - start;
+                if (spans.length === 0) {
+                    if (length !== name.length || !s.startsWith(name, start)) {
+                        throw new Error(`Mismatched closing tag: expected </${name}>, got </${s.substring(start, this.i)}>`);
+                    }
                 }
                 else {
-                    children.push(this.parseElement());
+                    const openLength = spans.pop();
+                    const openStart = spans.pop();
+                    if (!this.sameSpan(openStart, openLength, start, length)) {
+                        throw new Error(`Mismatched closing tag: expected </${s.substring(openStart, openStart + openLength)}>, got </${s.substring(start, this.i)}>`);
+                    }
                 }
+                this.skipWhitespace();
+                this.expectChar(GT, ">");
+                depth--;
+            }
+            else if (next === BANG && s.startsWith("<!--", lt)) {
+                this.skipComment();
+            }
+            else if (next === BANG && s.startsWith("<![CDATA[", lt)) {
+                const end = s.indexOf("]]>", lt + 9);
+                if (end === -1)
+                    throw new Error("Unterminated CDATA section");
+                this.i = end + 3;
+            }
+            else if (next === QUESTION) {
+                this.skipPi();
             }
             else {
-                const t = this.readText();
-                if (t.length > 0) {
-                    text = text === undefined ? t : text + t;
+                this.i++;
+                const start = this.i;
+                this.skipName();
+                const length = this.i - start;
+                this.skipAttributes();
+                this.skipWhitespace();
+                if (s.charCodeAt(this.i) === SLASH && s.charCodeAt(this.i + 1) === GT) {
+                    this.i += 2;
+                    continue;
                 }
+                this.expectChar(GT, ">");
+                spans.push(start, length);
+                depth++;
             }
         }
-        // closing tag </name>
-        this.expect("</");
-        const closing = this.readName();
-        if (closing !== name) {
-            throw new Error(`Mismatched closing tag: expected </${name}>, got </${closing}>`);
+    }
+    sameSpan(aStart, aLength, bStart, bLength) {
+        if (aLength !== bLength)
+            return false;
+        const s = this.s;
+        for (let k = 0; k < aLength; k++) {
+            if (s.charCodeAt(aStart + k) !== s.charCodeAt(bStart + k))
+                return false;
         }
-        this.skipWhitespace();
-        this.expect(">");
-        const el = { name, attributes, children };
-        if (text !== undefined)
-            el.text = text;
-        return el;
+        return true;
     }
     readAttributes(attrs) {
-        while (this.i < this.s.length) {
+        const s = this.s;
+        while (this.i < this.n) {
             this.skipWhitespace();
-            const ch = this.s[this.i];
-            if (ch === ">" || ch === "/")
+            const ch = s.charCodeAt(this.i);
+            if (ch === GT || ch === SLASH)
                 return;
             const key = this.readName();
             this.skipWhitespace();
-            this.expect("=");
+            this.expectChar(EQ, "=");
+            this.skipWhitespace();
+            attrs[key] = this.readAttrValue();
+        }
+    }
+    /** Like readAttributes, but validates only; nothing is built. */
+    skipAttributes() {
+        const s = this.s;
+        while (this.i < this.n) {
+            this.skipWhitespace();
+            const ch = s.charCodeAt(this.i);
+            if (ch === GT || ch === SLASH)
+                return;
+            this.skipName();
+            this.skipWhitespace();
+            this.expectChar(EQ, "=");
             this.skipWhitespace();
-            const value = this.readAttrValue();
-            attrs[key] = value;
+            const quote = s.charCodeAt(this.i);
+            if (quote !== DQUOTE && quote !== SQUOTE) {
+                throw new Error(`Expected quote at position ${this.i}`);
+            }
+            this.i++;
+            const end = s.indexOf(quote === DQUOTE ? '"' : "'", this.i);
+            this.i = end === -1 ? this.n + 1 : end + 1;
         }
     }
     readAttrValue() {
-        const quote = this.s[this.i];
-        if (quote !== '"' && quote !== "'") {
+        const quote = this.s.charCodeAt(this.i);
+        if (quote !== DQUOTE && quote !== SQUOTE) {
             throw new Error(`Expected quote at position ${this.i}`);
         }
         this.i++;
         const start = this.i;
-        while (this.i < this.s.length && this.s[this.i] !== quote) {
-            this.i++;
+        let end = this.s.indexOf(quote === DQUOTE ? '"' : "'", start);
+        if (end === -1)
+            end = this.n;
+        this.i = end + 1; // skip closing quote
+        return this.slice(start, end);
+    }
+    /**
+     * Substring with entities decoded. Values rarely contain "&", so instead of
+     * scanning each one, the position of the next "&" is remembered and only
+     * refreshed once the scan has moved past it.
+     */
+    slice(start, end) {
+        let amp = this.nextAmp;
+        if (amp !== -1 && amp < start) {
+            amp = this.s.indexOf("&", start);
+            this.nextAmp = amp;
         }
-        const value = this.s.substring(start, this.i);
-        this.i++; // skip closing quote
-        return decodeXmlEntities(value);
+        const value = this.s.substring(start, end);
+        return amp !== -1 && amp < end ? decodeXmlEntities(value) : value;
     }
     readText() {
         const start = this.i;
-        while (this.i < this.s.length && this.s[this.i] !== "<") {
-            this.i++;
-        }
-        return decodeXmlEntities(this.s.substring(start, this.i));
+        let end = this.s.indexOf("<", start);
+        if (end === -1)
+            end = this.n;
+        this.i = end;
+        return this.slice(start, end);
+    }
+    skipText() {
+        const end = this.s.indexOf("<", this.i);
+        this.i = end === -1 ? this.n : end;
+    }
+    skipCData() {
+        const end = this.s.indexOf("]]>", this.i + 9);
+        if (end === -1)
+            throw new Error("Unterminated CDATA section");
+        this.i = end + 3;
     }
     readName() {
         const start = this.i;
-        while (this.i < this.s.length) {
-            const c = this.s[this.i];
-            if (c === " " ||
-                c === "\t" ||
-                c === "\n" ||
-                c === "\r" ||
-                c === ">" ||
-                c === "/" ||
-                c === "=")
+        this.skipName();
+        return this.s.substring(start, this.i);
+    }
+    /** Advance past a name, recording the position of its first ":" in `colon`. */
+    skipName() {
+        const s = this.s;
+        let i = this.i;
+        let colon = -1;
+        while (i < this.n) {
+            const c = s.charCodeAt(i);
+            if (c === SPACE || c === TAB || c === LF || c === CR || c === GT || c === SLASH || c === EQ)
                 break;
-            this.i++;
+            if (c === COLON && colon === -1)
+                colon = i;
+            i++;
         }
-        return this.s.substring(start, this.i);
+        this.colon = colon;
+        this.i = i;
     }
     readCData() {
         this.i += 9; // skip <![CDATA[
@@ -161,65 +383,68 @@ class XmlReader {
     skipPi() {
         this.i += 2; // skip <?
         const end = this.s.indexOf("?>", this.i);
-        this.i = end === -1 ? this.s.length : end + 2;
+        this.i = end === -1 ? this.n : end + 2;
     }
     skipComment() {
         this.i += 4; // skip <!--
         const end = this.s.indexOf("-->", this.i);
-        this.i = end === -1 ? this.s.length : end + 3;
+        this.i = end === -1 ? this.n : end + 3;
     }
     skipBang() {
         // Skip <!DOCTYPE ...> and similar
         this.i += 2;
         let depth = 1;
-        while (this.i < this.s.length && depth > 0) {
-            if (this.s[this.i] === "<")
+        while (this.i < this.n && depth > 0) {
+            const c = this.s.charCodeAt(this.i);
+            if (c === LT)
                 depth++;
-            else if (this.s[this.i] === ">")
+            else if (c === GT)
                 depth--;
             this.i++;
         }
     }
     skipWhitespace() {
-        while (this.i < this.s.length) {
-            const c = this.s[this.i];
-            if (c !== " " && c !== "\t" && c !== "\n" && c !== "\r")
+        const s = this.s;
+        let i = this.i;
+        while (i < this.n) {
+            const c = s.charCodeAt(i);
+            if (c !== SPACE && c !== TAB && c !== LF && c !== CR)
                 break;
-            this.i++;
+            i++;
         }
+        this.i = i;
     }
-    expect(str) {
-        if (!this.s.startsWith(str, this.i)) {
-            throw new Error(`Expected "${str}" at position ${this.i}`);
+    expectChar(code, shown) {
+        if (this.s.charCodeAt(this.i) !== code) {
+            throw new Error(`Expected "${shown}" at position ${this.i}`);
         }
-        this.i += str.length;
-    }
-    startsWith(prefix) {
-        return this.s.startsWith(prefix, this.i);
+        this.i++;
     }
 }
 // ---------------------------------------------------------------------------
 // Entity helpers
 // ---------------------------------------------------------------------------
+const ENTITY_RE = /&(?:amp|lt|gt|quot|apos|#x[0-9a-fA-F]+|#[0-9]+);/g;
+function decodeEntity(m) {
+    if (m === "&amp;")
+        return "&";
+    if (m === "&lt;")
+        return "<";
+    if (m === "&gt;")
+        return ">";
+    if (m === "&quot;")
+        return '"';
+    if (m === "&apos;")
+        return "'";
+    if (m.startsWith("&#x"))
+        return String.fromCodePoint(Number.parseInt(m.slice(3, -1), 16));
+    return String.fromCodePoint(Number.parseInt(m.slice(2, -1), 10));
+}
 /** Decode XML predefined and numeric character entities in a string. */
 function decodeXmlEntities(s) {
     if (!s.includes("&"))
         return s;
-    return s.replace(/&(?:amp|lt|gt|quot|apos|#x[0-9a-fA-F]+|#[0-9]+);/g, (m) => {
-        if (m === "&amp;")
-            return "&";
-        if (m === "&lt;")
-            return "<";
-        if (m === "&gt;")
-            return ">";
-        if (m === "&quot;")
-            return '"';
-        if (m === "&apos;")
-            return "'";
-        if (m.startsWith("&#x"))
-            return String.fromCodePoint(Number.parseInt(m.slice(3, -1), 16));
-        return String.fromCodePoint(Number.parseInt(m.slice(2, -1), 10));
-    });
+    return s.replace(ENTITY_RE, decodeEntity);
 }
 // ---------------------------------------------------------------------------
 // Serializer
@@ -229,48 +454,74 @@ function decodeXmlEntities(s) {
  * Produces a well-formed XML document with declaration.
  */
 export function serializeXml(element) {
-    const parts = ['<?xml version="1.0" encoding="UTF-8"?>\n'];
-    writeElement(parts, element, 0);
-    parts.push("\n");
-    return parts.join("");
+    return `<?xml version="1.0" encoding="UTF-8"?>\n${writeElement(element, 0)}\n`;
 }
-function writeElement(parts, el, depth) {
-    const indent = "  ".repeat(depth);
-    parts.push(indent, "<", el.name);
-    for (const [key, value] of Object.entries(el.attributes)) {
+/** Indentation strings by depth, built once and reused across documents. */
+const INDENTS = [];
+function indentFor(depth) {
+    let s = INDENTS[depth];
+    if (s === undefined) {
+        s = "  ".repeat(depth);
+        INDENTS[depth] = s;
+    }
+    return s;
+}
+function writeElement(el, depth) {
+    const indent = indentFor(depth);
+    let out = `${indent}<${el.name}`;
+    const attributes = el.attributes;
+    for (const key in attributes) {
+        const value = attributes[key];
         // el.attributes is typed Record<string, string>, but content built from
         // generated/untyped code can leave a value undefined at runtime — skip
         // rather than crash the whole serialization on one bad attribute.
         if (typeof value !== "string")
             continue;
-        parts.push(" ", key, '="', escapeAttr(value), '"');
+        out += ` ${key}="${escapeAttr(value)}"`;
     }
-    const hasChildren = el.children.length > 0;
+    const children = el.children;
+    const hasChildren = children.length > 0;
     const hasText = el.text !== undefined;
-    if (!hasChildren && !hasText) {
-        parts.push("/>\n");
-        return;
-    }
-    parts.push(">");
-    if (hasText) {
-        parts.push(escapeText(el.text));
-    }
+    if (!hasChildren && !hasText)
+        return `${out}/>\n`;
+    out += ">";
+    if (hasText)
+        out += escapeText(el.text);
     if (hasChildren) {
-        parts.push("\n");
-        for (const child of el.children) {
-            writeElement(parts, child, depth + 1);
-        }
-        parts.push(indent);
+        out += "\n";
+        for (const child of children)
+            out += writeElement(child, depth + 1);
+        out += indent;
     }
-    parts.push("</", el.name, ">\n");
+    return `${out}</${el.name}>\n`;
+}
+// One regex test decides whether a value needs escaping at all; most do not,
+// and the ones that do are rewritten in a single pass instead of six.
+const ATTR_ESCAPE_RE = /[&<"\n\r\t]/;
+const ATTR_ESCAPE_ALL_RE = /[&<"\n\r\t]/g;
+const TEXT_ESCAPE_RE = /[&<>]/;
+const TEXT_ESCAPE_ALL_RE = /[&<>]/g;
+const ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    // Whitespace that XML parsers would normalize in attribute values.
+    "\n": "&#10;",
+    "\r": "&#13;",
+    "\t": "&#9;",
+};
+function escapeChar(ch) {
+    return ESCAPES[ch] ?? ch;
 }
 function escapeAttr(value) {
-    let s = value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll('"', "&quot;");
-    // Re-encode whitespace that XML parsers would normalize in attribute values
-    s = s.replaceAll("\n", "&#10;").replaceAll("\r", "&#13;").replaceAll("\t", "&#9;");
-    return s;
+    if (!ATTR_ESCAPE_RE.test(value))
+        return value;
+    return value.replace(ATTR_ESCAPE_ALL_RE, escapeChar);
 }
 function escapeText(value) {
-    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+    if (!TEXT_ESCAPE_RE.test(value))
+        return value;
+    return value.replace(TEXT_ESCAPE_ALL_RE, escapeChar);
 }
 //# sourceMappingURL=xml-parser.js.map