ooxml-core 1.1.0 → 1.2.0

package/dist/diagram/layout/smartart-text-wrap-fit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-text-wrap-fit.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-text-wrap-fit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uDAAuD,CAAC;AAM9F;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,4BAA4B,MAAM,CAAC;AA4BhD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAgBhG;AAkDD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,gBAAgB,GACrB,MAAM,CAER;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,gBAAgB,GACrB,MAAM,CAER;AAqBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,gBAA6C,EACpD,iBAAiB,GAAE,MAAqC,GACtD,MAAM,CAqBR"}

package/dist/diagram/layout/smartart-tree.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The SmartArt node forest the hierarchy arrangers walk: nodes linked into
+ * trees either from `parentId` pointers (the flat point list a reader
+ * produces) or from already-nested `children` arrays, and the width and
+ * depth measures the tree placers size rows with.
+ *
+ * Extracted from `pptx/core/utils/smartart-helpers.ts`; the pptx module
+ * re-exports these next to its slide-element factories.
+ */
+import type { DiagramNode } from '../model/index.js';
+/** One node of the forest and its child subtrees. */
+export interface TreeNode<S = unknown> {
+    node: DiagramNode<S>;
+    children: TreeNode<S>[];
+}
+/** Link a flat node list into trees through `parentId` (orphans become roots). */
+export declare function buildForest<S>(nodes: DiagramNode<S>[]): TreeNode<S>[];
+/**
+ * Build a forest from a node array, accepting either input shape:
+ * - A flat list with `parentId` pointers (the format the parser emits for
+ *   flat `<dgm:pt>` elements) - handled by delegating to {@link buildForest}.
+ * - An already-nested list where every root node carries a `children` array.
+ *
+ * The DiagramML interpreter's hierarchy arranger receives either shape
+ * depending on the caller, so it needs both branches; `buildForest` alone
+ * only handles the flat case.
+ */
+export declare function buildTree<S>(nodes: DiagramNode<S>[]): TreeNode<S>[];
+/** Leaf count of `t` (a leaf counts as one). */
+export declare function treeWidth<S>(t: TreeNode<S>, depth?: number): number;
+/** Generation count of `t` (a leaf counts as one). */
+export declare function treeDepth<S>(t: TreeNode<S>, depth?: number): number;
+//# sourceMappingURL=smartart-tree.d.ts.map

package/dist/diagram/layout/smartart-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartart-tree.d.ts","sourceRoot":"","sources":["../../../diagram/layout/smartart-tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,qDAAqD;AACrD,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACpC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACrB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;CACxB;AAED,kFAAkF;AAClF,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,CAerE;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,CAYnE;AAWD,gDAAgD;AAChD,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,SAAI,GAAG,MAAM,CAY9D;AAED,sDAAsD;AACtD,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,KAAK,SAAI,GAAG,MAAM,CAe9D"}

package/dist/diagram/model/constraint-rules.d.ts

@@ -0,0 +1,31 @@
+export type DiagramConstraintRelationship = 'self' | 'ch' | 'des';
+export type DiagramConstraintOperator = 'none' | 'equ' | 'gte' | 'lte';
+export type DiagramConstraintPointType = 'all' | 'doc' | 'node' | 'norm' | 'nonNorm' | 'asst' | 'nonAsst' | 'parTrans' | 'pres' | 'sibTrans';
+export interface DiagramConstraintTarget {
+    for?: DiagramConstraintRelationship | undefined;
+    forName?: string | undefined;
+    pointType?: DiagramConstraintPointType | undefined;
+}
+/** Editable DiagramML CT_Constraint. */
+export interface DiagramConstraint<R = unknown> extends DiagramConstraintTarget {
+    type: string;
+    referenceType?: string | undefined;
+    referenceFor?: DiagramConstraintRelationship | undefined;
+    referenceForName?: string | undefined;
+    referencePointType?: DiagramConstraintPointType | undefined;
+    operator?: DiagramConstraintOperator | undefined;
+    value?: number | undefined;
+    factor?: number | undefined;
+    /** Original constraint retained for foreign attributes and extension content. */
+    rawXml?: R | undefined;
+}
+/** Editable DiagramML CT_NumericRule. */
+export interface DiagramNumericRule<R = unknown> extends DiagramConstraintTarget {
+    type: string;
+    value?: number | undefined;
+    factor?: number | undefined;
+    max?: number | undefined;
+    /** Original rule retained for foreign attributes and extension content. */
+    rawXml?: R | undefined;
+}
+//# sourceMappingURL=constraint-rules.d.ts.map

package/dist/diagram/model/constraint-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-rules.d.ts","sourceRoot":"","sources":["../../../diagram/model/constraint-rules.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,6BAA6B,GAAG,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC;AAClE,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;AACvE,MAAM,MAAM,0BAA0B,GACnC,KAAK,GACL,KAAK,GACL,MAAM,GACN,MAAM,GACN,SAAS,GACT,MAAM,GACN,SAAS,GACT,UAAU,GACV,MAAM,GACN,UAAU,CAAC;AAEd,MAAM,WAAW,uBAAuB;IACvC,GAAG,CAAC,EAAE,6BAA6B,GAAG,SAAS,CAAC;IAChD,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,SAAS,CAAC,EAAE,0BAA0B,GAAG,SAAS,CAAC;CACnD;AAED,wCAAwC;AACxC,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,uBAAuB;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,YAAY,CAAC,EAAE,6BAA6B,GAAG,SAAS,CAAC;IACzD,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,kBAAkB,CAAC,EAAE,0BAA0B,GAAG,SAAS,CAAC;IAC5D,QAAQ,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;IACjD,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,iFAAiF;IACjF,MAAM,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACvB;AAED,yCAAyC;AACzC,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,uBAAuB;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;CACvB"}

package/dist/diagram/model/data.d.ts

@@ -0,0 +1,109 @@
+/**
+ * The parsed SmartArt model the layout engine reads: data-model nodes and
+ * connections, layout variables, the typed layout definition, colour transform
+ * and quick style. Package concerns (relationship ids, cached drawing shapes,
+ * background chrome, save hints) are added by the format area that loads it
+ * (pptx: `PptxSmartArtData extends DiagramData`). Moved from
+ * `pptx/core/types/smart-art.ts`.
+ */
+import type { DiagramColorScheme, DiagramConnection, DiagramLayoutType, DiagramStyleIntensity } from '../types.js';
+import type { DiagramLayoutDefinition } from './layout-definition.js';
+import type { DiagramNode } from './node.js';
+import type { DiagramColorTransform, DiagramQuickStyle } from './style-definition.js';
+/**
+ * Named SmartArt layout presets for creation (subset of the built-in layouts).
+ *
+ * @example
+ * ```ts
+ * const layout: DiagramLayoutPreset = "hierarchy";
+ * // => "hierarchy" - one of: "basicBlockList" | "alternatingHexagons" | "hierarchy" | ...
+ * ```
+ */
+export type DiagramLayoutPreset = 'basicBlockList' | 'alternatingHexagons' | 'basicChevronProcess' | 'basicCycle' | 'basicPie' | 'basicRadial' | 'basicVenn' | 'continuousBlockProcess' | 'convergingRadial' | 'hierarchy' | 'horizontalBulletList' | 'linearVenn' | 'segmentedProcess' | 'stackedList' | 'tableList' | 'trapezoidList' | 'upwardArrow' | 'basicFunnel' | 'basicTarget' | 'interlockingGears' | 'basicTimeline' | 'basicMatrix' | 'basicPyramid' | 'invertedPyramid' | 'bendingProcess' | 'stepDownProcess' | 'alternatingFlow' | 'descendingProcess' | 'pictureAccentList' | 'verticalBlockList' | 'groupedList' | 'pyramidList' | 'horizontalPictureList' | 'accentProcess' | 'verticalChevronList';
+/**
+ * Presentation layout variables from `dgm:prSet/dgm:presLayoutVars` (data model)
+ * or `dgm:varLst` (layout definition defaults).
+ *
+ * These drive how the DiagramML layout interpreter arranges points: flow
+ * direction, hierarchy branch style, org-chart mode, and child count limits.
+ * The fallback layout engine can consult them for direction/org-chart hints.
+ *
+ * @example
+ * ```ts
+ * const vars: DiagramPresLayoutVars = { direction: "rev", orgChart: true };
+ * // => satisfies DiagramPresLayoutVars
+ * ```
+ */
+export interface DiagramPresLayoutVars {
+    /** Flow direction (`dgm:dir`): "norm" (default) or "rev" (reversed/RTL). */
+    direction?: 'norm' | 'rev';
+    /** Hierarchy branch style (`dgm:hierBranch`): std/init/l/r/hang. */
+    hierarchyBranch?: 'std' | 'init' | 'l' | 'r' | 'hang';
+    /** Org-chart mode enabled (`dgm:orgChart`). */
+    orgChart?: boolean;
+    /** Maximum children per node (`dgm:chMax`, -1 = unbounded). */
+    childMax?: number;
+    /** Preferred children per node (`dgm:chPref`, -1 = unbounded). */
+    childPreferred?: number;
+    /** Whether bullets are enabled (`dgm:bulletEnabled`). */
+    bulletEnabled?: boolean;
+    /** Animation-by-level setting (`dgm:animLvl`). */
+    animationLevel?: string;
+    /** Animate-one setting (`dgm:animOne`). */
+    animateOne?: string;
+    /** Allowed resize handles (`dgm:resizeHandles`). */
+    resizeHandles?: string;
+}
+/**
+ * The format-neutral part of a parsed SmartArt graphic: everything the layout
+ * engine and interpreters read.
+ *
+ * @example
+ * ```ts
+ * const data: DiagramData = {
+ *   resolvedLayoutType: "hierarchy",
+ *   layout: "hierarchy",
+ *   colorScheme: "colorful1",
+ *   style: "moderate",
+ *   nodes: [
+ *     { id: "1", text: "CEO", children: [
+ *       { id: "2", text: "VP Marketing", parentId: "1" },
+ *     ]},
+ *   ],
+ * };
+ * // => satisfies DiagramData
+ * ```
+ */
+export interface DiagramData {
+    layoutType?: string;
+    resolvedLayoutType?: DiagramLayoutType;
+    /** Named layout preset (used when creating new SmartArt). */
+    layout?: DiagramLayoutPreset;
+    /** Colour scheme for the SmartArt graphic. */
+    colorScheme?: DiagramColorScheme;
+    /** Visual style intensity. */
+    style?: DiagramStyleIntensity;
+    nodes: DiagramNode[];
+    /** Connections between data-model nodes. */
+    connections?: DiagramConnection[];
+    /** Colour transform from the diagram colours part. */
+    colorTransform?: DiagramColorTransform;
+    /** Quick style from the diagram quick-style part. */
+    quickStyle?: DiagramQuickStyle;
+    /** Editable metadata from the related DiagramML layout definition. */
+    layoutDefinition?: DiagramLayoutDefinition;
+    /**
+     * Presentation layout variables (direction, hierarchy branch, org-chart,
+     * child limits, bullets) from `dgm:presLayoutVars` / layout `dgm:varLst`.
+     * Consulted by the fallback layout engine for direction/org-chart hints.
+     */
+    presLayoutVars?: DiagramPresLayoutVars;
+    /**
+     * The document theme's minor-Latin font (`a:fontScheme/a:minorFont/a:latin/
+     * @typeface`): what SmartArt text actually renders in when no per-run
+     * `a:latin` override is present (the common case; the font-fit is the one
+     * consumer). Undefined when the theme carries no font scheme at all.
+     */
+    themeMinorFont?: string;
+}
+//# sourceMappingURL=data.d.ts.map

package/dist/diagram/model/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../diagram/model/data.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,qBAAqB,EACrB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAEnF;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,GAC5B,gBAAgB,GAChB,qBAAqB,GACrB,qBAAqB,GACrB,YAAY,GACZ,UAAU,GACV,aAAa,GACb,WAAW,GACX,wBAAwB,GACxB,kBAAkB,GAClB,WAAW,GACX,sBAAsB,GACtB,YAAY,GACZ,kBAAkB,GAClB,aAAa,GACb,WAAW,GACX,eAAe,GACf,aAAa,GACb,aAAa,GACb,aAAa,GACb,mBAAmB,GACnB,eAAe,GACf,aAAa,GACb,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,iBAAiB,GACjB,iBAAiB,GACjB,mBAAmB,GACnB,mBAAmB,GACnB,mBAAmB,GACnB,aAAa,GACb,aAAa,GACb,uBAAuB,GACvB,eAAe,GACf,qBAAqB,CAAC;AAEzB;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,qBAAqB;IACrC,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAC3B,oEAAoE;IACpE,eAAe,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,MAAM,CAAC;IACtD,+CAA+C;IAC/C,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,kDAAkD;IAClD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2CAA2C;IAC3C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,aAAa,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,WAAW;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kBAAkB,CAAC,EAAE,iBAAiB,CAAC;IACvC,6DAA6D;IAC7D,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,8CAA8C;IAC9C,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,8BAA8B;IAC9B,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,4CAA4C;IAC5C,WAAW,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAClC,sDAAsD;IACtD,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC,qDAAqD;IACrD,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,uBAAuB,CAAC;IAC3C;;;;OAIG;IACH,cAAc,CAAC,EAAE,qBAAqB,CAAC;IACvC;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACxB"}

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

@@ -0,0 +1,7 @@
+export type * from './constraint-rules.js';
+export type * from './layout-primitives.js';
+export type * from './layout-definition.js';
+export type * from './style-definition.js';
+export type * from './node.js';
+export type * from './data.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../diagram/model/index.ts"],"names":[],"mappings":"AAGA,mBAAmB,oBAAoB,CAAC;AACxC,mBAAmB,qBAAqB,CAAC;AACzC,mBAAmB,qBAAqB,CAAC;AACzC,mBAAmB,oBAAoB,CAAC;AACxC,mBAAmB,QAAQ,CAAC;AAC5B,mBAAmB,QAAQ,CAAC"}

package/dist/diagram/model/layout-definition.d.ts

@@ -0,0 +1,276 @@
+/** Typed, editable metadata from a DiagramML layout-definition part. */
+import type { DiagramConstraint, DiagramNumericRule } from './constraint-rules.js';
+import type { DiagramChoose, DiagramForEach, DiagramIteratorAttributes, DiagramLayoutAlgorithm, DiagramLayoutCategory, DiagramLayoutNodeShape, DiagramLocalizedText, DiagramWhen } from './layout-primitives.js';
+/** Identity and ordering metadata from DiagramML CT_LayoutNode. */
+export interface DiagramLayoutNode<R = unknown> {
+    name?: string | undefined;
+    styleLabel?: string | undefined;
+    childOrder?: 'b' | 't' | undefined;
+    moveWith?: string | undefined;
+    algorithm?: DiagramLayoutAlgorithm | undefined;
+    forEach?: DiagramForEach<R>[] | undefined;
+    choose?: DiagramChoose<R>[] | undefined;
+    constraints?: DiagramConstraint<R>[] | undefined;
+    rules?: DiagramNumericRule<R>[] | undefined;
+    /** `dgm:shape`: this node's own preset geometry override, when present. */
+    shape?: DiagramLayoutNodeShape | undefined;
+    /**
+     * `dgm:presOf` (CT_PresentationOf, same iterator shape as `dgm:forEach`):
+     * which data-model point(s) this node's OWN text/geometry binds to -
+     * `axis: ['self']` the point currently being iterated, `['des']` all of
+     * its descendants, `['ch']` its direct children, and so on. Absent or
+     * empty `axis` (including a bare `<dgm:presOf/>`) means the node carries
+     * no text of its own (a pure positioning/decoration wrapper - `composite`,
+     * `sp` spacer, connector cap). See `smartart-layout-interpreter-item-
+     * roles.ts`, the one consumer: it is what lets the interpreter tell a
+     * text-bearing per-item role (a list layout's `childText`, a card
+     * layout's `roleText`/`bodyText`) apart from a same-generation sibling
+     * that positions or decorates instead.
+     */
+    presentationOf?: DiagramIteratorAttributes | undefined;
+    /**
+     * EVERY `dgm:constr` reachable from this node, including ones declared
+     * inside a `dgm:choose`/`dgm:if`/`dgm:else` that wraps THIS layoutNode's
+     * `constrLst` (a genuinely conditional constraint set, e.g. one branch
+     * per data-point count - `gear`'s composite positions its `gear1`/
+     * `gear2`/`gear3` slots this way, so its plain, direct-child-only
+     * `constraints` above is empty for it). Stops at a nested `dgm:layoutNode`
+     * boundary: that child's own conditional constrLst becomes ITS
+     * `allConstraints`, not folded into the parent's. Read-only /
+     * interpretation-only - `constraints` above (this node's own DIRECT
+     * constrLst) remains the one `applySmartArtLayoutDefinition` round-trips,
+     * so editing an unrelated property can never collapse a genuinely
+     * conditional constrLst into a single branch. `undefined` when this node
+     * declares no constrLst at all, in or out of a choose (the common case);
+     * otherwise a superset of `constraints` (every branch, blindly unioned -
+     * this interpreter does not evaluate `dgm:choose` conditions when
+     * indexing constraints, matching the same "flatten both branches"
+     * convention `nestedLayoutNodes` already uses for `children`). See
+     * `smartart-constraint-solver.ts`'s `buildConstraintIndex`, the only
+     * consumer.
+     */
+    allConstraints?: DiagramConstraint<R>[] | undefined;
+    children?: DiagramLayoutNode<R>[] | undefined;
+    /**
+     * The iterator attributes of the ENCLOSING `dgm:forEach` this node was
+     * found through, when `nestedLayoutNodes` (`smartart-layout-definition
+     * .ts`) reached it by walking one - as opposed to being a direct child of
+     * its parent layoutNode, or reached only through a `dgm:choose` wrapper
+     * (a condition, not an iteration, leaves this `undefined`).
+     *
+     * `forEach` above records a node's OWN direct `dgm:forEach` children
+     * (which wrap ITS descendants); this is the opposite direction - the
+     * forEach that wraps the node ITSELF, one level up. A layoutNode can sit
+     * inside more than one enclosing forEach only via nesting, so this is
+     * always the SINGLE nearest one, not a list.
+     *
+     * This is what tells a genuinely repeated per-child template
+     * (`axis="ch"`, `ptType` absent or `"node"`) apart from a once-only or
+     * transition-only sibling that merely happens to sit inside SOME
+     * `dgm:forEach` (a `ptType="parTrans"`/`"sibTrans"` connector, or
+     * `axis="followSib" cnt="1"`) - both can be direct siblings under the
+     * SAME parent layoutNode (`lProcess1`'s `vertFlow` has one forEach for
+     * its `parTrans` connector and a SEPARATE one, `axis="ch"`, for its
+     * repeated `child` items; `vertFlow.forEach` bundles both, but only
+     * `child.forEachOrigin` says which ONE produced it). See
+     * `smartart-layout-interpreter-item-roles-recursive.ts`, the one
+     * consumer. Read-only / interpretation-only, like `allConstraints`:
+     * never round-tripped by `applySmartArtLayoutDefinition`.
+     */
+    forEachOrigin?: DiagramIteratorAttributes | undefined;
+    /**
+     * The conditions of EVERY enclosing `dgm:if` this node was found through,
+     * outermost first, when `nestedLayoutNodes` (`smartart-layout-
+     * definition.ts`) reached it via one or more `dgm:choose`'s `if` branches
+     * (as opposed to a direct child, a `dgm:else` branch contributing no
+     * condition of its own - see below - or a `dgm:forEach`, which sets
+     * {@link forEachOrigin} instead). ALL must hold (evaluate `!== false`,
+     * per {@link chooseGuard}'s own AND semantics - see `evaluateWhen`) for
+     * this node's branch to be genuinely live. A caller that already has the
+     * data-model node list can use this instead of treating every
+     * choose-flattened branch as unconditionally present
+     * (`nestedLayoutNodes`' pre-existing "flatten every branch" convention,
+     * still the default when this is absent or a caller does not evaluate
+     * it) - e.g. `cycle-matrix--fallback-n2.pptx`'s `child1group`..
+     * `child4group`, each gated on a DIFFERENT top-level point existing and
+     * having its own child (`axis="ch ch" st="N 1" cnt="1 0" func="cnt"
+     * op="gte" val="1"`).
+     *
+     * A CHAIN, not a single condition, because a node can sit inside NESTED
+     * `dgm:choose`s whose OWN conditions are each individually necessary -
+     * `sub-step-process--hier5.pptx`'s `chLin1`..`chLin7` each sit inside
+     * BOTH an outer `dgm:if func="pos" op="equ" val="N"` (which one of the
+     * 7 hand-duplicated per-position templates this is) AND an inner,
+     * nearly-vacuous `dgm:if func="cnt" op="gte" val="1"` (has >= 1 point at
+     * all) - keeping only the NEAREST (inner) one, as an earlier single-
+     * condition design did, loses the ONE piece of information (the outer
+     * `pos` guard) that actually discriminates `chLin1` from `chLin2`.
+     *
+     * A `dgm:else` branch contributes NO condition of its own (ECMA-376
+     * defines it as "none of the sibling ifs matched", which would need the
+     * FULL sibling list's conditions negated and ANDed together, not a
+     * single condition - no gallery fixture measured needs an else branch's
+     * own guard yet, so it is left unconditional, matching the pre-existing
+     * flatten-everything behaviour) but does NOT clear any OUTER ancestor
+     * guard already accumulated before it. Evaluate with `smartart-layout-
+     * interpreter-when.ts`'s `evaluateWhen`, once per entry, ANDed.
+     */
+    chooseGuard?: DiagramWhen<R>[] | undefined;
+    /**
+     * ROUND 42: the forEach iterator active WHEN EACH ENTRY of {@link
+     * chooseGuard} was declared (index-parallel with it, `undefined` per
+     * entry when no forEach was active at that point) - NOT the same as
+     * {@link forEachOrigin}, which is always this NODE's own single nearest
+     * enclosing forEach, however deep. A `dgm:if` declared ABOVE a `dgm:forEach`
+     * that this node's own branch happens to descend through afterwards needs
+     * ITS OWN, SHALLOWER anchor for a `func="cnt"`/`"maxDepth"`-family
+     * `@axis` condition, not this node's deeper one - `funnel--flat3.pptx`'s
+     * `item1`/`item2`/`item3` (`chooseGuard: [Name5's axis="ch" func="cnt"
+     * op="gte" val="1"]`, declared directly under the composite root, BEFORE
+     * each item's own per-item `dgm:forEach axis="ch" st="2"/"3"/"4" cnt="1"`)
+     * is exactly this shape: evaluating Name5's condition anchored to item1's
+     * OWN forEach binding (one specific data point, with no children of its
+     * own in a flat dataset) wrongly resolves its `axis="ch"` child count to
+     * 0 instead of the diagram's real top-level count, dropping the item
+     * entirely - `chooseGuardOrigins[i]` for that entry is `undefined`
+     * (Name5 sits above ANY forEach), so the guard correctly stays
+     * root-relative. See `smartart-layout-interpreter-composite-
+     * candidates.ts`'s `guardAllows`, the one production consumer.
+     * `undefined` whenever {@link chooseGuard} itself is (no enclosing
+     * choose at all).
+     */
+    chooseGuardOrigins?: (DiagramIteratorAttributes | undefined)[] | undefined;
+    /**
+     * The chain of every enclosing `dgm:choose`'s own GROUP identity + this
+     * node's ordinal position within it + THAT branch's own condition,
+     * outermost first - identifies WHICH `dgm:choose` instance and WHERE
+     * within its own `dgm:if`/`dgm:else` list this node's branch sits, unlike
+     * {@link chooseGuard} (a flat AND-chain of every condition with no group/
+     * position identity, and no entry at all for a `dgm:else` branch, which
+     * has no condition of its own - see that field's doc comment). `id` is a
+     * synthetic, process-unique identifier assigned per `dgm:choose` instance
+     * during flattening (`smartart-layout-definition-nesting.ts`'s
+     * `nestedLayoutNodes`, a monotonic counter - NOT round-tripped, NOT the
+     * choose's own `@_name`, which is not guaranteed unique across a whole
+     * layoutDef); `ordinal` is 0-based document order within that ONE choose
+     * (every `dgm:if` in order, then `dgm:else` last, if present); `guard` is
+     * that branch's OWN condition (`undefined` for a `dgm:else` entry, which
+     * has none - deliberately kept PER-ENTRY rather than cross-referenced by
+     * index against {@link chooseGuard}, whose own length can diverge from
+     * this chain's whenever an ancestor `dgm:else` contributed a group
+     * position but no guard).
+     *
+     * Lets a consumer recover ECMA-376's real `dgm:choose` semantics - "the
+     * FIRST branch whose condition holds wins, siblings never coexist" -
+     * from the flattened `.children` array, where that grouping would
+     * otherwise be lost: `balance--hier5.pptx`'s `balance_NN`/`left_NN_M`/
+     * `right_NN_M` family (127 members across ~30 NESTED `dgm:choose`
+     * instances, not one flat 127-branch choose) needs first-match-wins
+     * WITHIN each individual choose to resolve to the single genuinely-live
+     * arrangement, not the "every guard-true node is an independent
+     * candidate" reading `smartart-layout-interpreter-composite-choose.ts`'s
+     * `collectRawCandidates` used before this field existed - see that
+     * module's own consumer of this field for the actual selection rule.
+     * `undefined` (or an empty array) for a node reached without any
+     * enclosing choose (a direct child, or a `dgm:forEach`-only path) -
+     * every PRE-EXISTING caller that does not consult this field is
+     * unaffected by its mere presence.
+     *
+     * ROUND 42: `origin` is the forEach iterator active when THIS branch's
+     * own `dgm:if`/`dgm:else` was declared (the SAME "declaration time, not
+     * whatever descendant ends up carrying it" concept {@link
+     * chooseGuardOrigins} exists for) - the anchor a `func="cnt"`/`"maxDepth"`
+     * -family condition in `guard` needs, NOT a representative member's own
+     * (possibly deeper) `forEachOrigin`. See `smartart-layout-interpreter-
+     * composite-choose-groups.ts`'s `winningOrdinalFor`, the one consumer.
+     */
+    chooseGroups?: {
+        id: string;
+        ordinal: number;
+        guard?: DiagramWhen<R> | undefined;
+        origin?: DiagramIteratorAttributes | undefined;
+    }[] | undefined;
+    /**
+     * Every `dgm:presOf` candidate reachable through a `dgm:choose`/`dgm:if`/
+     * `dgm:else` wrapping THIS node's OWN presOf (as opposed to
+     * {@link chooseGuard}, which gates the layoutNode's own EXISTENCE), each
+     * tagged with the FULL chain of enclosing `dgm:if` conditions that select
+     * it (`guard`, empty for an unconditional or `dgm:else`-reached
+     * candidate), in document order (every `dgm:if` then `dgm:else` last).
+     * `undefined` when this node's presOf is not choose-guarded at all (the
+     * overwhelmingly common case) - {@link presentationOf} already carries
+     * the one-and-only value then. Exists for a genuinely conditional presOf
+     * where TWO OR MORE branches each declare a real, DIFFERENT axis
+     * (`funnel--flat3.pptx`'s `item1`/`item2`/`item3`, one literal axis per
+     * data-point count): `smartart-layout-definition-constraints.ts`'s
+     * `choosePresentationOf` (feeding {@link presentationOf}) can only ever
+     * guess ONE branch statically, at parse time, with no diagram to
+     * evaluate against; this field lets an interpret-time caller with the
+     * actual diagram (`smartart-layout-interpreter-when.ts`'s
+     * `resolvePresentationOf`, the one consumer) pick the branch PowerPoint's
+     * own runtime would, first-match-wins.
+     */
+    presentationOfCandidates?: {
+        guard: DiagramWhen<R>[];
+        presentationOf: DiagramIteratorAttributes;
+    }[] | undefined;
+    /**
+     * SESSION 17: every `dgm:rule` reachable through a `dgm:choose`/`dgm:if`/
+     * `dgm:else` wrapping THIS node's `ruleLst` (a genuinely count-gated rule
+     * set, e.g. `diverging-radial`'s own `w for="ch" forName="node"` ceiling:
+     * 6 `dgm:if cnt<=N` branches, each its own `fact`), tagged with its guard
+     * chain - the SAME shape {@link presentationOfCandidates} uses for
+     * choose-guarded `presOf`, applied to `dgm:rule`. `undefined` when not
+     * choose-guarded (`rules` above then carries the one set, the common
+     * case). See `smartart-layout-interpreter-cycle-hub-ratio.ts`'s
+     * `resolveHubToNodeRatio` (COM-verified live mechanism, not a guess) for
+     * how the guard is evaluated against the real satellite count.
+     */
+    ruleCandidates?: {
+        guard: DiagramWhen<R>[];
+        rule: DiagramNumericRule<R>;
+    }[] | undefined;
+    /**
+     * ROUND 39: every `dgm:constr` reachable through a `dgm:choose`/`dgm:if`/
+     * `dgm:else` wrapping THIS node's `constrLst` (a genuinely count/position
+     * -branched constraint set, e.g. `basic-venn--flat3.pptx`'s composite
+     * `Name9` choose, one `ctrX`/`ctrY`/`w`/`h` per data-point-count branch
+     * for `circ1`/`circ1Tx`/...), each tagged with its guard chain - the SAME
+     * shape {@link presentationOfCandidates}/{@link ruleCandidates} use,
+     * applied to `dgm:constr`. `undefined` when not choose-guarded
+     * (`allConstraints`/`constraints` above then carry the one set, the
+     * common case). See `smartart-constraint-branch-index.ts`'s
+     * `selectConstraints` for how the guard is evaluated against the real
+     * diagram, and that module's own doc comment for why `allConstraints`'s
+     * pre-existing blind union of every branch is not enough on its own.
+     */
+    constraintCandidates?: {
+        guard: DiagramWhen<R>[];
+        constraint: DiagramConstraint<R>;
+    }[] | undefined;
+}
+/** Metadata and root node from DiagramML CT_DiagramDefinition. */
+export interface DiagramLayoutDefinition<R = unknown> {
+    uniqueId?: string | undefined;
+    minimumVersion?: string | undefined;
+    defaultStyle?: string | undefined;
+    titles?: DiagramLocalizedText[] | undefined;
+    descriptions?: DiagramLocalizedText[] | undefined;
+    categories?: DiagramLayoutCategory[] | undefined;
+    rootNode: DiagramLayoutNode<R>;
+    /** Original definition retained for constraint evaluation and foreign rules. */
+    rawXml?: R | undefined;
+    /**
+     * The un-parsed layout-definition part text (starting at `<dgm:layoutDef>`,
+     * XML declaration included). `rawXml` above loses the document order of
+     * differently-named siblings (the package-wide `fast-xml-parser`
+     * configuration groups children into one array per tag), which the
+     * per-point DiagramML engine (`core/utils/smartart-engine/`) needs to
+     * execute a `layoutNode` body's `forEach`/`choose`/`constrLst` statements
+     * in their real declared sequence - see that package's `ordered-xml.ts`.
+     * `undefined` when the part could not be read (matches `rawXml`'s own
+     * optionality); the engine falls back to the legacy interpreter then.
+     */
+    rawXmlText?: string | undefined;
+}
+//# sourceMappingURL=layout-definition.d.ts.map

package/dist/diagram/model/layout-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-definition.d.ts","sourceRoot":"","sources":["../../../diagram/model/layout-definition.ts"],"names":[],"mappings":"AAAA,wEAAwE;AAKxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,EACX,aAAa,EACb,cAAc,EACd,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,oBAAoB,EACpB,WAAW,EACX,MAAM,qBAAqB,CAAC;AAE7B,mEAAmE;AACnE,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO;IAC7C,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,UAAU,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,CAAC,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC/C,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC;IAC1C,MAAM,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC;IACxC,WAAW,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC;IACjD,KAAK,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC;IAC5C,2EAA2E;IAC3E,KAAK,CAAC,EAAE,sBAAsB,GAAG,SAAS,CAAC;IAC3C;;;;;;;;;;;;OAYG;IACH,cAAc,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;IACvD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,cAAc,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC;IACpD,QAAQ,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC;IAC9C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,aAAa,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;IACtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC;IAC3C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,kBAAkB,CAAC,EAAE,CAAC,yBAAyB,GAAG,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC;IAC3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,YAAY,CAAC,EACV;QACA,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;QACnC,MAAM,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;KAC9C,EAAE,GACH,SAAS,CAAC;IACb;;;;;;;;;;;;;;;;;;;OAmBG;IACH,wBAAwB,CAAC,EACtB;QACA,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;QACxB,cAAc,EAAE,yBAAyB,CAAC;KACzC,EAAE,GACH,SAAS,CAAC;IACb;;;;;;;;;;;OAWG;IACH,cAAc,CAAC,EACZ;QACA,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;QACxB,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;KAC3B,EAAE,GACH,SAAS,CAAC;IACb;;;;;;;;;;;;;OAaG;IACH,oBAAoB,CAAC,EAClB;QACA,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;QACxB,UAAU,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;KAChC,EAAE,GACH,SAAS,CAAC;CACb;AAED,kEAAkE;AAClE,MAAM,WAAW,uBAAuB,CAAC,CAAC,GAAG,OAAO;IACnD,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,MAAM,CAAC,EAAE,oBAAoB,EAAE,GAAG,SAAS,CAAC;IAC5C,YAAY,CAAC,EAAE,oBAAoB,EAAE,GAAG,SAAS,CAAC;IAClD,UAAU,CAAC,EAAE,qBAAqB,EAAE,GAAG,SAAS,CAAC;IACjD,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IAC/B,gFAAgF;IAChF,MAAM,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IACvB;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC"}

package/dist/diagram/model/layout-primitives.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Leaf DiagramML layout-definition types (localized text, categories,
+ * algorithm parameters, iterator/`dgm:forEach`/`dgm:when`/`dgm:choose`
+ * attributes, and `dgm:shape` metadata). `R` is the raw XML node a reader
+ * keeps for round-trip (pptx: its `XmlObject` tree). Moved from
+ * `pptx/core/types/smart-art-layout-primitives.ts`.
+ */
+export interface DiagramLocalizedText {
+    value: string;
+    language?: string;
+}
+export interface DiagramLayoutCategory {
+    type: string;
+    priority: number;
+}
+export interface DiagramAlgorithmParameter {
+    type: string;
+    value?: string | undefined;
+}
+/** Typed DiagramML CT_Algorithm data attached to a layout node. */
+export interface DiagramLayoutAlgorithm {
+    type: string;
+    revision?: number;
+    parameters?: DiagramAlgorithmParameter[];
+}
+export interface DiagramIteratorAttributes {
+    name?: string | undefined;
+    reference?: string | undefined;
+    axis?: string[] | undefined;
+    pointTypes?: string[] | undefined;
+    hideLastTransition?: boolean[] | undefined;
+    start?: number[] | undefined;
+    count?: number[] | undefined;
+    step?: number[] | undefined;
+}
+export interface DiagramForEach<R = unknown> extends DiagramIteratorAttributes {
+    rawXml?: R;
+}
+export interface DiagramWhen<R = unknown> extends DiagramIteratorAttributes {
+    function: string;
+    argument?: string | undefined;
+    operator: string;
+    value: string;
+    rawXml?: R;
+}
+export interface DiagramChoose<R = unknown> {
+    name?: string;
+    when: DiagramWhen<R>[];
+    otherwise?: {
+        name?: string;
+        rawXml?: R;
+    } | null;
+    rawXml?: R;
+}
+/** A single `dgm:adj/@val` adjustment, keyed by its `@idx` (1-based, like `a:gd`). */
+export interface DiagramShapeAdjustment {
+    index: number;
+    value: number;
+}
+/**
+ * Typed DiagramML CT_Shape data (`dgm:shape`) attached to a layout node: the
+ * per-node preset geometry override real (and third-party/custom) layout
+ * definitions use so a layoutNode can be e.g. an ellipse or a chevron instead
+ * of the arranger family's hardcoded default shape.
+ */
+export interface DiagramLayoutNodeShape {
+    /** `dgm:shape/@type`: a preset geometry name (`roundRect`, `ellipse`, `chevron`, `conn`, ...). */
+    presetGeometry?: string;
+    /** `dgm:adjLst/dgm:adj` entries (adjustment index -> value, as authored). */
+    adjustments?: DiagramShapeAdjustment[];
+    /** `dgm:shape/@hideGeom`: the shape is present only to size text, never painted. */
+    hideGeometry?: boolean;
+    /**
+     * `dgm:shape/@lkTxEntry` (CT_Shape, boolean, default false): this node is a
+     * decorative shape that should mirror its paired content node's text
+     * rather than always rendering blank. See `smartart-layout-interpreter-
+     * pyramid.ts`'s `arrangePyramid`, the interpreter's one existing
+     * synthesized-decorative-shape call site.
+     */
+    lkTxEntry?: boolean;
+}
+//# sourceMappingURL=layout-primitives.d.ts.map

package/dist/diagram/model/layout-primitives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layout-primitives.d.ts","sourceRoot":"","sources":["../../../diagram/model/layout-primitives.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,oBAAoB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,qBAAqB;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC3B;AAED,mEAAmE;AACnE,MAAM,WAAW,sBAAsB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,yBAAyB,EAAE,CAAC;CACzC;AAED,MAAM,WAAW,yBAAyB;IACzC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAClC,kBAAkB,CAAC,EAAE,OAAO,EAAE,GAAG,SAAS,CAAC;IAC3C,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,yBAAyB;IAC7E,MAAM,CAAC,EAAE,CAAC,CAAC;CACX;AAED,MAAM,WAAW,WAAW,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,yBAAyB;IAC1E,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,CAAC,CAAC;CACX;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;IACjD,MAAM,CAAC,EAAE,CAAC,CAAC;CACX;AAED,sFAAsF;AACtF,MAAM,WAAW,sBAAsB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACtC,kGAAkG;IAClG,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,6EAA6E;IAC7E,WAAW,CAAC,EAAE,sBAAsB,EAAE,CAAC;IACvC,oFAAoF;IACpF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACpB"}