ooxml-core 1.1.0 → 1.2.1

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"}

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"}