manim-web 0.2.0

package/dist/utils/featureFlags.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Lightweight feature flag system for manim-js.
+ * Enables toggling experimental features without code changes.
+ */
+type FeatureFlags = Record<string, boolean>;
+/** Check if a feature flag is enabled. */
+export declare function isFeatureEnabled(flag: string): boolean;
+/** Override feature flags (e.g., from environment or config). */
+export declare function setFeatureFlags(overrides: Partial<FeatureFlags>): void;
+/** Reset all flags to defaults. */
+export declare function resetFeatureFlags(): void;
+/** Get all current flag values. */
+export declare function getFeatureFlags(): Readonly<FeatureFlags>;
+export {};
+//# sourceMappingURL=featureFlags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"featureFlags.d.ts","sourceRoot":"","sources":["../../src/utils/featureFlags.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,KAAK,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAU5C,0CAA0C;AAC1C,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,iEAAiE;AACjE,wBAAgB,eAAe,CAAC,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,IAAI,CAEtE;AAED,mCAAmC;AACnC,wBAAgB,iBAAiB,IAAI,IAAI,CAExC;AAED,mCAAmC;AACnC,wBAAgB,eAAe,IAAI,QAAQ,CAAC,YAAY,CAAC,CAExD"}

package/dist/utils/hungarian.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Hungarian (Kuhn-Munkres) Algorithm for Optimal Assignment
+ *
+ * Solves the assignment problem: given an n x m cost matrix, find the
+ * assignment of rows to columns that minimizes the total cost.
+ *
+ * Time complexity: O(n^3) where n = max(rows, cols)
+ * Space complexity: O(n^2)
+ *
+ * Handles rectangular matrices (different number of source vs target parts)
+ * by padding to square with zero-cost dummy entries.
+ */
+/**
+ * Result of the Hungarian algorithm.
+ */
+export interface HungarianResult {
+    /**
+     * Optimal row-to-column assignments.
+     * assignments[i] = j means row i is assigned to column j.
+     * assignments[i] = -1 means row i is unassigned (when cols < rows after filtering dummies).
+     */
+    assignments: number[];
+    /** Total cost of the optimal assignment */
+    totalCost: number;
+    /** Set of row indices that are assigned (not dummy) */
+    assignedRows: Set<number>;
+    /** Set of column indices that are assigned (not dummy) */
+    assignedCols: Set<number>;
+}
+/**
+ * Solve the assignment problem using the Hungarian (Kuhn-Munkres) algorithm.
+ *
+ * Given an n x m cost matrix, finds the optimal one-to-one assignment of
+ * rows to columns that minimizes total cost.
+ *
+ * Implementation uses the successive shortest path formulation with
+ * potential functions (Jonker-Volgenant style) for O(n^3) performance.
+ *
+ * @param costMatrix - n x m matrix where costMatrix[i][j] is the cost
+ *                     of assigning row i to column j
+ * @returns HungarianResult with optimal assignments and metadata
+ *
+ * @example
+ * ```typescript
+ * const cost = [
+ *   [10, 5, 13],
+ *   [3, 7, 15],
+ *   [8, 12, 11],
+ * ];
+ * const result = hungarian(cost);
+ * // result.assignments might be [1, 0, 2] with totalCost = 5+3+11 = 19
+ * ```
+ */
+export declare function hungarian(costMatrix: number[][]): HungarianResult;
+/**
+ * Convenience function to find the optimal matching given a similarity matrix.
+ * Converts similarities (higher = better) to costs (lower = better) and
+ * runs the Hungarian algorithm.
+ *
+ * @param similarityMatrix - n x m matrix where higher values mean better matches
+ * @param threshold - Minimum similarity to consider a valid match (default: 0).
+ *                    Pairs below this threshold are treated as unmatched.
+ * @returns HungarianResult with optimal assignments
+ */
+export declare function hungarianFromSimilarity(similarityMatrix: number[][], threshold?: number): HungarianResult;
+//# sourceMappingURL=hungarian.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hungarian.d.ts","sourceRoot":"","sources":["../../src/utils/hungarian.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,WAAW,EAAE,MAAM,EAAE,CAAC;IAEtB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,CAAC;IAElB,uDAAuD;IACvD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAE1B,0DAA0D;IAC1D,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,GAAG,eAAe,CAgIjE;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,gBAAgB,EAAE,MAAM,EAAE,EAAE,EAC5B,SAAS,GAAE,MAAU,GACpB,eAAe,CAkDjB"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Structured logger for manim-js.
+ * Provides consistent logging interface for both browser and Node environments.
+ * Includes log sanitization to redact sensitive data (tokens, keys, emails).
+ */
+interface Logger {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+export declare const logger: Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,UAAU,MAAM;IACd,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACpC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACnC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACnC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACrC;AAwGD,eAAO,MAAM,MAAM,EAAE,MAapB,CAAC"}

package/dist/utils/math.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared math utility functions used across the codebase.
+ */
+/**
+ * Linear interpolation between two numbers.
+ * Returns a + (b - a) * t.
+ */
+export declare function lerp(a: number, b: number, t: number): number;
+/**
+ * Linear interpolation between two 3D points, component-wise.
+ * Each point is represented as a number array [x, y, z].
+ */
+export declare function lerpPoint(a: number[], b: number[], t: number): number[];
+/**
+ * Hermite smoothstep interpolation.
+ * Maps t in [0, 1] to a smooth S-curve: 3t^2 - 2t^3.
+ * Commonly used for smooth camera movements and animation easing.
+ */
+export declare function smoothstep(t: number): number;
+/**
+ * Convert graph coordinates to visual point coordinates.
+ *
+ * @param x - X coordinate in graph space
+ * @param y - Y coordinate in graph space
+ * @param xRange - X-axis range as [min, max, ...] (only first two elements used)
+ * @param yRange - Y-axis range as [min, max, ...] (only first two elements used)
+ * @param xLength - Visual length of the x-axis
+ * @param yLength - Visual length of the y-axis
+ * @returns The visual point [x, y, 0]
+ */
+export declare function coordsToPoint(x: number, y: number, xRange: [number, number, ...number[]], yRange: [number, number, ...number[]], xLength: number, yLength: number): [number, number, number];
+/**
+ * Convert visual point coordinates to graph coordinates.
+ *
+ * @param point - Visual point [x, y, z] (z is ignored)
+ * @param xRange - X-axis range as [min, max, ...] (only first two elements used)
+ * @param yRange - Y-axis range as [min, max, ...] (only first two elements used)
+ * @param xLength - Visual length of the x-axis
+ * @param yLength - Visual length of the y-axis
+ * @returns Graph coordinates [x, y]
+ */
+export declare function pointToCoords(point: [number, number, number], xRange: [number, number, ...number[]], yRange: [number, number, ...number[]], xLength: number, yLength: number): [number, number];
+/**
+ * Evaluate a cubic Bezier curve at parameter t.
+ * Uses the standard cubic Bernstein polynomial:
+ *   B(t) = (1-t)^3 * p0 + 3*(1-t)^2*t * p1 + 3*(1-t)*t^2 * p2 + t^3 * p3
+ *
+ * The z-component uses nullish coalescing (p[2] ?? 0) so that 2D points
+ * (without an explicit z) are handled safely.
+ */
+export declare function evalCubicBezier(p0: number[], p1: number[], p2: number[], p3: number[], t: number): number[];
+//# sourceMappingURL=math.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"math.d.ts","sourceRoot":"","sources":["../../src/utils/math.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAMvE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACrC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAQ1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC/B,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACrC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,EACrC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,CAAC,MAAM,EAAE,MAAM,CAAC,CAQlB;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EAAE,EACZ,EAAE,EAAE,MAAM,EAAE,EACZ,EAAE,EAAE,MAAM,EAAE,EACZ,EAAE,EAAE,MAAM,EAAE,EACZ,CAAC,EAAE,MAAM,GACR,MAAM,EAAE,CAYV"}

package/dist/utils/ode.d.ts

@@ -0,0 +1,135 @@
+/**
+ * ODE (Ordinary Differential Equation) solvers for numerical integration.
+ *
+ * Provides Runge-Kutta 4th order (RK4) integration for systems of the form:
+ *   dy/dt = f(t, y)
+ *
+ * Supports scalar and vector-valued state variables (2D and 3D).
+ */
+/**
+ * A function defining the right-hand side of an ODE system: dy/dt = f(t, y).
+ * @param t - Current time
+ * @param y - Current state vector
+ * @returns The derivative dy/dt at (t, y)
+ */
+export type ODEFunction = (t: number, y: number[]) => number[];
+/**
+ * An autonomous vector field function: dy/dt = f(y).
+ * This is the common case for phase flows where the field does not
+ * depend on time explicitly.
+ * @param point - Current position as [x, y, z]
+ * @returns Velocity vector [vx, vy, vz]
+ */
+export type VectorFieldFunction3D = (point: [number, number, number]) => [number, number, number];
+/**
+ * Options for the IVP (Initial Value Problem) solver.
+ */
+export interface SolveIVPOptions {
+    /** Fixed step size. If not provided, defaults to (tEnd - t0) / numSteps. */
+    stepSize?: number;
+    /** Number of integration steps (used when stepSize is not provided). Default: 100 */
+    numSteps?: number;
+    /** Whether to record the full trajectory or only return the final state. Default: false */
+    recordTrajectory?: boolean;
+}
+/**
+ * Result of solving an IVP.
+ */
+export interface IVPResult {
+    /** Final state vector */
+    y: number[];
+    /** Final time */
+    t: number;
+    /** Trajectory of [t, y] pairs (only populated if recordTrajectory is true) */
+    trajectory: {
+        t: number;
+        y: number[];
+    }[];
+}
+/**
+ * Perform a single RK4 integration step.
+ *
+ * Advances the state y at time t by one step of size h using the
+ * classical 4th-order Runge-Kutta method.
+ *
+ * @param f - The ODE function dy/dt = f(t, y)
+ * @param t - Current time
+ * @param y - Current state vector
+ * @param h - Step size
+ * @returns The new state vector at time t + h
+ */
+export declare function rk4Step(f: ODEFunction, t: number, y: number[], h: number): number[];
+/**
+ * Solve an initial value problem (IVP) using RK4 integration.
+ *
+ * Integrates dy/dt = f(t, y) from t0 to tEnd starting at y0.
+ *
+ * @param f - The ODE function dy/dt = f(t, y)
+ * @param t0 - Initial time
+ * @param y0 - Initial state vector
+ * @param tEnd - Final time
+ * @param options - Solver options (stepSize, numSteps, recordTrajectory)
+ * @returns The solution at tEnd (and optionally the full trajectory)
+ *
+ * @example
+ * ```typescript
+ * // Solve a simple harmonic oscillator: x'' = -x
+ * // Written as a system: y = [x, v], dy/dt = [v, -x]
+ * const result = solveIVP(
+ *   (t, y) => [y[1], -y[0]],
+ *   0,           // t0
+ *   [1, 0],      // y0 = [x0, v0]
+ *   2 * Math.PI,  // tEnd (one full period)
+ *   { numSteps: 1000 }
+ * );
+ * // result.y should be close to [1, 0]
+ * ```
+ */
+export declare function solveIVP(f: ODEFunction, t0: number, y0: number[], tEnd: number, options?: SolveIVPOptions): IVPResult;
+/**
+ * Flow a 3D point along an autonomous vector field for a given duration.
+ *
+ * This is a convenience wrapper around solveIVP for the common case of
+ * flowing a point through a time-independent vector field:
+ *   dp/dt = vectorField(p)
+ *
+ * @param vectorField - The vector field function (point) => velocity
+ * @param start - Starting point [x, y, z]
+ * @param time - Duration to flow (can be negative for backward flow)
+ * @param numSteps - Number of integration steps (default: 100)
+ * @returns The final position [x, y, z]
+ *
+ * @example
+ * ```typescript
+ * // Circular flow: dp/dt = [-y, x, 0]
+ * const end = flowPoint(
+ *   ([x, y, z]) => [-y, x, 0],
+ *   [1, 0, 0],
+ *   Math.PI / 2  // quarter turn
+ * );
+ * // end should be close to [0, 1, 0]
+ * ```
+ */
+export declare function flowPoint(vectorField: VectorFieldFunction3D, start: [number, number, number], time: number, numSteps?: number): [number, number, number];
+/**
+ * Flow a 3D point along an autonomous vector field and return the full trajectory.
+ *
+ * @param vectorField - The vector field function (point) => velocity
+ * @param start - Starting point [x, y, z]
+ * @param time - Duration to flow
+ * @param numSteps - Number of integration steps (default: 100)
+ * @returns Array of points along the trajectory
+ *
+ * @example
+ * ```typescript
+ * // Get trajectory for a spiral flow
+ * const trajectory = flowPointTrajectory(
+ *   ([x, y, z]) => [-y - 0.1*x, x - 0.1*y, 0],
+ *   [1, 0, 0],
+ *   10,
+ *   500
+ * );
+ * ```
+ */
+export declare function flowPointTrajectory(vectorField: VectorFieldFunction3D, start: [number, number, number], time: number, numSteps?: number): [number, number, number][];
+//# sourceMappingURL=ode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ode.d.ts","sourceRoot":"","sources":["../../src/utils/ode.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;AAE/D;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAElG;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2FAA2F;IAC3F,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,yBAAyB;IACzB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,iBAAiB;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,8EAA8E;IAC9E,UAAU,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAkCnF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,WAAW,EACd,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EAAE,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,GAC5B,SAAS,CAmCX;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CACvB,WAAW,EAAE,qBAAqB,EAClC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,MAAY,GACrB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAe1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,qBAAqB,EAClC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,MAAY,GACrB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAkB5B"}

package/dist/utils/skeletonize.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Glyph Skeletonization — Medial Axis Extraction via Zhang-Suen Thinning
+ *
+ * Converts a glyph's cubic Bezier outline into center-line paths that
+ * represent the natural pen strokes of the character. The algorithm:
+ *
+ * 1. Rasterizes the glyph outline to a binary grid (filled / empty)
+ * 2. Applies the Zhang-Suen thinning algorithm to extract a 1-pixel skeleton
+ * 3. Traces skeleton pixels into ordered path chains
+ * 4. Smooths the paths using Catmull-Rom interpolation
+ * 5. Fits cubic Bezier curves to the smooth paths
+ *
+ * The output format matches VMobject's control point convention:
+ *   [anchor1, handle1, handle2, anchor2, handle3, handle4, anchor3, ...]
+ */
+export interface SkeletonizeOptions {
+    /** Grid resolution (pixels along the longest glyph dimension). Default: 100 */
+    gridResolution?: number;
+    /** Smoothing subdivisions per traced segment (Catmull-Rom). Default: 4 */
+    smoothSubdivisions?: number;
+    /** Minimum chain length in pixels to keep. Default: 3 */
+    minChainLength?: number;
+}
+/**
+ * Extract the medial-axis (skeleton) of a glyph outline as cubic Bezier
+ * control points compatible with VMobject.
+ *
+ * @param outlinePoints Cubic Bezier control points from GlyphVMobject:
+ *   [anchor1, handle1, handle2, anchor2, ...]  where each point is [x, y, z].
+ * @param options  Tuning parameters.
+ * @returns Array of cubic Bezier control points tracing the skeleton center-line,
+ *   or an empty array if the glyph has no interior (e.g. a dot or very thin glyph).
+ */
+export declare function skeletonizeGlyph(outlinePoints: number[][], options?: SkeletonizeOptions): number[][];
+//# sourceMappingURL=skeletonize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skeletonize.d.ts","sourceRoot":"","sources":["../../src/utils/skeletonize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,MAAM,WAAW,kBAAkB;IACjC,+EAA+E;IAC/E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0EAA0E;IAC1E,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,yDAAyD;IACzD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,EAAE,EAAE,EACzB,OAAO,GAAE,kBAAuB,GAC/B,MAAM,EAAE,EAAE,CAqEZ"}

package/dist/utils/triangulate.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Polygon triangulation using earcut.
+ *
+ * earcut is the JS port of mapbox-earcut -- the same robust library that
+ * Python manim relies on for polygon fill.  It handles:
+ *   - Simple convex / concave polygons
+ *   - Polygons with holes (inner rings)
+ *   - Self-intersecting polygons (best-effort)
+ *   - Degenerate / zero-area cases (returns empty indices)
+ *
+ * Usage:
+ *   const indices = triangulatePolygon(outerRing);
+ *   const indices = triangulatePolygon(outerRing, [hole1, hole2]);
+ */
+/**
+ * Triangulate a 2D polygon, optionally with holes.
+ *
+ * @param vertices - Outer ring as an array of [x, y] pairs (or [x, y, z] --
+ *                   only the first two components are used).
+ * @param holes    - Optional array of hole rings.  Each hole is an array of
+ *                   [x, y] (or [x, y, z]) pairs wound in the opposite
+ *                   direction of the outer ring.
+ * @returns Flat array of triangle vertex indices into the combined vertex
+ *          list (outer ring vertices followed by all hole vertices in order).
+ *          Length is always a multiple of 3.  Returns [] for degenerate input.
+ */
+export declare function triangulatePolygon(vertices: number[][], holes?: number[][][]): number[];
+/**
+ * Triangulate a polygon and return a flat Float32Array of triangle positions
+ * suitable for use as a Three.js BufferGeometry position attribute.
+ *
+ * @param vertices - Outer ring [x, y] pairs
+ * @param holes    - Optional hole rings
+ * @param z        - Z coordinate to assign to every output vertex (default 0)
+ * @returns Float32Array of xyz triplets (length = numTriangles * 9), or an
+ *          empty Float32Array for degenerate input.
+ */
+export declare function triangulatePolygonPositions(vertices: number[][], holes?: number[][][], z?: number): Float32Array;
+/**
+ * Compute the signed area of a 2D polygon ring.
+ * Positive = counter-clockwise, negative = clockwise.
+ */
+export declare function signedArea2D(ring: number[][]): number;
+/**
+ * Ensure a ring is wound counter-clockwise (positive signed area).
+ * Returns the ring unchanged if already CCW, or reversed otherwise.
+ */
+export declare function ensureCCW(ring: number[][]): number[][];
+/**
+ * Ensure a ring is wound clockwise (negative signed area).
+ * Holes should be CW when the outer ring is CCW.
+ */
+export declare function ensureCW(ring: number[][]): number[][];
+//# sourceMappingURL=triangulate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triangulate.d.ts","sourceRoot":"","sources":["../../src/utils/triangulate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAQH;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAAE,EAAE,EACpB,KAAK,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,GACnB,MAAM,EAAE,CAiCV;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,MAAM,EAAE,EAAE,EACpB,KAAK,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EACpB,CAAC,GAAE,MAAU,GACZ,YAAY,CAuBd;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAOrD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAEtD;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAErD"}

package/dist/utils/vectors.d.ts

@@ -0,0 +1,57 @@
+import { Vector3Tuple } from '../core/Mobject';
+/**
+ * Scale a direction vector by a scalar.
+ *
+ * @param scalar - The scalar multiplier
+ * @param vec - The direction vector [x, y, z]
+ * @returns Scaled vector as [x * scalar, y * scalar, z * scalar]
+ *
+ * @example
+ * ```ts
+ * scaleVec(2, LEFT)  // [-2, 0, 0]
+ * scaleVec(1.5, UP)  // [0, 1.5, 0]
+ * ```
+ */
+export declare function scaleVec(scalar: number, vec: Vector3Tuple): Vector3Tuple;
+/**
+ * Add two or more vectors component-wise.
+ *
+ * @param vecs - Two or more vectors to add
+ * @returns Sum vector as [sum_x, sum_y, sum_z]
+ *
+ * @example
+ * ```ts
+ * addVec(LEFT, UP)       // [-1, 1, 0]
+ * addVec(scaleVec(2, RIGHT), scaleVec(3, DOWN))  // [2, -3, 0]
+ * ```
+ */
+export declare function addVec(...vecs: Vector3Tuple[]): Vector3Tuple;
+/**
+ * Subtract one vector from another (a - b).
+ *
+ * @param a - The vector to subtract from
+ * @param b - The vector to subtract
+ * @returns Difference vector as [a_x - b_x, a_y - b_y, a_z - b_z]
+ *
+ * @example
+ * ```ts
+ * subVec([4, 3, 0], [1, 0, 0])  // [3, 3, 0]
+ * ```
+ */
+export declare function subVec(a: Vector3Tuple, b: Vector3Tuple): Vector3Tuple;
+/**
+ * Create an array of evenly spaced values (NumPy linspace equivalent).
+ *
+ * @param start - Start value
+ * @param stop - End value (inclusive)
+ * @param num - Number of points to generate
+ * @returns Array of `num` evenly spaced values from `start` to `stop`
+ *
+ * @example
+ * ```ts
+ * linspace(0, 10, 5)  // [0, 2.5, 5, 7.5, 10]
+ * linspace(0, 1, 3)   // [0, 0.5, 1]
+ * ```
+ */
+export declare function linspace(start: number, stop: number, num: number): number[];
+//# sourceMappingURL=vectors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vectors.d.ts","sourceRoot":"","sources":["../../src/utils/vectors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,YAAY,GAAG,YAAY,CAExE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,GAAG,IAAI,EAAE,YAAY,EAAE,GAAG,YAAY,CAQ5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY,CAErE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAG3E"}

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "manim-web",
+  "version": "0.2.0",
+  "description": "Manim-like mathematical animation library for the web",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/integrations/react.d.ts",
+      "import": "./dist/integrations/react.js",
+      "default": "./dist/integrations/react.js"
+    },
+    "./vue": {
+      "types": "./dist/integrations/vue.d.ts",
+      "import": "./dist/integrations/vue.js",
+      "default": "./dist/integrations/vue.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write src/",
+    "docs": "node scripts/generate-example-docs.mjs && cd website && npm run build",
+    "docs:dev": "node scripts/generate-example-docs.mjs && cd website && npm start",
+    "docs:examples": "node scripts/generate-example-docs.mjs",
+    "cpd": "jscpd src/",
+    "test:integration": "npx playwright test",
+    "format:check": "prettier --check src/",
+    "knip": "knip",
+    "release": "standard-version",
+    "release:minor": "standard-version --release-as minor",
+    "release:major": "standard-version --release-as major",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "eslint --fix",
+      "prettier --write"
+    ]
+  },
+  "dependencies": {
+    "earcut": "^3.0.2",
+    "gif.js": "^0.2.0",
+    "katex": "^0.16.28",
+    "opentype.js": "^1.3.4",
+    "polygon-clipping": "^0.15.7",
+    "three": "^0.182.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@playwright/test": "^1.58.2",
+    "@types/earcut": "^3.0.0",
+    "@types/katex": "^0.16.8",
+    "@types/react": "^19.2.13",
+    "@types/three": "^0.182.0",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "husky": "^9.1.7",
+    "jscpd": "^4.0.8",
+    "knip": "^5.83.1",
+    "lint-staged": "^16.2.7",
+    "prettier": "^3.8.1",
+    "standard-version": "^9.5.0",
+    "typedoc": "^0.28.16",
+    "typescript": "^5.3.0",
+    "typescript-eslint": "^8.54.0",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18",
+    "vue": "^3.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "vue": ">=3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/maloyan/manim-js.git"
+  },
+  "homepage": "https://maloyan.github.io/manim-js/",
+  "bugs": {
+    "url": "https://github.com/maloyan/manim-js/issues"
+  },
+  "keywords": [
+    "animation",
+    "math",
+    "visualization",
+    "manim",
+    "threejs",
+    "webgl",
+    "3blue1brown",
+    "mathematical-animations",
+    "typescript"
+  ],
+  "license": "MIT"
+}