ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/render/deck-save-options.d.ts

@@ -0,0 +1,64 @@
+/**
+ * buildDeckSaveOptions: the ONE assembler for the `PptxHandlerSaveOptions`
+ * object every binding's main "download / getContent" path passes to
+ * `handler.save(...)` / `saveDeckWithPassword(...)`.
+ *
+ * Before this module existed, React's `useSerialize`, Vue's `useLoadContent`,
+ * Angular's `LoadContentService`, Svelte's `saveEditorDocument`, and Vanilla's
+ * `editor-operations` each hand-assembled this object independently. They
+ * agreed field-for-field by convention, not by construction, which is exactly
+ * the kind of drift Rule 2 in CLAUDE.md exists to prevent: a future save
+ * option added to one binding and forgotten in the other four would silently
+ * ship. Routing every binding's main save path through this single function
+ * makes that drift structurally impossible.
+ *
+ * `DeckSaveState` is the plain-value snapshot every binding already holds
+ * (React/Angular in component state/signals, Vue/Svelte/Vanilla in refs or a
+ * reactive store) at the moment it serialises. Slide-size RESOLUTION
+ * (`resolveSlideSizeSelection`) stays a binding-side concern, since it needs
+ * the live canvas size alongside the EMU value; callers pass the already
+ * resolved `slideSize` here.
+ *
+ * @module render/deck-save-options
+ */
+import type { PptxAppProperties, PptxCoreProperties, PptxCustomProperty, PptxCustomShow, PptxHandlerSaveOptions, PptxHandoutMaster, PptxHeaderFooter, PptxNotesMaster, PptxPresentationProperties, PptxSaveFormat, PptxSection, PptxSlideMaster, PptxSlideSize, PptxTagCollection, PptxViewProperties } from 'ooxml-core/pptx';
+import type { TableStyleSaveOptionsState } from './table-style-map-edits.js';
+/** The plain-value snapshot a binding's main serialize path assembles from. */
+export interface DeckSaveState {
+    headerFooter: PptxHeaderFooter | undefined;
+    presentationProperties: PptxPresentationProperties;
+    /** `ppt/viewProps.xml` (grid/snap/guides toggles, grid spacing). */
+    viewProperties?: PptxViewProperties | undefined;
+    customShows: readonly PptxCustomShow[];
+    sections: readonly PptxSection[];
+    coreProperties: PptxCoreProperties | undefined;
+    appProperties: PptxAppProperties | undefined;
+    customProperties: readonly PptxCustomProperty[];
+    tagCollections: readonly PptxTagCollection[];
+    slideMasters: readonly PptxSlideMaster[] | undefined;
+    notesMaster: PptxNotesMaster | undefined;
+    handoutMaster: PptxHandoutMaster | undefined;
+    /** Already-resolved `p:sldSz`; omit to preserve the load-time dimensions. */
+    slideSize?: PptxSlideSize | undefined;
+    /** Target output format. Omit to keep core's own default (`'pptx'`). */
+    outputFormat?: PptxSaveFormat | undefined;
+    /**
+     * RC4 CryptoAPI password for a `'ppt'`-format save. Ignored for every
+     * other {@link outputFormat}. See `PptxHandlerSaveOptions.pptPassword`.
+     */
+    pptPassword?: string | undefined;
+    /** File > Fonts > "Embed fonts in the file". Defaults to `true`. */
+    embedFonts?: boolean | undefined;
+    tableStyleMap: TableStyleSaveOptionsState['tableStyleMap'];
+    tableStylesDefaultId: TableStyleSaveOptionsState['tableStylesDefaultId'];
+    tableStylesToDelete: TableStyleSaveOptionsState['tableStylesToDelete'];
+}
+/**
+ * Assemble the full `PptxHandlerSaveOptions` for a binding's main save path.
+ * Array-valued fields are omitted (not passed as an empty array) when empty,
+ * matching every binding's pre-existing convention and the option docs on
+ * `PptxHandlerSaveOptions` itself (an omitted field round-trips the original
+ * part verbatim; an empty array would instead clear it).
+ */
+export declare function buildDeckSaveOptions(state: DeckSaveState): PptxHandlerSaveOptions;
+//# sourceMappingURL=deck-save-options.d.ts.map

package/dist/pptx/render/deck-save-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deck-save-options.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/deck-save-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EACX,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,gBAAgB,EAChB,eAAe,EACf,0BAA0B,EAC1B,cAAc,EACd,WAAW,EACX,eAAe,EACf,aAAa,EACb,iBAAiB,EACjB,kBAAkB,EAClB,MAAM,iBAAiB,CAAC;AAIzB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAE1E,+EAA+E;AAC/E,MAAM,WAAW,aAAa;IAC7B,YAAY,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC3C,sBAAsB,EAAE,0BAA0B,CAAC;IACnD,oEAAoE;IACpE,cAAc,CAAC,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAChD,WAAW,EAAE,SAAS,cAAc,EAAE,CAAC;IACvC,QAAQ,EAAE,SAAS,WAAW,EAAE,CAAC;IACjC,cAAc,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAC/C,aAAa,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC7C,gBAAgB,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAChD,cAAc,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC7C,YAAY,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,CAAC;IACrD,WAAW,EAAE,eAAe,GAAG,SAAS,CAAC;IACzC,aAAa,EAAE,iBAAiB,GAAG,SAAS,CAAC;IAC7C,6EAA6E;IAC7E,SAAS,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IACtC,wEAAwE;IACxE,YAAY,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IAC1C;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,oEAAoE;IACpE,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACjC,aAAa,EAAE,0BAA0B,CAAC,eAAe,CAAC,CAAC;IAC3D,oBAAoB,EAAE,0BAA0B,CAAC,sBAAsB,CAAC,CAAC;IACzE,mBAAmB,EAAE,0BAA0B,CAAC,qBAAqB,CAAC,CAAC;CACvE;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,sBAAsB,CAwBjF"}

package/dist/pptx/render/diagram-build.d.ts

@@ -0,0 +1,107 @@
+/**
+ * `diagram-build`: staged SmartArt reveal (`p:bldDgm` / `a:bldDgm`) projection.
+ *
+ * Maps the playback-time diagram {@link DiagramBuildMode} + progress to the
+ * number of leading nodes a staged SmartArt renderer should reveal. The renderer
+ * slices its node list (and, for the precomputed-drawing path, its shape list)
+ * to that prefix, so later nodes stay hidden until the build advances.
+ *
+ *  - `byOne` / `byLvl`  reveal one node at a time (count = node count).
+ *  - `byLvlAtOnce`      reveal a whole level per stage (count = level count);
+ *                       the returned node count spans the revealed levels.
+ *  - `asOne`            reveal everything at once.
+ *
+ * `byOne` and `byLvl` share the same one-node-per-stage cadence here: the OOXML
+ * distinction is traversal ordering, which the node list already encodes in
+ * document order, so a leading-prefix reveal honours both.
+ *
+ * `applyDiagramRevealDescriptor` is the authored-index counterpart, consumed
+ * instead of the count-based path whenever a `DiagramRevealDescriptor` (see
+ * `diagram-reveal-descriptor`) is available; `resolveRevealedSmartArtNodes` is
+ * the single entry point every binding's SmartArt renderer should call, since
+ * it picks between the two exactly as `chart-build`'s
+ * `resolveRevealedChartData` does for charts.
+ *
+ * `p:bldDgm/@bld="one"` is itself ambiguous between PowerPoint's "One by One"
+ * and "By branch, one by one" Effect Options: both are legal authoring choices
+ * that write the same generic `one` token, and the diagram's OWN default hint
+ * - `dgm:presLayoutVars/dgm:animOne` / `dgm:animLvl` (parsed into
+ * `PptxSmartArtPresLayoutVars.animateOne` / `.animationLevel`) - is what
+ * disambiguates which one PowerPoint actually plays. `resolveDiagramBuildMode`
+ * (`animation-build.ts`) cannot make that call: it only sees the animation
+ * token, never the diagram's own layout data. So {@link revealedSmartArtNodeCount}
+ * takes the presLayoutVars hint as a THIRD, optional argument and refines the
+ * generic `byOne`/`byLvl` mode before falling through to the plain per-node
+ * cadence:
+ *  - `animateOne === 'branch'`         group the reveal by top-level branch
+ *                                      (one whole root-to-leaf branch per
+ *                                      stage) instead of node-by-node.
+ *  - `animateOne === 'one' | 'chOne'`  the diagram is authored to build as a
+ *                                      single object ("As One Object"/"All at
+ *                                      once" in the Effect Options), so every
+ *                                      node reveals together, same as `asOne`.
+ *  - `animationLevel === 'lvl'`        reveal a whole level per stage, same as
+ *                                      `byLvlAtOnce`.
+ * A more specific EXPLICIT token (`lvlOne`/`lvlAtOnce`, i.e. `build.mode` is
+ * already `byLvl`/`byLvlAtOnce`) is the author's own unambiguous choice and is
+ * never second-guessed by the diagram's default hint.
+ *
+ * @module render/diagram-build
+ */
+import type { PptxSmartArtNode, PptxSmartArtPresLayoutVars } from 'ooxml-core/pptx';
+import type { DiagramBuildMode, DiagramRevealDescriptor, ElementAnimationState } from './animation-timeline-types.js';
+/** The diagram variant of a playback-time build state. */
+export interface DiagramBuildState {
+    mode: DiagramBuildMode;
+    /** 0..1 fraction of the build revealed at the current playback time. */
+    progress: number;
+}
+/**
+ * Number of leading nodes to reveal for a diagram build at `progress`.
+ *
+ * Returns `nodes.length` for `asOne` or a fully-revealed build, `0` at progress
+ * `0`. For `byLvlAtOnce` the count spans every node whose level falls within the
+ * revealed leading levels (assuming the node list is level-ordered, as SmartArt
+ * document order is).
+ *
+ * @param presLayoutVars - Optional diagram default-build hint
+ *   (`dgm:presLayoutVars.animOne`/`.animLvl`) that refines an ambiguous
+ *   `byOne`/`byLvl` mode; see the module doc comment. Ignored for the already
+ *   fully-explicit `asOne`/`byLvlAtOnce` modes.
+ */
+export declare function revealedSmartArtNodeCount(nodes: readonly PptxSmartArtNode[], build: DiagramBuildState, presLayoutVars?: PptxSmartArtPresLayoutVars): number;
+/**
+ * Project a node list down to the AUTHORED reveal set named by a
+ * {@link DiagramRevealDescriptor} (see `diagram-reveal-descriptor`), rather
+ * than a click-count estimate. Correct for a reversed-order, by-branch, or
+ * directional-traversal build, where {@link revealedSmartArtNodeCount}'s
+ * leading-prefix assumption is not. Preserves the input node list's own
+ * (document) order.
+ */
+export declare function applyDiagramRevealDescriptor(nodes: readonly PptxSmartArtNode[], descriptor: DiagramRevealDescriptor): PptxSmartArtNode[];
+/** Result of resolving how many/which SmartArt nodes are revealed right now. */
+export interface DiagramRevealResult {
+    /**
+     * Revealed nodes, in the input list's own (document) order. A mutable array
+     * (like `Array.prototype.slice`/`.filter` produce) so a caller can pass it
+     * straight into `computeSmartArtElementLayout` / `flattenNodes` without a
+     * copy of its own.
+     */
+    nodes: PptxSmartArtNode[];
+    /**
+     * Count of revealed nodes relative to the full list, for a renderer that
+     * also needs to proportionally trim a parallel PRECOMPUTED structure with
+     * no per-node id of its own (e.g. cached `dsp:` drawing shapes).
+     */
+    shownCount: number;
+}
+/**
+ * Resolve the SmartArt nodes revealed at the current playback state,
+ * preferring the authored-index {@link DiagramRevealDescriptor}
+ * (`state.diagramReveal`) over the count-based `state.build` when both are
+ * available, and revealing every node when neither applies. Every binding's
+ * SmartArt element renderer calls this in place of calling
+ * `revealedSmartArtNodeCount` + slicing directly.
+ */
+export declare function resolveRevealedSmartArtNodes(nodes: readonly PptxSmartArtNode[], state: Pick<ElementAnimationState, 'build' | 'diagramReveal'> | undefined, presLayoutVars?: PptxSmartArtPresLayoutVars): DiagramRevealResult;
+//# sourceMappingURL=diagram-build.d.ts.map

package/dist/pptx/render/diagram-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram-build.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/diagram-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAGpF,OAAO,KAAK,EACX,gBAAgB,EAChB,uBAAuB,EACvB,qBAAqB,EACrB,MAAM,4BAA4B,CAAC;AAEpC,0DAA0D;AAC1D,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,gBAAgB,CAAC;IACvB,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;CACjB;AAiFD;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,SAAS,gBAAgB,EAAE,EAClC,KAAK,EAAE,iBAAiB,EACxB,cAAc,CAAC,EAAE,0BAA0B,GACzC,MAAM,CAyBR;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC3C,KAAK,EAAE,SAAS,gBAAgB,EAAE,EAClC,UAAU,EAAE,uBAAuB,GACjC,gBAAgB,EAAE,CAEpB;AAED,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IACnC;;;;;OAKG;IACH,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC3C,KAAK,EAAE,SAAS,gBAAgB,EAAE,EAClC,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,OAAO,GAAG,eAAe,CAAC,GAAG,SAAS,EACzE,cAAc,CAAC,EAAE,0BAA0B,GACzC,mBAAmB,CAUrB"}

package/dist/pptx/render/diagram-drawing-shape-reveal.d.ts

@@ -0,0 +1,51 @@
+/**
+ * `diagram-drawing-shape-reveal`: staged reveal projection for the
+ * PRE-COMPUTED `dsp:` drawing shapes a SmartArt element caches
+ * (`smartArtData.drawingShapes`), as opposed to `diagram-build.ts`'s
+ * `resolveRevealedSmartArtNodes`, which projects the NODE tree consumed by
+ * the shared layout-engine fallback path.
+ *
+ * Every binding's SmartArt renderer prefers the cached drawing when present
+ * (it is PowerPoint's own layout output), so a staged `p:bldDgm` build must
+ * reveal it too. Two reveal strategies, exactly mirroring `diagram-build.ts`:
+ *
+ *  - **Authored-index** (`resolveRevealedDrawingShapes` given a
+ *    `DiagramRevealDescriptor`): each shape is mapped back to its source node
+ *    id via `resolveDrawingShapeNodeId` and kept only when that node id is in
+ *    the revealed set; a shape that cannot be mapped to any node (background /
+ *    connector decoration) is always kept, since it carries no node identity
+ *    of its own to gate on. This is exact, but only as exact as
+ *    `resolveDrawingShapeNodeId`'s best-effort mapping is.
+ *  - **Count-based fallback** (no descriptor, only `state.build`): the shape
+ *    list has no per-node identity to filter by, so it is trimmed to a
+ *    proportional PREFIX (`shownNodeCount / totalNodes` of the shape count),
+ *    same as every binding computed inline before this module existed.
+ *
+ * @module render/diagram-drawing-shape-reveal
+ */
+import type { PptxSmartArtDrawingShape, PptxSmartArtNode } from 'ooxml-core/pptx';
+import type { ElementAnimationState } from './animation-timeline-types.js';
+/**
+ * Resolve the cached drawing shapes revealed at the current playback state,
+ * preferring the authored-index {@link DiagramRevealDescriptor}
+ * (`state.diagramReveal`) over the count-based `state.build` when both are
+ * available, and revealing every shape when neither applies. Every binding's
+ * SmartArt element renderer calls this in place of hand-rolling the
+ * proportional-count slice.
+ */
+export declare function resolveRevealedDrawingShapes(shapes: readonly PptxSmartArtDrawingShape[], nodes: readonly PptxSmartArtNode[], state: Pick<ElementAnimationState, 'build' | 'diagramReveal'> | undefined): PptxSmartArtDrawingShape[];
+/**
+ * Node id for each REVEALED drawing shape, index-aligned with `revealed`.
+ *
+ * The ids are resolved over the FULL cached shape list, never over the
+ * revealed subset: `resolveDrawingShapeNodeId` maps by position whenever the
+ * shape count equals the node count, and a partially revealed subset breaks
+ * that alignment (with one node shown, the first rendered shape is whichever
+ * node the authored reveal named, not the first node). Resolving over the
+ * full list, then picking ids by shape identity (the reveal filters the same
+ * objects, see {@link resolveRevealedDrawingShapes}), keeps the tag correct
+ * for every reveal state. Every binding stamps its `data-smartart-node-id`
+ * (and looks up its a11y label) through this.
+ */
+export declare function resolveRevealedDrawingShapeNodeIds(allShapes: readonly PptxSmartArtDrawingShape[], revealed: readonly PptxSmartArtDrawingShape[], nodes: readonly PptxSmartArtNode[]): (string | undefined)[];
+//# sourceMappingURL=diagram-drawing-shape-reveal.d.ts.map

package/dist/pptx/render/diagram-drawing-shape-reveal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram-drawing-shape-reveal.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/diagram-drawing-shape-reveal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAElF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAiBxE;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC3C,MAAM,EAAE,SAAS,wBAAwB,EAAE,EAC3C,KAAK,EAAE,SAAS,gBAAgB,EAAE,EAClC,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,OAAO,GAAG,eAAe,CAAC,GAAG,SAAS,GACvE,wBAAwB,EAAE,CAyB5B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,kCAAkC,CACjD,SAAS,EAAE,SAAS,wBAAwB,EAAE,EAC9C,QAAQ,EAAE,SAAS,wBAAwB,EAAE,EAC7C,KAAK,EAAE,SAAS,gBAAgB,EAAE,GAChC,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAaxB"}

package/dist/pptx/render/diagram-reveal-descriptor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `diagram-reveal-descriptor`: authored-index staged SmartArt diagram reveal.
+ *
+ * `diagram-build.ts`'s `revealedSmartArtNodeCount` infers how many nodes are
+ * revealed purely from elapsed-time PROGRESS (a click-count proxy): stage N is
+ * shown once progress crosses N/total, in NODE-LIST order. That matches
+ * PowerPoint whenever the per-node `p:par` effects a `p:bldDgm` build authors
+ * fire in the same order the node list is walked, but ECMA-376 does not
+ * require that: `p:spTgt/p:graphicEl/p:dgm` (CT_TLBuildDiagram, S19.5.10)
+ * names the EXACT `@id` (the diagram data-model point id, matching
+ * `PptxSmartArtNode.id`) each effect reveals, and PowerPoint's own Effect
+ * Options exposes "Reverse Order" plus non-document-order traversals
+ * (`cw`/`ccw`/`inByRing`/...), which author effects out of node-list order.
+ *
+ * This module derives a reveal descriptor directly from which authored
+ * `p:graphicEl`-carrying steps have actually FIRED so far (in any order),
+ * rather than from a time-progress fraction. `diagram-build.ts`'s
+ * `resolveRevealedSmartArtNodes` consumes it in place of the count-based path
+ * whenever every fired step for a diagram carries `@id` (or `bldStep="bg"`)
+ * data; a deck that mixes indexed and un-indexed steps (or predates this
+ * parsing, or uses `asOne`) falls back to the legacy progress-based reveal,
+ * since {@link resolveDiagramRevealDescriptor} returns `undefined` for that
+ * case.
+ *
+ * @module render/diagram-reveal-descriptor
+ */
+import type { AnimationTimeline, DiagramBuildMode, DiagramRevealDescriptor, TimelineStep } from './animation-timeline-types.js';
+/**
+ * Resolve a {@link DiagramRevealDescriptor} from the diagram-build steps that
+ * have fired so far for one element, in any order.
+ *
+ * @param firedSteps - Every step belonging to the diagram's `p:graphicEl`
+ *   build that has ACTUALLY fired (survived `@restart` gating) up to the
+ *   current playback position. Order does not affect the result: a
+ *   reversed-order or by-branch build reveals the same set regardless of when
+ *   each stage fired.
+ * @returns `undefined` when any fired step lacks `graphicElement` data (an
+ *   older/hand-authored deck, or a build with no per-effect node ids),
+ *   signalling the caller to fall back to the count-based
+ *   `revealedSmartArtNodeCount`.
+ */
+export declare function resolveDiagramRevealDescriptor(firedSteps: readonly TimelineStep[]): DiagramRevealDescriptor | undefined;
+/**
+ * Collect each diagram element's static build MODE by scanning every step
+ * across the whole timeline (main sequence, interactive sequences, and hover
+ * sequences), keyed by element id.
+ *
+ * The mode is an authored constant, not playback state, so `TimelineEngine`
+ * calls this once at construction rather than per tick.
+ */
+export declare function collectDiagramBuildInfo(timeline: AnimationTimeline): ReadonlyMap<string, {
+    mode: DiagramBuildMode;
+}>;
+//# sourceMappingURL=diagram-reveal-descriptor.d.ts.map

package/dist/pptx/render/diagram-reveal-descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagram-reveal-descriptor.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/diagram-reveal-descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EACX,iBAAiB,EACjB,gBAAgB,EAChB,uBAAuB,EACvB,YAAY,EACZ,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,8BAA8B,CAC7C,UAAU,EAAE,SAAS,YAAY,EAAE,GACjC,uBAAuB,GAAG,SAAS,CAsBrC;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACtC,QAAQ,EAAE,iBAAiB,GACzB,WAAW,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,CAAC,CAuBjD"}

package/dist/pptx/render/document-statistics.d.ts

@@ -0,0 +1,18 @@
+import type { PptxCoreProperties, PptxSlide } from 'ooxml-core/pptx';
+/** Live document statistics derived from the editable slide model. */
+export interface DocumentStatistics {
+    slideCount: number;
+    hiddenSlideCount: number;
+    noteCount: number;
+    elementCount: number;
+    wordCount: number;
+    paragraphCount: number;
+    created: string | undefined;
+    modified: string | undefined;
+    revision: string | undefined;
+    lastModifiedBy: string | undefined;
+}
+export declare function countWords(text: string | undefined): number;
+/** Compute current counts rather than trusting potentially stale app.xml totals. */
+export declare function computeDocumentStatistics(slides: readonly PptxSlide[], coreProperties: PptxCoreProperties | undefined): DocumentStatistics;
+//# sourceMappingURL=document-statistics.d.ts.map

package/dist/pptx/render/document-statistics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-statistics.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/document-statistics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAe,SAAS,EAAe,MAAM,iBAAiB,CAAC;AAE/F,sEAAsE;AACtE,MAAM,WAAW,kBAAkB;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAG3D;AAyCD,oFAAoF;AACpF,wBAAgB,yBAAyB,CACxC,MAAM,EAAE,SAAS,SAAS,EAAE,EAC5B,cAAc,EAAE,kBAAkB,GAAG,SAAS,GAC5C,kBAAkB,CAyBpB"}

package/dist/pptx/render/dompurify-safe.d.ts

@@ -0,0 +1,5 @@
+/** Sanitise `markup`; outside a DOM, returns the raw input unchanged. */
+export declare function sanitizeMarkupOrRaw(markup: string, config: Record<string, unknown>): string;
+/** Sanitise `markup`; outside a DOM, returns `''` (fail closed). */
+export declare function sanitizeMarkupOrEmpty(markup: string, config: Record<string, unknown>): string;
+//# sourceMappingURL=dompurify-safe.d.ts.map

package/dist/pptx/render/dompurify-safe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dompurify-safe.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/dompurify-safe.ts"],"names":[],"mappings":"AA2BA,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAG3F;AAED,oEAAoE;AACpE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAG7F"}

package/dist/pptx/render/drawing-color.d.ts

@@ -0,0 +1,16 @@
+/**
+ * OOXML drawing-colour resolution: colour-choice parsing (srgb/scrgb/sys/scheme/
+ * hsl/preset), the 26 colour transforms, scheme inheritance, and alpha
+ * resolution. Pure TypeScript shared by the React, Vue, and Angular bindings.
+ */
+import { XmlObject } from 'ooxml-core/pptx';
+export declare const DEFAULT_SCHEME_COLOR_MAP: Record<string, string>;
+/**
+ * Apply all 26 OOXML drawing colour transforms to a base colour.
+ * Delegates to the comprehensive implementation in the editor core.
+ */
+export declare function applyDrawingColorTransforms(baseColor: string, colorNode: XmlObject): string;
+export declare function parseDrawingColorChoice(colorNode: XmlObject | undefined, schemeColorOverrides?: Record<string, string | undefined>): string | undefined;
+export declare function parseDrawingColor(colorNode: XmlObject | undefined, schemeColorOverrides?: Record<string, string | undefined>): string | undefined;
+export declare function parseDrawingColorOpacity(colorNode: XmlObject | undefined): number | undefined;
+//# sourceMappingURL=drawing-color.d.ts.map

package/dist/pptx/render/drawing-color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drawing-color.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/drawing-color.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EACN,SAAS,EAIT,MAAM,iBAAiB,CAAC;AAKzB,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkB3D,CAAC;AAEF;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,CAE3F;AAED,wBAAgB,uBAAuB,CACtC,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GACvD,MAAM,GAAG,SAAS,CAoFpB;AAED,wBAAgB,iBAAiB,CAChC,SAAS,EAAE,SAAS,GAAG,SAAS,EAChC,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GACvD,MAAM,GAAG,SAAS,CAYpB;AAED,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAkC7F"}

package/dist/pptx/render/edit-points/edit-points-availability.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Whether Edit Points may be offered for an element: the one gate every
+ * entry point (context menu, ribbon, keyboard) asks, so the `noEditPoints`
+ * lock and the element-type rule cannot drift between bindings.
+ *
+ * @module render/edit-points/edit-points-availability
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+/** How Edit Points should be offered for an element. */
+export type EditPointsAvailability = 'available' | 'locked' | 'unsupported';
+/**
+ * `available`: offer it; `locked`: offer it greyed out (the shape carries
+ * `a:spLocks/@noEditPoints`, as PowerPoint greys the entry); `unsupported`:
+ * do not offer it at all (not a shape, or no outline to edit).
+ */
+export declare function resolveEditPointsAvailability(element: PptxElement | null | undefined): EditPointsAvailability;
+/** Shorthand: may the user start Edit Points on `element` right now? */
+export declare function canEditElementPoints(element: PptxElement | null | undefined): boolean;
+//# sourceMappingURL=edit-points-availability.d.ts.map

package/dist/pptx/render/edit-points/edit-points-availability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-availability.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-availability.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAKnD,wDAAwD;AACxD,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG,QAAQ,GAAG,aAAa,CAAC;AAE5E;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC5C,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACrC,sBAAsB,CAKxB;AAED,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAErF"}

package/dist/pptx/render/edit-points/edit-points-bezier.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Cubic Bezier helpers for the Edit Points model: evaluation, splitting,
+ * tight bounds, nearest-point projection, and the conversions that fold
+ * quadratics and elliptical arcs into cubics.
+ *
+ * @module render/edit-points/edit-points-bezier
+ */
+import type { EditPoint } from './edit-points-types.js';
+/** A cubic from `p0` to `p3` with controls `p1`, `p2`. */
+export interface CubicBezier {
+    p0: EditPoint;
+    p1: EditPoint;
+    p2: EditPoint;
+    p3: EditPoint;
+}
+/** The point at parameter `t` (0..1). */
+export declare function cubicPointAt(c: CubicBezier, t: number): EditPoint;
+/** Split at `t` (de Casteljau); both halves together trace the original. */
+export declare function splitCubic(c: CubicBezier, t: number): [CubicBezier, CubicBezier];
+/** Tight bounds of a cubic (not the looser hull of its control points). */
+export declare function cubicBounds(c: CubicBezier): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+/**
+ * The parameter of the point on the cubic nearest `target`: a coarse sample
+ * followed by a few rounds of local refinement, plenty for picking where a
+ * user grabbed a segment.
+ */
+export declare function nearestCubicParam(c: CubicBezier, target: EditPoint): number;
+/** Parameter of the point on segment `a`..`b` nearest `target`. */
+export declare function nearestLineParam(a: EditPoint, b: EditPoint, target: EditPoint): number;
+/** A quadratic `p0 -> q -> p2` as the identical cubic's two control points. */
+export declare function quadToCubicControls(p0: EditPoint, q: EditPoint, p2: EditPoint): {
+    c1: EditPoint;
+    c2: EditPoint;
+};
+/**
+ * An axis-aligned elliptical arc as a run of cubics (one per <= 90 degrees),
+ * parameterised the way the geometry engine draws `a:arcTo`: the point at
+ * angle `a` is `(cx + rx cos a, cy + ry sin a)`.
+ */
+export declare function ellipseArcToCubics(cx: number, cy: number, rx: number, ry: number, startRad: number, sweepRad: number): Array<{
+    c1: EditPoint;
+    c2: EditPoint;
+    end: EditPoint;
+}>;
+/**
+ * An SVG `A` command (from the current point) as cubics, via the standard
+ * endpoint-to-centre conversion (SVG 1.1 appendix F.6). Rotated ellipses are
+ * supported for completeness even though the preset engine never emits one.
+ */
+export declare function svgArcToCubics(from: EditPoint, rxIn: number, ryIn: number, xAxisRotationDeg: number, largeArc: boolean, sweep: boolean, to: EditPoint): Array<{
+    c1: EditPoint;
+    c2: EditPoint;
+    end: EditPoint;
+}>;
+//# sourceMappingURL=edit-points-bezier.d.ts.map

package/dist/pptx/render/edit-points/edit-points-bezier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-bezier.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-bezier.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAErD,0DAA0D;AAC1D,MAAM,WAAW,WAAW;IAC3B,EAAE,EAAE,SAAS,CAAC;IACd,EAAE,EAAE,SAAS,CAAC;IACd,EAAE,EAAE,SAAS,CAAC;IACd,EAAE,EAAE,SAAS,CAAC;CACd;AAMD,yCAAyC;AACzC,wBAAgB,YAAY,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAUjE;AAED,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,WAAW,EAAE,WAAW,CAAC,CAWhF;AAuBD,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACb,CAmBA;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CA8B3E;AAED,mEAAmE;AACnE,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAQtF;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAClC,EAAE,EAAE,SAAS,EACb,CAAC,EAAE,SAAS,EACZ,EAAE,EAAE,SAAS,GACX;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,SAAS,CAAA;CAAE,CAKlC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACd,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,CAAC,CAuBzD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC7B,IAAI,EAAE,SAAS,EACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,OAAO,EACd,EAAE,EAAE,SAAS,GACX,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,SAAS,CAAC;IAAC,GAAG,EAAE,SAAS,CAAA;CAAE,CAAC,CAyDzD"}

package/dist/pptx/render/edit-points/edit-points-commands.d.ts

@@ -0,0 +1,13 @@
+import type { EditPointsCommandId, EditPointsTarget } from './edit-points-menu.js';
+import type { EditGeometry, EditNodeRef } from './edit-points-types.js';
+/** The outcome of a command: the new geometry and the vertex to select. */
+export interface EditPointsCommandResult {
+    geometry: EditGeometry;
+    selected?: EditNodeRef | null;
+}
+/**
+ * Run `id` against `target` (`t` is where on a segment the command applies,
+ * for Add Point). `undefined` when the command does not apply.
+ */
+export declare function runEditPointsCommand(geometry: EditGeometry, id: EditPointsCommandId, target: EditPointsTarget, t?: number): EditPointsCommandResult | undefined;
+//# sourceMappingURL=edit-points-commands.d.ts.map

package/dist/pptx/render/edit-points/edit-points-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-commands.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAiBhF,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAErE,2EAA2E;AAC3E,MAAM,WAAW,uBAAuB;IACvC,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;CAC9B;AAMD;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,YAAY,EACtB,EAAE,EAAE,mBAAmB,EACvB,MAAM,EAAE,gBAAgB,EACxB,CAAC,SAAM,GACL,uBAAuB,GAAG,SAAS,CAuDrC"}

package/dist/pptx/render/edit-points/edit-points-dom.d.ts

@@ -0,0 +1,42 @@
+/** The Edit Points target id on (or above) the element an event hit. */
+export declare function readEditPointsTarget(eventTarget: EventTarget | null): string | null;
+/**
+ * A viewport (client) position as slide pixels, given the overlay element
+ * that spans exactly the slide (its on-screen rect already includes zoom).
+ */
+export declare function clientToSlidePoint(overlay: Element, clientX: number, clientY: number, slideWidth: number, slideHeight: number): {
+    x: number;
+    y: number;
+};
+/** The pointer fields a session reads, from a DOM mouse / pointer event. */
+export interface OverlayPointerEventLike {
+    clientX: number;
+    clientY: number;
+    button: number;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    target: EventTarget | null;
+}
+/** Build the session input for `event` over `overlay`. */
+export declare function overlayPointerInput(event: OverlayPointerEventLike, overlay: Element, slideWidth: number, slideHeight: number): {
+    x: number;
+    y: number;
+    clientX: number;
+    clientY: number;
+    button: number;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    target: string | null;
+};
+/** Anything with a `keyDown(key)` that says whether it consumed the key. */
+export interface OverlayKeyHandler {
+    keyDown(key: string): boolean;
+}
+/**
+ * Route key presses to `handler` in the CAPTURE phase on `target` (the window
+ * by default), stopping every key it consumes before the editor's shortcut
+ * handler sees it. Keys typed into a text field are left alone. Returns the
+ * detach function.
+ */
+export declare function attachOverlayKeyboard(handler: OverlayKeyHandler, target?: Pick<Window, 'addEventListener' | 'removeEventListener'>): () => void;
+//# sourceMappingURL=edit-points-dom.d.ts.map

package/dist/pptx/render/edit-points/edit-points-dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-dom.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-dom.ts"],"names":[],"mappings":"AAaA,wEAAwE;AACxE,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAQnF;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACjB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAK1B;AAED,4EAA4E;AAC5E,MAAM,WAAW,uBAAuB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CAC3B;AAED,0DAA0D;AAC1D,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,uBAAuB,EAC9B,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GACjB;IACF,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB,CAYA;AAED,4EAA4E;AAC5E,MAAM,WAAW,iBAAiB;IACjC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,iBAAiB,EAC1B,MAAM,GAAE,IAAI,CAAC,MAAM,EAAE,kBAAkB,GAAG,qBAAqB,CAAU,GACvE,MAAM,IAAI,CAeZ"}

package/dist/pptx/render/edit-points/edit-points-drag-ops.d.ts

@@ -0,0 +1,19 @@
+import type { EditGeometry, EditHandleRef, EditNodeRef, EditPoint, EditSegmentRef } from './edit-points-types.js';
+/**
+ * Move a vertex to `to`. Its two handles travel with it, so the curves either
+ * side keep their shape near the vertex (PowerPoint behaves the same).
+ */
+export declare function moveEditNode(geometry: EditGeometry, ref: EditNodeRef, to: EditPoint): EditGeometry;
+/**
+ * Move one Bezier handle to `to`. A smooth or straight vertex swings its other
+ * handle to stay collinear (see `constrainOppositeHandle`).
+ */
+export declare function moveEditHandle(geometry: EditGeometry, ref: EditHandleRef, to: EditPoint): EditGeometry;
+/**
+ * Bend a segment so the point originally at parameter `t` follows the pointer
+ * to `to`. A straight segment becomes a curve first (PowerPoint converts it the
+ * same way). Both controls move, weighted towards the nearer end, by exactly
+ * the amount that puts `B(t)` on the pointer.
+ */
+export declare function bendEditSegment(geometry: EditGeometry, ref: EditSegmentRef, t: number, to: EditPoint): EditGeometry;
+//# sourceMappingURL=edit-points-drag-ops.d.ts.map

package/dist/pptx/render/edit-points/edit-points-drag-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-drag-ops.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-drag-ops.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACX,YAAY,EACZ,aAAa,EACb,WAAW,EACX,SAAS,EACT,cAAc,EACd,MAAM,qBAAqB,CAAC;AAE7B;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,WAAW,EAChB,EAAE,EAAE,SAAS,GACX,YAAY,CAwBd;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC7B,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,aAAa,EAClB,EAAE,EAAE,SAAS,GACX,YAAY,CAkBd;AAKD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,QAAQ,EAAE,YAAY,EACtB,GAAG,EAAE,cAAc,EACnB,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,SAAS,GACX,YAAY,CAwBd"}

package/dist/pptx/render/edit-points/edit-points-export.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Editable points back to an element: the patch that turns a shape into (or
+ * keeps it as) an `a:custGeom` freeform.
+ *
+ * The patch re-anchors the box to the outline's tight bounds (as PowerPoint
+ * does after every Edit Points gesture), keeps the outline where it is on the
+ * slide even when the shape is rotated or flipped, and writes the geometry in
+ * both forms every consumer reads: the structured `customGeometryPaths` the
+ * save pipeline serialises, and the aggregate SVG `pathData` the renderers
+ * paint. Path coordinates are EMU (9525 per pixel), the space PowerPoint
+ * itself authors freeforms in, so the saved `a:path/@w`/`@h` equal the
+ * shape's `a:ext`.
+ *
+ * Everything that described the OLD geometry is cleared: preset adjustments,
+ * raw guide / handle / connection-site XML and the text rectangle. Left in
+ * place, the save pipeline would re-derive the outline from that stale raw
+ * XML instead of the edited points.
+ *
+ * @module render/edit-points/edit-points-export
+ */
+import type { CustomGeometryPath, ShapePptxElement } from 'ooxml-core/pptx';
+import type { EditFrame, EditGeometry } from './edit-points-types.js';
+/** Path coordinate units per local pixel (EMU per CSS pixel). */
+export declare const EDIT_POINTS_PATH_SCALE = 9525;
+/** The element fields an Edit Points commit writes. */
+export type EditPointsElementPatch = Pick<ShapePptxElement, 'x' | 'y' | 'width' | 'height' | 'shapeType' | 'shapeAdjustments' | 'pathData' | 'pathWidth' | 'pathHeight' | 'customGeometryPaths' | 'customGeometryRawData' | 'customGeometryAdjustHandlesXY' | 'customGeometryAdjustHandlesPolar' | 'customGeometryConnectionSites' | 'customGeometryTextRect'>;
+/** Tight local bounds of every sub-path (curves by their true extent). */
+export declare function editGeometryBounds(geometry: EditGeometry): {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+} | undefined;
+/**
+ * Serialise `geometry` as structured paths plus SVG, offset by `(ox, oy)` and
+ * scaled by `scale`.
+ */
+export declare function editGeometryToPaths(geometry: EditGeometry, ox: number, oy: number, width: number, height: number, scale?: number): {
+    paths: CustomGeometryPath[];
+    svg: string;
+};
+/**
+ * The element patch for `geometry` edited in `frame`, or `undefined` when the
+ * geometry is empty (nothing left to draw).
+ */
+export declare function editGeometryToElementPatch(geometry: EditGeometry, frame: EditFrame): EditPointsElementPatch | undefined;
+//# sourceMappingURL=edit-points-export.d.ts.map

package/dist/pptx/render/edit-points/edit-points-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-points-export.d.ts","sourceRoot":"","sources":["../../../../src/pptx/render/edit-points/edit-points-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAyB,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAInG,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAa,MAAM,qBAAqB,CAAC;AAE9E,iEAAiE;AACjE,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAK3C,uDAAuD;AACvD,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACxC,gBAAgB,EACd,GAAG,GACH,GAAG,GACH,OAAO,GACP,QAAQ,GACR,WAAW,GACX,kBAAkB,GAClB,UAAU,GACV,WAAW,GACX,YAAY,GACZ,qBAAqB,GACrB,uBAAuB,GACvB,+BAA+B,GAC/B,kCAAkC,GAClC,+BAA+B,GAC/B,wBAAwB,CAC1B,CAAC;AAEF,0EAA0E;AAC1E,wBAAgB,kBAAkB,CACjC,QAAQ,EAAE,YAAY,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA+BxE;AAMD;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,YAAY,EACtB,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,SAAyB,GAC5B;IAAE,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CA6C9C;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACzC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,SAAS,GACd,sBAAsB,GAAG,SAAS,CAkDpC"}