manim-web 0.3.24 → 0.11.0

package/dist/utils/ManimColor.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Class layer ported from ManimCE's `manim/utils/color/core.py` (ManimCE 0.22.0).
+ *
+ * The free color functions (hex/rgb/hsv conversion, interpolation, gradients)
+ * live in `./color` and use the 0.0..1.0 float convention. This module adds the
+ * `ManimColor` object on top of them.
+ *
+ * manim-web otherwise stores a color as a `#rrggbb` hex string end to end, so a
+ * `ManimColor` stays interoperable by exposing {@link ManimColor.toHex}: the
+ * returned string works everywhere the repo expects a color.
+ *
+ * Deliberate divergences from ManimCE (documented for parity readers):
+ * - TypeScript cannot tell an integer tuple from a float tuple at run time, so a
+ *   numeric array is always read as a float RGB(A) array in 0.0..1.0. ManimCE's
+ *   int-vs-float auto-detection is not reproduced.
+ * - {@link RandomColorGenerator} is deterministic for a given seed, but it does
+ *   not reproduce CPython's Mersenne Twister sequence; it uses a `mulberry32`
+ *   PRNG instead.
+ */
+/** A color channel. Name-parity with ManimCE's numpy `float64` dtype. */
+export type ManimColorDType = number;
+type Rgb = [number, number, number];
+type Rgba = [number, number, number, number];
+type Hsv = [number, number, number];
+/** Every type that {@link ManimColor.parse} and the constructor accept. */
+export type ParsableManimColor = ManimColor | number | string | [number, number, number] | [number, number, number, number];
+/**
+ * Internal color data structure, ported from ManimCE's `ManimColor`.
+ *
+ * The internal representation is an `[r,g,b,a]` array of floats in 0.0..1.0.
+ */
+export declare class ManimColor {
+    protected readonly value: Rgba;
+    /**
+     * @param value Any {@link ParsableManimColor}, or `null` for black.
+     * @param alpha Opacity in 0.0..1.0. Default `1.0`. Ignored for an 8-digit hex
+     *   string and for a 4-element (RGBA) array, which carry their own alpha.
+     */
+    constructor(value: ParsableManimColor | null, alpha?: number);
+    /** The `[r,g,b,a]` internal value. Overridden by subclasses. */
+    protected internalRgba(): Rgba;
+    /** The space used for operators and interpolation (`[r,g,b,a]` for the base). */
+    protected getSpace(): number[];
+    /** Build a color of this class from a space array. Overridden by subclasses. */
+    protected constructFromSpace(space: number[]): ManimColor;
+    /** Build a color of this class from an `[r,g,b,a]` value (ManimCE `_from_internal`). */
+    protected fromInternal(rgba: Rgba): ManimColor;
+    /** Convert to an `[r,g,b]` float array (0.0..1.0). */
+    toRgb(): Rgb;
+    /** Convert to an `[r,g,b,a]` float array (0.0..1.0). */
+    toRgba(): Rgba;
+    /** Convert to an `[r,g,b]` integer array (0..255, truncated). */
+    toIntRgb(): Rgb;
+    /** Convert to an `[r,g,b,a]` integer array (0..255, truncated). */
+    toIntRgba(): Rgba;
+    /**
+     * Convert to a `#RRGGBB` hex string, or `#RRGGBBAA` when `withAlpha` is true.
+     */
+    toHex(withAlpha?: boolean): string;
+    /** Convert to an `[h,s,v]` float array (0.0..1.0). */
+    toHsv(): Hsv;
+    /**
+     * Interpolate toward `other` in this color's space.
+     *
+     * `alpha` 0.0 returns a copy of this color, 1.0 returns `other`.
+     */
+    interpolate(other: ManimColor, alpha: number): ManimColor;
+    /**
+     * Return a linearly inverted color (`1 - channel`).
+     *
+     * @param withAlpha If true, the alpha is inverted too. Default `false`.
+     */
+    invert(withAlpha?: boolean): ManimColor;
+    /** Return a new color with the given opacity and the same color values. */
+    opacity(opacity: number): ManimColor;
+    /** Alias of {@link opacity}. */
+    withAlpha(alpha: number): ManimColor;
+    /**
+     * Return a darker color: interpolated toward black. The opacity is unchanged.
+     *
+     * @param blend 0.0 (unchanged) to 1.0 (pure black). Default `0.2`.
+     */
+    darker(blend?: number): ManimColor;
+    /**
+     * Return a lighter color: interpolated toward white. The opacity is unchanged.
+     *
+     * @param blend 0.0 (unchanged) to 1.0 (pure white). Default `0.2`.
+     */
+    lighter(blend?: number): ManimColor;
+    /** Compare two colors with a numpy-style `allclose` tolerance. */
+    equals(other: ManimColor): boolean;
+    /** Return the `#RRGGBB` hex string, so a color interpolates into templates. */
+    toString(): string;
+    /** Create a color from an RGB(A) float array. Ports `ManimColor.from_rgb`. */
+    static fromRgb(rgb: Rgb | Rgba, alpha?: number): ManimColor;
+    /** Create a color from an RGBA float array. Ports `ManimColor.from_rgba`. */
+    static fromRgba(rgba: Rgba): ManimColor;
+    /** Create a color from a hex string. Ports `ManimColor.from_hex`. */
+    static fromHex(hex: string, alpha?: number): ManimColor;
+    /** Create a color from an `[h,s,v]` float array. Ports `ManimColor.from_hsv`. */
+    static fromHsv(hsv: Hsv, alpha?: number): ManimColor;
+    /**
+     * Parse one color, or a list of colors.
+     *
+     * A numeric array (length 3 or 4) is read as a single RGB(A) color. An array
+     * whose elements are themselves colors (strings, numbers-as-ints via nested
+     * arrays, or `ManimColor`s) is read as a list. This resolves ManimCE's
+     * documented "array of numbers becomes a list of colors" footgun in favor of
+     * the single-color reading.
+     */
+    static parse(color: ParsableManimColor | ParsableManimColor[] | null, alpha?: number): ManimColor | ManimColor[];
+}
+/** RGBA color space. In ManimCE this is an alias of {@link ManimColor}. */
+export declare const RGBA: typeof ManimColor;
+/** RGBA color space type. In ManimCE this is an alias of {@link ManimColor}. */
+export type RGBA = ManimColor;
+/**
+ * HSV color space, a {@link ManimColor} subclass.
+ *
+ * It is constructed from `[h,s,v]` (or `[h,s,v,a]`) floats in 0.0..1.0 and keeps
+ * that representation internally, so operators and {@link ManimColor.interpolate}
+ * act in HSV space.
+ */
+export declare class HSV extends ManimColor {
+    private readonly hsva;
+    constructor(hsv: Hsv | [number, number, number, number], alpha?: number);
+    protected internalRgba(): Rgba;
+    protected getSpace(): number[];
+    protected constructFromSpace(space: number[]): ManimColor;
+    protected fromInternal(rgba: Rgba): ManimColor;
+    get h(): number;
+    get s(): number;
+    get v(): number;
+}
+/**
+ * A generator of random colors, deterministic when given a seed.
+ *
+ * Ports ManimCE's `RandomColorGenerator`. With a `seed`, the same sequence of
+ * colors is produced every time (see the module note on the PRNG). Without a
+ * seed, `Math.random` is used and the output is non-deterministic.
+ */
+export declare class RandomColorGenerator {
+    private readonly rng;
+    private readonly colors;
+    constructor(seed?: number, sampleColors?: readonly ParsableManimColor[]);
+    /** Return the next random color from the configured palette. */
+    next(): ManimColor;
+}
+/**
+ * Add light or shadow to an `rgb` color on a surface, ported from ManimCE's
+ * `get_shaded_rgb`.
+ *
+ * The surface sits at `point`, faces `unitNormal`, and may be lit by
+ * `lightSource`. The result is not clamped, matching ManimCE.
+ *
+ * @param rgb The surface base color (0.0..1.0 floats).
+ * @param point The location of the surface.
+ * @param unitNormal The unit normal the surface faces.
+ * @param lightSource The location of the light source.
+ */
+export declare function getShadedRgb(rgb: Rgb, point: readonly number[], unitNormal: readonly number[], lightSource: readonly number[]): Rgb;
+export {};
+//# sourceMappingURL=ManimColor.d.ts.map

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

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

package/dist/utils/bezier.d.ts

@@ -0,0 +1,95 @@
+import { integerInterpolate, partialBezierPoints, smoothHandlePoints } from '../core/VMobjectCurveMath';
+/**
+ * Control points of the portion of a Bézier curve between parameters `a` and `b`.
+ * Canonical implementation lives in `VMobjectCurveMath` (Manim CE `partial_bezier_points`).
+ */
+export { partialBezierPoints };
+/**
+ * Integer-and-residue split of `alpha` over the range `[start, end)`.
+ * Canonical implementation lives in `VMobjectCurveMath` (Manim CE `integer_interpolate`).
+ */
+export { integerInterpolate };
+/**
+ * Smooth cubic-Bézier handles for a sequence of anchors (Manim CE
+ * `get_smooth_cubic_bezier_handle_points`).
+ *
+ * manim-web smooths every spline as an open spline (the `get_smooth_open_cubic_bezier_handle_points`
+ * case in Manim CE), so closed loops are not periodic-smooth at the seam. The
+ * return value is `{ h1, h2 }`, not the `(H1, H2)` tuple Manim CE returns.
+ */
+export { smoothHandlePoints as getSmoothCubicBezierHandlePoints };
+/** Linearly interpolate between two scalars. Returns `(1 - alpha) * start + alpha * end`. */
+export declare function interpolate(start: number, end: number, alpha: number): number;
+/** Linearly interpolate between two points, component-wise. */
+export declare function interpolate(start: number[], end: number[], alpha: number): number[];
+/** Midpoint of two scalars. */
+export declare function mid(start: number, end: number): number;
+/** Midpoint of two points, component-wise. */
+export declare function mid(start: number[], end: number[]): number[];
+/** Inverse interpolation: the `alpha` such that `interpolate(start, end, alpha) === value`. */
+declare function inverseInterpolate(start: number, end: number, value: number): number;
+/** Inverse interpolation between two points, component-wise. */
+declare function inverseInterpolate(start: number[], end: number[], value: number[]): number[];
+/**
+ * Map a value from an old range onto a new range, preserving its relative
+ * position: `interpolate(newStart, newEnd, inverse_interpolate(oldStart, oldEnd, oldValue))`.
+ */
+declare function matchInterpolate(newStart: number, newEnd: number, oldStart: number, oldEnd: number, oldValue: number): number;
+/** {@link matchInterpolate} with a point `oldValue`, mapped component-wise. */
+declare function matchInterpolate(newStart: number, newEnd: number, oldStart: number, oldEnd: number, oldValue: number[]): number[];
+/** Build the evaluator of a Bézier curve defined by scalar control values. */
+export declare function bezier(points: number[]): (t: number) => number;
+/** Build the evaluator of a Bézier curve defined by point control values. */
+export declare function bezier(points: number[][]): (t: number) => number[];
+/**
+ * Split a Bézier curve at parameter `t` into two curves of the same degree.
+ *
+ * @returns `2 * N` control points: the first `N` are the curve over `[0, t]`,
+ *          the last `N` are the curve over `[t, 1]`.
+ */
+declare function splitBezier(points: number[][], t: number): number[][];
+/**
+ * Subdivide a Bézier curve into `n_divisions` subcurves of the same degree and
+ * equal parameter spans, split at `t = i / n_divisions`.
+ *
+ * Each subcurve is the portion over `[i / n, (i + 1) / n]`, which is what Manim
+ * CE's memoized subdivision matrices compute for curves of degree up to 3 (the
+ * only degrees manim-web produces). Manim CE's higher-degree fallback uses a
+ * different successive-split schedule; this equal-interval form is the correct
+ * subdivision for every degree.
+ *
+ * @returns `n_divisions * N` control points, the subcurves concatenated in order.
+ */
+declare function subdivideBezier(points: number[][], nDivisions: number): number[][];
+/**
+ * Subdivide each curve in `bezierTuples` until the total reaches
+ * `newNumberOfCurves`, matching Manim CE's `bezier_remap`.
+ *
+ * @param bezierTuples - Curves as `(currentNumberOfCurves, nppc, dim)`.
+ * @param newNumberOfCurves - Target number of curves (>= current).
+ */
+declare function bezierRemap(bezierTuples: number[][][], newNumberOfCurves: number): number[][][];
+/**
+ * Whether the spline is closed: its first and last points are close enough to
+ * be the same, using Manim CE's `rtol = 1e-5`, `atol = 1e-8` over 3 coordinates.
+ */
+declare function isClosed(points: number[][]): boolean;
+/**
+ * Parameters `t` in `[0, 1]` at which the Bézier curve defined by
+ * `controlPoints` passes through `point`. Usually one or zero values; a point
+ * at the seam of a closed loop can yield more. Port of Manim CE's
+ * `proportions_along_bezier_curve_for_point`.
+ *
+ * @throws Error when `point` and the control points have different shapes.
+ */
+declare function proportionsAlongBezierCurveForPoint(point: number[], controlPoints: number[][], roundTo?: number): number[];
+/**
+ * Whether `point` lies on the Bézier curve defined by `controlPoints`
+ * (Manim CE `point_lies_on_bezier`). The point lies on the curve when the
+ * Bézier polynomial has at least one real root in `[0, 1]`.
+ *
+ * @throws Error when `point` and the control points have different shapes.
+ */
+declare function pointLiesOnBezier(point: number[], controlPoints: number[][], roundTo?: number): boolean;
+export { inverseInterpolate, matchInterpolate, splitBezier, subdivideBezier, bezierRemap, isClosed, proportionsAlongBezierCurveForPoint, pointLiesOnBezier, };
+//# sourceMappingURL=bezier.d.ts.map

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

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

package/dist/utils/color.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Color conversion utilities ported from ManimCE's `manim/utils/color/core.py`
+ * (ManimCE 0.22.0).
+ *
+ * manim-web represents a color as a `#rrggbb` (or `#rrggbbaa`) hex string, so
+ * these helpers adapt ManimCE's `ManimColor`-based functional helpers to that
+ * model: inputs that ManimCE types as a color are hex strings here, and
+ * functions that ManimCE returns a `ManimColor` from return a hex string.
+ *
+ * Numeric conventions match ManimCE exactly:
+ * - RGB float arrays use the 0.0..1.0 range (`hexToRgb('#FFFFFF')` -> [1, 1, 1]).
+ * - Integer RGB arrays use the 0..255 range, truncated toward zero
+ *   (`Math.trunc(x * 255)`, matching NumPy's `.astype(int)` / Python `int()`).
+ * - Hex output truncates channels and uppercases (matching `ManimColor.to_hex`).
+ * - HSV conversion mirrors Python's `colorsys` (h, s, v all in 0.0..1.0).
+ *
+ * The `ManimColor`, `HSV` and `RGBA` classes (the object layer on top of these
+ * functions) live in `./ManimColor`.
+ */
+type Rgb = [number, number, number];
+type Rgba = [number, number, number, number];
+type Hsv = [number, number, number];
+export { colorGradient } from '../core/VMobjectColorGradient';
+/**
+ * Convert an `[r, g, b]` float array (0.0..1.0) to a `#RRGGBB` hex string.
+ *
+ * Ports `ManimColor.from_rgb(...).to_hex()`. Channels are truncated, not
+ * rounded, to match ManimCE.
+ */
+export declare function rgbToHex(rgb: Rgb): string;
+/** Convert a color (hex string) to an `[r, g, b]` float array (0.0..1.0). */
+export declare function hexToRgb(hexCode: string): Rgb;
+/** Alias of {@link hexToRgb}; ports ManimCE's `color_to_rgb`. */
+export declare function colorToRgb(color: string): Rgb;
+/**
+ * Convert a color to an `[r, g, b, a]` float array (0.0..1.0).
+ *
+ * Ports `color_to_rgba`: the supplied `alpha` replaces any alpha carried by the
+ * color itself.
+ */
+export declare function colorToRgba(color: string, alpha?: number): Rgba;
+/** Convert a color to an `[r, g, b]` integer array (0..255). Ports `color_to_int_rgb`. */
+export declare function colorToIntRgb(color: string): Rgb;
+/**
+ * Convert a color to an `[r, g, b, a]` integer array (0..255).
+ *
+ * Ports `color_to_int_rgba`: the supplied `alpha` (0.0..1.0) is scaled to 0..255.
+ */
+export declare function colorToIntRgba(color: string, alpha?: number): Rgba;
+/**
+ * Convert an `[r, g, b]` float array (0.0..1.0) to a color (hex string).
+ *
+ * Ports `rgb_to_color`. Unlike ManimCE, the array is always interpreted as
+ * floats in 0.0..1.0 (manim-web's internal color model); ManimCE's int-vs-float
+ * auto-detection is not reproduced.
+ */
+export declare function rgbToColor(rgb: Rgb): string;
+/**
+ * Convert an `[r, g, b, a]` float array to a color (hex string).
+ *
+ * Ports `rgba_to_color`. The alpha is dropped, matching `ManimColor.to_hex`
+ * with its default `with_alpha=False`.
+ */
+export declare function rgbaToColor(rgba: Rgba): string;
+/** Return the linearly inverted color (1 - channel). Ports `invert_color`. */
+export declare function invertColor(color: string): string;
+/**
+ * Interpolate two colors in RGB space and return the result as a hex string.
+ *
+ * Ports `interpolate_color`: `alpha` of 0.0 yields `color1`, 1.0 yields `color2`.
+ */
+export declare function interpolateColor(color1: string, color2: string, alpha: number): string;
+/**
+ * Return the per-channel average of the given colors as a hex string.
+ *
+ * Ports `average_color`. Alpha is ignored; the result is fully opaque.
+ */
+export declare function averageColor(...colors: string[]): string;
+/** Return a random color from the Manim palette. Ports `random_color`. */
+export declare function randomColor(): string;
+/**
+ * Return a random bright color: a random palette color averaged with white.
+ *
+ * Ports `random_bright_color` (`0.5 * (rgb + 1)`).
+ */
+export declare function randomBrightColor(): string;
+/**
+ * Convert an `[h, s, v]` array (0.0..1.0) to an `[r, g, b]` array (0.0..1.0).
+ *
+ * Faithful port of Python's `colorsys.hsv_to_rgb`.
+ */
+export declare function hsvToRgb(hsv: Hsv): Rgb;
+/**
+ * Convert an `[r, g, b]` array (0.0..1.0) to an `[h, s, v]` array (0.0..1.0).
+ *
+ * Faithful port of Python's `colorsys.rgb_to_hsv`.
+ */
+export declare function rgbToHsv(rgb: Rgb): Hsv;
+//# sourceMappingURL=color.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/utils/color.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,KAAK,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACpC,KAAK,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAC7C,KAAK,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAKpC,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AA+C9D;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAEzC;AAED,6EAA6E;AAC7E,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAG7C;AAED,iEAAiE;AACjE,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAE7C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAM,GAAG,IAAI,CAG5D;AAED,0FAA0F;AAC1F,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAGhD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAM,GAAG,IAAI,CAG/D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,MAAM,CAE3C;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAE9C;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjD;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAQtF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAaxD;AAMD,0EAA0E;AAC1E,wBAAgB,WAAW,IAAI,MAAM,CAGpC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAG1C;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAwBtC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,CAuBtC"}

package/dist/utils/debug.d.ts

@@ -0,0 +1,36 @@
+import { Mobject } from '../core/Mobject';
+import { VGroup } from '../core/VGroup';
+/**
+ * Return every family member (self plus all descendants) of each mobject in
+ * `mobjectList`, flattened into a single list. Mirrors ManimCE
+ * `extract_mobject_family_members`.
+ *
+ * @param onlyThoseWithPoints - keep only members that own geometry (a
+ *   `VMobject` with its own points), matching ManimCE `only_those_with_points`.
+ */
+export declare function extractMobjectFamilyMembers(mobjectList: Mobject[], onlyThoseWithPoints?: boolean): Mobject[];
+/**
+ * Remove everything in `toRemove` from `mobjectList`, but when a removed item
+ * is a family member of an item in `mobjectList`, add that item's other family
+ * members back in. Mirrors ManimCE
+ * `restructure_list_to_exclude_certain_family_members`.
+ */
+export declare function restructureListToExcludeCertainFamilyMembers(mobjectList: Mobject[], toRemove: Mobject[]): Mobject[];
+/** Options for {@link indexLabels}. */
+export interface IndexLabelsOptions {
+    /** Height of each label in scene units. Default: 0.15 (matches ManimCE). */
+    labelHeight?: number;
+}
+/**
+ * Return a `VGroup` of `Integer` labels showing the index of each submobject of
+ * `mobject`. Useful for inspecting the parts of a complicated mobject. Mirrors
+ * ManimCE `index_labels`.
+ */
+export declare function indexLabels(mobject: Mobject, options?: IndexLabelsOptions): VGroup;
+/**
+ * Build a tree view of `mobject` and its descendants, one line per family
+ * member indented by depth. Mirrors ManimCE `print_family`, but returns the
+ * string and logs it through the repo logger (never `console`).
+ */
+export declare function printFamily(mobject: Mobject, nTabs?: number): string;
+//# sourceMappingURL=debug.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../src/utils/debug.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE1C,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAIxC;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,OAAO,EAAE,EACtB,mBAAmB,GAAE,OAAe,GACnC,OAAO,EAAE,CASX;AAED;;;;;GAKG;AACH,wBAAgB,4CAA4C,CAC1D,WAAW,EAAE,OAAO,EAAE,EACtB,QAAQ,EAAE,OAAO,EAAE,GAClB,OAAO,EAAE,CAoBX;AAED,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE,kBAAuB,GAAG,MAAM,CAUtF;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,GAAE,MAAU,GAAG,MAAM,CAYvE"}

package/dist/utils/iterables.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Operations on iterables, ported from ManimCE `manim/utils/iterables.py`.
+ *
+ * Some helpers are thin wrappers over native `Array` operations. They are
+ * ported anyway to keep name-parity with ManimCE's public API:
+ *  - `concatenateLists`       (CE `concatenate_lists`)
+ *  - `listify`                (CE `listify`)
+ *  - `removeNones`            (CE `remove_nones`)
+ *  - `allElementsAreInstances` (CE `all_elements_are_instances`)
+ *  - `makeEvenByCycling`      (CE `make_even_by_cycling`)
+ *
+ * `powerset` is not part of ManimCE 0.22.0 `iterables.py`; it is added here as
+ * a genuinely useful combinatorial helper (present in older manim variants).
+ *
+ * Public names are camelCased to match the rest of manim-web (ManimCE's
+ * snake_case originals are noted in each "Mirrors ManimCE" reference).
+ */
+/** A key function that maps an element to a value used for equality checks. */
+type KeyFn<T> = (item: T) => unknown;
+/**
+ * Return the sequence split cyclically into `n`-length tuples.
+ *
+ * Mirrors ManimCE `adjacent_n_tuples`.
+ *
+ * @example
+ * adjacentNTuples([1, 2, 3, 4], 2); // [[1,2],[2,3],[3,4],[4,1]]
+ * adjacentNTuples([1, 2, 3, 4], 3); // [[1,2,3],[2,3,4],[3,4,1],[4,1,2]]
+ */
+export declare function adjacentNTuples<T>(objects: readonly T[], n: number): T[][];
+/**
+ * Alias for `adjacentNTuples(objects, 2)`. Mirrors ManimCE `adjacent_pairs`.
+ *
+ * @example
+ * adjacentPairs([1, 2, 3]); // [[1,2],[2,3],[3,1]]
+ */
+export declare function adjacentPairs<T>(objects: readonly T[]): T[][];
+/**
+ * Remove duplicate elements while preserving order, keeping the LAST
+ * occurrence of each element. Used instead of `[...new Set(l)]` when the
+ * last-occurrence ordering matters (mirrors ManimCE `remove_list_redundancies`).
+ *
+ * @example
+ * removeListRedundancies([1, 2, 1, 3, 2]); // [1, 3, 2]
+ */
+export declare function removeListRedundancies<T>(lst: readonly T[]): T[];
+/**
+ * Return the elements of `l1` that are not present in `l2`.
+ *
+ * An optional `key` function determines which elements count as equal.
+ * Mirrors ManimCE `list_difference_update`.
+ *
+ * @example
+ * listDifferenceUpdate([1, 2, 3, 4, 1], [2, 4]); // [1, 3, 1]
+ */
+export declare function listDifferenceUpdate<T, U>(l1: readonly T[], l2: readonly U[], key?: KeyFn<T | U>): T[];
+/**
+ * Return a new list of the elements of `l1` not present in `l2`, followed by
+ * every element of `l2`. Order is preserved. Mirrors ManimCE `list_update`.
+ *
+ * @example
+ * listUpdate([1, 2, 3], [2, 4, 4]); // [1, 3, 2, 4, 4]
+ */
+export declare function listUpdate<T, U>(l1: readonly T[], l2: readonly U[], key?: KeyFn<T | U>): (T | U)[];
+/**
+ * Convert a value to an array intelligently. A string becomes a single-element
+ * array; any other iterable is spread; anything else is wrapped.
+ *
+ * ManimCE `tuplify` returns a tuple; JavaScript has no distinct tuple type, so
+ * this returns an array.
+ *
+ * @example
+ * tuplify("str");  // ["str"]
+ * tuplify([1, 2]); // [1, 2]
+ * tuplify(5);      // [5]
+ */
+export declare function tuplify<T>(obj: T | readonly T[] | string): (T | string)[];
+/**
+ * Extend the shorter of two iterables with duplicate values until both have
+ * the same length (favours earlier elements). Mirrors ManimCE `make_even`.
+ *
+ * @example
+ * makeEven([1, 2], [3, 4, 5, 6]); // [[1,1,2,2], [3,4,5,6]]
+ */
+export declare function makeEven<T, U>(iterable1: readonly T[], iterable2: readonly U[]): [T[], U[]];
+/**
+ * Resample a numeric array up to `length` by index duplication (favours earlier
+ * elements). Mirrors ManimCE `stretch_array_to_length`.
+ *
+ * @throws if `length` is shorter than the input (matches ManimCE, which raises).
+ * @example
+ * stretchArrayToLength([1, 2], 4); // [1, 1, 2, 2]
+ */
+export declare function stretchArrayToLength<T>(array: readonly T[], length: number): T[];
+/**
+ * Yield every unique element from the given iterables, in order of first
+ * appearance. Mirrors ManimCE `uniq_chain` (a lazy generator).
+ *
+ * @example
+ * [...uniqChain([1, 2], [2, 3], [1, 4, 4])]; // [1, 2, 3, 4]
+ */
+export declare function uniqChain<T>(...args: Iterable<T>[]): Generator<T, void, undefined>;
+/**
+ * Return every subset of `items` (the power set), as an array of arrays.
+ * The result has `2 ** items.length` entries.
+ *
+ * Not in ManimCE 0.22.0; added as a useful combinatorial helper.
+ *
+ * @example
+ * powerset([1, 2]); // [[], [1], [2], [1, 2]]
+ */
+export declare function powerset<T>(items: readonly T[]): T[][];
+/**
+ * Return `true` when every element of `iterable` is an instance of `Class`.
+ * Mirrors ManimCE `all_elements_are_instances`.
+ */
+export declare function allElementsAreInstances<T>(iterable: Iterable<unknown>, ctor: abstract new (...args: never[]) => T): boolean;
+/**
+ * Combine the given iterables into one flat list (one level deep).
+ * Mirrors ManimCE `concatenate_lists`.
+ *
+ * @example
+ * concatenateLists([1, 2], [3, 4], [5]); // [1, 2, 3, 4, 5]
+ */
+export declare function concatenateLists<T>(...listOfLists: Iterable<T>[]): T[];
+/**
+ * Convert a value to a list intelligently. A string becomes a single-element
+ * array; any other iterable is spread; anything else is wrapped.
+ *
+ * Mirrors ManimCE `listify` (equivalent to `tuplify`, kept for name-parity).
+ *
+ * @example
+ * listify("str");  // ["str"]
+ * listify([1, 2]); // [1, 2]
+ * listify(5);      // [5]
+ */
+export declare function listify<T>(obj: T | readonly T[] | string): (T | string)[];
+/**
+ * Return the elements of `sequence` that are truthy (drops values where
+ * `Boolean(x)` is `false`). Mirrors ManimCE `remove_nones`.
+ *
+ * @example
+ * removeNones(["m", "", "l", 0, 42, false, true]); // ["m", "l", 42, true]
+ */
+export declare function removeNones<T>(sequence: Iterable<T>): NonNullable<T>[];
+/**
+ * Extend the shorter of two iterables by cycling its values until both have
+ * the same length. Mirrors ManimCE `make_even_by_cycling`.
+ *
+ * @example
+ * makeEvenByCycling([1, 2], [3, 4, 5, 6]); // [[1,2,1,2], [3,4,5,6]]
+ */
+export declare function makeEvenByCycling<T, U>(iterable1: readonly T[], iterable2: readonly U[]): [T[], U[]];
+/**
+ * Determine a deterministic numeric hash, even for mutable objects.
+ *
+ * ManimCE `hash_obj` relies on Python's `hash`; JavaScript has none, so this
+ * builds a canonical string for the value (object keys sorted, sets sorted)
+ * and folds it with a 32-bit FNV-1a hash.
+ */
+export declare function hashObj(obj: unknown): number;
+export {};
+//# sourceMappingURL=iterables.d.ts.map

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

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

package/dist/utils/paths.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Port of ManimCE `manim/utils/paths.py` (0.22.0) public API.
+ *
+ * A path function maps a set of start points and a set of end points, together
+ * with an interpolation parameter `alpha` in `[0, 1]`, to an intermediate set
+ * of points. These drive the `pathArc` behavior of Transform animations.
+ *
+ * Points are `number[][]` (each point `[x, y, z]`). The two input arrays must
+ * have equal length. Function declarations use the repository's camelCase
+ * convention; the public ManimCE names (snake_case) are exposed through the
+ * alias export block at the end of the file.
+ */
+/** A transformation path function (ManimCE `PathFuncType`). */
+export type PathFunc = (startPoints: number[][], endPoints: number[][], alpha: number) => number[][];
+/**
+ * Simplest path: each point moves in a straight line toward its destination
+ * (ManimCE `straight_path`).
+ */
+declare function straightPath(): PathFunc;
+/**
+ * Each point moves roughly along a circle with its own center
+ * (ManimCE `path_along_circles`).
+ */
+declare function pathAlongCircles(arcAngle: number, circlesCenters: number[][], axis?: number[]): PathFunc;
+/**
+ * Each point moves along a circular arc of angle `arcAngle` about `axis`
+ * (ManimCE `path_along_arc`).
+ */
+declare function pathAlongArc(arcAngle: number, axis?: number[]): PathFunc;
+/** Each point moves clockwise around a half circle (ManimCE `clockwise_path`). */
+declare function clockwisePath(): PathFunc;
+/**
+ * Each point moves counterclockwise around a half circle
+ * (ManimCE `counterclockwise_path`).
+ */
+declare function counterclockwisePath(): PathFunc;
+export { straightPath, pathAlongArc, pathAlongCircles, clockwisePath, counterclockwisePath };
+//# sourceMappingURL=paths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/utils/paths.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAKH,+DAA+D;AAC/D,MAAM,MAAM,QAAQ,GAAG,CACrB,WAAW,EAAE,MAAM,EAAE,EAAE,EACvB,SAAS,EAAE,MAAM,EAAE,EAAE,EACrB,KAAK,EAAE,MAAM,KACV,MAAM,EAAE,EAAE,CAAC;AAahB;;;GAGG;AACH,iBAAS,YAAY,IAAI,QAAQ,CAEhC;AAED;;;GAGG;AACH,iBAAS,gBAAgB,CACvB,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,MAAM,EAAE,EAAE,EAC1B,IAAI,GAAE,MAAM,EAAQ,GACnB,QAAQ,CAeV;AAED;;;GAGG;AACH,iBAAS,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAQ,GAAG,QAAQ,CAsBtE;AAED,kFAAkF;AAClF,iBAAS,aAAa,IAAI,QAAQ,CAEjC;AAED;;;GAGG;AACH,iBAAS,oBAAoB,IAAI,QAAQ,CAExC;AAID,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,oBAAoB,EAAE,CAAC"}

package/dist/utils/simpleFunctions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Port of ManimCE `manim/utils/simple_functions.py` (0.22.0) public API.
+ */
+/**
+ * Numerical binary search for the input to `fn`, between `lowerBound` and
+ * `upperBound`, whose output is `target` to within `tolerance`
+ * (ManimCE `binary_search`). Returns `undefined` if no such input exists in
+ * the bounds.
+ */
+declare function binarySearch(fn: (x: number) => number, target: number, lowerBound: number, upperBound: number, tolerance?: number): number | undefined;
+/**
+ * The binomial coefficient "n choose k" (ManimCE `choose`). Returns 0 when
+ * `k < 0` or `k > n`.
+ */
+export declare function choose(n: number, k: number): number;
+/**
+ * Clip `a` to the interval `[minA, maxA]` (ManimCE `clip`). Returns `a` when it
+ * is already inside the interval, otherwise the nearer bound.
+ */
+export declare function clip(a: number, minA: number, maxA: number): number;
+/**
+ * The logistic function `1 / (1 + e^-x)` (ManimCE `sigmoid`).
+ */
+export declare function sigmoid(x: number): number;
+export { binarySearch };
+//# sourceMappingURL=simpleFunctions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"simpleFunctions.d.ts","sourceRoot":"","sources":["../../src/utils/simpleFunctions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,iBAAS,YAAY,CACnB,EAAE,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACzB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,SAAS,SAAO,GACf,MAAM,GAAG,SAAS,CAqBpB;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CASnD;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIlE;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzC;AAID,OAAO,EAAE,YAAY,EAAE,CAAC"}