ooxml-core 1.1.0 → 1.2.0

package/dist/diagram/engine/constraint-fill-idiom.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The `ctrX`/`w` (or `ctrY`/`h`) "fill and centre" idiom (ECMA-376 Part 1,
+ * 21.4.2.x `dgm:constr`), split out of `constraint-eval.ts` to keep that file
+ * under the repo's per-file line budget.
+ *
+ * A composite child's size/position types (`w`, `h`, `l`, `t`, `r`, `b`,
+ * `ctrX`, `ctrY`) are ordinarily genuine absolute lengths in the same
+ * millimetre convention `constraint-eval.ts` applies to every other bare
+ * literal (e.g. Gear's `gear1srcNode`/`gear1dstNode` anchor points declare
+ * `w val="1"` / `h val="1"` alongside an `l`/`t`/`r` position - a real, tiny
+ * ~2.83pt marker box the `conn` algorithm routes a connector through;
+ * treating that pair as anything else regresses Gear's measured geometry).
+ * But when a `constrLst` declares BOTH a centre (`ctrX`/`ctrY`) AND its
+ * paired size (`w`/`h`) as bare literals for the SAME target (no
+ * `l`/`t`/`r`/`b` at all) - real "Basic Pyramid"'s layout1.xml:
+ * `<dgm:constr type="ctrX" for="ch" forName="level" val="1"/>` beside
+ * `<dgm:constr type="w" for="ch" forName="level" val="1"/>` (and the same
+ * pairing for `ctrY`/`h`, and for `acctBkgd`/`acctTx`) - no consistent
+ * absolute-length reading of `val="1"` can produce "fill the box": `ctrX = w`
+ * under ANY single unit conversion places the box from `w/2` to `3w/2`, never
+ * centred edge-to-edge. COM-verified against Basic Pyramid, the actual
+ * rendered "level" band fills its WHOLE slot, which is exactly the composite
+ * algorithm's own DEFAULT for an unconstrained child (`compositeChildBoxes`'s
+ * `resolveSize`/`resolveAxis` fall back to the preferred/full size when
+ * nothing is set) - so this idiom is read as "a fraction of the declaring
+ * node's own already-resolved size" per axis, the same convention the legacy
+ * family interpreter independently derived (`resolveRatioConstraint` /
+ * `smartart-constraint-ratio-fallback.ts`) and `alg-cycle.ts`'s own
+ * `resolveGapRatio`: a literal `val` in `[0, 1)` is that fraction; `val >= 1`
+ * (including the pyramid's own redundant `val="1"`, which just restates the
+ * composite's default) does not correspond to any valid fraction and is
+ * treated as unconstrained, falling back to the algorithm's natural sizing -
+ * a no-op that matches COM output exactly.
+ *
+ * Scanning the whole 229-fixture gallery corpus for this exact `ctrX`+`w`
+ * (or `ctrY`+`h`) bare-literal pairing finds it ONLY in `basic-pyramid--*`
+ * and `inverted-pyramid--*`, so this reading never touches Gear's anchor
+ * points, the numbered linear arrow process's own hairline connector (`h
+ * val="0.002"`, which has no `ctrX`/`ctrY` peer and so keeps the ordinary
+ * millimetre reading - 0.002mm, still an effectively-invisible line), or any
+ * other fixture's `w`/`h`/`l`/`t`/`r`/`b`/`ctrX`/`ctrY` literal.
+ */
+import type { EngineNode } from './engine-node.js';
+import type { LdConstraint } from './layout-def-types.js';
+/**
+ * Whether `constraint` (a `ctrX`/`w`/`ctrY`/`h` bare literal) has a matching
+ * bare-literal peer declared for the SAME `for`/`forName`/`ptType` target in
+ * `node`'s own `constrLst`. Only then is the literal read as a fraction
+ * (via {@link fillIdiomFraction}) rather than a length.
+ */
+export declare function hasFillIdiomPeer(node: EngineNode, constraint: LdConstraint): boolean;
+/**
+ * `constraint`'s bare literal `val`, read as a fraction of `node`'s (the
+ * declaring node's) own already-resolved size on that axis. Only call this
+ * once {@link hasFillIdiomPeer} confirms the idiom applies: a fraction in
+ * `[0, 1)`, or `undefined` when `val` is out of that range (no valid
+ * fraction, hence unconstrained) or the declaring node's own size isn't
+ * resolved yet.
+ */
+export declare function fillIdiomFraction(node: EngineNode, constraint: LdConstraint): number | undefined;
+//# sourceMappingURL=constraint-fill-idiom.d.ts.map

package/dist/diagram/engine/constraint-fill-idiom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-fill-idiom.d.ts","sourceRoot":"","sources":["../../../diagram/engine/constraint-fill-idiom.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAcvD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,GAAG,OAAO,CAepF;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,GAAG,MAAM,GAAG,SAAS,CAQhG"}

package/dist/diagram/engine/constraint-units.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Units and value assignment shared by constraint evaluation
+ * (`constraint-eval.ts`) and font-relative length resolution
+ * (`font-length.ts`).
+ */
+import type { EngineNode } from './engine-node.js';
+import type { LdConstraint } from './layout-def-types.js';
+export declare const POINTS_PER_MM: number;
+/** Constraint types that are lengths (literal values in millimetres). */
+export declare const LENGTH_TYPES: Set<string>;
+/**
+ * Text-frame margins are POINTS, not millimetres (the font-size unit, so a
+ * `refType="primFontSz"` margin is simply `fact x size`). Measured against
+ * the cached drawings: a literal `rMarg val="20"` ("Increasing Arrows
+ * Process") is a 20pt `rIns`, a literal `lMarg val="1"` ("Horizontal
+ * Hierarchy") a 1pt `lIns`, and a length-referenced `tMarg refType="h"
+ * fact="0.28"` ("Vertical Action List") is `0.28 x` the node's height
+ * IN MILLIMETRES read as points (a 128.1pt = 45.2mm tall box gets a
+ * 12.66pt `tIns`, not 35.9pt).
+ */
+export declare const MARGIN_TYPES: Set<string>;
+/**
+ * A reference whose value is a length: a geometry type, or a `userA`-`userZ`
+ * variable, which the built-in layouts only ever assign lengths to and read
+ * back in margins as `fact="2.834"` (points per millimetre) - "Upward
+ * Arrow"'s `lMarg refType="userA" fact="2.834"` is an 8.8pt inset for a
+ * 3.1mm `userA`.
+ */
+export declare function isLengthReference(refType: string): boolean;
+export declare const FONT_TYPES: Set<string>;
+/** Types an algorithm computes itself; a bare constraint must not zero them. */
+export declare const COMPUTED_TYPES: Set<string>;
+/** Store a constraint's value on `target` (a bound for `gte`/`lte`). */
+export declare function assign(target: EngineNode, constraint: LdConstraint, value: number): void;
+//# sourceMappingURL=constraint-units.d.ts.map

package/dist/diagram/engine/constraint-units.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-units.d.ts","sourceRoot":"","sources":["../../../diagram/engine/constraint-units.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,eAAO,MAAM,aAAa,QAAY,CAAC;AAEvC,yEAAyE;AACzE,eAAO,MAAM,YAAY,aA0BvB,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,aAAgD,CAAC;AAE1E;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,eAAO,MAAM,UAAU,aAAuC,CAAC;AAE/D,gFAAgF;AAChF,eAAO,MAAM,cAAc,aAAwB,CAAC;AAEpD,wEAAwE;AACxE,wBAAgB,MAAM,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAiBxF"}

package/dist/diagram/engine/data-points.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The semantic data model the SmartArt layout engine walks: the `doc` point,
+ * every content point (`node`/`asst`), and the `parTrans`/`sibTrans`
+ * transition points of each parent-child connection, arranged as the tree the
+ * DiagramML axes (ECMA-376 Part 1, 21.4.7.6 ST_AxisType) navigate.
+ *
+ * Under a parent, each child connection contributes three points in this
+ * order: its `parTrans`, the child content point, then its `sibTrans`. That
+ * ordering is what makes `precedSib ptType="parTrans"` and `followSib
+ * ptType="sibTrans" cnt="1"` resolve to the transitions around a node, and it
+ * is how PowerPoint's built-in layouts address connectors and arrows.
+ *
+ * Presentation (`pres`) points in the data part are deliberately ignored:
+ * they are PowerPoint's own cached output, and a diagram from another
+ * producer does not have them.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { DiagramConnection } from '../types.js';
+export type PointType = 'doc' | 'node' | 'asst' | 'parTrans' | 'sibTrans';
+export interface DataPoint {
+    id: string;
+    type: PointType;
+    /** Content point for `node`/`asst`; undefined for doc and transitions. */
+    source?: DiagramNode;
+    /** Connector text for a transition point. */
+    label?: string | undefined;
+    parent?: DataPoint;
+    /** Ordered children: parTrans, node, sibTrans per child connection. */
+    children: DataPoint[];
+}
+export interface DataModel {
+    doc: DataPoint;
+    byId: Map<string, DataPoint>;
+}
+/**
+ * Build the engine's data tree from the loader's node list and connections.
+ * Child order follows each parent connection's `srcOrd` (falling back to
+ * node-list order); transitions missing from the connection list are
+ * synthesised so every child still has its `parTrans`/`sibTrans` pair.
+ */
+export declare function buildDataModel(nodes: DiagramNode[], connections: DiagramConnection[] | undefined): DataModel;
+/** Content children (`node`/`asst`) of a point, in order. */
+export declare function contentChildren(point: DataPoint): DataPoint[];
+/** Depth of a content point below the doc point (top-level nodes are 1). */
+export declare function pointDepth(point: DataPoint): number;
+/** Deepest content-point depth below `point` (0 when it has no content children). */
+export declare function maxContentDepth(point: DataPoint): number;
+//# sourceMappingURL=data-points.d.ts.map

package/dist/diagram/engine/data-points.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-points.d.ts","sourceRoot":"","sources":["../../../diagram/engine/data-points.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAElD,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,CAAC;AAE1E,MAAM,WAAW,SAAS;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,SAAS,CAAC;IAChB,0EAA0E;IAC1E,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,uEAAuE;IACvE,QAAQ,EAAE,SAAS,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,SAAS;IACzB,GAAG,EAAE,SAAS,CAAC;IACf,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;CAC7B;AAyBD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,WAAW,EAAE,EACpB,WAAW,EAAE,iBAAiB,EAAE,GAAG,SAAS,GAC1C,SAAS,CA8DX;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,EAAE,CAE7D;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAQnD;AAED,qFAAqF;AACrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAMxD"}

package/dist/diagram/engine/engine-context.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What the layout needs to know about a diagram's TEXT while it lays the
+ * presentation tree out: the paragraphs each node shows and the font metrics
+ * to measure them with. Only text-driven sizing (`font-search.ts`,
+ * `text-grow.ts`) reads it; a tree laid out without a context behaves
+ * exactly as a purely geometric layout.
+ */
+import type { EngineNode } from './engine-node.js';
+import type { NodeText, TextMetrics } from './text-measure.js';
+export interface EngineLayoutContext {
+    /** The paragraphs `node` shows, if any. */
+    textOf(node: EngineNode): NodeText | undefined;
+    metrics: TextMetrics;
+    /** Nesting depth of running font searches (only the outermost one searches). */
+    searchDepth: number;
+}
+/** Attach `context` to the tree rooted at `root`. */
+export declare function setLayoutContext(root: EngineNode, context: EngineLayoutContext): void;
+/** The context of the tree `node` belongs to. */
+export declare function layoutContextOf(node: EngineNode): EngineLayoutContext | undefined;
+//# sourceMappingURL=engine-context.d.ts.map

package/dist/diagram/engine/engine-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-context.d.ts","sourceRoot":"","sources":["../../../diagram/engine/engine-context.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE5D,MAAM,WAAW,mBAAmB;IACnC,2CAA2C;IAC3C,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAC;IAC/C,OAAO,EAAE,WAAW,CAAC;IACrB,gFAAgF;IAChF,WAAW,EAAE,MAAM,CAAC;CACpB;AAID,qDAAqD;AACrD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAErF;AAED,iDAAiD;AACjD,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,mBAAmB,GAAG,SAAS,CAMjF"}

package/dist/diagram/engine/engine-first-allowlist.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Layouts where the per-point DiagramML engine (`smartart-engine/`) is
+ * measurably at least as good as the legacy family-based interpreter
+ * (`smartart-layout-interpreter.ts`) on EVERY dataset fixture of that
+ * layout in the 229-fixture COM gallery corpus, with no shape-set loss
+ * (`packages/core/src/__tests__/fixtures/smartart-gallery/`): the engine
+ * matches at least as many cached-drawing shapes as legacy on every
+ * dataset, and its worst geometry deviation is never larger than legacy's.
+ * Most entries are strictly smaller on at least one dataset; a few (Basic
+ * Pyramid, Inverted Pyramid) tie legacy exactly on every dataset instead -
+ * still listed since routing to either engine costs nothing when they agree,
+ * and it keeps the pyramid family on one code path. Basic Cycle and Titled
+ * Matrix tie legacy's geometry exactly and are listed because the engine
+ * matches more cached font sizes on the tied datasets (the measurement's
+ * font tie-break, added once the engine sized text from `primFontSz`).
+ *
+ * `computeDiagramMlElements` (`smartart-decompose-diagram.ts`) consults
+ * this set to try the engine BEFORE the legacy interpreter for a listed
+ * `layoutDefinition.uniqueId`, falling back to legacy (then the
+ * algorithmic heuristic) exactly as before when the engine declines.
+ *
+ * Measured 2026-09-24, re-measured 2026-09-25, with `scripts/measure-smartart-engine-vs-legacy.ts`;
+ * see that script's own doc comment for the exact inclusion rule and
+ * `docs/architecture/openxml-conformance.md#smartart-layout-ground-truth`
+ * for the resulting gate numbers. Regenerate this list (in comparison
+ * mode) whenever either engine changes, rather than hand-editing it: a
+ * hand edit with no fresh measurement is exactly the kind of unverified
+ * claim this file exists to avoid.
+ */
+export declare const ENGINE_FIRST_LAYOUT_IDS: ReadonlySet<string>;
+//# sourceMappingURL=engine-first-allowlist.d.ts.map

package/dist/diagram/engine/engine-first-allowlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-first-allowlist.d.ts","sourceRoot":"","sources":["../../../diagram/engine/engine-first-allowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAgJtD,CAAC"}

package/dist/diagram/engine/engine-fonts.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Output-stage font sizing for the per-point engine: gathers the text every
+ * rendered node shows (its own paragraph when it presents its own data
+ * point, plus folded descendant paragraphs), resolves all sizes jointly
+ * (`font-groups.ts`), and writes them onto the rendered nodes in pixels.
+ */
+import type { DiagramNode } from '../model/index.js';
+import type { RenderedRectNode } from '../layout/smartart-layout-types.js';
+import type { EngineNode } from './engine-node.js';
+import type { NodeText } from './text-fit.js';
+/** A rendered node paired with the engine node that produced it. */
+export interface RenderedEngineNode {
+    node: EngineNode;
+    rendered: RenderedRectNode;
+    mergedIds?: string[] | undefined;
+    /** A folded `moveWith` carrier whose box and constraints size the text (else `node`). */
+    textNode?: EngineNode | undefined;
+}
+/**
+ * The paragraphs `entry` renders (see {@link nodeTextFor}), including any
+ * point a `moveWith` carrier folded into it.
+ */
+export declare function nodeTextOf(entry: RenderedEngineNode, nodeById: Map<string, DiagramNode>): NodeText | undefined;
+/** Resolve and assign every collected node's font size (pixels). */
+export declare function applyEngineFonts(collected: readonly RenderedEngineNode[], nodeById: Map<string, DiagramNode>, fontName: string | undefined): void;
+//# sourceMappingURL=engine-fonts.d.ts.map

package/dist/diagram/engine/engine-fonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-fonts.d.ts","sourceRoot":"","sources":["../../../diagram/engine/engine-fonts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAKhD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAG3C,oEAAoE;AACpE,MAAM,WAAW,kBAAkB;IAClC,IAAI,EAAE,UAAU,CAAC;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACjC,yFAAyF;IACzF,QAAQ,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;CAClC;AAID;;;GAGG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,kBAAkB,EACzB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,GAChC,QAAQ,GAAG,SAAS,CActB;AAED,oEAAoE;AACpE,wBAAgB,gBAAgB,CAC/B,SAAS,EAAE,SAAS,kBAAkB,EAAE,EACxC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC1B,IAAI,CAmDN"}

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

@@ -0,0 +1,72 @@
+/**
+ * Runtime state the SmartArt layout engine attaches to each presentation
+ * node while laying it out: resolved constraint values, deferred
+ * font-relative constraints, equality groups, and the final box.
+ */
+import type { PresNode } from './pres-tree.js';
+/** A constraint whose value can only be known once text is fitted. */
+export interface DeferredConstraint {
+    /** The declaring constraint, so a re-evaluation replaces rather than duplicates. */
+    source: object;
+    type: string;
+    op: 'none' | 'equ' | 'gte' | 'lte';
+    /** Node whose `refType` value the constraint reads (after fitting). */
+    ref: EngineNode;
+    refType: string;
+    fact: number;
+}
+/** A set of nodes whose value of `type` must end up equal (`op="equ"`). */
+export interface EqualityGroup {
+    type: string;
+    members: EngineNode[];
+}
+export interface Box {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface EngineNode extends PresNode {
+    children: EngineNode[];
+    parent?: EngineNode;
+    /** Resolved constraint values, in points (lengths, font sizes) or raw numbers. */
+    values: Map<string, number>;
+    /** Numeric lower/upper bounds from `op="gte"`/`"lte"` constraints. */
+    minValues: Map<string, number>;
+    maxValues: Map<string, number>;
+    /** Constraints that reference a fitted font size (margins, linked fonts). */
+    deferred: DeferredConstraint[];
+    /** Equality groups this node declared for its children/descendants. */
+    groups: EqualityGroup[];
+    /** Final box, absolute within the diagram, in points. */
+    box?: Box;
+    /** Rotation in degrees (shape `rot` plus algorithm rotation). */
+    rotation: number;
+    /** Final primary font size in points once fitted. */
+    fontSize?: number;
+    /** Final secondary (child-level) font size in points once fitted. */
+    secondaryFontSize?: number;
+    /** Text box (absolute) when it differs from the shape box. */
+    textBox?: Box;
+    /**
+     * The font size (points) a text-driven font search (`font-search.ts`)
+     * fixed for this node while laying its ancestor out; while set, every
+     * length constraint that reads this node's font resolves against it.
+     */
+    forcedFontPt?: number;
+    /** The reference size the node's own last constraint evaluation wrote into `values`. */
+    selfRef?: {
+        w: number;
+        h: number;
+    };
+    /** Minimum size a text-grown node takes (an `op="equ"` group's largest need). */
+    growFloor?: {
+        w?: number;
+        h?: number;
+    } | undefined;
+}
+/** Promote a presentation tree to engine nodes in place. */
+export declare function toEngineTree(node: PresNode): EngineNode;
+/** Every node of an engine tree in pre-order. */
+export declare function flattenEngineTree(root: EngineNode): EngineNode[];
+//# sourceMappingURL=engine-node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine-node.d.ts","sourceRoot":"","sources":["../../../diagram/engine/engine-node.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IAClC,oFAAoF;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IACnC,uEAAuE;IACvE,GAAG,EAAE,UAAU,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACb;AAED,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,GAAG;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,MAAM,WAAW,UAAW,SAAQ,QAAQ;IAC3C,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,kFAAkF;IAClF,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,sEAAsE;IACtE,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,6EAA6E;IAC7E,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,uEAAuE;IACvE,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,yDAAyD;IACzD,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;IACjB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qEAAqE;IACrE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,8DAA8D;IAC9D,OAAO,CAAC,EAAE,GAAG,CAAC;IACd;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wFAAwF;IACxF,OAAO,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,iFAAiF;IACjF,SAAS,CAAC,EAAE;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;CACnD;AAED,4DAA4D;AAC5D,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,GAAG,UAAU,CAYvD;AAED,iDAAiD;AACjD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,EAAE,CAQhE"}

package/dist/diagram/engine/engine-to-result.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Bridge from the per-point layout engine (`engine.ts`) to the same
+ * `SmartArtLayoutResult` shape the legacy family-based interpreter produces
+ * (`smartart-layout-types.ts`), so the existing save-pipeline bridge
+ * (`smartart-interpreter-drawing-bridge.ts`'s `interpretedLayoutToElements`)
+ * converts either one to `PptxElement[]` identically: text projection
+ * (folding, per-run styling), node-style overrides and id conventions are
+ * resolved there, once, for both engines.
+ *
+ * Every rendered node is emitted as a `RenderedRectNode`: the ACTUAL preset
+ * geometry (chevron, ellipse, hexagon, ...) is carried verbatim in
+ * `presetOverride` and rendered later by the full 187-preset geometry engine
+ * from a plain bounding box, so a rect-shaped carrier is sufficient
+ * regardless of the visual shape - see that bridge's `rect` branch, which
+ * already treats `presetOverride` as authoritative over its own `kind`
+ * default.
+ *
+ * Declines (`undefined`) whenever the layout definition uses an algorithm
+ * this engine does not implement (none in the gallery corpus today): the
+ * registry (`registry.ts`) silently substitutes
+ * `composite` for an unknown type so the layout still runs to completion,
+ * which would otherwise produce plausible-looking but wrong geometry with no
+ * signal to the caller. Checking the resolved tree's actual algorithm set
+ * (not the layout definition's declared choose/if branches) also correctly
+ * accepts a layout that DECLARES a `dgm:choose` naming an unsupported
+ * algorithm on a branch the data never takes.
+ */
+import type { DiagramData, DiagramNode } from '../model/index.js';
+import type { DiagramStyleIntensity } from '../types.js';
+import type { SmartArtLayoutResult } from '../layout/smartart-layout-types.js';
+/**
+ * Run the per-point engine for `smartArtData` in a `containerBounds.width` x
+ * `containerBounds.height` PIXEL frame (this package's standard element unit)
+ * and convert its output to the shared `SmartArtLayoutResult` shape.
+ * Returns `undefined` when there is no layout definition, the engine cannot
+ * parse it, the resolved tree needs an unimplemented algorithm, or the
+ * result is not sane geometry - every case the caller should fall back from.
+ */
+export declare function runEngineLayout(smartArtData: DiagramData, containerBounds: {
+    width: number;
+    height: number;
+}, nodes: DiagramNode[], palette: string[], style: DiagramStyleIntensity): SmartArtLayoutResult | undefined;
+//# sourceMappingURL=engine-to-result.d.ts.map

package/dist/diagram/engine/engine-to-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-to-result.d.ts","sourceRoot":"","sources":["../../../diagram/engine/engine-to-result.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAUtD,OAAO,KAAK,EAAoB,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AA6K9F;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC9B,YAAY,EAAE,WAAW,EACzB,eAAe,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAClD,KAAK,EAAE,WAAW,EAAE,EACpB,OAAO,EAAE,MAAM,EAAE,EACjB,KAAK,EAAE,qBAAqB,GAC1B,oBAAoB,GAAG,SAAS,CA0ClC"}

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

@@ -0,0 +1,18 @@
+/**
+ * SmartArt DiagramML layout engine entry point: parse the layout definition,
+ * expand it per data point into the presentation tree, and lay the tree out
+ * in the diagram frame.
+ */
+import type { DiagramData } from '../model/index.js';
+import type { EngineLayoutContext } from './engine-context.js';
+import type { EngineNode } from './engine-node.js';
+export interface EngineRun {
+    root: EngineNode;
+}
+/**
+ * Run the engine for `data` in a `width` x `height` point frame, measuring
+ * text through `context` where the layout depends on it. Returns
+ * `undefined` when the diagram carries no layout-definition source.
+ */
+export declare function runSmartArtEngine(data: DiagramData, layoutXml: string, width: number, height: number, context?: EngineLayoutContext): EngineRun | undefined;
+//# sourceMappingURL=engine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../diagram/engine/engine.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAG5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAOhD,MAAM,WAAW,SAAS;IACzB,IAAI,EAAE,UAAU,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,WAAW,EACjB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,mBAAmB,GAC3B,SAAS,GAAG,SAAS,CAkBvB"}

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

@@ -0,0 +1,33 @@
+/**
+ * Cross-node font-size resolution for the per-point layout engine.
+ *
+ * ECMA-376 Part 1, 21.4.2.x: `<dgm:constr type="primFontSz" ... op="equ"/>`
+ * makes every addressed node share ONE size, and PowerPoint picks the size
+ * the worst-fitting member can still fit at (every cached gallery drawing
+ * renders an `equ` group at a single whole point, however short a member's
+ * own text is). `op="lte"` with a `refType="primFontSz"` reference caps a
+ * node at another node's final size (times `fact`), and `op="equ"` with such
+ * a reference joins the two into one group.
+ *
+ * Each text node first gets its own best fit (`text-fit.ts`), then groups
+ * collapse to their minimum and references cap their dependants, repeating
+ * until nothing changes (every step only ever lowers a size, so this
+ * terminates). A margin that references ANOTHER node's font size ("Gear"'s
+ * child box: `lMarg` = 0.3 x the gear's own `primFontSz`) is fitted against
+ * that node's size from the previous round, so the whole resolution runs
+ * again until the sizes it reads are the sizes it produced.
+ */
+import type { EngineNode } from './engine-node.js';
+import type { NodeText, TextMetrics } from './text-fit.js';
+/** One rendered, text-bearing node awaiting its size. */
+export interface FontFitEntry {
+    node: EngineNode;
+    text: NodeText;
+}
+/**
+ * Resolve every entry's primary font size in whole POINTS. Nodes that are
+ * not in `entries` (no text) still take part in equality groups only as
+ * bridges; they never lower anyone's size themselves.
+ */
+export declare function resolveEngineFonts(entries: readonly FontFitEntry[], metrics: TextMetrics): Map<EngineNode, number>;
+//# sourceMappingURL=font-groups.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"font-groups.d.ts","sourceRoot":"","sources":["../../../diagram/engine/font-groups.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGxD,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,QAAQ,CAAC;CACf;AAoID;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,WAAW,GAClB,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAsBzB"}

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

@@ -0,0 +1,26 @@
+/**
+ * Font-relative lengths and the bounds they shadow (see
+ * `constraint-eval.ts`'s `applyConstraint`).
+ */
+import type { EngineNode } from './engine-node.js';
+import type { LdConstraint } from './layout-def-types.js';
+export declare const fontAssigned: {
+    has(node: EngineNode, type: string): boolean;
+};
+/**
+ * A LENGTH that reads a font size (`<dgm:constr type="h" refType="primFontSz"
+ * fact="0.52"/>`) is `fact x size` millimetres. The size is only known inside
+ * a text-driven font search (`layout-font.ts`); there it resolves at once, so
+ * the layout is built around the candidate size. Outside a search it stays
+ * deferred and unassigned, as before.
+ */
+export declare function resolveFontLength(targets: EngineNode[], constraint: LdConstraint, ref: EngineNode): void;
+/**
+ * A reference bound that sits beside a font-relative assignment of the same
+ * value, from the same node, does not bind: "Vertical Box List" sizes its
+ * `negativeSpace` overlap `-0.41 x primFontSz` and ALSO declares it
+ * `lte`/`gte -0.82 x parentText.h`, yet every cached overlap is exactly the
+ * font-relative half of the parent box, never the bound.
+ */
+export declare function isShadowedBound(node: EngineNode, constraint: LdConstraint): boolean;
+//# sourceMappingURL=font-length.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"font-length.d.ts","sourceRoot":"","sources":["../../../diagram/engine/font-length.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAUvD,eAAO,MAAM,YAAY;IACxB,GAAG,OAAO,UAAU,QAAQ,MAAM,GAAG,OAAO;CAG5C,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,UAAU,EAAE,EACrB,UAAU,EAAE,YAAY,EACxB,GAAG,EAAE,UAAU,GACb,IAAI,CAgBN;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,GAAG,OAAO,CAanF"}

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

@@ -0,0 +1,38 @@
+/**
+ * Text-driven font search (ECMA-376 Part 1, 21.4.2.x `dgm:ruleLst`). When a
+ * node's geometry depends on its text's font size (a child `h` declared as
+ * `fact x primFontSz`, a `tx` node that grows to fit its text), the size
+ * cannot be fitted after the layout: it decides the layout. PowerPoint starts
+ * the addressed nodes at their `primFontSz` constraint (65pt) and applies the
+ * node's `<dgm:rule type="primFontSz" val="5"/>`, stepping the size down
+ * until the whole subtree fits: every text fits its (possibly grown) box and
+ * nothing spills out of the node.
+ *
+ * "Vertical Bullet List" (5 items in 400pt): at 47pt the grown parent boxes
+ * and `0.46 x size` child boxes overflow the frame, at 46pt they fit, and the
+ * cached drawing is laid out at exactly 46pt. "Horizontal Bullet List" stops
+ * at 32pt because "Node Three" is the widest word its column can hold.
+ *
+ * The search is whole points, largest first, and only the outermost
+ * font-driven node searches (a nested one keeps the size its ancestor chose
+ * for it).
+ */
+import type { EngineLayoutContext } from './engine-context.js';
+import type { EngineNode } from './engine-node.js';
+import type { LdRule } from './layout-def-types.js';
+/** The rule and the nodes whose size a search at `node` would pick, if it should search. */
+export declare function fontSearchPlan(node: EngineNode): {
+    rule: LdRule;
+    targets: EngineNode[];
+    context: EngineLayoutContext;
+} | undefined;
+/**
+ * Lay `node` out at the largest whole-point size its font rule allows that
+ * fits; `layoutOnce` lays the subtree out once at the current forced size.
+ */
+export declare function layoutWithFontSearch(node: EngineNode, plan: {
+    rule: LdRule;
+    targets: EngineNode[];
+    context: EngineLayoutContext;
+}, layoutOnce: () => void): void;
+//# sourceMappingURL=font-search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"font-search.d.ts","sourceRoot":"","sources":["../../../diagram/engine/font-search.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAuBjD,4FAA4F;AAC5F,wBAAgB,cAAc,CAC7B,IAAI,EAAE,UAAU,GACd;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,mBAAmB,CAAA;CAAE,GAAG,SAAS,CAWnF;AAoFD;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,mBAAmB,CAAA;CAAE,EAC3E,UAAU,EAAE,MAAM,IAAI,GACpB,IAAI,CAyBN"}

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

@@ -0,0 +1,47 @@
+/**
+ * Org-chart assistants (ECMA-376 Part 1, 21.4.2.6/21.4.2.7: `asst` points
+ * under a `hierRoot`, laid out by their own `hierChild` row, the built-in
+ * org charts' `hierChild3` / `forEach ptType="asst"`).
+ *
+ * Measured on `smartart-orgchart-hierbranch.pptx` (four managers with two
+ * assistants, `hierBranch` std/hang/l/r) and
+ * `smartart-orgchart-fan-variants.pptx` (one assistant each):
+ *
+ * - the assistants sit in their own band one `sp` below the manager, ABOVE
+ *   every other row, which then starts one `sp` below the band;
+ * - they pair up around the manager's centre line, first on the left: the
+ *   left one ends and the right one starts `sibSp / 2` from the centre
+ *   (`0.105 W` for the org charts' `sibSp = 0.21 W`), whatever `hierBranch`
+ *   the manager hangs its reports with; a lone assistant sits on the left;
+ * - a hanging manager with assistants insets its column by its `alignOff`
+ *   (the definitions switch it from 0.25 to 0.65 when an assistant exists),
+ *   read in `hier-measure.ts`.
+ *
+ * Further pairs stack one `sp` below the previous pair (the rows' own
+ * `secLinDir="fromT"`).
+ */
+import type { EngineNode } from './engine-node.js';
+import type { HierShape, OutlineRect } from './hier-shape.js';
+/** Whether every item of a `hierChild` row is an assistant. */
+export declare function isAssistantRow(row: EngineNode, items: readonly EngineNode[]): boolean;
+/**
+ * Whether a `hierChild` row splits its items into two columns either side
+ * of its parent's connector (`secLinDir`: the assistants' row, and a
+ * `hierBranch="hang"` manager's reports).
+ */
+export declare function isTwoColumnRow(row: EngineNode): boolean;
+/**
+ * Place measured subtrees in two columns either side of the line `centre`,
+ * starting at `top`: items alternate left, right; each column stacks its
+ * items `sp` apart and left-aligns them, the left column ending and the
+ * right one starting `gap / 2` from the line. Measured on
+ * `smartart-orgchart-hierbranch.pptx`'s hanging manager: the first report's
+ * whole subtree ends `sibSp / 2` left of the manager's centre, the second
+ * starts `sibSp / 2` right of it, and the third drops below the first,
+ * flush with its subtree's left edge. Returns the outline and its bottom.
+ */
+export declare function placeTwoColumns(shapes: readonly HierShape[], centre: number, top: number, gap: number, sp: number): {
+    rects: OutlineRect[];
+    bottom: number;
+};
+//# sourceMappingURL=hier-assistants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hier-assistants.d.ts","sourceRoot":"","sources":["../../../diagram/engine/hier-assistants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAG3D,+DAA+D;AAC/D,wBAAgB,cAAc,CAAC,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,UAAU,EAAE,GAAG,OAAO,CAMrF;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC9B,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,EAAE,EAAE,MAAM,GACR;IAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAgB1C"}

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

@@ -0,0 +1,28 @@
+/**
+ * Hanging org-chart branches: a `hierRoot` aligned to one corner of its rows
+ * (`hierAlign="tL"`/`"tR"`) whose rows are vertical columns (`hierChild`
+ * `linDir="fromT"`) hangs those columns below the node, inset toward the
+ * aligned side, instead of fanning them.
+ *
+ * The built-in org charts spell every hanging case out in their own
+ * choose/if blocks rather than leaving it to the algorithm: `hierBranch`
+ * `l`/`r` select `hierAlign="tR"`/`"tL"` plus a `fromT` column, and the
+ * default `init` does the same for a node whose descendants are all leaves
+ * (`axis="des" func="maxDepth" op="lte" val="1"`). "Name and Title
+ * Organization Chart" leaves that `init` branch on the plain fan, and its
+ * cached drawing indeed stacks Node Five straight below Node Two.
+ *
+ * Geometry, measured on the gallery's cached "Organization Chart" drawings
+ * (hier5: Node Five under Node Two; hier8: Branch C Root under Branch B
+ * Grandchild): the column's near edge sits exactly `0.25 x` the parent
+ * node's width in from the parent's own edge (the legacy interpreter's
+ * `HIER_TAIL_OFFSET_RATIO`, COM-verified across every `hierBranch` value),
+ * one `sp` below the node. Siblings pack by outline (`hier-shape.ts`), so
+ * the column juts past its parent without widening the parent's row.
+ */
+import type { EngineNode } from './engine-node.js';
+/** The hanging column's inset from the parent node's near edge, as a fraction of the node's width. */
+export declare const HANG_OFFSET_RATIO = 0.25;
+/** Whether a `hierChild` row runs as a vertical column. */
+export declare function isColumn(row: EngineNode): boolean;
+//# sourceMappingURL=hier-hang.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hier-hang.d.ts","sourceRoot":"","sources":["../../../diagram/engine/hier-hang.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,sGAAsG;AACtG,eAAO,MAAM,iBAAiB,OAAO,CAAC;AAEtC,2DAA2D;AAC3D,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAGjD"}