ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/animation-ribbon-preview.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The Ribbon Animations tab's "Preview" command: a real in-place preview of
+ * the selected element's authored effect, played directly on the live canvas
+ * node.
+ *
+ * Only Svelte and Vanilla ever wired this up for real: React and Vue's
+ * Preview button just highlighted itself for a second and did nothing, and
+ * Angular's started the FULL slide show, leaving the editor entirely. Vanilla
+ * already shared one copy of this DOM player between its own ribbon and
+ * inspector-panel Preview buttons ("Shared by the ribbon's Preview command
+ * and the inspector panel's Preview button so the two surfaces can never
+ * drift apart" - the same reasoning now applies across bindings, not just
+ * within one). This module is that one implementation, lifted out so all five
+ * ribbons can call it instead of five (or fewer) independent re-implementations.
+ *
+ * The scope is deliberately the same as the two bindings that already worked:
+ * a one-shot preview of the SELECTED element's own effect (the button is
+ * disabled otherwise), not a full click-stepped playback of the slide's whole
+ * animation sequence - that is what presentation mode's
+ * `PresentationAnimationController` already does, and reusing this simpler
+ * player is what kept the fix bounded enough to land in all five bindings at
+ * once instead of none.
+ *
+ * @module render/animation-ribbon-preview
+ */
+import type { PptxElementAnimation } from 'ooxml-core/pptx';
+import type { AnimationPreviewDescriptor } from './animation-preview.js';
+/**
+ * Build the preview descriptor for one animation entry.
+ *
+ * The motion path wins over the preset buckets: a path is the effect being
+ * authored on the canvas at that moment, and playing a fade instead would
+ * hide the travel entirely (which is the only thing the author is looking
+ * at).
+ *
+ * @param target - The rendered node, used only to measure the slide stage:
+ * path coordinates are fractions of the SLIDE, not of the element box.
+ */
+export declare function buildAnimationRibbonPreview(animation: PptxElementAnimation, target: HTMLElement): AnimationPreviewDescriptor | undefined;
+/**
+ * Play a one-shot canvas preview of `animation`'s effect by injecting the
+ * shared keyframes and applying the CSS animation shorthand to the element's
+ * own rendered node (found by `data-element-id`). A no-op when the element is
+ * not mounted (e.g. it is on a different slide) or the animation has no
+ * effect to show.
+ */
+export declare function playAnimationRibbonPreview(doc: Document, animation: PptxElementAnimation | undefined): void;
+//# sourceMappingURL=animation-ribbon-preview.d.ts.map

package/dist/pptx/render/animation-ribbon-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-ribbon-preview.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-ribbon-preview.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE5D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAUtE;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAC1C,SAAS,EAAE,oBAAoB,EAC/B,MAAM,EAAE,WAAW,GACjB,0BAA0B,GAAG,SAAS,CAuBxC;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACzC,GAAG,EAAE,QAAQ,EACb,SAAS,EAAE,oBAAoB,GAAG,SAAS,GACzC,IAAI,CA+BN"}

package/dist/pptx/render/animation-sampled-mask-keyframes.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `animation-sampled-mask-keyframes` - `@keyframes` for reveals whose mask is
+ * a gradient that changes SHAPE as it plays (Blinds, Checkerboard, Random
+ * Bars, Wheel): the hard-stop position or the conic angle moves.
+ *
+ * Browsers do not interpolate gradient images, so a two-stop keyframe swaps
+ * from fully hidden to fully shown at the halfway point: PowerPoint's Blinds
+ * sweeps each band open over the whole effect (CreateVideo of a 2 s Blinds:
+ * 0.9 % of the shape shown at 0.1 s, 22 % at 0.5 s, 50 % at 1.0 s), while the
+ * two-stop keyframe showed nothing until 1.0 s and then everything. Sampling
+ * the reveal at many stops makes the swap happen in small steps instead.
+ *
+ * @module render/animation-sampled-mask-keyframes
+ */
+/** Stops across the effect: the mask steps every 2.5 % of the duration. */
+export declare const MASK_SAMPLE_STEPS = 40;
+/**
+ * A `@keyframes` block named `name` whose stop at fraction `f` carries
+ * `declAt(f)` (a kebab-case declaration list) with the shape fully opaque.
+ */
+export declare function sampledMaskKeyframes(name: string, declAt: (fraction: number) => string, steps?: number): string;
+//# sourceMappingURL=animation-sampled-mask-keyframes.d.ts.map

package/dist/pptx/render/animation-sampled-mask-keyframes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-sampled-mask-keyframes.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-sampled-mask-keyframes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,EACpC,KAAK,GAAE,MAA0B,GAC/B,MAAM,CAOR"}

package/dist/pptx/render/animation-sequence-gating.d.ts

@@ -0,0 +1,145 @@
+/**
+ * `animation-sequence-gating`: pure decision functions for the `p:seq`
+ * `@concurrent` / `@nextAc` / `@prevAc` attributes (ECMA-376 S19.5.60,
+ * captured onto every {@link TimelineClickGroup} in the sequence they
+ * govern) and the per-effect `p:cTn/@restart` attribute (ECMA-376 S19.5.27,
+ * `ST_TLTimeNodeRestartType`, captured onto each {@link TimelineStep}).
+ *
+ * `TimelineEngine` calls these to decide whether a "next" advance / "reset"
+ * request against an already-active click-group, or a re-trigger of an
+ * already-active step, should proceed, be swallowed, or be blocked - instead
+ * of always proceeding unconditionally, which was the previous behaviour
+ * (see the Animation authoring section of `docs/guide/limitations.md`).
+ *
+ * @module render/animation-sequence-gating
+ */
+import type { TimelineClickGroup, TimelineStep } from './animation-timeline-types.js';
+/**
+ * A "nothing to play" click-group: every binding's playback loop treats a
+ * truthy group returned from `advance`/`advanceInteractive`/`advanceHover` as
+ * "this click was consumed by an animation on the current slide" and a falsy
+ * one as "there was nothing left to animate here, fall through to slide
+ * navigation" (see e.g. React's `useSlideNavigation`:
+ * `if (direction === 1 && playNextAnimationGroup()) { return; }`).
+ *
+ * `TimelineEngine` returns THIS constant (rather than `null`) when
+ * `shouldBlockNextAdvance` swallows a request: the click must still count as
+ * "consumed" - the deck said not to advance yet - or the binding would
+ * misread the block as "no more steps" and skip to the next slide instead of
+ * waiting, which is the opposite of what `@nextAc="none"` asks for. `null` is
+ * reserved for genuine exhaustion (no groups at all, or already at the last
+ * one), which SHOULD fall through to slide navigation.
+ */
+export declare const EMPTY_CLICK_GROUP: TimelineClickGroup;
+/**
+ * True while a group started at `startedAtMs` is still inside its own
+ * duration window (`totalDurationMs`) at `nowMs`.
+ */
+export declare function isGroupActive(group: TimelineClickGroup | undefined, startedAtMs: number | undefined, nowMs: number): boolean;
+/**
+ * Whether a "next" advance request against the currently-active `group`
+ * should be swallowed (no new time node starts) rather than moving forward.
+ *
+ * `@concurrent="1"` lets this sequence's effects play alongside the
+ * surrounding timeline instead of strictly blocking it, so a concurrent
+ * group never blocks. Absent `@nextAc`, and the explicit `"seek"` token, are
+ * PowerPoint's "finish the current effect in place, then allow the next one"
+ * default; this engine already gets that for free (a newly-applied group's
+ * steps simply supersede the old ones, so there is nothing to seek), so only
+ * the explicit `"none"` token - "ignore next presses until this node
+ * finishes on its own" - introduces new blocking behaviour. Absent
+ * `@concurrent`/`@nextAc` therefore stays fully permissive, so a deck that
+ * never sets them (the common case for hand-authored or non-PowerPoint
+ * content) sees no change in behaviour.
+ */
+export declare function shouldBlockNextAdvance(group: TimelineClickGroup | undefined, startedAtMs: number | undefined, nowMs: number): boolean;
+/**
+ * Whether a "reset / back out" request against the currently-active `group`
+ * should be deferred until it finishes, rather than discarding it immediately.
+ *
+ * This engine has no granular "step backward through this slide's own
+ * click-groups" operation (going Previous is slide-level; see
+ * `PresentationAnimationController.completeAll`), so `@prevAc` is honoured at
+ * the one place a triggered sequence already has an equivalent "back out"
+ * action: `TimelineEngine.resetHover`, invoked when the pointer leaves a
+ * hover-triggered shape. Symmetric to {@link shouldBlockNextAdvance}: only
+ * the explicit `"none"` token (PowerPoint's own default, "no special
+ * previous handling") defers the reset; the explicit `"skipTimeNode"` token,
+ * and an absent attribute, both preserve this engine's original
+ * immediate-reset behaviour.
+ */
+export declare function shouldBlockReset(group: TimelineClickGroup | undefined, startedAtMs: number | undefined, nowMs: number): boolean;
+/** Per-step runtime state used to enforce `p:cTn/@restart` (ECMA-376 S19.5.27). */
+export interface StepRestartState {
+    /** Wall-clock time (ms) until which the step's most recent trigger is still playing. */
+    activeUntilMs: number;
+}
+/**
+ * Whether `step` may (re)trigger now, given its previous {@link StepRestartState}
+ * (`undefined` when the step has never triggered before).
+ *
+ * - `"always"` (or absent, the OOXML default): always allowed, matching this
+ *   engine's original behaviour.
+ * - `"whenNotActive"`: allowed again only once the previous trigger's active
+ *   window (its `delayMs + durationMs`) has elapsed.
+ * - `"never"`: allowed only the very first time; every subsequent trigger for
+ *   the same step is blocked outright, whether it is still active or not.
+ */
+export declare function canTriggerStep(restart: TimelineStep['restart'], state: StepRestartState | undefined, nowMs: number): boolean;
+/**
+ * The subset of `TimelineEngine`'s tracking collections one step application
+ * touches. Passed in (rather than owned here) so this stays a pure function
+ * over caller-owned state, with the engine itself still deciding lifecycle
+ * (construction, `reset()`).
+ */
+export interface StepApplicationState {
+    stepRestartState: WeakMap<TimelineStep, StepRestartState>;
+    activeAnimations: Map<string, string>;
+    activeSteps: Map<string, TimelineStep>;
+    revealedElements: Set<string>;
+    exitedElements: Set<string>;
+    /**
+     * Cumulative history (oldest first) of fired chart-build steps per element,
+     * unlike {@link activeSteps} which only ever keeps the latest. Consumed by
+     * `chart-reveal-descriptor`'s `resolveChartRevealDescriptor` to derive the
+     * AUTHORED reveal set regardless of the order stages actually fired in.
+     * Optional: a caller that never surfaces chart reveal state (tests, or a
+     * consumer that only needs `activeSteps`) may omit it.
+     */
+    chartRevealHistory?: Map<string, TimelineStep[]>;
+    /**
+     * Cumulative history of fired diagram-build steps per element, mirroring
+     * {@link chartRevealHistory} for `p:bldDgm` per-node builds. Consumed by
+     * `diagram-reveal-descriptor`'s `resolveDiagramRevealDescriptor`.
+     */
+    diagramRevealHistory?: Map<string, TimelineStep[]>;
+    /**
+     * Element ids currently running a `step.endsOnNextClick` loop ("Repeat
+     * until next click"), mapped to the step that started it. Kept separate
+     * from {@link activeSteps} (which only tracks build/colour-target steps)
+     * so `TimelineEngine.advance()` can freeze exactly these loops in place
+     * the next time the presentation advances, without disturbing every other
+     * element's tracked step. Optional: a caller with no such steps (or that
+     * doesn't care) may omit it.
+     */
+    loopEndingOnNextClick?: Map<string, TimelineStep>;
+}
+/**
+ * Apply one step to `state`, honouring `@restart` via {@link canTriggerStep}.
+ * A step whose previous run is still active (`whenNotActive`) or has already
+ * played once (`never`) is skipped entirely: its currently-running effect and
+ * visibility state are left undisturbed instead of being yanked back to the
+ * start. A `p:cmd` media command step (empty `elementId`) carries no `@restart`
+ * semantics of its own and is always applied.
+ *
+ * Returns `true` when the step was applied, `false` when `@restart` blocked
+ * it. The caller uses this to decide whether the step belongs in the
+ * click-group it hands back to the binding: every binding's playback loop
+ * (React's `applyAnimationGroupSteps` and its Vue/Angular/Svelte/Vanilla
+ * equivalents) applies CSS and schedules cleanup timers purely from the
+ * returned group's `steps`, so a step this function blocks must never reach
+ * that list, or the binding would re-apply (and re-schedule cleanup for) an
+ * effect the deck said must not restart.
+ */
+export declare function applyRestartGatedStep(step: TimelineStep, nowMs: number, state: StepApplicationState): boolean;
+//# sourceMappingURL=animation-sequence-gating.d.ts.map

package/dist/pptx/render/animation-sequence-gating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-sequence-gating.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-sequence-gating.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAEnF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,kBAG9B,CAAC;AAEH;;;GAGG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,kBAAkB,GAAG,SAAS,EACrC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,KAAK,EAAE,MAAM,GACX,OAAO,CAKT;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,kBAAkB,GAAG,SAAS,EACrC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,KAAK,EAAE,MAAM,GACX,OAAO,CAKT;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,kBAAkB,GAAG,SAAS,EACrC,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,KAAK,EAAE,MAAM,GACX,OAAO,CAKT;AAED,mFAAmF;AACnF,MAAM,WAAW,gBAAgB;IAChC,wFAAwF;IACxF,aAAa,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC7B,OAAO,EAAE,YAAY,CAAC,SAAS,CAAC,EAChC,KAAK,EAAE,gBAAgB,GAAG,SAAS,EACnC,KAAK,EAAE,MAAM,GACX,OAAO,CAYT;AAED;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACpC,gBAAgB,EAAE,OAAO,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAC;IAC1D,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACvC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC9B,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IACjD;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IACnD;;;;;;;;OAQG;IACH,qBAAqB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACpC,IAAI,EAAE,YAAY,EAClB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,oBAAoB,GACzB,OAAO,CAqCT"}

package/dist/pptx/render/animation-sequencer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * `animation-sequencer`  -  `AnimationSequencer`, a pure builder that turns a
+ * slide's flat `nativeAnimations` list into an ordered {@link AnimationStep}
+ * timeline (with cumulative trigger-based delays) plus the `@keyframes` CSS and
+ * initial hidden styles. No DOM / framework dependency.
+ *
+ * @module render/animation-sequencer
+ */
+import type { PptxSlide } from 'ooxml-core/pptx';
+import type { AnimationStep, AnimationStyle } from './animation-timeline-types.js';
+export declare class AnimationSequencer {
+    private readonly slide;
+    private readonly elementMap;
+    private readonly dynamicKeyframeBlocks;
+    private readonly pixelateMosaic;
+    /**
+     * @param pixelateMosaic - Opt-in override for `p:animEffect/@filter="pixelate"`:
+     *   `true` plays the blocky mosaic reveal; omitted or `false` (the
+     *   default, matching PowerPoint's own behaviour) snaps the element to
+     *   its end state. See `resolveFilterEffect`'s doc in
+     *   `animation-filter-effects.ts` and `docs/guide/visual-effects.md`.
+     */
+    constructor(slide: PptxSlide, pixelateMosaic?: boolean);
+    /**
+     * Returns the CSS properties an element should have before any animations
+     * play. Entrance animations start hidden; others are unchanged.
+     */
+    getInitialStyles(elementId: string): AnimationStyle;
+    /**
+     * Builds an ordered timeline of animation steps from the slide's
+     * `nativeAnimations` array. Steps are ordered as they appear in the
+     * OOXML sequence, with computed cumulative delays derived from trigger
+     * types.
+     */
+    buildTimeline(): AnimationStep[];
+    /**
+     * Returns a `<style>` block string containing all `@keyframes` definitions
+     * required by the animations on this slide. Safe to inject into a
+     * `<style>` element or `dangerouslySetInnerHTML`.
+     */
+    getKeyframeDefinitions(): string;
+}
+//# sourceMappingURL=animation-sequencer.d.ts.map

package/dist/pptx/render/animation-sequencer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-sequencer.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-sequencer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAqC,MAAM,iBAAiB,CAAC;AAapF,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAc,MAAM,4BAA4B,CAAC;AAM5F,qBAAa,kBAAkB;IAC9B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAY;IAClC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA2B;IACtD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAgB;IACtD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAsB;IAErD;;;;;;OAMG;IACH,YAAmB,KAAK,EAAE,SAAS,EAAE,cAAc,CAAC,EAAE,OAAO,EAO5D;IAED;;;OAGG;IACI,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,CAezD;IAED;;;;;OAKG;IACI,aAAa,IAAI,aAAa,EAAE,CAkGtC;IAED;;;;OAIG;IACI,sBAAsB,IAAI,MAAM,CA0BtC;CACD"}

package/dist/pptx/render/animation-slide-filter.d.ts

@@ -0,0 +1,59 @@
+/**
+ * `animation-slide-filter`: the `slide(<fromEdge>)` `p:animEffect` filter as
+ * the element's content sliding in through a fixed window.
+ *
+ * Ground truth (PowerPoint 365, a COM-authored Wipe whose `@filter` was
+ * rewritten to `slide(fromLeft)` / `slide(fromBottom)` by hand, then
+ * `Presentation.CreateVideo` at 62.5 fps on a 200x200 rectangle carrying
+ * text): the content itself translates in from the named edge, clipped to a
+ * window fixed on the slide. The window is the box plus a soft ramp about
+ * 14% of the box extent wide that lies OUTSIDE the box on the entry side, so
+ * the content starts fully inside that ramp (translated by 114%) and ends at
+ * rest. Progress is linear. The exit plays the same slide time-reversed: the
+ * content leaves through the edge it names.
+ *
+ * `cover`, `uncover`, `push` and `pull` are NOT animated by PowerPoint at
+ * all (same capture method): the entrance appears at the effect's start and
+ * the exit vanishes at its end, which the `cutIn`/`cutOut` keyframes already
+ * play (see `animation-filter-effects`).
+ *
+ * The window is a gradient mask sized 3x the box on the travel axis; its
+ * `mask-position` moves opposite to the `transform` so the window stays put
+ * on the slide while the content moves. Both animate linearly between two
+ * keyframes, so they stay in lockstep under any timing function.
+ *
+ * @module render/animation-slide-filter
+ */
+/** The edge the content enters through (the `slide(from*)` subtype). */
+export type SlideFromEdge = 'Left' | 'Right' | 'Top' | 'Bottom';
+/** Soft ramp width outside the box, as a fraction of the box extent. */
+export declare const SLIDE_FEATHER = 0.14;
+/** Every slide keyframe name, by class and edge. */
+export type SlideFilterEffectName = `slideIn${SlideFromEdge}` | `slideOut${SlideFromEdge}`;
+/** The slide effect for a filter subtype token (bottom edge when absent/unknown). */
+export declare function slideFilterEffectName(subtype: string | undefined, isExit: boolean): SlideFilterEffectName;
+interface SlideFrame {
+    transform: string;
+    maskImage: string;
+    maskSize: string;
+    maskPosition: string;
+}
+/**
+ * The transform + window mask at linear progress `p` (0 = content fully
+ * outside the window, 1 = at rest) for content entering through `edge`.
+ *
+ * Derivation (for `Left`, box width `W`, window `[-F W, W]` on the slide,
+ * mask image `3W` wide with the window at image `[W, (2 + F) W]`): the
+ * content translates by `T = -(1 + F) W (1 - p)`, so the image offset that
+ * keeps the window fixed is `o = -(1 + F) W p`, a `mask-position` of
+ * `p (1 + F) / 2` of the `2W` free travel. `Right`/`Bottom` mirror it.
+ */
+export declare function slideFrameAt(edge: SlideFromEdge, progress: number): SlideFrame;
+/** CamelCase inline-style map for a slide entrance's HIDDEN state. */
+export declare function slideInitialStyle(edge: SlideFromEdge): Record<string, string | number>;
+/** The entrance edge a `slideIn*` effect name encodes, or `undefined`. */
+export declare function slideEntranceEdge(effect: string): SlideFromEdge | undefined;
+/** Static `@keyframes` for every slide edge, entrance and exit. */
+export declare const SLIDE_FILTER_KEYFRAME_DEFINITIONS: Record<SlideFilterEffectName, string>;
+export {};
+//# sourceMappingURL=animation-slide-filter.d.ts.map

package/dist/pptx/render/animation-slide-filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-slide-filter.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-slide-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,wEAAwE;AACxE,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC;AAEhE,wEAAwE;AACxE,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC,oDAAoD;AACpD,MAAM,MAAM,qBAAqB,GAAG,UAAU,aAAa,EAAE,GAAG,WAAW,aAAa,EAAE,CAAC;AAW3F,qFAAqF;AACrF,wBAAgB,qBAAqB,CACpC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,MAAM,EAAE,OAAO,GACb,qBAAqB,CAGvB;AAMD,UAAU,UAAU;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CA2B9E;AAMD,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAGtF;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE3E;AASD,mEAAmE;AACnE,eAAO,MAAM,iCAAiC,EAKzC,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC"}

package/dist/pptx/render/animation-sound-authoring.d.ts

@@ -0,0 +1,79 @@
+/**
+ * `animation-sound-authoring`  -  pure decision logic for the animation panel's
+ * effect sound picker (`p:stSnd`).
+ *
+ * Playback already resolves and plays `PptxElementAnimation.soundRId` /
+ * `soundPath` (see `pptx-viewer-shared/render/animation-sound` used by every
+ * binding's presentation mode); what was missing was an AUTHORING control:
+ * a way to choose "no sound" or a new audio file, with the choice actually
+ * landing in the saved OOXML.
+ *
+ * Two kinds of pick exist. A **stock** pick names one of PowerPoint's 19
+ * built-in gallery sounds (see `effect-sound-catalogue.ts`); Microsoft's own
+ * WAV assets cannot be redistributed, so `effect-sound-synth.ts` synthesises
+ * a DOM-free placeholder and this module stages it with the catalogue's
+ * canonical `@_name` so the SAVED deck is byte-for-byte what PowerPoint
+ * itself recognises as that stock sound (COM-verified, see the catalogue
+ * module's doc comment). A **custom** pick is a sound the user chooses from
+ * their own files, with no catalogue match. Either way the result is a
+ * `dataUrl` staged as a *pending* embed (mirrors `imageData` / `mediaData`):
+ * `PptxHandlerRuntimeSaveSlideWriter`'s `embedPendingAnimationSounds`
+ * converts it to real archive bytes and mints an `audio` relationship on
+ * save, at which point `soundRId` / `soundPath` become the resolved
+ * reference and `soundData` is cleared.
+ *
+ * @module render/animation-sound-authoring
+ */
+import type { PptxElementAnimation } from 'ooxml-core/pptx';
+/** A newly-picked sound file, staged for embedding on the next save. */
+export interface EffectSoundPick {
+    /** `data:audio/...;base64,...` contents of the picked file. */
+    dataUrl: string;
+    /** Display name (e.g. the file's original name), shown by the picker. */
+    fileName?: string;
+    /**
+     * The `@_name` PowerPoint should write for this sound. Set for a stock
+     * gallery pick to the catalogue's canonical file name (e.g.
+     * `"CHIMES.WAV"`); absent for a custom file pick with no meaningful name.
+     */
+    soundName?: string;
+}
+/** Framework-neutral descriptor of an effect's current sound state. */
+export interface EffectSoundState {
+    /** Whether the effect currently has a sound bound, embedded or pending. */
+    hasSound: boolean;
+    /**
+     * Best-effort display name: the picked file's own name when known,
+     * otherwise the resolved archive path's file name for a sound that was
+     * already on the deck when it was opened.
+     */
+    fileName?: string;
+    /**
+     * The matching stock-gallery id (`effect-sound-catalogue.ts`) when the
+     * current sound's `soundName` names one of PowerPoint's 19 built-in
+     * sounds, so the picker can show that entry selected instead of falling
+     * back to a raw file name. Absent for a custom sound or "no sound".
+     */
+    catalogueId?: string;
+}
+/**
+ * Derive the sound picker's current state for one element's animation entry.
+ * Returns "no sound" for an element with no animation entry at all (the
+ * panel only shows the sound row once an effect exists).
+ */
+export declare function getEffectSoundState(slideAnimations: readonly PptxElementAnimation[], elementId: string): EffectSoundState;
+/**
+ * Stage one of PowerPoint's 19 built-in stock sounds (`catalogueId`, e.g.
+ * `"chime"`) as the effect's pending sound. Returns the input array unchanged
+ * when `catalogueId` does not match a catalogue entry.
+ */
+export declare function setEffectStockSound(anims: readonly PptxElementAnimation[], elementId: string, catalogueId: string): PptxElementAnimation[];
+/**
+ * Stage a newly-picked sound file on the element's animation entry, or clear
+ * it entirely when `pick` is `undefined` ("No sound"). Either way, any
+ * previously-resolved `soundRId` / `soundPath` is cleared: a fresh pick
+ * supersedes it (the save-time embed step re-derives both), and clearing
+ * removes it outright so the next save writes no `p:stSnd` for this effect.
+ */
+export declare function setEffectSound(anims: readonly PptxElementAnimation[], elementId: string, pick: EffectSoundPick | undefined): PptxElementAnimation[];
+//# sourceMappingURL=animation-sound-authoring.d.ts.map

package/dist/pptx/render/animation-sound-authoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-sound-authoring.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-sound-authoring.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAM5D,wEAAwE;AACxE,MAAM,WAAW,eAAe;IAC/B,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,uEAAuE;AACvE,MAAM,WAAW,gBAAgB;IAChC,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,eAAe,EAAE,SAAS,oBAAoB,EAAE,EAChD,SAAS,EAAE,MAAM,GACf,gBAAgB,CAclB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,SAAS,oBAAoB,EAAE,EACtC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GACjB,oBAAoB,EAAE,CAUxB;AAUD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC7B,KAAK,EAAE,SAAS,oBAAoB,EAAE,EACtC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,eAAe,GAAG,SAAS,GAC/B,oBAAoB,EAAE,CASxB"}

package/dist/pptx/render/animation-strips-reveal.d.ts

@@ -0,0 +1,77 @@
+/**
+ * `animation-strips-reveal`: the Strips entrance/exit (`presetID` 18,
+ * `p:animEffect filter="strips(<dir>)"`) as a diagonal corner-to-corner
+ * mask sweep.
+ *
+ * Ground truth (PowerPoint 365, COM `AddEffect(msoAnimEffectStrips)` then
+ * `Presentation.CreateVideo` at 62.5 fps, frame-diffed on a 200x200 red
+ * rectangle): the reveal starts at ONE corner and sweeps linearly to the
+ * opposite corner along the diagonal. The token names the TRAVEL direction,
+ * so `downLeft` starts at the top-right corner, `upLeft` at the bottom-right,
+ * `downRight` at the top-left and `upRight` at the bottom-left
+ * (`presetSubtype` 12 / 9 / 6 / 3 respectively). The sweep front sits at the
+ * effect's linear progress (half-coverage at 50%), and the leading edge is a
+ * soft band about 1/8 of the corner-to-corner distance wide (PowerPoint draws
+ * that band as a 16x16 staircase of cells; this mask draws it as a smooth
+ * ramp). The exit form plays the same sweep time-reversed: the hidden region
+ * grows from the END corner back toward the start corner.
+ *
+ * The mask is one `linear-gradient(to <corner>)` image sized 3x the element
+ * on both axes; only `mask-position` animates, which browsers interpolate
+ * smoothly, and the "magic corner" gradient keeps the isolines parallel to
+ * the element's own diagonal for any aspect ratio.
+ *
+ * @module render/animation-strips-reveal
+ */
+/** A `strips(<token>)` filter subtype: the direction the sweep travels. */
+export type StripsDirection = 'downLeft' | 'upLeft' | 'downRight' | 'upRight';
+/** Soft leading-band width, as a fraction of the corner-to-corner travel. */
+export declare const STRIPS_BAND = 0.125;
+/** `presetSubtype` codes PowerPoint writes for each Strips direction (COM-verified). */
+export declare const STRIPS_SUBTYPE_TO_DIRECTION: Readonly<Record<number, StripsDirection>>;
+/** PowerPoint's default Strips direction (`AddEffect` with no Direction set). */
+export declare const DEFAULT_STRIPS_DIRECTION: StripsDirection;
+/** Narrow a filter subtype token to a {@link StripsDirection}. */
+export declare function isStripsDirection(token: string | undefined): token is StripsDirection;
+/**
+ * `mask-position` that puts the sweep front (the band's midline) at `front`,
+ * where `front` is the distance from the start corner along the diagonal as a
+ * fraction of the corner-to-corner travel (0 = start corner, 1 = far corner).
+ *
+ * Derivation: with the image `k` times the element and positioned at
+ * `(px, py)`, a magic-corner gradient's parameter at an element point whose
+ * diagonal distance is `d` is `s = (2d + (k - 1)(qx + qy)) / 2k`, where `qx`
+ * is `px` (left start) or `1 - px` (right start), likewise `qy`. The band is
+ * centred on `s = 0.5`, so `qx = qy = (k - 2 front) / (2 (k - 1))`.
+ */
+export declare function stripsMaskPosition(direction: StripsDirection, front: number): string;
+/** Sweep front for a linear progress `p` (0-1): fully hidden at 0, fully shown at 1. */
+export declare function stripsFrontAt(progress: number): number;
+/** Kebab-case declarations for the Strips mask at a linear reveal progress (0-1). */
+export declare function stripsDecl(direction: StripsDirection, progress: number): string;
+/** CamelCase inline-style map for a Strips entrance's HIDDEN state. */
+export declare function stripsInitialStyle(direction: StripsDirection): Record<string, string | number>;
+/** Every Strips keyframe name, by direction and class. */
+export type StripsEffectName = 'stripsInDownLeft' | 'stripsInUpLeft' | 'stripsInDownRight' | 'stripsInUpRight' | 'stripsOutDownLeft' | 'stripsOutUpLeft' | 'stripsOutDownRight' | 'stripsOutUpRight';
+/** The Strips effect name for a direction and class. */
+export declare function stripsEffectName(direction: StripsDirection, isExit: boolean): StripsEffectName;
+/**
+ * Resolve the Strips direction from the filter subtype token (the literal
+ * PowerPoint pairs with every Strips preset), falling back to the numeric
+ * `presetSubtype`, then to PowerPoint's own default.
+ */
+export declare function resolveStripsDirection(filterSubtype: string | undefined, presetSubtype: number | undefined): StripsDirection;
+/** Static `@keyframes` for every Strips direction, entrance and exit. */
+export declare const STRIPS_KEYFRAME_DEFINITIONS: Record<StripsEffectName, string>;
+/**
+ * Redirect a default Strips effect name (`stripsInDownLeft` /
+ * `stripsOutDownLeft`, what the preset tables map `presetID` 18 to) onto the
+ * animation's own direction. Any other effect name is returned unchanged.
+ */
+export declare function redirectStripsEffect<T extends string>(effect: T | undefined, filter: {
+    family: string;
+    subtype?: string;
+} | undefined, presetSubtype: number | undefined): T | StripsEffectName | undefined;
+/** The travel direction a Strips ENTRANCE effect name encodes, or `undefined`. */
+export declare function stripsEntranceDirection(effect: string): StripsDirection | undefined;
+//# sourceMappingURL=animation-strips-reveal.d.ts.map

package/dist/pptx/render/animation-strips-reveal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-strips-reveal.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-strips-reveal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,QAAQ,GAAG,WAAW,GAAG,SAAS,CAAC;AAqB9E,6EAA6E;AAC7E,eAAO,MAAM,WAAW,QAAQ,CAAC;AAEjC,wFAAwF;AACxF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAKjF,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,wBAAwB,EAAE,eAA4B,CAAC;AAEpE,kEAAkE;AAClE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,IAAI,eAAe,CAErF;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAMpF;AAOD,wFAAwF;AACxF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGtD;AAED,qFAAqF;AACrF,wBAAgB,UAAU,CAAC,SAAS,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAI/E;AAED,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAQ9F;AASD,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,GACzB,kBAAkB,GAClB,gBAAgB,GAChB,mBAAmB,GACnB,iBAAiB,GACjB,mBAAmB,GACnB,iBAAiB,GACjB,oBAAoB,GACpB,kBAAkB,CAAC;AAEtB,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,eAAe,EAAE,MAAM,EAAE,OAAO,GAAG,gBAAgB,CAE9F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACrC,aAAa,EAAE,MAAM,GAAG,SAAS,EACjC,aAAa,EAAE,MAAM,GAAG,SAAS,GAC/B,eAAe,CAQjB;AAcD,yEAAyE;AACzE,eAAO,MAAM,2BAA2B,EAKnC,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;AAEtC;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EACpD,MAAM,EAAE,CAAC,GAAG,SAAS,EACrB,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,EACxD,aAAa,EAAE,MAAM,GAAG,SAAS,GAC/B,CAAC,GAAG,gBAAgB,GAAG,SAAS,CASlC;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEnF"}

package/dist/pptx/render/animation-target-id.d.ts

@@ -0,0 +1,19 @@
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+/** Synthetic state-map suffix for a `p:spTgt/p:bg` background-only target. */
+export declare const BACKGROUND_ANIMATION_ID_SUFFIX = "::pptx-bg";
+/**
+ * Resolve the view-layer target for an animation.
+ *
+ * PowerPoint's `p:bg` target animates only the shape paint while its text stays
+ * visible. Keeping that state under a synthetic id lets bindings paint a
+ * separate background layer without hiding or transforming the whole element.
+ *
+ * A `p:spTgt/p:subSp` target (a shape animated while nested inside a group,
+ * authored by selecting a group member in PowerPoint's Animation Pane without
+ * ungrouping it) names the descendant shape's id on `subShapeId`; that leaf id
+ * is the real playback target, so it wins over the parse layer's `targetId`
+ * (which core keeps pointed at the same leaf already, but a caller reading the
+ * full `target` object should still prefer `subShapeId` explicitly here).
+ */
+export declare function resolveAnimationTargetId(animation: PptxNativeAnimation): string;
+//# sourceMappingURL=animation-target-id.d.ts.map

package/dist/pptx/render/animation-target-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-target-id.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-target-id.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,8EAA8E;AAC9E,eAAO,MAAM,8BAA8B,cAAc,CAAC;AAE1D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,mBAAmB,GAAG,MAAM,CAS/E"}

package/dist/pptx/render/animation-text-style-css.d.ts

@@ -0,0 +1,70 @@
+/**
+ * `animation-text-style-css` - builds a scoped, `!important` CSS rule that
+ * applies an active {@link TextStyleAnimationDescriptor} on top of an
+ * element's own rendered text runs.
+ *
+ * Every binding already stamps its top-level rendered element wrapper with
+ * `data-element-id="<id>"` (selection, hit-testing, the four non-React
+ * bindings' post-render DOM pass). A run span always carries its OWN inline
+ * `style` attribute (bold/italic/underline/size are declared there
+ * unconditionally, see `text-run-style.ts`), so plain CSS inheritance from an
+ * ancestor can never reach it: only a stylesheet rule with `!important`
+ * outranks another element's own inline style. Scoping the selector to this
+ * element's `data-element-id` keeps the override from leaking onto sibling
+ * elements that reuse the same generic run markup.
+ *
+ * `fontScale` is applied as `calc(1em * <scale>)` rather than an absolute
+ * size: once this rule wins, the run's own inline `font-size` is not
+ * consulted at all, so the `em` here resolves against the INHERITED
+ * (ancestor) font-size, giving a reasonable relative-size approximation
+ * without needing per-run size bookkeeping at the override layer.
+ *
+ * @module render/animation-text-style-css
+ */
+import type { TextStyleAnimationDescriptor } from './animation-text-style-resolve.js';
+/**
+ * Build the CSS override rule for one element's active text-style animation,
+ * or `undefined` when there is nothing to override (so a binding can skip
+ * rendering a `<style>` tag entirely).
+ *
+ * Emits TWO scoped rules, both keyed off the SAME `data-element-id`, so one
+ * call covers every element type a font-style emphasis effect can target
+ * (text/shape, a table cell, a connector caption, a chart title/label/legend,
+ * a SmartArt node caption): a binding no longer needs to gate this call on
+ * "is this a plain text element" - PowerPoint animates a table cell or a
+ * chart title exactly the same way.
+ *
+ * - The `[style]` rule targets ordinary HTML text (paragraph runs, table
+ *   cell spans, connector caption spans): every one of those already carries
+ *   its OWN inline `style` attribute (see the module doc), which plain CSS
+ *   inheritance cannot reach.
+ * - The `text, tspan` rule targets SVG text (chart titles/axis
+ *   labels/data labels/legend, SmartArt node captions): every binding draws
+ *   those as raw SVG presentation ATTRIBUTES (`fill=`, `font-weight=`, ...),
+ *   never an inline `style`, so the `[style]` rule's selector never matches
+ *   them at all. `font-weight`/`font-style`/`font-size`/`text-decoration`
+ *   are CSS properties SVG text already honours; `color` is not (SVG paints
+ *   text via `fill`), so the colour case is re-expressed as `fill` here
+ *   instead of reusing the `color` declaration.
+ *
+ * Neither rule leaks onto a chart's non-text SVG (bars, slices, borders):
+ * `text, tspan` is a plain type selector, not `*`, so nothing else in the
+ * element's subtree matches it.
+ */
+export declare function buildTextStyleOverrideCss(elementId: string, style: TextStyleAnimationDescriptor | undefined): string | undefined;
+/**
+ * A visually inert `@keyframes` block for an emphasis step whose ONLY effect
+ * is a text-style change (Bold Reveal, Underline, Style Emphasis, ...).
+ *
+ * The timeline builder needs every step to own a CSS animation so the
+ * playback engine's timing (delay, duration, cleanup) has something to hang
+ * off, but the unmapped-preset safety net used to hand these steps a neutral
+ * `pulse`, so PowerPoint's plain "the text turns bold" played with a scale
+ * throb on top. This keyframe holds the element exactly as rendered while the
+ * `textStyle` override does the visible work.
+ */
+export declare function buildTextStyleHoldKeyframe(uid: number): {
+    keyframeName: string;
+    css: string;
+};
+//# sourceMappingURL=animation-text-style-css.d.ts.map

package/dist/pptx/render/animation-text-style-css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-text-style-css.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-text-style-css.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAOnF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,yBAAyB,CACxC,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,4BAA4B,GAAG,SAAS,GAC7C,MAAM,GAAG,SAAS,CAyCpB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAM7F"}