manim-web 0.2.0

package/dist/mobjects/value-tracker/ValueTracker.d.ts

@@ -0,0 +1,248 @@
+import { Mobject, Vector3Tuple } from '../../core/Mobject';
+import { Animation, AnimationOptions } from '../../animation/Animation';
+/**
+ * ValueTracker - A mobject that tracks a numerical value that can be animated.
+ *
+ * ValueTrackers are invisible mobjects that hold a value which can be smoothly
+ * animated using the standard animation system. Other mobjects can use updaters
+ * to respond to changes in the ValueTracker's value.
+ *
+ * @example
+ * ```typescript
+ * // Create a tracker starting at 0
+ * const tracker = new ValueTracker(0);
+ *
+ * // Create a dot that follows the tracker value on a number line
+ * const dot = new Dot();
+ * dot.addUpdater((d) => {
+ *   d.moveTo(numberLine.numberToPoint(tracker.getValue()));
+ * });
+ *
+ * // Animate the tracker from 0 to 5
+ * timeline.add(tracker.animateTo(5, { duration: 2 }));
+ * ```
+ */
+import * as THREE from 'three';
+/**
+ * Options for creating a ValueTracker
+ */
+export interface ValueTrackerOptions {
+    /** Initial value (default: 0) */
+    value?: number;
+}
+/**
+ * ValueTracker - Tracks a numerical value that can be animated.
+ *
+ * This is an invisible mobject designed to hold a single numerical value
+ * that can be smoothly animated. It's commonly used with updaters to
+ * create dynamic animations where multiple mobjects respond to a single
+ * changing value.
+ */
+export declare class ValueTracker extends Mobject {
+    /** The tracked value */
+    private _value;
+    /**
+     * Create a new ValueTracker.
+     * @param value - Initial value (default: 0)
+     */
+    constructor(value?: number);
+    constructor(options?: ValueTrackerOptions);
+    /**
+     * Get the current value.
+     * @returns The current tracked value
+     */
+    getValue(): number;
+    /**
+     * Set the value directly (without animation).
+     * @param value - The new value
+     * @returns this for chaining
+     */
+    setValue(value: number): this;
+    /**
+     * Increment the value by a given amount.
+     * @param amount - The amount to add (can be negative)
+     * @returns this for chaining
+     */
+    incrementValue(amount: number): this;
+    /**
+     * Create an animation that smoothly changes the value.
+     * @param targetValue - The value to animate to
+     * @param options - Animation options (duration, rateFunc, etc.)
+     * @returns An animation that can be added to a timeline
+     *
+     * @example
+     * ```typescript
+     * // Animate from current value to 10 over 2 seconds
+     * timeline.add(tracker.animateTo(10, { duration: 2 }));
+     *
+     * // Animate with custom rate function
+     * timeline.add(tracker.animateTo(5, {
+     *   duration: 1.5,
+     *   rateFunc: easeInOut
+     * }));
+     * ```
+     */
+    animateTo(targetValue: number, options?: AnimationOptions): Animation;
+    /**
+     * Alias for animateTo - matches Manim's API.
+     * @param targetValue - The value to animate to
+     * @param options - Animation options
+     * @returns An animation
+     */
+    animate(targetValue: number, options?: AnimationOptions): Animation;
+    /**
+     * Get the center position (returns origin since this is invisible).
+     * @returns [0, 0, 0]
+     */
+    getCenter(): Vector3Tuple;
+    /**
+     * Create a copy of this ValueTracker.
+     * @returns A new ValueTracker with the same value
+     */
+    protected _createCopy(): ValueTracker;
+    /**
+     * Create an empty Three.js object (ValueTracker is invisible).
+     * @returns An empty THREE.Group
+     */
+    protected _createThreeObject(): THREE.Object3D;
+}
+/**
+ * Complex number representation
+ */
+export interface Complex {
+    /** Real part */
+    re: number;
+    /** Imaginary part */
+    im: number;
+}
+/**
+ * Options for creating a ComplexValueTracker
+ */
+export interface ComplexValueTrackerOptions {
+    /** Initial complex value */
+    value?: Complex;
+}
+/**
+ * ComplexValueTracker - Tracks a complex number that can be animated.
+ *
+ * Similar to ValueTracker but for complex numbers. The value is stored
+ * as {re, im} representing the real and imaginary parts.
+ *
+ * @example
+ * ```typescript
+ * // Create a tracker at 1 + 2i
+ * const tracker = new ComplexValueTracker({ re: 1, im: 2 });
+ *
+ * // Create a dot that visualizes the complex number
+ * const dot = new Dot();
+ * dot.addUpdater((d) => {
+ *   const z = tracker.getValue();
+ *   d.moveTo([z.re, z.im, 0]);
+ * });
+ *
+ * // Animate to -1 + 0i
+ * timeline.add(tracker.animateTo({ re: -1, im: 0 }, { duration: 2 }));
+ * ```
+ */
+export declare class ComplexValueTracker extends Mobject {
+    /** The tracked complex value */
+    private _value;
+    /**
+     * Create a new ComplexValueTracker.
+     * @param value - Initial complex value (default: { re: 0, im: 0 })
+     */
+    constructor(value?: Complex);
+    constructor(options?: ComplexValueTrackerOptions);
+    /**
+     * Get the current complex value.
+     * @returns The current value as { re, im }
+     */
+    getValue(): Complex;
+    /**
+     * Alias for getValue - returns the complex number.
+     * @returns The current value as { re, im }
+     */
+    getComplex(): Complex;
+    /**
+     * Get the real part of the value.
+     * @returns The real part
+     */
+    getReal(): number;
+    /**
+     * Get the imaginary part of the value.
+     * @returns The imaginary part
+     */
+    getImaginary(): number;
+    /**
+     * Get the magnitude (absolute value) of the complex number.
+     * @returns |z| = sqrt(re^2 + im^2)
+     */
+    getMagnitude(): number;
+    /**
+     * Get the argument (phase angle) of the complex number.
+     * @returns The angle in radians
+     */
+    getArgument(): number;
+    /**
+     * Set the value directly (without animation).
+     * @param value - The new complex value
+     * @returns this for chaining
+     */
+    setValue(value: Complex): this;
+    /**
+     * Set the value using polar coordinates.
+     * @param r - Magnitude
+     * @param theta - Angle in radians
+     * @returns this for chaining
+     */
+    setFromPolar(r: number, theta: number): this;
+    /**
+     * Increment the value by a given complex amount.
+     * @param amount - The amount to add
+     * @returns this for chaining
+     */
+    incrementValue(amount: Complex): this;
+    /**
+     * Create an animation that smoothly changes the complex value.
+     * @param targetValue - The value to animate to
+     * @param options - Animation options (duration, rateFunc, etc.)
+     * @returns An animation that can be added to a timeline
+     */
+    animateTo(targetValue: Complex, options?: AnimationOptions): Animation;
+    /**
+     * Alias for animateTo - matches Manim's API.
+     * @param targetValue - The value to animate to
+     * @param options - Animation options
+     * @returns An animation
+     */
+    animate(targetValue: Complex, options?: AnimationOptions): Animation;
+    /**
+     * Get the center position (returns the complex number as a 2D point).
+     * @returns [re, im, 0]
+     */
+    getCenter(): Vector3Tuple;
+    /**
+     * Create a copy of this ComplexValueTracker.
+     * @returns A new ComplexValueTracker with the same value
+     */
+    protected _createCopy(): ComplexValueTracker;
+    /**
+     * Create an empty Three.js object (ComplexValueTracker is invisible).
+     * @returns An empty THREE.Group
+     */
+    protected _createThreeObject(): THREE.Object3D;
+}
+/**
+ * Factory function to create a ValueTracker.
+ * @param value - Initial value (default: 0)
+ * @returns A new ValueTracker
+ */
+export declare function valueTracker(value?: number): ValueTracker;
+/**
+ * Factory function to create a ComplexValueTracker.
+ * @param value - Initial complex value (default: { re: 0, im: 0 })
+ * @returns A new ComplexValueTracker
+ */
+export declare function complexValueTracker(value?: Complex): ComplexValueTracker;
+export default ValueTracker;
+//# sourceMappingURL=ValueTracker.d.ts.map

package/dist/mobjects/value-tracker/ValueTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ValueTracker.d.ts","sourceRoot":"","sources":["../../../src/mobjects/value-tracker/ValueTracker.ts"],"names":[],"mappings":"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"}

package/dist/mobjects/value-tracker/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Value Tracker exports
+ *
+ * ValueTracker and ComplexValueTracker are invisible mobjects that hold
+ * values which can be smoothly animated. They are commonly used with
+ * updaters to create dynamic animations.
+ */
+export { ValueTracker, valueTracker, ComplexValueTracker, complexValueTracker, type ValueTrackerOptions, type ComplexValueTrackerOptions, type Complex, } from './ValueTracker';
+//# sourceMappingURL=index.d.ts.map

package/dist/mobjects/value-tracker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mobjects/value-tracker/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,OAAO,GACb,MAAM,gBAAgB,CAAC"}

package/dist/rate-functions/index.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Rate/easing functions for animations.
+ * These control how the animation progress (0-1) is mapped to visual progress.
+ */
+export type RateFunction = (t: number) => number;
+/**
+ * Linear interpolation - constant speed
+ */
+export declare const linear: RateFunction;
+/**
+ * Manim Python's smooth function using sigmoid curve.
+ * Matches: smooth(t, inflection=10) from manim.utils.rate_functions
+ * Steeper in the middle, flatter at endpoints than simple smoothstep.
+ */
+export declare const smooth: RateFunction;
+/**
+ * Cubic ease in-out - slower at both ends
+ */
+export declare const easeInOut: RateFunction;
+/**
+ * Cubic ease in - starts slow, accelerates
+ */
+export declare const easeIn: RateFunction;
+/**
+ * Cubic ease out - starts fast, decelerates
+ */
+export declare const easeOut: RateFunction;
+/**
+ * Quadratic ease in
+ */
+export declare const easeInQuad: RateFunction;
+/**
+ * Quadratic ease out
+ */
+export declare const easeOutQuad: RateFunction;
+/**
+ * Exponential ease in
+ */
+export declare const easeInExpo: RateFunction;
+/**
+ * Exponential ease out
+ */
+export declare const easeOutExpo: RateFunction;
+/**
+ * Bounce ease out - simulates bouncing
+ */
+export declare const easeOutBounce: RateFunction;
+/**
+ * Bounce ease in
+ */
+export declare const easeInBounce: RateFunction;
+/**
+ * There and back - goes to 1 at t=0.5, returns to 0 at t=1
+ */
+export declare const thereAndBack: RateFunction;
+/**
+ * Rush into - quickly accelerate then maintain
+ */
+export declare const rushInto: RateFunction;
+/**
+ * Rush from - maintain then quickly decelerate
+ */
+export declare const rushFrom: RateFunction;
+/**
+ * Double smooth - extra smooth transitions
+ */
+export declare const doubleSmooth: RateFunction;
+/**
+ * Create a rate function that stays at 0 until a certain point,
+ * then jumps to 1
+ */
+export declare const stepFunction: (threshold?: number) => RateFunction;
+/**
+ * Reverse a rate function
+ */
+export declare const reverse: (func: RateFunction) => RateFunction;
+/**
+ * Compose two rate functions
+ */
+export declare const compose: (outer: RateFunction, inner: RateFunction) => RateFunction;
+//# sourceMappingURL=index.d.ts.map

package/dist/rate-functions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rate-functions/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,YAAuC,CAAC;AAE7D;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,YAKpB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,YAIvB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,MAAM,EAAE,YAEpB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,YAErB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,YAExB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,YAEzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,YAExB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,YAEzB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,YAa3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,YAE1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,YAI1B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,YAEtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,YAEtB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,YAK1B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,GAAI,YAAW,MAAY,KAAG,YAEtD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,YAAY,KAAG,YAE5C,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,OAAO,GAClB,OAAO,YAAY,EACnB,OAAO,YAAY,KAClB,YAEF,CAAC"}

package/dist/rate-functions/rateFunctions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=rateFunctions.test.d.ts.map

package/dist/rate-functions/rateFunctions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rateFunctions.test.d.ts","sourceRoot":"","sources":["../../src/rate-functions/rateFunctions.test.ts"],"names":[],"mappings":""}

package/dist/rendering/BezierRenderer.d.ts

@@ -0,0 +1,112 @@
+import { BezierShaderMaterialOptions } from './BezierShaderMaterial';
+/**
+ * BezierRenderer - Converts VMobject cubic Bezier data into instanced Three.js
+ * geometry for GPU-accelerated SDF curve rendering.
+ *
+ * Each cubic Bezier segment of a VMobject becomes one instance of a screen-aligned
+ * quad. The BezierShaderMaterial's fragment shader evaluates the SDF per-pixel to
+ * produce anti-aliased strokes with variable width and round caps.
+ *
+ * Usage:
+ * ```ts
+ * const renderer = new BezierRenderer({ resolution: [1920, 1080] });
+ * const mesh = renderer.buildMesh(vmobject);
+ * scene.add(mesh);
+ *
+ * // On resize:
+ * renderer.updateResolution(newWidth, newHeight, pixelRatio);
+ *
+ * // When VMobject points change:
+ * renderer.updateMesh(mesh, vmobject);
+ * ```
+ */
+import * as THREE from 'three';
+export interface BezierRendererOptions {
+    /** Renderer resolution [width, height] in CSS pixels. Default: [800, 450] */
+    resolution?: [number, number];
+    /** Device pixel ratio. Default: 1 */
+    pixelRatio?: number;
+    /** Additional material options */
+    materialOptions?: BezierShaderMaterialOptions;
+}
+/**
+ * Per-segment data extracted from a VMobject or provided directly.
+ */
+export interface BezierSegment {
+    /** Control point 0 (start anchor) */
+    p0: number[];
+    /** Control point 1 */
+    p1: number[];
+    /** Control point 2 */
+    p2: number[];
+    /** Control point 3 (end anchor) */
+    p3: number[];
+    /** Stroke width at start of segment */
+    widthStart: number;
+    /** Stroke width at end of segment */
+    widthEnd: number;
+    /** RGBA color [r, g, b, a] where each channel is 0..1 */
+    color: [number, number, number, number];
+}
+export declare class BezierRenderer {
+    private _material;
+    private _pixelRatio;
+    constructor(options?: BezierRendererOptions);
+    /** Access the underlying ShaderMaterial (e.g. to update uniforms). */
+    get material(): THREE.ShaderMaterial;
+    /**
+     * Update renderer resolution. Call on window/canvas resize.
+     */
+    updateResolution(width: number, height: number, pixelRatio?: number): void;
+    /**
+     * Extract cubic Bezier segments from a VMobject-like object.
+     *
+     * VMobject stores points as:
+     *   [anchor0, handle0, handle1, anchor1, handle2, handle3, anchor2, ...]
+     * Each group of 4 consecutive points (stepping by 3) is one cubic segment.
+     *
+     * @param points - The VMobject's 3D points array
+     * @param strokeWidth - Uniform stroke width (or start width)
+     * @param strokeWidthEnd - End stroke width for variable width. Defaults to strokeWidth.
+     * @param color - CSS color string
+     * @param opacity - Overall opacity 0..1
+     * @returns Array of BezierSegment
+     */
+    static extractSegments(points: number[][], strokeWidth: number, strokeWidthEnd?: number, color?: string, opacity?: number): BezierSegment[];
+    /**
+     * Build an InstancedMesh for the given Bezier segments.
+     *
+     * @param segments - Array of BezierSegment
+     * @returns THREE.Mesh using InstancedBufferGeometry
+     */
+    buildMeshFromSegments(segments: BezierSegment[]): THREE.Mesh;
+    /**
+     * Convenience: build a mesh directly from VMobject-style data.
+     *
+     * @param points - Cubic Bezier control points (from VMobject.getVisiblePoints3D())
+     * @param strokeWidth - Stroke width
+     * @param color - CSS color string
+     * @param opacity - Opacity 0..1
+     * @param strokeWidthEnd - End stroke width for tapering (optional)
+     * @returns THREE.Mesh
+     */
+    buildMesh(points: number[][], strokeWidth: number, color?: string, opacity?: number, strokeWidthEnd?: number): THREE.Mesh;
+    /**
+     * Update an existing mesh's instance data without reallocating geometry
+     * (when segment count is the same) or rebuild if count differs.
+     *
+     * @param mesh - Previously built mesh
+     * @param segments - New segment data
+     * @returns The (possibly new) mesh
+     */
+    updateMeshFromSegments(mesh: THREE.Mesh, segments: BezierSegment[]): THREE.Mesh;
+    /**
+     * Convenience: update from VMobject-style data.
+     */
+    updateMesh(mesh: THREE.Mesh, points: number[][], strokeWidth: number, color?: string, opacity?: number, strokeWidthEnd?: number): THREE.Mesh;
+    /**
+     * Dispose the shared material. Call when the renderer is no longer needed.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=BezierRenderer.d.ts.map

package/dist/rendering/BezierRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BezierRenderer.d.ts","sourceRoot":"","sources":["../../src/rendering/BezierRenderer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAGL,KAAK,2BAA2B,EACjC,MAAM,wBAAwB,CAAC;AAMhC,MAAM,WAAW,qBAAqB;IACpC,6EAA6E;IAC7E,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kCAAkC;IAClC,eAAe,CAAC,EAAE,2BAA2B,CAAC;CAC/C;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,sBAAsB;IACtB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,sBAAsB;IACtB,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,mCAAmC;IACnC,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,uCAAuC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,yDAAyD;IACzD,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAyBD,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,GAAE,qBAA0B;IAgB/C,sEAAsE;IACtE,IAAI,QAAQ,IAAI,KAAK,CAAC,cAAc,CAEnC;IAED;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI;IAS1E;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,eAAe,CACpB,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,WAAW,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,KAAK,GAAE,MAAkB,EACzB,OAAO,GAAE,MAAU,GAClB,aAAa,EAAE;IA2ClB;;;;;OAKG;IACH,qBAAqB,CAAC,QAAQ,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC,IAAI;IAyD5D;;;;;;;;;OASG;IACH,SAAS,CACP,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,MAAkB,EACzB,OAAO,GAAE,MAAU,EACnB,cAAc,CAAC,EAAE,MAAM,GACtB,KAAK,CAAC,IAAI;IAOb;;;;;;;OAOG;IACH,sBAAsB,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC,IAAI;IA6D/E;;OAEG;IACH,UAAU,CACR,IAAI,EAAE,KAAK,CAAC,IAAI,EAChB,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,WAAW,EAAE,MAAM,EACnB,KAAK,GAAE,MAAkB,EACzB,OAAO,GAAE,MAAU,EACnB,cAAc,CAAC,EAAE,MAAM,GACtB,KAAK,CAAC,IAAI;IAOb;;OAEG;IACH,OAAO,IAAI,IAAI;CAGhB"}

package/dist/rendering/BezierShaderMaterial.d.ts

@@ -0,0 +1,50 @@
+/**
+ * BezierShaderMaterial - ManimGL-quality Bezier curve rendering via Three.js ShaderMaterial.
+ *
+ * Uses GPU-evaluated signed distance fields (SDF) for cubic Bezier curves
+ * to achieve pixel-perfect anti-aliasing, variable stroke width, and round
+ * caps/joints -- the signature "ManimGL look."
+ *
+ * Each curve segment is a screen-aligned quad (two triangles) that bounds the
+ * Bezier curve with padding for stroke width. The fragment shader computes the
+ * exact closest-point distance to the cubic Bezier via iterative Newton refinement,
+ * then applies smoothstep anti-aliasing.
+ */
+import * as THREE from 'three';
+export interface BezierShaderMaterialOptions {
+    /** Enable transparency. Default: true */
+    transparent?: boolean;
+    /** Depth test. Default: true */
+    depthTest?: boolean;
+    /** Depth write. Default: false (for proper alpha blending) */
+    depthWrite?: boolean;
+    /** Blending mode. Default: THREE.NormalBlending */
+    blending?: THREE.Blending;
+    /** Side to render. Default: THREE.DoubleSide */
+    side?: THREE.Side;
+    /** Device pixel ratio. Default: 1 */
+    pixelRatio?: number;
+    /** Renderer resolution [width, height] in CSS pixels */
+    resolution?: [number, number];
+}
+/**
+ * Create a Three.js ShaderMaterial configured for Bezier curve SDF rendering.
+ *
+ * The material expects instanced geometry where each instance carries:
+ *   aP0, aP1, aP2, aP3  - cubic Bezier control points (vec3)
+ *   aWidthStart, aWidthEnd - stroke width at t=0 and t=1 (float)
+ *   aColor                 - RGBA color (vec4)
+ *
+ * And per-vertex:
+ *   aQuadUV - quad corner coordinate (vec2)
+ *
+ * @param options - Material configuration
+ * @returns Configured ShaderMaterial
+ */
+export declare function createBezierShaderMaterial(options?: BezierShaderMaterialOptions): THREE.ShaderMaterial;
+/**
+ * Update the resolution uniform on a BezierShaderMaterial.
+ * Call this when the renderer resizes.
+ */
+export declare function updateBezierMaterialResolution(material: THREE.ShaderMaterial, width: number, height: number, pixelRatio?: number): void;
+//# sourceMappingURL=BezierShaderMaterial.d.ts.map

package/dist/rendering/BezierShaderMaterial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BezierShaderMaterial.d.ts","sourceRoot":"","sources":["../../src/rendering/BezierShaderMaterial.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAyO/B,MAAM,WAAW,2BAA2B;IAC1C,yCAAyC;IACzC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,gCAAgC;IAChC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8DAA8D;IAC9D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC;IAC1B,gDAAgD;IAChD,IAAI,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC;IAClB,qCAAqC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,wDAAwD;IACxD,UAAU,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,GAAE,2BAAgC,GACxC,KAAK,CAAC,cAAc,CAwBtB;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,MAAU,GACrB,IAAI,CAON"}

package/dist/rendering/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Rendering module - GPU-accelerated Bezier curve rendering via custom shaders.
+ *
+ * Provides ManimGL-quality anti-aliased curves with variable stroke width,
+ * round caps, and clean SDF-based rendering as an opt-in alternative to
+ * the default Line2-based stroke rendering.
+ */
+export { createBezierShaderMaterial, updateBezierMaterialResolution, type BezierShaderMaterialOptions, } from './BezierShaderMaterial';
+export { BezierRenderer, type BezierRendererOptions, type BezierSegment, } from './BezierRenderer';
+//# sourceMappingURL=index.d.ts.map

package/dist/rendering/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rendering/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,0BAA0B,EAC1B,8BAA8B,EAC9B,KAAK,2BAA2B,GACjC,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,aAAa,GACnB,MAAM,kBAAkB,CAAC"}

package/dist/utils/Performance.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Performance monitoring utilities for manimweb.
+ * Provides FPS tracking and performance metrics.
+ */
+/**
+ * Performance monitor for tracking frame rate and other metrics.
+ * Useful for debugging and optimizing animations.
+ */
+export declare class PerformanceMonitor {
+    private _frameCount;
+    private _lastTime;
+    private _fps;
+    private _callback;
+    private _animationFrameId;
+    private _isRunning;
+    private _fpsHistory;
+    private _historySize;
+    /**
+     * Start monitoring performance.
+     * @param callback - Optional callback called each second with current FPS
+     */
+    start(callback?: (fps: number) => void): void;
+    /**
+     * Stop monitoring performance.
+     */
+    stop(): void;
+    /**
+     * Internal update loop.
+     */
+    private _update;
+    /**
+     * Get the current FPS (rolling average).
+     * @returns Current frames per second
+     */
+    getFps(): number;
+    /**
+     * Get the instant FPS (last measured value before averaging).
+     * @returns Instant frames per second
+     */
+    getInstantFps(): number;
+    /**
+     * Check if the monitor is currently running.
+     * @returns true if monitoring is active
+     */
+    isRunning(): boolean;
+    /**
+     * Reset the monitor statistics.
+     */
+    reset(): void;
+}
+/**
+ * Create a new PerformanceMonitor instance.
+ * @returns A new PerformanceMonitor
+ */
+export declare function createPerformanceMonitor(): PerformanceMonitor;
+/**
+ * Simple frame time tracker for measuring render performance.
+ */
+export declare class FrameTimeTracker {
+    private _frameTimes;
+    private _maxSamples;
+    private _lastFrameStart;
+    /**
+     * Create a new FrameTimeTracker.
+     * @param maxSamples - Maximum number of samples to keep (default: 60)
+     */
+    constructor(maxSamples?: number);
+    /**
+     * Mark the start of a frame.
+     */
+    startFrame(): void;
+    /**
+     * Mark the end of a frame and record the time.
+     */
+    endFrame(): void;
+    /**
+     * Get the average frame time in milliseconds.
+     * @returns Average frame time in ms
+     */
+    getAverageFrameTime(): number;
+    /**
+     * Get the maximum frame time in milliseconds.
+     * @returns Max frame time in ms
+     */
+    getMaxFrameTime(): number;
+    /**
+     * Get the minimum frame time in milliseconds.
+     * @returns Min frame time in ms
+     */
+    getMinFrameTime(): number;
+    /**
+     * Get the 95th percentile frame time.
+     * Useful for identifying stutter/jank.
+     * @returns 95th percentile frame time in ms
+     */
+    get95thPercentile(): number;
+    /**
+     * Reset all recorded frame times.
+     */
+    reset(): void;
+    /**
+     * Get a summary of frame time statistics.
+     * @returns Object with avg, min, max, and p95 frame times
+     */
+    getSummary(): {
+        avg: number;
+        min: number;
+        max: number;
+        p95: number;
+    };
+}
+/**
+ * Create a new FrameTimeTracker instance.
+ * @param maxSamples - Maximum number of samples to keep
+ * @returns A new FrameTimeTracker
+ */
+export declare function createFrameTimeTracker(maxSamples?: number): FrameTimeTracker;
+//# sourceMappingURL=Performance.d.ts.map

package/dist/utils/Performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Performance.d.ts","sourceRoot":"","sources":["../../src/utils/Performance.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;GAGG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,WAAW,CAAa;IAChC,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,SAAS,CAAwC;IACzD,OAAO,CAAC,iBAAiB,CAAuB;IAChD,OAAO,CAAC,UAAU,CAAkB;IAGpC,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,YAAY,CAAc;IAElC;;;OAGG;IACH,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAW7C;;OAEG;IACH,IAAI,IAAI,IAAI;IAQZ;;OAEG;IACH,OAAO,CAAC,OAAO,CA4Bb;IAEF;;;OAGG;IACH,MAAM,IAAI,MAAM;IAIhB;;;OAGG;IACH,aAAa,IAAI,MAAM;IAMvB;;;OAGG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,kBAAkB,CAE7D;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,eAAe,CAAa;IAEpC;;;OAGG;gBACS,UAAU,GAAE,MAAW;IAInC;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAQhB;;;OAGG;IACH,mBAAmB,IAAI,MAAM;IAK7B;;;OAGG;IACH,eAAe,IAAI,MAAM;IAKzB;;;OAGG;IACH,eAAe,IAAI,MAAM;IAKzB;;;;OAIG;IACH,iBAAiB,IAAI,MAAM;IAO3B;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;;OAGG;IACH,UAAU,IAAI;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE;CAQrE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAE5E"}