@bpmnkit/core 0.1.1 → 0.2.0

package/dist/bpmn/bpmn-parser.js

@@ -1,40 +1,34 @@
 import { ParseError } from "../errors.js";
-import { parseXml } from "../xml/xml-parser.js";
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
+import { Visit, scanXml } from "../xml/xml-parser.js";
 function localName(name) {
     const idx = name.indexOf(":");
     return idx >= 0 ? name.slice(idx + 1) : name;
 }
-function findChildren(element, tagLocalName) {
-    return element.children.filter((c) => localName(c.name) === tagLocalName);
-}
-function findChild(element, tagLocalName) {
-    return element.children.find((c) => localName(c.name) === tagLocalName);
+/** True when `qname` is `local` or `<prefix>:<local>` — without slicing a new string. */
+function hasLocalName(qname, local) {
+    const idx = qname.indexOf(":");
+    if (idx < 0)
+        return qname === local;
+    return qname.length - idx - 1 === local.length && qname.endsWith(local);
 }
-function attr(element, name) {
-    if (element.attributes[name] !== undefined)
-        return element.attributes[name];
-    for (const [key, value] of Object.entries(element.attributes)) {
-        if (localName(key) === name)
-            return value;
+function attr(attributes, name) {
+    const direct = attributes[name];
+    if (direct !== undefined)
+        return direct;
+    // Fall back to a namespace-qualified spelling of the same attribute.
+    for (const key in attributes) {
+        if (key.length > name.length && hasLocalName(key, name))
+            return attributes[key];
     }
     return undefined;
 }
-function requiredAttr(element, name) {
-    const value = attr(element, name);
+function requiredAttr(attributes, name, elementName) {
+    const value = attr(attributes, name);
     if (value === undefined) {
-        throw new ParseError(`Missing required attribute "${name}" on <${element.name}>`);
+        throw new ParseError(`Missing required attribute "${name}" on <${elementName}>`);
     }
     return value;
 }
-/** Collect text from child <bpmn:incoming> / <bpmn:outgoing> elements. */
-function collectFlowRefs(element, tag) {
-    return findChildren(element, tag)
-        .map((c) => c.text?.trim())
-        .filter((t) => !!t);
-}
 /** Known attribute names on flow nodes — everything else goes to unknownAttributes. */
 const KNOWN_ATTRS = new Set([
     "id",
@@ -59,22 +53,23 @@ const KNOWN_ATTRS = new Set([
     "exporter",
     "exporterVersion",
     "processRef",
+    "messageRef",
     "dataObjectRef",
     "dataStoreRef",
     "isCollection",
     "categoryValueRef",
 ]);
 /** Extract unknown (namespace-qualified) attributes from an element. */
-function unknownAttrs(element) {
+function unknownAttrs(attributes) {
     const result = {};
-    for (const [key, value] of Object.entries(element.attributes)) {
-        if (key.startsWith("xmlns:") || key === "xmlns")
-            continue;
+    for (const key in attributes) {
         if (KNOWN_ATTRS.has(key))
             continue;
-        if (KNOWN_ATTRS.has(localName(key)))
+        if (key.startsWith("xmlns:") || key === "xmlns")
+            continue;
+        if (key.includes(":") && KNOWN_ATTRS.has(localName(key)))
             continue;
-        result[key] = value;
+        result[key] = attributes[key];
     }
     return result;
 }
@@ -129,114 +124,298 @@ const KNOWN_PROCESS_CHILDREN = new Set([
     "extensionElements",
 ]);
 // ---------------------------------------------------------------------------
-// Extension elements
+// Streaming model builder
+//
+// The document is scanned once. Each known element gets a small frame that
+// keeps only what the model needs and builds the model object at the end tag,
+// in the same field order the former tree walk produced. Unknown children are
+// skipped by the scanner without any allocation; only the content of
+// <extensionElements> is still materialised as XmlElement trees, because the
+// model keeps it verbatim.
 // ---------------------------------------------------------------------------
-function parseExtensionElements(element) {
-    const ext = findChild(element, "extensionElements");
-    return ext ? ext.children : [];
+/** One element's handler while the scanner is inside it. */
+class Frame {
+    /** Whether this frame reads character data; the scanner skips it otherwise. */
+    wantsText = false;
+    /** A child start tag: the frame for it, or null to skip its whole subtree. */
+    child(_local, _name, _attrs) {
+        return null;
+    }
+    /** Character data directly inside this element. */
+    text(_text) { }
 }
-// ---------------------------------------------------------------------------
-// Event definitions
-// ---------------------------------------------------------------------------
-function parseEventDefinitions(element) {
-    const defs = [];
-    for (const child of element.children) {
-        const ln = localName(child.name);
-        if (ln === "timerEventDefinition") {
-            const durationEl = findChild(child, "timeDuration");
-            const dateEl = findChild(child, "timeDate");
-            const cycleEl = findChild(child, "timeCycle");
-            defs.push({
-                type: "timer",
-                id: attr(child, "id"),
-                timeDuration: durationEl?.text?.trim(),
-                timeDurationAttributes: durationEl
-                    ? Object.keys(durationEl.attributes).length > 0
-                        ? { ...durationEl.attributes }
-                        : undefined
-                    : undefined,
-                timeDate: dateEl?.text?.trim(),
-                timeDateAttributes: dateEl
-                    ? Object.keys(dateEl.attributes).length > 0
-                        ? { ...dateEl.attributes }
-                        : undefined
-                    : undefined,
-                timeCycle: cycleEl?.text?.trim(),
-                timeCycleAttributes: cycleEl
-                    ? Object.keys(cycleEl.attributes).length > 0
-                        ? { ...cycleEl.attributes }
-                        : undefined
-                    : undefined,
-            });
-        }
-        else if (ln === "errorEventDefinition") {
-            defs.push({
-                type: "error",
-                id: attr(child, "id"),
-                errorRef: attr(child, "errorRef"),
-            });
-        }
-        else if (ln === "escalationEventDefinition") {
-            defs.push({
-                type: "escalation",
-                id: attr(child, "id"),
-                escalationRef: attr(child, "escalationRef"),
-            });
-        }
-        else if (ln === "messageEventDefinition") {
-            defs.push({
-                type: "message",
-                id: attr(child, "id"),
-                messageRef: attr(child, "messageRef"),
-            });
-        }
-        else if (ln === "signalEventDefinition") {
-            defs.push({
-                type: "signal",
-                id: attr(child, "id"),
-                signalRef: attr(child, "signalRef"),
-            });
-        }
-        else if (ln === "conditionalEventDefinition") {
-            const condEl = findChild(child, "condition");
-            defs.push({
-                type: "conditional",
-                id: attr(child, "id"),
-                condition: condEl?.text?.trim(),
-            });
-        }
-        else if (ln === "linkEventDefinition") {
-            defs.push({
-                type: "link",
-                id: attr(child, "id"),
-                name: attr(child, "name"),
-            });
-        }
-        else if (ln === "cancelEventDefinition") {
-            defs.push({ type: "cancel", id: attr(child, "id") });
+// Which text-bearing child a TextFrame reports back to its owner.
+const SLOT_INCOMING = 0;
+const SLOT_OUTGOING = 1;
+const SLOT_DOCUMENTATION = 2;
+const SLOT_FLOW_NODE_REF = 3;
+const SLOT_TEXT = 4;
+const SLOT_CONDITION_EXPRESSION = 5;
+const SLOT_COMPLETION_CONDITION = 6;
+const SLOT_TIME_DURATION = 7;
+const SLOT_TIME_DATE = 8;
+const SLOT_TIME_CYCLE = 9;
+const SLOT_CONDITION = 10;
+const SLOT_LOOP_CARDINALITY = 13;
+/** Collects the direct character data of a leaf element; its children are skipped. */
+class TextFrame extends Frame {
+    owner;
+    slot;
+    attrs;
+    wantsText = true;
+    value;
+    constructor(owner, slot, attrs) {
+        super();
+        this.owner = owner;
+        this.slot = slot;
+        this.attrs = attrs;
+    }
+    text(text) {
+        this.value = this.value === undefined ? text : this.value + text;
+    }
+    finish() {
+        this.owner.setText(this.slot, this.value, this.attrs);
+    }
+}
+/** Materialises the children of an <extensionElements> as XmlElement trees. */
+class TreeFrame extends Frame {
+    target;
+    owner;
+    wantsText = true;
+    stack = [];
+    /**
+     * @param target - Where top-level children are appended.
+     * @param owner - Element receiving character data directly inside it, when
+     *   the frame stands for an element rather than a bare child list.
+     */
+    constructor(target, owner) {
+        super();
+        this.target = target;
+        this.owner = owner;
+    }
+    child(_local, name, attrs) {
+        const el = { name, attributes: attrs, children: [] };
+        const parent = this.stack[this.stack.length - 1];
+        if (parent)
+            parent.children.push(el);
+        else
+            this.target.push(el);
+        this.stack.push(el);
+        return this;
+    }
+    text(text) {
+        const el = this.stack[this.stack.length - 1] ?? this.owner;
+        if (el)
+            el.text = el.text === undefined ? text : el.text + text;
+    }
+    finish() {
+        dropLayoutWhitespace(this.stack.pop() ?? this.owner);
+    }
+}
+/**
+ * Clears an element's text when it is only the indentation between its child
+ * elements. Without this, re-serialising a nested extension or captured subtree
+ * re-emits that indentation as content and it grows on every round trip.
+ */
+function dropLayoutWhitespace(element) {
+    if (element === undefined)
+        return;
+    if (element.children.length > 0 && element.text !== undefined && element.text.trim() === "") {
+        element.text = undefined;
+    }
+}
+/**
+ * Shared handling of the two children every BPMN base element may have.
+ *
+ * Subclasses call {@link baseChild} first and fall through to their own cases,
+ * and read {@link baseFields} when building their model object. Frames that
+ * also collect text children override {@link baseText}.
+ */
+class BaseElementFrame extends Frame {
+    documentation;
+    documentationSeen = false;
+    extensions = null;
+    /** A base child's frame, or `undefined` when `local` is not one. */
+    baseChild(local, attrs) {
+        switch (local) {
+            case "documentation":
+                if (this.documentationSeen)
+                    return null;
+                this.documentationSeen = true;
+                return new TextFrame(this, SLOT_DOCUMENTATION, attrs);
+            case "extensionElements":
+                if (this.extensions !== null)
+                    return null;
+                this.extensions = [];
+                return new TreeFrame(this.extensions);
+            default:
+                return undefined;
         }
-        else if (ln === "terminateEventDefinition") {
-            defs.push({ type: "terminate", id: attr(child, "id") });
+    }
+    /** Only defined keys, so model objects keep the shape they had before. */
+    baseFields() {
+        const fields = {};
+        if (this.documentation !== undefined)
+            fields.documentation = this.documentation;
+        if (this.extensions !== null && this.extensions.length > 0) {
+            fields.extensionElements = this.extensions;
         }
-        else if (ln === "compensateEventDefinition") {
-            defs.push({
-                type: "compensate",
-                id: attr(child, "id"),
-                activityRef: attr(child, "activityRef"),
-            });
+        return fields;
+    }
+    setText(slot, text, attrs) {
+        if (slot === SLOT_DOCUMENTATION) {
+            this.documentation = text;
+            return;
         }
+        this.baseText(slot, text, attrs);
+    }
+    /** Text children other than `documentation`. */
+    baseText(_slot, _text, _attrs) { }
+}
+/**
+ * Captures an unrecognised child subtree verbatim so a round trip does not
+ * discard it.
+ *
+ * Only ever called from a frame's `default:` branch — the path that means "this
+ * element is not part of the model". Children a frame recognises but chooses
+ * not to store (a second `documentation`, a loop on a type that cannot loop)
+ * keep returning `null`, so nothing is captured twice.
+ */
+function captureUnknown(target, name, attrs) {
+    const element = { name, attributes: attrs, children: [] };
+    target.push(element);
+    return new TreeFrame(element.children, element);
+}
+/**
+ * A frame for an element whose only children are `documentation` and
+ * `extensionElements`; everything else it needs comes from its attributes.
+ */
+class BaseOnlyFrame extends BaseElementFrame {
+    attrs;
+    build;
+    target;
+    constructor(attrs, build, target) {
+        super();
+        this.attrs = attrs;
+        this.build = build;
+        this.target = target;
+    }
+    child(local, _name, attrs) {
+        return this.baseChild(local, attrs) ?? null;
+    }
+    finish() {
+        this.target.push(this.build(this.attrs, this.baseFields()));
     }
-    return defs;
 }
 // ---------------------------------------------------------------------------
-// Multi-instance loop
+// Attribute-only elements
 // ---------------------------------------------------------------------------
-function parseLoopCharacteristics(element) {
-    const loopEl = findChild(element, "multiInstanceLoopCharacteristics");
-    if (!loopEl)
-        return undefined;
-    const isSequential = loopEl.attributes.isSequential === "true" ? true : undefined;
-    return { isSequential, extensionElements: parseExtensionElements(loopEl) };
+function parseAssociation(name, attrs, base = {}) {
+    return {
+        id: requiredAttr(attrs, "id", name),
+        sourceRef: requiredAttr(attrs, "sourceRef", name),
+        targetRef: requiredAttr(attrs, "targetRef", name),
+        associationDirection: attr(attrs, "associationDirection"),
+        ...base,
+        unknownAttributes: unknownAttrs(attrs),
+    };
+}
+function parseGroup(name, attrs, base = {}) {
+    return {
+        id: requiredAttr(attrs, "id", name),
+        categoryValueRef: attr(attrs, "categoryValueRef"),
+        ...base,
+        unknownAttributes: unknownAttrs(attrs),
+    };
+}
+function parseParticipant(name, attrs, base = {}) {
+    return {
+        id: requiredAttr(attrs, "id", name),
+        name: attr(attrs, "name"),
+        processRef: attr(attrs, "processRef"),
+        ...base,
+        unknownAttributes: unknownAttrs(attrs),
+    };
+}
+function parseMessageFlow(name, attrs, base = {}) {
+    return {
+        id: requiredAttr(attrs, "id", name),
+        name: attr(attrs, "name"),
+        sourceRef: requiredAttr(attrs, "sourceRef", name),
+        targetRef: requiredAttr(attrs, "targetRef", name),
+        messageRef: attr(attrs, "messageRef"),
+        ...base,
+        unknownAttributes: unknownAttrs(attrs),
+    };
+}
+function parseError(name, attrs, base = {}) {
+    return {
+        id: requiredAttr(attrs, "id", name),
+        name: attr(attrs, "name"),
+        errorCode: attr(attrs, "errorCode"),
+        ...base,
+        unknownAttributes: unknownAttrs(attrs),
+    };
+}
+function parseEscalation(name, attrs, base = {}) {
+    return {
+        id: requiredAttr(attrs, "id", name),
+        name: attr(attrs, "name"),
+        escalationCode: attr(attrs, "escalationCode"),
+        ...base,
+        unknownAttributes: unknownAttrs(attrs),
+    };
+}
+function parseMessage(name, attrs, base = {}) {
+    return {
+        id: requiredAttr(attrs, "id", name),
+        name: attr(attrs, "name"),
+        ...base,
+        unknownAttributes: unknownAttrs(attrs),
+    };
+}
+function parseSignal(name, attrs, base = {}) {
+    return {
+        id: requiredAttr(attrs, "id", name),
+        name: attr(attrs, "name"),
+        ...base,
+        unknownAttributes: unknownAttrs(attrs),
+    };
+}
+function parseBounds(attrs) {
+    return {
+        x: Number(attr(attrs, "x") ?? "0"),
+        y: Number(attr(attrs, "y") ?? "0"),
+        width: Number(attr(attrs, "width") ?? "0"),
+        height: Number(attr(attrs, "height") ?? "0"),
+    };
+}
+function newContents() {
+    return { flowElements: [], sequenceFlows: [], textAnnotations: [], associations: [], groups: [] };
+}
+/**
+ * A frame for a child of a flow-element container.
+ *
+ * Returns `null` when the child is recognised but needs no frame, and
+ * `undefined` when it is not part of the model — the caller keeps the latter
+ * verbatim, so the two cases must stay distinct.
+ */
+function contentsChild(contents, local, name, attrs) {
+    if (FLOW_ELEMENT_TYPES.has(local)) {
+        return new FlowNodeFrame(local, name, attrs, contents);
+    }
+    switch (local) {
+        case "sequenceFlow":
+            return new SequenceFlowFrame(name, attrs, contents);
+        case "textAnnotation":
+            return new TextAnnotationFrame(name, attrs, contents.textAnnotations);
+        case "association":
+            return new BaseOnlyFrame(attrs, (a, base) => parseAssociation(name, a, base), contents.associations);
+        case "group":
+            return new BaseOnlyFrame(attrs, (a, base) => parseGroup(name, a, base), contents.groups);
+        default:
+            return undefined;
+    }
 }
 // ---------------------------------------------------------------------------
 // Flow elements
@@ -269,444 +448,1158 @@ const FLOW_ELEMENT_TYPES = new Set([
     "dataObjectReference",
     "dataStoreReference",
 ]);
-function parseFlowElement(element) {
-    const ln = localName(element.name);
-    if (!FLOW_ELEMENT_TYPES.has(ln))
-        return undefined;
-    const base = {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        incoming: collectFlowRefs(element, "incoming"),
-        outgoing: collectFlowRefs(element, "outgoing"),
-        documentation: findChild(element, "documentation")?.text,
-        extensionElements: parseExtensionElements(element),
-        unknownAttributes: unknownAttrs(element),
-    };
-    switch (ln) {
-        case "startEvent": {
-            const isInterruptingAttr = attr(element, "isInterrupting");
-            return {
-                ...base,
-                type: "startEvent",
-                eventDefinitions: parseEventDefinitions(element),
-                ...(isInterruptingAttr === "false" ? { isInterrupting: false } : {}),
-            };
+const EVENT_TYPES = new Set([
+    "startEvent",
+    "endEvent",
+    "intermediateCatchEvent",
+    "intermediateThrowEvent",
+    "boundaryEvent",
+]);
+/** Types whose <multiInstanceLoopCharacteristics> child is read. */
+const LOOP_TYPES = new Set([
+    "task",
+    "serviceTask",
+    "scriptTask",
+    "userTask",
+    "businessRuleTask",
+    "manualTask",
+    "callActivity",
+    "sendTask",
+    "receiveTask",
+    "adHocSubProcess",
+    "subProcess",
+    "transaction",
+]);
+const CONTAINER_TYPES = new Set([
+    "adHocSubProcess",
+    "subProcess",
+    "eventSubProcess",
+    "transaction",
+]);
+const EVENT_DEFINITION_TYPES = new Set([
+    "timerEventDefinition",
+    "errorEventDefinition",
+    "escalationEventDefinition",
+    "messageEventDefinition",
+    "signalEventDefinition",
+    "conditionalEventDefinition",
+    "linkEventDefinition",
+    "cancelEventDefinition",
+    "terminateEventDefinition",
+    "compensateEventDefinition",
+]);
+class FlowNodeFrame extends Frame {
+    type;
+    name;
+    attrs;
+    target;
+    id;
+    incoming = [];
+    outgoing = [];
+    documentation;
+    documentationSeen = false;
+    extensionElements = null;
+    eventDefinitions;
+    loopCharacteristics;
+    loopSeen = false;
+    completionCondition;
+    completionSeen = false;
+    unknownChildren = [];
+    properties = [];
+    dataInputAssociations = [];
+    dataOutputAssociations = [];
+    contents;
+    constructor(type, name, attrs, target) {
+        super();
+        this.type = type;
+        this.name = name;
+        this.attrs = attrs;
+        this.target = target;
+        this.id = requiredAttr(attrs, "id", name);
+        this.eventDefinitions = EVENT_TYPES.has(type) ? [] : null;
+        this.contents = CONTAINER_TYPES.has(type) ? newContents() : null;
+    }
+    child(local, name, attrs) {
+        switch (local) {
+            case "incoming":
+                return new TextFrame(this, SLOT_INCOMING, attrs);
+            case "outgoing":
+                return new TextFrame(this, SLOT_OUTGOING, attrs);
+            case "documentation":
+                if (this.documentationSeen)
+                    return null;
+                this.documentationSeen = true;
+                return new TextFrame(this, SLOT_DOCUMENTATION, attrs);
+            case "extensionElements":
+                if (this.extensionElements !== null)
+                    return null;
+                this.extensionElements = [];
+                return new TreeFrame(this.extensionElements);
+            case "multiInstanceLoopCharacteristics":
+                if (!LOOP_TYPES.has(this.type) || this.loopSeen)
+                    return null;
+                this.loopSeen = true;
+                return new LoopFrame(attrs, this);
+            case "completionCondition":
+                if (this.type !== "adHocSubProcess" || this.completionSeen)
+                    return null;
+                this.completionSeen = true;
+                return new TextFrame(this, SLOT_COMPLETION_CONDITION, attrs);
+            case "property":
+                this.properties.push({
+                    id: attr(attrs, "id"),
+                    name: attr(attrs, "name"),
+                    itemSubjectRef: attr(attrs, "itemSubjectRef"),
+                    unknownAttributes: unknownAttrs(attrs),
+                });
+                return null;
+            case "dataInputAssociation":
+                return new DataAssociationFrame(attrs, this.dataInputAssociations);
+            case "dataOutputAssociation":
+                return new DataAssociationFrame(attrs, this.dataOutputAssociations);
+            default:
+                break;
         }
-        case "endEvent":
-        case "intermediateCatchEvent":
-        case "intermediateThrowEvent":
-            return { ...base, type: ln, eventDefinitions: parseEventDefinitions(element) };
-        case "boundaryEvent":
-            return {
-                ...base,
-                type: "boundaryEvent",
-                attachedToRef: requiredAttr(element, "attachedToRef"),
-                cancelActivity: attr(element, "cancelActivity") !== undefined
-                    ? attr(element, "cancelActivity") === "true"
-                    : undefined,
-                eventDefinitions: parseEventDefinitions(element),
-            };
-        case "task":
-        case "serviceTask":
-        case "scriptTask":
-        case "userTask":
-        case "businessRuleTask":
-        case "manualTask":
-        case "callActivity":
-            return {
-                ...base,
-                type: ln,
-                loopCharacteristics: parseLoopCharacteristics(element),
-                isForCompensation: attr(element, "isForCompensation") === "true" ? true : undefined,
-            };
-        case "sendTask":
-        case "receiveTask":
-            return {
-                ...base,
-                type: ln,
-                messageRef: attr(element, "messageRef"),
-                loopCharacteristics: parseLoopCharacteristics(element),
-                isForCompensation: attr(element, "isForCompensation") === "true" ? true : undefined,
-            };
-        case "adHocSubProcess":
-            return {
-                ...base,
-                type: "adHocSubProcess",
-                loopCharacteristics: parseLoopCharacteristics(element),
-                ...parseProcessContents(element),
-            };
-        case "subProcess":
-            return {
-                ...base,
-                type: "subProcess",
-                triggeredByEvent: attr(element, "triggeredByEvent") !== undefined
-                    ? attr(element, "triggeredByEvent") === "true"
-                    : undefined,
-                loopCharacteristics: parseLoopCharacteristics(element),
-                ...parseProcessContents(element),
-            };
-        case "eventSubProcess":
-            return {
-                ...base,
-                type: "eventSubProcess",
-                ...parseProcessContents(element),
-            };
-        case "transaction":
-            return {
-                ...base,
-                type: "transaction",
-                loopCharacteristics: parseLoopCharacteristics(element),
-                ...parseProcessContents(element),
-            };
-        case "exclusiveGateway":
-            return { ...base, type: "exclusiveGateway", default: attr(element, "default") };
-        case "parallelGateway":
-            return { ...base, type: "parallelGateway" };
-        case "inclusiveGateway":
-            return { ...base, type: "inclusiveGateway", default: attr(element, "default") };
-        case "eventBasedGateway":
-            return { ...base, type: "eventBasedGateway" };
-        case "complexGateway":
-            return { ...base, type: "complexGateway", default: attr(element, "default") };
-        case "dataObject":
-            return {
-                ...base,
-                type: "dataObject",
-                ...(attr(element, "isCollection") === "true" ? { isCollection: true } : {}),
-            };
-        case "dataObjectReference":
-            return {
-                ...base,
-                type: "dataObjectReference",
-                dataObjectRef: attr(element, "dataObjectRef"),
-                ...(attr(element, "isCollection") === "true" ? { isCollection: true } : {}),
-            };
-        case "dataStoreReference":
-            return {
-                ...base,
-                type: "dataStoreReference",
-                dataStoreRef: attr(element, "dataStoreRef"),
-            };
-        default:
-            return undefined;
+        if (this.eventDefinitions !== null && EVENT_DEFINITION_TYPES.has(local)) {
+            return eventDefinitionFrame(local, attrs, this.eventDefinitions);
+        }
+        if (this.contents !== null) {
+            const child = contentsChild(this.contents, local, name, attrs);
+            if (child !== undefined)
+                return child;
+        }
+        return captureUnknown(this.unknownChildren, name, attrs);
     }
-}
-// ---------------------------------------------------------------------------
-// Sequence flows
-// ---------------------------------------------------------------------------
-function parseSequenceFlow(element) {
-    const condEl = findChild(element, "conditionExpression");
-    let conditionExpression;
-    if (condEl) {
-        conditionExpression = {
-            text: condEl.text ?? "",
-            attributes: { ...condEl.attributes },
+    setText(slot, text, attrs) {
+        switch (slot) {
+            case SLOT_INCOMING: {
+                const ref = text?.trim();
+                if (ref)
+                    this.incoming.push(ref);
+                break;
+            }
+            case SLOT_OUTGOING: {
+                const ref = text?.trim();
+                if (ref)
+                    this.outgoing.push(ref);
+                break;
+            }
+            case SLOT_DOCUMENTATION:
+                this.documentation = text;
+                break;
+            case SLOT_COMPLETION_CONDITION:
+                this.completionCondition = { text: text ?? "", attributes: { ...attrs } };
+                break;
+            default:
+                break;
+        }
+    }
+    setLoopCharacteristics(loop) {
+        this.loopCharacteristics = loop;
+    }
+    finish() {
+        const attrs = this.attrs;
+        const base = {
+            id: this.id,
+            ...(this.properties.length > 0 ? { properties: this.properties } : {}),
+            ...(this.dataInputAssociations.length > 0
+                ? { dataInputAssociations: this.dataInputAssociations }
+                : {}),
+            ...(this.dataOutputAssociations.length > 0
+                ? { dataOutputAssociations: this.dataOutputAssociations }
+                : {}),
+            ...(this.unknownChildren.length > 0 ? { unknownChildren: this.unknownChildren } : {}),
+            name: attr(attrs, "name"),
+            incoming: this.incoming,
+            outgoing: this.outgoing,
+            documentation: this.documentation,
+            extensionElements: this.extensionElements ?? [],
+            unknownAttributes: unknownAttrs(attrs),
         };
+        const eventDefinitions = this.eventDefinitions ?? [];
+        const contents = this.contents ?? newContents();
+        const type = this.type;
+        let el;
+        switch (type) {
+            case "startEvent": {
+                const isInterruptingAttr = attr(attrs, "isInterrupting");
+                el = {
+                    ...base,
+                    type: "startEvent",
+                    eventDefinitions,
+                    ...(isInterruptingAttr === "false" ? { isInterrupting: false } : {}),
+                };
+                break;
+            }
+            case "endEvent":
+            case "intermediateCatchEvent":
+            case "intermediateThrowEvent":
+                el = { ...base, type, eventDefinitions };
+                break;
+            case "boundaryEvent":
+                el = {
+                    ...base,
+                    type: "boundaryEvent",
+                    attachedToRef: requiredAttr(attrs, "attachedToRef", this.name),
+                    cancelActivity: attr(attrs, "cancelActivity") !== undefined
+                        ? attr(attrs, "cancelActivity") === "true"
+                        : undefined,
+                    eventDefinitions,
+                };
+                break;
+            case "task":
+            case "serviceTask":
+            case "scriptTask":
+            case "userTask":
+            case "businessRuleTask":
+            case "manualTask":
+            case "callActivity":
+                el = {
+                    ...base,
+                    type,
+                    loopCharacteristics: this.loopCharacteristics,
+                    isForCompensation: attr(attrs, "isForCompensation") === "true" ? true : undefined,
+                };
+                break;
+            case "sendTask":
+            case "receiveTask":
+                el = {
+                    ...base,
+                    type,
+                    messageRef: attr(attrs, "messageRef"),
+                    loopCharacteristics: this.loopCharacteristics,
+                    isForCompensation: attr(attrs, "isForCompensation") === "true" ? true : undefined,
+                };
+                break;
+            case "adHocSubProcess":
+                el = {
+                    ...base,
+                    type: "adHocSubProcess",
+                    loopCharacteristics: this.loopCharacteristics,
+                    completionCondition: this.completionCondition,
+                    cancelRemainingInstances: attr(attrs, "cancelRemainingInstances") !== undefined
+                        ? attr(attrs, "cancelRemainingInstances") === "true"
+                        : undefined,
+                    ...contents,
+                };
+                break;
+            case "subProcess":
+                el = {
+                    ...base,
+                    type: "subProcess",
+                    triggeredByEvent: attr(attrs, "triggeredByEvent") !== undefined
+                        ? attr(attrs, "triggeredByEvent") === "true"
+                        : undefined,
+                    loopCharacteristics: this.loopCharacteristics,
+                    ...contents,
+                };
+                break;
+            case "eventSubProcess":
+                el = { ...base, type: "eventSubProcess", ...contents };
+                break;
+            case "transaction":
+                el = {
+                    ...base,
+                    type: "transaction",
+                    loopCharacteristics: this.loopCharacteristics,
+                    ...contents,
+                };
+                break;
+            case "exclusiveGateway":
+                el = { ...base, type: "exclusiveGateway", default: attr(attrs, "default") };
+                break;
+            case "parallelGateway":
+                el = { ...base, type: "parallelGateway" };
+                break;
+            case "inclusiveGateway":
+                el = { ...base, type: "inclusiveGateway", default: attr(attrs, "default") };
+                break;
+            case "eventBasedGateway":
+                el = { ...base, type: "eventBasedGateway" };
+                break;
+            case "complexGateway":
+                el = { ...base, type: "complexGateway", default: attr(attrs, "default") };
+                break;
+            case "dataObject":
+                el = {
+                    ...base,
+                    type: "dataObject",
+                    ...(attr(attrs, "isCollection") === "true" ? { isCollection: true } : {}),
+                };
+                break;
+            case "dataObjectReference":
+                el = {
+                    ...base,
+                    type: "dataObjectReference",
+                    dataObjectRef: attr(attrs, "dataObjectRef"),
+                    ...(attr(attrs, "isCollection") === "true" ? { isCollection: true } : {}),
+                };
+                break;
+            case "dataStoreReference":
+                el = {
+                    ...base,
+                    type: "dataStoreReference",
+                    dataStoreRef: attr(attrs, "dataStoreRef"),
+                };
+                break;
+            default:
+                return;
+        }
+        this.target.flowElements.push(el);
     }
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        sourceRef: requiredAttr(element, "sourceRef"),
-        targetRef: requiredAttr(element, "targetRef"),
-        conditionExpression,
-        extensionElements: parseExtensionElements(element),
-        unknownAttributes: unknownAttrs(element),
-    };
 }
 // ---------------------------------------------------------------------------
-// Annotations
+// Event definitions
 // ---------------------------------------------------------------------------
-function parseTextAnnotation(element) {
-    const textEl = findChild(element, "text");
-    return {
-        id: requiredAttr(element, "id"),
-        text: textEl?.text,
-        unknownAttributes: unknownAttrs(element),
-    };
+function eventDefinitionFrame(local, attrs, target) {
+    switch (local) {
+        case "timerEventDefinition":
+            return new TimerDefinitionFrame(attrs, target);
+        case "conditionalEventDefinition":
+            return new ConditionalDefinitionFrame(attrs, target);
+        case "errorEventDefinition":
+            target.push({ type: "error", id: attr(attrs, "id"), errorRef: attr(attrs, "errorRef") });
+            return null;
+        case "escalationEventDefinition":
+            target.push({
+                type: "escalation",
+                id: attr(attrs, "id"),
+                escalationRef: attr(attrs, "escalationRef"),
+            });
+            return null;
+        case "messageEventDefinition":
+            target.push({ type: "message", id: attr(attrs, "id"), messageRef: attr(attrs, "messageRef") });
+            return null;
+        case "signalEventDefinition":
+            target.push({ type: "signal", id: attr(attrs, "id"), signalRef: attr(attrs, "signalRef") });
+            return null;
+        case "linkEventDefinition":
+            target.push({ type: "link", id: attr(attrs, "id"), name: attr(attrs, "name") });
+            return null;
+        case "cancelEventDefinition":
+            target.push({ type: "cancel", id: attr(attrs, "id") });
+            return null;
+        case "terminateEventDefinition":
+            target.push({ type: "terminate", id: attr(attrs, "id") });
+            return null;
+        case "compensateEventDefinition":
+            target.push({
+                type: "compensate",
+                id: attr(attrs, "id"),
+                activityRef: attr(attrs, "activityRef"),
+            });
+            return null;
+        default:
+            return null;
+    }
 }
-function parseAssociation(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        sourceRef: requiredAttr(element, "sourceRef"),
-        targetRef: requiredAttr(element, "targetRef"),
-        associationDirection: attr(element, "associationDirection"),
-        unknownAttributes: unknownAttrs(element),
-    };
+class TimerDefinitionFrame extends Frame {
+    attrs;
+    target;
+    duration;
+    date;
+    cycle;
+    constructor(attrs, target) {
+        super();
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, _name, attrs) {
+        switch (local) {
+            case "timeDuration":
+                if (this.duration)
+                    return null;
+                this.duration = { text: undefined, attrs };
+                return new TextFrame(this, SLOT_TIME_DURATION, attrs);
+            case "timeDate":
+                if (this.date)
+                    return null;
+                this.date = { text: undefined, attrs };
+                return new TextFrame(this, SLOT_TIME_DATE, attrs);
+            case "timeCycle":
+                if (this.cycle)
+                    return null;
+                this.cycle = { text: undefined, attrs };
+                return new TextFrame(this, SLOT_TIME_CYCLE, attrs);
+            default:
+                return null;
+        }
+    }
+    setText(slot, text) {
+        if (slot === SLOT_TIME_DURATION && this.duration)
+            this.duration.text = text;
+        else if (slot === SLOT_TIME_DATE && this.date)
+            this.date.text = text;
+        else if (slot === SLOT_TIME_CYCLE && this.cycle)
+            this.cycle.text = text;
+    }
+    finish() {
+        this.target.push({
+            type: "timer",
+            id: attr(this.attrs, "id"),
+            timeDuration: this.duration?.text?.trim(),
+            timeDurationAttributes: partAttributes(this.duration),
+            timeDate: this.date?.text?.trim(),
+            timeDateAttributes: partAttributes(this.date),
+            timeCycle: this.cycle?.text?.trim(),
+            timeCycleAttributes: partAttributes(this.cycle),
+        });
+    }
 }
-function parseGroup(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        categoryValueRef: attr(element, "categoryValueRef"),
-        unknownAttributes: unknownAttrs(element),
-    };
+function partAttributes(part) {
+    if (!part)
+        return undefined;
+    return Object.keys(part.attrs).length > 0 ? { ...part.attrs } : undefined;
+}
+class ConditionalDefinitionFrame extends Frame {
+    attrs;
+    target;
+    conditionSeen = false;
+    condition;
+    constructor(attrs, target) {
+        super();
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, _name, attrs) {
+        if (local !== "condition" || this.conditionSeen)
+            return null;
+        this.conditionSeen = true;
+        return new TextFrame(this, SLOT_CONDITION, attrs);
+    }
+    setText(_slot, text) {
+        this.condition = text;
+    }
+    finish() {
+        this.target.push({
+            type: "conditional",
+            id: attr(this.attrs, "id"),
+            condition: this.condition?.trim(),
+        });
+    }
 }
 // ---------------------------------------------------------------------------
-// Process contents (shared between process and adHocSubProcess)
+// Multi-instance loop
 // ---------------------------------------------------------------------------
-function parseProcessContents(element) {
-    const flowElements = [];
-    const sequenceFlows = [];
-    const textAnnotations = [];
-    const associations = [];
-    const groups = [];
-    for (const child of element.children) {
-        const ln = localName(child.name);
-        if (FLOW_ELEMENT_TYPES.has(ln)) {
-            const fe = parseFlowElement(child);
-            if (fe)
-                flowElements.push(fe);
-        }
-        else if (ln === "sequenceFlow") {
-            sequenceFlows.push(parseSequenceFlow(child));
-        }
-        else if (ln === "textAnnotation") {
-            textAnnotations.push(parseTextAnnotation(child));
-        }
-        else if (ln === "association") {
-            associations.push(parseAssociation(child));
-        }
-        else if (ln === "group") {
-            groups.push(parseGroup(child));
+class LoopFrame extends Frame {
+    attrs;
+    owner;
+    unknownChildren = [];
+    extensionElements = null;
+    loopCardinality;
+    cardinalitySeen = false;
+    completionCondition;
+    completionSeen = false;
+    constructor(attrs, owner) {
+        super();
+        this.attrs = attrs;
+        this.owner = owner;
+    }
+    child(local, _name, attrs) {
+        switch (local) {
+            case "extensionElements":
+                if (this.extensionElements !== null)
+                    return null;
+                this.extensionElements = [];
+                return new TreeFrame(this.extensionElements);
+            case "loopCardinality":
+                if (this.cardinalitySeen)
+                    return null;
+                this.cardinalitySeen = true;
+                return new TextFrame(this, SLOT_LOOP_CARDINALITY, attrs);
+            case "completionCondition":
+                if (this.completionSeen)
+                    return null;
+                this.completionSeen = true;
+                return new TextFrame(this, SLOT_COMPLETION_CONDITION, attrs);
+            default:
+                return captureUnknown(this.unknownChildren, _name, attrs);
         }
     }
-    return { flowElements, sequenceFlows, textAnnotations, associations, groups };
+    setText(slot, text, attrs) {
+        const expression = { text: text ?? "", attributes: { ...attrs } };
+        if (slot === SLOT_LOOP_CARDINALITY)
+            this.loopCardinality = expression;
+        else if (slot === SLOT_COMPLETION_CONDITION)
+            this.completionCondition = expression;
+    }
+    finish() {
+        this.owner.setLoopCharacteristics({
+            isSequential: this.attrs.isSequential === "true" ? true : undefined,
+            loopCardinality: this.loopCardinality,
+            completionCondition: this.completionCondition,
+            extensionElements: this.extensionElements ?? [],
+            ...(this.unknownChildren.length > 0 ? { unknownChildren: this.unknownChildren } : {}),
+        });
+    }
 }
 // ---------------------------------------------------------------------------
-// Lanes
+// Sequence flows and annotations
 // ---------------------------------------------------------------------------
-function parseLane(element) {
-    const flowNodeRefs = findChildren(element, "flowNodeRef")
-        .map((c) => c.text?.trim())
-        .filter((t) => !!t);
-    const childLaneSetEl = findChild(element, "childLaneSet");
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        flowNodeRefs,
-        childLaneSet: childLaneSetEl ? parseLaneSet(childLaneSetEl) : undefined,
-        unknownAttributes: unknownAttrs(element),
-    };
+class SequenceFlowFrame extends Frame {
+    attrs;
+    target;
+    id;
+    sourceRef;
+    targetRef;
+    conditionExpression;
+    conditionSeen = false;
+    extensionElements = null;
+    constructor(name, attrs, target) {
+        super();
+        this.attrs = attrs;
+        this.target = target;
+        this.id = requiredAttr(attrs, "id", name);
+        this.sourceRef = requiredAttr(attrs, "sourceRef", name);
+        this.targetRef = requiredAttr(attrs, "targetRef", name);
+    }
+    child(local, _name, attrs) {
+        switch (local) {
+            case "conditionExpression":
+                if (this.conditionSeen)
+                    return null;
+                this.conditionSeen = true;
+                return new TextFrame(this, SLOT_CONDITION_EXPRESSION, attrs);
+            case "extensionElements":
+                if (this.extensionElements !== null)
+                    return null;
+                this.extensionElements = [];
+                return new TreeFrame(this.extensionElements);
+            default:
+                return null;
+        }
+    }
+    setText(_slot, text, attrs) {
+        this.conditionExpression = { text: text ?? "", attributes: { ...attrs } };
+    }
+    finish() {
+        this.target.sequenceFlows.push({
+            id: this.id,
+            name: attr(this.attrs, "name"),
+            sourceRef: this.sourceRef,
+            targetRef: this.targetRef,
+            conditionExpression: this.conditionExpression,
+            extensionElements: this.extensionElements ?? [],
+            unknownAttributes: unknownAttrs(this.attrs),
+        });
+    }
 }
-function parseLaneSet(element) {
-    return {
-        id: attr(element, "id"),
-        lanes: findChildren(element, "lane").map(parseLane),
-    };
+class TextAnnotationFrame extends BaseElementFrame {
+    name;
+    attrs;
+    target;
+    textSeen = false;
+    value;
+    constructor(name, attrs, target) {
+        super();
+        this.name = name;
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, _name, attrs) {
+        const base = this.baseChild(local, attrs);
+        if (base !== undefined)
+            return base;
+        if (local !== "text" || this.textSeen)
+            return null;
+        this.textSeen = true;
+        return new TextFrame(this, SLOT_TEXT, attrs);
+    }
+    baseText(_slot, text) {
+        this.value = text;
+    }
+    finish() {
+        this.target.push({
+            id: requiredAttr(this.attrs, "id", this.name),
+            text: this.value,
+            ...this.baseFields(),
+            unknownAttributes: unknownAttrs(this.attrs),
+        });
+    }
 }
 // ---------------------------------------------------------------------------
-// Process
+// Categories
 // ---------------------------------------------------------------------------
-function parseProcess(element) {
-    const laneSetEl = findChild(element, "laneSet");
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        isExecutable: attr(element, "isExecutable") === "true" ? true : undefined,
-        extensionElements: parseExtensionElements(element),
-        unknownAttributes: unknownAttrs(element),
-        laneSet: laneSetEl ? parseLaneSet(laneSetEl) : undefined,
-        ...parseProcessContents(element),
-    };
+/** A root `bpmn:category`; its values supply the labels groups point at. */
+class CategoryFrame extends BaseElementFrame {
+    attrs;
+    target;
+    categoryValues = [];
+    constructor(attrs, target) {
+        super();
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, _name, attrs) {
+        const base = this.baseChild(local, attrs);
+        if (base !== undefined)
+            return base;
+        if (local === "categoryValue") {
+            const id = attr(attrs, "id");
+            if (id !== undefined) {
+                this.categoryValues.push({
+                    id,
+                    value: attr(attrs, "value"),
+                    unknownAttributes: unknownAttrs(attrs),
+                });
+            }
+        }
+        return null;
+    }
+    finish() {
+        this.target.push({
+            id: attr(this.attrs, "id"),
+            name: attr(this.attrs, "name"),
+            categoryValues: this.categoryValues,
+            unknownAttributes: unknownAttrs(this.attrs),
+        });
+    }
 }
 // ---------------------------------------------------------------------------
-// Collaboration
+// Data associations
 // ---------------------------------------------------------------------------
-function parseParticipant(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        processRef: attr(element, "processRef"),
-        unknownAttributes: unknownAttrs(element),
-    };
+const SLOT_SOURCE_REF = 11;
+const SLOT_TARGET_REF = 12;
+/** A `dataInputAssociation` or `dataOutputAssociation` and its ref children. */
+class DataAssociationFrame extends BaseElementFrame {
+    attrs;
+    target;
+    sourceRefs = [];
+    unknownChildren = [];
+    targetRef;
+    constructor(attrs, target) {
+        super();
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, name, attrs) {
+        const base = this.baseChild(local, attrs);
+        if (base !== undefined)
+            return base;
+        if (local === "sourceRef")
+            return new TextFrame(this, SLOT_SOURCE_REF, attrs);
+        if (local === "targetRef")
+            return new TextFrame(this, SLOT_TARGET_REF, attrs);
+        return captureUnknown(this.unknownChildren, name, attrs);
+    }
+    baseText(slot, text) {
+        const ref = text?.trim();
+        if (!ref)
+            return;
+        if (slot === SLOT_SOURCE_REF)
+            this.sourceRefs.push(ref);
+        else if (slot === SLOT_TARGET_REF)
+            this.targetRef = ref;
+    }
+    finish() {
+        this.target.push({
+            id: attr(this.attrs, "id"),
+            sourceRefs: this.sourceRefs,
+            targetRef: this.targetRef,
+            unknownAttributes: unknownAttrs(this.attrs),
+            ...(this.unknownChildren.length > 0 ? { unknownChildren: this.unknownChildren } : {}),
+        });
+    }
 }
-function parseMessageFlow(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        sourceRef: requiredAttr(element, "sourceRef"),
-        targetRef: requiredAttr(element, "targetRef"),
-        unknownAttributes: unknownAttrs(element),
-    };
+class LaneSetFrame extends Frame {
+    attrs;
+    owner;
+    lanes = [];
+    constructor(attrs, owner) {
+        super();
+        this.attrs = attrs;
+        this.owner = owner;
+    }
+    child(local, name, attrs) {
+        return local === "lane" ? new LaneFrame(name, attrs, this.lanes) : null;
+    }
+    finish() {
+        this.owner.setLaneSet({
+            id: attr(this.attrs, "id"),
+            name: attr(this.attrs, "name"),
+            lanes: this.lanes,
+            unknownAttributes: unknownAttrs(this.attrs),
+        });
+    }
 }
-function parseCollaboration(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        participants: findChildren(element, "participant").map(parseParticipant),
-        messageFlows: findChildren(element, "messageFlow").map(parseMessageFlow),
-        textAnnotations: findChildren(element, "textAnnotation").map(parseTextAnnotation),
-        associations: findChildren(element, "association").map(parseAssociation),
-        groups: findChildren(element, "group").map(parseGroup),
-        extensionElements: parseExtensionElements(element),
-        unknownAttributes: unknownAttrs(element),
-    };
+class LaneFrame extends BaseElementFrame {
+    name;
+    attrs;
+    target;
+    flowNodeRefs = [];
+    childLaneSet;
+    childLaneSetSeen = false;
+    constructor(name, attrs, target) {
+        super();
+        this.name = name;
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, _name, attrs) {
+        const base = this.baseChild(local, attrs);
+        if (base !== undefined)
+            return base;
+        switch (local) {
+            case "flowNodeRef":
+                return new TextFrame(this, SLOT_FLOW_NODE_REF, attrs);
+            case "childLaneSet":
+                if (this.childLaneSetSeen)
+                    return null;
+                this.childLaneSetSeen = true;
+                return new LaneSetFrame(attrs, this);
+            default:
+                return null;
+        }
+    }
+    baseText(_slot, text) {
+        const ref = text?.trim();
+        if (ref)
+            this.flowNodeRefs.push(ref);
+    }
+    setLaneSet(laneSet) {
+        this.childLaneSet = laneSet;
+    }
+    finish() {
+        this.target.push({
+            id: requiredAttr(this.attrs, "id", this.name),
+            name: attr(this.attrs, "name"),
+            flowNodeRefs: this.flowNodeRefs,
+            childLaneSet: this.childLaneSet,
+            ...this.baseFields(),
+            unknownAttributes: unknownAttrs(this.attrs),
+        });
+    }
 }
 // ---------------------------------------------------------------------------
-// Root elements
+// Process
 // ---------------------------------------------------------------------------
-function parseError(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        errorCode: attr(element, "errorCode"),
-    };
-}
-function parseEscalation(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        escalationCode: attr(element, "escalationCode"),
-    };
-}
-function parseMessage(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-        unknownAttributes: unknownAttrs(element),
-    };
-}
-function parseSignal(element) {
-    return {
-        id: requiredAttr(element, "id"),
-        name: attr(element, "name"),
-    };
+class ProcessFrame extends Frame {
+    attrs;
+    target;
+    id;
+    unknownChildren = [];
+    documentation;
+    documentationSeen = false;
+    extensionElements = null;
+    laneSet;
+    laneSetSeen = false;
+    contents = newContents();
+    constructor(name, attrs, target) {
+        super();
+        this.attrs = attrs;
+        this.target = target;
+        this.id = requiredAttr(attrs, "id", name);
+    }
+    child(local, name, attrs) {
+        switch (local) {
+            case "documentation":
+                if (this.documentationSeen)
+                    return null;
+                this.documentationSeen = true;
+                return new TextFrame(this, SLOT_DOCUMENTATION, attrs);
+            case "extensionElements":
+                if (this.extensionElements !== null)
+                    return null;
+                this.extensionElements = [];
+                return new TreeFrame(this.extensionElements);
+            case "laneSet":
+                if (this.laneSetSeen)
+                    return null;
+                this.laneSetSeen = true;
+                return new LaneSetFrame(attrs, this);
+            default: {
+                const child = contentsChild(this.contents, local, name, attrs);
+                return child === undefined ? captureUnknown(this.unknownChildren, name, attrs) : child;
+            }
+        }
+    }
+    setText(slot, text) {
+        if (slot === SLOT_DOCUMENTATION)
+            this.documentation = text;
+    }
+    setLaneSet(laneSet) {
+        this.laneSet = laneSet;
+    }
+    finish() {
+        const attrs = this.attrs;
+        this.target.push({
+            id: this.id,
+            name: attr(attrs, "name"),
+            isExecutable: attr(attrs, "isExecutable") === "true" ? true : undefined,
+            ...(this.documentation !== undefined ? { documentation: this.documentation } : {}),
+            extensionElements: this.extensionElements ?? [],
+            unknownAttributes: unknownAttrs(attrs),
+            laneSet: this.laneSet,
+            ...(this.unknownChildren.length > 0 ? { unknownChildren: this.unknownChildren } : {}),
+            ...this.contents,
+        });
+    }
 }
 // ---------------------------------------------------------------------------
-// Diagram interchange
+// Collaboration
 // ---------------------------------------------------------------------------
-function parseBounds(element) {
-    return {
-        x: Number(attr(element, "x") ?? "0"),
-        y: Number(attr(element, "y") ?? "0"),
-        width: Number(attr(element, "width") ?? "0"),
-        height: Number(attr(element, "height") ?? "0"),
-    };
+class CollaborationFrame extends Frame {
+    attrs;
+    target;
+    id;
+    participants = [];
+    messageFlows = [];
+    textAnnotations = [];
+    associations = [];
+    groups = [];
+    unknownChildren = [];
+    extensionElements = null;
+    constructor(name, attrs, target) {
+        super();
+        this.attrs = attrs;
+        this.target = target;
+        this.id = requiredAttr(attrs, "id", name);
+    }
+    child(local, name, attrs) {
+        switch (local) {
+            case "participant":
+                return new BaseOnlyFrame(attrs, (a, base) => parseParticipant(name, a, base), this.participants);
+            case "messageFlow":
+                return new BaseOnlyFrame(attrs, (a, base) => parseMessageFlow(name, a, base), this.messageFlows);
+            case "textAnnotation":
+                return new TextAnnotationFrame(name, attrs, this.textAnnotations);
+            case "association":
+                return new BaseOnlyFrame(attrs, (a, base) => parseAssociation(name, a, base), this.associations);
+            case "group":
+                return new BaseOnlyFrame(attrs, (a, base) => parseGroup(name, a, base), this.groups);
+            case "extensionElements":
+                if (this.extensionElements !== null)
+                    return null;
+                this.extensionElements = [];
+                return new TreeFrame(this.extensionElements);
+            default:
+                return captureUnknown(this.unknownChildren, name, attrs);
+        }
+    }
+    finish() {
+        this.target.push({
+            id: this.id,
+            participants: this.participants,
+            messageFlows: this.messageFlows,
+            textAnnotations: this.textAnnotations,
+            associations: this.associations,
+            groups: this.groups,
+            extensionElements: this.extensionElements ?? [],
+            unknownAttributes: unknownAttrs(this.attrs),
+            ...(this.unknownChildren.length > 0 ? { unknownChildren: this.unknownChildren } : {}),
+        });
+    }
 }
-function parseLabel(element) {
-    const labelEl = findChild(element, "BPMNLabel");
-    if (!labelEl)
-        return undefined;
-    const boundsEl = findChild(labelEl, "Bounds");
-    return { bounds: boundsEl ? parseBounds(boundsEl) : undefined };
+class LabelFrame extends Frame {
+    owner;
+    bounds;
+    boundsSeen = false;
+    constructor(owner) {
+        super();
+        this.owner = owner;
+    }
+    child(local, _name, attrs) {
+        if (local === "Bounds" && !this.boundsSeen) {
+            this.boundsSeen = true;
+            this.bounds = parseBounds(attrs);
+        }
+        return null;
+    }
+    finish() {
+        this.owner.setLabel({ bounds: this.bounds });
+    }
 }
-function parseDiShape(element) {
-    const boundsEl = findChild(element, "Bounds");
-    if (!boundsEl)
-        throw new Error(`Missing <dc:Bounds> in shape "${attr(element, "id")}"`);
-    return {
-        id: requiredAttr(element, "id"),
-        bpmnElement: requiredAttr(element, "bpmnElement"),
-        isMarkerVisible: attr(element, "isMarkerVisible") !== undefined
-            ? attr(element, "isMarkerVisible") === "true"
-            : undefined,
-        isExpanded: attr(element, "isExpanded") !== undefined
-            ? attr(element, "isExpanded") === "true"
-            : undefined,
-        isHorizontal: attr(element, "isHorizontal") !== undefined
-            ? attr(element, "isHorizontal") === "true"
-            : undefined,
-        bounds: parseBounds(boundsEl),
-        label: parseLabel(element),
-        unknownAttributes: unknownAttrs(element),
-    };
+class ShapeFrame extends Frame {
+    name;
+    attrs;
+    target;
+    bounds;
+    label;
+    labelSeen = false;
+    constructor(name, attrs, target) {
+        super();
+        this.name = name;
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, _name, attrs) {
+        switch (local) {
+            case "Bounds":
+                if (this.bounds === undefined)
+                    this.bounds = parseBounds(attrs);
+                return null;
+            case "BPMNLabel":
+                if (this.labelSeen)
+                    return null;
+                this.labelSeen = true;
+                return new LabelFrame(this);
+            default:
+                return null;
+        }
+    }
+    setLabel(label) {
+        this.label = label;
+    }
+    finish() {
+        const attrs = this.attrs;
+        if (!this.bounds)
+            throw new Error(`Missing <dc:Bounds> in shape "${attr(attrs, "id")}"`);
+        this.target.push({
+            id: requiredAttr(attrs, "id", this.name),
+            bpmnElement: requiredAttr(attrs, "bpmnElement", this.name),
+            isMarkerVisible: attr(attrs, "isMarkerVisible") !== undefined
+                ? attr(attrs, "isMarkerVisible") === "true"
+                : undefined,
+            isExpanded: attr(attrs, "isExpanded") !== undefined ? attr(attrs, "isExpanded") === "true" : undefined,
+            isHorizontal: attr(attrs, "isHorizontal") !== undefined
+                ? attr(attrs, "isHorizontal") === "true"
+                : undefined,
+            bounds: this.bounds,
+            label: this.label,
+            unknownAttributes: unknownAttrs(attrs),
+        });
+    }
 }
-function parseDiEdge(element) {
-    const waypoints = findChildren(element, "waypoint").map((w) => ({
-        x: Number(attr(w, "x") ?? "0"),
-        y: Number(attr(w, "y") ?? "0"),
-    }));
-    return {
-        id: requiredAttr(element, "id"),
-        bpmnElement: requiredAttr(element, "bpmnElement"),
-        waypoints,
-        label: parseLabel(element),
-        unknownAttributes: unknownAttrs(element),
-    };
+class EdgeFrame extends Frame {
+    name;
+    attrs;
+    target;
+    waypoints = [];
+    label;
+    labelSeen = false;
+    constructor(name, attrs, target) {
+        super();
+        this.name = name;
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, _name, attrs) {
+        switch (local) {
+            case "waypoint":
+                this.waypoints.push({
+                    x: Number(attr(attrs, "x") ?? "0"),
+                    y: Number(attr(attrs, "y") ?? "0"),
+                });
+                return null;
+            case "BPMNLabel":
+                if (this.labelSeen)
+                    return null;
+                this.labelSeen = true;
+                return new LabelFrame(this);
+            default:
+                return null;
+        }
+    }
+    setLabel(label) {
+        this.label = label;
+    }
+    finish() {
+        const attrs = this.attrs;
+        this.target.push({
+            id: requiredAttr(attrs, "id", this.name),
+            bpmnElement: requiredAttr(attrs, "bpmnElement", this.name),
+            waypoints: this.waypoints,
+            label: this.label,
+            unknownAttributes: unknownAttrs(attrs),
+        });
+    }
 }
-function parseDiagram(element) {
-    const planeEl = findChild(element, "BPMNPlane");
-    if (!planeEl)
-        throw new Error("Missing <bpmndi:BPMNPlane> in diagram");
-    const shapes = [];
-    const edges = [];
-    for (const child of planeEl.children) {
-        const ln = localName(child.name);
-        if (ln === "BPMNShape")
-            shapes.push(parseDiShape(child));
-        else if (ln === "BPMNEdge")
-            edges.push(parseDiEdge(child));
+class PlaneFrame extends Frame {
+    name;
+    attrs;
+    owner;
+    shapes = [];
+    edges = [];
+    constructor(name, attrs, owner) {
+        super();
+        this.name = name;
+        this.attrs = attrs;
+        this.owner = owner;
+    }
+    child(local, name, attrs) {
+        if (local === "BPMNShape")
+            return new ShapeFrame(name, attrs, this.shapes);
+        if (local === "BPMNEdge")
+            return new EdgeFrame(name, attrs, this.edges);
+        return null;
+    }
+    finish() {
+        this.owner.setPlane(this);
+    }
+}
+class DiagramFrame extends Frame {
+    name;
+    attrs;
+    target;
+    plane;
+    planeSeen = false;
+    constructor(name, attrs, target) {
+        super();
+        this.name = name;
+        this.attrs = attrs;
+        this.target = target;
+    }
+    child(local, name, attrs) {
+        if (local !== "BPMNPlane" || this.planeSeen)
+            return null;
+        this.planeSeen = true;
+        return new PlaneFrame(name, attrs, this);
+    }
+    setPlane(plane) {
+        this.plane = plane;
+    }
+    finish() {
+        const plane = this.plane;
+        if (!plane)
+            throw new Error("Missing <bpmndi:BPMNPlane> in diagram");
+        this.target.push({
+            id: requiredAttr(this.attrs, "id", this.name),
+            plane: {
+                id: requiredAttr(plane.attrs, "id", plane.name),
+                bpmnElement: requiredAttr(plane.attrs, "bpmnElement", plane.name),
+                shapes: plane.shapes,
+                edges: plane.edges,
+            },
+        });
     }
-    return {
-        id: requiredAttr(element, "id"),
-        plane: {
-            id: requiredAttr(planeEl, "id"),
-            bpmnElement: requiredAttr(planeEl, "bpmnElement"),
-            shapes,
-            edges,
-        },
-    };
 }
 // ---------------------------------------------------------------------------
-// Public API
+// Definitions (document root)
 // ---------------------------------------------------------------------------
-/** Parse a BPMN XML string into a typed BpmnDefinitions model. */
-export function parseBpmn(xml) {
-    const root = parseXml(xml);
-    if (localName(root.name) !== "definitions") {
-        throw new Error(`Expected <definitions> root element, got <${root.name}>`);
-    }
-    const namespaces = {};
-    const unknownAttributes = {};
-    for (const [key, value] of Object.entries(root.attributes)) {
-        if (key.startsWith("xmlns:")) {
-            namespaces[key.slice(6)] = value;
+class DefinitionsFrame extends Frame {
+    name;
+    attrs;
+    sink;
+    categories = [];
+    documentation;
+    documentationSeen = false;
+    errors = [];
+    escalations = [];
+    messages = [];
+    signals = [];
+    collaborations = [];
+    processes = [];
+    diagrams = [];
+    unknownChildren = [];
+    constructor(name, attrs, sink) {
+        super();
+        this.name = name;
+        this.attrs = attrs;
+        this.sink = sink;
+    }
+    child(local, name, attrs) {
+        switch (local) {
+            case "documentation":
+                if (this.documentationSeen)
+                    return null;
+                this.documentationSeen = true;
+                return new TextFrame(this, SLOT_DOCUMENTATION, attrs);
+            case "error":
+                return new BaseOnlyFrame(attrs, (a, base) => parseError(name, a, base), this.errors);
+            case "escalation":
+                return new BaseOnlyFrame(attrs, (a, base) => parseEscalation(name, a, base), this.escalations);
+            case "message":
+                return new BaseOnlyFrame(attrs, (a, base) => parseMessage(name, a, base), this.messages);
+            case "signal":
+                return new BaseOnlyFrame(attrs, (a, base) => parseSignal(name, a, base), this.signals);
+            case "category":
+                return new CategoryFrame(attrs, this.categories);
+            case "collaboration":
+                return new CollaborationFrame(name, attrs, this.collaborations);
+            case "process":
+                return new ProcessFrame(name, attrs, this.processes);
+            case "BPMNDiagram":
+                return new DiagramFrame(name, attrs, this.diagrams);
+            default:
+                return captureUnknown(this.unknownChildren, name, attrs);
         }
-        else if (key === "xmlns") {
-            namespaces[""] = value;
+    }
+    setText(slot, text) {
+        if (slot === SLOT_DOCUMENTATION)
+            this.documentation = text;
+    }
+    finish() {
+        const attrs = this.attrs;
+        const namespaces = {};
+        const unknownAttributes = {};
+        for (const key in attrs) {
+            const value = attrs[key];
+            if (key.startsWith("xmlns:")) {
+                namespaces[key.slice(6)] = value;
+            }
+            else if (key === "xmlns") {
+                namespaces[""] = value;
+            }
+            else if (KNOWN_ATTRS.has(key)) {
+            }
+            else {
+                unknownAttributes[key] = value;
+            }
         }
-        else if (KNOWN_ATTRS.has(key)) {
+        this.sink.result = {
+            id: requiredAttr(attrs, "id", this.name),
+            targetNamespace: requiredAttr(attrs, "targetNamespace", this.name),
+            exporter: attr(attrs, "exporter"),
+            exporterVersion: attr(attrs, "exporterVersion"),
+            namespaces,
+            unknownAttributes,
+            ...(this.documentation !== undefined ? { documentation: this.documentation } : {}),
+            ...(this.categories.length > 0 ? { categories: this.categories } : {}),
+            errors: this.errors,
+            escalations: this.escalations,
+            messages: this.messages,
+            signals: this.signals,
+            collaborations: this.collaborations,
+            processes: this.processes,
+            diagrams: this.diagrams,
+            ...(this.unknownChildren.length > 0 ? { unknownChildren: this.unknownChildren } : {}),
+        };
+    }
+}
+/** Routes scanner events to the frame stack. */
+class BpmnSink {
+    result;
+    /** Set when the root element is not <definitions>; reported once scanning is done. */
+    rootName;
+    stack = [];
+    start(name, local, attrs) {
+        const top = this.stack[this.stack.length - 1];
+        let next;
+        if (top === undefined) {
+            if (local !== "definitions") {
+                this.rootName = name;
+                return Visit.Skip;
+            }
+            next = new DefinitionsFrame(name, attrs, this);
         }
         else {
-            unknownAttributes[key] = value;
+            next = top.child(local, name, attrs);
         }
+        if (next === null)
+            return Visit.Skip;
+        this.stack.push(next);
+        return next.wantsText ? Visit.All : Visit.ElementsOnly;
     }
-    const errors = [];
-    const escalations = [];
-    const messages = [];
-    const signals = [];
-    const collaborations = [];
-    const processes = [];
-    const diagrams = [];
-    for (const child of root.children) {
-        const ln = localName(child.name);
-        if (ln === "error")
-            errors.push(parseError(child));
-        else if (ln === "escalation")
-            escalations.push(parseEscalation(child));
-        else if (ln === "message")
-            messages.push(parseMessage(child));
-        else if (ln === "signal")
-            signals.push(parseSignal(child));
-        else if (ln === "collaboration")
-            collaborations.push(parseCollaboration(child));
-        else if (ln === "process")
-            processes.push(parseProcess(child));
-        else if (ln === "BPMNDiagram")
-            diagrams.push(parseDiagram(child));
+    text(text) {
+        ;
+        this.stack[this.stack.length - 1].text(text);
     }
-    return {
-        id: requiredAttr(root, "id"),
-        targetNamespace: requiredAttr(root, "targetNamespace"),
-        exporter: attr(root, "exporter"),
-        exporterVersion: attr(root, "exporterVersion"),
-        namespaces,
-        unknownAttributes,
-        errors,
-        escalations,
-        messages,
-        signals,
-        collaborations,
-        processes,
-        diagrams,
-    };
+    end() {
+        ;
+        this.stack.pop().finish();
+    }
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Parse a BPMN XML string into a typed BpmnDefinitions model. */
+export function parseBpmn(xml) {
+    const sink = new BpmnSink();
+    if (!scanXml(xml, sink))
+        throw new Error("Failed to parse XML: no root element found");
+    if (sink.rootName !== undefined) {
+        throw new Error(`Expected <definitions> root element, got <${sink.rootName}>`);
+    }
+    return sink.result;
 }
 //# sourceMappingURL=bpmn-parser.js.map