@bpmnkit/core 0.0.8

package/dist/dmn/dmn-layout.js

@@ -0,0 +1,256 @@
+import { parseDmn } from "./dmn-parser.js";
+// ── Element sizes (matches Camunda Modeler defaults) ──────────────────────────
+const SIZES = {
+    decision: { width: 180, height: 80 },
+    inputData: { width: 125, height: 45 },
+    knowledgeSource: { width: 100, height: 63 },
+    businessKnowledgeModel: { width: 160, height: 80 },
+};
+const H_GAP = 60; // horizontal gap between layers
+const V_GAP = 40; // vertical gap within a layer
+const MARGIN_X = 160;
+const MARGIN_Y = 100;
+// ── Graph collection ──────────────────────────────────────────────────────────
+function collectNodes(defs) {
+    const nodes = [];
+    for (const d of defs.decisions)
+        nodes.push({ id: d.id, kind: "decision", name: d.name });
+    for (const d of defs.inputData)
+        nodes.push({ id: d.id, kind: "inputData", name: d.name });
+    for (const ks of defs.knowledgeSources)
+        nodes.push({ id: ks.id, kind: "knowledgeSource", name: ks.name });
+    for (const bkm of defs.businessKnowledgeModels)
+        nodes.push({ id: bkm.id, kind: "businessKnowledgeModel", name: bkm.name });
+    return nodes;
+}
+function collectEdges(defs) {
+    const edges = [];
+    for (const d of defs.decisions) {
+        for (const req of d.informationRequirements) {
+            const src = req.requiredDecision ?? req.requiredInput ?? "";
+            if (src)
+                edges.push({ sourceId: src, targetId: d.id, reqId: req.id });
+        }
+        for (const req of d.knowledgeRequirements) {
+            edges.push({ sourceId: req.requiredKnowledge, targetId: d.id, reqId: req.id });
+        }
+        for (const req of d.authorityRequirements) {
+            const src = req.requiredAuthority ?? req.requiredDecision ?? req.requiredInput ?? "";
+            if (src)
+                edges.push({ sourceId: src, targetId: d.id, reqId: req.id });
+        }
+    }
+    for (const bkm of defs.businessKnowledgeModels) {
+        for (const req of bkm.knowledgeRequirements) {
+            edges.push({ sourceId: req.requiredKnowledge, targetId: bkm.id, reqId: req.id });
+        }
+        for (const req of bkm.authorityRequirements) {
+            const src = req.requiredAuthority ?? req.requiredDecision ?? req.requiredInput ?? "";
+            if (src)
+                edges.push({ sourceId: src, targetId: bkm.id, reqId: req.id });
+        }
+    }
+    for (const ks of defs.knowledgeSources) {
+        for (const req of ks.authorityRequirements) {
+            const src = req.requiredAuthority ?? req.requiredDecision ?? req.requiredInput ?? "";
+            if (src)
+                edges.push({ sourceId: src, targetId: ks.id, reqId: req.id });
+        }
+    }
+    return edges;
+}
+// ── Layer assignment (longest-path / BFS) ────────────────────────────────────
+function assignLayers(nodes, edges) {
+    const outgoing = new Map();
+    const inDegree = new Map();
+    for (const n of nodes) {
+        outgoing.set(n.id, []);
+        inDegree.set(n.id, 0);
+    }
+    for (const e of edges) {
+        outgoing.get(e.sourceId)?.push(e.targetId);
+        inDegree.set(e.targetId, (inDegree.get(e.targetId) ?? 0) + 1);
+    }
+    const layers = new Map();
+    const queue = [];
+    for (const n of nodes) {
+        if ((inDegree.get(n.id) ?? 0) === 0) {
+            layers.set(n.id, 0);
+            queue.push(n.id);
+        }
+    }
+    let i = 0;
+    while (i < queue.length) {
+        const id = queue[i++];
+        if (id === undefined)
+            continue;
+        const layer = layers.get(id) ?? 0;
+        for (const succ of outgoing.get(id) ?? []) {
+            const newLayer = Math.max(layers.get(succ) ?? 0, layer + 1);
+            layers.set(succ, newLayer);
+            const deg = (inDegree.get(succ) ?? 1) - 1;
+            inDegree.set(succ, deg);
+            if (deg === 0)
+                queue.push(succ);
+        }
+    }
+    // Disconnected nodes default to layer 0
+    for (const n of nodes) {
+        if (!layers.has(n.id))
+            layers.set(n.id, 0);
+    }
+    return layers;
+}
+// ── Layout ────────────────────────────────────────────────────────────────────
+/**
+ * Auto-layout a DMN definitions object.
+ * Assigns DMNDI diagram positions to all DRG elements using a left-to-right
+ * layered layout based on the requirement DAG.
+ */
+export function layoutDmn(defs) {
+    const nodes = collectNodes(defs);
+    if (nodes.length === 0)
+        return defs;
+    const edges = collectEdges(defs);
+    const layerMap = assignLayers(nodes, edges);
+    // Group nodes by layer
+    const byLayer = new Map();
+    for (const n of nodes) {
+        const layer = layerMap.get(n.id) ?? 0;
+        const arr = byLayer.get(layer);
+        if (arr)
+            arr.push(n);
+        else
+            byLayer.set(layer, [n]);
+    }
+    const sortedLayers = [...byLayer.keys()].sort((a, b) => a - b);
+    // Compute x per layer (left = upstream/leaf, right = final decision)
+    let x = MARGIN_X;
+    const xByLayer = new Map();
+    const widthByLayer = new Map();
+    for (const layerIdx of sortedLayers) {
+        const layerNodes = byLayer.get(layerIdx) ?? [];
+        const maxWidth = Math.max(...layerNodes.map((n) => SIZES[n.kind].width));
+        xByLayer.set(layerIdx, x);
+        widthByLayer.set(layerIdx, maxWidth);
+        x += maxWidth + H_GAP;
+    }
+    // Compute total height per layer (for vertical centering)
+    const heightByLayer = new Map();
+    for (const layerIdx of sortedLayers) {
+        const layerNodes = byLayer.get(layerIdx) ?? [];
+        let h = 0;
+        for (const n of layerNodes) {
+            h += SIZES[n.kind].height;
+        }
+        h += Math.max(0, layerNodes.length - 1) * V_GAP;
+        heightByLayer.set(layerIdx, h);
+    }
+    const maxHeight = Math.max(...[...heightByLayer.values()], 0);
+    // Position nodes
+    const positioned = new Map();
+    for (const layerIdx of sortedLayers) {
+        const layerNodes = byLayer.get(layerIdx) ?? [];
+        const layerX = xByLayer.get(layerIdx) ?? MARGIN_X;
+        const layerHeight = heightByLayer.get(layerIdx) ?? 0;
+        const startY = MARGIN_Y + (maxHeight - layerHeight) / 2;
+        let y = startY;
+        for (const n of layerNodes) {
+            const size = SIZES[n.kind];
+            positioned.set(n.id, {
+                ...n,
+                layer: layerIdx,
+                x: layerX,
+                y,
+                width: size.width,
+                height: size.height,
+            });
+            y += size.height + V_GAP;
+        }
+    }
+    // Build shapes
+    const shapes = [];
+    for (const [, node] of positioned) {
+        shapes.push({
+            dmnElementRef: node.id,
+            bounds: { x: node.x, y: node.y, width: node.width, height: node.height },
+        });
+    }
+    // Build edges — connect right edge of source to left edge of target
+    const diagramEdges = [];
+    for (const edge of edges) {
+        const src = positioned.get(edge.sourceId);
+        const tgt = positioned.get(edge.targetId);
+        if (!src || !tgt)
+            continue;
+        const srcX = src.x + src.width;
+        const srcY = src.y + src.height / 2;
+        const tgtX = tgt.x;
+        const tgtY = tgt.y + tgt.height / 2;
+        diagramEdges.push({
+            dmnElementRef: edge.reqId,
+            waypoints: [
+                { x: srcX, y: srcY },
+                { x: tgtX, y: tgtY },
+            ],
+        });
+    }
+    const diagram = { shapes, edges: diagramEdges };
+    return { ...defs, diagram };
+}
+/** Parse the reference layout, strip DMNDI, run auto-layout, and compare. */
+export function benchmarkDmnLayout(xml, fileName) {
+    const ref = parseDmn(xml);
+    const refShapes = new Map();
+    for (const shape of ref.diagram?.shapes ?? []) {
+        refShapes.set(shape.dmnElementRef, shape);
+    }
+    const stripped = { ...ref, diagram: undefined };
+    const layouted = layoutDmn(stripped);
+    const autoShapes = new Map();
+    for (const shape of layouted.diagram?.shapes ?? []) {
+        autoShapes.set(shape.dmnElementRef, shape);
+    }
+    const allNodes = collectNodes(ref);
+    const comparisons = [];
+    let matchedCount = 0;
+    for (const n of allNodes) {
+        const refShape = refShapes.get(n.id);
+        const autoShape = autoShapes.get(n.id);
+        if (!refShape || !autoShape)
+            continue;
+        matchedCount++;
+        const refCx = refShape.bounds.x + refShape.bounds.width / 2;
+        const refCy = refShape.bounds.y + refShape.bounds.height / 2;
+        const autoCx = autoShape.bounds.x + autoShape.bounds.width / 2;
+        const autoCy = autoShape.bounds.y + autoShape.bounds.height / 2;
+        const dx = autoCx - refCx;
+        const dy = autoCy - refCy;
+        const distance = Math.sqrt(dx * dx + dy * dy);
+        comparisons.push({
+            id: n.id,
+            name: n.name,
+            kind: n.kind,
+            ref: { cx: refCx, cy: refCy },
+            auto: { cx: autoCx, cy: autoCy },
+            delta: { dx, dy },
+            distance,
+        });
+    }
+    comparisons.sort((a, b) => b.distance - a.distance);
+    const avgDistance = comparisons.length > 0
+        ? comparisons.reduce((s, c) => s + c.distance, 0) / comparisons.length
+        : 0;
+    const p90Distance = comparisons.length > 0 ? (comparisons[Math.floor(comparisons.length * 0.9)]?.distance ?? 0) : 0;
+    const maxDistance = comparisons[0]?.distance ?? 0;
+    return {
+        fileName,
+        elementCount: allNodes.length,
+        matchedCount,
+        avgDistance,
+        p90Distance,
+        maxDistance,
+        elements: comparisons,
+    };
+}
+//# sourceMappingURL=dmn-layout.js.map

package/dist/dmn/dmn-model.d.ts

@@ -0,0 +1,158 @@
+import type { XmlElement } from "../types/xml-element.js";
+/** DMN hit policy for decision tables. */
+export type HitPolicy = "UNIQUE" | "FIRST" | "ANY" | "COLLECT" | "RULE ORDER" | "OUTPUT ORDER" | "PRIORITY";
+/** DMN collect aggregation for COLLECT hit policy. */
+export type DmnAggregation = "SUM" | "MIN" | "MAX" | "COUNT";
+/** DMN type reference for inputs/outputs. */
+export type DmnTypeRef = "string" | "boolean" | "number" | "date";
+/** A single input column in a decision table. */
+export interface DmnInput {
+    id: string;
+    label?: string;
+    inputExpression: {
+        id: string;
+        typeRef?: DmnTypeRef;
+        text?: string;
+    };
+}
+/** A single output column in a decision table. */
+export interface DmnOutput {
+    id: string;
+    label?: string;
+    name?: string;
+    typeRef?: DmnTypeRef;
+}
+/** An input entry (unary test) within a rule. */
+export interface DmnInputEntry {
+    id: string;
+    text: string;
+}
+/** An output entry (literal expression) within a rule. */
+export interface DmnOutputEntry {
+    id: string;
+    text: string;
+}
+/** A single rule (row) in a decision table. */
+export interface DmnRule {
+    id: string;
+    description?: string;
+    inputEntries: DmnInputEntry[];
+    outputEntries: DmnOutputEntry[];
+}
+/** A decision table within a decision element. */
+export interface DmnDecisionTable {
+    id: string;
+    hitPolicy?: HitPolicy;
+    aggregation?: DmnAggregation;
+    inputs: DmnInput[];
+    outputs: DmnOutput[];
+    rules: DmnRule[];
+}
+/** Information requirement — connects a decision or input data to a decision. */
+export interface DmnInformationRequirement {
+    id: string;
+    /** Ref to required decision id (mutually exclusive with requiredInput). */
+    requiredDecision?: string;
+    /** Ref to required input data id (mutually exclusive with requiredDecision). */
+    requiredInput?: string;
+}
+/** Knowledge requirement — connects a BKM to a decision or BKM. */
+export interface DmnKnowledgeRequirement {
+    id: string;
+    /** Ref to the required BKM id. */
+    requiredKnowledge: string;
+}
+/** Authority requirement — connects a knowledge source or decision to a DRG element. */
+export interface DmnAuthorityRequirement {
+    id: string;
+    requiredDecision?: string;
+    requiredInput?: string;
+    /** Ref to knowledge source id. */
+    requiredAuthority?: string;
+}
+/** A top-level decision element. */
+export interface DmnDecision {
+    id: string;
+    name?: string;
+    /** Decision table (optional — a decision may contain a literal expression instead). */
+    decisionTable?: DmnDecisionTable;
+    informationRequirements: DmnInformationRequirement[];
+    knowledgeRequirements: DmnKnowledgeRequirement[];
+    authorityRequirements: DmnAuthorityRequirement[];
+    extensionElements?: XmlElement[];
+}
+/** Input data element — an external data source feeding into decisions. */
+export interface DmnInputData {
+    id: string;
+    name?: string;
+}
+/** Knowledge source element — an authority for decisions or BKMs. */
+export interface DmnKnowledgeSource {
+    id: string;
+    name?: string;
+    authorityRequirements: DmnAuthorityRequirement[];
+}
+/** Business knowledge model element — a reusable function or decision table. */
+export interface DmnBusinessKnowledgeModel {
+    id: string;
+    name?: string;
+    knowledgeRequirements: DmnKnowledgeRequirement[];
+    authorityRequirements: DmnAuthorityRequirement[];
+}
+/** Text annotation element — a free-form textual comment. */
+export interface DmnTextAnnotation {
+    id: string;
+    text?: string;
+}
+/** Association between any two DRG elements (often with text annotations). */
+export interface DmnAssociation {
+    id: string;
+    sourceRef: string;
+    targetRef: string;
+}
+/** A waypoint in a diagram edge path. */
+export interface DmnWaypoint {
+    x: number;
+    y: number;
+}
+/** DMN diagram shape for visual representation. */
+export interface DmnDiagramShape {
+    dmnElementRef: string;
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/** DMN diagram edge for visual representation. */
+export interface DmnDiagramEdge {
+    dmnElementRef: string;
+    waypoints: DmnWaypoint[];
+}
+/** DMN diagram information. */
+export interface DmnDiagram {
+    shapes: DmnDiagramShape[];
+    edges: DmnDiagramEdge[];
+}
+/** Root DMN definitions element. */
+export interface DmnDefinitions {
+    id: string;
+    name: string;
+    namespace: string;
+    exporter?: string;
+    exporterVersion?: string;
+    /** Namespace declarations from the XML document (prefix → URI). */
+    namespaces: Record<string, string>;
+    /** Modeler extension attributes (e.g. executionPlatform). */
+    modelerAttributes: Record<string, string>;
+    decisions: DmnDecision[];
+    inputData: DmnInputData[];
+    knowledgeSources: DmnKnowledgeSource[];
+    businessKnowledgeModels: DmnBusinessKnowledgeModel[];
+    textAnnotations: DmnTextAnnotation[];
+    associations: DmnAssociation[];
+    diagram?: DmnDiagram;
+    extensionElements?: XmlElement[];
+}
+//# sourceMappingURL=dmn-model.d.ts.map

package/dist/dmn/dmn-model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dmn-model.js.map

package/dist/dmn/dmn-parser.d.ts

@@ -0,0 +1,4 @@
+import type { DmnDefinitions } from "./dmn-model.js";
+/** Parse a DMN XML string into a typed DmnDefinitions model. */
+export declare function parseDmn(xml: string): DmnDefinitions;
+//# sourceMappingURL=dmn-parser.d.ts.map

package/dist/dmn/dmn-parser.js

@@ -0,0 +1,275 @@
+import { parseXml } from "../xml/xml-parser.js";
+const DMN_NS = "https://www.omg.org/spec/DMN/20191111/MODEL/";
+/** Strip namespace prefix from a tag name. */
+function localName(name) {
+    const idx = name.indexOf(":");
+    return idx >= 0 ? name.slice(idx + 1) : name;
+}
+/** Find child elements by local name. */
+function findChildren(element, tagLocalName) {
+    return element.children.filter((c) => localName(c.name) === tagLocalName);
+}
+/** Find first child element by local name. */
+function findChild(element, tagLocalName) {
+    return element.children.find((c) => localName(c.name) === tagLocalName);
+}
+/** Get attribute value, trying with and without namespace prefixes. */
+function attr(element, name) {
+    // Try direct name first
+    if (element.attributes[name] !== undefined)
+        return element.attributes[name];
+    // Try all prefixed variants
+    for (const [key, value] of Object.entries(element.attributes)) {
+        if (localName(key) === name)
+            return value;
+    }
+    return undefined;
+}
+function requiredAttr(element, name) {
+    const value = attr(element, name);
+    if (value === undefined) {
+        throw new Error(`Missing required attribute "${name}" on element <${element.name}>`);
+    }
+    return value;
+}
+/** Strip the leading '#' from a DMN href reference. */
+function deref(href) {
+    if (!href)
+        return undefined;
+    return href.startsWith("#") ? href.slice(1) : href;
+}
+function parseTypeRef(value) {
+    if (!value)
+        return undefined;
+    return value;
+}
+function parseHitPolicy(value) {
+    if (!value)
+        return undefined;
+    return value;
+}
+function parseInputExpression(el) {
+    const textEl = findChild(el, "text");
+    return {
+        id: requiredAttr(el, "id"),
+        typeRef: parseTypeRef(attr(el, "typeRef")),
+        text: textEl?.text,
+    };
+}
+function parseInput(el) {
+    const exprEl = findChild(el, "inputExpression");
+    if (!exprEl) {
+        throw new Error(`Missing <inputExpression> in input "${attr(el, "id")}"`);
+    }
+    return {
+        id: requiredAttr(el, "id"),
+        label: attr(el, "label"),
+        inputExpression: parseInputExpression(exprEl),
+    };
+}
+function parseOutput(el) {
+    return {
+        id: requiredAttr(el, "id"),
+        label: attr(el, "label"),
+        name: attr(el, "name"),
+        typeRef: parseTypeRef(attr(el, "typeRef")),
+    };
+}
+function parseInputEntry(el) {
+    const textEl = findChild(el, "text");
+    return {
+        id: requiredAttr(el, "id"),
+        text: textEl?.text ?? "",
+    };
+}
+function parseOutputEntry(el) {
+    const textEl = findChild(el, "text");
+    return {
+        id: requiredAttr(el, "id"),
+        text: textEl?.text ?? "",
+    };
+}
+function parseRule(el) {
+    const descEl = findChild(el, "description");
+    return {
+        id: requiredAttr(el, "id"),
+        description: descEl?.text,
+        inputEntries: findChildren(el, "inputEntry").map(parseInputEntry),
+        outputEntries: findChildren(el, "outputEntry").map(parseOutputEntry),
+    };
+}
+function parseDecisionTable(el) {
+    return {
+        id: requiredAttr(el, "id"),
+        hitPolicy: parseHitPolicy(attr(el, "hitPolicy")),
+        aggregation: attr(el, "aggregation"),
+        inputs: findChildren(el, "input").map(parseInput),
+        outputs: findChildren(el, "output").map(parseOutput),
+        rules: findChildren(el, "rule").map(parseRule),
+    };
+}
+function parseInformationRequirement(el) {
+    const reqDecEl = findChild(el, "requiredDecision");
+    const reqInEl = findChild(el, "requiredInput");
+    return {
+        id: requiredAttr(el, "id"),
+        requiredDecision: deref(attr(reqDecEl ?? { name: "", attributes: {}, children: [] }, "href")),
+        requiredInput: deref(attr(reqInEl ?? { name: "", attributes: {}, children: [] }, "href")),
+    };
+}
+function parseKnowledgeRequirement(el) {
+    const reqEl = findChild(el, "requiredKnowledge");
+    return {
+        id: requiredAttr(el, "id"),
+        requiredKnowledge: deref(attr(reqEl ?? { name: "", attributes: {}, children: [] }, "href")) ?? "",
+    };
+}
+function parseAuthorityRequirement(el) {
+    const reqDecEl = findChild(el, "requiredDecision");
+    const reqInEl = findChild(el, "requiredInput");
+    const reqAuthEl = findChild(el, "requiredAuthority");
+    return {
+        id: requiredAttr(el, "id"),
+        requiredDecision: deref(attr(reqDecEl ?? { name: "", attributes: {}, children: [] }, "href")),
+        requiredInput: deref(attr(reqInEl ?? { name: "", attributes: {}, children: [] }, "href")),
+        requiredAuthority: deref(attr(reqAuthEl ?? { name: "", attributes: {}, children: [] }, "href")),
+    };
+}
+function parseDecision(el) {
+    const tableEl = findChild(el, "decisionTable");
+    const extensionEls = findChild(el, "extensionElements");
+    const knownLocalNames = new Set([
+        "decisionTable",
+        "extensionElements",
+        "informationRequirement",
+        "knowledgeRequirement",
+        "authorityRequirement",
+    ]);
+    const unknownChildren = el.children.filter((c) => !knownLocalNames.has(localName(c.name)));
+    return {
+        id: requiredAttr(el, "id"),
+        name: attr(el, "name"),
+        decisionTable: tableEl ? parseDecisionTable(tableEl) : undefined,
+        informationRequirements: findChildren(el, "informationRequirement").map(parseInformationRequirement),
+        knowledgeRequirements: findChildren(el, "knowledgeRequirement").map(parseKnowledgeRequirement),
+        authorityRequirements: findChildren(el, "authorityRequirement").map(parseAuthorityRequirement),
+        extensionElements: extensionEls
+            ? extensionEls.children
+            : unknownChildren.length > 0
+                ? unknownChildren
+                : undefined,
+    };
+}
+function parseInputData(el) {
+    return {
+        id: requiredAttr(el, "id"),
+        name: attr(el, "name"),
+    };
+}
+function parseKnowledgeSource(el) {
+    return {
+        id: requiredAttr(el, "id"),
+        name: attr(el, "name"),
+        authorityRequirements: findChildren(el, "authorityRequirement").map(parseAuthorityRequirement),
+    };
+}
+function parseBusinessKnowledgeModel(el) {
+    return {
+        id: requiredAttr(el, "id"),
+        name: attr(el, "name"),
+        knowledgeRequirements: findChildren(el, "knowledgeRequirement").map(parseKnowledgeRequirement),
+        authorityRequirements: findChildren(el, "authorityRequirement").map(parseAuthorityRequirement),
+    };
+}
+function parseTextAnnotation(el) {
+    const textEl = findChild(el, "text");
+    return {
+        id: requiredAttr(el, "id"),
+        text: textEl?.text,
+    };
+}
+function parseAssociation(el) {
+    return {
+        id: requiredAttr(el, "id"),
+        sourceRef: deref(attr(el, "sourceRef")) ?? "",
+        targetRef: deref(attr(el, "targetRef")) ?? "",
+    };
+}
+function parseDiagram(dmndiEl) {
+    const diagramEl = findChild(dmndiEl, "DMNDiagram");
+    const shapes = [];
+    const edges = [];
+    if (diagramEl) {
+        for (const shapeEl of findChildren(diagramEl, "DMNShape")) {
+            const boundsEl = findChild(shapeEl, "Bounds");
+            if (boundsEl) {
+                shapes.push({
+                    dmnElementRef: requiredAttr(shapeEl, "dmnElementRef"),
+                    bounds: {
+                        x: Number(attr(boundsEl, "x") ?? "0"),
+                        y: Number(attr(boundsEl, "y") ?? "0"),
+                        width: Number(attr(boundsEl, "width") ?? "0"),
+                        height: Number(attr(boundsEl, "height") ?? "0"),
+                    },
+                });
+            }
+        }
+        for (const edgeEl of findChildren(diagramEl, "DMNEdge")) {
+            const waypoints = findChildren(edgeEl, "waypoint").map((wp) => ({
+                x: Number(attr(wp, "x") ?? "0"),
+                y: Number(attr(wp, "y") ?? "0"),
+            }));
+            edges.push({
+                dmnElementRef: requiredAttr(edgeEl, "dmnElementRef"),
+                waypoints,
+            });
+        }
+    }
+    return { shapes, edges };
+}
+/** Parse a DMN XML string into a typed DmnDefinitions model. */
+export function parseDmn(xml) {
+    const root = parseXml(xml);
+    if (localName(root.name) !== "definitions") {
+        throw new Error(`Expected <definitions> root element, got <${root.name}>`);
+    }
+    // Extract namespace declarations
+    const namespaces = {};
+    const modelerAttributes = {};
+    for (const [key, value] of Object.entries(root.attributes)) {
+        if (key.startsWith("xmlns:")) {
+            namespaces[key.slice(6)] = value;
+        }
+        else if (key === "xmlns") {
+            namespaces[""] = value;
+        }
+        else if (key.startsWith("modeler:")) {
+            modelerAttributes[key.slice(8)] = value;
+        }
+    }
+    const decisions = findChildren(root, "decision").map(parseDecision);
+    const inputData = findChildren(root, "inputData").map(parseInputData);
+    const knowledgeSources = findChildren(root, "knowledgeSource").map(parseKnowledgeSource);
+    const businessKnowledgeModels = findChildren(root, "businessKnowledgeModel").map(parseBusinessKnowledgeModel);
+    const textAnnotations = findChildren(root, "textAnnotation").map(parseTextAnnotation);
+    const associations = findChildren(root, "association").map(parseAssociation);
+    const dmndiEl = findChild(root, "DMNDI");
+    const diagram = dmndiEl ? parseDiagram(dmndiEl) : undefined;
+    return {
+        id: requiredAttr(root, "id"),
+        name: requiredAttr(root, "name"),
+        namespace: attr(root, "namespace") ?? DMN_NS,
+        exporter: attr(root, "exporter"),
+        exporterVersion: attr(root, "exporterVersion"),
+        namespaces,
+        modelerAttributes,
+        decisions,
+        inputData,
+        knowledgeSources,
+        businessKnowledgeModels,
+        textAnnotations,
+        associations,
+        diagram,
+    };
+}
+//# sourceMappingURL=dmn-parser.js.map