ooxml-core 1.0.0 → 1.2.0

package/dist/diagram/dom.d.ts

@@ -1,15 +1,2 @@
-import { NS, children, elements, first, isElement, type XmlElement } from '../xml/index.js';
-import type { AttributeReader } from './types.js';
-export { children, elements, first, isElement, NS };
-export type { XmlElement };
-/** Reads an attribute by local name regardless of its prefix (`r:dm` and `dm` are the same here). */
-export declare function attributeReader(element: XmlElement | null | undefined): AttributeReader;
-/** A trimmed, non-empty attribute value. */
-export declare function stringAttribute(element: XmlElement | null | undefined, name: string): string | undefined;
-/** An integer attribute (base 10); `undefined` when absent or not a number. */
-export declare function integerAttribute(element: XmlElement | null | undefined, name: string): number | undefined;
-/** `1`, `true` -> true; `0`, `false` -> false; otherwise `undefined`. */
-export declare function booleanAttribute(element: XmlElement | null | undefined, name: string): boolean | undefined;
-/** All descendant elements with a local name, in document order, in any namespace. */
-export declare function descendants(root: XmlElement, local: string): XmlElement[];
+export * from '../drawingml/dom.js';
 //# sourceMappingURL=dom.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../diagram/dom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAC;AACzF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC;AACpD,YAAY,EAAE,UAAU,EAAE,CAAC;AAE3B,qGAAqG;AACrG,wBAAgB,eAAe,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,CAYvF;AAED,4CAA4C;AAC5C,wBAAgB,eAAe,CAC9B,OAAO,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAGpB;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAGpB;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAC/B,OAAO,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GACV,OAAO,GAAG,SAAS,CAKrB;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,EAAE,CAWzE"}
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../diagram/dom.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAC"}

package/dist/diagram/engine/alg-composite.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `composite` algorithm (ECMA-376 Part 1, 21.4.2.x): every child is placed by
+ * its own `l`/`t`/`r`/`b`/`w`/`h`/`ctrX`/`ctrY` values (plus the `*Off`
+ * offsets), relative to the composite's top-left corner. A dimension no
+ * constraint fixes defaults to the composite's own; an unset position
+ * defaults to the origin.
+ */
+import type { Box, EngineNode } from './engine-node.js';
+/** Place every child relative to `box`'s top-left corner. */
+export declare function compositeChildBoxes(node: EngineNode, box: Box): void;
+/**
+ * The composite's working box: the whole node, or, with an `ar` (aspect
+ * ratio, width / height) parameter, the largest box of that aspect that fits,
+ * aligned by `horzAlign`/`vertAlign` (centred by default).
+ */
+export declare function compositeFrame(node: EngineNode, box: Box): Box;
+export declare function arrangeComposite(node: EngineNode): void;
+//# sourceMappingURL=alg-composite.d.ts.map

package/dist/diagram/engine/alg-composite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alg-composite.d.ts","sourceRoot":"","sources":["../../../diagram/engine/alg-composite.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAoDrD,6DAA6D;AAC7D,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAsBpE;AAYD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,GAAG,GAAG,CAa9D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAWvD"}

package/dist/diagram/engine/alg-connector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `conn` algorithm (ECMA-376 Part 1, 21.4.2.x Connector): draws a transition
+ * between the two shapes it connects. The source and destination are the
+ * content points on either side of the transition point (a `sibTrans` joins
+ * a node to its next sibling, wrapping for a cycle's last one; a `parTrans`
+ * joins a parent to the child), located among the laid-out nodes by data
+ * point and, when given, the `srcNode`/`dstNode` layout-node names.
+ *
+ * A 2-D connector (the default, e.g. an arrow) becomes a shape running from
+ * the source's edge to the destination's edge along the centre line, less
+ * `begPad`/`endPad`, as thick as the node's own height and rotated to the
+ * line; `connDist` is published for constraints to read. See
+ * `connector-size.ts` for the thickness, outline and default padding rules.
+ */
+import type { EngineNode } from './engine-node.js';
+export declare function arrangeConnector(node: EngineNode): void;
+//# sourceMappingURL=alg-connector.d.ts.map

package/dist/diagram/engine/alg-connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alg-connector.d.ts","sourceRoot":"","sources":["../../../diagram/engine/alg-connector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AASH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAwDhD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CA0CvD"}

package/dist/diagram/engine/alg-cycle.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `cycle` algorithm (ECMA-376 Part 1, 21.4.2.x): children are placed evenly
+ * around a ring inscribed in the node's box. `stAng` (start angle, clockwise
+ * from 12 o'clock) picks the first point; `spanAng` sweeps a full ring when
+ * `abs(spanAng) >= 360`, otherwise the LAST point lands exactly `spanAng`
+ * degrees from the first (`n - 1` gaps, not `n`). `ctrShpMap="fNode"` pulls
+ * the FIRST content point off the ring and centres it instead - PowerPoint's
+ * hub+ring "Radial Cycle" construction. `rotPath="alongPath"` rotates each
+ * ring item to the path's own tangent at its position instead of leaving it
+ * upright.
+ *
+ * Mirrors the legacy family interpreter's derivation
+ * (`smartart-layout-interpreter-cycle-ring.ts`'s module doc comment, itself
+ * reverse-engineered against live PowerPoint COM output): in a unit space
+ * where the ring item's own width is 1, the ring radius solves the
+ * adjacent-item chord to `1 + sibSp`, then the whole ring (radius and item
+ * size together) is scaled by a SINGLE isotropic factor to CONTAIN it in the
+ * node's box (never stretched per axis, matching that module's "contain not
+ * cover" fit), centring the slack. Unlike that interpreter, which also
+ * resolves hub-satellite gap ratios, a `sibTrans` curve's own bulge and
+ * axis-flush centring for asymmetric ring counts, this engine algorithm keeps
+ * the plain-ring and `ctrShpMap="fNode"` hub cases only; each item's own
+ * subtree still sizes itself through the engine's ordinary constraint/
+ * font-fit pipeline the same way every other per-point algorithm does.
+ */
+import type { EngineNode } from './engine-node.js';
+export declare function arrangeCycle(node: EngineNode): void;
+//# sourceMappingURL=alg-cycle.d.ts.map

package/dist/diagram/engine/alg-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alg-cycle.d.ts","sourceRoot":"","sources":["../../../diagram/engine/alg-cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAwJhD,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CA+FnD"}

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

@@ -0,0 +1,33 @@
+/**
+ * `hierRoot`/`hierChild` algorithms (ECMA-376 Part 1, 21.4.2.6/21.4.2.7):
+ * the org-chart/hierarchy family.
+ *
+ * A gallery layoutDef hand-unrolls the recursion per generation: an outer
+ * `hierChild1` fans the top-level points, one `hierRoot1` per point; each
+ * `hierRoot` holds its own node (a `composite`) and, as direct children,
+ * `hierChild` rows continuing the tree one generation deeper (org charts add
+ * a second row for assistants). Every generation runs the same algorithm
+ * whatever its literal name.
+ *
+ * PowerPoint lays the whole tree out ONCE, bottom-up, in the definition's
+ * own unscaled space (`hier-measure.ts`), then scales it uniformly to fit
+ * the frame and centres what is drawn: the outermost hierarchy node places
+ * every hierarchy node below it in one pass, and the nested `hierRoot`/
+ * `hierChild` calls the layout driver makes afterwards keep those boxes.
+ * Measured on the gallery's cached "Hierarchy" and "Organization Chart"
+ * drawings (three generations exactly filling the 400pt frame height, the
+ * top node centred over its children's row, the drawing centred on its own
+ * extent including a hanging column's overhang).
+ */
+import type { EngineNode } from './engine-node.js';
+/**
+ * Whether `node` is an org-chart assistant this port cannot place: an
+ * assistant band is modelled below a manager that heads its rows from the
+ * top (`hier-assistants.ts`); a manager aligned to another side (a
+ * horizontal org chart) is left to the legacy interpreter (see
+ * `engine-to-result.ts`).
+ */
+export declare function isAssistantItem(node: EngineNode): boolean;
+export declare function arrangeHierChild(node: EngineNode): void;
+export declare function arrangeHierRoot(node: EngineNode): void;
+//# sourceMappingURL=alg-hier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"alg-hier.d.ts","sourceRoot":"","sources":["../../../diagram/engine/alg-hier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAO,UAAU,EAAE,MAAM,eAAe,CAAC;AAoDrD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAOzD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAIvD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAItD"}

package/dist/diagram/engine/alg-linear.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `lin` algorithm (ECMA-376 Part 1, 21.4.2.x Linear Flow): children are
+ * placed one after another along `linDir` (`fromL` default, `fromR`,
+ * `fromT`, `fromB`) at their constraint sizes plus `sibSp` spacing. When the
+ * run is longer than the node, the node's reference size along the flow is
+ * scaled down and its constraints re-evaluated until the run fits, so every
+ * size derived from it (items, transition slots, negative overlaps) shrinks
+ * together while sizes tied to the cross axis stay put. A run that is too
+ * thick across the flow shrinks the same way. The run is then aligned with
+ * `nodeHorzAlign`/`nodeVertAlign` (centred by default).
+ */
+import type { Box, EngineNode } from './engine-node.js';
+import type { Size } from './preferred-size.js';
+interface Measure {
+    sizes: Size[];
+    total: number;
+    cross: number;
+    spacing: number;
+}
+/** Fit the run: shrink the flow-axis reference until length and thickness fit. */
+export declare function fitLinear(node: EngineNode, box: Box, horizontal: boolean): Measure;
+export declare function arrangeLinear(node: EngineNode): void;
+export {};
+//# sourceMappingURL=alg-linear.d.ts.map

package/dist/diagram/engine/alg-linear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alg-linear.d.ts","sourceRoot":"","sources":["../../../diagram/engine/alg-linear.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGrD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AAE7C,UAAU,OAAO;IAChB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CAChB;AAmGD,kFAAkF;AAClF,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,UAAU,EAAE,OAAO,GAAG,OAAO,CAiClF;AA+ED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAuCpD"}

package/dist/diagram/engine/alg-pyra.d.ts

@@ -0,0 +1,117 @@
+/**
+ * `pyra` algorithm (ECMA-376 Part 1, 21.4.2.x): stacks the data points as
+ * equal-height horizontal bands along the node's box, each band's width
+ * proportional to its position in the stack (`i/n` at the narrow edge,
+ * `(i+1)/n` at the wide edge), forming a triangle. `linDir="fromT"` (real
+ * "Inverted Pyramid") points the apex DOWN instead of the default
+ * `"fromB"` apex-up; `sibSp` (rare - neither real "Basic Pyramid" nor
+ * "Inverted Pyramid" declares one) adds absolute spacing between bands, the
+ * same convention `alg-linear.ts` uses for its own flow spacing.
+ *
+ * Mirrors the legacy family interpreter's band derivation
+ * (`smartart-layout-interpreter-pyramid.ts`'s `arrangePyramid`, itself
+ * COM-verified against real PowerPoint output), but only the band-stacking
+ * geometry: each item's own `<dgm:layoutNode name="Name8" alg="composite">`
+ * subtree still sizes and positions its "level"/"levelTx" (and, when a data
+ * point has a child, "acctBkgd"/"acctTx") shapes itself through the engine's
+ * ordinary constraint pipeline (including the `ctrX`/`w` "fill and centre"
+ * idiom `constraint-fill-idiom.ts` now reads correctly), the same way every
+ * other per-point algorithm here delegates to its children's own subtrees.
+ *
+ * Each band is given its TIGHT bounding box (the wide edge's half-width,
+ * spanning the full band height): `scoreAgainstCached`
+ * (`measure-smartart-engine-vs-legacy.ts`) and the acceptance gate compare a
+ * shape's bounding box, not its exact polygon outline, and the composite
+ * child's own `dgm:shape type="trapezoid"` (carried through verbatim as
+ * `presetOverride`) supplies the actual tapered geometry from that box at
+ * render time - so the bounding box below must already be the trapezoid's
+ * own tightest box, not the full (untapered) slot.
+ *
+ * ## `pyraLvlNode`'s own self-scoped `w`/`h` must be sanitized before layout
+ *
+ * `dgm:param[@type="pyraLvlNode"]` (default `"level"`) names the per-item
+ * layoutNode representing each band's own shape. Real "Basic Pyramid"
+ * declares `<dgm:constr type="h" val="500"/>` / `<dgm:constr type="w"
+ * val="1"/>` directly on "level"'s OWN `constrLst` (`for="self"`, no
+ * `refType`) - COM-verified as a no-op: neither is a valid ratio (`500` is
+ * not less than 1), so "level" should keep whatever size the composite fill
+ * idiom already gave it (see the module doc comment there). But
+ * `preferred-size.ts`'s `preferredSize` (called from `alg-composite.ts`'s
+ * `compositeChildBoxes` to size EVERY composite child, "level" included)
+ * deliberately RE-APPLIES a child's own self-scoped `w`/`h` constraints
+ * on top of whatever its ancestor already assigned it, by design, so a
+ * child's genuine self-declared aspect ratio (`h refType="w" fact="0.6"`)
+ * survives - that reapplication has no way to tell "level"'s `val="500"`
+ * apart from a genuine, tiny, deliberate anchor-point marker (the SAME
+ * bare-literal-`w`/`h`-only shape `dummyConnPt`/`wedge*` layoutNodes declare
+ * on themselves in `radial-cycle`/`segmented-cycle`/`vertical-chevron-list`,
+ * where it MUST stay a real ~2.83pt point: their own position comes from a
+ * SIBLING `for="ch"` declaration elsewhere, exactly the shape "level"'s own
+ * declaration has, so no generic rule distinguishes them). Since only THIS
+ * algorithm's own `pyraLvlNode` convention has the context to know "level"'s
+ * declaration is a no-op-or-ratio, not a marker, this sanitizes it here,
+ * scoped to exactly the named node `pyra` itself points at, before the rest
+ * of the tree lays out: any bare-literal (`refType="none"`) self-scoped `w`/
+ * `h` constraint on it is dropped outright, letting the composite fill idiom
+ * decide "level"'s size undisturbed.
+ *
+ * `pyraLvlNode` actually narrowing a band by a genuine sub-1 ratio is dropped
+ * (sanitized away) rather than applied above, since no fixture in the
+ * 229-fixture gallery corpus declares one.
+ *
+ * ## `pyraAcctRatio` accent-column split (`applyPyraAccentSplit`)
+ *
+ * Real "Basic Pyramid"/"Inverted Pyramid" also declare `pyraAcctRatio`
+ * (`dgm:constr type="pyraAcctRatio"`, `for="self"` on the `pyra` node
+ * itself, `dgm:choose`-gated on `func="maxDepth" op="gte" val="2"` - true
+ * whenever ANY point in the whole diagram has a child), ported here from the
+ * legacy interpreter's COM-verified `repositionPyramidBands` (see
+ * `smartart-layout-interpreter-pyramid.ts`'s own module doc comment for the
+ * full derivation this mirrors). Once active, EVERY row's own `pyraLvlNode`
+ * ("level") shrinks to `(1 - pyraAcctRatio)` of its natural width, anchored
+ * at the diagram box's own LEFT edge, even a row with no accent (the ratio is
+ * diagram-wide, not per-row, so an unaccented row is left with a visible gap
+ * on its right rather than staying full width - COM-verified). A row whose
+ * own data point has a child (so the layout definition actually created
+ * `pyraAcctBkgdNode`/`pyraAcctTxNode` - "acctBkgd"/"acctTx" by default -
+ * instances for it) then has that accent column fill the remainder of the
+ * row's natural slot, out to the diagram box's own right edge (see the
+ * "accent column's own LEFT edge" section below for exactly where that
+ * remainder starts).
+ *
+ * This has to run as a POST-pass, after `pyraLvlNode`'s own subtree
+ * (including a text overlay like "levelTx", positioned by the composite
+ * fill idiom relative to "level"'s box) has already been laid out by the
+ * generic composite algorithm: only then does "level" have a final box to
+ * shrink. `applyPyraAccentSplit` therefore scales every box in
+ * `pyraLvlNode`'s own subtree by the SAME (anchor, scale) affine transform,
+ * not just `pyraLvlNode`'s own box: since a fill-idiom child's box is
+ * already some fraction of "level"'s box under a uniform x-scale, applying
+ * the identical transform to it preserves that fraction and its centring
+ * exactly, without needing to know each child's own derivation.
+ *
+ * ### The accent column's own LEFT edge is not `pyraLvlNode`'s shrunk right edge
+ *
+ * Each row is itself a trapezoid (`arrangePyramid`'s legacy geometry has a
+ * narrower top edge and a wider bottom edge within the SAME row, `fTop =
+ * effectiveI/n` vs `fBot = (effectiveI+1)/n`); `arrangePyra`'s own item box
+ * already collapses that to its tight bounding box using the WIDE (`fBot`)
+ * edge only (see the module doc comment above), so `pyraLvlNode`'s shrunk
+ * right edge is the scaled WIDE corner, not the narrow one. COM-verified
+ * (`basic-pyramid--hier5.pptx`/`--hier8.pptx`): the accent column's own left
+ * edge is the scaled NARROW (`fTop`) corner, which sits to the LEFT of the
+ * shrunk level's own right edge, not flush against it - recomputed
+ * independently here (mirroring the legacy interpreter's own
+ * `pyramidRowGeometry`) since the row's narrow-edge fraction isn't
+ * recoverable from the item's already-collapsed wide-edge box alone.
+ */
+import type { EngineNode } from './engine-node.js';
+export declare function arrangePyra(node: EngineNode): void;
+/**
+ * `pyraAcctRatio` band-splitting post-pass (see the module doc comment for
+ * the full derivation). Run by the layout driver AFTER `node`'s children
+ * (the per-point composite items) and their whole subtrees have already been
+ * laid out, so `pyraLvlNode`'s own subtree has a final box to shrink.
+ */
+export declare function applyPyraAccentSplit(node: EngineNode): void;
+//# sourceMappingURL=alg-pyra.d.ts.map

package/dist/diagram/engine/alg-pyra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alg-pyra.d.ts","sourceRoot":"","sources":["../../../diagram/engine/alg-pyra.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0GG;AAEH,OAAO,KAAK,EAAO,UAAU,EAAE,MAAM,eAAe,CAAC;AAyCrD,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAyBlD;AAOD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAsE3D"}

package/dist/diagram/engine/alg-snake.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `snake` algorithm (ECMA-376 Part 1, 21.4.2.x): the node's content points
+ * fill a grid line by line, each keeping the size its constraints gave it,
+ * with the whole grid scaled uniformly to fit the node.
+ *
+ * - Cells are the non-transition children; a `sibTrans` child between two
+ *   cells is a spacer whose own `w` (`h` for `flowDir="col"`) is the gap
+ *   along a line, and the node's `sp` is the gap between lines.
+ * - The line length is `bkPtFixedVal` for `bkpt="fixed"`; otherwise every
+ *   line length is tried and the one whose grid scales largest into the
+ *   node wins (the grid only ever shrinks to fit, never grows) (`bkpt="bal"` then evens the lines out). "Basic Block List":
+ *   three `W x 0.6 W` cells, `0.1 W` apart, fit a 650 x 400 frame largest as
+ *   two columns, at the cached 307.5 x 184.5.
+ * - `flowDir` picks the line axis, `contDir="revDir"` reverses alternate
+ *   lines, `grDir` the starting corner, `off="ctr"` centres a short last
+ *   line, and `horzAlign`/`vertAlign` place the grid in the node (centred
+ *   by default).
+ */
+import type { EngineNode } from './engine-node.js';
+export declare function arrangeSnake(node: EngineNode): void;
+//# sourceMappingURL=alg-snake.d.ts.map

package/dist/diagram/engine/alg-snake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alg-snake.d.ts","sourceRoot":"","sources":["../../../diagram/engine/alg-snake.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,KAAK,EAAO,UAAU,EAAE,MAAM,eAAe,CAAC;AAkHrD,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CA0DnD"}

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

@@ -0,0 +1,24 @@
+/**
+ * DiagramML iterator evaluation (ECMA-376 Part 1, 21.4.2.x `dgm:forEach`,
+ * `dgm:presOf`, `dgm:if`): axis navigation over the engine's data tree,
+ * point-type filtering, `hideLastTrans`, and the `st`/`cnt`/`step` window.
+ *
+ * Multi-valued attributes (`axis="ch ch" ptType="node node"`) are applied as
+ * successive steps, each step starting from every point the previous one
+ * produced.
+ */
+import type { DataPoint } from './data-points.js';
+import type { LdIterator } from './layout-def-types.js';
+/** Points on one axis from `point`, in document order. */
+export declare function axisPoints(point: DataPoint, axis: string): DataPoint[];
+/** ST_ElementType filter. `node` covers assistant points as well. */
+export declare function matchesPointType(point: DataPoint, ptType: string | undefined): boolean;
+/** Apply `st`/`cnt`/`step` (1-based start, negative counts from the end). */
+export declare function windowPoints(points: DataPoint[], st?: number, cnt?: number, step?: number): DataPoint[];
+/**
+ * Every point an iterator selects from `point`. An iterator without any
+ * `axis` selects nothing (a bare `dgm:presOf`), except that a `ptType`-only
+ * iterator filters the point itself.
+ */
+export declare function iteratePoints(point: DataPoint, iterator: LdIterator): DataPoint[];
+//# sourceMappingURL=axis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"axis.d.ts","sourceRoot":"","sources":["../../../diagram/engine/axis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAuBrD,0DAA0D;AAC1D,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,CAoDtE;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAuBtF;AA0BD,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,SAAI,EAAE,GAAG,SAAI,EAAE,IAAI,SAAI,GAAG,SAAS,EAAE,CAexF;AAsBD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,GAAG,SAAS,EAAE,CAoBjF"}

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

@@ -0,0 +1,12 @@
+/**
+ * `dgm:if` evaluation (ECMA-376 Part 1, 21.4.2.13 and ST_FunctionType
+ * 21.4.7.29): `cnt`, `pos`, `revPos`, `posEven`, `posOdd`, `depth`,
+ * `maxDepth` and `var`, compared with ST_FunctionOperator.
+ */
+import type { DataPoint } from './data-points.js';
+import type { LdCondition } from './layout-def-types.js';
+/** Resolves a layout variable for the node currently being built. */
+export type VariableLookup = (name: string) => string | undefined;
+/** Evaluate a `dgm:if` for `point`. An undecidable function is false. */
+export declare function evaluateCondition(condition: LdCondition, point: DataPoint, lookup: VariableLookup): boolean;
+//# sourceMappingURL=conditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../../../diagram/engine/conditions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,WAAW,EAAc,MAAM,oBAAoB,CAAC;AAelE,qEAAqE;AACrE,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAmIlE,yEAAyE;AACzE,wBAAgB,iBAAiB,CAChC,SAAS,EAAE,WAAW,EACtB,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,cAAc,GACpB,OAAO,CAQT"}

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

@@ -0,0 +1,25 @@
+/**
+ * The drawn shape of a `conn`-algorithm node. Split out of
+ * `engine-to-result.ts` for the file-size budget.
+ *
+ * A 2-D straight connector (ECMA-376 Part 1, 21.4.2 `conn` algorithm, `dim`
+ * default `2D`, `connRout` default `stra`) is a block arrow PowerPoint caches
+ * as a `rightArrow` (`adj1 60000`, `adj2 50000`) rotated to the line, e.g.
+ * Basic Cycle's `sibTrans` arrows (style label `sibTrans2D1`). A `1D`
+ * connector is a line and a bent / curved one has no box here, so neither
+ * becomes a shape (PowerPoint rebuilds connector lines itself).
+ */
+import type { DiagramData } from '../model/index.js';
+import type { RenderedRectNode } from '../layout/smartart-layout-types.js';
+import type { EngineNode } from './engine-node.js';
+/** The preset a placed `conn` node draws as, or `undefined` when it draws no shape. */
+export declare function connectorPreset(node: EngineNode): string | undefined;
+type RoleColors = NonNullable<DiagramData['colorTransform']>['roleColors'];
+/**
+ * A placed 2-D connector as a rendered shape, filled from its style label's
+ * own colour list (`sibTrans2D1` is a tint of the node colour) when the colour
+ * transform has one. `undefined` when the connector draws no shape.
+ */
+export declare function buildConnectorNode(node: EngineNode, index: number, connectorIndex: number, palette: string[], roleColors: RoleColors): RenderedRectNode | undefined;
+export {};
+//# sourceMappingURL=connector-shape.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connector-shape.d.ts","sourceRoot":"","sources":["../../../diagram/engine/connector-shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;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;AAShD,uFAAuF;AACvF,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAqBpE;AAED,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,gBAAgB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AAE3E;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EACb,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,UAAU,GACpB,gBAAgB,GAAG,SAAS,CAmC9B"}

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

@@ -0,0 +1,30 @@
+/**
+ * Geometry inputs of a `conn` node that depend on the FINAL boxes of the
+ * shapes around it. Split out of `alg-connector.ts` for the file-size budget.
+ *
+ * - Thickness: a parent constraint sizing the connector off a content node
+ *   (Basic Cycle: `w for="ch" ptType="sibTrans" refType="w" refPtType="node"
+ *   fact="0.25"`, then the arrow's own `h refType="w" fact="1.35"`) is
+ *   evaluated before the cycle algorithm shrinks the nodes to fit, so it
+ *   still reads the unshrunk width. PowerPoint keeps the ratio to the laid-out
+ *   node, so the connector's size is re-derived from the referenced node's
+ *   final box here.
+ * - Edge distance: an `ellipse` is left along the centre line at its own
+ *   outline, not its bounding box's.
+ * - Padding: a connector with no `begPad`/`endPad` constraint keeps 22% / 25%
+ *   of the gap free at either end (measured on Basic Cycle's cached arrows,
+ *   which span 0.53 of the gap starting 0.22 in).
+ */
+import type { Box, EngineNode } from './engine-node.js';
+/** Default `begPad` / `endPad`, as fractions of `connDist`. */
+export declare const DEFAULT_BEGIN_PAD = 0.22;
+export declare const DEFAULT_END_PAD = 0.25;
+/**
+ * Re-apply the parent's size constraints that address `node` off another
+ * node's laid-out box, then `node`'s own self-scoped size constraints.
+ * Returns the connector's thickness (`h`), or `fallback` when nothing sizes it.
+ */
+export declare function connectorThickness(node: EngineNode, fallback: number): number;
+/** Distance from a shape's centre to its outline along the unit direction (dx, dy). */
+export declare function edgeDistance(shape: EngineNode, box: Box, dx: number, dy: number): number;
+//# sourceMappingURL=connector-size.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connector-size.d.ts","sourceRoot":"","sources":["../../../diagram/engine/connector-size.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAKrD,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,eAAe,OAAO,CAAC;AAEpC;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuC7E;AAED,uFAAuF;AACvF,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CASxF"}

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

@@ -0,0 +1,37 @@
+/**
+ * Constraint evaluation (ECMA-376 Part 1, 21.4.2.x `dgm:constr`,
+ * CT_Constraint). A node's `constrLst` assigns values to itself
+ * (`for="self"`), its children (`for="ch"`) or any descendant
+ * (`for="des"`), filtered by layout-node name and data-point type. A value
+ * is either a literal `val` or another node's value times `fact`.
+ *
+ * Literal lengths are millimetres per the schema and are converted to points
+ * here; the engine works in points throughout. Constraints that read a font
+ * size (margins at `fact` x `primFontSz`, fonts linked across nodes) cannot be
+ * known until text is fitted, so they are recorded as deferred constraints
+ * and resolved by the text fitter.
+ *
+ * One exception to the millimetre convention: the `ctrX`/`w` (or `ctrY`/`h`)
+ * "fill and centre" idiom real "Basic Pyramid" writes for its `level` node,
+ * where a bare literal is a FRACTION of the declaring node's own size instead
+ * - see `constraint-fill-idiom.ts`'s module doc comment for the full,
+ * COM-verified derivation and why it is scoped narrowly enough not to affect
+ * Gear's own (superficially identical) anchor-point literals.
+ */
+import type { EngineNode } from './engine-node.js';
+import type { LdConstraint } from './layout-def-types.js';
+export { FONT_TYPES } from './constraint-units.js';
+export { fontAssigned } from './font-length.js';
+/** Nodes a constraint addresses relative to `node`. */
+export declare function relatedNodes(node: EngineNode, relation: 'self' | 'ch' | 'des', name: string | undefined, ptType: string): EngineNode[];
+/**
+ * A node's current value of `type`: an assigned constraint value, or one
+ * derived from the others on the same axis (`r = l + w`, `b = ctrY + h/2`,
+ * ...), or its box size.
+ */
+export declare function valueOf(node: EngineNode, type: string): number | undefined;
+/** Apply one constraint declared on `node`. */
+export declare function applyConstraint(node: EngineNode, constraint: LdConstraint): void;
+/** Apply every constraint declared on `node`, in document order. */
+export declare function evaluateConstraints(node: EngineNode): void;
+//# sourceMappingURL=constraint-eval.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-eval.d.ts","sourceRoot":"","sources":["../../../diagram/engine/constraint-eval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAaH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAE7C,uDAAuD;AACvD,wBAAgB,YAAY,CAC3B,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,EAC/B,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,MAAM,EAAE,MAAM,GACZ,UAAU,EAAE,CAsBd;AAiED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAO1E;AA6BD,+CAA+C;AAC/C,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,GAAG,IAAI,CA6DhF;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAK1D"}

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