ooxml-core 1.1.0 → 1.2.1

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

@@ -0,0 +1,38 @@
+export type * from './smartart-layout-types.js';
+export { resolveFontTable } from './smartart-font-table.js';
+export { SMARTART_LINE_SPACING_FACTOR, fitWrappedFontSize, measureTextWidth, wrappedLineCount, wrappedWidestLineWidth, } from './smartart-text-wrap-fit.js';
+export { algorithmParameters, groupedChildren, orderedXmlView, type RawXmlView, } from './smartart-choose-xml.js';
+export { orderedAttributes, parseIteratorAttributes, parseOrderedWhen, parseWhenAttributes, validateSmartArtControlFlow, } from './smartart-layout-control-flow.js';
+export { activeBranch, nestedChooseBranch } from './smartart-layout-interpreter-choose-branch.js';
+export { chooseAlgorithm, chooseAlgorithmOfType, chooseAlgType, } from './smartart-layout-interpreter-choose-algorithm.js';
+export { structuralChooseAlgDepth, tunnelsPastOwnCompositeSlot, type StructuralChooseAlgResult, } from './smartart-layout-interpreter-choose-depth.js';
+export { evaluateWhen, type WhenContext } from './smartart-layout-interpreter-when.js';
+export { resolvePresentationOf } from './smartart-layout-interpreter-presof-choose.js';
+export { resolveAxisCount, resolveAxisNodes } from './smartart-layout-interpreter-axis-count.js';
+export { constraintAttributes, formatXsdDouble, parseConstraintAttributes, parseRuleAttributes, parseXsdDouble, ruleAttributes, validateSmartArtConstraintRules, type DiagramAttributeValue, } from './smartart-constraint-rules.js';
+export { buildConstraintIndex, EMPTY_CONSTRAINT_INDEX, resolveConstraint, type ConstraintIndex, type IndexedConstraint, } from './smartart-constraint-solver.js';
+export { resolveRatioConstraint } from './smartart-constraint-ratio-fallback.js';
+export { selectConstraints } from './smartart-constraint-branch-index.js';
+export { clampByRules, findConstraint, ratioConstraint, } from './smartart-layout-interpreter-constraints.js';
+export { discoverArrangement, resolveFlowDirection, type ArrangementKind, type ArrangementPlan, type FlowDirection, } from './smartart-layout-interpreter-model.js';
+export { selectArrangedNodes } from './smartart-layout-interpreter-flow.js';
+export { buildForest, buildTree, treeDepth, treeWidth, type TreeNode } from './smartart-tree.js';
+export { resolveHierarchyItemFontSizePx } from './smartart-layout-interpreter-hierarchy-fontfit.js';
+export { resolveRoleFontSize, resolveSharedItemFontSize, type FontFitItem, } from './smartart-layout-item-font-size.js';
+export { resolveTieredItemFontSize, SMARTART_DESCENDANT_FONT_SCALE, } from './smartart-layout-item-font-tier.js';
+export { presetBoxNode, type PresetBoxNodeParams } from './smartart-layout-interpreter-preset-node.js';
+export { circleNode, polygonNode, rectNode, styleContext, type StyleContext, } from './smartart-layout-interpreter-render.js';
+export { presetPolygonPoints } from './smartart-layout-shape-polygon.js';
+export { interpretSmartArtLayout, type InterpretLayoutInput } from './smartart-layout-interpreter.js';
+export { dispatchArrangement } from './smartart-layout-interpreter-dispatch.js';
+export { arrangeConn, arrangeSpacer, arrangeText } from './smartart-layout-interpreter-aux.js';
+export { arrangeComposite } from './smartart-layout-interpreter-composite.js';
+export { arrangeCycle } from './smartart-layout-interpreter-cycle.js';
+export { arrangeLinear } from './smartart-layout-interpreter-linear.js';
+export { arrangePyramid } from './smartart-layout-interpreter-pyramid.js';
+export { arrangeSnake } from './smartart-layout-interpreter-snake.js';
+export { applyCustomLayoutOverrides } from './smartart-layout-interpreter-custom.js';
+export { applySmartArtRoleColors, type SmartArtColorRoleMap } from './smartart-node-role-colors.js';
+export { smartArtChildrenOf, topLevelSmartArtNodes } from './smartart-node-tree-axis.js';
+export { collectFoldedDescendants, foldedDescendantTexts, foldedItemText, } from './smartart-interpreter-fold-text.js';
+//# sourceMappingURL=index.d.ts.map

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

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

package/dist/diagram/layout/smartart-choose-xml.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The one raw-XML representation the SmartArt layout interpreter walks: the
+ * engine's document-order element tree (`engine/ordered-xml`). A layout
+ * definition model keeps its raw slots (`rawXml`) in whatever form its reader
+ * produced; a {@link RawXmlView} turns one slot into an element (pptx adapts
+ * its `fast-xml-parser` objects at its own boundary).
+ *
+ * The walkers iterate children through {@link groupedChildren}: every child
+ * with the same local name together, groups ordered by each name's first
+ * appearance. That is the order the walkers were measured against (the pptx
+ * object tree groups same-named siblings into one array per tag), so the
+ * result is the same whether the element came from the object tree or from
+ * the part text in document order.
+ */
+import type { OrderedXmlElement } from '../engine/ordered-xml.js';
+export type { OrderedXmlElement } from '../engine/ordered-xml.js';
+/** Turns a model's raw-XML slot into an element, or `undefined` when there is none. */
+export type RawXmlView<R> = (raw: R | undefined) => OrderedXmlElement | undefined;
+/** A view for models whose raw slots already are ordered elements. */
+export declare const orderedXmlView: RawXmlView<OrderedXmlElement>;
+/** `element`'s children, same-named siblings grouped together in first-appearance order. */
+export declare function groupedChildren(element: OrderedXmlElement): readonly OrderedXmlElement[];
+/** Children of `element` named `name` (local name), in document order. */
+export declare function childrenNamed(element: OrderedXmlElement | undefined, name: string): OrderedXmlElement[];
+/** The first child of `element` named `name` (local name). */
+export declare function firstChildNamed(element: OrderedXmlElement | undefined, name: string): OrderedXmlElement | undefined;
+/** `dgm:param` children of a `dgm:alg` element as `{ type, value }`, skipping a missing `@type`. */
+export declare function algorithmParameters(alg: OrderedXmlElement): {
+    type: string;
+    value: string | undefined;
+}[];
+//# sourceMappingURL=smartart-choose-xml.d.ts.map

package/dist/diagram/layout/smartart-choose-xml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-choose-xml.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-choose-xml.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,uFAAuF;AACvF,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,SAAS,KAAK,iBAAiB,GAAG,SAAS,CAAC;AAElF,sEAAsE;AACtE,eAAO,MAAM,cAAc,EAAE,UAAU,CAAC,iBAAiB,CAAgB,CAAC;AAI1E,4FAA4F;AAC5F,wBAAgB,eAAe,CAAC,OAAO,EAAE,iBAAiB,GAAG,SAAS,iBAAiB,EAAE,CAiBxF;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAC5B,OAAO,EAAE,iBAAiB,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GACV,iBAAiB,EAAE,CAErB;AAED,8DAA8D;AAC9D,wBAAgB,eAAe,CAC9B,OAAO,EAAE,iBAAiB,GAAG,SAAS,EACtC,IAAI,EAAE,MAAM,GACV,iBAAiB,GAAG,SAAS,CAE/B;AAED,oGAAoG;AACpG,wBAAgB,mBAAmB,CAClC,GAAG,EAAE,iBAAiB,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EAAE,CAS/C"}

package/dist/diagram/layout/smartart-constraint-branch-index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * SmartArt DiagramML interpreter - choose-aware constraint selection.
+ *
+ * `smartart-constraint-solver.ts`'s `buildConstraintIndex` has always indexed
+ * `DiagramLayoutNode.allConstraints`: every `dgm:constr` reachable
+ * through a `dgm:choose`/`dgm:if`/`dgm:else` wrapping a node's own
+ * `constrLst`, BLINDLY UNIONED with no guard evaluation at all (that field's
+ * own doc comment documents this as deliberate: "this interpreter does not
+ * evaluate `dgm:choose` conditions when indexing constraints"). That
+ * degrades correctly when only one branch ever declares a given (role, type)
+ * pair, but `basic-venn--flat3.pptx`'s composite `Name9` choose declares a
+ * SEPARATE, genuinely different `ctrX`/`ctrY`/`w`/`h` for `circ1` (and every
+ * other named slot) per data-point-count branch - `resolveInternal`
+ * (`smartart-constraint-solver.ts`) then picks whichever branch's constraint
+ * sits FIRST in raw-XML document order, regardless of which branch is
+ * actually live for the current diagram.
+ *
+ * {@link selectConstraints} is the choose-aware alternative: it groups
+ * `DiagramLayoutNode.constraintCandidates` (round 39,
+ * `smartart-layout-definition-constraint-candidates.ts`) by guard chain (one
+ * group per `dgm:if`/`dgm:else` branch) and returns the constraints of the
+ * FIRST branch, in document order, whose ENTIRE guard chain evaluates
+ * DEFINITIVELY true via `evaluateWhen` - deliberately stricter than this
+ * interpreter's usual "undecidable defaults to allow" convention, since a
+ * wrongly-selected branch here silently swaps in a DIFFERENT numeric
+ * constant, not merely an extra/missing shape. A group with an EMPTY guard
+ * chain (an unconditional constraint sitting alongside a choose, or an
+ * outermost `dgm:else` with no ancestor `dgm:if`) is never treated as
+ * decidably selected either: nothing proves its siblings false, so it stays
+ * a fallback candidate, never a positive match.
+ *
+ * `undefined` whenever nothing resolves decidably - no candidates, `nodeCount`
+ * omitted, or every branch (the `else` included) stays undecided - so the
+ * caller falls back to `buildConstraintIndex`'s pre-existing blind union
+ * exactly as before. A node whose `constrLst` is not choose-guarded at all
+ * (`constraintCandidates` absent, the overwhelmingly common case) is
+ * completely unaffected: this returns `undefined` on the very first check.
+ *
+ * Pure geometry; no framework code.
+ */
+import type { DiagramConstraint, DiagramLayoutNode } from '../model/index.js';
+import type { WhenContext } from './smartart-layout-interpreter-when.js';
+/**
+ * The constraints of the one genuinely LIVE branch for `node`'s
+ * `constrLst`, or `undefined` when nothing resolves decidably (see this
+ * module's own doc comment for the full contract).
+ */
+export declare function selectConstraints(node: DiagramLayoutNode, nodeCount: number | undefined, context: WhenContext | undefined): DiagramConstraint[] | undefined;
+//# sourceMappingURL=smartart-constraint-branch-index.d.ts.map

package/dist/diagram/layout/smartart-constraint-branch-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-constraint-branch-index.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-constraint-branch-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,iBAAiB,EAAe,MAAM,UAAU,CAAC;AAClF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAuCtE;;;;GAIG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,iBAAiB,EACvB,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,OAAO,EAAE,WAAW,GAAG,SAAS,GAC9B,iBAAiB,EAAE,GAAG,SAAS,CAiBjC"}

package/dist/diagram/layout/smartart-constraint-declared-by.d.ts

@@ -0,0 +1,64 @@
+/**
+ * SmartArt DiagramML interpreter - arranger-scoped constraint resolution.
+ *
+ * Split out of `smartart-constraint-solver.ts` to keep that file under the
+ * repo's per-file line budget: this is one extra, narrower resolution mode
+ * layered on top of the general `ConstraintIndex` machinery there.
+ */
+import type { DiagramConstraint } from '../model/index.js';
+import type { ConstraintIndex, IndexedConstraint } from './smartart-constraint-solver.js';
+/**
+ * Resolve a role's constraint of `type`, considering ONLY declarations made
+ * by `declaringRole` (typically the ARRANGER itself, via its own `for="ch"
+ * forName="<role>"`/`ptType="<role>"` entries) - a role's OWN self-scoped
+ * constrLst entry for the same `type` is ignored at this top level (though a
+ * reference chain from an accepted candidate still resolves normally, with no
+ * such restriction, once underway).
+ *
+ * This distinction is measured, not incidental: real PowerPoint output honours
+ * an ARRANGER-declared per-item aspect (verified against `animation-builds-
+ * color.pptx` in `smartart-relative-constraint-roundtrip.test.ts`, a genuine
+ * `for="ch" forName="node" refType="w" refFor="ch" refForName="node" fact=
+ * "0.6"` declaration), but does NOT apply an item's OWN self-scoped `h`/`w`
+ * (e.g. "Basic Process"'s `tx` item template's own `<dgm:constr type="h"
+ * refType="w" fact="0.6"/>`, and "Vertical Process"'s roundRect item's own
+ * `<dgm:constr type="w" refType="h" fact="1.8"/>`) to the outer box at all -
+ * both are genuinely full-cross-axis boxes in the cached drawing regardless.
+ * Applying the item's own declaration as if it were arranger-declared
+ * regressed both from ~2-4% deviation to over 70-90%
+ * (`smartart-gallery-ground-truth.test.ts`).
+ */
+export declare function resolveConstraintDeclaredBy(index: ConstraintIndex, role: string, type: string, declaringRole: string): number | undefined;
+/**
+ * The raw `dgm:constr` a role's `type` is declared by `declaringRole`, when
+ * one exists - the SAME entry {@link resolveConstraintDeclaredBy} would
+ * resolve, but unresolved (no factor/reference walk applied). Exposed for a
+ * caller (`smartart-layout-interpreter-composite-slots.ts`) that needs the
+ * constraint's own `referenceType` to pick which box axis (`w`/`h`) the
+ * resolved NUMBER scales against - `resolveConstraintDeclaredBy` folds that
+ * choice away internally.
+ */
+export declare function firstConstraintDeclaredBy(index: ConstraintIndex, role: string, type: string, declaringRole: string): DiagramConstraint | undefined;
+/**
+ * Find a `type`-typed constraint declared by one of `declaringRoleChain`
+ * (nearest ancestor first), scanning the WHOLE index rather than one known
+ * `(role, type)` key - for a lookup whose target role is not known in
+ * advance (a `ptType`-targeted `userS` declaration keyed by a generic role
+ * like `node`, not by the specific item's own `forName`; see
+ * `smartart-layout-interpreter-cycle-hub-ratio.ts`'s `resolveHubToNodeRatioViaUserSize`).
+ *
+ * Disambiguates the SAME way `resolveConstraintDeclaredBy` already does for
+ * a known role key: when multiple declarations of `type` exist across the
+ * whole layout definition (e.g. `radial-cluster--hier5.pptx`'s own
+ * `userS` declared BOTH at the diagram root `Name0` for its `dir=norm`/
+ * `dir=rev` branches AND, unrelated, at the `singleCycle` alternative
+ * branch for its OWN `n=1` structure), only a declaration made by a TRUE
+ * ancestor of the current arranger should win - picking whichever candidate
+ * merely sits first in document order is exactly the ambiguity this guards
+ * against. `optionalMatch`, when given, further restricts which constraint
+ * of `type` counts (e.g. "carries a `referenceForName`"). Returns the
+ * nearest ancestor's own match first; `undefined` when no candidate's
+ * `declaringRole` is anywhere in the chain.
+ */
+export declare function resolveByAncestorChain(index: ConstraintIndex, type: string, declaringRoleChain: readonly string[], optionalMatch?: (constraint: DiagramConstraint) => boolean): IndexedConstraint | undefined;
+//# sourceMappingURL=smartart-constraint-declared-by.d.ts.map

package/dist/diagram/layout/smartart-constraint-declared-by.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-constraint-declared-by.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-constraint-declared-by.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGvF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GACnB,MAAM,GAAG,SAAS,CAgBpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,GACnB,iBAAiB,GAAG,SAAS,CAG/B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,EACZ,kBAAkB,EAAE,SAAS,MAAM,EAAE,EACrC,aAAa,CAAC,EAAE,CAAC,UAAU,EAAE,iBAAiB,KAAK,OAAO,GACxD,iBAAiB,GAAG,SAAS,CAc/B"}

package/dist/diagram/layout/smartart-constraint-ratio-fallback.d.ts

@@ -0,0 +1,18 @@
+/**
+ * SmartArt DiagramML interpreter - relative-constraint ratio fallback.
+ *
+ * Split out of `smartart-constraint-solver.ts` to keep that file under the
+ * repo's per-file line budget: this is the `resolveRatioConstraint` drop-in
+ * replacement for a bare `ratioConstraint(...)` scalar-literal scan, layered
+ * on top of the general `ConstraintIndex` machinery there.
+ */
+import type { DiagramConstraint, DiagramNumericRule } from '../model/index.js';
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+/**
+ * Drop-in replacement for a bare `ratioConstraint(...)` call: tries the exact
+ * same literal scan first (so every already-passing behaviour is unchanged),
+ * then falls back to resolving a relative constraint declared for `role`
+ * before giving up to `fallback`.
+ */
+export declare function resolveRatioConstraint(constraints: DiagramConstraint[] | undefined, index: ConstraintIndex, role: string, types: readonly string[], fallback: number, rules?: DiagramNumericRule[]): number;
+//# sourceMappingURL=smartart-constraint-ratio-fallback.d.ts.map

package/dist/diagram/layout/smartart-constraint-ratio-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-constraint-ratio-fallback.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-constraint-ratio-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AA+BpE;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACrC,WAAW,EAAE,iBAAiB,EAAE,GAAG,SAAS,EAC5C,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,QAAQ,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,kBAAkB,EAAE,GAC1B,MAAM,CAOR"}

package/dist/diagram/layout/smartart-constraint-resolve.d.ts

@@ -0,0 +1,24 @@
+/**
+ * SmartArt DiagramML interpreter - constraint reference-chain resolution.
+ *
+ * Split out of `smartart-constraint-solver.ts` (the repo's per-file line
+ * budget): that module builds the `ConstraintIndex`, this module walks it -
+ * resolving a `dgm:constr`'s own literal `val`/`fact`, or, when it carries a
+ * `refType`/`refFor`/`refForName`/`refPtType`, following the reference chain
+ * depth-first (with cycle and missing-target protection) until a literal
+ * value is reached. See `smartart-constraint-solver.ts`'s own module doc
+ * comment for the full targeting/degradation rules this implements.
+ *
+ * Pure graph/geometry code; no framework code, no DOM.
+ */
+import type { ConstraintIndex, IndexedConstraint } from './smartart-constraint-solver.js';
+/** Exposed for `smartart-constraint-declared-by.ts` (see `IndexedConstraint`). */
+export declare function resolveEntry(index: ConstraintIndex, entry: IndexedConstraint, visiting: Set<string>): number | undefined;
+/**
+ * Resolve the value a role's constraint of `type` ultimately carries, walking
+ * any `refType`/`refFor`/`refForName` chain. Returns `undefined` when nothing
+ * declares it, a reference cannot be resolved, or resolution would cycle - the
+ * caller is expected to fall back to its own default in every such case.
+ */
+export declare function resolveConstraint(index: ConstraintIndex, role: string, type: string): number | undefined;
+//# sourceMappingURL=smartart-constraint-resolve.d.ts.map

package/dist/diagram/layout/smartart-constraint-resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-constraint-resolve.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-constraint-resolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAgCvF,kFAAkF;AAClF,wBAAgB,YAAY,CAC3B,KAAK,EAAE,eAAe,EACtB,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,GACnB,MAAM,GAAG,SAAS,CAqDpB;AAyDD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACV,MAAM,GAAG,SAAS,CAEpB"}

package/dist/diagram/layout/smartart-constraint-rules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * DiagramML `dgm:constr` (CT_Constraint) and `dgm:rule` (CT_NumericRule)
+ * attributes read through an {@link AttributeReader}, their validation, and
+ * the attribute values a writer puts back. Extracted from
+ * `pptx/core/utils/smartart-constraint-rules.ts`; pptx keeps the object-tree
+ * list lookup and the writer that merges these values into its parts.
+ */
+import type { AttributeReader } from '../../drawingml/types.js';
+import type { DiagramConstraint, DiagramLayoutNode, DiagramNumericRule } from '../model/index.js';
+/** An `xsd:double` attribute (`NaN`, `INF` and `-INF` included), `undefined` when absent or invalid. */
+export declare function parseXsdDouble(value: string | undefined): number | undefined;
+/** The `xsd:double` lexical form of `value`. */
+export declare function formatXsdDouble(value: number): string;
+/** A `dgm:constr`, keeping `rawXml` as the reader's round-trip slot. */
+export declare function parseConstraintAttributes<R>(read: AttributeReader, rawXml: R | undefined): DiagramConstraint<R>;
+/** A `dgm:rule`, keeping `rawXml` as the reader's round-trip slot. */
+export declare function parseRuleAttributes<R>(read: AttributeReader, rawXml: R | undefined): DiagramNumericRule<R>;
+/** Enumeration errors in a layout node's constraints and rules. */
+export declare function validateSmartArtConstraintRules(value: DiagramLayoutNode): string[];
+/** One attribute a writer sets (a string) or removes (`undefined`), in write order. */
+export type DiagramAttributeValue = readonly [name: string, value: string | undefined];
+/** The `dgm:constr` attributes a writer sets for `value`, in write order. */
+export declare function constraintAttributes(value: DiagramConstraint): DiagramAttributeValue[];
+/** The `dgm:rule` attributes a writer sets for `value`, in write order. */
+export declare function ruleAttributes(value: DiagramNumericRule): DiagramAttributeValue[];
+//# sourceMappingURL=smartart-constraint-rules.d.ts.map

package/dist/diagram/layout/smartart-constraint-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-constraint-rules.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-constraint-rules.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EACX,iBAAiB,EAKjB,iBAAiB,EACjB,kBAAkB,EAClB,MAAM,UAAU,CAAC;AAQlB,wGAAwG;AACxG,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAe5E;AAED,gDAAgD;AAChD,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAWrD;AAUD,wEAAwE;AACxE,wBAAgB,yBAAyB,CAAC,CAAC,EAC1C,IAAI,EAAE,eAAe,EACrB,MAAM,EAAE,CAAC,GAAG,SAAS,GACnB,iBAAiB,CAAC,CAAC,CAAC,CAatB;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,CAAC,EACpC,IAAI,EAAE,eAAe,EACrB,MAAM,EAAE,CAAC,GAAG,SAAS,GACnB,kBAAkB,CAAC,CAAC,CAAC,CASvB;AAgBD,mEAAmE;AACnE,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,EAAE,CAuBlF;AAED,uFAAuF;AACvF,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAiBvF,6EAA6E;AAC7E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,qBAAqB,EAAE,CAStF;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAAC,KAAK,EAAE,kBAAkB,GAAG,qBAAqB,EAAE,CAEjF"}

package/dist/diagram/layout/smartart-constraint-sibling-roles.d.ts

@@ -0,0 +1,100 @@
+/**
+ * SmartArt DiagramML interpreter - sibling-role enumeration over a
+ * {@link ConstraintIndex}.
+ *
+ * Split out of `smartart-constraint-solver.ts` (the repo's per-file line
+ * budget, already at 300 LOC). `entryKey`/`ConstraintIndex.entries` are keyed
+ * `${role}::${type}` with no reverse lookup by `(declaringRole, type)` alone -
+ * every existing consumer queries ONE already-known target role at a time.
+ * `smartart-layout-interpreter-item-role-stack.ts`'s `stackAsRect` (round 20)
+ * needs the OPPOSITE direction: given an arranger role and a constraint
+ * `type`, every role NAME that arranger declares one for, whether or not
+ * that role ended up resolving actual content this point (a non-text
+ * sibling like "Vertical Bullet List"'s `spacer` never resolves into
+ * `ItemRoleContent`, but its own declared `h`-weight still reserves a real
+ * share of the item box other roles must not silently absorb).
+ */
+import type { ConstraintIndex } from './smartart-constraint-solver.js';
+/**
+ * Every role NAME `declaringRole` declares a `type` constraint for, scanning
+ * the WHOLE index (not just one already-known target). Order is not
+ * meaningful; a caller that needs to sum weights should just fold over the
+ * result. Empty when `declaringRole` declares no `type` constraint for any
+ * child at all.
+ */
+export declare function siblingRolesDeclaringType(index: ConstraintIndex, declaringRole: string, type: string): string[];
+/**
+ * Round 23: true when EVERY role `arrangerRole` declares an `h` constraint
+ * for is `primFontSz`-relative to `itemRole` itself (`<dgm:constr type="h"
+ * for="ch" forName="parentText" refType="primFontSz" refFor="ch"
+ * refForName="parentText" fact="0.52"/>`, `forName="childText" ...
+ * refForName="parentText" fact="0.46"`, ... - "Vertical Bullet List"'s own
+ * pattern). Signals that any OTHER declared role's content (`childText`) is
+ * a SEPARATE rendered box for `itemRole`'s own text, not a paragraph folded
+ * into the SAME box the way `basic-process`'s bare `axis="ch"` folding is -
+ * see `TieredFontFitItem.separateDescendantBox`'s doc comment for why that
+ * distinction changes the font-fit's own `spcAft` term. `false` (not just
+ * "no pattern") when the arranger declares no `h` constraint for any child
+ * role at all, so a plain item template is unaffected.
+ *
+ * ALSO requires `itemRole`'s own `primFontSz` to carry a LITERAL ceiling
+ * somewhere in the index (`op="equ" val="65"`, no `ref*` at all) - the
+ * genuine top-level anchor a shared font-fit can key off. Round 23:
+ * `vertical-circle-list--hier5.pptx`'s NESTED `lin` declares the SAME
+ * shape one level down (`txLvl2`/`txLvl3`/`smCircle`/`indentDot1-3`, all
+ * `primFontSz`-relative to `txLvl2`), but `txLvl2`'s OWN `primFontSz` is
+ * ITSELF only ever declared as a REFERENCE (`0.78 * txLvl1`, from the OUTER
+ * arranger) - not a real anchor, already a once-demoted descendant size.
+ * Reusing `arrangeLinear`'s own fit for `txLvl2` there regressed it (25.3px
+ * cached vs 68.0px, worse than the pre-round-23 34.7px) - requiring a
+ * literal ceiling excludes this case while keeping "Vertical Bullet
+ * List"'s own `parentText` (`<dgm:constr type="primFontSz" for="ch"
+ * forName="parentText" op="equ" val="65"/>`, no reference at all).
+ */
+export declare function isPrimFontSzRoleSplitItem(index: ConstraintIndex, arrangerRole: string, itemRole: string): boolean;
+/**
+ * Round 25: true when `itemRole` (the `isPrimFontSzRoleSplitItem` driving
+ * role) is itself declared by `arrangerRole` with `for="des"` (a NESTED
+ * descendant of the arranger, reached through a wrapper sub-arranger), not
+ * `for="ch"` (a flat, direct sibling at the arranger's own level).
+ *
+ * "Vertical Bullet List"'s `parentText`/`childText` are BOTH literal
+ * `for="ch"` roles of "linear" itself (`<dgm:constr type="h" for="ch"
+ * forName="parentText" refType="primFontSz" refFor="ch" refForName=
+ * "parentText" fact="0.52"/>`) - genuine flat siblings competing for ONE
+ * shared, weight-split box. "Vertical Box List"'s `parentText` is declared
+ * `for="des"` (`<dgm:constr type="h" for="des" forName="parentText"
+ * refType="primFontSz" refFor="des" refForName="parentText" fact="0.82"/>`),
+ * because it is only reachable as a DESCENDANT of "linear" - nested inside
+ * `parentLin`, a wrapper sub-arranger - never a flat sibling of `childText`
+ * (itself still a plain `for="ch"` role of "linear").
+ *
+ * This distinguishes two real, differently-rendered constructs that both
+ * satisfy `isPrimFontSzRoleSplitItem`:
+ *  - The `ch`-rooted case (`false`): `arrangeLinear`'s existing joint
+ *    root+descendant fit (folding the descendant's text into the SAME
+ *    height budget, `TieredFontFitItem.separateDescendantBox`'s own
+ *    trailing-`spcAft`-skip aside) and `stackAsRect`'s `descendantFontSize`
+ *    reuse (`SMARTART_DESCENDANT_FONT_SCALE=0.78`) are BOTH COM/cached-
+ *    verified correct here: "Vertical Bullet List"'s `childText` cached at
+ *    36pt against `parentText`'s 46pt (a genuine 0.78x ratio), and the joint
+ *    fit against the item's own shared box is what CORRECTLY caps
+ *    `parentText` at 46pt rather than its 65pt raw ceiling.
+ *  - The `des`-rooted case (`true`): `childText` there is a genuinely
+ *    SEPARATE, independently content-sized box (its own `dgm:rule
+ *    h="INF"`), never sharing `parentText`'s box at all - folding its text
+ *    into `parentText`'s OWN joint fit is a category error that measurably
+ *    OVER-shoots the shared size further (49pt, against a cached 30pt -
+ *    dragging even the leaf "Node Three", no descendant of its own, up with
+ *    it, since the whole set shares one binary search); `arrangeLinear`
+ *    keeps `separateDescendantBox` OFF (fits `parentText` alone, no
+ *    folding) here, landing on 40pt - closer to cached, though NOT yet
+ *    exact (a separate, not-yet-root-caused gap, likely margin resolution -
+ *    see the round-25 successor doc). Regardless of the fitted value,
+ *    `childText` shares that SAME driving-role size (ratio 1.0, not 0.78) -
+ *    cached ground truth confirms every shape in this construct (`parentText`
+ *    AND `childText`) is rendered at the identical 30pt, never the `ch`-
+ *    rooted flat-sibling split's own diminished ratio.
+ */
+export declare function isDesRootedFontRole(index: ConstraintIndex, arrangerRole: string, itemRole: string): boolean;
+//# sourceMappingURL=smartart-constraint-sibling-roles.d.ts.map

package/dist/diagram/layout/smartart-constraint-sibling-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-constraint-sibling-roles.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-constraint-sibling-roles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAqB,MAAM,8BAA8B,CAAC;AAGvF;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,eAAe,EACtB,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,MAAM,GACV,MAAM,EAAE,CAcV;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,eAAe,EACtB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACd,OAAO,CAmCT;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,eAAe,EACtB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACd,OAAO,CAET"}

package/dist/diagram/layout/smartart-constraint-solver.d.ts

@@ -0,0 +1,133 @@
+/**
+ * SmartArt DiagramML interpreter - relative constraint resolver.
+ *
+ * `dgm:constr` (`DiagramConstraint`) can express a value relative to
+ * ANOTHER layoutNode role's resolved value via `@refType`/`@refFor`/
+ * `@refForName`/`@refPtType`, instead of (or alongside) an absolute
+ * `@val`/`@fact`. Every existing consumer of `constrLst` in this interpreter
+ * (`ratioConstraint`, the item-aspect lookup, the `composite` slot resolver)
+ * only ever read a constraint's OWN `val`/`fact`, so a relative-only
+ * constraint silently produced nothing and the caller fell back to a
+ * hard-coded default. Confirmed against genuine PowerPoint content: `ppt/
+ * diagrams/layout1.xml` inside `e2e/fixtures/animation-builds-color.pptx`
+ * declares (on its root `diagram` layoutNode):
+ *
+ * ```xml
+ * <dgm:constr type="w" for="ch" forName="node" refType="w"/>
+ * <dgm:constr type="h" for="ch" forName="node" refType="w" refFor="ch" refForName="node" fact="0.6"/>
+ * <dgm:constr type="w" for="ch" forName="sibTrans" refType="w" refFor="ch" refForName="node" fact="0.1"/>
+ * <dgm:constr type="sp" refType="w" refFor="ch" refForName="sibTrans"/>
+ * ```
+ *
+ * i.e. every item's height is 0.6x its own (box-relative) width, the spacer
+ * between items is 0.1x an item's width, and the inter-item gap equals the
+ * spacer's width exactly - none of that resolves without walking references.
+ *
+ * This module builds a one-shot index of every `dgm:constr` in a layout
+ * definition, keyed by the ROLE it targets (the `name=` of the `dgm:layoutNode`
+ * it constrains), and resolves a (role, constraint-type) pair to a number by
+ * walking the reference chain depth-first, with cycle and missing-target
+ * protection. Pure graph/geometry code; no framework code, no DOM.
+ *
+ * ## Targeting
+ *
+ * A `dgm:constr` declared inside layoutNode `D`'s `constrLst`:
+ *   - `for` omitted or `"self"` -> targets `D` itself.
+ *   - `for="ch"` / `for="des"` with `forName="X"` -> targets the layoutNode
+ *     named `X` (a structural ROLE, not a data point - `forName` names a
+ *     `dgm:layoutNode`, confirmed against the genuine sample above; see
+ *     `smartart-layout-interpreter-named-rules.ts` for the same finding
+ *     against `dgm:rule`).
+ *   - `for="ch"` / `for="des"` with no `forName` -> no single named role is
+ *     identified, so it is attributed to `D` itself (its own configuration for
+ *     its children collectively), matching how callers already read a plain
+ *     `constrLst` array before this module existed.
+ *
+ * A reference (`refType`/`refFor`/`refForName`) resolves the same way, relative
+ * to the SAME declaring node `D`: `refFor` omitted/`"self"` refers to `D`'s own
+ * resolved value of `refType` (defaulting to the constraint's own `type` when
+ * `refType` is omitted); `refFor="ch"`/`"des"` with `refForName` refers to that
+ * named role instead.
+ *
+ * ## Degradation
+ *
+ * - A reference to a (role, type) with no declaration anywhere resolves to
+ *   `undefined`, EXCEPT the root layoutNode's own `w`/`h`: those default to
+ *   `1` (the box's own full extent), the implicit "whole diagram" unit every
+ *   `fact` in a real definition is ultimately expressed against.
+ * - A cycle (`A` needs `B` needs `A`) is caught by a resolution-stack guard and
+ *   resolves to `undefined` rather than recursing forever.
+ * - Both degrade to "not resolved": callers fall back to their own hard-coded
+ *   default, exactly as they did before any relative constraint existed.
+ */
+import type { DiagramConstraint, DiagramLayoutDefinition, DiagramLayoutNode } from '../model/index.js';
+import type { WhenContext } from './smartart-layout-interpreter-when.js';
+/** One `dgm:constr` plus the role that declared it. Exposed for
+ * `smartart-constraint-declared-by.ts`, which needs to filter candidates by
+ * `declaringRole` before running the same reference-walking logic. */
+export interface IndexedConstraint {
+    constraint: DiagramConstraint;
+    /** Name of the layoutNode whose `constrLst` declared this entry ("self"). */
+    declaringRole: string;
+}
+/** One-shot index over every `dgm:constr` in a layout definition. */
+export interface ConstraintIndex {
+    entries: Map<string, IndexedConstraint[]>;
+    rootRole: string;
+}
+/**
+ * The role a target (`for`/`forName`/`ptType`, or `refFor`/`refForName`/
+ * `refPtType`) resolves to.
+ *
+ * `forName` names a `dgm:layoutNode` directly and wins when present. Absent
+ * that, `ptType` (`node`/`sibTrans`/`asst`/...) is the DiagramML-level
+ * targeting dimension real built-ins actually use for a `for="ch"` constraint
+ * with no `forName` - e.g. "Basic Process"'s real layoutDef declares BOTH
+ * `<dgm:constr type="w" for="ch" ptType="node" .../>` (the item box) AND
+ * `<dgm:constr type="w" for="ch" ptType="sibTrans" .../>` (the connector) on
+ * the SAME declaring node with NO `forName` on either. Before `ptType` was
+ * part of the role key, both collapsed onto `declaringRole` and clobbered
+ * each other in the index (whichever was inserted first silently won every
+ * lookup for BOTH the item's own w/h and the connector's), which is why
+ * `itemAspect` (`smartart-layout-interpreter-linear.ts`) could never resolve
+ * a per-item aspect for these layouts even though the constraint order was
+ * unambiguous in the XML. Used as the role key verbatim (not scoped under
+ * `declaringRole`) because every built-in item template's own `dgm:layoutNode
+ * name=` conventionally equals its `ptType` string ("node"), which is also
+ * what `roleOf(itemNode(arranger))` reads at the call site - so this need not
+ * invent a synthetic key the rest of the interpreter would never look up.
+ */
+/** Exposed for `smartart-constraint-resolve.ts` (reference-role targeting
+ * uses the SAME logic as forward targeting). */
+export declare function targetRole(target: {
+    for?: string | undefined;
+    forName?: string | undefined;
+    pointType?: string | undefined;
+}, declaringRole: string): string;
+/** Exposed for `smartart-constraint-declared-by.ts` (see {@link IndexedConstraint}). */
+export declare function entryKey(role: string, type: string): string;
+/** True when a constraint carries any `ref*` attribute (a relative constraint). */
+export declare function hasReference(constraint: DiagramConstraint): boolean;
+/** The role name a layoutNode's own constraints/references resolve under. */
+export declare function roleOf(node: DiagramLayoutNode | undefined): string;
+/**
+ * An index over no constraints at all. Every arranger that consults a
+ * `ConstraintIndex` accepts this as its default, so adding the parameter
+ * never breaks an existing caller that arranges without one (it just gets
+ * exactly the pre-existing scalar-only behaviour: every lookup degrades).
+ */
+export declare const EMPTY_CONSTRAINT_INDEX: ConstraintIndex;
+/**
+ * Build a resolvable index of every `dgm:constr` in the whole layout tree.
+ *
+ * `nodeCount`/`context` (round 39) enable choose-AWARE selection for a node
+ * whose `constrLst` is genuinely branched (`node.constraintCandidates`, see
+ * `smartart-constraint-branch-index.ts`'s `selectConstraints`): when the
+ * live branch decides, only ITS constraints are indexed for that node,
+ * instead of blindly unioning every branch. Omit both (every pre-existing
+ * caller) to keep the old blind-union behaviour exactly as before - a
+ * caller with no diagram to evaluate against cannot decide a branch anyway.
+ */
+export declare function buildConstraintIndex(definition: DiagramLayoutDefinition, nodeCount?: number, context?: WhenContext): ConstraintIndex;
+export { resolveConstraint, resolveEntry } from './smartart-constraint-resolve.js';
+//# sourceMappingURL=smartart-constraint-solver.d.ts.map

package/dist/diagram/layout/smartart-constraint-solver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-constraint-solver.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-constraint-solver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE9F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAKtE;;sEAEsE;AACtE,MAAM,WAAW,iBAAiB;IACjC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,6EAA6E;IAC7E,aAAa,EAAE,MAAM,CAAC;CACtB;AAED,qEAAqE;AACrE,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;IAC1C,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;gDACgD;AAChD,wBAAgB,UAAU,CACzB,MAAM,EAAE;IACP,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B,EACD,aAAa,EAAE,MAAM,GACnB,MAAM,CAQR;AAED,wFAAwF;AACxF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,UAAU,EAAE,iBAAiB,GAAG,OAAO,CAOnE;AAED,6EAA6E;AAC7E,wBAAgB,MAAM,CAAC,IAAI,EAAE,iBAAiB,GAAG,SAAS,GAAG,MAAM,CAElE;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,eAAsD,CAAC;AAE5F;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CACnC,UAAU,EAAE,uBAAuB,EACnC,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,WAAW,GACnB,eAAe,CA8BjB;AAMD,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/diagram/layout/smartart-constraint-values.d.ts

@@ -0,0 +1,5 @@
+export declare const SMART_ART_CONSTRAINT_TYPES: Set<string>;
+export declare const SMART_ART_RELATIONSHIPS: Set<string>;
+export declare const SMART_ART_POINT_TYPES: Set<string>;
+export declare const SMART_ART_CONSTRAINT_OPERATORS: Set<string>;
+//# sourceMappingURL=smartart-constraint-values.d.ts.map

package/dist/diagram/layout/smartart-constraint-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-constraint-values.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-constraint-values.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B,aAyCrC,CAAC;AAEH,eAAO,MAAM,uBAAuB,aAAiC,CAAC;AACtE,eAAO,MAAM,qBAAqB,aAWhC,CAAC;AACH,eAAO,MAAM,8BAA8B,aAAyC,CAAC"}

package/dist/diagram/layout/smartart-font-table.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Font advance-table lookup shared by the layout engine and the interpreters.
+ * Moved from `pptx/core/utils/smartart-layout-item-font-size.ts`, which
+ * re-exports it.
+ */
+import type { FontAdvanceTable } from '../../text/font-metrics/font-advance-widths.generated';
+/**
+ * Resolve the {@link FontAdvanceTable} for `fontName`, defaulting to Calibri
+ * (the Office theme's default minor font, and what SmartArt renders in
+ * absent an explicit per-node font override) and falling back to the
+ * cross-font average for a font this table has not measured.
+ */
+export declare function resolveFontTable(fontName: string | undefined): FontAdvanceTable;
+//# sourceMappingURL=smartart-font-table.d.ts.map

package/dist/diagram/layout/smartart-font-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-font-table.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-font-table.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uDAAuD,CAAC;AAE9F;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAE/E"}