manim-web 0.2.0

package/dist/core/VMobject.d.ts

@@ -0,0 +1,419 @@
+import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
+import { Mobject, Vector3Tuple } from './Mobject';
+/**
+ * Vectorized Mobject - a mobject defined by cubic Bezier curves.
+ * This is the base class for all path-based shapes.
+ *
+ * Points are stored as cubic Bezier control points:
+ * [anchor1, handle1, handle2, anchor2, handle3, handle4, anchor3, ...]
+ *
+ * Each curve segment uses 4 points: anchor -> handle -> handle -> anchor
+ * Consecutive segments share the anchor point.
+ */
+import * as THREE from 'three';
+/**
+ * 2D Point interface for backward compatibility
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+/**
+ * Vectorized mobject class for path-based shapes.
+ */
+export declare class VMobject extends Mobject {
+    /**
+     * Array of cubic Bezier control points in 3D.
+     * Each point is [x, y, z].
+     * Stored as: [anchor1, handle1, handle2, anchor2, handle3, handle4, anchor3, ...]
+     */
+    protected _points3D: number[][];
+    /** Number of points visible (for Create animation) */
+    protected _visiblePointCount: number | null;
+    /** Three.js stroke material (Line2 LineMaterial for thick strokes) */
+    protected _strokeMaterial: LineMaterial | null;
+    /** Three.js fill material */
+    protected _fillMaterial: THREE.MeshBasicMaterial | null;
+    /** Whether geometry needs rebuild (separate from material dirty) */
+    protected _geometryDirty: boolean;
+    /** Cached Line2 for in-place geometry updates (avoids dispose/recreate) */
+    private _cachedLine2;
+    /** Cached Line2 array for multi-subpath stroke rendering */
+    private _cachedLine2Array;
+    /** Cached fill mesh for in-place geometry updates */
+    private _cachedFillMesh;
+    /** Renderer resolution for LineMaterial (set by Scene) */
+    static _rendererWidth: number;
+    static _rendererHeight: number;
+    /** Camera frame width in world units (set by Scene, for stroke width conversion) */
+    static _frameWidth: number;
+    /**
+     * Convert Manim-compatible strokeWidth to LineMaterial linewidth in pixels.
+     * Python Manim uses cairo_line_width_multiple=0.01, so:
+     *   linewidth_px = strokeWidth * 0.01 * (rendererWidth / frameWidth)
+     */
+    static _toLinewidth(strokeWidth: number): number;
+    /**
+     * When true, VMobjects use GPU Bezier SDF shaders for stroke rendering
+     * instead of the default Line2/LineMaterial approach. This produces
+     * ManimGL-quality anti-aliased curves with variable stroke width and
+     * round caps. Default: false (opt-in).
+     */
+    static useShaderCurves: boolean;
+    /** Shared BezierRenderer instance (lazy-initialized when useShaderCurves is first used) */
+    private static _sharedBezierRenderer;
+    /** Per-instance: cached Bezier SDF stroke mesh */
+    private _cachedBezierMesh;
+    /** Per-instance override for shader curves (null = use static default) */
+    private _useShaderCurvesOverride;
+    /**
+     * When true, render stroke as a mesh ring with miter-joined corners instead
+     * of Line2 for closed paths.  Falls back to Line2 for open/partial paths
+     * (e.g. during Create/Uncreate animations).
+     */
+    useStrokeMesh: boolean;
+    /** Cached mesh-based stroke ring */
+    private _cachedStrokeMesh;
+    /** Material for mesh-based stroke */
+    private _strokeMeshMaterial;
+    /**
+     * Get the shared BezierRenderer, creating it if needed.
+     */
+    private static _getBezierRenderer;
+    constructor();
+    /**
+     * Check whether this instance should use shader-based Bezier curve rendering.
+     * Returns the per-instance override if set, otherwise the class-level default.
+     */
+    get shaderCurves(): boolean;
+    /**
+     * Enable or disable shader-based Bezier curve rendering for this instance.
+     * Pass `null` to revert to the class-level VMobject.useShaderCurves default.
+     */
+    set shaderCurves(value: boolean | null);
+    /**
+     * Get all points as 2D Point objects (derived from _points3D)
+     */
+    get points(): Point[];
+    /**
+     * Set the points defining this VMobject.
+     * Accepts either Point[] ({x, y} objects) or number[][] ([x, y, z] arrays).
+     * @param points - Array of points in either format
+     * @returns this for chaining
+     */
+    setPoints(points: Point[] | number[][]): this;
+    /**
+     * Set the points defining this VMobject using 3D arrays (alias for setPoints with number[][])
+     * @param points - Array of [x, y, z] control points for cubic Bezier curves
+     * @returns this for chaining
+     */
+    setPoints3D(points: number[][]): this;
+    /**
+     * Get all points defining this VMobject as 3D arrays
+     * @returns Copy of the points array
+     */
+    getPoints(): number[][];
+    /**
+     * Get the number of points
+     */
+    get numPoints(): number;
+    /**
+     * Get the number of visible points (for Create animation)
+     */
+    get visiblePointCount(): number;
+    /**
+     * Set the number of visible points (for Create animation)
+     */
+    set visiblePointCount(count: number);
+    /**
+     * Get points that should be visible (for rendering) as 2D Points
+     */
+    getVisiblePoints(): Point[];
+    /**
+     * Get points that should be visible (for rendering) as 3D arrays
+     */
+    getVisiblePoints3D(): number[][];
+    /**
+     * Add points to this VMobject using 2D Point objects
+     */
+    addPoints(...points: Point[]): this;
+    /**
+     * Set the points to form straight line segments between corner points.
+     * Each pair of consecutive corners becomes a cubic Bezier with linear handles.
+     * Matches Manim's set_points_as_corners.
+     * @param corners Array of [x, y, z] corner points
+     * @returns this for chaining
+     */
+    setPointsAsCorners(corners: number[][]): this;
+    /**
+     * Add straight line segments from the last point to each corner.
+     * Each corner creates a new cubic Bezier segment with linear handles.
+     * Matches Manim's add_points_as_corners.
+     * @param corners Array of [x, y, z] corner points to connect to
+     * @returns this for chaining
+     */
+    addPointsAsCorners(corners: number[][]): this;
+    /**
+     * Clear all points
+     */
+    clearPoints(): this;
+    /**
+     * Interpolate this VMobject towards a target VMobject
+     * @param target - The target VMobject to interpolate towards
+     * @param alpha - Progress from 0 (this) to 1 (target)
+     * @returns this for chaining
+     */
+    interpolate(target: VMobject, alpha: number): this;
+    /**
+     * Align points between this VMobject and a target so they have the same count.
+     * This is necessary for smooth morphing animations.
+     * @param target - The target VMobject to align with
+     */
+    alignPoints(target: VMobject): void;
+    /**
+     * Interpolate a 3D point list to have a specific number of points.
+     */
+    protected _interpolatePointList3D(points: number[][], targetCount: number): number[][];
+    /**
+     * Convert Bezier control points to a Three.js Shape for filled rendering.
+     * @returns THREE.Shape representing the path
+     */
+    protected _pointsToShape(): THREE.Shape;
+    /**
+     * Convert points to a THREE.CurvePath for stroke rendering
+     */
+    protected _pointsToCurvePath(): THREE.CurvePath<THREE.Vector3>;
+    /**
+     * Build a THREE.BufferGeometry for the filled region using earcut triangulation.
+     *
+     * Earcut handles concave polygons, self-intersecting paths, and holes far
+     * more robustly than Three.js' built-in ShapeGeometry triangulator, which
+     * is a simple ear-clipping implementation that struggles with complex SVG
+     * outlines.
+     *
+     * If earcut returns zero triangles (completely degenerate input) we fall
+     * back to THREE.ShapeGeometry so existing simple shapes still render.
+     *
+     * @param points3D - The visible Bezier control points
+     * @returns A BufferGeometry ready for use as a fill mesh, or null if the
+     *          polygon is too degenerate even for fallback.
+     */
+    protected _buildEarcutFillGeometry(points3D: number[][]): THREE.BufferGeometry | null;
+    /**
+     * Build fill geometry for multi-subpath shapes (e.g. boolean XOR).
+     * Splits control points by subpath boundaries, samples each independently,
+     * and triangulates each subpath as a separate region.
+     */
+    private _buildEarcutFillGeometryMulti;
+    /**
+     * Sample the Bezier path into a 2D polyline suitable for earcut triangulation.
+     *
+     * This is similar to _sampleBezierPath but returns [x, y] pairs (no z) and
+     * skips duplicate-point de-duplication at segment boundaries (earcut handles
+     * that correctly and de-dup can introduce off-by-one for hole indices).
+     */
+    private _sampleBezierOutline;
+    /**
+     * Split a sampled outline into separate rings based on subpath control-point
+     * lengths.  Used for compound paths (outer boundary + holes).
+     *
+     * Each subpath length is the number of Bezier control points.  We compute
+     * how many sampled points each subpath produced and split accordingly.
+     */
+    /**
+     * Create the Three.js backing object for this VMobject.
+     * Creates both stroke (using Line2 for thick, smooth strokes) and fill meshes.
+     */
+    protected _createThreeObject(): THREE.Object3D;
+    /**
+     * Update the geometry within the Three.js group.
+     * Reuses existing Line2 / Mesh objects when possible to avoid expensive
+     * dispose-and-recreate cycles during per-frame animation updates.
+     *
+     * When `shaderCurves` is enabled, stroke rendering uses GPU Bezier SDF
+     * shaders via BezierRenderer instead of the Line2 polyline approach.
+     */
+    protected _updateGeometry(group: THREE.Group): void;
+    /**
+     * Update stroke using the classic Line2 approach (polyline approximation).
+     * Supports subpath-aware rendering: when getSubpaths() returns multiple
+     * subpaths, each is rendered as a separate Line2 to avoid visible bridge lines.
+     */
+    private _updateLine2Stroke;
+    /**
+     * Render multiple separate Line2 strokes, one per subpath.
+     */
+    private _updateLine2StrokeMulti;
+    /**
+     * Check if the Bezier control points form a closed path (first ≈ last anchor).
+     */
+    private _isClosedPath;
+    /**
+     * Build a mesh-based stroke ring from a closed sampled path.
+     * Uses miter joins at corners for pixel-perfect sharp corners.
+     * Stroke width is in world units (strokeWidth * 0.005 per side).
+     */
+    private _updateMeshStroke;
+    /**
+     * Remove the cached mesh-based stroke ring.
+     */
+    private _removeMeshStroke;
+    /**
+     * Remove all cached multi-subpath Line2 objects.
+     */
+    private _clearCachedLine2Array;
+    /**
+     * Update stroke using GPU Bezier SDF shader (ManimGL-quality rendering).
+     * Each cubic Bezier segment becomes one instanced quad rendered by the
+     * BezierShaderMaterial fragment shader.
+     */
+    private _updateBezierStroke;
+    /**
+     * Dispose and remove all children from a Three.js group
+     */
+    private _disposeGroupChildren;
+    /**
+     * Sample Bezier curves for smooth rendering.
+     * Uses adaptive sampling: nearly-linear segments (from prepareForNonlinearTransform)
+     * use only their endpoints, avoiding expensive per-sample Bezier evaluation.
+     *
+     * @param points - Bezier control points
+     * @param samplesPerSegment - Number of samples per curved Bezier segment
+     * @returns Sampled points along the path
+     */
+    private _sampleBezierPath;
+    /**
+     * Check if a cubic Bezier segment is nearly linear by measuring the maximum
+     * distance from handles to the chord (p0 → p3).
+     */
+    private static _isNearlyLinear;
+    /**
+     * Sync material properties to Three.js
+     */
+    protected _syncMaterialToThree(): void;
+    /**
+     * Create a copy of this VMobject
+     */
+    protected _createCopy(): VMobject;
+    /**
+     * Get the unit vector from the first to the last point of this VMobject,
+     * accounting for the object's current rotation transform.
+     */
+    getUnitVector(): Vector3Tuple;
+    /**
+     * Get the center of this VMobject based on its points.
+     * Uses bounding box center (matching Python Manim's get_center behavior)
+     * rather than point centroid, which is inaccurate for Bezier control points.
+     */
+    getCenter(): Vector3Tuple;
+    /**
+     * Clean up Three.js resources
+     */
+    dispose(): void;
+}
+/**
+ * Get the number of curve segments in a VMobject.
+ * Each cubic Bezier segment uses 4 points (anchor, handle, handle, anchor),
+ * with consecutive segments sharing anchors.
+ * @param vmobject - The VMobject to count curves from
+ * @returns Number of curve segments
+ */
+export declare function getNumCurves(vmobject: VMobject): number;
+/**
+ * Get the nth curve segment from a VMobject as a new VMobject.
+ * @param vmobject - The source VMobject
+ * @param n - Index of the curve segment (0-based)
+ * @returns A new VMobject containing just that curve segment
+ */
+export declare function getNthCurve(vmobject: VMobject, n: number): VMobject;
+/**
+ * Split a VMobject's curves into separate VMobject submobjects.
+ * Each cubic Bezier curve segment becomes its own VMobject child.
+ * Useful for animating parts of a path independently (e.g., staggered animations).
+ *
+ * @param vmobject - The VMobject to split
+ * @returns A new VMobject with each curve as a child submobject
+ *
+ * @example
+ * ```typescript
+ * const path = new VMobject();
+ * path.setPoints([...complex path with multiple curves...]);
+ *
+ * // Split into individual curves for staggered animation
+ * const curves = curvesAsSubmobjects(path);
+ *
+ * // Now animate each curve independently
+ * for (const curve of curves.children) {
+ *   scene.play(Create(curve));
+ * }
+ * ```
+ */
+export declare function curvesAsSubmobjects(vmobject: VMobject): VMobject;
+/**
+ * CurvesAsSubmobjects class - Splits a VMobject's curves into separate submobjects.
+ *
+ * This class extends VMobject and creates children where each child is a single
+ * cubic Bezier curve segment from the source VMobject. This is useful for:
+ * - Staggered animations (animate each curve segment with delay)
+ * - Per-curve styling (color each segment differently)
+ * - Selective curve manipulation
+ *
+ * @example
+ * ```typescript
+ * const path = new VMobject();
+ * path.setPoints([...]);
+ *
+ * const curves = new CurvesAsSubmobjects(path);
+ *
+ * // Access individual curves
+ * curves.children[0].setColor('red');
+ * curves.children[1].setColor('blue');
+ * ```
+ */
+export declare class CurvesAsSubmobjects extends VMobject {
+    /** The source VMobject this was created from */
+    protected _source: VMobject | null;
+    /**
+     * Create a CurvesAsSubmobjects from a VMobject.
+     * @param vmobject - The VMobject to split into curve submobjects
+     */
+    constructor(vmobject?: VMobject);
+    /**
+     * Set up this object from a VMobject, splitting its curves into children.
+     * @param vmobject - The source VMobject
+     * @returns this for chaining
+     */
+    setFromVMobject(vmobject: VMobject): this;
+    /**
+     * Get the number of curve segments (same as number of children).
+     */
+    get numCurves(): number;
+    /**
+     * Get the nth curve as a VMobject.
+     * @param n - Index of the curve (0-based)
+     * @returns The curve VMobject at that index
+     */
+    getCurve(n: number): VMobject;
+    /**
+     * Iterate over all curves.
+     */
+    [Symbol.iterator](): Iterator<VMobject>;
+    /**
+     * Apply a function to each curve.
+     * @param fn - Function to apply
+     * @returns this for chaining
+     */
+    forEach(fn: (curve: VMobject, index: number) => void): this;
+    /**
+     * Map over all curves.
+     * @param fn - Mapping function
+     * @returns Array of mapped values
+     */
+    map<T>(fn: (curve: VMobject, index: number) => T): T[];
+    /**
+     * Create a copy of this CurvesAsSubmobjects.
+     */
+    protected _createCopy(): VMobject;
+}
+export default VMobject;
+//# sourceMappingURL=VMobject.d.ts.map

package/dist/core/VMobject.d.ts.map

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

package/dist/core/index.d.ts

@@ -0,0 +1,16 @@
+export { Mobject, type MobjectStyle, type Vector3Tuple } from './Mobject';
+export { VMobject, type Point, CurvesAsSubmobjects, curvesAsSubmobjects, getNumCurves, getNthCurve, } from './VMobject';
+export { Group } from './Group';
+export { VGroup } from './VGroup';
+export { VDict, VectorizedPoint } from './VDict';
+export { Scene, type SceneOptions } from './Scene';
+export { Camera2D, Camera3D, type CameraOptions, type Camera3DOptions } from './Camera';
+export { MovingCamera, ThreeDCamera, MultiCamera, type MovingCameraOptions, type ThreeDCameraOptions, type CameraAnimationOptions, type CameraViewport, type CameraEntry, type MultiCameraOptions, } from './CameraExtensions';
+export { CameraFrame, CameraAnimateProxy, type CameraFrameOptions, type CameraFrameState, type CameraAnimationOptions as CameraFrameAnimationOptions, } from './CameraFrame';
+export { Renderer, type RendererOptions } from './Renderer';
+export { SceneStateManager, serializeMobject, deserializeMobject, saveMobjectState, restoreMobjectState, stateToJSON, stateFromJSON, snapshotToJSON, snapshotFromJSON, type MobjectState, type SceneSnapshot, } from './StateManager';
+export { AudioManager, type AudioTrack, type AddSoundOptions } from './AudioManager';
+export { InteractiveScene, type InteractiveSceneOptions } from './InteractiveScene';
+export { Lighting, type AmbientLightOptions, type DirectionalLightOptions, type PointLightOptions, type SpotLightOptions } from './Lighting';
+export { ThreeDScene, MovingCameraScene, ZoomedScene, VectorScene, LinearTransformationScene, type ThreeDSceneOptions, type MovingCameraSceneOptions, type ZoomedSceneOptions, type VectorSceneOptions, type LinearTransformationSceneOptions, type Matrix2D, } from './SceneExtensions';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,WAAW,CAAC;AAC1E,OAAO,EACL,QAAQ,EACR,KAAK,KAAK,EACV,mBAAmB,EACnB,mBAAmB,EACnB,YAAY,EACZ,WAAW,GACZ,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,UAAU,CAAC;AACxF,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,kBAAkB,GACxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,sBAAsB,IAAI,2BAA2B,GAC3D,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,EACL,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,aAAa,EACb,cAAc,EACd,gBAAgB,EAChB,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,YAAY,EAAE,KAAK,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACrF,OAAO,EAAE,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AACpF,OAAO,EAAE,QAAQ,EAAE,KAAK,mBAAmB,EAAE,KAAK,uBAAuB,EAAE,KAAK,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC7I,OAAO,EACL,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,WAAW,EACX,yBAAyB,EACzB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,gCAAgC,EACrC,KAAK,QAAQ,GACd,MAAM,mBAAmB,CAAC"}

package/dist/examples.test.d.ts

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

package/dist/examples.test.d.ts.map

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

package/dist/export/GifExporter.d.ts

@@ -0,0 +1,40 @@
+import { Scene } from '../core/Scene';
+interface GifExportOptions {
+    fps?: number;
+    quality?: number;
+    width?: number;
+    height?: number;
+    duration?: number;
+    workers?: number;
+    repeat?: number;
+    onProgress?: (progress: number) => void;
+}
+export declare class GifExporter {
+    private _scene;
+    private _options;
+    constructor(scene: Scene, options?: GifExportOptions);
+    /**
+     * Export the timeline as a GIF
+     */
+    exportTimeline(duration?: number): Promise<Blob>;
+    /**
+     * Get timeline duration if available
+     */
+    private _getTimelineDuration;
+    /**
+     * Get the worker script URL
+     * gif.js requires a worker script for encoding
+     */
+    private _getWorkerScript;
+    /**
+     * Download the GIF
+     */
+    static download(blob: Blob, filename?: string): void;
+    /**
+     * Convenience method: export and download
+     */
+    exportAndDownload(filename?: string, duration?: number): Promise<void>;
+}
+export declare function createGifExporter(scene: Scene, options?: GifExportOptions): GifExporter;
+export type { GifExportOptions };
+//# sourceMappingURL=GifExporter.d.ts.map

package/dist/export/GifExporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GifExporter.d.ts","sourceRoot":"","sources":["../../src/export/GifExporter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAEtC,UAAU,gBAAgB;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAA6B;gBAEjC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,gBAAgB;IAepD;;OAEG;IACG,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqDtD;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAQ5B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,GAAE,MAAwB,GAAG,IAAI;IAWrE;;OAEG;IACG,iBAAiB,CAAC,QAAQ,GAAE,MAAwB,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAI9F;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,WAAW,CAEvF;AAED,YAAY,EAAE,gBAAgB,EAAE,CAAC"}

package/dist/export/VideoExporter.d.ts

@@ -0,0 +1,135 @@
+import { Scene } from '../core/Scene';
+import { AudioManager } from '../core/AudioManager';
+/**
+ * Options for configuring video export.
+ */
+export interface VideoExportOptions {
+    /** Frames per second. Defaults to 60. */
+    fps?: number;
+    /** Quality from 0-1. Defaults to 0.9. */
+    quality?: number;
+    /** Video format. Defaults to 'webm' (mp4 requires additional browser codec support). */
+    format?: 'webm' | 'mp4';
+    /** Output width in pixels. Defaults to scene width. */
+    width?: number;
+    /** Output height in pixels. Defaults to scene height. */
+    height?: number;
+    /** Duration in seconds. Auto-detects from timeline if not specified. */
+    duration?: number;
+    /** Progress callback (0-1). */
+    onProgress?: (progress: number) => void;
+    /**
+     * Include audio from the scene's AudioManager in the exported video.
+     * Defaults to true when the scene has audio tracks loaded.
+     */
+    includeAudio?: boolean;
+    /**
+     * Provide an external AudioManager to use for the audio track.
+     * If not specified, the scene's audioManager is used.
+     */
+    audioManager?: AudioManager;
+}
+interface ResolvedVideoExportOptions {
+    fps: number;
+    quality: number;
+    format: 'webm' | 'mp4';
+    width: number;
+    height: number;
+    duration: number;
+    onProgress: (progress: number) => void;
+    includeAudio: boolean;
+    audioManager: AudioManager | null;
+}
+/**
+ * Video exporter for manimweb scenes.
+ * Uses the MediaRecorder API for browser-native recording.
+ *
+ * WebM with VP9 has the best browser support.
+ * MP4 encoding requires browser support (limited availability).
+ *
+ * Frame-by-frame export gives consistent results vs real-time recording.
+ *
+ * When `includeAudio` is true (default when audio tracks exist), the exported
+ * video includes the mixed-down audio from the scene's AudioManager.
+ */
+export declare class VideoExporter {
+    private _scene;
+    private _options;
+    private _mediaRecorder;
+    private _recordedChunks;
+    private _isRecording;
+    /**
+     * Create a new VideoExporter.
+     * @param scene - The scene to export
+     * @param options - Export options
+     */
+    constructor(scene: Scene, options?: VideoExportOptions);
+    /**
+     * Get the AudioManager to use for export.
+     * Returns the explicitly provided one, or the scene's manager if it has tracks.
+     */
+    private _getAudioManager;
+    /**
+     * Start recording the scene.
+     * If audio is available and `includeAudio` is true, the audio stream
+     * is merged into the recording.
+     * @throws Error if already recording or format not supported
+     */
+    startRecording(): Promise<void>;
+    /**
+     * Stop recording and return the video blob.
+     * @returns Promise resolving to the video Blob
+     * @throws Error if not recording
+     */
+    stopRecording(): Promise<Blob>;
+    /**
+     * Export a specific duration of the timeline.
+     * Renders frame-by-frame for consistent results.
+     *
+     * If the scene has audio and `includeAudio` is true, audio is included
+     * in the exported video file.
+     *
+     * @param duration - Duration to export in seconds (auto-detects from timeline if not specified)
+     * @returns Promise resolving to the video Blob
+     */
+    exportTimeline(duration?: number): Promise<Blob>;
+    /**
+     * Export audio-only as a WAV Blob.
+     * Useful when you need the audio track separately (e.g., for external muxing).
+     *
+     * @param duration - Duration in seconds (defaults to timeline duration)
+     * @returns WAV Blob, or null if no audio is available
+     */
+    exportAudio(duration?: number): Promise<Blob | null>;
+    /**
+     * Download a video blob as a file.
+     * @param blob - The video blob to download
+     * @param filename - The filename (defaults to 'animation.webm')
+     */
+    static download(blob: Blob, filename?: string): void;
+    /**
+     * Convenience method: export timeline and download the result.
+     * @param filename - Optional filename (extension auto-added based on format)
+     * @param duration - Optional duration override
+     */
+    exportAndDownload(filename?: string, duration?: number): Promise<void>;
+    /**
+     * Check if currently recording.
+     * @returns true if recording is in progress
+     */
+    isRecording(): boolean;
+    /**
+     * Get the export options.
+     * @returns The resolved export options
+     */
+    getOptions(): Readonly<ResolvedVideoExportOptions>;
+}
+/**
+ * Factory function to create a VideoExporter.
+ * @param scene - The scene to export
+ * @param options - Export options
+ * @returns A new VideoExporter instance
+ */
+export declare function createVideoExporter(scene: Scene, options?: VideoExportOptions): VideoExporter;
+export {};
+//# sourceMappingURL=VideoExporter.d.ts.map

package/dist/export/VideoExporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VideoExporter.d.ts","sourceRoot":"","sources":["../../src/export/VideoExporter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,yCAAyC;IACzC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wFAAwF;IACxF,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACxB,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wEAAwE;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,UAAU,0BAA0B;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,YAAY,EAAE,OAAO,CAAC;IACtB,YAAY,EAAE,YAAY,GAAG,IAAI,CAAC;CACnC;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,QAAQ,CAA6B;IAC7C,OAAO,CAAC,cAAc,CAA8B;IACpD,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,YAAY,CAAkB;IAEtC;;;;OAIG;gBACS,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,kBAAkB;IAetD;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;;;;OAKG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAiDrC;;;;OAIG;IACG,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBpC;;;;;;;;;OASG;IACG,cAAc,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAuCtD;;;;;;OAMG;IACG,WAAW,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAQ1D;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,GAAE,MAAyB,GAAG,IAAI;IAWtE;;;;OAIG;IACG,iBAAiB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAM5E;;;OAGG;IACH,WAAW,IAAI,OAAO;IAItB;;;OAGG;IACH,UAAU,IAAI,QAAQ,CAAC,0BAA0B,CAAC;CAGnD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,aAAa,CAE7F"}

package/dist/export/index.d.ts

@@ -0,0 +1,3 @@
+export { GifExporter, createGifExporter, type GifExportOptions } from './GifExporter';
+export { VideoExporter, createVideoExporter, type VideoExportOptions } from './VideoExporter';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/export/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtF,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}