@redwilly/anima 0.1.0 → 0.1.2

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,40 +0,0 @@
-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);
-        }
-    }
-}

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

@@ -1,31 +0,0 @@
-import type { EasingFunction } from '../easing';
-import type { Keyframe, KeyframeValue, InterpolatorFn } from './types';
-/**
- * Manages a sequence of keyframes for animating a single property.
- * Keyframes are stored sorted by time and interpolated on demand.
- */
-export declare class KeyframeTrack<T extends KeyframeValue = number> {
-    private keyframes;
-    private readonly interpolator;
-    /**
-     * Creates a new KeyframeTrack with the specified interpolator.
-     * Defaults to linear number interpolation.
-     */
-    constructor(interpolator?: InterpolatorFn<T>);
-    /**
-     * Adds a keyframe at the specified normalized time.
-     * Time must be in [0, 1]. Replaces existing keyframe at same time.
-     */
-    addKeyframe(time: number, value: T, easing?: EasingFunction): this;
-    removeKeyframe(time: number): boolean;
-    /**
-     * Gets the keyframe at the specified time.
-     * Returns undefined if no keyframe exists at that time.
-     */
-    getKeyframe(time: number): Keyframe<T> | undefined;
-    /** All keyframes sorted by time. */
-    getKeyframes(): ReadonlyArray<Keyframe<T>>;
-    /** Interpolated value at normalized time (uses target keyframe easing). */
-    getValueAt(time: number): T;
-    getKeyframeCount(): number;
-}

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

@@ -1,83 +0,0 @@
-import { linear } from '../easing';
-import { lerpNumber } from './types';
-/**
- * Manages a sequence of keyframes for animating a single property.
- * Keyframes are stored sorted by time and interpolated on demand.
- */
-export class KeyframeTrack {
-    keyframes = [];
-    interpolator;
-    /**
-     * Creates a new KeyframeTrack with the specified interpolator.
-     * Defaults to linear number interpolation.
-     */
-    constructor(interpolator) {
-        this.interpolator = interpolator ?? lerpNumber;
-    }
-    /**
-     * Adds a keyframe at the specified normalized time.
-     * Time must be in [0, 1]. Replaces existing keyframe at same time.
-     */
-    addKeyframe(time, value, easing) {
-        if (time < 0 || time > 1) {
-            throw new Error('Keyframe time must be in [0, 1]');
-        }
-        // Remove existing keyframe at same time
-        this.keyframes = this.keyframes.filter((kf) => kf.time !== time);
-        const keyframe = { time, value, easing };
-        this.keyframes.push(keyframe);
-        this.keyframes.sort((a, b) => a.time - b.time);
-        return this;
-    }
-    removeKeyframe(time) {
-        const initialLength = this.keyframes.length;
-        this.keyframes = this.keyframes.filter((kf) => kf.time !== time);
-        return this.keyframes.length < initialLength;
-    }
-    /**
-     * Gets the keyframe at the specified time.
-     * Returns undefined if no keyframe exists at that time.
-     */
-    getKeyframe(time) {
-        return this.keyframes.find((kf) => kf.time === time);
-    }
-    /** All keyframes sorted by time. */
-    getKeyframes() {
-        return this.keyframes;
-    }
-    /** Interpolated value at normalized time (uses target keyframe easing). */
-    getValueAt(time) {
-        if (this.keyframes.length === 0) {
-            throw new Error('KeyframeTrack has no keyframes');
-        }
-        const clampedTime = Math.max(0, Math.min(1, time));
-        // Find keyframes before and after the requested time
-        let prevKeyframe;
-        let nextKeyframe;
-        for (const kf of this.keyframes) {
-            if (kf.time <= clampedTime) {
-                prevKeyframe = kf;
-            }
-            if (kf.time >= clampedTime && nextKeyframe === undefined) {
-                nextKeyframe = kf;
-            }
-        }
-        if (prevKeyframe === undefined) {
-            return this.keyframes[0].value;
-        }
-        if (nextKeyframe === undefined) {
-            return prevKeyframe.value;
-        }
-        if (prevKeyframe === nextKeyframe) {
-            return prevKeyframe.value;
-        }
-        const span = nextKeyframe.time - prevKeyframe.time;
-        const localProgress = (clampedTime - prevKeyframe.time) / span;
-        const easing = nextKeyframe.easing ?? linear;
-        const easedProgress = easing(localProgress);
-        return this.interpolator(prevKeyframe.value, nextKeyframe.value, easedProgress);
-    }
-    getKeyframeCount() {
-        return this.keyframes.length;
-    }
-}

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

@@ -1,4 +0,0 @@
-export type { Keyframe, KeyframeValue, InterpolatorFn } from './types';
-export { lerpNumber } from './types';
-export { KeyframeTrack } from './KeyframeTrack';
-export { KeyframeAnimation } from './KeyframeAnimation';

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

@@ -1,5 +0,0 @@
-export { lerpNumber } from './types';
-// Keyframe track
-export { KeyframeTrack } from './KeyframeTrack';
-// Keyframe animation
-export { KeyframeAnimation } from './KeyframeAnimation';

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

@@ -1,25 +0,0 @@
-import type { EasingFunction } from '../easing';
-/**
- * Supported value types for keyframe interpolation.
- */
-export type KeyframeValue = number;
-/**
- * A single keyframe with a normalized time position [0,1] and value.
- */
-export interface Keyframe<T extends KeyframeValue = KeyframeValue> {
-    /** Normalized time position in [0, 1]. */
-    readonly time: number;
-    /** The value at this keyframe. */
-    readonly value: T;
-    /** Optional easing function for interpolation TO this keyframe. */
-    readonly easing?: EasingFunction;
-}
-/**
- * Interpolation function for a specific value type.
- * Takes start value, end value, and progress [0,1], returns interpolated value.
- */
-export type InterpolatorFn<T> = (start: T, end: T, progress: number) => T;
-/**
- * Default numeric interpolation (linear).
- */
-export declare function lerpNumber(a: number, b: number, t: number): number;

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

@@ -1,6 +0,0 @@
-/**
- * Default numeric interpolation (linear).
- */
-export function lerpNumber(a, b, t) {
-    return a + (b - a) * t;
-}