manim-web 0.26.0 → 0.28.0

package/dist/mobjects/ml/mlStyles.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Shared style options and defaults for the neural-network diagram toolkit.
+ *
+ * These interfaces describe how nodes (circles, feature maps, grids) and the
+ * connection lines between layers look. Every field is optional; the layer and
+ * network classes fill the gaps from the DEFAULT_* records below.
+ */
+/** Visual style for a single node (a circle, a feature-map square, a grid). */
+export interface NodeStyleOptions {
+    /** Stroke color as a CSS color string. */
+    color?: string;
+    /** Fill color as a CSS color string. Defaults to `color`. */
+    fillColor?: string;
+    /** Fill opacity from 0 to 1. */
+    fillOpacity?: number;
+    /** Stroke width in pixels. */
+    strokeWidth?: number;
+}
+/** Visual style for a connection line (an edge) between two nodes. */
+export interface ConnectionStyleOptions {
+    /** Stroke color as a CSS color string. */
+    color?: string;
+    /** Stroke width in pixels. */
+    strokeWidth?: number;
+    /** Resting stroke opacity from 0 to 1, before a forward pass activates it. */
+    opacity?: number;
+}
+/** Fully resolved node style (no optional fields). */
+export type ResolvedNodeStyle = Required<NodeStyleOptions>;
+/** Fully resolved edge style (no optional fields). */
+export type ResolvedEdgeStyle = Required<ConnectionStyleOptions>;
+/** Default node style: a blue outline with a faint blue fill. */
+export declare const DEFAULT_NODE_STYLE: ResolvedNodeStyle;
+/** Default edge style: a thin grey line at a low resting opacity. */
+export declare const DEFAULT_EDGE_STYLE: ResolvedEdgeStyle;
+/** Default color a connection takes while a signal flows through it. */
+export declare const DEFAULT_ACTIVATION_COLOR = "#FFFFFF";
+/**
+ * Merge a partial node style over a resolved base style.
+ * @param base - The resolved style to start from.
+ * @param override - The partial style whose set fields win.
+ * @returns A new resolved node style.
+ */
+export declare function resolveNodeStyle(base: ResolvedNodeStyle, override?: NodeStyleOptions): ResolvedNodeStyle;
+/**
+ * Merge a partial edge style over a resolved base style.
+ * @param base - The resolved style to start from.
+ * @param override - The partial style whose set fields win.
+ * @returns A new resolved edge style.
+ */
+export declare function resolveEdgeStyle(base: ResolvedEdgeStyle, override?: ConnectionStyleOptions): ResolvedEdgeStyle;
+//# sourceMappingURL=mlStyles.d.ts.map

package/dist/mobjects/ml/mlStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mlStyles.d.ts","sourceRoot":"","sources":["../../../src/mobjects/ml/mlStyles.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,+EAA+E;AAC/E,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gCAAgC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8BAA8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,sEAAsE;AACtE,MAAM,WAAW,sBAAsB;IACrC,0CAA0C;IAC1C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,8BAA8B;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,sDAAsD;AACtD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC;AAE3D,sDAAsD;AACtD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC,sBAAsB,CAAC,CAAC;AAEjE,iEAAiE;AACjE,eAAO,MAAM,kBAAkB,EAAE,iBAKhC,CAAC;AAEF,qEAAqE;AACrE,eAAO,MAAM,kBAAkB,EAAE,iBAIhC,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,YAAQ,CAAC;AAE9C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,iBAAiB,EACvB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,iBAAiB,CAEnB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,iBAAiB,EACvB,QAAQ,CAAC,EAAE,sBAAsB,GAChC,iBAAiB,CAEnB"}

package/dist/mobjects/physics/PhysicsWorld.d.ts

@@ -0,0 +1,83 @@
+import { Group } from '../../core/Group';
+import { Body, BodyOptions } from './bodies';
+import { Constraint } from './constraints';
+import { Bounds } from './collisions';
+import { Vec2 } from './vec2';
+/** Options for a {@link PhysicsWorld}. */
+export interface PhysicsWorldOptions {
+    /** Global acceleration `[x, y]` in units/sec^2. Default: `[0, -9.8]`. */
+    gravity?: Vec2;
+    /** World bounds for wall collisions. Default: open on every side. */
+    bounds?: Bounds;
+    /** Constraint position-solver iterations per step. Default: 4. */
+    iterations?: number;
+    /** Seed for the deterministic PRNG. Default: 0. */
+    seed?: number;
+}
+/**
+ * A 2D rigid-body physics world. See the file overview for the model and an
+ * example.
+ */
+export declare class PhysicsWorld extends Group {
+    private readonly _bodies;
+    private readonly _constraints;
+    private _gravity;
+    private _bounds;
+    private readonly _iterations;
+    private _seed;
+    private _rng;
+    constructor(options?: PhysicsWorldOptions);
+    /** The seed that drives the deterministic PRNG. */
+    get seed(): number;
+    /** The current global gravity `[x, y]`. */
+    getGravity(): Vec2;
+    /** Set the global gravity `[x, y]`. */
+    setGravity(gravity: Vec2): this;
+    /** Set the world bounds for wall collisions. */
+    setBounds(bounds: Bounds): this;
+    /** The next deterministic random float in `[0, 1)`. */
+    random(): number;
+    /**
+     * Add a body to the world. Accepts a {@link Body} or plain options. If the
+     * body carries a mobject, it is added as a child so the scene renders it.
+     *
+     * @returns The body that was added, for building constraints.
+     */
+    addBody(bodyOrOptions: Body | BodyOptions): Body;
+    /** Add a constraint to the world. @returns The constraint, for chaining. */
+    addConstraint<T extends Constraint>(constraint: T): T;
+    /** All bodies, in insertion order. The array is a copy; the bodies are live. */
+    getBodies(): Body[];
+    /** The body at `index`, or undefined. */
+    getBody(index: number): Body | undefined;
+    /** All constraints, in insertion order. The array is a copy. */
+    getConstraints(): Constraint[];
+    /**
+     * Advance the simulation by `dt` seconds with semi-implicit Euler:
+     * accumulate forces, integrate velocity then position, solve constraint
+     * positions, resolve collisions, and move the attached mobjects.
+     *
+     * @param dt - Elapsed time in seconds. Values <= 0 are ignored.
+     */
+    step(dt: number): this;
+    /** Add gravity and spring forces to every body for this step. */
+    private _accumulateForces;
+    /** Semi-implicit Euler: velocity from force, then position from velocity. */
+    private _integrate;
+    /** Run the position solver for each constraint, several iterations. */
+    private _solveConstraints;
+    /** Resolve every body against the bounds and every circle pair. */
+    private _resolveCollisions;
+    /** Move each attached mobject to its body position, keeping its z. */
+    private _syncMobjects;
+    /**
+     * Restore every body to its initial state and restart the PRNG from the
+     * seed. After a reset, the same sequence of {@link step} calls reproduces
+     * the same evolution.
+     */
+    reset(): this;
+    copy(): PhysicsWorld;
+    /** Build a new body with the same state and a copied mobject. */
+    private _cloneBody;
+}
+//# sourceMappingURL=PhysicsWorld.d.ts.map

package/dist/mobjects/physics/PhysicsWorld.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsWorld.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/PhysicsWorld.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAsC,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAiB9B,0CAA0C;AAC1C,MAAM,WAAW,mBAAmB;IAClC,yEAAyE;IACzE,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAO;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,IAAI,CAAe;gBAEf,OAAO,GAAE,mBAAwB;IAa7C,mDAAmD;IACnD,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,2CAA2C;IAC3C,UAAU,IAAI,IAAI;IAIlB,uCAAuC;IACvC,UAAU,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI;IAK/B,gDAAgD;IAChD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK/B,uDAAuD;IACvD,MAAM,IAAI,MAAM;IAIhB;;;;;OAKG;IACH,OAAO,CAAC,aAAa,EAAE,IAAI,GAAG,WAAW,GAAG,IAAI;IAOhD,4EAA4E;IAC5E,aAAa,CAAC,CAAC,SAAS,UAAU,EAAE,UAAU,EAAE,CAAC,GAAG,CAAC;IAKrD,gFAAgF;IAChF,SAAS,IAAI,IAAI,EAAE;IAInB,yCAAyC;IACzC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAIxC,gEAAgE;IAChE,cAAc,IAAI,UAAU,EAAE;IAI9B;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAUtB,iEAAiE;IACjE,OAAO,CAAC,iBAAiB;IAWzB,6EAA6E;IAC7E,OAAO,CAAC,UAAU;IAgBlB,uEAAuE;IACvE,OAAO,CAAC,iBAAiB;IAQzB,mEAAmE;IACnE,OAAO,CAAC,kBAAkB;IAW1B,sEAAsE;IACtE,OAAO,CAAC,aAAa;IAQrB;;;;OAIG;IACH,KAAK,IAAI,IAAI;IAOJ,IAAI,IAAI,YAAY;IAmB7B,iEAAiE;IACjE,OAAO,CAAC,UAAU;CAoBnB"}

package/dist/mobjects/physics/bodies.d.ts

@@ -0,0 +1,91 @@
+import { Mobject } from '../../core/Mobject';
+import { Vec2 } from './vec2';
+/** A circle shape with a radius, centered on the body position. */
+export interface CircleShape {
+    kind: 'circle';
+    /** Radius in scene units. */
+    radius: number;
+}
+/** A convex polygon shape, as vertices relative to the body position. */
+export interface PolygonShape {
+    kind: 'polygon';
+    /** Vertices in local space, measured from the body position. */
+    vertices: Vec2[];
+}
+/** The collision shape of a {@link Body}. */
+export type BodyShape = CircleShape | PolygonShape;
+/** Options for {@link Body}. */
+export interface BodyOptions {
+    /** Start position `[x, y]`. Default: `[0, 0]`. */
+    position?: Vec2;
+    /** Start velocity `[x, y]` in units/sec. Default: `[0, 0]`. */
+    velocity?: Vec2;
+    /** Mass in arbitrary units. Ignored when `isStatic` is true. Default: 1. */
+    mass?: number;
+    /** Bounciness from 0 (no bounce) to 1 (elastic). Default: 0.5. */
+    restitution?: number;
+    /** A static body never moves and has infinite mass. Default: false. */
+    isStatic?: boolean;
+    /** Collision shape. Default: a circle of radius 0.5. */
+    shape?: BodyShape;
+    /**
+     * Scale on the world gravity for this body, so a body can ignore gravity
+     * (0) or feel more or less than the rest. Default: 1.
+     */
+    gravityScale?: number;
+    /** A mobject to move to the body position on each step. Default: none. */
+    mobject?: Mobject;
+}
+/**
+ * A rigid body in the physics world.
+ *
+ * The body is the single source of truth for its motion. An attached mobject
+ * follows the body, never the other way around.
+ *
+ * @example
+ * ```typescript
+ * const ball = new Body({
+ *   position: [0, 3],
+ *   shape: { kind: 'circle', radius: 0.2 },
+ *   restitution: 0.8,
+ * });
+ * ```
+ */
+export declare class Body {
+    /** Current position `[x, y]`. */
+    position: Vec2;
+    /** Current velocity `[x, y]` in units/sec. */
+    velocity: Vec2;
+    /** Force accumulator for the current step, cleared after integration. */
+    force: Vec2;
+    /** Mass in arbitrary units. A static body reports `Infinity`. */
+    readonly mass: number;
+    /** Inverse mass. Zero for a static body, which disables all motion. */
+    readonly invMass: number;
+    /** Bounciness from 0 to 1. */
+    readonly restitution: number;
+    /** Whether the body is static (never moves). */
+    readonly isStatic: boolean;
+    /** The collision shape. */
+    readonly shape: BodyShape;
+    /** Per-body scale on the world gravity. */
+    readonly gravityScale: number;
+    /** The attached mobject, or null. */
+    mobject: Mobject | null;
+    /** The z of the attached mobject at attach time, kept on every move. */
+    readonly z: number;
+    private readonly _initial;
+    constructor(options?: BodyOptions);
+    /** The circle radius, or 0 for a polygon body. */
+    get radius(): number;
+    /** Add a force `[x, y]` to the accumulator for the current step. */
+    applyForce(f: Vec2): this;
+    /**
+     * The axis-aligned bounds as `[minX, minY, maxX, maxY]` in world space.
+     * A circle uses its radius; a polygon uses its vertex extent.
+     */
+    aabb(): [number, number, number, number];
+    /** Restore the position and velocity recorded when the body was created. */
+    reset(): this;
+}
+//# sourceMappingURL=bodies.d.ts.map

package/dist/mobjects/physics/bodies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bodies.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/bodies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAa,MAAM,QAAQ,CAAC;AAEzC,mEAAmE;AACnE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,yEAAyE;AACzE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,gEAAgE;IAChE,QAAQ,EAAE,IAAI,EAAE,CAAC;CAClB;AAED,6CAA6C;AAC7C,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,YAAY,CAAC;AAEnD,gCAAgC;AAChC,MAAM,WAAW,WAAW;IAC1B,kDAAkD;IAClD,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,wDAAwD;IACxD,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAQD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,IAAI;IACf,iCAAiC;IACjC,QAAQ,EAAE,IAAI,CAAC;IACf,8CAA8C;IAC9C,QAAQ,EAAE,IAAI,CAAC;IACf,yEAAyE;IACzE,KAAK,EAAE,IAAI,CAAU;IACrB,iEAAiE;IACjE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,8BAA8B;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,2BAA2B;IAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,2CAA2C;IAC3C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,qCAAqC;IACrC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,wEAAwE;IACxE,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IAEnB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;gBAE5B,OAAO,GAAE,WAAgB;IA8BrC,kDAAkD;IAClD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,oEAAoE;IACpE,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAMzB;;;OAGG;IACH,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC;IAyBxC,4EAA4E;IAC5E,KAAK,IAAI,IAAI;CAMd"}

package/dist/mobjects/physics/builders.d.ts

@@ -0,0 +1,59 @@
+import { Mobject } from '../../core/Mobject';
+import { PhysicsWorld } from './PhysicsWorld';
+import { Vec2 } from './vec2';
+/** Options for {@link pendulum}. */
+export interface PendulumOptions {
+    /** Fixed pivot point `[x, y]`. Default: `[0, 2]`. */
+    pivot?: Vec2;
+    /** Rod length from the pivot to the bob. Default: 2. */
+    length?: number;
+    /** Bob mass. Default: 1. */
+    mass?: number;
+    /** Start angle in radians from straight down. Default: `Math.PI / 4`. */
+    angle?: number;
+    /** Bob radius. Default: 0.2. */
+    radius?: number;
+    /** Gravity `[x, y]`. Default: `[0, -9.8]`. */
+    gravity?: Vec2;
+    /** Mobject to attach to the bob. Default: none. */
+    bob?: Mobject;
+}
+/**
+ * Build a pendulum: a bob body pinned to a fixed pivot by a rigid distance
+ * constraint. The bob starts at `angle` from straight down and swings under
+ * gravity while the constraint holds it a near-constant `length` from the
+ * pivot.
+ */
+export declare function pendulum(options?: PendulumOptions): PhysicsWorld;
+/** Options for {@link springChain}. */
+export interface SpringChainOptions {
+    /** First link position `[x, y]`. Default: `[0, 3]`. */
+    start?: Vec2;
+    /** Number of bodies in the chain. Default: 4. */
+    count?: number;
+    /** Rest length between neighboring links. Default: 1. */
+    spacing?: number;
+    /** Mass of each body. Default: 1. */
+    mass?: number;
+    /** Spring stiffness. Default: 40. */
+    stiffness?: number;
+    /** Spring damping. Default: 2. */
+    damping?: number;
+    /** Gravity `[x, y]`. Default: `[0, -9.8]`. */
+    gravity?: Vec2;
+    /** Pin the first link to a fixed anchor at `start`. Default: true. */
+    anchored?: boolean;
+    /** Seeded horizontal jitter on the start positions. Default: 0. */
+    jitter?: number;
+    /** Seed for the jitter PRNG. Default: 0. */
+    seed?: number;
+    /** Mobjects to attach to the links, in order. Default: none. */
+    mobjects?: Mobject[];
+}
+/**
+ * Build a vertical chain of bodies linked by springs, hanging downward from
+ * `start`. With `anchored`, the top link is pinned to a fixed point, so the
+ * chain hangs and sways; without it, the whole chain is free.
+ */
+export declare function springChain(options?: SpringChainOptions): PhysicsWorld;
+//# sourceMappingURL=builders.d.ts.map

package/dist/mobjects/physics/builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builders.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/builders.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,qDAAqD;IACrD,KAAK,CAAC,EAAE,IAAI,CAAC;IACb,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4BAA4B;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gCAAgC;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,mDAAmD;IACnD,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,YAAY,CAqBpE;AAED,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,KAAK,CAAC,EAAE,IAAI,CAAC;IACb,iDAAiD;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kCAAkC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,sEAAsE;IACtE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mEAAmE;IACnE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACtB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,YAAY,CAyC1E"}

package/dist/mobjects/physics/collisions.d.ts

@@ -0,0 +1,29 @@
+import { Body } from './bodies';
+/**
+ * The rectangular bounds of the world. Any side left `undefined` is open, so
+ * a body passes through it freely.
+ */
+export interface Bounds {
+    /** Left wall x, or undefined for an open left side. */
+    minX?: number;
+    /** Floor y, or undefined for an open bottom. */
+    minY?: number;
+    /** Right wall x, or undefined for an open right side. */
+    maxX?: number;
+    /** Ceiling y, or undefined for an open top. */
+    maxY?: number;
+}
+/**
+ * Push `body` back inside `bounds` and reflect the velocity that drove it out,
+ * scaled by the body restitution. A static body is never moved.
+ */
+export declare function resolveBounds(body: Body, bounds: Bounds): void;
+/**
+ * Resolve a collision between two circle bodies. Does nothing when either body
+ * is not a circle, when they do not overlap, or when both are static.
+ *
+ * The step separates the overlap by inverse mass, then applies an impulse
+ * along the contact normal with restitution `min(a, b)`.
+ */
+export declare function resolveCircleCircle(a: Body, b: Body): void;
+//# sourceMappingURL=collisions.d.ts.map

package/dist/mobjects/physics/collisions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collisions.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/collisions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEhC;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,uDAAuD;IACvD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAqB9D;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,IAAI,CAgC1D"}

package/dist/mobjects/physics/constraints.d.ts

@@ -0,0 +1,67 @@
+import { Body } from './bodies';
+import { Vec2 } from './vec2';
+/** A constraint endpoint: a dynamic body or a fixed world point. */
+export type Anchor = Body | Vec2;
+/**
+ * A constraint on the physics world.
+ *
+ * The world runs two phases each step. It calls {@link accumulateForces} in
+ * the force phase (before integration) and {@link solvePositions} in the
+ * position phase (after integration). A constraint implements only the phase
+ * it needs.
+ */
+export interface Constraint {
+    /** Add forces to the linked bodies before integration. Optional. */
+    accumulateForces?(): void;
+    /** Correct the linked body positions after integration. Optional. */
+    solvePositions?(): void;
+    /** Return a copy of this constraint with bodies remapped through `map`. */
+    clone(map: Map<Body, Body>): Constraint;
+}
+/** Options for a {@link DistanceConstraint}. */
+export interface DistanceConstraintOptions {
+    /** How strongly the constraint corrects, from 0 to 1. Default: 1. */
+    stiffness?: number;
+}
+/**
+ * A rigid distance constraint. It keeps endpoint `a` and endpoint `b` a fixed
+ * `length` apart by correcting positions after integration. The correction
+ * splits between the endpoints by inverse mass, so a body pinned to a fixed
+ * point moves alone.
+ */
+export declare class DistanceConstraint implements Constraint {
+    private readonly _a;
+    private readonly _b;
+    private readonly _length;
+    private readonly _stiffness;
+    constructor(a: Anchor, b: Anchor, length: number, options?: DistanceConstraintOptions);
+    /** The target distance between the endpoints. */
+    get length(): number;
+    solvePositions(): void;
+    clone(map: Map<Body, Body>): DistanceConstraint;
+}
+/** Options for a {@link SpringConstraint}. */
+export interface SpringConstraintOptions {
+    /** Spring stiffness (Hooke's constant). Default: 10. */
+    stiffness?: number;
+    /** Damping on the relative velocity along the spring. Default: 0. */
+    damping?: number;
+}
+/**
+ * A spring between two endpoints. It applies a Hooke's-law force toward the
+ * rest length, plus optional damping on the closing speed, during the force
+ * phase. The endpoints oscillate around the rest length.
+ */
+export declare class SpringConstraint implements Constraint {
+    private readonly _a;
+    private readonly _b;
+    private readonly _restLength;
+    private readonly _stiffness;
+    private readonly _damping;
+    constructor(a: Anchor, b: Anchor, restLength: number, options?: SpringConstraintOptions);
+    /** The rest length the spring pulls toward. */
+    get restLength(): number;
+    accumulateForces(): void;
+    clone(map: Map<Body, Body>): SpringConstraint;
+}
+//# sourceMappingURL=constraints.d.ts.map

package/dist/mobjects/physics/constraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraints.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/constraints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAChC,OAAO,EAAE,IAAI,EAAyB,MAAM,QAAQ,CAAC;AAErD,oEAAoE;AACpE,MAAM,MAAM,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC;AAEjC;;;;;;;GAOG;AACH,MAAM,WAAW,UAAU;IACzB,oEAAoE;IACpE,gBAAgB,CAAC,IAAI,IAAI,CAAC;IAC1B,qEAAqE;IACrE,cAAc,CAAC,IAAI,IAAI,CAAC;IACxB,2EAA2E;IAC3E,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,UAAU,CAAC;CACzC;AAyBD,gDAAgD;AAChD,MAAM,WAAW,yBAAyB;IACxC,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,UAAU;IACnD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;gBAExB,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,yBAA8B;IAOzF,iDAAiD;IACjD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,cAAc,IAAI,IAAI;IA6BtB,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,kBAAkB;CAUhD;AAED,8CAA8C;AAC9C,MAAM,WAAW,uBAAuB;IACtC,wDAAwD;IACxD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qEAAqE;IACrE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,UAAU;IACjD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,GAAE,uBAA4B;IAQ3F,+CAA+C;IAC/C,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED,gBAAgB,IAAI,IAAI;IAyBxB,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,gBAAgB;CAW9C"}

package/dist/mobjects/physics/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 2D rigid-body physics: a compact, self-contained solver for gravity,
+ * collisions, springs and pendulums. Bodies attach to repo mobjects (Circle,
+ * Dot, Polygon) and move under the simulation, driven by an updater like
+ * {@link ParticleSystem}. The simulation is deterministic from a seed.
+ */
+export { PhysicsWorld, type PhysicsWorldOptions } from './PhysicsWorld';
+export { Body, type BodyOptions, type BodyShape, type CircleShape, type PolygonShape, } from './bodies';
+export { type Constraint, type Anchor, DistanceConstraint, type DistanceConstraintOptions, SpringConstraint, type SpringConstraintOptions, } from './constraints';
+export { type Bounds, resolveBounds, resolveCircleCircle } from './collisions';
+export { pendulum, type PendulumOptions, springChain, type SpringChainOptions } from './builders';
+export type { Vec2 } from './vec2';
+//# sourceMappingURL=index.d.ts.map

package/dist/mobjects/physics/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACxE,OAAO,EACL,IAAI,EACJ,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,YAAY,GAClB,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,KAAK,UAAU,EACf,KAAK,MAAM,EACX,kBAAkB,EAClB,KAAK,yBAAyB,EAC9B,gBAAgB,EAChB,KAAK,uBAAuB,GAC7B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,MAAM,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAClG,YAAY,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC"}

package/dist/mobjects/physics/vec2.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Minimal 2D vector helpers for the self-contained physics solver.
+ *
+ * The physics world runs in the XY plane. A {@link Vec2} is a plain `[x, y]`
+ * tuple, so it stays cheap to copy and compare in tests. Every helper is pure
+ * and returns a new value, which keeps the solver deterministic and easy to
+ * reason about.
+ */
+/** A 2D vector or point as an `[x, y]` tuple. */
+export type Vec2 = [number, number];
+/** Return a fresh copy of `v`. */
+export declare function cloneVec2(v: Vec2): Vec2;
+/** Return the dot product `a . b`. */
+export declare function dotVec2(a: Vec2, b: Vec2): number;
+/** Return the distance between points `a` and `b`. */
+export declare function distanceVec2(a: Vec2, b: Vec2): number;
+//# sourceMappingURL=vec2.d.ts.map

package/dist/mobjects/physics/vec2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vec2.d.ts","sourceRoot":"","sources":["../../../src/mobjects/physics/vec2.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,iDAAiD;AACjD,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEpC,kCAAkC;AAClC,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAEvC;AAED,sCAAsC;AACtC,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAEhD;AAED,sDAAsD;AACtD,wBAAgB,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAErD"}

package/dist/mobjects/shader/ShaderMobject.d.ts

@@ -0,0 +1,105 @@
+import { Mobject } from '../../core/Mobject';
+import * as THREE from 'three';
+/**
+ * Allowed value types for a ShaderMobject uniform.
+ *
+ * Floats map to GLSL `float`, vectors to `vecN`, `THREE.Color` to a `vec3`
+ * (THREE uploads its `.r/.g/.b`), `THREE.Texture` to a `sampler2D`, and a
+ * plain number array to the matching `vecN`/array uniform.
+ */
+export type ShaderUniformValue = number | boolean | THREE.Vector2 | THREE.Vector3 | THREE.Vector4 | THREE.Color | THREE.Texture | readonly number[];
+/**
+ * Options for a {@link ShaderMobject}.
+ */
+export interface ShaderMobjectOptions {
+    /** The GLSL fragment shader source. Required. */
+    fragmentShader: string;
+    /** The GLSL vertex shader source. Default: a pass-through that exposes `vUv`. */
+    vertexShader?: string;
+    /** Plane width in world units. Default: 8 */
+    width?: number;
+    /** Plane height in world units. Default: 4.5 */
+    height?: number;
+    /** User-defined uniforms, keyed by GLSL name. */
+    uniforms?: Record<string, ShaderUniformValue>;
+    /** Expose the Shadertoy-style `iMouse` (vec4) uniform. Default: false */
+    mouse?: boolean;
+    /** Blending mode. Default: THREE.NormalBlending */
+    blending?: THREE.Blending;
+    /** Enable transparency. Default: true */
+    transparent?: boolean;
+    /** Opacity, stored on the mobject. Default: 1 */
+    opacity?: number;
+}
+/**
+ * ShaderMobject -- a plane rendered with a user-supplied GLSL fragment shader.
+ *
+ * It mirrors the Shadertoy convention with built-in uniforms updated each
+ * frame: `iTime` (seconds), `iResolution` (vec3 plane size), and an optional
+ * `iMouse` (vec4). User uniforms (floats, vectors, colors, textures) pass
+ * through an options map. A frame updater advances `iTime`, so animated
+ * shaders run on the timeline.
+ *
+ * Construction never touches a WebGL context, so it is headless-safe; the
+ * material is built lazily on the first {@link getThreeObject} call. Uniform
+ * and time updates made before that point are stored and applied on build.
+ *
+ * @example
+ * ```typescript
+ * const shader = new ShaderMobject({
+ *   fragmentShader: `
+ *     precision highp float;
+ *     uniform float iTime;
+ *     varying vec2 vUv;
+ *     void main() {
+ *       gl_FragColor = vec4(vUv, 0.5 + 0.5 * sin(iTime), 1.0);
+ *     }
+ *   `,
+ * });
+ * scene.add(shader);
+ * ```
+ */
+export declare class ShaderMobject extends Mobject {
+    private _width;
+    private _height;
+    private _fragmentShader;
+    private _vertexShader;
+    private _mouse;
+    private _blending;
+    private _transparent;
+    private _time;
+    private _resolution;
+    private readonly _uniformValues;
+    private _material;
+    constructor(options: ShaderMobjectOptions);
+    protected _createThreeObject(): THREE.Object3D;
+    /** Set a uniform value, creating it if it was not declared. */
+    setUniform(name: string, value: ShaderUniformValue): this;
+    /** Get a uniform value, or `undefined` if it is not set. */
+    getUniform(name: string): ShaderUniformValue | undefined;
+    /** Set the shader time `iTime` (seconds). */
+    syncToTime(t: number): this;
+    /** Get the current shader time in seconds. */
+    getTime(): number;
+    /** Set the `iResolution` uniform (in pixels or world units, caller's choice). */
+    setResolution(width: number, height: number): this;
+    /** Get the fragment shader source. */
+    getFragmentShader(): string;
+    /** Get the vertex shader source. */
+    getVertexShader(): string;
+    /** Set the plane width in world units. */
+    setWidth(width: number): this;
+    /** Get the plane width. */
+    getWidth(): number;
+    /** Set the plane height in world units. */
+    setHeight(height: number): this;
+    /** Get the plane height. */
+    getHeight(): number;
+    /** Get the underlying ShaderMaterial, or `null` before the mesh is built. */
+    getMaterial(): THREE.ShaderMaterial | null;
+    normalizeTransform(worldMatrix?: THREE.Matrix4): this;
+    copy(): ShaderMobject;
+    /** Free GPU resources. */
+    dispose(): void;
+}
+//# sourceMappingURL=ShaderMobject.d.ts.map

package/dist/mobjects/shader/ShaderMobject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShaderMobject.d.ts","sourceRoot":"","sources":["../../../src/mobjects/shader/ShaderMobject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,GAC1B,MAAM,GACN,OAAO,GACP,KAAK,CAAC,OAAO,GACb,KAAK,CAAC,OAAO,GACb,KAAK,CAAC,OAAO,GACb,KAAK,CAAC,KAAK,GACX,KAAK,CAAC,OAAO,GACb,SAAS,MAAM,EAAE,CAAC;AAEtB;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,iDAAiD;IACjD,cAAc,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAC9C,yEAAyE;IACzE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mDAAmD;IACnD,QAAQ,CAAC,EAAE,KAAK,CAAC,QAAQ,CAAC;IAC1B,yCAAyC;IACzC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,aAAc,SAAQ,OAAO;IACxC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyC;IACxE,OAAO,CAAC,SAAS,CAAqC;gBAE1C,OAAO,EAAE,oBAAoB;IAuCzC,SAAS,CAAC,kBAAkB,IAAI,KAAK,CAAC,QAAQ;IA6B9C,+DAA+D;IAC/D,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAWzD,4DAA4D;IAC5D,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAIxD,6CAA6C;IAC7C,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAQ3B,8CAA8C;IAC9C,OAAO,IAAI,MAAM;IAIjB,iFAAiF;IACjF,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAQlD,sCAAsC;IACtC,iBAAiB,IAAI,MAAM;IAI3B,oCAAoC;IACpC,eAAe,IAAI,MAAM;IAIzB,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM7B,2BAA2B;IAC3B,QAAQ,IAAI,MAAM;IAIlB,2CAA2C;IAC3C,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM/B,4BAA4B;IAC5B,SAAS,IAAI,MAAM;IAInB,6EAA6E;IAC7E,WAAW,IAAI,KAAK,CAAC,cAAc,GAAG,IAAI;IAOjC,kBAAkB,CAAC,WAAW,GAAE,KAAK,CAAC,OAA2B,GAAG,IAAI;IAOxE,IAAI,IAAI,aAAa;IAsB9B,0BAA0B;IAC1B,OAAO,IAAI,IAAI;CAShB"}

package/dist/mobjects/shader/index.d.ts

@@ -0,0 +1,2 @@
+export { ShaderMobject, type ShaderMobjectOptions, type ShaderUniformValue } from './ShaderMobject';
+//# sourceMappingURL=index.d.ts.map

package/dist/mobjects/shader/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mobjects/shader/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,oBAAoB,EAAE,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/mobjects/sketch/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hand-drawn / sketch (rough.js / xkcd) stroke style for VMobjects.
+ */
+export { sketch, type SketchOptions } from './sketch';
+//# sourceMappingURL=index.d.ts.map

package/dist/mobjects/sketch/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mobjects/sketch/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAC"}

package/dist/mobjects/sketch/sketch.d.ts

@@ -0,0 +1,30 @@
+import { VMobject } from '../../core/VMobject';
+/** Options for {@link sketch}. */
+export interface SketchOptions {
+    /** Deviation scale. 0 keeps the source shape; 1 is a normal hand-drawn look. */
+    roughness?: number;
+    /** Side-bow of each edge, as a fraction of the edge length. */
+    bowing?: number;
+    /** Random stroke-width change, as a fraction of the source width (0..1). */
+    strokeWidthJitter?: number;
+    /** PRNG seed. The same seed gives the same output. */
+    seed?: number;
+    /** Number of overlapping strokes (1 or 2). 2 gives a double-stroke look. */
+    strokes?: 1 | 2;
+    /** Straight sub-segments per edge. More segments give a finer wobble. */
+    segments?: number;
+}
+/**
+ * Return a hand-drawn (sketch) copy of a VMobject.
+ *
+ * The source is copied first, so it is never changed. Every family member that
+ * owns points is perturbed with a seeded PRNG, which keeps the output
+ * deterministic for a given seed. The copy keeps the source type, stroke and
+ * fill style, so it is a drop-in replacement.
+ *
+ * @param mobject - Source VMobject (line, polygon, circle, text, group, ...)
+ * @param options - Sketch options; see {@link SketchOptions}
+ * @returns A new VMobject with the hand-drawn path
+ */
+export declare function sketch<T extends VMobject>(mobject: T, options?: SketchOptions): T;
+//# sourceMappingURL=sketch.d.ts.map

package/dist/mobjects/sketch/sketch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sketch.d.ts","sourceRoot":"","sources":["../../../src/mobjects/sketch/sketch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAG/C,kCAAkC;AAClC,MAAM,WAAW,aAAa;IAC5B,gFAAgF;IAChF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4EAA4E;IAC5E,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,OAAO,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAChB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA+JD;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAE,aAAkB,GAAG,CAAC,CASrF"}