@syncfusion/ej2-office-common 35.1.37

package/src/features/diagrams/diagram-serializers.js

@@ -0,0 +1,110 @@
+/**
+ * Serializers: diagram models/views → ElementTree (Transitional write).
+ * Never invent optional markup beyond model state; emit XSD defaults only
+ * when the model holds non-default values or required attributes.
+ *
+ * Citations: dml-diagram.xsd; ECMA-376 Transitional namespaces.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { A_NAMESPACE, DGM_NAMESPACE, DSP_NAMESPACE, } from './constants';
+import { attr, el } from './element-tree';
+import { cloneElement } from './element-tree';
+function pointAttrs(p) {
+    var attrs = [attr('modelId', p.modelId)];
+    if (p.type !== 'node')
+        attrs.push(attr('type', p.type));
+    if (p.cxnId !== '0')
+        attrs.push(attr('cxnId', p.cxnId));
+    return attrs;
+}
+function connectionAttrs(c) {
+    var attrs = [
+        attr('modelId', c.modelId),
+        attr('srcId', c.srcId),
+        attr('destId', c.destId),
+        attr('srcOrd', String(c.srcOrd)),
+        attr('destOrd', String(c.destOrd)),
+    ];
+    if (c.type !== 'parOf')
+        attrs.push(attr('type', c.type));
+    if (c.parTransId !== '0')
+        attrs.push(attr('parTransId', c.parTransId));
+    if (c.sibTransId !== '0')
+        attrs.push(attr('sibTransId', c.sibTransId));
+    if (c.presId !== '')
+        attrs.push(attr('presId', c.presId));
+    return attrs;
+}
+function bodyChildren(body) {
+    if (!body)
+        return [];
+    // Synthetic multi-child wrapper from parser.
+    if (body.localName === '_body' && body.namespaceUri == null) {
+        return body.children.map(function (c) {
+            return c.kind === 'text' ? c : cloneElement(c);
+        });
+    }
+    return [cloneElement(body)];
+}
+function serializePoint(p) {
+    return el('pt', DGM_NAMESPACE, pointAttrs(p), bodyChildren(p.body), 'dgm');
+}
+function serializeConnection(c) {
+    return el('cxn', DGM_NAMESPACE, connectionAttrs(c), bodyChildren(c.body), 'dgm');
+}
+/**
+ * Serialize CT_DataModel as `dgm:dataModel` (Transitional NS).
+ */
+export function serializeDiagramData(model) {
+    var children = [];
+    children.push(el('ptLst', DGM_NAMESPACE, [], model.points.map(serializePoint), 'dgm'));
+    children.push(el('cxnLst', DGM_NAMESPACE, [], model.connections.map(serializeConnection), 'dgm'));
+    if (model.background) {
+        var bg = cloneElement(model.background);
+        children.push(__assign({}, bg, { namespaceUri: (bg.namespaceUri != null ? bg.namespaceUri : DGM_NAMESPACE), localName: bg.localName || 'bg' }));
+    }
+    if (model.whole) {
+        var w = cloneElement(model.whole);
+        children.push(__assign({}, w, { namespaceUri: (w.namespaceUri != null ? w.namespaceUri : DGM_NAMESPACE), localName: w.localName || 'whole' }));
+    }
+    if (model.extLst) {
+        children.push(cloneElement(model.extLst));
+    }
+    return el('dataModel', DGM_NAMESPACE, [], children, 'dgm');
+}
+export function serializeDiagramLayout(view) {
+    var root = cloneElement(view.root);
+    // Force Transitional dgm NS on write.
+    return __assign({}, root, { namespaceUri: DGM_NAMESPACE, localName: 'layoutDef', prefix: (root.prefix != null ? root.prefix : 'dgm') });
+}
+export function serializeDiagramQuickStyle(view) {
+    var root = cloneElement(view.root);
+    return __assign({}, root, { namespaceUri: DGM_NAMESPACE, localName: 'styleDef', prefix: (root.prefix != null ? root.prefix : 'dgm') });
+}
+export function serializeDiagramColors(view) {
+    var root = cloneElement(view.root);
+    return __assign({}, root, { namespaceUri: DGM_NAMESPACE, localName: 'colorsDef', prefix: (root.prefix != null ? root.prefix : 'dgm') });
+}
+export function serializeDiagramDrawing(view) {
+    var root = cloneElement(view.root);
+    // Prefer dsp NS if root was drawing.
+    if (root.localName === 'drawing') {
+        return __assign({}, root, { namespaceUri: (root.namespaceUri != null ? root.namespaceUri : DSP_NAMESPACE), prefix: (root.prefix != null ? root.prefix : 'dsp') });
+    }
+    return root;
+}
+/** Helper: emit a minimal a:extLst shell (for tests / extensions). */
+export function extLst(children) {
+    if (children === void 0) { children = []; }
+    return el('extLst', A_NAMESPACE, [], children, 'a');
+}

package/src/features/diagrams/diagram-views.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Opaque / structured views for layout, quick style, colors, and MS drawing parts.
+ *
+ * Layout/style/colors: preserve full element trees for lossless round-trip.
+ * Drawing: MS cached drawing ([MS-ODRAWXML]); preserve tree + optional bytes.
+ *
+ * Citations: dml-diagram.xsd CT_DiagramDefinition, CT_StyleDefinition,
+ * CT_ColorTransform; [MS-ODRAWXML] diagramDrawing.
+ */
+import { ElementNode } from './element-tree';
+declare const LAYOUT_BRAND: unique symbol;
+declare const STYLE_BRAND: unique symbol;
+declare const COLORS_BRAND: unique symbol;
+declare const DRAWING_BRAND: unique symbol;
+declare abstract class DiagramPartViewBase {
+    protected _root: ElementNode;
+    protected _dirty: boolean;
+    protected _originalBytes: Uint8Array | null;
+    constructor(root: ElementNode);
+    readonly root: ElementNode;
+    /** Replace root tree (marks dirty). */
+    setRoot(root: ElementNode): void;
+    readonly dirty: boolean;
+    markDirty(): void;
+    clearDirty(originalBytes?: Uint8Array | null): void;
+    readonly originalBytes: Uint8Array | null;
+    setOriginalBytes(bytes: Uint8Array | null): void;
+    /** Unique name / uniqueId attribute when present on root. */
+    readonly uniqueId: string | undefined;
+    readonly minVer: string | undefined;
+    protected cloneBase(ctor: new (root: ElementNode) => DiagramPartViewBase): DiagramPartViewBase;
+}
+/** CT_DiagramDefinition view (layout part). */
+export declare class DiagramLayout extends DiagramPartViewBase {
+    readonly [LAYOUT_BRAND]: true;
+    clone(): DiagramLayout;
+}
+/** CT_StyleDefinition view (quick style part). */
+export declare class DiagramQuickStyle extends DiagramPartViewBase {
+    readonly [STYLE_BRAND]: true;
+    clone(): DiagramQuickStyle;
+}
+/** CT_ColorTransform view (colors part). */
+export declare class DiagramColors extends DiagramPartViewBase {
+    readonly [COLORS_BRAND]: true;
+    clone(): DiagramColors;
+}
+/**
+ * Microsoft diagram drawing (`dsp:drawing`) cached layout art.
+ * [MS-ODRAWXML] §2.1.3.
+ */
+export declare class DiagramDrawing extends DiagramPartViewBase {
+    readonly [DRAWING_BRAND]: true;
+    clone(): DiagramDrawing;
+}
+export declare function isDiagramLayout(value: unknown): value is DiagramLayout;
+export declare function isDiagramQuickStyle(value: unknown): value is DiagramQuickStyle;
+export declare function isDiagramColors(value: unknown): value is DiagramColors;
+export declare function isDiagramDrawing(value: unknown): value is DiagramDrawing;
+export {};

package/src/features/diagrams/diagram-views.js

@@ -0,0 +1,213 @@
+/**
+ * Opaque / structured views for layout, quick style, colors, and MS drawing parts.
+ *
+ * Layout/style/colors: preserve full element trees for lossless round-trip.
+ * Drawing: MS cached drawing ([MS-ODRAWXML]); preserve tree + optional bytes.
+ *
+ * Citations: dml-diagram.xsd CT_DiagramDefinition, CT_StyleDefinition,
+ * CT_ColorTransform; [MS-ODRAWXML] diagramDrawing.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var _a, _b, _c, _d;
+import { cloneElement } from './element-tree';
+var LAYOUT_BRAND = Symbol.for('@syncfusion/ej2-office-common.DiagramLayout');
+var STYLE_BRAND = Symbol.for('@syncfusion/ej2-office-common.DiagramQuickStyle');
+var COLORS_BRAND = Symbol.for('@syncfusion/ej2-office-common.DiagramColors');
+var DRAWING_BRAND = Symbol.for('@syncfusion/ej2-office-common.DiagramDrawing');
+var DiagramPartViewBase = /** @class */ (function () {
+    function DiagramPartViewBase(root) {
+        this._dirty = false;
+        this._originalBytes = null;
+        this._root = cloneElement(root);
+    }
+    Object.defineProperty(DiagramPartViewBase.prototype, "root", {
+        get: function () {
+            return this._root;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /** Replace root tree (marks dirty). */
+    DiagramPartViewBase.prototype.setRoot = function (root) {
+        this._root = cloneElement(root);
+        this.markDirty();
+    };
+    Object.defineProperty(DiagramPartViewBase.prototype, "dirty", {
+        get: function () {
+            return this._dirty;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DiagramPartViewBase.prototype.markDirty = function () {
+        this._dirty = true;
+        this._originalBytes = null;
+    };
+    DiagramPartViewBase.prototype.clearDirty = function (originalBytes) {
+        this._dirty = false;
+        this._originalBytes = (originalBytes != null ? originalBytes : null);
+    };
+    Object.defineProperty(DiagramPartViewBase.prototype, "originalBytes", {
+        get: function () {
+            return this._originalBytes;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DiagramPartViewBase.prototype.setOriginalBytes = function (bytes) {
+        this._originalBytes = bytes;
+    };
+    Object.defineProperty(DiagramPartViewBase.prototype, "uniqueId", {
+        /** Unique name / uniqueId attribute when present on root. */
+        get: function () {
+            var e_1, _a;
+            try {
+                for (var _b = __values(this._root.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var a = _c.value;
+                    if (a.name === 'uniqueId')
+                        return a.value;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DiagramPartViewBase.prototype, "minVer", {
+        get: function () {
+            var e_2, _a;
+            try {
+                for (var _b = __values(this._root.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var a = _c.value;
+                    if (a.name === 'minVer')
+                        return a.value;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DiagramPartViewBase.prototype.cloneBase = function (ctor) {
+        var v = new ctor(this._root);
+        if (this._dirty) {
+            v.markDirty();
+        }
+        else if (this._originalBytes) {
+            v.clearDirty(this._originalBytes);
+        }
+        return v;
+    };
+    return DiagramPartViewBase;
+}());
+/** CT_DiagramDefinition view (layout part). */
+var DiagramLayout = /** @class */ (function (_super) {
+    __extends(DiagramLayout, _super);
+    function DiagramLayout() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this[_a] = true;
+        return _this;
+    }
+    DiagramLayout.prototype.clone = function () {
+        return this.cloneBase(DiagramLayout);
+    };
+    return DiagramLayout;
+}(DiagramPartViewBase));
+export { DiagramLayout };
+_a = LAYOUT_BRAND;
+/** CT_StyleDefinition view (quick style part). */
+var DiagramQuickStyle = /** @class */ (function (_super) {
+    __extends(DiagramQuickStyle, _super);
+    function DiagramQuickStyle() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this[_b] = true;
+        return _this;
+    }
+    DiagramQuickStyle.prototype.clone = function () {
+        return this.cloneBase(DiagramQuickStyle);
+    };
+    return DiagramQuickStyle;
+}(DiagramPartViewBase));
+export { DiagramQuickStyle };
+_b = STYLE_BRAND;
+/** CT_ColorTransform view (colors part). */
+var DiagramColors = /** @class */ (function (_super) {
+    __extends(DiagramColors, _super);
+    function DiagramColors() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this[_c] = true;
+        return _this;
+    }
+    DiagramColors.prototype.clone = function () {
+        return this.cloneBase(DiagramColors);
+    };
+    return DiagramColors;
+}(DiagramPartViewBase));
+export { DiagramColors };
+_c = COLORS_BRAND;
+/**
+ * Microsoft diagram drawing (`dsp:drawing`) cached layout art.
+ * [MS-ODRAWXML] §2.1.3.
+ */
+var DiagramDrawing = /** @class */ (function (_super) {
+    __extends(DiagramDrawing, _super);
+    function DiagramDrawing() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this[_d] = true;
+        return _this;
+    }
+    DiagramDrawing.prototype.clone = function () {
+        return this.cloneBase(DiagramDrawing);
+    };
+    return DiagramDrawing;
+}(DiagramPartViewBase));
+export { DiagramDrawing };
+_d = DRAWING_BRAND;
+export function isDiagramLayout(value) {
+    return value instanceof DiagramLayout;
+}
+export function isDiagramQuickStyle(value) {
+    return value instanceof DiagramQuickStyle;
+}
+export function isDiagramColors(value) {
+    return value instanceof DiagramColors;
+}
+export function isDiagramDrawing(value) {
+    return value instanceof DiagramDrawing;
+}

package/src/features/diagrams/element-tree.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Local structural element tree for diagram parsers/serializers.
+ *
+ * Parsers MUST accept ElementTree only (no raw XML/bytes). A later TASK-9003
+ * unification may replace this with a shared core type; the public parse
+ * surface stays ElementTree-shaped.
+ */
+/** Attribute on an element. Namespace may be null for unnamespaced attrs. */
+export interface ElementAttr {
+    readonly name: string;
+    readonly value: string;
+    readonly namespaceUri?: string | null;
+    readonly prefix?: string | null;
+}
+/**
+ * Structural element node.
+ * `localName` is the unqualified name; `namespaceUri` is the expanded NS.
+ */
+export interface ElementNode {
+    readonly kind: 'element';
+    readonly localName: string;
+    readonly namespaceUri: string | null;
+    readonly prefix?: string | null;
+    readonly attributes: ReadonlyArray<ElementAttr>;
+    readonly children: ReadonlyArray<ElementChild>;
+}
+export interface TextNode {
+    readonly kind: 'text';
+    readonly text: string;
+}
+export declare type ElementChild = ElementNode | TextNode;
+/** Document or fragment root accepted by parsers (single element root preferred). */
+export declare type ElementTree = ElementNode;
+export declare function isElementNode(node: ElementChild | ElementTree): node is ElementNode;
+export declare function isTextNode(node: ElementChild): node is TextNode;
+/** Create an element node. */
+export declare function el(localName: string, namespaceUri: string | null, attributes?: ReadonlyArray<ElementAttr>, children?: ReadonlyArray<ElementChild>, prefix?: string | null): ElementNode;
+/** Create a text node. */
+export declare function text(value: string): TextNode;
+/** Attribute helper. */
+export declare function attr(name: string, value: string, namespaceUri?: string | null, prefix?: string | null): ElementAttr;
+/** Read attribute value by local name (any namespace) — first match. */
+export declare function getAttr(node: ElementNode, localName: string): string | undefined;
+/** Read attribute by local name + namespace URI (null = unnamespaced / any empty). */
+export declare function getAttrNS(node: ElementNode, localName: string, namespaceUri: string | null): string | undefined;
+/** Element children only. */
+export declare function elementChildren(node: ElementNode): ElementNode[];
+/** First element child with localName (+ optional ns predicate). */
+export declare function findChild(node: ElementNode, localName: string, nsPred?: (ns: string | null) => boolean): ElementNode | undefined;
+/** All element children with localName (+ optional ns predicate). */
+export declare function findChildren(node: ElementNode, localName: string, nsPred?: (ns: string | null) => boolean): ElementNode[];
+/** Concatenate descendant text (depth-first). */
+export declare function textContent(node: ElementNode): string;
+/** Deep-clone an element tree (mutable copies). */
+export declare function cloneElement(node: ElementNode): ElementNode;

package/src/features/diagrams/element-tree.js

@@ -0,0 +1,197 @@
+/**
+ * Local structural element tree for diagram parsers/serializers.
+ *
+ * Parsers MUST accept ElementTree only (no raw XML/bytes). A later TASK-9003
+ * unification may replace this with a shared core type; the public parse
+ * surface stays ElementTree-shaped.
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+export function isElementNode(node) {
+    return node.kind === 'element';
+}
+export function isTextNode(node) {
+    return node.kind === 'text';
+}
+/** Create an element node. */
+export function el(localName, namespaceUri, attributes, children, prefix) {
+    if (attributes === void 0) { attributes = []; }
+    if (children === void 0) { children = []; }
+    var node = { kind: 'element',
+        localName: localName,
+        namespaceUri: namespaceUri,
+        attributes: attributes,
+        children: children,
+    };
+    if (prefix != null && prefix !== '') {
+        return __assign({}, node, { prefix: prefix });
+    }
+    return node;
+}
+/** Create a text node. */
+export function text(value) {
+    return { kind: 'text', text: value };
+}
+/** Attribute helper. */
+export function attr(name, value, namespaceUri, prefix) {
+    var a = { name: name, value: value };
+    if (namespaceUri !== undefined) {
+        return __assign({}, a, { namespaceUri: namespaceUri }, (prefix != null && prefix !== '' ? { prefix: prefix } : {}));
+    }
+    return a;
+}
+/** Read attribute value by local name (any namespace) — first match. */
+export function getAttr(node, localName) {
+    var e_1, _a;
+    try {
+        for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var a = _c.value;
+            if (a.name === localName)
+                return a.value;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return undefined;
+}
+/** Read attribute by local name + namespace URI (null = unnamespaced / any empty). */
+export function getAttrNS(node, localName, namespaceUri) {
+    var e_2, _a;
+    try {
+        for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var a = _c.value;
+            var ans = (a.namespaceUri != null ? a.namespaceUri : null);
+            if (a.name === localName && ans === namespaceUri)
+                return a.value;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+/** Element children only. */
+export function elementChildren(node) {
+    var e_3, _a;
+    var out = [];
+    try {
+        for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var c = _c.value;
+            if (c.kind === 'element')
+                out.push(c);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return out;
+}
+/** First element child with localName (+ optional ns predicate). */
+export function findChild(node, localName, nsPred) {
+    var e_4, _a;
+    try {
+        for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var c = _c.value;
+            if (c.kind !== 'element')
+                continue;
+            if (c.localName !== localName)
+                continue;
+            if (nsPred && !nsPred(c.namespaceUri))
+                continue;
+            return c;
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return undefined;
+}
+/** All element children with localName (+ optional ns predicate). */
+export function findChildren(node, localName, nsPred) {
+    var e_5, _a;
+    var out = [];
+    try {
+        for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var c = _c.value;
+            if (c.kind !== 'element')
+                continue;
+            if (c.localName !== localName)
+                continue;
+            if (nsPred && !nsPred(c.namespaceUri))
+                continue;
+            out.push(c);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    return out;
+}
+/** Concatenate descendant text (depth-first). */
+export function textContent(node) {
+    var e_6, _a;
+    var s = '';
+    try {
+        for (var _b = __values(node.children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var c = _c.value;
+            if (c.kind === 'text')
+                s += c.text;
+            else
+                s += textContent(c);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return s;
+}
+/** Deep-clone an element tree (mutable copies). */
+export function cloneElement(node) {
+    return __assign({ kind: 'element', localName: node.localName, namespaceUri: node.namespaceUri }, (node.prefix != null ? { prefix: node.prefix } : {}), { attributes: node.attributes.map(function (a) { return (__assign({}, a)); }), children: node.children.map(function (c) {
+            return c.kind === 'text' ? { kind: 'text', text: c.text } : cloneElement(c);
+        }) });
+}

package/src/features/diagrams/errors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Typed errors for diagram parse / model / catalog operations.
+ * Load of recoverable diagram damage MUST NOT throw at package level;
+ * parsers of a single part MAY throw DiagramParseError for that part.
+ */
+export declare type DiagramErrorCode = 'invalid_root' | 'missing_required' | 'invalid_attribute' | 'limit_exceeded' | 'unknown_point' | 'inconsistent_graph' | 'invalid_rel_ids' | 'not_diagram' | 'catalog_error';
+export declare class DiagramError extends Error {
+    readonly code: DiagramErrorCode;
+    constructor(code: DiagramErrorCode, message: string);
+}
+export declare class DiagramParseError extends DiagramError {
+    constructor(code: DiagramErrorCode, message: string);
+}
+export declare class DiagramModelError extends DiagramError {
+    constructor(code: DiagramErrorCode, message: string);
+}
+export declare function isDiagramError(value: unknown): value is DiagramError;