ooxml-ui 0.30.1 → 0.31.0

package/dist/pptx/render/animation-motion-path.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `animation-motion-path`: parse an OOXML `p:animMotion/@path` string into a
+ * dense list of waypoints (percentages of the element box) suitable for driving
+ * a CSS `@keyframes translate()` animation.
+ *
+ * Unlike a naive parser that treats cubic-bezier `C` control points as literal
+ * waypoints (which produces a jagged polyline through the control handles), this
+ * module samples each `C` segment along the real bezier curve so the motion
+ * stays smooth. `M`/`L` segments contribute their endpoints unchanged, and both
+ * absolute (upper-case) and relative (lower-case) commands are supported.
+ *
+ * @module render/animation-motion-path
+ */
+/** A single sampled point on a motion path, in element-box percentage units. */
+export interface MotionPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Parse a motion-path `d`-style string into dense waypoints scaled to element
+ * box percentages (path coordinate `1.0` maps to `100%`). Cubic-bezier `C`
+ * segments are sampled along the true curve rather than through their control
+ * points. Returns an empty array for an unparseable path.
+ */
+export declare function parseMotionPathPoints(motionPath: string): MotionPoint[];
+//# sourceMappingURL=animation-motion-path.d.ts.map

package/dist/pptx/render/animation-motion-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-motion-path.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-motion-path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC3B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAoBD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,EAAE,CAoFvE"}

package/dist/pptx/render/animation-parallel-composition.d.ts

@@ -0,0 +1,8 @@
+import type { TimelineStep } from './animation-timeline-types.js';
+/** Whether two sibling behaviours can safely share one CSS animation list. */
+export declare function canComposeParallelSteps(left: TimelineStep, right: TimelineStep): boolean;
+/** Compose independent CSS properties without dropping either behaviour. */
+export declare function composeParallelSteps(left: TimelineStep, right: TimelineStep): TimelineStep;
+/** Properties ("transform" / "opacity" / "color" / "filter" / "unknown") a keyframe animates. */
+export declare function keyframeAnimatedProperties(keyframeName: string): Set<string>;
+//# sourceMappingURL=animation-parallel-composition.d.ts.map

package/dist/pptx/render/animation-parallel-composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-parallel-composition.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-parallel-composition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAgB3E,8EAA8E;AAC9E,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,OAAO,CA8BxF;AAED,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,GAAG,YAAY,CAO1F;AAsBD,iGAAiG;AACjG,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CA2C5E"}

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

@@ -0,0 +1,102 @@
+/**
+ * `animation-pixelate-filter` - the `p:animEffect/@filter="pixelate"` mosaic
+ * reveal/conceal: a genuinely blocky, content-preserving grid dissolve built
+ * from a small, FIXED set of self-contained SVG `<filter>` data-URIs. Every
+ * value is inlined directly inside the generated `@keyframes` CSS text
+ * (`filter: url("data:image/svg+xml,...")`), exactly like the diamond/wedge
+ * mask reveals' data-URI `mask-image`s in `animation-mask-reveal.ts`: no DOM
+ * `<defs>` injection, no per-element id, nothing for a binding to wire up.
+ *
+ * How the mosaic works (SVG filter primitives only, no canvas/WebGL):
+ *  1. `feFlood` paints a small opaque square (the "dot") sized `x=0 y=0
+ *     width=<dot> height=<dot>` inside a coordinate space that uses
+ *     `primitiveUnits="objectBoundingBox"`, so `<dot>` is a FRACTION of the
+ *     element's own box, not an absolute pixel size.
+ *  2. `<feComposite in="dot" width="<tile>" height="<tile>"/>` (no `in2`)
+ *     re-declares that dot's filter SUBREGION as the larger `<tile>` pitch,
+ *     so the dot now sits inside extra transparent margin: this margin is
+ *     what becomes the "grout" gap between cells once tiled.
+ *  3. `<feTile>` repeats that dot-plus-margin tile across the whole element,
+ *     producing an evenly spaced grid of opaque squares.
+ *  4. A final `<feComposite in="SourceGraphic" in2="grid" operator="in"/>`
+ *     masks `SourceGraphic` through that grid: each visible square shows the
+ *     element's OWN real painted content at that screen position (not a
+ *     repeated/duplicated sample from elsewhere), and the grout gaps are
+ *     fully transparent. This is the standard "SVG pixelate filter" recipe.
+ *
+ * Because `primitiveUnits="objectBoundingBox"` scales the whole filter with
+ * the element's own size, a small FIXED number of filter defs (one per
+ * mosaic "coarseness" level, {@link PIXELATE_LEVELS}) covers every element
+ * regardless of its pixel dimensions, matching this engine's "one static
+ * `@keyframes` block per effect" shape (see `animation-keyframes.ts`'s
+ * module doc): nothing here is keyed by element id, unlike
+ * `visual-effects.ts`'s per-element soft-edge/duotone `<filter>`s, which DO
+ * need a binding to inject matching DOM `<defs>`.
+ *
+ * CSS cannot interpolate `filter: url(...)` between two distinct filters, so
+ * playback is a fixed sequence of DISCRETE steps: coarse -> fine for a
+ * reveal (`pixelateIn`), fine -> coarse for a conceal (`pixelateOut`), each
+ * one its own keyframe percentage. The browser's default
+ * non-interpolatable-property behaviour (hold the earlier value, then flip
+ * at the midpoint to the next keyframe's value) turns that into the
+ * coarsening/refining animation, while `opacity` keeps ramping smoothly
+ * across the same stops.
+ *
+ * A non-square element gets non-square mosaic cells (objectBoundingBox
+ * fractions apply independently to the box's width and height), which is an
+ * accepted approximation, the same tradeoff `animation-mask-reveal.ts` makes
+ * for `diamondOut`/`wedgeOut`.
+ *
+ * ## Verified against real PowerPoint: there is no PowerPoint animation here
+ *
+ * Checked against PowerPoint 2016 (Office16 x64) via COM automation:
+ * `Presentation.CreateVideo` on `e2e/fixtures/pixelate-filter.pptx` (a bare,
+ * non-preset `p:animEffect filter="pixelate" transition="in"` click step),
+ * frame-diffed against an otherwise byte-identical control deck where only
+ * the `filter` value was swapped to `"dissolve"` (a real, Basic-gallery,
+ * PowerPoint-rendered SMIL filter). The control deck visibly dissolves: an
+ * early frame (mid-reveal, dithered) differs pixel-for-pixel from a later,
+ * settled frame. The pixelate deck does not: the earliest and latest frames
+ * of its click step are byte-for-byte identical, and the target shape is
+ * already fully painted at full opacity from the very first rendered frame.
+ * PowerPoint 2016 performs NO animation at all for `filter="pixelate"`, not
+ * a mosaic, not a fade, not even a hide-then-reveal: it silently snaps
+ * straight to the resolved end state, the same way it treats a build effect
+ * it cannot interpret.
+ *
+ * So there is no PowerPoint frame sequence for this module's mosaic to be
+ * verified AGAINST. `pixelate` is a schema-legal `ST_TransitionFilterType`
+ * value (ECMA-376 20.1.8.49) with no host implementation in real PowerPoint,
+ * not a rendered effect whose timing this engine could match. The block-size
+ * progression ({@link PIXELATE_LEVELS}) and step count are therefore a
+ * deliberate, hand-tuned design choice, not a fit to any PowerPoint
+ * reference: they exist so a file authored by a non-PowerPoint tool with
+ * this filter value gets a genuine, content-preserving reveal in this viewer
+ * instead of the silent instant-snap PowerPoint itself falls back to.
+ *
+ * @module render/animation-pixelate-filter
+ */
+/**
+ * Mosaic "coarseness" levels, coarsest first: each is the tile pitch as a
+ * fraction of the element's own bounding box. Loosely mirrors a progression
+ * of on-screen pixel sizes (imagine roughly 32px down to roughly 2px on a
+ * typical slide-sized element) expressed as size-independent fractions
+ * instead of absolute pixels.
+ */
+export declare const PIXELATE_LEVELS: readonly number[];
+/**
+ * Ready-to-use `filter: url("data:...")` CSS values, one per
+ * {@link PIXELATE_LEVELS} entry (coarsest first, same order/index).
+ */
+export declare const PIXELATE_FILTER_VALUES: readonly string[];
+/**
+ * `pixelateIn` keyframes: opacity 0 -> 1 while the mosaic refines from the
+ * coarsest level down to fully resolved (`filter: none`).
+ */
+export declare const PIXELATE_IN_KEYFRAMES: string;
+/**
+ * `pixelateOut` keyframes: opacity 1 -> 0 while the mosaic coarsens from
+ * fully resolved (`filter: none`) down to the coarsest level.
+ */
+export declare const PIXELATE_OUT_KEYFRAMES: string;
+//# sourceMappingURL=animation-pixelate-filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-pixelate-filter.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-pixelate-filter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6EG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,MAAM,EAA8C,CAAC;AA0C5F;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAGlD,CAAC;AA0BH;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAKnC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAKpC,CAAC"}

package/dist/pptx/render/animation-playback-engine.d.ts

@@ -0,0 +1,119 @@
+/**
+ * `animation-playback-engine`: the framework-light clock + DOM glue that drives
+ * a {@link PresentationAnimationController}-shaped clock (see
+ * {@link PlaybackAnimationController}) during a running slide show. Extracted
+ * from four near-identical copies (Vue `composables/animation-playback-helpers`,
+ * Angular `viewer/presentation-playback-helpers`, Svelte
+ * `presentation/animation-playback-helpers`, VanillaJS
+ * `animation/animation-playback-helpers`) that had all been hand-ported from the
+ * React binding's `presentation-mode/animation-helpers` + `build-playback`.
+ *
+ * The controller itself is pure (no DOM, no timers, no RAF) and lives in
+ * {@link module:render/presentation-animation-controller}. This module owns:
+ *  - applying a click-group's steps (visibility, CSS animation, sound, media
+ *    command) onto a `Map<elementId, ElementAnimationState>`;
+ *  - the requestAnimationFrame loop that ramps a staged chart / SmartArt build's
+ *    `progress` 0 -> 1 (`p:bldChart` / `p:bldDgm`);
+ *  - the auto-advance chain for consecutive withPrevious / afterPrevious groups.
+ *  - (via the sibling `animation-media-end-gating`, kept separate for this
+ *    file's line budget) wiring an `onStopAudio`-gated step to its REAL
+ *    `<audio>`/`<video>` element's `ended` event.
+ *
+ * Only `window.setTimeout` / `requestAnimationFrame` / `cancelAnimationFrame` /
+ * `performance.now` (all present in jsdom) and DOM lookups scoped through the
+ * caller-supplied {@link PlaybackContext.frameRoot} are touched, so this stays
+ * unit-testable outside a browser. Actual `Audio` playback is NOT touched here:
+ * a binding wires its local sound helper in as {@link PlaybackContext.playSound}
+ * / {@link PlaybackContext.stopSound} (an optional {@link PlaybackContext.onPlayActionSound}
+ * host override takes priority over `playSound` when set, matching the
+ * pre-extraction behaviour of `ctx.onPlayActionSound ?? playAnimationSound`).
+ *
+ * The `p:seq/@nextAc="seek"` nuance (a second advance while a group is still
+ * mid-flight fast-forwards it to its authored end state instead of playing the
+ * next group) lives in the sibling `animation-playback-seek`, whose
+ * `advanceMainSequence` is the "next click" entry point every binding uses.
+ *
+ * @module render/animation-playback-engine
+ */
+import type { ElementAnimationState, TimelineClickGroup } from './animation-timeline-types.js';
+import type { PresentationStatesOptions } from './presentation-animation-controller.js';
+/** Updater over the element-state map (React `setState`-compatible signature). */
+export type StatesSetter = (updater: (prev: Map<string, ElementAnimationState>) => Map<string, ElementAnimationState>) => void;
+/** Mutable handle holding the in-flight `requestAnimationFrame` id (or null). */
+export interface BuildRafHandle {
+    current: number | null;
+}
+/**
+ * The subset of {@link PresentationAnimationController} this engine needs to
+ * drive playback. A real controller instance satisfies this structurally, so a
+ * binding passes it through unchanged; tests can pass a plain stub instead of
+ * constructing a full controller from a slide.
+ */
+export interface PlaybackAnimationController {
+    shouldAutoAdvance(): boolean;
+    getAutoAdvanceDelay(): number;
+    peekNext(): TimelineClickGroup | null;
+    advance(nowMs?: number): TimelineClickGroup | null;
+    computeStatesFor(elementIds: readonly string[], options?: PresentationStatesOptions): Map<string, ElementAnimationState>;
+}
+/** Everything the step / build / auto-advance helpers need from the host. */
+export interface PlaybackContext {
+    setStates: StatesSetter;
+    /** Timer ids collected here so the host can clear them on slide change. */
+    timers: number[];
+    buildHandle: BuildRafHandle;
+    /** Host-provided action-sound player; takes priority over `playSound`. */
+    onPlayActionSound?: (soundPath: string) => void;
+    /** The binding's local action-sound player, used when no host override is set. */
+    playSound: (soundPath: string) => void;
+    /** Stops any in-progress action/animation sound. */
+    stopSound: () => void;
+    /** Root element to scope media-command target lookups to (the slide stage). */
+    frameRoot?: () => HTMLElement | null;
+    /**
+     * Maps a `p:audio`/`p:video` animation's OWN timing-tree node id to the
+     * element id it plays (`animation-media-end-gating`'s
+     * `resolveMediaTimeNodeElementIds`), so an `onStopAudio`-gated step can
+     * find the real DOM element for its `ended` event. Absent: falls back to
+     * the `delayMs` estimate alone (matches every binding before this existed).
+     */
+    mediaTimeNodeElementIds?: ReadonlyMap<number, string>;
+    /**
+     * ElementId -> bookmarkName -> time(ms) lookup
+     * (`animation-media-bookmark-gating`'s `resolveMediaBookmarkTimesMs`), so
+     * an `onMediaBookmark`-gated step can find the real DOM media element and
+     * the bookmark's authored time. Absent: a bookmark-gated step never fires
+     * (see `animation-media-bookmark-gating`'s module doc).
+     */
+    mediaBookmarkTimesMs?: ReadonlyMap<string, ReadonlyMap<string, number>>;
+}
+/** The staged-build fields of a state, carried across the step writes below. */
+type BuildStateFields = Pick<ElementAnimationState, 'build' | 'chartReveal' | 'diagramReveal' | 'textStyle'>;
+/**
+ * The staged-build reveal a state already holds. A `p:bldChart` / `p:bldDgm`
+ * build fires one step PER STAGE against the same element id, so every write
+ * that replaces the element's state object (a step starting, a step's cleanup
+ * timer) has to carry these through: dropping them hands the renderer a state
+ * with no build at all, which it reads as "reveal everything" - the whole
+ * diagram popped in the moment the first stage's fade finished.
+ */
+export declare function carryBuildState(state: ElementAnimationState | undefined): BuildStateFields;
+export { applyAnimationGroupSteps } from './animation-playback-steps.js';
+/** Cancel any in-flight build RAF and clear the handle. */
+export declare function cancelBuildReveal(handle: BuildRafHandle): void;
+/**
+ * Ramp a click-group's staged-build `progress` from 0 -> 1 via
+ * requestAnimationFrame, merging each build element's `build` descriptor onto the
+ * element states each frame. No-op when the group carries no build step, so
+ * ordinary click-advance is unchanged.
+ */
+export declare function driveBuildReveal(controller: PlaybackAnimationController, group: TimelineClickGroup, ctx: PlaybackContext): void;
+/** Apply a group's steps and start its staged-build reveal (if any). */
+export declare function playGroup(controller: PlaybackAnimationController, group: TimelineClickGroup, ctx: PlaybackContext): void;
+/**
+ * After a click-group plays, schedule the next group when it should auto-advance
+ * (withPrevious / afterPrevious), chaining through consecutive auto-advance
+ * groups.
+ */
+export declare function scheduleAutoAdvanceChain(controller: PlaybackAnimationController, ctx: PlaybackContext): void;
+//# sourceMappingURL=animation-playback-engine.d.ts.map

package/dist/pptx/render/animation-playback-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-playback-engine.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-playback-engine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAGH,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAE5F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAErF,kFAAkF;AAClF,MAAM,MAAM,YAAY,GAAG,CAC1B,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,KAAK,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,KACrF,IAAI,CAAC;AAEV,iFAAiF;AACjF,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IAC3C,iBAAiB,IAAI,OAAO,CAAC;IAC7B,mBAAmB,IAAI,MAAM,CAAC;IAC9B,QAAQ,IAAI,kBAAkB,GAAG,IAAI,CAAC;IACtC,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAAC;IACnD,gBAAgB,CACf,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,CAAC,EAAE,yBAAyB,GACjC,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAC;CACtC;AAED,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC/B,SAAS,EAAE,YAAY,CAAC;IACxB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,cAAc,CAAC;IAC5B,0EAA0E;IAC1E,iBAAiB,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,kFAAkF;IAClF,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,oDAAoD;IACpD,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,+EAA+E;IAC/E,SAAS,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,CAAC;IACrC;;;;;;OAMG;IACH,uBAAuB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtD;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACxE;AAMD,gFAAgF;AAChF,KAAK,gBAAgB,GAAG,IAAI,CAC3B,qBAAqB,EACrB,OAAO,GAAG,aAAa,GAAG,eAAe,GAAG,WAAW,CACvD,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,qBAAqB,GAAG,SAAS,GAAG,gBAAgB,CAkB1F;AAED,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAMtE,2DAA2D;AAC3D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,GAAG,IAAI,CAK9D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE,2BAA2B,EACvC,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,eAAe,GAClB,IAAI,CAyCN;AAMD,wEAAwE;AACxE,wBAAgB,SAAS,CACxB,UAAU,EAAE,2BAA2B,EACvC,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,eAAe,GAClB,IAAI,CAGN;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACvC,UAAU,EAAE,2BAA2B,EACvC,GAAG,EAAE,eAAe,GAClB,IAAI,CAqBN"}

package/dist/pptx/render/animation-playback-seek.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `animation-playback-seek`: PowerPoint's `p:seq/@nextAc="seek"` behaviour
+ * (ECMA-376 S19.5.60) for the main click sequence of a running slide show.
+ *
+ * A presenter click that lands while the previous click-group is still
+ * mid-flight must fast-forward THAT group to its authored end state, not start
+ * the next group on top of it: the running CSS / Web Animations are finished in
+ * place, every pending cleanup timer and the staged-build RAF are cancelled,
+ * and each step is written to the exact state its own cleanup timer would have
+ * reached. Only once the group is settled (or its duration has elapsed) does a
+ * click advance the sequence.
+ *
+ * This used to live only in the React binding
+ * (`presentation-mode/animation-helpers.ts`); Vue / Angular / Svelte / Vanilla
+ * advanced immediately regardless of `seqNextAction`, so a second click during
+ * a build silently skipped a step there. {@link advanceMainSequence} is the one
+ * entry point every binding now routes its "next click" through, so the branch
+ * cannot drift again.
+ *
+ * Companion to `animation-playback-engine` (kept separate for that file's line
+ * budget). `animation-sequence-gating` handles the OTHER two `@nextAc` tokens
+ * inside the pure `TimelineEngine`; `"seek"` needs the DOM and the host's
+ * timers, so it lives here in the DOM-glue layer instead.
+ *
+ * @module render/animation-playback-seek
+ */
+import type { PlaybackAnimationController, PlaybackContext, StatesSetter } from './animation-playback-engine.js';
+import type { ElementAnimationState, TimelineClickGroup } from './animation-timeline-types.js';
+/**
+ * The click-group most recently started by a presenter click, plus the
+ * wall-clock instant (`performance.now()` domain) at which its authored
+ * duration runs out. Owned by the binding (a ref / field / closure variable)
+ * and mutated in place by the helpers below.
+ */
+export interface ActiveAnimationGroup {
+    group: TimelineClickGroup | null;
+    endAtMs: number;
+}
+/** A fresh, empty tracker (no group in flight). */
+export declare function createActiveAnimationGroup(): ActiveAnimationGroup;
+/** Record `group` as the in-flight click-group, ending `totalDurationMs` from `nowMs`. */
+export declare function markAnimationGroupActive(active: ActiveAnimationGroup, group: TimelineClickGroup, nowMs?: number): void;
+/** Forget the in-flight click-group (slide change, seek completed, teardown). */
+export declare function clearActiveAnimationGroup(active: ActiveAnimationGroup): void;
+/**
+ * Whether a second presentation advance should seek the active group to its
+ * authored end instead of starting the next group immediately.
+ */
+export declare function shouldSeekAnimationGroup(group: TimelineClickGroup | null, endAtMs: number, nowMs: number): group is TimelineClickGroup;
+/**
+ * Finish the browser animations that belong to one timeline group.
+ *
+ * Presentation mode can render three independently animated DOM surfaces:
+ * whole elements, text-build spans, and the background-only paint layer used
+ * by `p:bg`. Match each surface by its timeline element id and leave unrelated
+ * animations on the page untouched. Returns the number of animations finished.
+ */
+export declare function finishDomAnimationsForGroup(group: TimelineClickGroup, root?: ParentNode): number;
+/**
+ * Fold a rapidly-seeked group into the same end state its normal cleanup
+ * timers would reach. `completedStates` carries progress 1 for staged chart
+ * and SmartArt builds.
+ */
+export declare function finishAnimationGroupSteps(group: TimelineClickGroup, setStates: StatesSetter, completedStates?: ReadonlyMap<string, ElementAnimationState>): void;
+/**
+ * {@link PlaybackAnimationController} plus the exhaustion probe the click path
+ * needs. A real `PresentationAnimationController` satisfies this structurally.
+ */
+export interface SeekableAnimationController extends PlaybackAnimationController {
+    hasMoreSteps(): boolean;
+}
+/**
+ * Cancel every pending step / auto-advance timer and the staged-build RAF held
+ * in `ctx`, in place (so a `ctx` built once stays valid), and forget the
+ * in-flight click-group when a tracker is supplied. Every binding's "clear
+ * timers" path should route through this so a slide change also drops the
+ * seek target: a stale group from the previous slide must never be seeked.
+ */
+export declare function clearPlaybackTimers(ctx: PlaybackContext, active?: ActiveAnimationGroup): void;
+/**
+ * Handle one presenter "next" click against the main sequence.
+ *
+ * - If the previously clicked group is authored `nextAc="seek"` and is still
+ *   inside its duration window, fast-forward it (DOM animations, timers,
+ *   states) and re-arm the auto-advance chain; the sequence position does NOT
+ *   move, so the following click starts the next group.
+ * - Otherwise advance the controller, play the returned group, and remember it
+ *   as the new seek target.
+ *
+ * Returns `true` when the click was consumed by this slide's animations and
+ * `false` when the sequence is exhausted (or there is no controller), so the
+ * caller can fall through to slide navigation. Callers gate on their own
+ * "animations enabled" switch before calling.
+ */
+export declare function advanceMainSequence(controller: SeekableAnimationController | null, ctx: PlaybackContext, active: ActiveAnimationGroup, nowMs?: number): boolean;
+//# sourceMappingURL=animation-playback-seek.d.ts.map

package/dist/pptx/render/animation-playback-seek.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-playback-seek.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-playback-seek.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EACX,2BAA2B,EAC3B,eAAe,EACf,YAAY,EACZ,MAAM,6BAA6B,CAAC;AAMrC,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAO5F;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACpC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,mDAAmD;AACnD,wBAAgB,0BAA0B,IAAI,oBAAoB,CAEjE;AAED,0FAA0F;AAC1F,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,oBAAoB,EAC5B,KAAK,EAAE,kBAAkB,EACzB,KAAK,GAAE,MAA0B,GAC/B,IAAI,CAGN;AAED,iFAAiF;AACjF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAG5E;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,kBAAkB,GAAG,IAAI,EAChC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACX,KAAK,IAAI,kBAAkB,CAE7B;AAMD;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,kBAAkB,EACzB,IAAI,GAAE,UAAqB,GACzB,MAAM,CA8CR;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACxC,KAAK,EAAE,kBAAkB,EACzB,SAAS,EAAE,YAAY,EACvB,eAAe,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAC1D,IAAI,CA4BN;AAMD;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,2BAA2B;IAC/E,YAAY,IAAI,OAAO,CAAC;CACxB;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,eAAe,EAAE,MAAM,CAAC,EAAE,oBAAoB,GAAG,IAAI,CAS7F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,2BAA2B,GAAG,IAAI,EAC9C,GAAG,EAAE,eAAe,EACpB,MAAM,EAAE,oBAAoB,EAC5B,KAAK,GAAE,MAA0B,GAC/B,OAAO,CAwBT"}

package/dist/pptx/render/animation-playback-steps.d.ts

@@ -0,0 +1,15 @@
+import type { PlaybackContext } from './animation-playback-engine.js';
+import type { TimelineClickGroup } from './animation-timeline-types.js';
+/**
+ * Apply a click-group's steps onto the element-state map: fire sound / media
+ * commands, set each step's initial visibility + CSS animation, then schedule
+ * cleanup timers to clear the animation (and hide exits) once each step ends.
+ *
+ * An `onStopAudio`-gated step also gets a real `ended` listener wired via
+ * `wireMediaEndedSteps` (`animation-media-end-gating`), which corrects the
+ * fallback estimate below once the actual media element finishes; the
+ * fallback still fires unconditionally, so no-real-media contexts
+ * (export/headless) are unaffected.
+ */
+export declare function applyAnimationGroupSteps(group: TimelineClickGroup, ctx: PlaybackContext): void;
+//# sourceMappingURL=animation-playback-steps.d.ts.map

package/dist/pptx/render/animation-playback-steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-playback-steps.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-playback-steps.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAGnE,OAAO,KAAK,EAAE,kBAAkB,EAAgB,MAAM,4BAA4B,CAAC;AAInF;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAiL9F"}

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

@@ -0,0 +1,72 @@
+/**
+ * `animation-playback`  -  pure click-stepped playback math for the editor's
+ * element-animation preset model.
+ *
+ * A slide carries an ordered list of {@link PptxElementAnimation}s. PowerPoint
+ * groups them into "click groups": an animation triggered `onClick` /
+ * `onShapeClick` / `onHover` starts a new group, while `withPrevious` /
+ * `afterPrevious` / `afterDelay` animations fold into the group that precedes
+ * them (running together or sequentially within that group). Advancing the
+ * presentation one step reveals one more click group.
+ *
+ * This module derives, for a given step:
+ *  - {@link revealedElementStyles}: the resolved CSS for every animation in the
+ *    revealed groups (with correct cumulative delays for sequential
+ *    `afterPrevious` chains); and
+ *  - {@link pendingElementStyles}: the hidden styles for entrances in
+ *    not-yet-revealed groups, so the host can pre-seed them without a flash.
+ *
+ * Pure: only the preset → CSS mapping is delegated to {@link resolveAnimationCss}
+ * / {@link initialHiddenStyle} from {@link module:render/animation-css}. No
+ * framework, no DOM, no RAF  -  the reactive hook / stateful service / RAF loop
+ * stays in each binding.
+ *
+ * @module render/animation-playback
+ */
+import type { PptxElementAnimation } from 'ooxml-core/pptx';
+/** Minimal CSS-properties shape: kebab-case property → value. */
+export type CSSProperties = Record<string, string>;
+/** A single click-triggered group of animations that play as one step. */
+export interface AnimationClickGroup {
+    /** Animations belonging to this group, in document order. */
+    animations: PptxElementAnimation[];
+}
+/**
+ * Splits an ordered animation list into click groups. The first animation
+ * always begins a group even if it isn't explicitly `onClick` (PowerPoint shows
+ * the first build on the first advance). Subsequent `withPrevious` /
+ * `afterPrevious` animations attach to the group in progress.
+ */
+export declare function buildClickGroups(animations: readonly PptxElementAnimation[]): AnimationClickGroup[];
+/**
+ * Builds the click groups that are effective for a running slide show.
+ * `showWithAnimation=false` is the presentation-level switch from `p:showPr`:
+ * no entrance should be hidden and an advance should move directly to the next
+ * slide, regardless of animation records stored on that slide.
+ */
+export declare function buildPresentationClickGroups(animations: readonly PptxElementAnimation[], showWithAnimation: boolean | undefined): AnimationClickGroup[];
+/** Clamp a step into `[0, count]`. */
+export declare function clampStep(value: number, count: number): number;
+/**
+ * Reveal the next click group. Returns the next step, clamped to `count`.
+ * Equivalent to `clampStep(step + 1, count)`.
+ */
+export declare function advanceStep(step: number, count: number): number;
+/** Parse the numeric ms duration out of a resolved style's `animation-duration`. */
+export declare function durationOf(style: CSSProperties): number;
+/**
+ * Resolve the CSS for every animation in the revealed groups (the first `step`
+ * groups). Within a group, `afterPrevious` animations are pushed back by the
+ * accumulated duration of the preceding animations so sequential chains play in
+ * order; `withPrevious` shares the running delay. The last write for an element
+ * id wins (a later emphasis/exit overrides an earlier entrance), matching how a
+ * single CSS `animation` shorthand can only hold one running effect.
+ */
+export declare function revealedElementStyles(groups: readonly AnimationClickGroup[], step: number): Map<string, CSSProperties>;
+/**
+ * Elements with a pending entrance (in a not-yet-revealed group, i.e. groups at
+ * or beyond `step`) that should be hidden until their group plays. An element
+ * an already-revealed group made visible is never re-hidden.
+ */
+export declare function pendingElementStyles(groups: readonly AnimationClickGroup[], step: number): Map<string, CSSProperties>;
+//# sourceMappingURL=animation-playback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-playback.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-playback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAwB,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAIlF,iEAAiE;AACjE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEnD,0EAA0E;AAC1E,MAAM,WAAW,mBAAmB;IACnC,6DAA6D;IAC7D,UAAU,EAAE,oBAAoB,EAAE,CAAC;CACnC;AAeD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC/B,UAAU,EAAE,SAAS,oBAAoB,EAAE,GACzC,mBAAmB,EAAE,CAWvB;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC3C,UAAU,EAAE,SAAS,oBAAoB,EAAE,EAC3C,iBAAiB,EAAE,OAAO,GAAG,SAAS,GACpC,mBAAmB,EAAE,CAEvB;AAED,sCAAsC;AACtC,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ9D;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAOvD;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,SAAS,mBAAmB,EAAE,EACtC,IAAI,EAAE,MAAM,GACV,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAoC5B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE,SAAS,mBAAmB,EAAE,EACtC,IAAI,EAAE,MAAM,GACV,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAe5B"}

package/dist/pptx/render/animation-ppt-formula.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure evaluator for PowerPoint's `p:anim`/`p:tav` geometry-formula language
+ * (ECMA-376 S19.5, seen on `from`/`to`/`by` attributes and `p:tav`/`p:tav@fmla`
+ * values that target `ppt_x`/`ppt_y`/`ppt_w`/`ppt_h`).
+ *
+ * Grammar (a hand-rolled recursive-descent parser, no `eval`/`Function`):
+ *
+ * ```
+ * expr    := term (('+' | '-') term)*
+ * term    := power (('*' | '/') power)*
+ * power   := unary ('^' power)?        // right-associative
+ * unary   := ('-' | '+')? primary
+ * primary := number | variable | call | '(' expr ')'
+ * call    := name '(' expr (',' expr)* ')'
+ * ```
+ *
+ * Variables: `$` (the sampled time/interpolation parameter), and
+ * `ppt_x`/`ppt_y`/`ppt_w`/`ppt_h` (an optional leading `#` is accepted and
+ * ignored, matching PowerPoint's own `#ppt_x` spelling), `pi`, `e`.
+ * Functions: `abs sqrt sin cos tan atan min max` (`min`/`max` take 2+ args).
+ *
+ * See `animation-ppt-formula-ground-truth.md` for the real-PowerPoint samples
+ * this grammar was derived from.
+ *
+ * @module render/animation-ppt-formula
+ */
+export type PptFormulaVars = Readonly<Record<string, number>>;
+/**
+ * Evaluate a PowerPoint animation geometry formula (`#ppt_x+0.1`,
+ * `(#ppt_h/3+#ppt_w*0.1)`, `#ppt_y-sin(pi*$)/3`, ...) against a fixed set of
+ * variables. Variable lookups are case-insensitive and a leading `#` on a
+ * `ppt_*` token is optional. Returns `undefined` (never throws) on a syntax
+ * error, an unknown identifier/function, a wrong function arity, or a
+ * non-finite result (e.g. division by zero) so a caller can fall back rather
+ * than animate to a garbage position.
+ */
+export declare function evaluatePptFormula(formula: string, vars?: PptFormulaVars): number | undefined;
+/** Canonical (lower-cased) variable names this module understands. */
+export declare const PPT_FORMULA_GEOMETRY_VARS: readonly ['ppt_x', 'ppt_y', 'ppt_w', 'ppt_h'];
+export type PptFormulaGeometryVar = (typeof PPT_FORMULA_GEOMETRY_VARS)[number];
+//# sourceMappingURL=animation-ppt-formula.d.ts.map

package/dist/pptx/render/animation-ppt-formula.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-ppt-formula.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-ppt-formula.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AA+O9D;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,cAAmB,GAAG,MAAM,GAAG,SAAS,CAYjG;AAED,sEAAsE;AACtE,eAAO,MAAM,yBAAyB,YAAI,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,CAAU,CAAC;AACvF,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/pptx/render/animation-preset-ground-truth.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `animation-preset-ground-truth` - raw COM-derived facts about what OOXML
+ * `p:cTn`/`p:animEffect` nodes retail PowerPoint actually writes for the
+ * entrance/exit preset catalogue, gathered for the W3-A pass that closed the
+ * "68 entrance / 68 exit preset IDs, only 54/200 non-path IDs covered" gap.
+ *
+ * Method: `MainSequence.AddEffect(shape, <MsoAnimEffect>, msoAnimateLevelNone,
+ * msoAnimTriggerOnPageClick)` on a blank rectangle, then (per row) toggling
+ * `Effect.Exit = True`, `SaveAs` to `.pptx`, and reading the saved
+ * `ppt/slides/slide1.xml` for the effect's own `p:cTn/@presetClass` /
+ * `@presetID` / `@presetSubtype` and whether it also carries a
+ * `p:animEffect/@filter`, `p:animScale`, `p:animRot`, or `p:animMotion` child.
+ *
+ * CONFIDENCE, READ BEFORE TRUSTING AN ENTRY: ids 1-26 are trustworthy for
+ * BOTH the numeric id (`presetId`) AND the reveal filter, because the
+ * `MsoAnimEffect` constant requested for each one produced a `presetId`
+ * that already matched (and cross-validates) the independently-established
+ * authoring reverse lookup (`animation-write-mappings.ts`) and UI catalog
+ * (`animation-preset-catalog.ts`). From id 27 up, PowerPoint's classic
+ * `AddEffect` automation could not reproduce most of the "extended"
+ * (post-2007) gallery effects with their full authored richness: it degraded
+ * them to a plain `filter="fade"` reveal with none of `animScale`/`animRot`
+ * ever set, and (per a `msoAnimEffectColorReveal`/`msoAnimEffectCredits`
+ * mismatch discovered in this same pass) the specific `MsoAnimEffect`
+ * constant requested did not reliably land on the catalog's assumed id for
+ * that gallery name. Rows for ids 27+ are kept here only as a record of what
+ * automation produced (still useful: presetId itself is spec-defined and not
+ * automation-dependent), NOT as proof of which gallery effect that id
+ * "really" is; `PRESET_ID_TO_EFFECT`'s ids 27+ are matched by NAME against
+ * the pre-existing, previously-reviewed authoring/catalog tables instead (see
+ * the comments next to those entries in `animation-presets-extended.ts`).
+ *
+ * @module render/animation-preset-ground-truth
+ */
+/** One COM-observed OOXML `p:cTn` + child-node signature for a preset id. */
+export interface AnimationPresetGroundTruthRow {
+    presetClass: 'entr' | 'exit';
+    presetId: number;
+    /** `p:cTn/@presetSubtype`, when present. */
+    presetSubtype?: number;
+    /** `p:animEffect/@filter`, when the effect carries one. */
+    filter?: string;
+    /** Whether the saved XML also carried a `p:animScale` node. */
+    hasAnimScale: boolean;
+    /** Whether the saved XML also carried a `p:animRot` node. */
+    hasAnimRot: boolean;
+    /** Whether the saved XML also carried a `p:animMotion` node. */
+    hasAnimMotion: boolean;
+}
+/**
+ * COM-confirmed rows for entrance/exit preset ids 1-26: the band where the
+ * requested `MsoAnimEffect` constant's resulting `presetId` independently
+ * matches the authoring/catalog identity already established across prior
+ * COM-verification waves (see the module doc above). Ids above 26 are
+ * omitted here: PowerPoint's `AddEffect` automation is not a reliable source
+ * for the gallery-name identity of those ids for the reasons documented
+ * above, even though the numeric id it wrote is real.
+ */
+export declare const ANIMATION_PRESET_GROUND_TRUTH: readonly AnimationPresetGroundTruthRow[];
+//# sourceMappingURL=animation-preset-ground-truth.d.ts.map

package/dist/pptx/render/animation-preset-ground-truth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-preset-ground-truth.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-preset-ground-truth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,6EAA6E;AAC7E,MAAM,WAAW,6BAA6B;IAC7C,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+DAA+D;IAC/D,YAAY,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,UAAU,EAAE,OAAO,CAAC;IACpB,gEAAgE;IAChE,aAAa,EAAE,OAAO,CAAC;CACvB;AAgCD;;;;;;;;GAQG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,6BAA6B,EA4BjF,CAAC"}

package/dist/pptx/render/animation-preset-labels.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+var chunkUSBRSEJK_cjs = require('../chunk-USBRSEJK.cjs');
+
+
+
+Object.defineProperty(exports, "ANIMATION_PRESET_VALUES", {
+  enumerable: true,
+  get: function () { return chunkUSBRSEJK_cjs.ANIMATION_PRESET_VALUES; }
+});
+Object.defineProperty(exports, "animationCatalogPresetLabelKey", {
+  enumerable: true,
+  get: function () { return chunkUSBRSEJK_cjs.animationCatalogPresetLabelKey; }
+});
+Object.defineProperty(exports, "animationCatalogPresetSlug", {
+  enumerable: true,
+  get: function () { return chunkUSBRSEJK_cjs.animationCatalogPresetSlug; }
+});
+Object.defineProperty(exports, "animationEffectLabel", {
+  enumerable: true,
+  get: function () { return chunkUSBRSEJK_cjs.animationEffectLabel; }
+});
+Object.defineProperty(exports, "animationEffectLabelKey", {
+  enumerable: true,
+  get: function () { return chunkUSBRSEJK_cjs.animationEffectLabelKey; }
+});
+Object.defineProperty(exports, "animationPresetLabelKey", {
+  enumerable: true,
+  get: function () { return chunkUSBRSEJK_cjs.animationPresetLabelKey; }
+});
+Object.defineProperty(exports, "isAnimationCatalogPresetId", {
+  enumerable: true,
+  get: function () { return chunkUSBRSEJK_cjs.isAnimationCatalogPresetId; }
+});