ooxml-ui 0.30.0 → 0.31.0

package/dist/pptx/render/animation-mask-hole-reveal.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `animation-mask-hole-reveal`  -  the "In" direction reveal for the Box,
+ * Circle, Diamond and Plus entrance effects.
+ *
+ * COM-verified (PowerPoint `Sequence.AddEffect` with
+ * `EffectParameters.Direction = msoAnimDirectionIn`, `CreateVideo` frame
+ * capture): "In" is the geometric INVERSE of `animation-mask-reveal`'s
+ * `boxOut`/`circleOut`/`diamondOut`/`plusOut` shapes. Instead of a solid
+ * shape growing from a point at centre outward, a HOLE shaped like the
+ * preset (inscribed touching the element's own edges/edge-midpoints) shrinks
+ * from that inscribed size down to nothing, so the element appears to fill
+ * in from its own edges/corners inward, like a closing picture frame. Every
+ * `PptxAnimationPreset` named `boxIn`/`circleIn`/`diamondIn`/`plusIn`
+ * (`presetId` 4/6/8/13, entrance class) previously reused the `xOut` shapes
+ * verbatim, which is PowerPoint's `msoAnimDirectionOut` visual, not `In` -
+ * the wrong direction for what is, by far, the common case (it is also the
+ * direction this project's own writer always authors,
+ * the captured `box(in)` tree in core's `animation-behavior-captures.json`).
+ *
+ * Implemented with `mask-composite: exclude` (boolean XOR) against an
+ * always-solid base layer: XORing a solid layer with a shape inverts that
+ * shape, exactly the "cut a hole out of a solid" operation needed. `plusIn`
+ * unions its two independent bars first (`add`) before excluding the union:
+ * sequential exclude of two overlapping shapes would incorrectly re-reveal
+ * their overlap, since XOR-ing twice cancels out.
+ *
+ * @module render/animation-mask-hole-reveal
+ */
+/** The three single-hole preset shapes (Plus needs its own two-bar builder). */
+export type MaskHoleShape = 'box' | 'circle' | 'diamond';
+/** Kebab-case declarations for a box/circle/diamond hole reveal (hidden = full hole, shown = no hole). */
+export declare function maskHoleDecl(shape: MaskHoleShape, phase: 'hidden' | 'shown'): string;
+/** CamelCase inline-style map for a box/circle/diamond hole reveal's HIDDEN state. */
+export declare function maskHoleInitialStyle(shape: MaskHoleShape): Record<string, string | number>;
+/** Kebab-case declarations for the Plus hole reveal (two bars, unioned then excluded from a solid base). */
+export declare function maskPlusHoleDecl(phase: 'hidden' | 'shown'): string;
+/** CamelCase inline-style map for the Plus hole reveal's HIDDEN state. */
+export declare function maskPlusHoleInitialStyle(): Record<string, string | number>;
+//# sourceMappingURL=animation-mask-hole-reveal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-mask-hole-reveal.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-mask-hole-reveal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,QAAQ,GAAG,SAAS,CAAC;AAYzD,0GAA0G;AAC1G,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CASpF;AAED,sFAAsF;AACtF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAS1F;AAED,4GAA4G;AAC5G,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CASlE;AAED,0EAA0E;AAC1E,wBAAgB,wBAAwB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAS1E"}

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

@@ -0,0 +1,80 @@
+/**
+ * `animation-mask-reveal`: CSS `mask`-based reveal states for the clip family
+ * of entrance/exit effects (wipe, peek, blinds, split, box, random bars).
+ *
+ * These effects used to animate `clip-path: inset(...)`, but the element
+ * container ALSO carries its shape geometry as a `clip-path` (a parallelogram,
+ * a freeform outline, an image crop). A CSS animation's `clip-path` keyframe
+ * REPLACES that inline geometry for the whole animation, so a thin diagonal
+ * stripe wiped in as its full BOUNDING BOX: a huge filled rectangle "blob"
+ * until the animation ended. A CSS `mask` composites WITH `clip-path` instead
+ * of replacing it, so the reveal sweeps the actual painted shape.
+ *
+ * Each reveal is a hard-stop gradient mask sized at 2x the element on the
+ * travel axis; only `mask-position` animates between the hidden and shown
+ * states, which browsers interpolate smoothly.
+ *
+ * @module render/animation-mask-reveal
+ */
+import type { BlindsDirection, CheckerboardDirection, RandomBarsDirection } from './animation-presets-subtypes.js';
+/** The edge a reveal grows FROM (the first part of the element to appear). */
+export type RevealEdge = 'left' | 'right' | 'top' | 'bottom';
+/**
+ * Non-directional reveal shapes. `mask-size` animates instead of the position:
+ *  - `splitHorizontalIn`: two bands growing from the top + bottom edges inward.
+ *  - `splitHorizontalOut`: one centred band growing outward vertically.
+ *  - `splitVerticalIn`: two bands growing from the left + right edges inward.
+ *  - `splitVerticalOut`: one centred band growing outward horizontally.
+ *  - `boxOut`: one centred rectangle growing outward on both axes.
+ *  - `circleOut`: one centred circle growing outward on both axes (the Circle
+ *    entrance/exit preset's iris-style reveal).
+ *  - `diamondOut`: one centred diamond (rotated square) growing outward on
+ *    both axes, for the `diamond` SMIL filter family.
+ *  - `plusOut`: a horizontal bar and a vertical bar, both centred, growing
+ *    outward simultaneously; their union traces a cross/plus shape from a
+ *    point at centre to full coverage, for the `plus` SMIL filter family.
+ */
+export type MaskRevealShape = 'splitHorizontalIn' | 'splitHorizontalOut' | 'splitVerticalIn' | 'splitVerticalOut' | 'boxOut' | 'circleOut' | 'diamondOut' | 'plusOut';
+/** Kebab-case declaration list for a directional wipe keyframe stop. */
+export declare function maskEdgeDecl(edge: RevealEdge, phase: 'hidden' | 'shown'): string;
+/** Kebab-case declarations for a partially swept directional wipe (0..1). */
+export declare function maskEdgePartialDecl(edge: RevealEdge, revealedFraction: number): string;
+/** Kebab-case declaration list for a size-animated (split / box) stop. */
+export declare function maskShapeDecl(shape: MaskRevealShape, phase: 'hidden' | 'shown'): string;
+/**
+ * CamelCase inline-style map for a directional wipe's HIDDEN state, used to
+ * pre-seed an element before its entrance plays (mirrors the keyframe `from`).
+ */
+export declare function maskEdgeInitialStyle(edge: RevealEdge): Record<string, string | number>;
+/** CamelCase inline-style map for a split / box reveal's HIDDEN state. */
+export declare function maskShapeInitialStyle(shape: MaskRevealShape): Record<string, string | number>;
+/** Kebab-case declarations for a Blinds reveal (8 parallel bands) at a given fraction (0-1). */
+export declare function blindsDecl(direction: BlindsDirection, revealedFraction: number): string;
+/**
+ * Kebab-case declarations for a Random Bars reveal (16 thinner parallel
+ * bands) at a given fraction (0-1). See {@link bandRevealDecl}'s doc for why
+ * this is a directional band sweep rather than a genuinely randomised one.
+ */
+export declare function randomBarsBandDecl(direction: RandomBarsDirection, revealedFraction: number): string;
+/**
+ * Kebab-case declarations for a tiled checkerboard reveal at a given
+ * fraction (0-1), swept along `direction` ('across' = left-to-right, 'down'
+ * = top-to-bottom).
+ *
+ * Two identical 45deg diagonal-gradient tiles, offset by half a cell, union
+ * (`mask-composite: add`, the default combine mode) into solid alternating
+ * squares - the same construction commonly used for a checkerboard CSS
+ * background, applied here as a mask instead of a paint. A third mask layer
+ * (a plain directional wipe) then INTERSECTS that checkerboard shape, so
+ * only the squares within the swept region are visible.
+ */
+export declare function checkerboardDecl(direction: CheckerboardDirection, revealedFraction: number): string;
+/**
+ * Kebab-case declarations for a Wheel reveal at a given fraction (0-1):
+ * `spokeCount` pie-slice sectors, all growing simultaneously from their
+ * shared leading edge, via a hard-stop `repeating-conic-gradient`. Matches
+ * PowerPoint's "Spokes" Effect Option (1, 2, 3, 4, or 8; see
+ * `resolveWheelSpokeCount` in `animation-presets-subtypes.ts`).
+ */
+export declare function wheelDecl(spokeCount: number, revealedFraction: number): string;
+//# sourceMappingURL=animation-mask-reveal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-mask-reveal.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-mask-reveal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EACX,eAAe,EACf,qBAAqB,EACrB,mBAAmB,EACnB,MAAM,8BAA8B,CAAC;AAEtC,8EAA8E;AAC9E,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,QAAQ,CAAC;AA+C7D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,eAAe,GACxB,mBAAmB,GACnB,oBAAoB,GACpB,iBAAiB,GACjB,kBAAkB,GAClB,QAAQ,GACR,WAAW,GACX,YAAY,GACZ,SAAS,CAAC;AA8Eb,wEAAwE;AACxE,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CAIhF;AAED,6EAA6E;AAC7E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAYtF;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CAIvF;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAStF;AAED,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAS7F;AAwCD,gGAAgG;AAChG,wBAAgB,UAAU,CAAC,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAEvF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,mBAAmB,EAC9B,gBAAgB,EAAE,MAAM,GACtB,MAAM,CAER;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC/B,SAAS,EAAE,qBAAqB,EAChC,gBAAgB,EAAE,MAAM,GACtB,MAAM,CAeR;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAM9E"}

package/dist/pptx/render/animation-media-bookmark-gating.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `animation-media-bookmark-gating`: bridges a real `<audio>`/`<video>`
+ * element's live playback position to the {@link TimelineStep}s whose OOXML
+ * start condition is `p:cond/@evt="onMediaBookmark"` targeting a specific
+ * bookmark on that media element (`p14:bmkTgt`, an Office 2010 `p14`
+ * extension - see `PptxMediaBookmarkTarget` in `ooxml-core/pptx`).
+ *
+ * Mirrors `animation-media-end-gating.ts`'s shape (find gated steps, wire a
+ * real DOM listener, apply the step via the shared `applyMediaEndedStep`),
+ * but keys off the media element's `timeupdate` position crossing the
+ * bookmark's authored time instead of its `ended` event:
+ *
+ *  - {@link resolveMediaBookmarkTimesMs} builds an elementId -> bookmarkName
+ *    -> time(ms) lookup from the slide's own parsed elements, once per slide
+ *    load (`PlaybackContext.mediaBookmarkTimesMs`).
+ *  - {@link isBookmarkGated} / {@link findMediaBookmarkGatedSteps} identify
+ *    which of a click-group's steps wait on a bookmark.
+ *  - {@link wireMediaBookmarkSteps} attaches the real `timeupdate` listener,
+ *    firing the gated step (via `applyMediaEndedStep`, reused unchanged: the
+ *    real event IS the zero point either way) the first time playback
+ *    reaches the bookmark.
+ *
+ * A gated step's `EffectiveStartCondition` resolves to a zero, non-auto-firing
+ * delay (see `resolveEffectiveStartCondition`'s `onMediaBookmark` branch), so
+ * without a real media element to wire (export/headless, or a binding that
+ * has not populated `mediaBookmarkTimesMs`) the step simply never fires,
+ * rather than firing at the wrong time - the same trade-off this project
+ * already makes for an `onStopAudio` dependency with no real audio element.
+ *
+ * @module render/animation-media-bookmark-gating
+ */
+import type { PptxElement } from 'ooxml-core/pptx';
+import type { PlaybackContext } from './animation-playback-engine.js';
+import type { TimelineClickGroup, TimelineStep } from './animation-timeline-types.js';
+/**
+ * Build an elementId -> bookmarkName -> time(ms) lookup from a slide's own
+ * elements. Built once per slide load and passed as
+ * `PlaybackContext.mediaBookmarkTimesMs`, mirroring
+ * `animation-media-end-gating`'s `resolveMediaTimeNodeElementIds`.
+ */
+export declare function resolveMediaBookmarkTimesMs(elements: readonly PptxElement[] | undefined): ReadonlyMap<string, ReadonlyMap<string, number>>;
+/**
+ * Whether `step` waits for a SPECIFIC media element to reach a specific
+ * bookmark (`p:cond/@evt="onMediaBookmark"`), rather than resolving entirely
+ * from a fixed computed delay.
+ */
+export declare function isBookmarkGated(step: TimelineStep): boolean;
+/** Steps in `group` gated on a media bookmark. */
+export declare function findMediaBookmarkGatedSteps(group: TimelineClickGroup | null | undefined): TimelineStep[];
+/**
+ * Wire every bookmark-gated step in `group` to its real `<audio>`/`<video>`
+ * element's `timeupdate` event, firing the step (once) the first time
+ * playback crosses the bookmark's authored time. Called once per group
+ * application by `animation-playback-engine`'s `applyAnimationGroupSteps`; a
+ * context missing the media element, or `mediaBookmarkTimesMs`, or the named
+ * bookmark is a no-op (see the module doc for why that is the right
+ * trade-off).
+ */
+export declare function wireMediaBookmarkSteps(group: TimelineClickGroup, ctx: PlaybackContext): void;
+//# sourceMappingURL=animation-media-bookmark-gating.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-media-bookmark-gating.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-media-bookmark-gating.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EAAoB,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAIrE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAGnF;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,GAC1C,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiBlD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAM3D;AAED,kDAAkD;AAClD,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,GAC1C,YAAY,EAAE,CAKhB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CA0B5F"}

package/dist/pptx/render/animation-media-commands.d.ts

@@ -0,0 +1,65 @@
+/**
+ * `animation-media-commands` - pure helpers for OOXML `p:cmd` media playback
+ * commands in the timing tree. A `p:cmd` node (parsed onto
+ * {@link PptxNativeAnimation.commandString}) tells the player to drive a media
+ * element (play / pause / seek) at a point in the slide timeline. These helpers
+ * recognise the command, build the {@link TimelineStepCommand} carried on a
+ * timeline step, and parse the command string into a browser-actionable verb.
+ *
+ * Framework-agnostic: the actual DOM `HTMLMediaElement` control lives in each
+ * binding, which maps the parsed verb onto `play()` / `pause()` / `currentTime`.
+ *
+ * @module render/animation-media-commands
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { TimelineStepCommand } from './animation-timeline-types.js';
+/**
+ * Browser-actionable media command verbs we map from an OOXML `p:cmd` string.
+ *
+ * Deferred / unmapped forms (e.g. arbitrary `evt`/`verb` command strings with no
+ * media meaning) resolve to `undefined` from {@link parseMediaCommand} and the
+ * playback layer no-ops them.
+ */
+export type MediaCommandVerb = 'playFrom' | 'play' | 'pause' | 'stop' | 'togglePlay';
+/** Result of parsing a `p:cmd` command string into a media verb. */
+export interface ParsedMediaCommand {
+    /** The recognised verb. */
+    verb: MediaCommandVerb;
+    /**
+     * For `playFrom`, the seek target in seconds (OOXML encodes the argument in
+     * seconds, e.g. `playFrom(2.5)`). Defaults to `0` when absent or unparseable.
+     */
+    seekSeconds?: number;
+}
+/**
+ * True when a parsed native animation carries a non-empty `p:cmd` command
+ * string. Such nodes have no preset effect and would otherwise be dropped by the
+ * timeline builder; instead they become command steps.
+ */
+export declare function isMediaCommandAnimation(anim: PptxNativeAnimation): boolean;
+/**
+ * Build the {@link TimelineStepCommand} for a command animation, or `undefined`
+ * when the animation carries no command string.
+ */
+export declare function buildStepCommand(anim: PptxNativeAnimation): TimelineStepCommand | undefined;
+/**
+ * Parse an OOXML `p:cmd/@cmd` string into a browser-actionable media verb.
+ *
+ * Recognised forms (case-insensitive):
+ * - `playFrom(<seconds>)` -> seek to `<seconds>` then play.
+ * - `play` / `resume` -> resume playback.
+ * - `pause` -> pause playback.
+ * - `stop` / `stopMedia` -> pause and rewind to the start.
+ * - `togglePlay` / `togglePause` -> pause if playing, else play.
+ *
+ * `togglePause` is PowerPoint's own spelling: a video authored with "click to
+ * pause" emits `<p:cmd type="call" cmd="togglePause"/>` in its interactiveSeq,
+ * never `togglePlay`. Both name the same two-way toggle, so they map to one
+ * verb; missing the alias made clicking such a video silently do nothing.
+ *
+ * Any other command string (including non-media `evt` / `verb` commands, or a
+ * numeric verb code with no browser analogue) returns `undefined` so the caller
+ * can no-op it.
+ */
+export declare function parseMediaCommand(commandString: string): ParsedMediaCommand | undefined;
+//# sourceMappingURL=animation-media-commands.d.ts.map

package/dist/pptx/render/animation-media-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-media-commands.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-media-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,YAAY,CAAC;AAErF,oEAAoE;AACpE,MAAM,WAAW,kBAAkB;IAClC,2BAA2B;IAC3B,IAAI,EAAE,gBAAgB,CAAC;IACvB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAE1E;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,mBAAmB,GAAG,mBAAmB,GAAG,SAAS,CAU3F;AA4CD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CA0BvF"}

package/dist/pptx/render/animation-media-end-gating.d.ts

@@ -0,0 +1,114 @@
+/**
+ * `animation-media-end-gating`: bridges a real `<audio>`/`<video>` element's
+ * `ended` DOM event to the {@link TimelineStep}s whose OOXML start condition
+ * is `p:cond/@evt="onStopAudio"` targeting that SPECIFIC media element,
+ * whether named by time-node id (`@_tn`, `dependsOnTimeNodeId`) or by shape
+ * (`p:tgtEl/p:spTgt`, `dependsOnShapeId`) - `CT_TLTimeCondition` (ECMA-376
+ * S19.5.28/19.5.31) allows either as an alternative way to say "this specific
+ * one" - rather than the estimated-duration delay `animation-timeline-builder`
+ * bakes into `TimelineStep.delayMs` (and into `TimelineStep.cssAnimation`'s
+ * own `animation-delay`) as a fallback.
+ *
+ * PowerPoint's own duration for the referenced audio node is only an ESTIMATE
+ * of how long the clip actually plays: a variable-length or `p14:trim`med
+ * file desyncs the follow-on effect's start from real playback. This module
+ * gives a binding what it needs to fire the dependent step's CSS the moment
+ * the real media element fires `ended`, instead of waiting out (or firing too
+ * early relative to) that estimate:
+ *
+ *  - {@link findMediaEndGatedSteps} finds which of a click-group's steps wait
+ *    on a specific media node.
+ *  - {@link zeroDelayCssAnimation} rewrites a step's pre-built `cssAnimation`
+ *    shorthand to start immediately (the real event IS the zero point), since
+ *    the string was built with the ESTIMATED delay baked in.
+ *  - {@link applyMediaEndedStep} applies that corrected step onto the same
+ *    `PlaybackContext` state map `animation-playback-engine`'s
+ *    `applyAnimationGroupSteps` uses, and schedules its own correctly-timed
+ *    cleanup.
+ *
+ * A binding still schedules the ordinary fallback timer from `delayMs`
+ * (`applyAnimationGroupSteps` already does this unconditionally) for
+ * headless/export contexts with no real media element; `applyMediaEndedStep`
+ * is additive, correcting the effect to the ACTUAL completion time when a
+ * real `<audio>`/`<video>` element does exist.
+ *
+ * @module render/animation-media-end-gating
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { PlaybackContext } from './animation-playback-engine.js';
+import type { TimelineClickGroup, TimelineStep } from './animation-timeline-types.js';
+/**
+ * Whether `step` waits for a SPECIFIC media element's real completion
+ * (`p:cond/@evt="onStopAudio"` naming its dependency by either `@tn`
+ * (`dependsOnTimeNodeId`) or `p:tgtEl/p:spTgt` (`dependsOnShapeId`)), rather
+ * than resolving entirely from a fixed computed delay.
+ */
+export declare function isMediaEndGated(step: TimelineStep): boolean;
+/**
+ * Steps in `group` gated on the given media time node id's real completion.
+ * A binding calls this from the corresponding `<audio>`/`<video>` element's
+ * `ended` handler (matched by that media's own timeline node id) to apply
+ * those steps immediately via {@link zeroDelayCssAnimation}, rather than
+ * waiting out (or racing) the pre-computed `delayMs` estimate.
+ *
+ * Only matches the `@tn` (time-node id) dependency form; a `p:tgtEl/p:spTgt`
+ * (shape id) dependency is resolved directly by {@link wireMediaEndedSteps}
+ * without going through a node-id lookup, so it has no equivalent id to pass
+ * here.
+ */
+export declare function findMediaEndGatedSteps(group: TimelineClickGroup | null | undefined, mediaNodeId: number): TimelineStep[];
+/**
+ * Rewrite every comma-joined segment of a `cssAnimation` shorthand's DELAY
+ * token to `0ms`: the real `ended` event that triggered this call IS the
+ * zero point, so the ESTIMATED delay baked in at build time no longer
+ * applies. A segment that does not match the expected 7-token shape (should
+ * not happen for a generated `cssAnimation`, but a defensive fallback matters
+ * more than a crash here) is returned unchanged.
+ */
+export declare function zeroDelayCssAnimation(cssAnimation: string): string;
+/**
+ * Apply a single `onStopAudio`-gated step's CSS the moment the media node it
+ * depends on REALLY finishes, rather than the estimated `delayMs` baked into
+ * `step.cssAnimation` at build time. A binding calls this from the
+ * corresponding `<audio>`/`<video>` element's `ended` handler (steps found
+ * via {@link findMediaEndGatedSteps}).
+ *
+ * `animation-playback-engine`'s `applyAnimationGroupSteps` already scheduled
+ * this same step's normal (estimate-based) apply + cleanup unconditionally as
+ * the fallback for a context with no real media element (export/headless);
+ * this call is additive, correcting the effect to the ACTUAL completion time
+ * when a real element does exist, using {@link zeroDelayCssAnimation} since
+ * the real event IS the zero point.
+ */
+/**
+ * Wire every media-end-gated step in `group` to its real `<audio>`/`<video>`
+ * element's `ended` event. The target element is resolved one of two ways,
+ * matching the OOXML choice `p:cond` makes between `@tn` and `p:tgtEl`:
+ *
+ *  - {@link TimelineStep.dependsOnShapeId} (`p:tgtEl/p:spTgt`): resolved
+ *    DIRECTLY by `data-element-id` via {@link findMediaElementByElementId},
+ *    scoped to `ctx.frameRoot`. No per-slide map needed since the shape id
+ *    already names the element.
+ *  - {@link TimelineStep.dependsOnTimeNodeId} (`@tn`): looked up through
+ *    `ctx.mediaTimeNodeElementIds` (see {@link resolveMediaTimeNodeElementIds})
+ *    first, since a time-node id is not itself an element id.
+ *
+ * Called once per group application by `animation-playback-engine`'s
+ * `applyAnimationGroupSteps`; a context with no real media element for the
+ * dependency (export/headless, an unmounted element, or
+ * `mediaTimeNodeElementIds` omitted for the `@tn` form) is a no-op, leaving
+ * the estimate-based fallback as the only trigger.
+ */
+export declare function wireMediaEndedSteps(group: TimelineClickGroup, ctx: PlaybackContext): void;
+/**
+ * Map each `p:audio`/`p:video` animation's OWN timing-tree node id
+ * (`p:cTn/@id`) to the element id (shape id) it plays, from the slide's
+ * parsed native animations. Built once per slide load and passed as
+ * `PlaybackContext.mediaTimeNodeElementIds`, so {@link wireMediaEndedSteps}
+ * can resolve a `dependsOnTimeNodeId` back to the REAL DOM element to listen
+ * for `ended` on (via `findMediaElementByElementId`'s `data-element-id`
+ * lookup, exactly like the `p:cmd` media-command resolver already uses).
+ */
+export declare function resolveMediaTimeNodeElementIds(animations: readonly PptxNativeAnimation[]): ReadonlyMap<number, string>;
+export declare function applyMediaEndedStep(step: TimelineStep, ctx: PlaybackContext): void;
+//# sourceMappingURL=animation-media-end-gating.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-media-end-gating.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-media-end-gating.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAGnF;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAK3D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,EAC5C,WAAW,EAAE,MAAM,GACjB,YAAY,EAAE,CAOhB;AAaD;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAalE;AAED;;;;;;;;;;;;;GAaG;AACH;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAezF;AAED;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAC7C,UAAU,EAAE,SAAS,mBAAmB,EAAE,GACxC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAQ7B;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,EAAE,GAAG,EAAE,eAAe,GAAG,IAAI,CAgClF"}

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

@@ -0,0 +1,78 @@
+/**
+ * `animation-media-playback` - the DOM half of OOXML `p:cmd` media commands.
+ *
+ * {@link ./animation-media-commands} recognises and parses a `p:cmd` node into a
+ * {@link ParsedMediaCommand}; this module applies that verb to a real
+ * `<video>` / `<audio>` node during slide-show playback.
+ *
+ * WHY it is shared even though it touches the DOM: only the *lookup* of the
+ * target node is per-binding (React keeps a shapeId -> node registry populated
+ * by its media renderer; the other four query the live stage by
+ * `data-element-id`). The verb mapping itself (play / pause / stop / seek, plus
+ * swallowing the promise rejection from a blocked autoplay and the
+ * `InvalidStateError` from seeking a not-yet-seekable element) is identical
+ * everywhere, and was copied five times before this module existed. Callers
+ * inject their lookup via {@link runMediaCommand}; the common `data-element-id`
+ * lookup is provided here as {@link findMediaElementByElementId}.
+ *
+ * @module render/animation-media-playback
+ */
+import type { ParsedMediaCommand } from './animation-media-commands.js';
+import type { TimelineStepCommand } from './animation-timeline-types.js';
+/** Resolves a timeline command's `targetId` to the media node it drives. */
+export type MediaElementResolver = (targetId: string) => HTMLMediaElement | null | undefined;
+/**
+ * Apply a parsed media verb to a media element.
+ *
+ * Both side effects are deliberately guarded: `play()` returns a promise that
+ * rejects when autoplay policy blocks it or the element is not ready, and
+ * assigning `currentTime` throws while the element has no seekable range. A
+ * slide show must not surface either as an unhandled error, so both degrade to
+ * a no-op.
+ *
+ * @returns `true` when the verb was applied.
+ */
+export declare function applyMediaCommandVerb(el: HTMLMediaElement, parsed: ParsedMediaCommand): boolean;
+/**
+ * Find the `<video>` / `<audio>` for an element id by walking `data-element-id`
+ * wrappers under `root`.
+ *
+ * The id may sit on the media node itself or on the wrapper a binding renders
+ * around it, so both shapes are accepted. Pass the slide stage as `root` where
+ * possible: the thumbnail rail and the off-screen export stage carry the same
+ * element ids, and a document-wide lookup can therefore hit the wrong copy.
+ *
+ * Returns `undefined` outside a DOM (SSR / node tests) rather than throwing.
+ */
+export declare function findMediaElementByElementId(targetId: string, root?: ParentNode | null): HTMLMediaElement | undefined;
+/**
+ * Run a timeline media command against whatever node `resolve` hands back.
+ *
+ * @returns `false` when the target cannot be resolved or the command string has
+ * no browser mapping, so the caller can treat the step as a no-op.
+ */
+export declare function runMediaCommand(command: TimelineStepCommand, resolve: MediaElementResolver): boolean;
+/**
+ * Run a timeline media command against the live DOM, resolving the target by
+ * `data-element-id`. The default for bindings without an element registry.
+ *
+ * @param frameRoot - Lazily resolves the slide stage to scope the lookup to;
+ * omit to search the whole document.
+ */
+export declare function executeMediaCommandInDom(command: TimelineStepCommand, frameRoot?: () => HTMLElement | null): boolean;
+/**
+ * `ppaction://media`: toggle play/pause on the `<video>` / `<audio>` embedded
+ * in `elementId`'s rendered subtree, scoped to `root` (the presentation stage).
+ *
+ * A click carrying this action targets the CLICKED element's own media, as
+ * opposed to a `media` element's normal inline transport controls. A missing
+ * element, or one carrying no playable media, is a silent no-op.
+ *
+ * Every binding's action runner calls this; it deliberately resolves the node
+ * through {@link findMediaElementByElementId} (an attribute compare) rather
+ * than splicing the id into a selector string, so an id never needs escaping.
+ *
+ * @returns `true` when a media element was found and toggled.
+ */
+export declare function toggleStageElementMedia(root: ParentNode | null | undefined, elementId: string | undefined): boolean;
+//# sourceMappingURL=animation-media-playback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-media-playback.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-media-playback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AACrE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,4EAA4E;AAC5E,MAAM,MAAM,oBAAoB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,gBAAgB,GAAG,IAAI,GAAG,SAAS,CAAC;AAE7F;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,gBAAgB,EAAE,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAuC/F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAC1C,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,UAAU,GAAG,IAAI,GACtB,gBAAgB,GAAG,SAAS,CAqB9B;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC9B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,oBAAoB,GAC3B,OAAO,CAUT;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACvC,OAAO,EAAE,mBAAmB,EAC5B,SAAS,CAAC,EAAE,MAAM,WAAW,GAAG,IAAI,GAClC,OAAO,CAIT;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACtC,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EACnC,SAAS,EAAE,MAAM,GAAG,SAAS,GAC3B,OAAO,CAST"}

package/dist/pptx/render/animation-motion-chain-keyframes.d.ts

@@ -0,0 +1,16 @@
+import type { ChainedMotionAnimation } from './animation-motion-path-chain.js';
+import type { AnimationElementBox } from './animation-render-context.js';
+import type { TransformKeyframePrefixes } from './animation-transform-keyframes.js';
+/**
+ * Build one `@keyframes` block covering a whole chained journey. Waypoints
+ * land at their authored TIME positions: each segment keeps its own duration
+ * and accel/decel easing, and a gap between segments holds the last reached
+ * position via duplicated keyframes. Duplicate progress values (segment
+ * joints whose endpoints disagree slightly) resolve by last-wins, matching
+ * CSS's own duplicate-keyframe rule.
+ */
+export declare function buildChainedMotionKeyframes(anim: ChainedMotionAnimation, uid: number, prefixes: TransformKeyframePrefixes, box?: AnimationElementBox): {
+    keyframeName: string;
+    css: string;
+} | undefined;
+//# sourceMappingURL=animation-motion-chain-keyframes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-motion-chain-keyframes.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-motion-chain-keyframes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC;AAE5E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;AAEjF;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAC1C,IAAI,EAAE,sBAAsB,EAC5B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,yBAAyB,EACnC,GAAG,CAAC,EAAE,mBAAmB,GACvB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA6DnD"}

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

@@ -0,0 +1,91 @@
+/**
+ * `animation-motion-path-chain` - chained (`p:animMotion` sequence) motion
+ * paths: merging same-target path segments and playing them as ONE continuous
+ * choreography.
+ *
+ * PowerPoint decks frequently express one continuous journey (a crane picking
+ * an object up, carrying it across, and setting it down) as SEVERAL
+ * `presetClass: "path"` effects on the SAME shape, timed back-to-back inside
+ * one sequence (each with its own effect-wrapper offset via
+ * `parGroupDelayMs`). All segments share ONE reference frame: slide-fraction
+ * offsets from the shape's own layout position (`pathEditMode="relative"`,
+ * `origin="layout"`), which is exactly the frame a CSS `translate()` applied
+ * to that shape speaks.
+ *
+ * Played naively as separate per-segment CSS animations the journey breaks in
+ * two ways:
+ * 1. The playback engine keeps one CSS animation per element (later steps
+ *    replace earlier ones in its element-state map), so only the LAST
+ *    segment's keyframes ever attach.
+ * 2. With `animation-fill-mode: both` (the `path` default) that last
+ *    segment's 0% frame shows during its whole `animation-delay`, so the
+ *    shape teleports to that segment's start offset the moment the click
+ *    fires and sits there frozen.
+ *
+ * The fix here merges each run of same-target path segments into a single
+ * synthetic animation whose keyframes cover the whole journey: waypoints land
+ * at their AUTHORED time positions (each segment keeps its own duration and
+ * accel/decel easing), and the 0% frame is the first segment's own start
+ * offset - which deck authors place at the shape's resting spot, so the
+ * pre-delay freeze shows the shape standing still, as authored, instead of
+ * teleporting.
+ *
+ * @module render/animation-motion-path-chain
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { MotionPoint } from './animation-motion-path.js';
+export { buildChainedMotionKeyframes } from './animation-motion-chain-keyframes.js';
+/** One authored path segment inside a merged chain, in authored time. */
+export interface ChainedMotionSegment {
+    /** Parsed waypoints, in the shared slide-fraction offset frame. */
+    points: MotionPoint[];
+    /** Authored start offset (ms) from the chain window's start. */
+    startMs: number;
+    /** Authored active duration (ms) of this segment. */
+    durationMs: number;
+    /** CSS timing function for this segment (from its authored accel/decel). */
+    easing: string;
+}
+/** A synthetic path animation carrying its merged segment breakdown. */
+export interface ChainedMotionAnimation extends PptxNativeAnimation {
+    /** Segment breakdown consumed by `buildChainedMotionKeyframes`. Render-only. */
+    motionChain?: ChainedMotionSegment[];
+    /** True for the members a merge consumed into a chain head. */
+    motionChainSwallowed?: boolean;
+    /**
+     * True when the same sequence holds an authored EXIT for this element at
+     * (or before) the chain start: the element is hidden by that exit and must
+     * stay hidden (via the chain keyframes' leading `opacity: 0`) until the
+     * journey's own start, then pop in exactly as the first segment begins.
+     */
+    motionChainHideUntilStart?: boolean;
+}
+export declare function isChainedMotionAnimation(anim: PptxNativeAnimation): anim is ChainedMotionAnimation;
+export declare function isChainedMotionSwallowed(anim: PptxNativeAnimation): boolean;
+/**
+ * Merge same-target path animations into chained synthetic animations,
+ * preserving array order and leaving swallowed members in place (flagged) so
+ * callers can skip them without disturbing their own prevStep bookkeeping.
+ *
+ * A run qualifies when every member:
+ *
+ * - is `presetClass: "path"` with an actual `motionPath`,
+ * - resolves to the same element id,
+ * - carries an absolute effect-wrapper offset (`parGroupDelayMs`), so removal
+ *   cannot disturb the prevStep delay chaining other animations rely on,
+ * - carries none of the extras the chain keyframes cannot reproduce,
+ * - and (except for the run's head) is NOT `onClick`-triggered, so a chain
+ *   can never collapse two click groups into one.
+ *
+ * Segments carrying animation SOUNDS still merge: their motion is consumed
+ * into the chain, and the builder emits each swallowed member's sound as a
+ * sound-only timeline step timed at the segment's own start, so the crane's
+ * move / drop cues keep firing at the authored moments.
+ *
+ * Runs need not be adjacent in the array (decks interleave other shapes'
+ * effects between one shape's segments); members are ordered by their
+ * authored wrapper offsets inside the run. Gaps between segments are fine -
+ * the keyframes hold the last reached position across them.
+ */
+export declare function mergeChainedMotionPathAnims(anims: readonly PptxNativeAnimation[]): PptxNativeAnimation[];
+//# sourceMappingURL=animation-motion-path-chain.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-motion-path-chain.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-motion-path-chain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAK3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAG3D,OAAO,EAAE,2BAA2B,EAAE,MAAM,oCAAoC,CAAC;AAEjF,yEAAyE;AACzE,MAAM,WAAW,oBAAoB;IACpC,mEAAmE;IACnE,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;CACf;AAED,wEAAwE;AACxE,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IAClE,gFAAgF;IAChF,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACrC,+DAA+D;IAC/D,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;OAKG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,wBAAgB,wBAAwB,CACvC,IAAI,EAAE,mBAAmB,GACvB,IAAI,IAAI,sBAAsB,CAEhC;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAE3E;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,SAAS,mBAAmB,EAAE,GACnC,mBAAmB,EAAE,CAgIvB"}

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

@@ -0,0 +1,24 @@
+/**
+ * `animation-motion-path-paced` - constant-speed travel along a sampled
+ * motion path.
+ *
+ * `p:animMotion` moves at an even speed along the path's length (SMIL's
+ * default `calcMode="paced"` for motion), not an even share of time per
+ * sampled point. Measured on PowerPoint's Arc Up entrance (CreateVideo, a
+ * 200 px square, 2 s): 1.3 s in, the eased progress is 0.85 and the shape
+ * sits just past the end of the third of four curve segments, which ends at
+ * 84% of the path's length but at 75% of its point count.
+ *
+ * Path coordinates are fractions of the slide's width (x) and height (y), so
+ * the length is measured with x scaled by the slide aspect ratio.
+ *
+ * @module render/animation-motion-path-paced
+ */
+import type { MotionPoint } from './animation-motion-path.js';
+/** Default slide aspect (16:9) when the caller does not know the real one. */
+export declare const DEFAULT_SLIDE_ASPECT: number;
+/** Cumulative length fraction (0..1) at each point; all zeros for a zero-length path. */
+export declare function pacedFractions(points: ReadonlyArray<MotionPoint>, aspect?: number): number[];
+/** The point `progress` (0..1) of the way along the path by length. */
+export declare function pacedPointAt(points: ReadonlyArray<MotionPoint>, fractions: ReadonlyArray<number>, progress: number): MotionPoint;
+//# sourceMappingURL=animation-motion-path-paced.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-motion-path-paced.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-motion-path-paced.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,8EAA8E;AAC9E,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAE3C,yFAAyF;AACzF,wBAAgB,cAAc,CAC7B,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,EAClC,MAAM,GAAE,MAA6B,GACnC,MAAM,EAAE,CAaV;AAED,uEAAuE;AACvE,wBAAgB,YAAY,CAC3B,MAAM,EAAE,aAAa,CAAC,WAAW,CAAC,EAClC,SAAS,EAAE,aAAa,CAAC,MAAM,CAAC,EAChC,QAAQ,EAAE,MAAM,GACd,WAAW,CAoBb"}