manim-web 0.2.0

package/dist/animation/movement/Rotate.d.ts

@@ -0,0 +1,47 @@
+import { Mobject, Vector3Tuple } from '../../core/Mobject';
+import { Animation, AnimationOptions } from '../Animation';
+export interface RotateOptions extends AnimationOptions {
+    /** Angle to rotate in radians */
+    angle: number;
+    /** Axis of rotation [x, y, z], defaults to Z axis [0, 0, 1] */
+    axis?: Vector3Tuple;
+    /** Point to rotate about, defaults to mobject center */
+    aboutPoint?: Vector3Tuple;
+}
+export declare class Rotate extends Animation {
+    /** Angle to rotate in radians */
+    readonly angle: number;
+    /** Axis of rotation */
+    readonly axis: Vector3Tuple;
+    /** Point to rotate about */
+    readonly aboutPoint: Vector3Tuple | null;
+    /** Initial rotation stored as quaternion */
+    private _initialQuaternion;
+    /** Initial position (for rotation about a point) */
+    private _initialPosition;
+    /** Rotation axis as THREE.Vector3 */
+    private _axisVector;
+    /** About point as THREE.Vector3 */
+    private _aboutPointVector;
+    constructor(mobject: Mobject, options: RotateOptions);
+    /**
+     * Set up the animation - store initial rotation
+     */
+    begin(): void;
+    /**
+     * Interpolate the rotation at the given alpha
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Ensure the rotation is exact at the end
+     */
+    finish(): void;
+}
+/**
+ * Create a Rotate animation for a mobject.
+ * @param mobject The mobject to rotate
+ * @param angle Angle to rotate in radians
+ * @param options Animation options (duration, rateFunc, axis, aboutPoint)
+ */
+export declare function rotate(mobject: Mobject, angle: number, options?: Omit<RotateOptions, 'angle'>): Rotate;
+//# sourceMappingURL=Rotate.d.ts.map

package/dist/animation/movement/Rotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rotate.d.ts","sourceRoot":"","sources":["../../../src/animation/movement/Rotate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,WAAW,aAAc,SAAQ,gBAAgB;IACrD,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,+DAA+D;IAC/D,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,wDAAwD;IACxD,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B;AAED,qBAAa,MAAO,SAAQ,SAAS;IACnC,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB,uBAAuB;IACvB,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAE5B,4BAA4B;IAC5B,QAAQ,CAAC,UAAU,EAAE,YAAY,GAAG,IAAI,CAAC;IAEzC,4CAA4C;IAC5C,OAAO,CAAC,kBAAkB,CAA4C;IAEtE,oDAAoD;IACpD,OAAO,CAAC,gBAAgB,CAAsC;IAE9D,qCAAqC;IACrC,OAAO,CAAC,WAAW,CAAsC;IAEzD,mCAAmC;IACnC,OAAO,CAAC,iBAAiB,CAA8B;gBAE3C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,aAAa;IAOpD;;OAEG;IACM,KAAK,IAAI,IAAI;IA0BtB;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IA6BhC;;OAEG;IACM,MAAM,IAAI,IAAI;CAIxB;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,OAAO,EAAE,OAAO,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GACrC,MAAM,CAER"}

package/dist/animation/movement/Scale.d.ts

@@ -0,0 +1,74 @@
+import { Mobject, Vector3Tuple } from '../../core/Mobject';
+import { Animation, AnimationOptions } from '../Animation';
+export interface ScaleOptions extends AnimationOptions {
+    /** Scale factor: number for uniform scale, tuple for per-axis scale */
+    scaleFactor: number | Vector3Tuple;
+    /** Point to scale about, defaults to mobject center */
+    aboutPoint?: Vector3Tuple;
+}
+export declare class Scale extends Animation {
+    /** Scale factor */
+    readonly scaleFactor: number | Vector3Tuple;
+    /** Point to scale about */
+    readonly aboutPoint: Vector3Tuple | null;
+    /** Initial scale vector */
+    private _initialScale;
+    /** Target scale vector */
+    private _targetScale;
+    /** Initial position */
+    private _initialPosition;
+    /** About point as THREE.Vector3 */
+    private _aboutPointVector;
+    constructor(mobject: Mobject, options: ScaleOptions);
+    /**
+     * Set up the animation - store initial scale
+     */
+    begin(): void;
+    /**
+     * Interpolate the scale at the given alpha
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Ensure the scale is exact at the end
+     */
+    finish(): void;
+}
+/**
+ * Create a Scale animation for a mobject.
+ * @param mobject The mobject to scale
+ * @param factor Scale factor (number for uniform, tuple for per-axis)
+ * @param options Animation options (duration, rateFunc, aboutPoint)
+ */
+export declare function scale(mobject: Mobject, factor: number | Vector3Tuple, options?: Omit<ScaleOptions, 'scaleFactor'>): Scale;
+/**
+ * GrowFromCenter options
+ */
+export interface GrowFromCenterOptions extends AnimationOptions {
+}
+/**
+ * GrowFromCenter animation - scales from 0 to 1, appearing from center.
+ */
+export declare class GrowFromCenter extends Animation {
+    /** Initial scale to restore at begin */
+    private _targetScale;
+    constructor(mobject: Mobject, options?: GrowFromCenterOptions);
+    /**
+     * Set up the animation - start with scale 0
+     */
+    begin(): void;
+    /**
+     * Interpolate the scale from 0 to target
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Ensure the scale is exact at the end
+     */
+    finish(): void;
+}
+/**
+ * Create a GrowFromCenter animation for a mobject.
+ * @param mobject The mobject to grow from center
+ * @param options Animation options (duration, rateFunc)
+ */
+export declare function growFromCenter(mobject: Mobject, options?: GrowFromCenterOptions): GrowFromCenter;
+//# sourceMappingURL=Scale.d.ts.map

package/dist/animation/movement/Scale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scale.d.ts","sourceRoot":"","sources":["../../../src/animation/movement/Scale.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,WAAW,YAAa,SAAQ,gBAAgB;IACpD,uEAAuE;IACvE,WAAW,EAAE,MAAM,GAAG,YAAY,CAAC;IACnC,uDAAuD;IACvD,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B;AAaD,qBAAa,KAAM,SAAQ,SAAS;IAClC,mBAAmB;IACnB,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,YAAY,CAAC;IAE5C,2BAA2B;IAC3B,QAAQ,CAAC,UAAU,EAAE,YAAY,GAAG,IAAI,CAAC;IAEzC,2BAA2B;IAC3B,OAAO,CAAC,aAAa,CAAsC;IAE3D,0BAA0B;IAC1B,OAAO,CAAC,YAAY,CAAsC;IAE1D,uBAAuB;IACvB,OAAO,CAAC,gBAAgB,CAAsC;IAE9D,mCAAmC;IACnC,OAAO,CAAC,iBAAiB,CAA8B;gBAE3C,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY;IAMnD;;OAEG;IACM,KAAK,IAAI,IAAI;IA0CtB;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAyBhC;;OAEG;IACM,MAAM,IAAI,IAAI;CAIxB;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,YAAY,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,GAC1C,KAAK,CAEP;AAED;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;CAAG;AAElE;;GAEG;AACH,qBAAa,cAAe,SAAQ,SAAS;IAC3C,wCAAwC;IACxC,OAAO,CAAC,YAAY,CAAsC;gBAE9C,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE,qBAA0B;IAIjE;;OAEG;IACM,KAAK,IAAI,IAAI;IAUtB;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAShC;;OAEG;IACM,MAAM,IAAI,IAAI;CAKxB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,OAAO,EAChB,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAEhB"}

package/dist/animation/movement/Shift.d.ts

@@ -0,0 +1,74 @@
+import { Mobject, Vector3Tuple } from '../../core/Mobject';
+import { Animation, AnimationOptions } from '../Animation';
+export interface ShiftOptions extends AnimationOptions {
+    /** Direction/delta to move [dx, dy, dz] */
+    direction: Vector3Tuple;
+}
+export declare class Shift extends Animation {
+    /** Direction to shift */
+    readonly direction: Vector3Tuple;
+    /** Initial position */
+    private _initialPosition;
+    /** Target position */
+    private _targetPosition;
+    constructor(mobject: Mobject, options: ShiftOptions);
+    /**
+     * Set up the animation - store initial position
+     */
+    begin(): void;
+    /**
+     * Interpolate the position at the given alpha
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Ensure the position is exact at the end
+     */
+    finish(): void;
+}
+/**
+ * Create a Shift animation for a mobject.
+ * @param mobject The mobject to shift
+ * @param direction Direction/delta to move [dx, dy, dz]
+ * @param options Animation options (duration, rateFunc)
+ */
+export declare function shift(mobject: Mobject, direction: Vector3Tuple, options?: Omit<ShiftOptions, 'direction'>): Shift;
+/**
+ * MoveToTargetPosition options - moves mobject to its targetPosition property.
+ */
+export interface MoveToTargetPositionOptions extends AnimationOptions {
+}
+/**
+ * Interface for mobjects with a targetPosition property.
+ */
+export interface MobjectWithTargetPosition extends Mobject {
+    targetPosition?: Vector3Tuple;
+}
+/**
+ * MoveToTargetPosition animation - moves a mobject to its targetPosition property.
+ */
+export declare class MoveToTargetPosition extends Animation {
+    /** Initial position */
+    private _initialPosition;
+    /** Target position */
+    private _targetPosition;
+    constructor(mobject: MobjectWithTargetPosition, options?: MoveToTargetPositionOptions);
+    /**
+     * Set up the animation - store initial and target positions
+     */
+    begin(): void;
+    /**
+     * Interpolate the position at the given alpha
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Ensure the position is exact at the end
+     */
+    finish(): void;
+}
+/**
+ * Create a MoveToTargetPosition animation for a mobject.
+ * @param mobject The mobject to move (must have targetPosition set)
+ * @param options Animation options (duration, rateFunc)
+ */
+export declare function moveToTargetPosition(mobject: MobjectWithTargetPosition, options?: MoveToTargetPositionOptions): MoveToTargetPosition;
+//# sourceMappingURL=Shift.d.ts.map

package/dist/animation/movement/Shift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Shift.d.ts","sourceRoot":"","sources":["../../../src/animation/movement/Shift.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,WAAW,YAAa,SAAQ,gBAAgB;IACpD,2CAA2C;IAC3C,SAAS,EAAE,YAAY,CAAC;CACzB;AAED,qBAAa,KAAM,SAAQ,SAAS;IAClC,yBAAyB;IACzB,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IAEjC,uBAAuB;IACvB,OAAO,CAAC,gBAAgB,CAAsC;IAE9D,sBAAsB;IACtB,OAAO,CAAC,eAAe,CAAsC;gBAEjD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY;IAKnD;;OAEG;IACM,KAAK,IAAI,IAAI;IActB;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAShC;;OAEG;IACM,MAAM,IAAI,IAAI;CAKxB;AAED;;;;;GAKG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,YAAY,EACvB,OAAO,CAAC,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,GACxC,KAAK,CAEP;AAED;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,gBAAgB;CAAG;AAExE;;GAEG;AACH,MAAM,WAAW,yBAA0B,SAAQ,OAAO;IACxD,cAAc,CAAC,EAAE,YAAY,CAAC;CAC/B;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,uBAAuB;IACvB,OAAO,CAAC,gBAAgB,CAAsC;IAE9D,sBAAsB;IACtB,OAAO,CAAC,eAAe,CAAsC;gBAEjD,OAAO,EAAE,yBAAyB,EAAE,OAAO,GAAE,2BAAgC;IASzF;;OAEG;IACM,KAAK,IAAI,IAAI;IAkBtB;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAShC;;OAEG;IACM,MAAM,IAAI,IAAI;CAKxB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,yBAAyB,EAClC,OAAO,CAAC,EAAE,2BAA2B,GACpC,oBAAoB,CAEtB"}

package/dist/animation/movement/index.d.ts

@@ -0,0 +1,6 @@
+export { Rotate, rotate, type RotateOptions } from './Rotate';
+export { Scale, scale, GrowFromCenter, growFromCenter, type ScaleOptions, type GrowFromCenterOptions } from './Scale';
+export { Shift, shift, MoveToTargetPosition, moveToTargetPosition, type ShiftOptions, type MoveToTargetPositionOptions, type MobjectWithTargetPosition } from './Shift';
+export { MoveAlongPath, moveAlongPath, type MoveAlongPathOptions } from './MoveAlongPath';
+export { Homotopy, homotopy, ComplexHomotopy, complexHomotopy, SmoothedVectorizedHomotopy, smoothedVectorizedHomotopy, PhaseFlow, phaseFlow, type HomotopyFunction, type ComplexHomotopyFunction, type VectorFieldFunction, type Complex, type HomotopyOptions, type ComplexHomotopyOptions, type SmoothedVectorizedHomotopyOptions, type PhaseFlowOptions } from './Homotopy';
+//# sourceMappingURL=index.d.ts.map

package/dist/animation/movement/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/animation/movement/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,MAAM,EACN,MAAM,EACN,KAAK,aAAa,EACnB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,KAAK,EACL,KAAK,EACL,cAAc,EACd,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC3B,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,KAAK,EACL,KAAK,EACL,oBAAoB,EACpB,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC/B,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,aAAa,EACb,aAAa,EACb,KAAK,oBAAoB,EAC1B,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,QAAQ,EACR,QAAQ,EACR,eAAe,EACf,eAAe,EACf,0BAA0B,EAC1B,0BAA0B,EAC1B,SAAS,EACT,SAAS,EACT,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,iCAAiC,EACtC,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC"}

package/dist/animation/numbers/index.d.ts

@@ -0,0 +1,152 @@
+import { Animation, AnimationOptions } from '../Animation';
+import { DecimalNumber } from '../../mobjects/text/DecimalNumber';
+/**
+ * Options for ChangingDecimal animation
+ */
+export interface ChangingDecimalOptions extends AnimationOptions {
+    /** Starting value (default: current DecimalNumber value) */
+    startValue?: number;
+    /** Ending value (required) */
+    endValue: number;
+    /** Whether to suspend updating the DecimalNumber display during animation (default: false) */
+    suspendMobjectUpdating?: boolean;
+}
+/**
+ * ChangingDecimal - Animate a DecimalNumber's value changing from start to end.
+ *
+ * This animation smoothly interpolates between two numeric values, updating
+ * the DecimalNumber's display on each frame. The number formatting (decimal places,
+ * sign, commas) is preserved throughout the animation.
+ *
+ * @example
+ * ```typescript
+ * // Create a decimal number starting at 0
+ * const num = new DecimalNumber({ value: 0, numDecimalPlaces: 2 });
+ *
+ * // Animate from 0 to 100
+ * timeline.add(new ChangingDecimal(num, { endValue: 100 }));
+ *
+ * // Animate from a specific start value
+ * timeline.add(new ChangingDecimal(num, {
+ *   startValue: 50,
+ *   endValue: 200,
+ *   duration: 2
+ * }));
+ * ```
+ */
+export declare class ChangingDecimal extends Animation {
+    /** The DecimalNumber being animated */
+    readonly decimalNumber: DecimalNumber;
+    /** Starting value for the animation */
+    private _startValue;
+    /** Ending value for the animation */
+    private _endValue;
+    /** Whether to suspend mobject updating during animation */
+    private _suspendMobjectUpdating;
+    constructor(decimalNumber: DecimalNumber, options: ChangingDecimalOptions);
+    /**
+     * Called when the animation starts.
+     * Captures the current value if no explicit start value was provided.
+     */
+    begin(): void;
+    /**
+     * Interpolate the decimal value at the given alpha.
+     * @param alpha - Progress from 0 (start) to 1 (end), after rate function applied
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Called when the animation ends.
+     * Ensures the final value is set exactly.
+     */
+    finish(): void;
+    /**
+     * Get the start value of the animation
+     */
+    getStartValue(): number;
+    /**
+     * Get the end value of the animation
+     */
+    getEndValue(): number;
+}
+/**
+ * Options for ChangeDecimalToValue animation
+ */
+export interface ChangeDecimalToValueOptions extends AnimationOptions {
+    /** Target value to animate to (required) */
+    targetValue: number;
+    /** Whether to suspend updating the DecimalNumber display during animation (default: false) */
+    suspendMobjectUpdating?: boolean;
+}
+/**
+ * ChangeDecimalToValue - Animate a DecimalNumber to a specific target value.
+ *
+ * This is a convenience animation that automatically uses the DecimalNumber's
+ * current value as the starting point. It's equivalent to ChangingDecimal
+ * with startValue set to the current value.
+ *
+ * @example
+ * ```typescript
+ * // Create a decimal number at 42
+ * const num = new DecimalNumber({ value: 42 });
+ *
+ * // Animate to 100 (starts from current value 42)
+ * timeline.add(new ChangeDecimalToValue(num, { targetValue: 100 }));
+ *
+ * // With custom duration and rate function
+ * timeline.add(new ChangeDecimalToValue(num, {
+ *   targetValue: 0,
+ *   duration: 2,
+ *   rateFunc: easeInOut
+ * }));
+ * ```
+ */
+export declare class ChangeDecimalToValue extends Animation {
+    /** The DecimalNumber being animated */
+    readonly decimalNumber: DecimalNumber;
+    /** Starting value (captured at animation begin) */
+    private _startValue;
+    /** Target value for the animation */
+    private _targetValue;
+    /** Whether to suspend mobject updating during animation */
+    private _suspendMobjectUpdating;
+    constructor(decimalNumber: DecimalNumber, options: ChangeDecimalToValueOptions);
+    /**
+     * Called when the animation starts.
+     * Captures the current value as the starting point.
+     */
+    begin(): void;
+    /**
+     * Interpolate the decimal value at the given alpha.
+     * @param alpha - Progress from 0 (start) to 1 (end), after rate function applied
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Called when the animation ends.
+     * Ensures the final value is set exactly.
+     */
+    finish(): void;
+    /**
+     * Get the start value of the animation
+     */
+    getStartValue(): number;
+    /**
+     * Get the target value of the animation
+     */
+    getTargetValue(): number;
+}
+/**
+ * Factory function to create a ChangingDecimal animation.
+ * @param decimalNumber - The DecimalNumber to animate
+ * @param options - Animation options including start and end values
+ * @returns A new ChangingDecimal animation
+ */
+export declare function changingDecimal(decimalNumber: DecimalNumber, options: ChangingDecimalOptions): ChangingDecimal;
+/**
+ * Factory function to create a ChangeDecimalToValue animation.
+ * @param decimalNumber - The DecimalNumber to animate
+ * @param options - Animation options including target value
+ * @returns A new ChangeDecimalToValue animation
+ */
+export declare function changeDecimalToValue(decimalNumber: DecimalNumber, options: ChangeDecimalToValueOptions): ChangeDecimalToValue;
+export default ChangingDecimal;
+//# sourceMappingURL=index.d.ts.map

package/dist/animation/numbers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/animation/numbers/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC9D,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,8FAA8F;IAC9F,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,uCAAuC;IACvC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IAEtC,uCAAuC;IACvC,OAAO,CAAC,WAAW,CAAS;IAE5B,qCAAqC;IACrC,OAAO,CAAC,SAAS,CAAS;IAE1B,2DAA2D;IAC3D,OAAO,CAAC,uBAAuB,CAAU;gBAE7B,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,sBAAsB;IASzE;;;OAGG;IACM,KAAK,IAAI,IAAI;IAQtB;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAShC;;;OAGG;IACM,MAAM,IAAI,IAAI;IAMvB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,WAAW,IAAI,MAAM;CAGtB;AAED;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,gBAAgB;IACnE,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,8FAA8F;IAC9F,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,uCAAuC;IACvC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;IAEtC,mDAAmD;IACnD,OAAO,CAAC,WAAW,CAAS;IAE5B,qCAAqC;IACrC,OAAO,CAAC,YAAY,CAAS;IAE7B,2DAA2D;IAC3D,OAAO,CAAC,uBAAuB,CAAU;gBAE7B,aAAa,EAAE,aAAa,EAAE,OAAO,EAAE,2BAA2B;IAS9E;;;OAGG;IACM,KAAK,IAAI,IAAI;IAMtB;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAShC;;;OAGG;IACM,MAAM,IAAI,IAAI;IAMvB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,cAAc,IAAI,MAAM;CAGzB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,sBAAsB,GAC9B,eAAe,CAEjB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,aAAa,EAC5B,OAAO,EAAE,2BAA2B,GACnC,oBAAoB,CAEtB;AAED,eAAe,eAAe,CAAC"}

package/dist/animation/speed/index.d.ts

@@ -0,0 +1,114 @@
+import { Animation } from '../Animation';
+/**
+ * Speed function type: maps progress (0-1) to a speed multiplier.
+ * - Values > 1 speed up the animation at that point
+ * - Values < 1 slow down the animation at that point
+ * - Values = 1 play at normal speed
+ */
+export type SpeedFunction = (t: number) => number;
+export interface ChangeSpeedOptions {
+    /** Rate function applied to the overall animation progress (default: linear) */
+    rateFunc?: (t: number) => number;
+}
+/**
+ * ChangeSpeed - Wraps an animation to modify its playback speed dynamically.
+ *
+ * The speed function maps progress (0-1) to a speed multiplier:
+ * - speed(0.5) = 2 means at the halfway point, play at 2x speed
+ * - speed(0.2) = 0.5 means at 20% progress, play at 0.5x speed (slower)
+ *
+ * This is useful for emphasizing certain parts of an animation by slowing them down,
+ * or rushing through less important parts by speeding them up.
+ *
+ * @example
+ * ```typescript
+ * // Slow down the middle of an animation
+ * const anim = changeSpeed(
+ *   fadeIn(circle),
+ *   (t) => t < 0.3 || t > 0.7 ? 2 : 0.5 // Fast start/end, slow middle
+ * );
+ *
+ * // Exponential slowdown (dramatic ending)
+ * const anim2 = changeSpeed(
+ *   transform(square, circle),
+ *   (t) => 2 - t // Starts at 2x, ends at 1x
+ * );
+ * ```
+ */
+export declare class ChangeSpeed extends Animation {
+    /** The wrapped animation */
+    readonly animation: Animation;
+    /** The speed function */
+    readonly speedFunc: SpeedFunction;
+    /** Number of samples for numerical integration */
+    private readonly _numSamples;
+    constructor(animation: Animation, speedFunc: SpeedFunction, options?: ChangeSpeedOptions);
+    /**
+     * Set up the animation - call begin on the wrapped animation
+     */
+    begin(): void;
+    /**
+     * Map adjusted progress to original animation progress and interpolate
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Finish the wrapped animation
+     */
+    finish(): void;
+    /**
+     * Reset both this animation and the wrapped animation
+     */
+    reset(): void;
+}
+/**
+ * Create a ChangeSpeed animation that modifies playback speed dynamically.
+ *
+ * @param animation The animation to wrap
+ * @param speedFunc A function mapping progress (0-1) to speed multiplier
+ * @param options Optional configuration
+ * @returns A new ChangeSpeed animation
+ *
+ * @example
+ * ```typescript
+ * // Slow down at the end for emphasis
+ * changeSpeed(fadeIn(circle), (t) => 1 + (1 - t));
+ *
+ * // Speed up in the middle
+ * changeSpeed(rotate(square), (t) => {
+ *   const mid = Math.abs(t - 0.5);
+ *   return 0.5 + mid * 3; // Slow at edges, fast in middle
+ * });
+ * ```
+ */
+export declare function changeSpeed(animation: Animation, speedFunc: SpeedFunction, options?: ChangeSpeedOptions): ChangeSpeed;
+/**
+ * Linear speed ramp from startSpeed to endSpeed.
+ */
+export declare function linearSpeedRamp(startSpeed: number, endSpeed: number): SpeedFunction;
+/**
+ * Speed that emphasizes (slows down) a specific portion of the animation.
+ *
+ * @param emphasizeStart Start of the emphasized region (0-1)
+ * @param emphasizeEnd End of the emphasized region (0-1)
+ * @param normalSpeed Speed outside the emphasized region
+ * @param emphasizedSpeed Speed during the emphasized region (typically < normalSpeed)
+ */
+export declare function emphasizeRegion(emphasizeStart: number, emphasizeEnd: number, normalSpeed?: number, emphasizedSpeed?: number): SpeedFunction;
+/**
+ * Speed that rushes through (speeds up) a specific portion of the animation.
+ *
+ * @param rushStart Start of the rushed region (0-1)
+ * @param rushEnd End of the rushed region (0-1)
+ * @param normalSpeed Speed outside the rushed region
+ * @param rushedSpeed Speed during the rushed region (typically > normalSpeed)
+ */
+export declare function rushRegion(rushStart: number, rushEnd: number, normalSpeed?: number, rushedSpeed?: number): SpeedFunction;
+/**
+ * Smooth speed transition using a sine-based curve.
+ * Useful for creating natural-feeling speed variations.
+ *
+ * @param minSpeed Minimum speed (at t=0.5)
+ * @param maxSpeed Maximum speed (at t=0 and t=1)
+ */
+export declare function smoothSpeedCurve(minSpeed: number, maxSpeed: number): SpeedFunction;
+//# sourceMappingURL=index.d.ts.map

package/dist/animation/speed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/animation/speed/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAIzC;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAElD,MAAM,WAAW,kBAAkB;IACjC,gFAAgF;IAChF,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAClC;AAmGD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACxC,4BAA4B;IAC5B,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAE9B,yBAAyB;IACzB,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC;IAElC,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAe;gBAGzC,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,aAAa,EACxB,OAAO,GAAE,kBAAuB;IAoBlC;;OAEG;IACM,KAAK,IAAI,IAAI;IAKtB;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAehC;;OAEG;IACM,MAAM,IAAI,IAAI;IAKvB;;OAEG;IACM,KAAK,IAAI,IAAI;CAIvB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CACzB,SAAS,EAAE,SAAS,EACpB,SAAS,EAAE,aAAa,EACxB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,WAAW,CAEb;AAID;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAEnF;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,WAAW,GAAE,MAAU,EACvB,eAAe,GAAE,MAAY,GAC5B,aAAa,CAOf;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,MAAU,EACvB,WAAW,GAAE,MAAU,GACtB,aAAa,CAOf;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,aAAa,CAMlF"}

package/dist/animation/transform/ApplyPointwiseFunction.d.ts

@@ -0,0 +1,23 @@
+import { Mobject } from '../../core/Mobject';
+import { Animation, AnimationOptions } from '../Animation';
+export interface ApplyPointwiseFunctionOptions extends AnimationOptions {
+    /** Function to apply to each point [x, y, z] => [x', y', z'] */
+    func?: (point: number[]) => number[];
+}
+/**
+ * ApplyPointwiseFunction — applies a point-wise function to every VMobject
+ * in the family tree and interpolates from start to target over the animation.
+ */
+export declare class ApplyPointwiseFunction extends Animation {
+    readonly func: (point: number[]) => number[];
+    private _snapshots;
+    constructor(mobject: Mobject, func: (point: number[]) => number[], options?: Omit<ApplyPointwiseFunctionOptions, 'func'>);
+    begin(): void;
+    interpolate(alpha: number): void;
+    finish(): void;
+}
+/**
+ * Factory helper.
+ */
+export declare function applyPointwiseFunction(mobject: Mobject, func: (point: number[]) => number[], options?: Omit<ApplyPointwiseFunctionOptions, 'func'>): ApplyPointwiseFunction;
+//# sourceMappingURL=ApplyPointwiseFunction.d.ts.map

package/dist/animation/transform/ApplyPointwiseFunction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ApplyPointwiseFunction.d.ts","sourceRoot":"","sources":["../../../src/animation/transform/ApplyPointwiseFunction.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAG3D,MAAM,WAAW,6BAA8B,SAAQ,gBAAgB;IACrE,gEAAgE;IAChE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;CACtC;AAqBD;;;GAGG;AACH,qBAAa,sBAAuB,SAAQ,SAAS;IACnD,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IAC7C,OAAO,CAAC,UAAU,CAAuB;gBAGvC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACnC,OAAO,CAAC,EAAE,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC;IAM9C,KAAK,IAAI,IAAI;IA2CtB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAYvB,MAAM,IAAI,IAAI;CAOxB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACnC,OAAO,CAAC,EAAE,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,GACpD,sBAAsB,CAExB"}

package/dist/animation/transform/Transform.d.ts

@@ -0,0 +1,89 @@
+import { Mobject } from '../../core/Mobject';
+import { VMobject } from '../../core/VMobject';
+import { Animation, AnimationOptions } from '../Animation';
+export declare class Transform extends Animation {
+    /** The target mobject to transform into */
+    readonly target: Mobject;
+    /** Copy of the starting points (point morphing mode) */
+    private _startPoints;
+    /** Copy of the target points after alignment (point morphing mode) */
+    private _targetPoints;
+    /** Starting style values */
+    private _startOpacity;
+    private _targetOpacity;
+    private _startFillOpacity;
+    private _targetFillOpacity;
+    private _startStrokeWidth;
+    private _targetStrokeWidth;
+    /** Starting and target colors for interpolation (stroke) */
+    private _startColor;
+    private _targetColor;
+    private _interpolateColor;
+    /** Starting and target fill colors for interpolation (separate from stroke) */
+    private _startFillColor;
+    private _targetFillColor;
+    private _interpolateFillColor;
+    /** Starting and target transform properties (position, rotation, scale) */
+    private _startPosition;
+    private _targetPosition;
+    private _startRotation;
+    private _targetRotation;
+    private _startScale;
+    private _targetScale;
+    /** Whether to use cross-fade instead of point morphing */
+    private _useCrossFade;
+    /** Original target opacity before cross-fade zeroes it */
+    private _crossFadeTargetOpacity;
+    constructor(mobject: Mobject, target: Mobject, options?: AnimationOptions);
+    /**
+     * Set up the animation - align points between mobject and target,
+     * or set up cross-fade if either is not a VMobject.
+     */
+    begin(): void;
+    /**
+     * Interpolate between start and target at the given alpha
+     */
+    interpolate(alpha: number): void;
+    /**
+     * Ensure the mobject matches the target at the end
+     */
+    finish(): void;
+}
+/**
+ * Create a Transform animation that morphs one mobject into another.
+ * @param mobject The source mobject
+ * @param target The target mobject to transform into
+ * @param options Animation options (duration, rateFunc)
+ */
+export declare function transform(mobject: Mobject, target: Mobject, options?: AnimationOptions): Transform;
+/**
+ * ReplacementTransform - like Transform, but replaces the mobject with the target
+ * in the scene after the animation completes.
+ */
+export declare class ReplacementTransform extends Transform {
+    constructor(mobject: Mobject, target: Mobject, options?: AnimationOptions);
+    /**
+     * After finishing, the calling code should replace mobject with target in the scene.
+     * This animation just handles the visual transition.
+     */
+    finish(): void;
+}
+/**
+ * Create a ReplacementTransform animation.
+ */
+export declare function replacementTransform(mobject: Mobject, target: Mobject, options?: AnimationOptions): ReplacementTransform;
+/**
+ * MoveToTarget animation - moves a mobject to its target copy.
+ * The mobject must have a `.targetCopy` property set beforehand.
+ */
+export interface MobjectWithTarget extends VMobject {
+    targetCopy: VMobject | null;
+}
+export declare class MoveToTarget extends Transform {
+    constructor(mobject: MobjectWithTarget, options?: AnimationOptions);
+}
+/**
+ * Create a MoveToTarget animation.
+ */
+export declare function moveToTarget(mobject: MobjectWithTarget, options?: AnimationOptions): MoveToTarget;
+//# sourceMappingURL=Transform.d.ts.map

package/dist/animation/transform/Transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Transform.d.ts","sourceRoot":"","sources":["../../../src/animation/transform/Transform.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAG3D,qBAAa,SAAU,SAAQ,SAAS;IACtC,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAEzB,wDAAwD;IACxD,OAAO,CAAC,YAAY,CAAkB;IAEtC,sEAAsE;IACtE,OAAO,CAAC,aAAa,CAAkB;IAEvC,4BAA4B;IAC5B,OAAO,CAAC,aAAa,CAAa;IAClC,OAAO,CAAC,cAAc,CAAa;IACnC,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,kBAAkB,CAAa;IACvC,OAAO,CAAC,iBAAiB,CAAa;IACtC,OAAO,CAAC,kBAAkB,CAAa;IAEvC,4DAA4D;IAC5D,OAAO,CAAC,WAAW,CAAkC;IACrD,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,iBAAiB,CAAkB;IAE3C,+EAA+E;IAC/E,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,gBAAgB,CAAkC;IAC1D,OAAO,CAAC,qBAAqB,CAAkB;IAE/C,2EAA2E;IAC3E,OAAO,CAAC,cAAc,CAAsC;IAC5D,OAAO,CAAC,eAAe,CAAsC;IAC7D,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,WAAW,CAA6C;IAChE,OAAO,CAAC,YAAY,CAA6C;IAEjE,0DAA0D;IAC1D,OAAO,CAAC,aAAa,CAAkB;IAEvC,0DAA0D;IAC1D,OAAO,CAAC,uBAAuB,CAAa;gBAG1C,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,gBAAqB;IAMhC;;;OAGG;IACM,KAAK,IAAI,IAAI;IA4FtB;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IA4DhC;;OAEG;IACM,MAAM,IAAI,IAAI;CA4ExB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,SAAS,CAEX;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;gBAE/C,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,GAAE,gBAAqB;IAKhC;;;OAGG;IACM,MAAM,IAAI,IAAI;CAKxB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,gBAAgB,GACzB,oBAAoB,CAEtB;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAkB,SAAQ,QAAQ;IACjD,UAAU,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC7B;AAED,qBAAa,YAAa,SAAQ,SAAS;gBAC7B,OAAO,EAAE,iBAAiB,EAAE,OAAO,GAAE,gBAAqB;CAQvE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,iBAAiB,EAC1B,OAAO,CAAC,EAAE,gBAAgB,GACzB,YAAY,CAEd"}