@redwilly/anima 0.1.0

package/dist/core/animations/easing/manim.d.ts

@@ -0,0 +1,46 @@
+import type { EasingFunction } from './types';
+/**
+ * Smooth S-curve using cubic smoothstep.
+ * This is the DEFAULT easing for all Manim animations.
+ * Formula: 3t² - 2t³
+ */
+export declare const smooth: EasingFunction;
+/**
+ * Applies smooth twice for extra smoothness.
+ * Creates an even more gradual transition at the endpoints.
+ */
+export declare const doubleSmooth: EasingFunction;
+/**
+ * Starts fast, decelerates at end (rush into the destination).
+ * Uses sqrt for fast start that slows down.
+ */
+export declare const rushInto: EasingFunction;
+/**
+ * Slow start, accelerates from beginning (rush from the start).
+ * Uses quadratic for slow start that speeds up.
+ */
+export declare const rushFrom: EasingFunction;
+/**
+ * Starts normal, slows into the end.
+ */
+export declare const slowInto: EasingFunction;
+/**
+ * Goes from 0 to 1 and back to 0.
+ * Useful for temporary effects.
+ */
+export declare const thereAndBack: EasingFunction;
+/** Goes from 0 to 1 and back to 0 with a pause at the peak. */
+export declare function thereAndBackWithPause(pauseRatio?: number): EasingFunction;
+/** Overshoots slightly then settles (like a running start). */
+export declare function runningStart(pullFactor?: number): EasingFunction;
+/**
+ * Oscillates back and forth (wiggle/shake effect).
+ * Creates a wobbling motion that ends at 1.
+ */
+export declare const wiggle: EasingFunction;
+/** Approaches but doesn't quite reach 1 (asymptotic approach). */
+export declare function notQuiteThere(proportion?: number): EasingFunction;
+/** Reaches the destination early and stays there. */
+export declare function lingering(proportion?: number): EasingFunction;
+/** Asymptotically approaches 1 via exponential decay. */
+export declare function exponentialDecay(halfLife?: number): EasingFunction;

package/dist/core/animations/easing/manim.js

@@ -0,0 +1,102 @@
+/**
+ * Smooth S-curve using cubic smoothstep.
+ * This is the DEFAULT easing for all Manim animations.
+ * Formula: 3t² - 2t³
+ */
+export const smooth = (t) => {
+    const s = t * t * (3 - 2 * t);
+    return s;
+};
+/**
+ * Applies smooth twice for extra smoothness.
+ * Creates an even more gradual transition at the endpoints.
+ */
+export const doubleSmooth = (t) => smooth(smooth(t));
+/**
+ * Starts fast, decelerates at end (rush into the destination).
+ * Uses sqrt for fast start that slows down.
+ */
+export const rushInto = (t) => {
+    return 1 - Math.pow(1 - t, 2);
+};
+/**
+ * Slow start, accelerates from beginning (rush from the start).
+ * Uses quadratic for slow start that speeds up.
+ */
+export const rushFrom = (t) => {
+    return Math.pow(t, 2);
+};
+/**
+ * Starts normal, slows into the end.
+ */
+export const slowInto = (t) => {
+    return Math.sqrt(t);
+};
+/**
+ * Goes from 0 to 1 and back to 0.
+ * Useful for temporary effects.
+ */
+export const thereAndBack = (t) => {
+    const mapped = 2 * t;
+    if (t < 0.5) {
+        return smooth(mapped);
+    }
+    return smooth(2 - mapped);
+};
+/** Goes from 0 to 1 and back to 0 with a pause at the peak. */
+export function thereAndBackWithPause(pauseRatio = 1 / 3) {
+    const a = pauseRatio / 2;
+    return (t) => {
+        if (t < 0.5 - a) {
+            return smooth(t / (0.5 - a));
+        }
+        else if (t < 0.5 + a) {
+            return 1;
+        }
+        else {
+            return smooth((1 - t) / (0.5 - a));
+        }
+    };
+}
+/** Overshoots slightly then settles (like a running start). */
+export function runningStart(pullFactor = 0.2) {
+    return (t) => {
+        // Cubic bezier from (0,0) to (1,1) with control points for overshoot
+        return bezierInterpolate(t, 0, -pullFactor, 1, 1);
+    };
+}
+/**
+ * Oscillates back and forth (wiggle/shake effect).
+ * Creates a wobbling motion that ends at 1.
+ */
+export const wiggle = (t) => {
+    const wiggles = 2;
+    // Damped sine wave that ends at 1
+    return t + (1 - t) * Math.sin(wiggles * 2 * Math.PI * t) * 0.3;
+};
+/** Approaches but doesn't quite reach 1 (asymptotic approach). */
+export function notQuiteThere(proportion = 0.7) {
+    return (t) => t === 1 ? 1 : proportion * smooth(t);
+}
+/** Reaches the destination early and stays there. */
+export function lingering(proportion = 0.75) {
+    return (t) => {
+        if (t >= proportion) {
+            return 1;
+        }
+        return smooth(t / proportion);
+    };
+}
+/** Asymptotically approaches 1 via exponential decay. */
+export function exponentialDecay(halfLife = 0.1) {
+    return (t) => {
+        if (t === 1)
+            return 1;
+        return 1 - Math.exp(-t / halfLife);
+    };
+}
+// Helper for cubic bezier interpolation (used by runningStart)
+function bezierInterpolate(t, p0, p1, p2, p3) {
+    const u = 1 - t;
+    return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3;
+}

package/dist/core/animations/easing/registry.d.ts

@@ -0,0 +1,8 @@
+import type { EasingFunction } from './types';
+/** @throws Error if an easing with the given name already exists. */
+export declare function registerEasing(name: string, fn: EasingFunction): void;
+export declare function getEasing(name: string): EasingFunction | undefined;
+export declare function hasEasing(name: string): boolean;
+export declare function unregisterEasing(name: string): boolean;
+/** Clears all registered custom easings (useful for testing). */
+export declare function clearRegistry(): void;

package/dist/core/animations/easing/registry.js

@@ -0,0 +1,25 @@
+/**
+ * Registry for custom easing functions.
+ * Allows users to register and retrieve custom easings by name.
+ */
+const easingRegistry = new Map();
+/** @throws Error if an easing with the given name already exists. */
+export function registerEasing(name, fn) {
+    if (easingRegistry.has(name)) {
+        throw new Error(`Easing "${name}" is already registered.`);
+    }
+    easingRegistry.set(name, fn);
+}
+export function getEasing(name) {
+    return easingRegistry.get(name);
+}
+export function hasEasing(name) {
+    return easingRegistry.has(name);
+}
+export function unregisterEasing(name) {
+    return easingRegistry.delete(name);
+}
+/** Clears all registered custom easings (useful for testing). */
+export function clearRegistry() {
+    easingRegistry.clear();
+}

package/dist/core/animations/easing/standard.d.ts

@@ -0,0 +1,113 @@
+import type { EasingFunction } from './types';
+/**
+ * Linear easing (no easing, constant speed).
+ */
+export declare const linear: EasingFunction;
+/**
+ * Quadratic ease-in: slow start, accelerating.
+ */
+export declare const easeInQuad: EasingFunction;
+/**
+ * Quadratic ease-out: fast start, decelerating.
+ */
+export declare const easeOutQuad: EasingFunction;
+/**
+ * Quadratic ease-in-out: slow start and end.
+ */
+export declare const easeInOutQuad: EasingFunction;
+/**
+ * Cubic ease-in: slow start, accelerating.
+ */
+export declare const easeInCubic: EasingFunction;
+/**
+ * Cubic ease-out: fast start, decelerating.
+ */
+export declare const easeOutCubic: EasingFunction;
+/**
+ * Cubic ease-in-out: slow start and end.
+ */
+export declare const easeInOutCubic: EasingFunction;
+/**
+ * Quartic ease-in: slow start, accelerating.
+ */
+export declare const easeInQuart: EasingFunction;
+/**
+ * Quartic ease-out: fast start, decelerating.
+ */
+export declare const easeOutQuart: EasingFunction;
+/**
+ * Quartic ease-in-out: slow start and end.
+ */
+export declare const easeInOutQuart: EasingFunction;
+/**
+ * Quintic ease-in: slow start, accelerating.
+ */
+export declare const easeInQuint: EasingFunction;
+/**
+ * Quintic ease-out: fast start, decelerating.
+ */
+export declare const easeOutQuint: EasingFunction;
+/**
+ * Quintic ease-in-out: slow start and end.
+ */
+export declare const easeInOutQuint: EasingFunction;
+/**
+ * Sinusoidal ease-in: uses sine curve for smooth acceleration.
+ */
+export declare const easeInSine: EasingFunction;
+/**
+ * Sinusoidal ease-out: uses sine curve for smooth deceleration.
+ */
+export declare const easeOutSine: EasingFunction;
+/**
+ * Sinusoidal ease-in-out: smooth S-curve using sine.
+ */
+export declare const easeInOutSine: EasingFunction;
+/**
+ * Exponential ease-in: dramatic acceleration.
+ */
+export declare const easeInExpo: EasingFunction;
+/**
+ * Exponential ease-out: dramatic deceleration.
+ */
+export declare const easeOutExpo: EasingFunction;
+/**
+ * Exponential ease-in-out: dramatic S-curve.
+ */
+export declare const easeInOutExpo: EasingFunction;
+/**
+ * Circular ease-in: quarter circle acceleration.
+ */
+export declare const easeInCirc: EasingFunction;
+/**
+ * Circular ease-out: quarter circle deceleration.
+ */
+export declare const easeOutCirc: EasingFunction;
+/**
+ * Circular ease-in-out: half circle S-curve.
+ */
+export declare const easeInOutCirc: EasingFunction;
+/**
+ * Back ease-in: pulls back before accelerating forward.
+ */
+export declare const easeInBack: EasingFunction;
+/**
+ * Back ease-out: overshoots then settles.
+ */
+export declare const easeOutBack: EasingFunction;
+/**
+ * Back ease-in-out: pulls back, overshoots, then settles.
+ */
+export declare const easeInOutBack: EasingFunction;
+/**
+ * Elastic ease-in: builds up elastic energy.
+ */
+export declare const easeInElastic: EasingFunction;
+/**
+ * Elastic ease-out: releases elastic energy with overshoot oscillation.
+ */
+export declare const easeOutElastic: EasingFunction;
+/**
+ * Elastic ease-in-out: elastic effect on both ends.
+ */
+export declare const easeInOutElastic: EasingFunction;

package/dist/core/animations/easing/standard.js

@@ -0,0 +1,151 @@
+/**
+ * Linear easing (no easing, constant speed).
+ */
+export const linear = (t) => t;
+// --- Quadratic ---
+/**
+ * Quadratic ease-in: slow start, accelerating.
+ */
+export const easeInQuad = (t) => t * t;
+/**
+ * Quadratic ease-out: fast start, decelerating.
+ */
+export const easeOutQuad = (t) => 1 - (1 - t) * (1 - t);
+/**
+ * Quadratic ease-in-out: slow start and end.
+ */
+export const easeInOutQuad = (t) => t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+// --- Cubic ---
+/**
+ * Cubic ease-in: slow start, accelerating.
+ */
+export const easeInCubic = (t) => t * t * t;
+/**
+ * Cubic ease-out: fast start, decelerating.
+ */
+export const easeOutCubic = (t) => 1 - Math.pow(1 - t, 3);
+/**
+ * Cubic ease-in-out: slow start and end.
+ */
+export const easeInOutCubic = (t) => t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+// --- Quartic ---
+/**
+ * Quartic ease-in: slow start, accelerating.
+ */
+export const easeInQuart = (t) => t * t * t * t;
+/**
+ * Quartic ease-out: fast start, decelerating.
+ */
+export const easeOutQuart = (t) => 1 - Math.pow(1 - t, 4);
+/**
+ * Quartic ease-in-out: slow start and end.
+ */
+export const easeInOutQuart = (t) => t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+// --- Quintic ---
+/**
+ * Quintic ease-in: slow start, accelerating.
+ */
+export const easeInQuint = (t) => t * t * t * t * t;
+/**
+ * Quintic ease-out: fast start, decelerating.
+ */
+export const easeOutQuint = (t) => 1 - Math.pow(1 - t, 5);
+/**
+ * Quintic ease-in-out: slow start and end.
+ */
+export const easeInOutQuint = (t) => t < 0.5 ? 16 * t * t * t * t * t : 1 - Math.pow(-2 * t + 2, 5) / 2;
+// --- Sinusoidal ---
+/**
+ * Sinusoidal ease-in: uses sine curve for smooth acceleration.
+ */
+export const easeInSine = (t) => 1 - Math.cos((t * Math.PI) / 2);
+/**
+ * Sinusoidal ease-out: uses sine curve for smooth deceleration.
+ */
+export const easeOutSine = (t) => Math.sin((t * Math.PI) / 2);
+/**
+ * Sinusoidal ease-in-out: smooth S-curve using sine.
+ */
+export const easeInOutSine = (t) => -(Math.cos(Math.PI * t) - 1) / 2;
+// --- Exponential ---
+/**
+ * Exponential ease-in: dramatic acceleration.
+ */
+export const easeInExpo = (t) => t === 0 ? 0 : Math.pow(2, 10 * t - 10);
+/**
+ * Exponential ease-out: dramatic deceleration.
+ */
+export const easeOutExpo = (t) => t === 1 ? 1 : 1 - Math.pow(2, -10 * t);
+/**
+ * Exponential ease-in-out: dramatic S-curve.
+ */
+export const easeInOutExpo = (t) => t === 0
+    ? 0
+    : t === 1
+        ? 1
+        : t < 0.5
+            ? Math.pow(2, 20 * t - 10) / 2
+            : (2 - Math.pow(2, -20 * t + 10)) / 2;
+// --- Circular ---
+/**
+ * Circular ease-in: quarter circle acceleration.
+ */
+export const easeInCirc = (t) => 1 - Math.sqrt(1 - t * t);
+/**
+ * Circular ease-out: quarter circle deceleration.
+ */
+export const easeOutCirc = (t) => Math.sqrt(1 - Math.pow(t - 1, 2));
+/**
+ * Circular ease-in-out: half circle S-curve.
+ */
+export const easeInOutCirc = (t) => t < 0.5
+    ? (1 - Math.sqrt(1 - Math.pow(2 * t, 2))) / 2
+    : (Math.sqrt(1 - Math.pow(-2 * t + 2, 2)) + 1) / 2;
+// --- Back (overshoots) ---
+const BACK_C1 = 1.70158;
+const BACK_C2 = BACK_C1 * 1.525;
+const BACK_C3 = BACK_C1 + 1;
+/**
+ * Back ease-in: pulls back before accelerating forward.
+ */
+export const easeInBack = (t) => BACK_C3 * t * t * t - BACK_C1 * t * t;
+/**
+ * Back ease-out: overshoots then settles.
+ */
+export const easeOutBack = (t) => 1 + BACK_C3 * Math.pow(t - 1, 3) + BACK_C1 * Math.pow(t - 1, 2);
+/**
+ * Back ease-in-out: pulls back, overshoots, then settles.
+ */
+export const easeInOutBack = (t) => t < 0.5
+    ? (Math.pow(2 * t, 2) * ((BACK_C2 + 1) * 2 * t - BACK_C2)) / 2
+    : (Math.pow(2 * t - 2, 2) * ((BACK_C2 + 1) * (t * 2 - 2) + BACK_C2) + 2) /
+        2;
+// --- Elastic ---
+const ELASTIC_C4 = (2 * Math.PI) / 3;
+const ELASTIC_C5 = (2 * Math.PI) / 4.5;
+/**
+ * Elastic ease-in: builds up elastic energy.
+ */
+export const easeInElastic = (t) => t === 0
+    ? 0
+    : t === 1
+        ? 1
+        : -Math.pow(2, 10 * t - 10) * Math.sin((t * 10 - 10.75) * ELASTIC_C4);
+/**
+ * Elastic ease-out: releases elastic energy with overshoot oscillation.
+ */
+export const easeOutElastic = (t) => t === 0
+    ? 0
+    : t === 1
+        ? 1
+        : Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * ELASTIC_C4) + 1;
+/**
+ * Elastic ease-in-out: elastic effect on both ends.
+ */
+export const easeInOutElastic = (t) => t === 0
+    ? 0
+    : t === 1
+        ? 1
+        : t < 0.5
+            ? -(Math.pow(2, 20 * t - 10) * Math.sin((20 * t - 11.125) * ELASTIC_C5)) / 2
+            : (Math.pow(2, -20 * t + 10) * Math.sin((20 * t - 11.125) * ELASTIC_C5)) / 2 + 1;

package/dist/core/animations/easing/types.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Type signature for an easing function.
+ * Maps a progress value t ∈ [0, 1] to an eased value.
+ * Must satisfy: f(0) = 0 and f(1) = 1
+ */
+export type EasingFunction = (t: number) => number;

package/dist/core/animations/fade/FadeIn.d.ts

@@ -0,0 +1,17 @@
+import { IntroductoryAnimation } from '../categories';
+import type { Mobject } from '../../../mobjects/Mobject';
+/**
+ * Animation that fades a Mobject in by increasing its opacity from 0 to 1.
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
+ * You do not need to call scene.add() before using FadeIn.
+ *
+ * @example
+ * const circle = new Circle(1);
+ * scene.play(new FadeIn(circle));  // Circle is auto-registered and faded in
+ */
+export declare class FadeIn<T extends Mobject = Mobject> extends IntroductoryAnimation<T> {
+    private readonly startOpacity;
+    constructor(target: T);
+    interpolate(progress: number): void;
+}

package/dist/core/animations/fade/FadeIn.js

@@ -0,0 +1,22 @@
+import { IntroductoryAnimation } from '../categories';
+/**
+ * Animation that fades a Mobject in by increasing its opacity from 0 to 1.
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
+ * You do not need to call scene.add() before using FadeIn.
+ *
+ * @example
+ * const circle = new Circle(1);
+ * scene.play(new FadeIn(circle));  // Circle is auto-registered and faded in
+ */
+export class FadeIn extends IntroductoryAnimation {
+    startOpacity;
+    constructor(target) {
+        super(target);
+        this.startOpacity = target.opacity;
+    }
+    interpolate(progress) {
+        const newOpacity = this.startOpacity + (1 - this.startOpacity) * progress;
+        this.target.setOpacity(newOpacity);
+    }
+}

package/dist/core/animations/fade/FadeOut.d.ts

@@ -0,0 +1,17 @@
+import { ExitAnimation } from '../categories';
+import type { Mobject } from '../../../mobjects/Mobject';
+/**
+ * Animation that fades a Mobject out by decreasing its opacity to 0.
+ *
+ * This is an exit animation - the target must already be in the scene.
+ * The starting opacity is captured when the animation first runs,
+ * not when it's constructed, so it correctly fades from the current opacity.
+ *
+ * @example
+ * scene.add(circle);
+ * scene.play(new FadeOut(circle));  // Circle fades out
+ */
+export declare class FadeOut<T extends Mobject = Mobject> extends ExitAnimation<T> {
+    private startOpacity;
+    interpolate(progress: number): void;
+}

package/dist/core/animations/fade/FadeOut.js

@@ -0,0 +1,23 @@
+import { ExitAnimation } from '../categories';
+/**
+ * Animation that fades a Mobject out by decreasing its opacity to 0.
+ *
+ * This is an exit animation - the target must already be in the scene.
+ * The starting opacity is captured when the animation first runs,
+ * not when it's constructed, so it correctly fades from the current opacity.
+ *
+ * @example
+ * scene.add(circle);
+ * scene.play(new FadeOut(circle));  // Circle fades out
+ */
+export class FadeOut extends ExitAnimation {
+    startOpacity = null;
+    interpolate(progress) {
+        // Capture opacity on first call (when animation actually runs)
+        if (this.startOpacity === null) {
+            this.startOpacity = this.target.opacity;
+        }
+        const newOpacity = this.startOpacity * (1 - progress);
+        this.target.setOpacity(newOpacity);
+    }
+}

package/dist/core/animations/fade/index.d.ts

@@ -0,0 +1,2 @@
+export { FadeIn } from './FadeIn';
+export { FadeOut } from './FadeOut';

package/dist/core/animations/fade/index.js

@@ -0,0 +1,2 @@
+export { FadeIn } from './FadeIn';
+export { FadeOut } from './FadeOut';

package/dist/core/animations/index.d.ts

@@ -0,0 +1,11 @@
+export { Animation } from './Animation';
+export { FadeIn, FadeOut } from './fade';
+export { MoveTo, Rotate, Scale } from './transform';
+export { MorphTo } from './morph';
+export { Draw, Write, Unwrite } from './draw';
+export { Sequence, Parallel } from './composition';
+export { KeyframeTrack, KeyframeAnimation } from './keyframes';
+export type { Keyframe } from './keyframes';
+export { Follow, Shake } from './camera';
+export type { AnimationConfig, FluentConfig, AnimationFactory, QueuedAnimation, QueuedPrebuilt, QueueEntry, } from './types';
+export { DEFAULT_DURATION, isPrebuilt } from './types';

package/dist/core/animations/index.js

@@ -0,0 +1,17 @@
+// Animation base class
+export { Animation } from './Animation';
+// Fade animations
+export { FadeIn, FadeOut } from './fade';
+// Transform animations
+export { MoveTo, Rotate, Scale } from './transform';
+// Morph animations
+export { MorphTo } from './morph';
+// Draw animations
+export { Draw, Write, Unwrite } from './draw';
+// Composition containers
+export { Sequence, Parallel } from './composition';
+// Keyframes
+export { KeyframeTrack, KeyframeAnimation } from './keyframes';
+// Camera animations
+export { Follow, Shake } from './camera';
+export { DEFAULT_DURATION, isPrebuilt } from './types';

package/dist/core/animations/keyframes/KeyframeAnimation.d.ts

@@ -0,0 +1,33 @@
+import { Animation } from '../Animation';
+import type { AnimationLifecycle } from '../types';
+import type { Mobject } from '../../../mobjects/Mobject';
+import { KeyframeTrack } from './KeyframeTrack';
+import type { KeyframeValue } from './types';
+/**
+ * Property setter function type for applying values to a Mobject.
+ */
+type PropertySetter<T extends Mobject, V> = (target: T, value: V) => void;
+/**
+ * Animation that interpolates multiple property tracks via keyframes.
+ * Each track controls a single property and is interpolated independently.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ */
+export declare class KeyframeAnimation<T extends Mobject = Mobject> extends Animation<T> {
+    private readonly tracks;
+    readonly lifecycle: AnimationLifecycle;
+    /**
+     * Adds a named keyframe track with its property setter.
+     * The setter is called during interpolation to apply values to the target.
+     */
+    addTrack<V extends KeyframeValue>(name: string, track: KeyframeTrack<V>, setter: PropertySetter<T, V>): this;
+    /** Gets a track by name. */
+    getTrack<V extends KeyframeValue>(name: string): KeyframeTrack<V> | undefined;
+    /** All track names. */
+    getTrackNames(): string[];
+    /**
+     * Interpolates all tracks at the given progress and applies values to target.
+     */
+    interpolate(progress: number): void;
+}
+export {};

package/dist/core/animations/keyframes/KeyframeAnimation.js

@@ -0,0 +1,40 @@
+import { Animation } from '../Animation';
+/**
+ * Animation that interpolates multiple property tracks via keyframes.
+ * Each track controls a single property and is interpolated independently.
+ *
+ * This is a transformative animation - the target must already be in the scene.
+ */
+export class KeyframeAnimation extends Animation {
+    tracks = new Map();
+    lifecycle = 'transformative';
+    /**
+     * Adds a named keyframe track with its property setter.
+     * The setter is called during interpolation to apply values to the target.
+     */
+    addTrack(name, track, setter) {
+        this.tracks.set(name, {
+            track: track,
+            setter: setter,
+        });
+        return this;
+    }
+    /** Gets a track by name. */
+    getTrack(name) {
+        const entry = this.tracks.get(name);
+        return entry?.track;
+    }
+    /** All track names. */
+    getTrackNames() {
+        return Array.from(this.tracks.keys());
+    }
+    /**
+     * Interpolates all tracks at the given progress and applies values to target.
+     */
+    interpolate(progress) {
+        for (const entry of this.tracks.values()) {
+            const value = entry.track.getValueAt(progress);
+            entry.setter(this.target, value);
+        }
+    }
+}