@redwilly/anima 0.1.0 → 0.1.2

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

@@ -1,120 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

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

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

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,37 +0,0 @@
-// --- 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

@@ -1,7 +0,0 @@
-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

@@ -1,11 +0,0 @@
-// 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 };

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

@@ -1,46 +0,0 @@
-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

@@ -1,102 +0,0 @@
-/**
- * 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

@@ -1,8 +0,0 @@
-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;