@redwilly/anima 0.1.0

package/dist/core/animations/draw/Draw.js

@@ -0,0 +1,122 @@
+import { IntroductoryAnimation } from '../categories';
+import { getPartialPath } from './partialPath';
+/**
+ * Checks if a VMobject is a VGroup (has getChildren method).
+ * Uses duck-typing to avoid circular dependency with VGroup import.
+ */
+function isVGroup(target) {
+    return typeof target.getChildren === 'function';
+}
+/**
+ * Animation that first draws the border progressively, then fills the shape.
+ * The first 50% of the animation draws the stroke, the second 50% fades in the fill.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
+ *
+ * @example
+ * const rect = new Rectangle(2, 1);
+ * scene.play(new Draw(rect));  // Border draws, then fill fades in
+ */
+export class Draw extends IntroductoryAnimation {
+    isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    originalPaths;
+    originalFillOpacity;
+    originalOpacity;
+    /** For VGroup targets: original state of each child. */
+    childStates;
+    constructor(target) {
+        super(target);
+        this.isVGroup = isVGroup(target);
+        this.originalOpacity = target.opacity;
+        this.originalFillOpacity = target.getFillOpacity();
+        if (this.isVGroup && isVGroup(target)) {
+            // Store original state for each child
+            this.originalPaths = [];
+            this.childStates = [];
+            for (const child of target.getChildren()) {
+                this.childStates.push({
+                    child,
+                    originalPaths: child.paths.map((p) => p.clone()),
+                    originalOpacity: child.opacity,
+                    originalFillOpacity: child.getFillOpacity(),
+                });
+            }
+        }
+        else {
+            // Store original paths on the target itself
+            this.originalPaths = target.paths.map(p => p.clone());
+            this.childStates = [];
+        }
+    }
+    /** Interpolates stroke drawing (0-0.5) and then fill fade (0.5-1). */
+    interpolate(progress) {
+        if (this.isVGroup) {
+            this.interpolateVGroup(progress);
+        }
+        else {
+            this.interpolateVMobject(progress);
+        }
+    }
+    /** Interpolates a single VMobject (non-VGroup). */
+    interpolateVMobject(progress) {
+        const targetOpacity = this.originalOpacity === 0 ? 1 : this.originalOpacity;
+        if (progress <= 0) {
+            this.target.paths = [];
+            this.target.setOpacity(0);
+            this.target.fill(this.target.getFillColor(), 0);
+            return;
+        }
+        this.target.setOpacity(targetOpacity);
+        if (progress < 0.5) {
+            // First half: draw stroke progressively, no fill
+            const strokeProgress = progress * 2;
+            const partialPaths = [];
+            for (const originalPath of this.originalPaths) {
+                partialPaths.push(getPartialPath(originalPath, strokeProgress));
+            }
+            this.target.paths = partialPaths;
+            this.target.fill(this.target.getFillColor(), 0);
+        }
+        else {
+            // Second half: full stroke, fade in fill
+            this.target.paths = this.originalPaths.map(p => p.clone());
+            const fillProgress = (progress - 0.5) * 2;
+            this.target.fill(this.target.getFillColor(), this.originalFillOpacity * fillProgress);
+        }
+    }
+    /** Interpolates a VGroup by animating each child's paths. */
+    interpolateVGroup(progress) {
+        const targetOpacity = this.originalOpacity === 0 ? 1 : this.originalOpacity;
+        this.target.setOpacity(progress <= 0 ? 0 : targetOpacity);
+        for (const state of this.childStates) {
+            const { child, originalPaths, originalOpacity, originalFillOpacity } = state;
+            const childOpacity = originalOpacity === 0 ? 1 : originalOpacity;
+            if (progress <= 0) {
+                child.paths = [];
+                child.setOpacity(0);
+                child.fill(child.getFillColor(), 0);
+                continue;
+            }
+            child.setOpacity(childOpacity);
+            if (progress < 0.5) {
+                // First half: draw stroke progressively, no fill
+                const strokeProgress = progress * 2;
+                const partialPaths = [];
+                for (const originalPath of originalPaths) {
+                    partialPaths.push(getPartialPath(originalPath, strokeProgress));
+                }
+                child.paths = partialPaths;
+                child.fill(child.getFillColor(), 0);
+            }
+            else {
+                // Second half: full stroke, fade in fill
+                child.paths = originalPaths.map(p => p.clone());
+                const fillProgress = (progress - 0.5) * 2;
+                child.fill(child.getFillColor(), originalFillOpacity * fillProgress);
+            }
+        }
+    }
+}

package/dist/core/animations/draw/Unwrite.d.ts

@@ -0,0 +1,30 @@
+import { ExitAnimation } from '../categories';
+import { VMobject } from '../../../mobjects/VMobject';
+/**
+ * Animation that progressively removes a VMobject by erasing the path.
+ * Reverse of Write animation - at progress 0, full object is visible;
+ * at progress 1, nothing is visible.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an exit animation - the target must already be in the scene.
+ *
+ * @example
+ * scene.play(new Write(text));
+ * scene.play(new Unwrite(text));  // Text is erased progressively
+ */
+export declare class Unwrite<T extends VMobject = VMobject> extends ExitAnimation<T> {
+    private readonly isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    private readonly originalPaths;
+    private readonly originalOpacity;
+    private readonly originalFillOpacity;
+    /** For VGroup targets: original state of each child. */
+    private readonly childStates;
+    constructor(target: T);
+    interpolate(progress: number): void;
+    /** Interpolates a single VMobject (non-VGroup). */
+    private interpolateVMobject;
+    /** Interpolates a VGroup by animating each child's paths. */
+    private interpolateVGroup;
+}

package/dist/core/animations/draw/Unwrite.js

@@ -0,0 +1,120 @@
+import { ExitAnimation } from '../categories';
+import { getPartialPath } from './partialPath';
+/**
+ * Checks if a VMobject is a VGroup (has getChildren method).
+ * Uses duck-typing to avoid circular dependency with VGroup import.
+ */
+function isVGroup(target) {
+    return typeof target.getChildren === 'function';
+}
+/**
+ * Animation that progressively removes a VMobject by erasing the path.
+ * Reverse of Write animation - at progress 0, full object is visible;
+ * at progress 1, nothing is visible.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an exit animation - the target must already be in the scene.
+ *
+ * @example
+ * scene.play(new Write(text));
+ * scene.play(new Unwrite(text));  // Text is erased progressively
+ */
+export class Unwrite extends ExitAnimation {
+    isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    originalPaths;
+    originalOpacity;
+    originalFillOpacity;
+    /** For VGroup targets: original state of each child. */
+    childStates;
+    constructor(target) {
+        super(target);
+        this.isVGroup = isVGroup(target);
+        this.originalOpacity = target.opacity;
+        this.originalFillOpacity = target.getFillOpacity();
+        if (this.isVGroup && isVGroup(target)) {
+            // Store original state for each child
+            this.originalPaths = [];
+            this.childStates = [];
+            for (const child of target.getChildren()) {
+                this.childStates.push({
+                    child,
+                    originalPaths: child.paths.map((p) => p.clone()),
+                    originalOpacity: child.opacity,
+                    originalFillOpacity: child.getFillOpacity(),
+                });
+            }
+        }
+        else {
+            // Store original paths on the target itself
+            this.originalPaths = target.paths.map(p => p.clone());
+            this.childStates = [];
+        }
+    }
+    interpolate(progress) {
+        if (this.isVGroup) {
+            this.interpolateVGroup(progress);
+        }
+        else {
+            this.interpolateVMobject(progress);
+        }
+    }
+    /** Interpolates a single VMobject (non-VGroup). */
+    interpolateVMobject(progress) {
+        if (progress >= 1) {
+            this.target.paths = [];
+            this.target.setOpacity(0);
+            return;
+        }
+        if (progress <= 0) {
+            this.target.paths = this.originalPaths.map(p => p.clone());
+            const targetOpacity = this.originalOpacity === 0 ? 1 : this.originalOpacity;
+            this.target.setOpacity(targetOpacity);
+            this.target.fill(this.target.getFillColor(), this.originalFillOpacity);
+            return;
+        }
+        // Show partial paths (reverse progress)
+        const reverseProgress = 1 - progress;
+        const targetOpacity = this.originalOpacity === 0 ? 1 : this.originalOpacity;
+        this.target.setOpacity(targetOpacity);
+        this.target.fill(this.target.getFillColor(), this.originalFillOpacity);
+        const partialPaths = [];
+        for (const originalPath of this.originalPaths) {
+            partialPaths.push(getPartialPath(originalPath, reverseProgress));
+        }
+        this.target.paths = partialPaths;
+    }
+    /** Interpolates a VGroup by animating each child's paths. */
+    interpolateVGroup(progress) {
+        if (progress >= 1) {
+            this.target.setOpacity(0);
+            for (const state of this.childStates) {
+                state.child.paths = [];
+                state.child.setOpacity(0);
+            }
+            return;
+        }
+        const targetOpacity = this.originalOpacity === 0 ? 1 : this.originalOpacity;
+        this.target.setOpacity(targetOpacity);
+        for (const state of this.childStates) {
+            const { child, originalPaths, originalOpacity, originalFillOpacity } = state;
+            const childOpacity = originalOpacity === 0 ? 1 : originalOpacity;
+            if (progress <= 0) {
+                child.paths = originalPaths.map(p => p.clone());
+                child.setOpacity(childOpacity);
+                child.fill(child.getFillColor(), originalFillOpacity);
+                continue;
+            }
+            // Show partial paths (reverse progress)
+            const reverseProgress = 1 - progress;
+            child.setOpacity(childOpacity);
+            child.fill(child.getFillColor(), originalFillOpacity);
+            const partialPaths = [];
+            for (const originalPath of originalPaths) {
+                partialPaths.push(getPartialPath(originalPath, reverseProgress));
+            }
+            child.paths = partialPaths;
+        }
+    }
+}

package/dist/core/animations/draw/Write.d.ts

@@ -0,0 +1,35 @@
+import { IntroductoryAnimation } from '../categories';
+import { VMobject } from '../../../mobjects/VMobject';
+/**
+ * Animation that progressively draws a VMobject's paths from start to end.
+ * Preserves both stroke and fill properties - the complete object is visible at the end.
+ *
+ * This is the canonical animation for progressive path drawing.
+ * At progress 0, nothing is shown. At progress 1, the complete path is shown.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
+ *
+ * @example
+ * const circle = new Circle(1);
+ * scene.play(new Write(circle));  // Circle is drawn progressively
+ *
+ * const text = new Text('Hello');
+ * scene.play(new Write(text));  // Text is written progressively
+ */
+export declare class Write<T extends VMobject = VMobject> extends IntroductoryAnimation<T> {
+    private readonly isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    private readonly originalPaths;
+    private readonly originalOpacity;
+    private readonly originalFillOpacity;
+    /** For VGroup targets: original state of each child. */
+    private readonly childStates;
+    constructor(target: T);
+    interpolate(progress: number): void;
+    /** Interpolates a single VMobject (non-VGroup). */
+    private interpolateVMobject;
+    /** Interpolates a VGroup by animating each child's paths. */
+    private interpolateVGroup;
+}

package/dist/core/animations/draw/Write.js

@@ -0,0 +1,119 @@
+import { IntroductoryAnimation } from '../categories';
+import { getPartialPath } from './partialPath';
+/**
+ * Checks if a VMobject is a VGroup (has getChildren method).
+ * Uses duck-typing to avoid circular dependency with VGroup import.
+ */
+function isVGroup(target) {
+    return typeof target.getChildren === 'function';
+}
+/**
+ * Animation that progressively draws a VMobject's paths from start to end.
+ * Preserves both stroke and fill properties - the complete object is visible at the end.
+ *
+ * This is the canonical animation for progressive path drawing.
+ * At progress 0, nothing is shown. At progress 1, the complete path is shown.
+ *
+ * Supports VGroup (including Text): animates each child's paths progressively.
+ *
+ * This is an introductory animation - it auto-registers the target with the scene.
+ *
+ * @example
+ * const circle = new Circle(1);
+ * scene.play(new Write(circle));  // Circle is drawn progressively
+ *
+ * const text = new Text('Hello');
+ * scene.play(new Write(text));  // Text is written progressively
+ */
+export class Write extends IntroductoryAnimation {
+    isVGroup;
+    /** For non-VGroup targets: original paths on the target itself. */
+    originalPaths;
+    originalOpacity;
+    originalFillOpacity;
+    /** For VGroup targets: original state of each child. */
+    childStates;
+    constructor(target) {
+        super(target);
+        this.isVGroup = isVGroup(target);
+        this.originalOpacity = target.opacity;
+        this.originalFillOpacity = target.getFillOpacity();
+        if (this.isVGroup && isVGroup(target)) {
+            // Store original state for each child
+            this.originalPaths = [];
+            this.childStates = [];
+            for (const child of target.getChildren()) {
+                this.childStates.push({
+                    child,
+                    originalPaths: child.paths.map((p) => p.clone()),
+                    originalOpacity: child.opacity,
+                    originalFillOpacity: child.getFillOpacity(),
+                });
+            }
+        }
+        else {
+            // Store original paths on the target itself
+            this.originalPaths = target.paths.map(p => p.clone());
+            this.childStates = [];
+        }
+    }
+    interpolate(progress) {
+        if (this.isVGroup) {
+            this.interpolateVGroup(progress);
+        }
+        else {
+            this.interpolateVMobject(progress);
+        }
+    }
+    /** Interpolates a single VMobject (non-VGroup). */
+    interpolateVMobject(progress) {
+        if (progress <= 0) {
+            this.target.paths = [];
+            this.target.setOpacity(0);
+            return;
+        }
+        // Make visible and preserve original fill opacity
+        const targetOpacity = this.originalOpacity === 0 ? 1 : this.originalOpacity;
+        this.target.setOpacity(targetOpacity);
+        this.target.fill(this.target.getFillColor(), this.originalFillOpacity);
+        if (progress >= 1) {
+            this.target.paths = this.originalPaths.map(p => p.clone());
+            return;
+        }
+        // Show partial paths
+        const partialPaths = [];
+        for (const originalPath of this.originalPaths) {
+            partialPaths.push(getPartialPath(originalPath, progress));
+        }
+        this.target.paths = partialPaths;
+    }
+    /** Interpolates a VGroup by animating each child's paths. */
+    interpolateVGroup(progress) {
+        // Set parent VGroup opacity
+        const targetOpacity = this.originalOpacity === 0 ? 1 : this.originalOpacity;
+        this.target.setOpacity(progress <= 0 ? 0 : targetOpacity);
+        // Animate each child
+        for (const state of this.childStates) {
+            const { child, originalPaths, originalOpacity, originalFillOpacity } = state;
+            if (progress <= 0) {
+                child.paths = [];
+                child.setOpacity(0);
+                continue;
+            }
+            // Make child visible
+            const childOpacity = originalOpacity === 0 ? 1 : originalOpacity;
+            child.setOpacity(childOpacity);
+            child.fill(child.getFillColor(), originalFillOpacity);
+            if (progress >= 1) {
+                child.paths = originalPaths.map(p => p.clone());
+                continue;
+            }
+            // Show partial paths for this child
+            const partialPaths = [];
+            for (const originalPath of originalPaths) {
+                partialPaths.push(getPartialPath(originalPath, progress));
+            }
+            child.paths = partialPaths;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export { Draw } from './Draw';
+export { Write } from './Write';
+export { Unwrite } from './Unwrite';

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

@@ -0,0 +1,3 @@
+export { Draw } from './Draw';
+export { Write } from './Write';
+export { Unwrite } from './Unwrite';

package/dist/core/animations/draw/partialPath.d.ts

@@ -0,0 +1,6 @@
+import { BezierPath } from '../../math/bezier/BezierPath';
+/**
+ * Returns a partial BezierPath from the start up to a given normalized t (0–1).
+ * The path is truncated at the exact point corresponding to t * totalLength.
+ */
+export declare function getPartialPath(path: BezierPath, t: number): BezierPath;

package/dist/core/animations/draw/partialPath.js

@@ -0,0 +1,138 @@
+import { BezierPath } from '../../math/bezier/BezierPath';
+import { Vector2 } from '../../math/Vector2/Vector2';
+import { getQuadraticLength, getCubicLength } from '../../math/bezier/length';
+import { evaluateQuadratic } from '../../math/bezier/evaluators';
+import { splitCubicAt } from '../../math/bezier/split';
+/**
+ * Returns a partial BezierPath from the start up to a given normalized t (0–1).
+ * The path is truncated at the exact point corresponding to t * totalLength.
+ */
+export function getPartialPath(path, t) {
+    if (t <= 0) {
+        return new BezierPath();
+    }
+    if (t >= 1) {
+        return path.clone();
+    }
+    const totalLength = path.getLength();
+    if (totalLength === 0) {
+        return path.clone();
+    }
+    const targetLength = t * totalLength;
+    const commands = path.getCommands();
+    const result = new BezierPath();
+    let accumulatedLength = 0;
+    let cursor = Vector2.ZERO;
+    let subpathStart = Vector2.ZERO;
+    for (const cmd of commands) {
+        const segmentLength = getSegmentLength(cmd, cursor, subpathStart);
+        const newAccumulated = accumulatedLength + segmentLength;
+        if (newAccumulated <= targetLength) {
+            // Include entire segment
+            appendCommand(result, cmd, cursor, subpathStart);
+            updateCursor(cmd, cursor, subpathStart, (c, s) => {
+                cursor = c;
+                subpathStart = s;
+            });
+            accumulatedLength = newAccumulated;
+        }
+        else {
+            // Partial segment needed
+            const remaining = targetLength - accumulatedLength;
+            const localT = segmentLength > 0 ? remaining / segmentLength : 0;
+            appendPartialCommand(result, cmd, cursor, subpathStart, localT);
+            break;
+        }
+    }
+    return result;
+}
+function getSegmentLength(cmd, cursor, subpathStart) {
+    switch (cmd.type) {
+        case 'Move':
+            return 0;
+        case 'Line':
+            return cursor.subtract(cmd.end).length();
+        case 'Quadratic':
+            if (cmd.control1) {
+                return getQuadraticLength(cursor, cmd.control1, cmd.end);
+            }
+            return 0;
+        case 'Cubic':
+            if (cmd.control1 && cmd.control2) {
+                return getCubicLength(cursor, cmd.control1, cmd.control2, cmd.end);
+            }
+            return 0;
+        case 'Close':
+            return cursor.subtract(subpathStart).length();
+        default:
+            return 0;
+    }
+}
+function updateCursor(cmd, _cursor, subpathStart, update) {
+    switch (cmd.type) {
+        case 'Move':
+            update(cmd.end, cmd.end);
+            break;
+        case 'Close':
+            update(subpathStart, subpathStart);
+            break;
+        default:
+            update(cmd.end, subpathStart);
+            break;
+    }
+}
+function appendCommand(result, cmd, _cursor, _subpathStart) {
+    switch (cmd.type) {
+        case 'Move':
+            result.moveTo(cmd.end);
+            break;
+        case 'Line':
+            result.lineTo(cmd.end);
+            break;
+        case 'Quadratic':
+            if (cmd.control1) {
+                result.quadraticTo(cmd.control1, cmd.end);
+            }
+            break;
+        case 'Cubic':
+            if (cmd.control1 && cmd.control2) {
+                result.cubicTo(cmd.control1, cmd.control2, cmd.end);
+            }
+            break;
+        case 'Close':
+            result.closePath();
+            break;
+    }
+}
+function appendPartialCommand(result, cmd, cursor, subpathStart, localT) {
+    switch (cmd.type) {
+        case 'Move':
+            result.moveTo(cmd.end);
+            break;
+        case 'Line': {
+            const point = cursor.lerp(cmd.end, localT);
+            result.lineTo(point);
+            break;
+        }
+        case 'Quadratic': {
+            if (cmd.control1) {
+                const point = evaluateQuadratic(cursor, cmd.control1, cmd.end, localT);
+                // Approximate with line for partial quadratic
+                result.lineTo(point);
+            }
+            break;
+        }
+        case 'Cubic': {
+            if (cmd.control1 && cmd.control2) {
+                const [first] = splitCubicAt(cursor, cmd.control1, cmd.control2, cmd.end, localT);
+                result.cubicTo(first.control1, first.control2, first.end);
+            }
+            break;
+        }
+        case 'Close': {
+            const point = cursor.lerp(subpathStart, localT);
+            result.lineTo(point);
+            break;
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { EasingFunction } from './types';
+/**
+ * Bounce ease-in: bounces before settling.
+ */
+export declare const easeInBounce: EasingFunction;
+/**
+ * Bounce ease-out: bounces at the end.
+ */
+export declare const easeOutBounce: EasingFunction;
+/**
+ * Bounce ease-in-out: bounces at both ends.
+ */
+export declare const easeInOutBounce: EasingFunction;

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

@@ -0,0 +1,37 @@
+// --- Bounce helpers ---
+/**
+ * Bounce ease-out helper calculation.
+ */
+function bounceOut(t) {
+    const n1 = 7.5625;
+    const d1 = 2.75;
+    if (t < 1 / d1) {
+        return n1 * t * t;
+    }
+    else if (t < 2 / d1) {
+        const adjusted = t - 1.5 / d1;
+        return n1 * adjusted * adjusted + 0.75;
+    }
+    else if (t < 2.5 / d1) {
+        const adjusted = t - 2.25 / d1;
+        return n1 * adjusted * adjusted + 0.9375;
+    }
+    else {
+        const adjusted = t - 2.625 / d1;
+        return n1 * adjusted * adjusted + 0.984375;
+    }
+}
+/**
+ * Bounce ease-in: bounces before settling.
+ */
+export const easeInBounce = (t) => 1 - bounceOut(1 - t);
+/**
+ * Bounce ease-out: bounces at the end.
+ */
+export const easeOutBounce = bounceOut;
+/**
+ * Bounce ease-in-out: bounces at both ends.
+ */
+export const easeInOutBounce = (t) => t < 0.5
+    ? (1 - bounceOut(1 - 2 * t)) / 2
+    : (1 + bounceOut(2 * t - 1)) / 2;

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

@@ -0,0 +1,7 @@
+export type { EasingFunction } from './types';
+export { linear, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInQuart, easeOutQuart, easeInOutQuart, easeInQuint, easeOutQuint, easeInOutQuint, easeInSine, easeOutSine, easeInOutSine, easeInExpo, easeOutExpo, easeInOutExpo, easeInCirc, easeOutCirc, easeInOutCirc, easeInBack, easeOutBack, easeInOutBack, easeInElastic, easeOutElastic, easeInOutElastic, } from './standard';
+export { easeInBounce, easeOutBounce, easeInOutBounce, } from './bounce';
+export { smooth, doubleSmooth, rushInto, rushFrom, slowInto, thereAndBack, thereAndBackWithPause, runningStart, wiggle, notQuiteThere, lingering, exponentialDecay, } from './manim';
+export { registerEasing, getEasing, hasEasing, unregisterEasing, clearRegistry, } from './registry';
+import { smooth } from './manim';
+export { smooth as defaultEasing };

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

@@ -0,0 +1,11 @@
+// Standard easing functions
+export { linear, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInQuart, easeOutQuart, easeInOutQuart, easeInQuint, easeOutQuint, easeInOutQuint, easeInSine, easeOutSine, easeInOutSine, easeInExpo, easeOutExpo, easeInOutExpo, easeInCirc, easeOutCirc, easeInOutCirc, easeInBack, easeOutBack, easeInOutBack, easeInElastic, easeOutElastic, easeInOutElastic, } from './standard';
+// Bounce functions
+export { easeInBounce, easeOutBounce, easeInOutBounce, } from './bounce';
+// Manim-style rate functions
+export { smooth, doubleSmooth, rushInto, rushFrom, slowInto, thereAndBack, thereAndBackWithPause, runningStart, wiggle, notQuiteThere, lingering, exponentialDecay, } from './manim';
+// Custom easing registry
+export { registerEasing, getEasing, hasEasing, unregisterEasing, clearRegistry, } from './registry';
+// Re-export smooth as the default easing
+import { smooth } from './manim';
+export { smooth as defaultEasing };