ooxml-core 1.1.0 → 1.2.0

package/dist/{chunk-2C72N64G.cjs → chunk-XROY25LN.cjs}

@@ -4,6 +4,17 @@
 function withCellText(cell, text) {
   const next = { ...cell, text };
   delete next.textRuns;
+  if (cell.paragraphs) {
+    next.paragraphs = cell.paragraphs.slice(0, 1);
+  }
+  return next;
+}
+function withCellStyle(cell, patch) {
+  const next = { ...cell, style: { ...cell.style, ...patch } };
+  const { align } = patch;
+  if (align) {
+    next.paragraphs = cell.text.split("\n").map((_, index) => ({ ...cell.paragraphs?.[index], align }));
+  }
   return next;
 }
 function setCellText(element, rowIndex, colIndex, text) {
@@ -24,4 +35,5 @@ function setCellText(element, rowIndex, colIndex, text) {
 }
 
 exports.setCellText = setCellText;
+exports.withCellStyle = withCellStyle;
 exports.withCellText = withCellText;

package/dist/collab/index.cjs

@@ -1206,6 +1206,7 @@ function createTransportProvider({ doc, awareness }, { transport, maxMessageByte
     const kind = decoding__namespace.readVarUint(decoder);
     const payload = decoding__namespace.readVarUint8Array(decoder);
     if (kind === SYNC_STEP1) {
+      if (awareness.getLocalState() !== null) sendAwareness([doc.clientID]);
       const encoder = encoding__namespace.createEncoder();
       encoding__namespace.writeVarUint(encoder, MESSAGE_SYNC);
       encoding__namespace.writeVarUint(encoder, SYNC_STEP2);

package/dist/collab/index.mjs

@@ -1182,6 +1182,7 @@ function createTransportProvider({ doc, awareness }, { transport, maxMessageByte
     const kind = decoding.readVarUint(decoder);
     const payload = decoding.readVarUint8Array(decoder);
     if (kind === SYNC_STEP1) {
+      if (awareness.getLocalState() !== null) sendAwareness([doc.clientID]);
       const encoder = encoding.createEncoder();
       encoding.writeVarUint(encoder, MESSAGE_SYNC);
       encoding.writeVarUint(encoder, SYNC_STEP2);

package/dist/collab/transport-provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transport-provider.d.ts","sourceRoot":"","sources":["../../collab/transport-provider.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAEX,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAKzC,MAAM,WAAW,wBAAwB;IACxC,SAAS,EAAE,SAAS,CAAC;IACrB,gEAAgE;IAChE,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,wBAAwB,GAC/B,CAAC,OAAO,EAAE,eAAe,KAAK,YAAY,CAE5C;AAED,wBAAgB,uBAAuB,CACtC,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,eAAe,EACnC,EAAE,SAAS,EAAE,eAAkC,EAAE,EAAE,wBAAwB,GACzE,YAAY,CAuLd"}
+{"version":3,"file":"transport-provider.d.ts","sourceRoot":"","sources":["../../collab/transport-provider.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAEX,eAAe,EAEf,YAAY,EACZ,SAAS,EACT,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,YAAY,IAAI,CAAC;AAC9B,eAAO,MAAM,iBAAiB,IAAI,CAAC;AACnC,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAKzC,MAAM,WAAW,wBAAwB;IACxC,SAAS,EAAE,SAAS,CAAC;IACrB,gEAAgE;IAChE,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,+FAA+F;AAC/F,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,wBAAwB,GAC/B,CAAC,OAAO,EAAE,eAAe,KAAK,YAAY,CAE5C;AAED,wBAAgB,uBAAuB,CACtC,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,eAAe,EACnC,EAAE,SAAS,EAAE,eAAkC,EAAE,EAAE,wBAAwB,GACzE,YAAY,CA0Ld"}

package/dist/color/hex-rgb.d.ts

@@ -0,0 +1,5 @@
+/** Parses `RRGGBB` or `AARRGGBB` (alpha ignored), with or without `#`. */
+export declare function parseArgbHex(hex: string): [number, number, number] | undefined;
+/** `#RRGGBB` (upper case) from rounded, clamped 0-255 channels. */
+export declare const rgbToUpperHex: (rgb: readonly number[]) => string;
+//# sourceMappingURL=hex-rgb.d.ts.map

package/dist/color/hex-rgb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hex-rgb.d.ts","sourceRoot":"","sources":["../../color/hex-rgb.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAK9E;AAID,mEAAmE;AACnE,eAAO,MAAM,aAAa,QAAS,SAAS,MAAM,EAAE,KAAG,MAIrC,CAAC"}

package/dist/color/index.cjs

@@ -468,6 +468,16 @@ function sigmaGradientStops(stops) {
   });
 }
 
+// color/hex-rgb.ts
+function parseArgbHex(hex) {
+  const clean = hex.replace(/^#/, "");
+  const rgb = clean.length === 8 ? clean.slice(2) : clean;
+  if (!/^[0-9a-fA-F]{6}$/.test(rgb)) return void 0;
+  return [0, 2, 4].map((i) => parseInt(rgb.slice(i, i + 2), 16));
+}
+var clamp255 = (v) => Math.max(0, Math.min(255, v));
+var rgbToUpperHex = (rgb) => `#${rgb.map((v) => clamp255(Math.round(v)).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+
 exports.blendColorOntoWhite = blendColorOntoWhite;
 exports.clampUnitInterval = clampUnitInterval;
 exports.colorWithOpacity = colorWithOpacity;
@@ -477,12 +487,14 @@ exports.hexToRgbUnit = hexToRgbUnit;
 exports.hslToRgb = hslToRgb;
 exports.linearToSrgb255 = linearToSrgb255;
 exports.normalizeHexColor = normalizeHexColor;
+exports.parseArgbHex = parseArgbHex;
 exports.parseDrawingFraction = parseDrawingFraction;
 exports.parseDrawingHueDegrees = parseDrawingHueDegrees;
 exports.parseDrawingPercent = parseDrawingPercent;
 exports.parseHex = parseHex;
 exports.parseOoxmlPercent = parseOoxmlPercent;
 exports.rgbToHsl = rgbToHsl;
+exports.rgbToUpperHex = rgbToUpperHex;
 exports.scrgbLinearToSrgb8 = scrgbLinearToSrgb8;
 exports.sigmaGradientStops = sigmaGradientStops;
 exports.srgb255ToLinear = srgb255ToLinear;

package/dist/color/index.d.ts

@@ -3,4 +3,5 @@ export * from './color-linear.js';
 export * from './contrast.js';
 export * from './unit-rgb.js';
 export * from './sigma-gradient-stops.js';
+export * from './hex-rgb.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/color/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../color/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../color/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,WAAW,CAAC"}

package/dist/color/index.mjs

@@ -466,4 +466,14 @@ function sigmaGradientStops(stops) {
   });
 }
 
-export { blendColorOntoWhite, clampUnitInterval, colorWithOpacity, contrastTextColor, hexToRgbChannels, hexToRgbUnit, hslToRgb, linearToSrgb255, normalizeHexColor, parseDrawingFraction, parseDrawingHueDegrees, parseDrawingPercent, parseHex, parseOoxmlPercent, rgbToHsl, scrgbLinearToSrgb8, sigmaGradientStops, srgb255ToLinear, toHex };
+// color/hex-rgb.ts
+function parseArgbHex(hex) {
+  const clean = hex.replace(/^#/, "");
+  const rgb = clean.length === 8 ? clean.slice(2) : clean;
+  if (!/^[0-9a-fA-F]{6}$/.test(rgb)) return void 0;
+  return [0, 2, 4].map((i) => parseInt(rgb.slice(i, i + 2), 16));
+}
+var clamp255 = (v) => Math.max(0, Math.min(255, v));
+var rgbToUpperHex = (rgb) => `#${rgb.map((v) => clamp255(Math.round(v)).toString(16).padStart(2, "0")).join("").toUpperCase()}`;
+
+export { blendColorOntoWhite, clampUnitInterval, colorWithOpacity, contrastTextColor, hexToRgbChannels, hexToRgbUnit, hslToRgb, linearToSrgb255, normalizeHexColor, parseArgbHex, parseDrawingFraction, parseDrawingHueDegrees, parseDrawingPercent, parseHex, parseOoxmlPercent, rgbToHsl, rgbToUpperHex, scrgbLinearToSrgb8, sigmaGradientStops, srgb255ToLinear, toHex };

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