ooxml-core 1.1.0 → 1.2.0

package/dist/diagram/engine/hier-measure.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Natural-size measurement for the `hierRoot`/`hierChild` pair (ECMA-376
+ * Part 1, 21.4.2.6/21.4.2.7), bottom-up, in the layout definition's own
+ * unscaled space: every item takes the `w`/`h` its composite was assigned by
+ * the outermost `hierChild`'s constraints (typically `w` = the whole frame's
+ * width, `h` a fixed fraction of it), `sibSp` separates siblings and `sp`
+ * separates a node from the rows it heads. Subtrees are outlines
+ * (`hier-shape.ts`) packed against each other; `alg-hier.ts` then scales the
+ * whole tree once, uniformly, to fit the frame.
+ *
+ * Measured against the gallery's cached "Hierarchy" drawing: composite
+ * `w = W`, `h = 0.667 W`, `sibSp = 0.1 W`, `sp = 0.25 h`; three generations
+ * stacked `3 h + 2 sp` exactly fill the 400pt frame, and the top node sits
+ * centred over its children's row.
+ */
+import type { EngineNode } from './engine-node.js';
+import type { HierShape } from './hier-shape.js';
+/** `node`'s own direct `hierRoot`-alg children (its items), in order. */
+export declare function itemsOf(node: EngineNode): EngineNode[];
+/**
+ * Measure a `hierChild` row: its items along `linDir` (`fromL`/`fromR` a
+ * horizontal row, `fromT`/`fromB` a vertical column), packed `sibSp` apart
+ * by outline, aligned across by `chAlign` (`t`/`l` start, `b`/`r` end).
+ */
+export declare function measureHierChild(node: EngineNode): HierShape;
+/**
+ * Measure a `hierRoot`: its own node and, on the side `hierAlign` names,
+ * its rows (stacked `sp` apart), the node aligned against the rows' own
+ * nodes (`CtrCh`/`CtrDes` centred, `L`/`T` start, `R`/`B` end). A `tL`/`tR`
+ * node over vertical columns hangs them instead (`hier-hang.ts`).
+ */
+export declare function measureHierRoot(root: EngineNode): HierShape;
+//# sourceMappingURL=hier-measure.d.ts.map

package/dist/diagram/engine/hier-measure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hier-measure.d.ts","sourceRoot":"","sources":["../../../diagram/engine/hier-measure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAO,UAAU,EAAE,MAAM,eAAe,CAAC;AAIrD,OAAO,KAAK,EAAE,SAAS,EAAe,MAAM,cAAc,CAAC;AAG3D,yEAAyE;AACzE,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,CAEtD;AAmDD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAS5D;AAwCD;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,SAAS,CAmE3D"}

package/dist/diagram/engine/hier-node-size.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The drawn extent of one hierarchy node (a `hierRoot`'s own content parts,
+ * usually one `composite`), in the definition's unscaled space.
+ */
+import type { EngineNode } from './engine-node.js';
+export interface NodeSize {
+    /** The drawn extent the node occupies in its tree. */
+    w: number;
+    h: number;
+    /** Each part's own size, and its offset inside that extent. */
+    partW: number;
+    partH: number;
+    dx: number;
+    dy: number;
+}
+/**
+ * The node's drawn extent: its content parts' own `w`/`h`, widened to
+ * whatever their children reach once the composite lays them out ("Name and
+ * Title Organization Chart"'s title box runs from `0.2 w` to `1.1 w`, so the
+ * node occupies more than its composite's own width).
+ */
+export declare function nodeSize(parts: readonly EngineNode[]): NodeSize;
+//# sourceMappingURL=hier-node-size.d.ts.map

package/dist/diagram/engine/hier-node-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hier-node-size.d.ts","sourceRoot":"","sources":["../../../diagram/engine/hier-node-size.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,MAAM,WAAW,QAAQ;IACxB,sDAAsD;IACtD,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACX;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,QAAQ,CA8B/D"}

package/dist/diagram/engine/hier-shape.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The outline a measured hierarchy subtree occupies: every drawn node's
+ * rectangle, relative to the subtree's own origin. Siblings are packed by
+ * these outlines rather than by bounding boxes (a Reingold-Tilford style
+ * contour packing), which is what PowerPoint does: "Organization Chart"
+ * rows keep the plain `W + sibSp` pitch although a hanging child juts
+ * `0.25 W` past its parent (it sits a generation lower, beside the empty
+ * space under the next sibling), and in `smartart-orgchart-nested-hang.pptx`
+ * Report B's three children fan out underneath its leaf siblings Report A
+ * and Report C instead of pushing them apart.
+ */
+import type { Box, EngineNode } from './engine-node.js';
+/** One drawn rectangle of a subtree outline; `node` is the part it places. */
+export interface OutlineRect extends Box {
+    node: EngineNode;
+}
+/** A measured subtree: its drawn outline and the extent of its own top-level node. */
+export interface HierShape {
+    rects: OutlineRect[];
+    /** The subtree's own node rectangle (the one siblings align and parents centre on). */
+    head: Box;
+}
+export declare function shiftShape(shape: HierShape, dx: number, dy: number): HierShape;
+export declare function boundsOf(rects: readonly Box[]): Box;
+/**
+ * The smallest shift along the packing axis that keeps every rectangle of
+ * `next` at least `gap` beyond every rectangle of `placed` it overlaps
+ * across that axis.
+ */
+export declare function packOffset(placed: readonly Box[], next: readonly Box[], gap: number, vertical: boolean): number;
+//# sourceMappingURL=hier-shape.d.ts.map

package/dist/diagram/engine/hier-shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hier-shape.d.ts","sourceRoot":"","sources":["../../../diagram/engine/hier-shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAErD,8EAA8E;AAC9E,MAAM,WAAW,WAAY,SAAQ,GAAG;IACvC,IAAI,EAAE,UAAU,CAAC;CACjB;AAED,sFAAsF;AACtF,MAAM,WAAW,SAAS;IACzB,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,uFAAuF;IACvF,IAAI,EAAE,GAAG,CAAC;CACV;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAK9E;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,EAAE,GAAG,GAAG,CAYnD;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACzB,MAAM,EAAE,SAAS,GAAG,EAAE,EACtB,IAAI,EAAE,SAAS,GAAG,EAAE,EACpB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,OAAO,GACf,MAAM,CAeR"}

package/dist/diagram/engine/index.d.ts

@@ -0,0 +1,6 @@
+export { runSmartArtEngine, type EngineRun } from './engine.js';
+export { runEngineLayout } from './engine-to-result.js';
+export { ENGINE_FIRST_LAYOUT_IDS } from './engine-first-allowlist.js';
+export { parseLayoutDefinitionXml } from './layout-def-parse.js';
+export type { EngineNode } from './engine-node.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/diagram/engine/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../diagram/engine/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,KAAK,SAAS,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}

package/dist/diagram/engine/layout-def-parse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Parse a DiagramML `dgm:layoutDef` part (as text) into the document-ordered
+ * {@link LdDefinition} the SmartArt layout engine executes. Attribute
+ * defaults follow the ECMA-376 Part 1 schema (21.4.2 / 21.4.7 simple types).
+ */
+import type { LdDefinition, LdIterator } from './layout-def-types.js';
+export declare function parseIterator(attrs: Record<string, string>): LdIterator;
+/**
+ * Parse layout-definition XML text. Returns `undefined` when the text holds
+ * no `layoutDef` with a root `layoutNode`.
+ */
+export declare function parseLayoutDefinitionXml(xml: string): LdDefinition | undefined;
+//# sourceMappingURL=layout-def-parse.d.ts.map

package/dist/diagram/engine/layout-def-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-def-parse.d.ts","sourceRoot":"","sources":["../../../diagram/engine/layout-def-parse.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAKX,YAAY,EAEZ,UAAU,EAKV,MAAM,oBAAoB,CAAC;AA6C5B,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,UAAU,CASvE;AA6JD;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAc9E"}

package/dist/diagram/engine/layout-def-types.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Typed, document-ordered model of a DiagramML `dgm:layoutDef`
+ * (ECMA-376 Part 1, 21.4.2), as executed by the SmartArt layout engine.
+ *
+ * Unlike the editable `DiagramLayoutNode` metadata the loader keeps for
+ * round-tripping, this model preserves the exact statement order inside every
+ * layout node, `dgm:forEach` and `dgm:choose` branch, and keeps each
+ * conditional branch intact, so the engine can evaluate the definition per
+ * data point the way PowerPoint does.
+ */
+/** Iterator attributes shared by `dgm:forEach`, `dgm:presOf` and `dgm:if`. */
+export interface LdIterator {
+    axis: string[];
+    ptType: string[];
+    hideLastTrans: boolean[];
+    st: number[];
+    cnt: number[];
+    step: number[];
+}
+/** `dgm:alg`. */
+export interface LdAlgorithm {
+    type: string;
+    params: Record<string, string>;
+}
+/** `dgm:shape`. */
+export interface LdShape {
+    type?: string | undefined;
+    rot: number;
+    zOrderOff: number;
+    hideGeom: boolean;
+    lkTxEntry: boolean;
+    blipPhldr: boolean;
+    adj: Record<number, number>;
+}
+/** `dgm:constr` (CT_Constraint), with ECMA defaults already applied. */
+export interface LdConstraint {
+    type: string;
+    for: 'self' | 'ch' | 'des';
+    forName?: string | undefined;
+    ptType: string;
+    refType: string;
+    refFor: 'self' | 'ch' | 'des';
+    refForName?: string | undefined;
+    refPtType: string;
+    op: 'none' | 'equ' | 'gte' | 'lte';
+    val: number;
+    /** Whether `val` was written (an `op="equ"` without one only links values). */
+    hasVal: boolean;
+    fact: number;
+}
+/** `dgm:rule` (CT_NumericRule); NaN marks an absent value. */
+export interface LdRule {
+    type: string;
+    for: 'self' | 'ch' | 'des';
+    forName?: string | undefined;
+    ptType: string;
+    val: number;
+    fact: number;
+    max: number;
+}
+/** `dgm:if` condition. */
+export interface LdCondition extends LdIterator {
+    func: string;
+    arg?: string | undefined;
+    op: string;
+    val: string;
+}
+export interface LdForEach {
+    kind: 'forEach';
+    name?: string | undefined;
+    ref?: string | undefined;
+    iterator: LdIterator;
+    body: LdStatement[];
+}
+export interface LdChooseBranch {
+    /** Absent for the `dgm:else` branch. */
+    condition?: LdCondition | undefined;
+    body: LdStatement[];
+}
+export interface LdChoose {
+    kind: 'choose';
+    branches: LdChooseBranch[];
+}
+export interface LdLayoutNode {
+    kind: 'layoutNode';
+    name: string;
+    styleLbl?: string | undefined;
+    chOrder: 'b' | 't';
+    moveWith?: string | undefined;
+    body: LdStatement[];
+}
+export type LdStatement = LdLayoutNode | LdForEach | LdChoose | {
+    kind: 'alg';
+    alg: LdAlgorithm;
+} | {
+    kind: 'shape';
+    shape: LdShape;
+} | {
+    kind: 'presOf';
+    iterator: LdIterator;
+} | {
+    kind: 'constrLst';
+    constraints: LdConstraint[];
+} | {
+    kind: 'ruleLst';
+    rules: LdRule[];
+} | {
+    kind: 'varLst';
+    vars: Record<string, string>;
+};
+/** A parsed layout definition: its root layout node plus named forEach bodies. */
+export interface LdDefinition {
+    uniqueId?: string | undefined;
+    root: LdLayoutNode;
+    /** Every named `dgm:forEach`, for `ref` resolution. */
+    forEachByName: Map<string, LdForEach>;
+}
+//# sourceMappingURL=layout-def-types.d.ts.map

package/dist/diagram/engine/layout-def-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-def-types.d.ts","sourceRoot":"","sources":["../../../diagram/engine/layout-def-types.ts"],"names":[],"mappings":"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"}

package/dist/diagram/engine/layout-driver.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Top-down layout driver. Each node receives its final box from its parent's
+ * algorithm; it then evaluates its own constraint list against that box
+ * (assigning preferred values to its children and descendants) and runs its
+ * own algorithm to place its children, recursively.
+ *
+ * An algorithm that has to shrink its content to fit (a `lin` row that is
+ * wider than the node) does so by re-evaluating the node's constraints
+ * against a scaled reference box ({@link evaluateWithReference}): every child
+ * value derived from the node's own `w`/`h` then scales with it, which is how
+ * PowerPoint keeps a `refType="w"` item width, a `fact="0.4"` arrow slot and
+ * a `fact="-0.015"` overlap in proportion while fitting them.
+ */
+import type { Box, EngineNode } from './engine-node.js';
+/** Places `node`'s children (sets each child's `box`); `node.box` is final. */
+export type ArrangeAlgorithm = (node: EngineNode) => void;
+/**
+ * Evaluate `node`'s constraints with its own `w`/`h` taken as `refW`/`refH`.
+ * Self-scoped geometry constraints are skipped: they sized the node for its
+ * parent and must not override the box the parent chose.
+ */
+export declare function evaluateWithReference(node: EngineNode, refW: number, refH: number): void;
+/** Give every child the parent's full box (algorithms without placement). */
+export declare function fillChildren(node: EngineNode): void;
+export interface LayoutRegistry {
+    resolve(type: string): ArrangeAlgorithm;
+    /**
+     * An optional pass run AFTER `node`'s own children (and their whole
+     * subtrees) have finished laying out - for a correction that needs a
+     * descendant's FINAL box, not just the box the parent algorithm itself
+     * assigned (`pyra`'s `pyraAcctRatio` band split reads and rewrites a
+     * band's already-composited `level`/`acctBkgd`/`acctTx` boxes; see
+     * `alg-pyra.ts`'s `applyPyraAccentSplit`).
+     */
+    resolvePost?(type: string): ArrangeAlgorithm | undefined;
+}
+/** Lay out `node` (whose box is set) and, recursively, its subtree. */
+export declare function layoutSubtree(node: EngineNode, registry: LayoutRegistry): void;
+/** Lay out the whole tree inside a `width` x `height` point frame. */
+export declare function layoutTree(root: EngineNode, frame: Box, registry: LayoutRegistry): void;
+//# sourceMappingURL=layout-driver.d.ts.map

package/dist/diagram/engine/layout-driver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-driver.d.ts","sourceRoot":"","sources":["../../../diagram/engine/layout-driver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGrD,+EAA+E;AAC/E,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;AAI1D;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAsBxF;AAkBD,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAQnD;AAED,MAAM,WAAW,cAAc;IAC9B,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACxC;;;;;;;OAOG;IACH,WAAW,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAAC;CACzD;AAED,uEAAuE;AACvE,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,CAU9E;AAmCD,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,cAAc,GAAG,IAAI,CASvF"}

package/dist/diagram/engine/layout-font.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Font sizes as the LAYOUT sees them, before the output stage fits text
+ * (`font-groups.ts`). A node's font is known during layout only inside a
+ * text-driven font search (`font-search.ts`): the search fixes a candidate
+ * size on the nodes its `dgm:rule type="primFontSz"` addresses
+ * (`EngineNode.forcedFontPt`), and every other node reaches that size
+ * through its own `refType="primFontSz"`/`"secFontSz"` links ("Vertical
+ * Bullet List"'s `childText` follows `parentText`; "Horizontal Bullet
+ * List"'s `desTx` sizes by its `secFontSz`, which equals `parTx`'s
+ * `primFontSz`). Outside a search every function here answers `undefined`
+ * and font-relative lengths stay deferred, exactly as before.
+ */
+import type { EngineNode } from './engine-node.js';
+/**
+ * The font-size variable a node's text is sized by: `primFontSz`, unless the
+ * node declares `<dgm:constr type="primFontSz" refType="secFontSz"/>` on
+ * itself, in which case its text follows its own `secFontSz` and the
+ * `secFontSz` rules ("Basic Pyramid"'s `acctTx` accent column: no
+ * `primFontSz` rule at all, a `secFontSz` rule down to 5pt, cached at 35pt
+ * instead of the 65pt start).
+ */
+export declare function sizingVariable(node: EngineNode): 'primFontSz' | 'secFontSz';
+/** The size (points) `node`'s text is laid out at during a font search, if known. */
+export declare function layoutFontOf(node: EngineNode, seen?: Set<EngineNode>): number | undefined;
+/** `ref`'s value of font variable `refType` during a search (a primary-sized node's `secFontSz` is `round(0.78 x primFontSz)`). */
+export declare function layoutFontRef(ref: EngineNode, refType: string, seen?: Set<EngineNode>): number | undefined;
+//# sourceMappingURL=layout-font.d.ts.map

package/dist/diagram/engine/layout-font.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-font.d.ts","sourceRoot":"","sources":["../../../diagram/engine/layout-font.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAOhD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,YAAY,GAAG,WAAW,CAK3E;AAED,qFAAqF;AACrF,wBAAgB,YAAY,CAC3B,IAAI,EAAE,UAAU,EAChB,IAAI,GAAE,GAAG,CAAC,UAAU,CAAa,GAC/B,MAAM,GAAG,SAAS,CAsBpB;AAED,mIAAmI;AACnI,wBAAgB,aAAa,CAC5B,GAAG,EAAE,UAAU,EACf,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,GAAG,CAAC,UAAU,CAAa,GAC/B,MAAM,GAAG,SAAS,CASpB"}

package/dist/diagram/engine/move-with-merge.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `dgm:layoutNode/@moveWith` (ECMA-376 Part 1, 21.4.2.19) pairs a hidden text
+ * carrier with the sibling shape whose geometry it tracks. Two authoring
+ * patterns share this attribute, and only one of them wants a merge:
+ *
+ * - Numbered Title List / Numbered Card List: `nodeText` (`hideGeom`,
+ *   `presOf` axis `desOrSelf`) presents the SAME point as `bgRect`
+ *   (`presOf` axis `self`) plus any demoted descendants folded in. Painting
+ *   both doubles the item in the text-keyed comparison (the background
+ *   under its own truncated text, the carrier under the fuller one) even
+ *   though PowerPoint paints exactly one shape: `bgRect`'s geometry/style
+ *   carrying `nodeText`'s fuller text. Here the carrier's presented ids are
+ *   a SUPERSET of the target's own, so folding the extra ids into the
+ *   target and dropping the carrier reproduces that one shape.
+ * - Detailed Process: `childNode` (`hideGeom`, `presOf` axis `des` only)
+ *   presents a DIFFERENT, demoted SIBLING point than `bgRect`'s own `self`
+ *   point (a disjoint id set, not a superset) - PowerPoint paints these as
+ *   two separate, independently positioned boxes (a promoted step's own
+ *   card plus its demoted child's card alongside it), so the carrier must
+ *   keep rendering on its own.
+ *
+ * `computeMoveWithMerge`'s `every` check below is exactly that distinction:
+ * fold and suppress only when the target's own ids are already fully covered
+ * by the carrier's, so the carrier is strictly "the target's content plus
+ * more," never "different content the target doesn't have."
+ */
+import type { EngineNode } from './engine-node.js';
+/** Data-model nodes this rendered point presents text for, in `presOf` order. */
+export declare function sourceIdsOf(node: EngineNode): string[];
+export interface MoveWithMerge {
+    /** `moveWith` target layout-node name -> extra source ids folded into it. */
+    extraIdsByTarget: Map<string, string[]>;
+    /** Carrier nodes that were folded into a target and must not render on their own. */
+    suppressed: Set<EngineNode>;
+    /**
+     * `moveWith` target layout-node name -> the carrier folded into it. The
+     * carrier is the `tx` node that actually sized the text (its own box,
+     * margins and `primFontSz` constraints), so font fitting reads it rather
+     * than the decorative target shape.
+     */
+    carrierByTarget: Map<string, EngineNode>;
+}
+/**
+ * `moveWith` only ever pairs SIBLINGS (nodes sharing the same parent), so
+ * this is computed once per sibling group as the engine tree is walked, not
+ * globally: see `engine-to-result.ts`'s `collectRenderedNodes`.
+ */
+export declare function computeMoveWithMerge(siblings: EngineNode[]): MoveWithMerge;
+//# sourceMappingURL=move-with-merge.d.ts.map

package/dist/diagram/engine/move-with-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-with-merge.d.ts","sourceRoot":"","sources":["../../../diagram/engine/move-with-merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,iFAAiF;AACjF,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,EAAE,CAQtD;AAED,MAAM,WAAW,aAAa;IAC7B,6EAA6E;IAC7E,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IACxC,qFAAqF;IACrF,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;IAC5B;;;;;OAKG;IACH,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CACzC;AA8BD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,aAAa,CAoC1E"}

package/dist/diagram/engine/node-text.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The text a presentation node shows, as paragraphs the text measurement
+ * understands (`text-measure.ts`'s {@link NodeText}). Shared by the output
+ * stage's font fit (`engine-fonts.ts`) and the layout's text-driven sizing
+ * (`text-grow.ts`), so both measure exactly the same paragraphs.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { EngineNode } from './engine-node.js';
+import type { NodeText } from './text-measure.js';
+/**
+ * A node whose own context point is among the points it presents shows that
+ * point's text as its top-level paragraph and every other presented point as
+ * a folded descendant; a node presenting only other points (a
+ * descendant-only "child text" box) shows them all as equal-level bullet
+ * paragraphs. `literal` is a transition point's label, used when no content
+ * point is presented; `fitNode` is the node whose `tx` parameters and
+ * sizing variable apply (a folded `moveWith` carrier, else `node`).
+ */
+export declare function nodeTextFor(node: EngineNode, ids: readonly string[], literal: string | undefined, nodeById: Map<string, DiagramNode>, fitNode?: EngineNode): NodeText | undefined;
+//# sourceMappingURL=node-text.d.ts.map

package/dist/diagram/engine/node-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-text.d.ts","sourceRoot":"","sources":["../../../diagram/engine/node-text.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAkB/C;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAC1B,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,SAAS,MAAM,EAAE,EACtB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,OAAO,GAAE,UAAiB,GACxB,QAAQ,GAAG,SAAS,CAoBtB"}

package/dist/diagram/engine/ordered-xml.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Minimal document-order XML reader for DiagramML layout definitions.
+ *
+ * The package-wide fast-xml-parser configuration drops the interleaving of
+ * differently-named siblings (it groups children into one array per tag), but
+ * a `dgm:layoutNode` body is an ordered sequence: a `dgm:forEach` between two
+ * `dgm:layoutNode`s decides where the iterated shapes sit among their
+ * siblings, which in turn decides a `lin` algorithm's placement order. This
+ * reader keeps that order. It only needs elements and attributes (layout
+ * definitions carry no mixed text content that the engine consumes), strips
+ * namespace prefixes, and decodes the five predefined XML entities plus
+ * numeric character references in attribute values.
+ */
+/** One element in document order, named by its local name (prefix removed). */
+export interface OrderedXmlElement {
+    name: string;
+    attrs: Record<string, string>;
+    children: OrderedXmlElement[];
+}
+/**
+ * Parse `xml` and return its document element, or `undefined` when the text
+ * holds no element at all. Comments, processing instructions, CDATA sections
+ * and DOCTYPE declarations are skipped. Linear in the input length.
+ */
+export declare function parseOrderedXml(xml: string): OrderedXmlElement | undefined;
+/** First direct child named `name`. */
+export declare function orderedChild(element: OrderedXmlElement | undefined, name: string): OrderedXmlElement | undefined;
+/** Depth-first search for the first descendant named `name`. */
+export declare function findOrderedDescendant(element: OrderedXmlElement | undefined, name: string): OrderedXmlElement | undefined;
+//# sourceMappingURL=ordered-xml.d.ts.map

package/dist/diagram/engine/ordered-xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordered-xml.d.ts","sourceRoot":"","sources":["../../../diagram/engine/ordered-xml.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,+EAA+E;AAC/E,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,EAAE,iBAAiB,EAAE,CAAC;CAC9B;AAoGD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS,CAwD1E;AAED,uCAAuC;AACvC,wBAAgB,YAAY,CAC3B,OAAO,EAAE,iBAAiB,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GACV,iBAAiB,GAAG,SAAS,CAE/B;AAED,gEAAgE;AAChE,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,iBAAiB,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GACV,iBAAiB,GAAG,SAAS,CAc/B"}

package/dist/diagram/engine/preferred-size.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A child's preferred size, as an arranging algorithm sees it: the values
+ * its parent's (and ancestors') constraints assigned, refined by the child's
+ * own self-scoped size constraints (`<dgm:constr type="h" refType="w"
+ * fact="0.6"/>` declared on the child itself keeps its aspect).
+ */
+import type { EngineNode } from './engine-node.js';
+/** Whether a constraint declared on `node` sizes the node itself. */
+export declare function isSelfSizeConstraint(node: EngineNode, index: number): boolean;
+export interface Size {
+    w: number;
+    h: number;
+}
+/**
+ * Apply `child`'s own self-scoped `w`/`h` constraints over the values its
+ * ancestors assigned, then read its size, defaulting an unconstrained
+ * dimension to `fallback`.
+ */
+export declare function preferredSize(child: EngineNode, fallback: Size): Size;
+/**
+ * Re-apply `node`'s own self-scoped `w`/`h` constraints over what its
+ * ancestors assigned. A bare literal one (`<dgm:constr type="h"/>`, no
+ * reference) is only the node's DEFAULT: it yields to a value an ancestor
+ * assigned during a text-driven font search ("Basic Chevron Process"'s
+ * `parTx` declares a bare `h` while the diagram sizes it `1.5 x primFontSz`).
+ */
+export declare function applySelfSizeConstraints(node: EngineNode): void;
+//# sourceMappingURL=preferred-size.d.ts.map

package/dist/diagram/engine/preferred-size.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preferred-size.d.ts","sourceRoot":"","sources":["../../../diagram/engine/preferred-size.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAKhD,qEAAqE;AACrE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAG7E;AAED,MAAM,WAAW,IAAI;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,IAAI,GAAG,IAAI,CAYrE;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAY/D"}

package/dist/diagram/engine/pres-tree.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Expand a layout definition against the data model into the presentation
+ * tree: one {@link PresNode} per `dgm:layoutNode` instance, created for the
+ * data point in context when the statement is reached (ECMA-376 Part 1,
+ * 21.4.2.19 / 21.4.4). `dgm:forEach` rebinds the context point for its body,
+ * `dgm:choose` runs the first branch whose `dgm:if` holds for the context
+ * point, and a node's own `alg`/`shape`/`presOf`/constraint/rule/variable
+ * statements (including ones nested in a `choose`) configure that instance.
+ */
+import type { DataPoint } from './data-points.js';
+import type { LdAlgorithm, LdConstraint, LdDefinition, LdRule, LdShape } from './layout-def-types.js';
+export interface PresNode {
+    name: string;
+    styleLbl?: string | undefined;
+    /**
+     * `dgm:layoutNode/@moveWith`: the name of a SIBLING layout node (within the
+     * same parent) this node's geometry tracks (ECMA-376 Part 1, 21.4.2.19).
+     * Combined with a `hideGeom` shape, this is how a decorative background
+     * (e.g. `bgRect`) and a borderless text carrier (e.g. `nodeText`) that both
+     * present the same data point are authored as two layout nodes but meant
+     * to read as ONE visual shape; see `engine-to-result.ts`'s sibling-merge
+     * pass, which is the only place this field is consumed.
+     */
+    moveWith?: string | undefined;
+    /** Data point in context when this instance was created. */
+    point: DataPoint;
+    alg: LdAlgorithm;
+    shape?: LdShape;
+    /** Points whose text this node presents (`dgm:presOf`). */
+    presOf: DataPoint[];
+    /** Whether the node declared any `dgm:presOf` axis at all. */
+    hasPresOf: boolean;
+    /**
+     * Whether the `dgm:presOf` iterator's last axis step includes the point
+     * itself (`self`, `desOrSelf`, `ancstOrSelf`): the first presented point is
+     * then the text's own top-level paragraph and the rest fold under it as
+     * smaller bullets ("Basic Pie"'s wedge: "Node One" 23pt, its child 18pt).
+     * A pure `des`/`ch` iterator presents every point as an equal bullet
+     * ("Vertical Bullet List"'s `childText`: child and grandchild both 27pt).
+     */
+    presOfAnchored: boolean;
+    constraints: LdConstraint[];
+    rules: LdRule[];
+    vars: Record<string, string>;
+    children: PresNode[];
+    parent?: PresNode | undefined;
+    /** Document-order index, used for stable z-ordering. */
+    order: number;
+}
+/** Diagram-level variable overrides stored in the data model. */
+export interface PresTreeOptions {
+    direction?: 'norm' | 'rev' | undefined;
+}
+/** Expand `def` for the data model rooted at `doc`. */
+export declare function buildPresentationTree(def: LdDefinition, doc: DataPoint, options?: PresTreeOptions): PresNode | undefined;
+/** Every node of the tree in pre-order. */
+export declare function flattenPresTree(root: PresNode): PresNode[];
+//# sourceMappingURL=pres-tree.d.ts.map

package/dist/diagram/engine/pres-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pres-tree.d.ts","sourceRoot":"","sources":["../../../diagram/engine/pres-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EAGZ,MAAM,EACN,OAAO,EAEP,MAAM,oBAAoB,CAAC;AAE5B,MAAM,WAAW,QAAQ;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,4DAA4D;IAC5D,KAAK,EAAE,SAAS,CAAC;IACjB,GAAG,EAAE,WAAW,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2DAA2D;IAC3D,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,8DAA8D;IAC9D,SAAS,EAAE,OAAO,CAAC;IACnB;;;;;;;OAOG;IACH,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,YAAY,EAAE,CAAC;IAC5B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,QAAQ,EAAE,QAAQ,EAAE,CAAC;IACrB,MAAM,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;IAC9B,wDAAwD;IACxD,KAAK,EAAE,MAAM,CAAC;CACd;AAED,iEAAiE;AACjE,MAAM,WAAW,eAAe;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;CACvC;AA6ID,uDAAuD;AACvD,wBAAgB,qBAAqB,CACpC,GAAG,EAAE,YAAY,EACjB,GAAG,EAAE,SAAS,EACd,OAAO,GAAE,eAAoB,GAC3B,QAAQ,GAAG,SAAS,CAEtB;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAQ1D"}

package/dist/diagram/engine/registry.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Algorithm registry: maps a `dgm:alg/@type` to the function that places a
+ * node's children.
+ */
+import type { LayoutRegistry } from './layout-driver.js';
+export declare const DEFAULT_REGISTRY: LayoutRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/diagram/engine/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../diagram/engine/registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AASH,OAAO,KAAK,EAAoB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAqBxE,eAAO,MAAM,gBAAgB,EAAE,cAO9B,CAAC"}

package/dist/diagram/engine/render-filter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Which engine nodes become drawn shapes, and the literal text a transition
+ * point carries. Split out of `engine-to-result.ts` for the file-size
+ * budget.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { EngineNode } from './engine-node.js';
+/**
+ * A presented `parTrans`/`sibTrans` transition point's own connector text
+ * (`DataPoint.label`, e.g. a numbered-list badge's ordinal "1"/"2"/"3", or an
+ * org-chart relationship line's label) - there is no `DiagramNode` to
+ * read `.text` from for a transition point (`point.source` is only ever set
+ * for a `node`/`asst` content point), so this is the transition-point
+ * equivalent `sourceIdsOf`'s content-point lookup can't cover. Only consulted
+ * when `sourceIdsOf` found nothing, matching the drawing bridge's own
+ * `literalText ?? projection?.text` precedence
+ * (`smartart-interpreter-drawing-bridge.ts`).
+ */
+export declare function transitionLabelOf(node: EngineNode): string | undefined;
+/**
+ * `hideGeom` (ECMA-376 Part 1, 21.4.7.16 `ST_OnOffStyleType`) means the node
+ * draws NO visible border/fill, not that it is not a node: PowerPoint still
+ * places its own text-bearing shape there (invisible outline, real text),
+ * commonly a "descendant" role box folded under a sibling's card (see
+ * `Vertical Action List`/`Descending Block List`/`Numbered Title List`: an
+ * item's own child node text renders as a second, borderless line inside the
+ * same visual card). Dropping every `hideGeom` node outright previously lost
+ * those boxes entirely (2-3 of 5-6 text-bearing shapes per fixture) even
+ * though the engine placed correct geometry for them; a `hideGeom` node with
+ * NO presented text (a genuinely decorative/structural placeholder, e.g. a
+ * sibling row with no descendant) is still skipped, since it carries nothing
+ * to compare or display.
+ *
+ * A ZERO-AREA node is also skipped regardless of `hideGeom`/text: a
+ * `hierChild` continuation for a childless leaf (the layout driver gives an
+ * unplaced child a `{w:0, h:0}` box) presents no text either way, so it was never
+ * going to draw anything visible - but it still reached `isFiniteGeometry`
+ * below as a "real" shape with degenerate geometry, declining the WHOLE
+ * diagram over a box nothing would have shown (the same failure mode
+ * `collectRenderedNodes`'s own `conn`-alg skip fixes for connectors).
+ */
+export declare function isRenderable(node: EngineNode, presented: readonly (DiagramNode | undefined)[], literalText: string | undefined): boolean;
+//# sourceMappingURL=render-filter.d.ts.map

package/dist/diagram/engine/render-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-filter.d.ts","sourceRoot":"","sources":["../../../diagram/engine/render-filter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAOtE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,UAAU,EAChB,SAAS,EAAE,SAAS,CAAC,WAAW,GAAG,SAAS,CAAC,EAAE,EAC/C,WAAW,EAAE,MAAM,GAAG,SAAS,GAC7B,OAAO,CAkBT"}

package/dist/diagram/engine/shape-adjust.d.ts

@@ -0,0 +1,16 @@
+/**
+ * DrawingML preset adjustments from a layout definition's `dgm:adjLst`.
+ *
+ * `dgm:adj` (ECMA-376 Part 1, 21.4.3.1) addresses a preset's adjust handle
+ * by 1-based index and writes its value in natural units: a FRACTION for a
+ * length handle (`roundRect`'s `<dgm:adj idx="1" val="0.1"/>` is a 10%
+ * corner, i.e. `adj = 10000` in the preset's own 1/100000 units) and
+ * DEGREES for an angle handle (`blockArc`/`circularArrow`'s `val="90"` is
+ * `5400000` in 1/60000 degree). Which one a handle is follows from the
+ * preset's own default: every angle default in the preset table is a
+ * 1/60000-degree value in the millions, every length default is at most a
+ * few hundred thousand.
+ */
+/** `{ adj1: 10000, ... }` for `evaluatePresetShape`, or undefined when nothing is declared. */
+export declare function presetAdjustments(presetName: string, adj: Record<number, number> | undefined): Record<string, number> | undefined;
+//# sourceMappingURL=shape-adjust.d.ts.map

package/dist/diagram/engine/shape-adjust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape-adjust.d.ts","sourceRoot":"","sources":["../../../diagram/engine/shape-adjust.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAChC,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,GACrC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAapC"}