ooxml-ui 0.30.1 → 1.0.0

package/dist/pptx/render/animation-behavior-values.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `animation-behavior-values` - the value one `p:anim` behaviour contributes
+ * at a given progress, following PowerPoint's formula semantics (see
+ * `animation-ppt-formula-ground-truth.md`): `#ppt_x`/`#ppt_y` are the shape's
+ * authored CENTRE and `#ppt_w`/`#ppt_h` its size, all as slide fractions and
+ * all constant for the effect; a `p:tav/@fmla` transforms `$`, the value
+ * interpolated between that stop's own `p:val` and the next one's.
+ *
+ * Without the `#`, `ppt_x`... name the attribute's value when the behaviour
+ * STARTS. Boomerang's exit shrinks the width to `ppt_w*.05` over its first
+ * half, then ramps `ppt_w` -> `ppt_w/.05`; PowerPoint's video shows the
+ * second half growing from that sliver back to full width (14 px wide one
+ * second in), not snapping back to `#ppt_w` and on to twenty times it.
+ *
+ * @module render/animation-behavior-values
+ */
+import type { PptxAnimBehavior } from 'ooxml-core/pptx';
+import type { PptFormulaVars } from './animation-ppt-formula.js';
+/** A resolved behaviour value: a number, or a discrete string (`visible`). */
+export type BehaviorValue = number | string;
+/** Variable prefix a `#ppt_*` (authored) reference is rewritten to. */
+export declare const AUTHORED_VAR_PREFIX = "orig_";
+/**
+ * Evaluate a behaviour formula: `#ppt_x` reads `orig_ppt_x` (the authored
+ * geometry), a bare `ppt_x` reads `ppt_x` (the value at the behaviour's start).
+ */
+export declare function evaluateBehaviorFormula(formula: string, vars: PptFormulaVars): number | undefined;
+/** Whether the behaviour's value can be resolved at all (every stop/formula parses). */
+export declare function isResolvableAnim(behavior: PptxAnimBehavior, vars: PptFormulaVars): boolean;
+/**
+ * The value a `p:anim` produces at `progress` (already eased), given the
+ * attribute's `underlying` value (what lower-priority behaviours left).
+ */
+export declare function animValueAt(behavior: PptxAnimBehavior, progress: number, underlying: BehaviorValue | undefined, vars: PptFormulaVars): BehaviorValue | undefined;
+//# sourceMappingURL=animation-behavior-values.d.ts.map

package/dist/pptx/render/animation-behavior-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-behavior-values.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-behavior-values.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAyB,MAAM,iBAAiB,CAAC;AAE/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAG9D,8EAA8E;AAC9E,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,CAAC;AAQ5C,uEAAuE;AACvE,eAAO,MAAM,mBAAmB,UAAU,CAAC;AAE3C;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAKjG;AAiFD,wFAAwF;AACxF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,cAAc,GAAG,OAAO,CAe1F;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAC1B,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,aAAa,GAAG,SAAS,EACrC,IAAI,EAAE,cAAc,GAClB,aAAa,GAAG,SAAS,CA4B3B"}

package/dist/pptx/render/animation-bookmark-trigger.d.ts

@@ -0,0 +1,49 @@
+/**
+ * `animation-bookmark-trigger`: the "On bookmark" trigger picker every
+ * binding's animation panel shows.
+ *
+ * An effect with `trigger: 'onMediaBookmark'` waits for a media element on the
+ * slide to reach one of its bookmarks (`MediaPptxElement.bookmarks`). The
+ * picker is a single `<select>` whose options are every (media element,
+ * bookmark) pair on the slide; each option's value packs both halves so a
+ * binding only ever maps {@link listMediaBookmarkOptions} onto `<option>`s and
+ * hands the chosen value back to {@link setTriggerBookmark}.
+ *
+ * @module render/animation-bookmark-trigger
+ */
+import type { PptxElement, PptxElementAnimation } from 'ooxml-core/pptx';
+/** One entry of the bookmark `<select>`. */
+export interface MediaBookmarkOption {
+    /** Opaque `<option value>`: pass it back to {@link setTriggerBookmark}. */
+    value: string;
+    /** The media element the bookmark belongs to. */
+    mediaId: string;
+    /** The bookmark's name. */
+    bookmarkName: string;
+    /**
+     * Display text: the bookmark name, prefixed with the media element's name
+     * when the slide has more than one media element with bookmarks.
+     */
+    label: string;
+}
+/** Pack a media element id and bookmark name into an option value. */
+export declare function bookmarkOptionValue(mediaId: string, bookmarkName: string): string;
+/** Unpack an option value, or `undefined` for an empty / malformed one. */
+export declare function parseBookmarkOptionValue(value: string): {
+    mediaId: string;
+    bookmarkName: string;
+} | undefined;
+/** Every (media element, bookmark) pair on a slide, in slide order. */
+export declare function listMediaBookmarkOptions(elements: readonly PptxElement[] | undefined): MediaBookmarkOption[];
+/** The option value an animation's current bookmark trigger selects ('' for none). */
+export declare function selectedBookmarkOptionValue(anim: PptxElementAnimation | undefined): string;
+/**
+ * The fields a bookmark picker choice sets: trigger `onMediaBookmark` plus the
+ * media element and bookmark. An empty value clears the bookmark but keeps the
+ * trigger, so the picker can show "Select a bookmark" again. For bindings that
+ * patch one animation entry instead of the whole list.
+ */
+export declare function bookmarkTriggerPatch(optionValue: string): Pick<PptxElementAnimation, 'trigger' | 'triggerShapeId' | 'triggerBookmark'>;
+/** {@link bookmarkTriggerPatch} applied to an element's entry in the list. */
+export declare function setTriggerBookmark(anims: readonly PptxElementAnimation[], elementId: string, optionValue: string): PptxElementAnimation[];
+//# sourceMappingURL=animation-bookmark-trigger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-bookmark-trigger.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-bookmark-trigger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAoB,WAAW,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAQ3F,4CAA4C;AAC5C,MAAM,WAAW,mBAAmB;IACnC,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAC;IACd,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;CACd;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAEjF;AAED,2EAA2E;AAC3E,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,MAAM,GACX;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAMvD;AAED,uEAAuE;AACvE,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAAG,SAAS,GAC1C,mBAAmB,EAAE,CAgBvB;AAED,sFAAsF;AACtF,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,GAAG,MAAM,CAK1F;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CACnC,WAAW,EAAE,MAAM,GACjB,IAAI,CAAC,oBAAoB,EAAE,SAAS,GAAG,gBAAgB,GAAG,iBAAiB,CAAC,CAO9E;AAED,8EAA8E;AAC9E,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,SAAS,oBAAoB,EAAE,EACtC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GACjB,oBAAoB,EAAE,CAExB"}

package/dist/pptx/render/animation-bounce-end.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `animation-bounce-end`: PowerPoint's "Bounce end" effect option
+ * (`p:anim/@p14:bounceEnd`, mirrored on `p:cTn/@p14:presetBounceEnd`),
+ * fitted to PowerPoint's own frames.
+ *
+ * ## Ground truth
+ *
+ * COM exposes the option as `Effect.Timing.BounceEnd` +
+ * `BounceEndIntensity`; setting intensity `k` makes PowerPoint write
+ * `p14:bounceEnd="k * 100000"` on each position `p:anim` of a Fly In. Decks
+ * authored that way (k = 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.75, 0.9; 2s, plus 3s
+ * at k = 0.5) were exported with `CreateVideo` at 1080p / 62.5fps and the
+ * shape's edge tracked per frame. What that measured:
+ *
+ *  - `bounceEnd` is the fraction of the duration spent BOUNCING, at the end.
+ *    The travel is the plain linear ramp compressed into the first `1 - k`
+ *    (the fitted slope matched `1 / (1 - k)` to four digits at every k); the
+ *    earlier reading here (travel ENDS at `k`) was backwards.
+ *  - The settle is a damped oscillation about the end value (overshooting in
+ *    the direction of travel first), scale-free in time: the 3s capture
+ *    matched the 2s one in settle-phase units. Its shape depends on `k` only:
+ *    `x(s) = r v0 / w * exp(-l s) * sin(w s)` in units of the travel distance,
+ *    with `s` the 0-1 settle-phase progress, `v0 = k / (1 - k)` the arrival
+ *    speed (so the curve leaves the ramp without a kink), and `w`, `l`, `r`
+ *    low-order polynomials in `k` ({@link BOUNCE_FIT}). A global least-squares
+ *    fit over every capture leaves an RMS error of 0.0011 of the travel (worst
+ *    sample 0.0036; per-k fits reach 0.0005, the pixel quantisation); the
+ *    previous hand-tuned curve was off by 0.04 to 0.07.
+ *
+ * @module render/animation-bounce-end
+ */
+/** Fitted coefficients (see the module doc). */
+export declare const BOUNCE_FIT: {
+    /** Angular frequency in settle-phase units: `w = a + b k + c k^2`. */
+    readonly omega: readonly [7.7846, 3.1207, 10.7958];
+    /** Decay rate in settle-phase units: `l = a + b k + c k^2`. */
+    readonly decay: readonly [2.7423, 5.3818, -1.5095];
+    /** Launch speed relative to the arrival speed: `r = a + b k`. */
+    readonly speed: readonly [0.8644, 0.0936];
+};
+/** `% stops` generated across the settle phase, enough for ~6 half-swings. */
+export declare const BOUNCE_SETTLE_SAMPLES = 32;
+/** Clamp an authored `bounceEnd` fraction to the modelled range. */
+export declare function normalizeBounceEnd(bounceEnd: number): number;
+/** Local progress (0-1) at which the travel ends and the settle begins. */
+export declare function bounceSettleStart(bounceEnd: number): number;
+/**
+ * Signed displacement from the end value, in units of the travel distance,
+ * `s` (0-1) into the settle phase. Positive is past the end value. The last
+ * stretch is faded out so the value lands exactly on the end value at `s = 1`.
+ */
+export declare function bounceSettleOffset(bounceEnd: number, s: number): number;
+/**
+ * Progress along a start-to-end ramp (0 = start, 1 = end, beyond 1 =
+ * overshoot) at `localProgress` of a behaviour carrying `bounceEnd`.
+ */
+export declare function bounceEndProgress(bounceEnd: number, localProgress: number): number;
+//# sourceMappingURL=animation-bounce-end.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-bounce-end.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-bounce-end.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,gDAAgD;AAChD,eAAO,MAAM,UAAU;IACtB,sEAAsE;aACtE,KAAK,YAAG,MAAM,EAAE,MAAM,EAAE,OAAO;IAC/B,+DAA+D;aAC/D,KAAK,YAAG,MAAM,EAAE,MAAM,EAAE,CAAC,MAAM;IAC/B,iEAAiE;aACjE,KAAK,YAAG,MAAM,EAAE,MAAM;CACb,CAAC;AAaX,8EAA8E;AAC9E,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAMxC,oEAAoE;AACpE,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAUvE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAQlF"}

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

@@ -0,0 +1,79 @@
+/**
+ * `animation-build`: staged-build (`p:bldChart` / `p:bldDgm`) resolution for
+ * the native-animation timeline. Maps the parsed OOXML build tokens carried on
+ * a {@link PptxNativeAnimation} to the normalized {@link StepBuildDescriptor}
+ * mode, plus the pure time->progress and progress->count helpers a staged
+ * chart / SmartArt renderer needs. Framework-free, no DOM.
+ *
+ * @module render/animation-build
+ */
+import type { PptxNativeAnimation } from 'ooxml-core/pptx';
+import type { ChartBuildMode, DiagramBuildMode, ElementAnimationState, StepBuildDescriptor, TimelineStep } from './animation-timeline-types.js';
+/** Options controlling how staged-build progress is resolved onto a state. */
+export interface ElementBuildStateOptions {
+    /**
+     * Milliseconds elapsed since the revealing step's click-group started. When
+     * provided, a staged-build element's `build.progress` is computed from the
+     * step's delay/duration at this time; when omitted, `progress` is `1` (the
+     * build is treated as fully revealed, matching discrete click semantics).
+     */
+    elapsedMs?: number;
+}
+/**
+ * Map a chart build token (`a:bldChart/@bld` or `p:bldOleChart/@bld`) to the
+ * normalized {@link ChartBuildMode}. Unknown tokens fall back to `asOne` so an
+ * unrecognised build never staggers unexpectedly.
+ */
+export declare function resolveChartBuildMode(token: string | undefined): ChartBuildMode;
+/**
+ * Map a diagram build token to the normalized {@link DiagramBuildMode}. Handles
+ * both the `a:bldDgm/@bld` set (`allAtOnce`/`one`/`lvlOne`/`lvlAtOnce`) and the
+ * broader `p:bldDgm/@bld` set (`whole`, `depthBy*`, `breadthBy*`, directional
+ * traversals). `whole`/`allAtOnce` reveal at once; everything staged that is
+ * not an explicit level build reveals node-by-node (`byOne`).
+ */
+export declare function resolveDiagramBuildMode(token: string | undefined): DiagramBuildMode;
+/**
+ * Derive the static staged-build descriptor for a native animation from its
+ * parsed `graphicBuildProperties` (chart / diagram sub-builds) and
+ * `smartArtBuild` (`p:bldDgm/@bld`) fields.
+ *
+ * Returns `undefined` when the animation carries no staged build, or when the
+ * build resolves to a whole-element reveal (`asOne`) that a staged renderer
+ * would treat identically to the existing whole-element entrance, so callers
+ * only attach a descriptor when it actually changes reveal behaviour.
+ */
+export declare function resolveStepBuildDescriptor(anim: PptxNativeAnimation): StepBuildDescriptor | undefined;
+/**
+ * Compute the 0..1 build progress at a playback time.
+ *
+ * @param timing - The revealing step's `delayMs` (relative to its click-group
+ *   start) and `durationMs`.
+ * @param elapsedMs - Milliseconds elapsed since the click-group started.
+ * @returns 0 before the step's delay elapses, ramping linearly to 1 at
+ *   `delayMs + durationMs`. A non-positive duration snaps straight to 1.
+ */
+export declare function computeBuildProgress(timing: {
+    delayMs: number;
+    durationMs: number;
+}, elapsedMs: number): number;
+/**
+ * Map a 0..1 build progress to a whole number of revealed stages given the
+ * renderer's own stage COUNT (series / categories / levels / nodes).
+ *
+ * The reveal is inclusive at the leading edge: progress `0` reveals nothing,
+ * any progress above `0` reveals at least one stage, and progress `1` reveals
+ * every stage. A consumer treats the returned integer as "reveal the first N
+ * stages" for its build mode.
+ */
+export declare function revealedStageCount(progress: number, totalStages: number): number;
+/**
+ * Fold a revealing step's staged-build + colour-target + text-style
+ * descriptors onto an {@link ElementAnimationState}. Mutates `state` in
+ * place, adding `build` (with progress resolved at `options.elapsedMs`),
+ * `animatesFill`, `animatesStroke`, and `textStyle` only when the step
+ * actually carries those descriptors, so a plain whole-element entrance
+ * leaves the state untouched.
+ */
+export declare function applyStepBuildMetadata(state: ElementAnimationState, step: TimelineStep | undefined, options?: ElementBuildStateOptions): void;
+//# sourceMappingURL=animation-build.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-build.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,OAAO,KAAK,EACX,cAAc,EACd,gBAAgB,EAChB,qBAAqB,EACrB,mBAAmB,EACnB,YAAY,EACZ,MAAM,4BAA4B,CAAC;AAEpC,8EAA8E;AAC9E,MAAM,WAAW,wBAAwB;IACxC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAMD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,cAAc,CAc/E;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,CAcnF;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACzC,IAAI,EAAE,mBAAmB,GACvB,mBAAmB,GAAG,SAAS,CA0BjC;AAWD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CACnC,MAAM,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EAC/C,SAAS,EAAE,MAAM,GACf,MAAM,CAKR;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAShF;AAMD;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,qBAAqB,EAC5B,IAAI,EAAE,YAAY,GAAG,SAAS,EAC9B,OAAO,CAAC,EAAE,wBAAwB,GAChC,IAAI,CAoBN"}

package/dist/pptx/render/animation-circle-iris.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `animation-circle-iris`: the Circle EXIT (`presetID` 6,
+ * `p:animEffect filter="circle(in)" transition="out"`) as an iris closing on
+ * the box centre.
+ *
+ * Ground truth (PowerPoint 365, COM `AddEffect(msoAnimEffectCircle)` +
+ * `Effect.Exit = True`, `Presentation.CreateVideo` at 62.5 fps on a 200x200
+ * red rectangle): the visible region is a feathered circle whose half-alpha
+ * radius starts just outside the box corners and shrinks linearly to the
+ * centre (half the half-diagonal at 50% progress), with a soft edge about
+ * 1/8 of the half-diagonal wide. The radius is measured in the box's own
+ * inscribed-ellipse frame, so a non-square box closes as an ellipse.
+ *
+ * A gradient's stop positions do not interpolate in CSS, so the keyframe
+ * block steps through discrete stops, like `animation-wedge-reveal`.
+ *
+ * @module render/animation-circle-iris
+ */
+/** Soft edge width, as a fraction of the half-diagonal. */
+export declare const IRIS_BAND = 0.127;
+/** Half-alpha radius, as a fraction of the half-diagonal, at exit progress `p`. */
+export declare function irisRadiusAt(progress: number): number;
+/** Kebab-case mask declarations for the closing iris at exit progress `p` (0-1). */
+export declare function irisDecl(progress: number): string;
+/** Static `@keyframes pptx-circleOut`. */
+export declare const CIRCLE_OUT_KEYFRAMES: string;
+//# sourceMappingURL=animation-circle-iris.d.ts.map

package/dist/pptx/render/animation-circle-iris.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-circle-iris.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-circle-iris.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,2DAA2D;AAC3D,eAAO,MAAM,SAAS,QAAQ,CAAC;AAO/B,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,oFAAoF;AACpF,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAMjD;AAWD,0CAA0C;AAC1C,eAAO,MAAM,oBAAoB,QAAmB,CAAC"}

package/dist/pptx/render/animation-color-base-style.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Snapshot the static shape colours that a relative `p:animClr/p:by/p:hsl`
+ * keyframe uses after the binding relinquishes its ordinary fill / stroke.
+ * Kept framework-neutral so all five renderers feed the same CSS variables.
+ */
+import type { PptxElement, ShapeStyle } from 'ooxml-core/pptx';
+import type { CssStyleMap } from './element-style-transform.js';
+export interface AnimationColorBaseStyleOptions {
+    animatesFill?: boolean;
+    animatesStroke?: boolean;
+    parentGroupFill?: ShapeStyle;
+}
+/**
+ * Build CSS custom properties only while a paint animation is active, keeping
+ * ordinary rendering and existing style snapshots unchanged.
+ */
+export declare function getAnimationColorBaseStyle(element: PptxElement, options?: AnimationColorBaseStyleOptions): CssStyleMap;
+//# sourceMappingURL=animation-color-base-style.d.ts.map

package/dist/pptx/render/animation-color-base-style.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-color-base-style.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-color-base-style.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAI/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAI7D,MAAM,WAAW,8BAA8B;IAC9C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,eAAe,CAAC,EAAE,UAAU,CAAC;CAC7B;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACzC,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,8BAAmC,GAC1C,WAAW,CAmBb"}

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

@@ -0,0 +1,78 @@
+/**
+ * `animation-color`  -  colour-space interpolation + `p:animClr` keyframe
+ * generation for native colour animations. Pure maths, framework-free.
+ *
+ * @module render/animation-color
+ */
+import type { PptxColorAnimation } from 'ooxml-core/pptx';
+import type { ColorAnimationTarget } from './animation-timeline-types.js';
+/** Parse a hex color string (#RRGGBB or RRGGBB) into RGB components (0-255). */
+export declare function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+};
+/** Convert RGB components (0-255) to a CSS hex color string. */
+export declare function rgbToHex(r: number, g: number, b: number): string;
+/** Convert RGB (0-255) to HSL (h: 0-360, s: 0-100, l: 0-100). */
+export declare function rgbToHsl(r: number, g: number, b: number): {
+    h: number;
+    s: number;
+    l: number;
+};
+/** Convert HSL (h: 0-360, s: 0-100, l: 0-100) to RGB (0-255). */
+export declare function hslToRgb(h: number, s: number, l: number): {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * Interpolate between two hex colors in the specified color space.
+ *
+ * @param from - Starting hex color
+ * @param to - Ending hex color
+ * @param t - Interpolation factor (0 = from, 1 = to)
+ * @param colorSpace - "rgb" for linear RGB, "hsl" for HSL hue interpolation
+ * @param direction - For HSL: "cw" (clockwise) or "ccw" (counter-clockwise) hue rotation
+ * @returns Interpolated hex color string
+ */
+export declare function interpolateColor(from: string, to: string, t: number, colorSpace: 'rgb' | 'hsl', direction?: 'cw' | 'ccw'): string;
+/**
+ * Resolve the CSS properties to animate from the OOXML attribute name.
+ * Falls back to `color` if the attribute is unknown or not provided.
+ *
+ * Exported so `animation-timeline-absolute`'s `p:tavLst`-driven colour
+ * keyframes (a generic `p:anim` node naming a colour attribute, as opposed
+ * to the dedicated `p:animClr` behaviour this module was written for) can
+ * reuse the exact same attribute-name -> CSS-property mapping instead of
+ * duplicating it.
+ */
+export declare function resolveCssProperties(attrName?: string): string[];
+/**
+ * Resolve which shape paint targets a `p:animClr` color animation drives, from
+ * the same OOXML attribute-name mapping used to emit the keyframes. A `fill`
+ * CSS property implies the shape fill; a `stroke` property implies the stroke.
+ * Returns an empty array for text/`color`-only animations, which do not need a
+ * vector renderer to relinquish its painted fill / stroke.
+ */
+export declare function resolveColorAnimationTargets(animationOrAttribute?: PptxColorAnimation | string): readonly ColorAnimationTarget[];
+/** CSS custom properties that snapshot the shape paint before animation owns it. */
+export declare const ANIMATION_COLOR_BASE_PROPERTIES: {
+    readonly color: '--pptx-animation-color-base';
+    readonly fill: '--pptx-animation-fill-base';
+    readonly stroke: '--pptx-animation-stroke-base';
+};
+/**
+ * Build CSS `@keyframes` for a color animation (`p:animClr`).
+ *
+ * Generates keyframe stops at regular intervals with interpolated colors.
+ * The CSS property is determined from the `targetAttribute` field which is
+ * parsed from `p:attrNameLst` (e.g. "fillcolor" → `backgroundColor`).
+ *
+ * @param colorAnim - Parsed color animation data
+ * @param keyframeName - Name for the generated `@keyframes` rule
+ * @param steps - Number of keyframe stops (default 10 for smooth interpolation)
+ * @returns CSS `@keyframes` string, or undefined if colors are missing
+ */
+export declare function buildColorAnimationKeyframes(colorAnim: PptxColorAnimation, keyframeName: string, steps?: number, themeColorMap?: Readonly<Record<string, string>>): string | undefined;
+//# sourceMappingURL=animation-color.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-color.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-color.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAqB,MAAM,iBAAiB,CAAC;AAG7E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAQvE,gFAAgF;AAChF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAQzE;AAED,gEAAgE;AAChE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAwB7F;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAsC7F;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,MAAM,EACT,UAAU,EAAE,KAAK,GAAG,KAAK,EACzB,SAAS,CAAC,EAAE,IAAI,GAAG,KAAK,GACtB,MAAM,CAoCR;AAkCD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAKhE;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC3C,oBAAoB,CAAC,EAAE,kBAAkB,GAAG,MAAM,GAChD,SAAS,oBAAoB,EAAE,CAkBjC;AAED,oFAAoF;AACpF,eAAO,MAAM,+BAA+B;aAC3C,KAAK,EAAE,6BAA6B;aACpC,IAAI,EAAE,4BAA4B;aAClC,MAAM,EAAE,8BAA8B;CAC7B,CAAC;AAmHX;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAC3C,SAAS,EAAE,kBAAkB,EAC7B,YAAY,EAAE,MAAM,EACpB,KAAK,GAAE,MAAW,EAClB,aAAa,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC9C,MAAM,GAAG,SAAS,CAmDpB"}

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

@@ -0,0 +1,77 @@
+/**
+ * `animation-css`  -  pure mapping from a core animation preset to CSS.
+ *
+ * Given a high-level {@link PptxElementAnimation} (an entrance / emphasis /
+ * exit preset id plus `durationMs` / `delayMs`), this module produces the CSS
+ * needed to play that effect:
+ *
+ *  - {@link resolveAnimationCss} returns the `animation-name` plus an inline
+ *    `style` map (`animation-name` / `-duration` / `-delay` / `-fill-mode` /
+ *    `-timing-function`) to apply to the rendered element.
+ *  - {@link ANIMATION_KEYFRAMES_CSS} is the full set of `@keyframes`
+ *    definitions referenced by those animation names, ready to inject once via
+ *    a single `<style>` element.
+ *
+ * The {@link PptxElementAnimation} entrance / exit / emphasis fields carry a
+ * {@link PptxAnimationPreset} string (e.g. `"fadeIn"`, `"flyIn"`, `"spin"`),
+ * not the editor catalog `entr.N` ids  -  so this module maps those string
+ * presets. Unknown / unmapped presets fall back to a sensible default (fade).
+ *
+ * This module is intentionally framework-light: it has no Vue imports and is a
+ * pure function of its inputs, which keeps it trivially unit-testable and
+ * reusable by the playback composable.
+ *
+ * @module composables/animation-css
+ */
+import type { PptxElementAnimation } from 'ooxml-core/pptx';
+/**
+ * The kind of effect a {@link PptxElementAnimation} is playing. Determines the
+ * default CSS `animation-fill-mode` and the initial (pre-play) visibility.
+ */
+export type AnimationKind = 'entrance' | 'emphasis' | 'exit';
+/**
+ * Result of mapping a {@link PptxElementAnimation} to CSS.
+ */
+export interface AnimationCssResult {
+    /** The `@keyframes` name to reference (always present in {@link ANIMATION_KEYFRAMES_CSS}). */
+    animationName: string;
+    /**
+     * Inline CSS properties to apply to the element. Keys are kebab-case CSS
+     * property names (`animation-name`, `animation-duration`, …) so the map can
+     * be spread directly onto an element `style` object or serialised as-is.
+     */
+    style: Record<string, string>;
+    /** Which effect bucket this animation belongs to. */
+    kind: AnimationKind;
+}
+/**
+ * Maps a single {@link PptxElementAnimation} to the CSS required to play it.
+ *
+ * The returned {@link AnimationCssResult.style} map is suitable to spread onto
+ * an element's inline style. The referenced `animation-name` is always one of
+ * the keyframes contained in {@link ANIMATION_KEYFRAMES_CSS}.
+ *
+ * @example
+ * ```ts
+ * resolveAnimationCss({ elementId: "t1", entrance: "fadeIn", durationMs: 600 });
+ * // => { animationName: "pptx-vue-fadeIn", kind: "entrance",
+ * //      style: { "animation-name": "pptx-vue-fadeIn", "animation-duration": "600ms", ... } }
+ * ```
+ */
+export declare function resolveAnimationCss(animation: PptxElementAnimation): AnimationCssResult | undefined;
+/**
+ * Returns the inline style an element should carry *before* its entrance
+ * animation plays  -  i.e. hidden. Emphasis / exit effects start from the
+ * element's normal visible state, so they return an empty map.
+ *
+ * Useful for pre-seeding elements that have a pending entrance so they don't
+ * flash visible for a frame before playback begins.
+ */
+export declare function initialHiddenStyle(animation: PptxElementAnimation): Record<string, string>;
+/**
+ * All `@keyframes` blocks referenced by {@link resolveAnimationCss}. Inject this
+ * once into a single `<style>` element in the presentation host. Every name is
+ * prefixed with `pptx-vue-` to avoid collisions with host-page styles.
+ */
+export declare const ANIMATION_KEYFRAMES_CSS: string;
+//# sourceMappingURL=animation-css.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-css.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-css.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,KAAK,EAAuB,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAMjF;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,8FAA8F;IAC9F,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,qDAAqD;IACrD,IAAI,EAAE,aAAa,CAAC;CACpB;AAmLD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,oBAAoB,GAC7B,kBAAkB,GAAG,SAAS,CA2BhC;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAM1F;AAMD;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,QAiM5B,CAAC"}

package/dist/pptx/render/animation-direction-options.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `animation-direction-options` - which directions the Animation pane offers
+ * for a preset: only the ones PowerPoint itself has a variant (a
+ * `presetSubtype`) for, so a picked direction always saves as a subtype and
+ * behaviour tree PowerPoint recognises.
+ *
+ * Ground truth: every `MsoAnimEffect` was driven through COM with every
+ * `MsoAnimDirection` it accepts and the saved subtype read back (core's
+ * `animation-behavior-captures.json`). Fly and Crawl accept all eight
+ * directions (edges and corners); Wipe, Peek and Stretch accept the four
+ * edges; Float In has no direction at all (Float Up / Float Down are
+ * separate presets), so it no longer shows a picker that saved nothing.
+ *
+ * @module render/animation-direction-options
+ */
+import type { PptxAnimationDirection, PptxElementAnimation } from 'ooxml-core/pptx';
+/** Every direction value, edges first then corners. */
+export declare const DIRECTION_VALUES: readonly PptxAnimationDirection[];
+/**
+ * Direction -> i18n dictionary key, for every picker in every binding, so the
+ * bindings spell a direction the same way without each keeping its own map.
+ */
+export declare const ANIMATION_DIRECTION_LABEL_KEYS: Readonly<Record<PptxAnimationDirection, string>>;
+/** Presets that expose the direction picker. */
+export declare const DIRECTIONAL_PRESETS: ReadonlySet<string>;
+/** The directions `preset` offers, empty when it has none. */
+export declare function directionValuesForPreset(preset: string | undefined): readonly PptxAnimationDirection[];
+/**
+ * The direction a picker shows for an entry: its own, else PowerPoint's
+ * default for every directional preset here ("From Bottom", subtype 4;
+ * Stretch's default "Across" has no picker value, so its first edge).
+ */
+export declare function effectiveDirection(entry: Pick<PptxElementAnimation, 'direction'> | undefined, values: readonly PptxAnimationDirection[]): PptxAnimationDirection | undefined;
+/**
+ * The directions offered for an element's animation entry: its entrance's,
+ * else its exit's (the pane edits one `direction` per entry). Empty when the
+ * element has no directional preset.
+ */
+export declare function directionValuesFor(slideAnimations: readonly PptxElementAnimation[], elementId: string): readonly PptxAnimationDirection[];
+//# sourceMappingURL=animation-direction-options.d.ts.map

package/dist/pptx/render/animation-direction-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation-direction-options.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-direction-options.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEpF,uDAAuD;AACvD,eAAO,MAAM,gBAAgB,EAAE,SAAS,sBAAsB,EAS7D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,MAAM,CAAC,sBAAsB,EAAE,MAAM,CAAC,CAS3F,CAAC;AAgBF,gDAAgD;AAChD,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAA2C,CAAC;AAEhG,8DAA8D;AAC9D,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,MAAM,GAAG,SAAS,GACxB,SAAS,sBAAsB,EAAE,CAEnC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,KAAK,EAAE,IAAI,CAAC,oBAAoB,EAAE,WAAW,CAAC,GAAG,SAAS,EAC1D,MAAM,EAAE,SAAS,sBAAsB,EAAE,GACvC,sBAAsB,GAAG,SAAS,CAKpC;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CACjC,eAAe,EAAE,SAAS,oBAAoB,EAAE,EAChD,SAAS,EAAE,MAAM,GACf,SAAS,sBAAsB,EAAE,CAOnC"}

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

@@ -0,0 +1,33 @@
+/**
+ * `animation-directional`: generate direction-aware `@keyframes` for the
+ * mask-reveal family of entrance/exit effects (wipe, peek, blinds, split) so a
+ * `p:cTn/@presetSubtype` direction code is honoured, not just for Fly.
+ *
+ * Two different subtype encodings are in play (verified against
+ * PowerPoint-authored XML, which pairs each subtype with an explicit
+ * `p:animEffect/@filter` direction):
+ *  - Fly / Peek / Blinds use the origin-edge bitmask (1=top, 2=right,
+ *    4=bottom, 8=left): the code names the edge the object/reveal comes FROM.
+ *  - Wipe uses the same bitmask for the edge the wipe works from: subtype 1
+ *    = `wipe(up)` reveals from the top edge; the exit conceals from the top,
+ *    so what is left of the shape retreats toward the bottom edge.
+ *  - Split uses barn-door variant codes (21 = `barn(inVertical)`, etc.).
+ *
+ * The reveals are CSS `mask` sweeps rather than `clip-path` keyframes: a
+ * `clip-path` animation REPLACES the element's own geometry clip (parallelogram
+ * outlines, image crops), flooding the bounding box with fill mid-animation.
+ * See `animation-mask-reveal`.
+ *
+ * @module render/animation-directional
+ */
+import type { EffectName } from './animation-timeline-types.js';
+/**
+ * Build a directional `@keyframes` block for a mask-reveal entrance/exit
+ * effect, or `undefined` when the effect is not directional or no direction
+ * subtype was supplied (so the caller keeps the static preset).
+ */
+export declare function buildDirectionalKeyframe(effect: EffectName, subtype: number | undefined, uid: number): {
+    keyframeName: string;
+    css: string;
+} | undefined;
+//# sourceMappingURL=animation-directional.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-directional.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-directional.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAUH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAgC7D;;;;GAIG;AACH,wBAAgB,wBAAwB,CACvC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,GAAG,EAAE,MAAM,GACT;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA+BnD"}

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

@@ -0,0 +1,67 @@
+/**
+ * `animation-easing` - the single source of truth for how an animation's
+ * speed profile becomes a CSS `animation-timing-function`.
+ *
+ * PowerPoint ground truth (measured with `Presentation.CreateVideo` on a Fly
+ * In, 62.5 fps, sub-pixel RMS against the model below):
+ *
+ * - An effect with no `accel`/`decel` plays at constant speed (`linear`), not
+ *   with CSS's default `ease`.
+ * - `accel` is the fraction of the duration spent speeding up, `decel` the
+ *   fraction spent slowing down, with constant speed in between. Each ramp's
+ *   velocity follows a half-cosine (`(1 - cos(pi * s)) / 2`), not a straight
+ *   line: a constant-acceleration (parabolic) ramp fit 5-17 px worse.
+ *
+ * The exact curve is emitted as a CSS `linear()` easing sampled densely inside
+ * the ramps (the cruise segment is exactly linear, so it needs no stops). Where
+ * the engine cannot parse `linear()`, a `cubic-bezier()` approximation is
+ * used instead, because an unparseable timing function would invalidate the
+ * whole `animation` shorthand and the step would not play at all.
+ *
+ * @module render/animation-easing
+ */
+import type { PptxAnimationTimingCurve } from 'ooxml-core/pptx';
+/**
+ * The timing curve an editor animation without an explicit `timingCurve`
+ * plays with. The core writer saves an unset curve as `accel=0 decel=0`
+ * (`timingCurveToAccelDecel(undefined)`), which PowerPoint plays linearly, so
+ * the inspector must show, and preview must play, `linear` for it too.
+ */
+export declare const DEFAULT_ANIMATION_TIMING_CURVE: PptxAnimationTimingCurve;
+/** Resolve an editor animation's effective timing curve (unset -> linear). */
+export declare function effectiveTimingCurve(curve: PptxAnimationTimingCurve | undefined): PptxAnimationTimingCurve;
+/**
+ * Normalise raw `accel`/`decel` fractions: clamp each into 0..1 and, when they
+ * sum past 1 (invalid per ECMA-376, which caps the sum at 100%), scale both
+ * down proportionally so the ramps meet instead of overlapping.
+ */
+export declare function normalizeAccelDecel(accel: number | undefined, decel: number | undefined): {
+    accel: number;
+    decel: number;
+};
+/**
+ * PowerPoint's animation progress (0..1) at normalised time `t` (0..1) for the
+ * given `accel`/`decel` fractions: half-cosine speed-up over the first
+ * `accel`, constant speed, half-cosine slow-down over the last `decel`.
+ */
+export declare function powerPointAccelDecelProgress(t: number, accel: number | undefined, decel: number | undefined): number;
+/**
+ * Whether the CSS engine understands `linear()` easing (Chrome 113, Firefox
+ * 112, Safari 17.2). Outside a browser (tests, SSR) there is no engine to
+ * reject it, so the exact form is assumed.
+ */
+export declare function supportsCssLinearEasing(): boolean;
+/**
+ * Map an effect's parsed `accel`/`decel` fractions to a CSS timing function.
+ * Neither set (or both zero) is constant speed: `linear`.
+ *
+ * @param useLinearFunction - override the `linear()` support probe (tests).
+ */
+export declare function cssEasingForAccelDecel(accel: number | undefined, decel: number | undefined, useLinearFunction?: boolean): string;
+/**
+ * Map an editor {@link PptxAnimationTimingCurve} to a CSS timing function. An
+ * unset (or unknown) curve is `linear`, matching what the core writer saves
+ * for it and what PowerPoint then plays.
+ */
+export declare function cssEasingForTimingCurve(curve: PptxAnimationTimingCurve | undefined): string;
+//# sourceMappingURL=animation-easing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"animation-easing.d.ts","sourceRoot":"","sources":["../../../src/pptx/render/animation-easing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAEhE;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,EAAE,wBAAmC,CAAC;AAEjF,8EAA8E;AAC9E,wBAAgB,oBAAoB,CACnC,KAAK,EAAE,wBAAwB,GAAG,SAAS,GACzC,wBAAwB,CAE1B;AASD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAClC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,KAAK,EAAE,MAAM,GAAG,SAAS,GACvB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAKlC;AAOD;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC3C,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,KAAK,EAAE,MAAM,GAAG,SAAS,GACvB,MAAM,CAYR;AA4CD;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,OAAO,CASjD;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,iBAAiB,GAAE,OAAmC,GACpD,MAAM,CASR;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,wBAAwB,GAAG,SAAS,GAAG,MAAM,CAW3F"}