@redwilly/anima 0.1.0

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

@@ -0,0 +1,7 @@
+export * from './Arc';
+export * from './Circle';
+export * from './Line';
+export * from './Point';
+export * from './Polygon';
+export * from './Rectangle';
+export * from './Arrow';

package/dist/mobjects/geometry/index.js

@@ -0,0 +1,7 @@
+export * from './Arc';
+export * from './Circle';
+export * from './Line';
+export * from './Point';
+export * from './Polygon';
+export * from './Rectangle';
+export * from './Arrow';

package/dist/mobjects/graph/Graph.d.ts

@@ -0,0 +1,28 @@
+import { VGroup } from '../VGroup';
+import { GraphNode } from './GraphNode';
+import { GraphEdge } from './GraphEdge';
+import type { GraphNodeId, NodeConfig, EdgeConfig, LayoutType, LayoutConfig } from './types';
+/**
+ * A graph structure containing nodes and edges.
+ * Manages nodes as VMobjects and edges as BezierPath curves.
+ * Supports multiple layout algorithms for automatic positioning.
+ */
+export declare class Graph extends VGroup {
+    private nodes;
+    private edges;
+    constructor();
+    /** Adds a node to the graph. */
+    addNode(id: GraphNodeId, config?: NodeConfig): GraphNode;
+    /** Removes a node and all connected edges from the graph. */
+    removeNode(id: GraphNodeId): this;
+    getNode(id: GraphNodeId): GraphNode | undefined;
+    getNodes(): GraphNode[];
+    addEdge(sourceId: GraphNodeId, targetId: GraphNodeId, config?: EdgeConfig): GraphEdge | undefined;
+    removeEdge(sourceId: GraphNodeId, targetId: GraphNodeId): this;
+    private removeEdgeInternal;
+    getEdgePath(sourceId: GraphNodeId, targetId: GraphNodeId): ReturnType<GraphEdge['getPath']>;
+    getEdges(): GraphEdge[];
+    /** Applies a layout algorithm to reposition all nodes. */
+    layout(type: LayoutType, config?: LayoutConfig): this;
+    updateEdges(): this;
+}

package/dist/mobjects/graph/Graph.js

@@ -0,0 +1,119 @@
+import { VGroup } from '../VGroup';
+import { GraphNode } from './GraphNode';
+import { GraphEdge } from './GraphEdge';
+import { circularLayout, treeLayout, forceDirectedLayout } from './layouts';
+/**
+ * A graph structure containing nodes and edges.
+ * Manages nodes as VMobjects and edges as BezierPath curves.
+ * Supports multiple layout algorithms for automatic positioning.
+ */
+export class Graph extends VGroup {
+    nodes = new Map();
+    edges = [];
+    constructor() {
+        super();
+    }
+    /** Adds a node to the graph. */
+    addNode(id, config = {}) {
+        if (this.nodes.has(id)) {
+            const existing = this.nodes.get(id);
+            if (existing)
+                return existing;
+        }
+        const node = new GraphNode(id, config);
+        this.nodes.set(id, node);
+        this.add(node);
+        return node;
+    }
+    /** Removes a node and all connected edges from the graph. */
+    removeNode(id) {
+        const node = this.nodes.get(id);
+        if (!node)
+            return this;
+        // Remove connected edges
+        const connectedEdges = this.edges.filter(e => e.source === id || e.target === id);
+        for (const edge of connectedEdges) {
+            this.removeEdgeInternal(edge);
+        }
+        // Remove node
+        this.nodes.delete(id);
+        this.remove(node);
+        return this;
+    }
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    getNodes() {
+        return Array.from(this.nodes.values());
+    }
+    addEdge(sourceId, targetId, config = {}) {
+        const sourceNode = this.nodes.get(sourceId);
+        const targetNode = this.nodes.get(targetId);
+        if (!sourceNode || !targetNode) {
+            return undefined;
+        }
+        const existing = this.edges.find(e => (e.source === sourceId && e.target === targetId) ||
+            (e.source === targetId && e.target === sourceId));
+        if (existing)
+            return existing;
+        const edge = new GraphEdge(sourceNode, targetNode, config);
+        this.edges.push(edge);
+        this.add(edge);
+        return edge;
+    }
+    removeEdge(sourceId, targetId) {
+        const edge = this.edges.find(e => (e.source === sourceId && e.target === targetId) ||
+            (e.source === targetId && e.target === sourceId));
+        if (edge) {
+            this.removeEdgeInternal(edge);
+        }
+        return this;
+    }
+    removeEdgeInternal(edge) {
+        const index = this.edges.indexOf(edge);
+        if (index > -1) {
+            this.edges.splice(index, 1);
+            this.remove(edge);
+        }
+    }
+    getEdgePath(sourceId, targetId) {
+        const edge = this.edges.find(e => (e.source === sourceId && e.target === targetId) ||
+            (e.source === targetId && e.target === sourceId));
+        return edge?.getPath();
+    }
+    getEdges() {
+        return [...this.edges];
+    }
+    /** Applies a layout algorithm to reposition all nodes. */
+    layout(type, config = {}) {
+        const nodeArray = this.getNodes();
+        let positions;
+        switch (type) {
+            case 'circular':
+                positions = circularLayout(nodeArray, config);
+                break;
+            case 'tree':
+                positions = treeLayout(nodeArray, this.edges, config);
+                break;
+            case 'force-directed':
+                positions = forceDirectedLayout(nodeArray, this.edges, config);
+                break;
+            default:
+                positions = new Map();
+        }
+        for (const [id, position] of positions) {
+            const node = this.nodes.get(id);
+            if (node) {
+                node.pos(position.x, position.y);
+            }
+        }
+        this.updateEdges();
+        return this;
+    }
+    updateEdges() {
+        for (const edge of this.edges) {
+            edge.updatePath();
+        }
+        return this;
+    }
+}

package/dist/mobjects/graph/GraphEdge.d.ts

@@ -0,0 +1,26 @@
+import { VMobject } from '../VMobject';
+import { BezierPath } from '../../core/math/bezier/BezierPath';
+import type { GraphNodeId, EdgeConfig } from './types';
+import type { GraphNode } from './GraphNode';
+/**
+ * A graph edge represented as a BezierPath connecting two nodes.
+ * Supports straight or curved edges with customizable styling.
+ */
+export declare class GraphEdge extends VMobject {
+    readonly source: GraphNodeId;
+    readonly target: GraphNodeId;
+    private sourceNode;
+    private targetNode;
+    private curved;
+    constructor(sourceNode: GraphNode, targetNode: GraphNode, config?: EdgeConfig);
+    /**
+     * Recalculates the edge path based on current node positions.
+     * Call this when nodes move to update the edge connection.
+     */
+    updatePath(): void;
+    getPath(): BezierPath | undefined;
+    /**
+     * Updates node references (used when nodes are replaced).
+     */
+    setNodes(sourceNode: GraphNode, targetNode: GraphNode): void;
+}

package/dist/mobjects/graph/GraphEdge.js

@@ -0,0 +1,64 @@
+import { VMobject } from '../VMobject';
+import { BezierPath } from '../../core/math/bezier/BezierPath';
+import { Vector2 } from '../../core/math/Vector2/Vector2';
+import { Color } from '../../core/math/color/Color';
+/**
+ * A graph edge represented as a BezierPath connecting two nodes.
+ * Supports straight or curved edges with customizable styling.
+ */
+export class GraphEdge extends VMobject {
+    source;
+    target;
+    sourceNode;
+    targetNode;
+    curved;
+    constructor(sourceNode, targetNode, config = {}) {
+        super();
+        this.source = sourceNode.id;
+        this.target = targetNode.id;
+        this.sourceNode = sourceNode;
+        this.targetNode = targetNode;
+        this.curved = config.curved ?? false;
+        // Apply styling
+        this.strokeColor = config.strokeColor ?? Color.WHITE;
+        this.strokeWidth = config.strokeWidth ?? 2;
+        this.fillColor = Color.TRANSPARENT;
+        this.fillOpacity = 0;
+        this.updatePath();
+    }
+    /**
+     * Recalculates the edge path based on current node positions.
+     * Call this when nodes move to update the edge connection.
+     */
+    updatePath() {
+        const startPos = this.sourceNode.getCenter();
+        const endPos = this.targetNode.getCenter();
+        const path = new BezierPath();
+        path.moveTo(startPos);
+        if (this.curved) {
+            // Create a curved path using quadratic Bezier
+            const mid = startPos.lerp(endPos, 0.5);
+            const direction = endPos.subtract(startPos);
+            const perpendicular = new Vector2(-direction.y, direction.x).normalize();
+            const curveOffset = direction.length() * 0.2;
+            const controlPoint = mid.add(perpendicular.multiply(curveOffset));
+            path.quadraticTo(controlPoint, endPos);
+        }
+        else {
+            // Straight line
+            path.lineTo(endPos);
+        }
+        this.pathList = [path];
+    }
+    getPath() {
+        return this.pathList[0];
+    }
+    /**
+     * Updates node references (used when nodes are replaced).
+     */
+    setNodes(sourceNode, targetNode) {
+        this.sourceNode = sourceNode;
+        this.targetNode = targetNode;
+        this.updatePath();
+    }
+}

package/dist/mobjects/graph/GraphNode.d.ts

@@ -0,0 +1,19 @@
+import { VMobject } from '../VMobject';
+import { Vector2 } from '../../core/math/Vector2/Vector2';
+import type { GraphNodeId, NodeConfig } from './types';
+/**
+ * A graph node represented as a circular VMobject.
+ * Supports customizable radius, stroke, and fill styling.
+ */
+export declare class GraphNode extends VMobject {
+    readonly id: GraphNodeId;
+    private nodeRadius;
+    constructor(id: GraphNodeId, config?: NodeConfig);
+    get radius(): number;
+    /**
+     * Generates a circular BezierPath approximation using cubic Bezier curves.
+     * Uses the standard 4-point circle approximation with control point factor ~0.5523.
+     */
+    private generateCirclePath;
+    getCenter(): Vector2;
+}

package/dist/mobjects/graph/GraphNode.js

@@ -0,0 +1,63 @@
+import { VMobject } from '../VMobject';
+import { BezierPath } from '../../core/math/bezier/BezierPath';
+import { Vector2 } from '../../core/math/Vector2/Vector2';
+const DEFAULT_RADIUS = 0.25;
+/**
+ * A graph node represented as a circular VMobject.
+ * Supports customizable radius, stroke, and fill styling.
+ */
+export class GraphNode extends VMobject {
+    id;
+    nodeRadius;
+    constructor(id, config = {}) {
+        super();
+        this.id = id;
+        this.nodeRadius = config.radius ?? DEFAULT_RADIUS;
+        // Apply initial position
+        if (config.position) {
+            this.pos(config.position.x, config.position.y);
+        }
+        // Apply styling only if explicitly provided in config
+        // If not provided, VMobject defaults apply (no stroke, no fill)
+        if (config.strokeColor !== undefined) {
+            this.strokeColor = config.strokeColor;
+        }
+        if (config.strokeWidth !== undefined) {
+            this.strokeWidth = config.strokeWidth;
+        }
+        if (config.fillColor !== undefined) {
+            this.fillColor = config.fillColor;
+        }
+        if (config.fillOpacity !== undefined) {
+            this.fillOpacity = config.fillOpacity;
+        }
+        this.generateCirclePath();
+    }
+    get radius() {
+        return this.nodeRadius;
+    }
+    /**
+     * Generates a circular BezierPath approximation using cubic Bezier curves.
+     * Uses the standard 4-point circle approximation with control point factor ~0.5523.
+     */
+    generateCirclePath() {
+        const path = new BezierPath();
+        const r = this.nodeRadius;
+        const k = 0.5522847498; // Magic number for circle approximation
+        // Start at the right-most point
+        path.moveTo(new Vector2(r, 0));
+        // Top-right quadrant
+        path.cubicTo(new Vector2(r, r * k), new Vector2(r * k, r), new Vector2(0, r));
+        // Top-left quadrant
+        path.cubicTo(new Vector2(-r * k, r), new Vector2(-r, r * k), new Vector2(-r, 0));
+        // Bottom-left quadrant
+        path.cubicTo(new Vector2(-r, -r * k), new Vector2(-r * k, -r), new Vector2(0, -r));
+        // Bottom-right quadrant
+        path.cubicTo(new Vector2(r * k, -r), new Vector2(r, -r * k), new Vector2(r, 0));
+        path.closePath();
+        this.pathList = [path];
+    }
+    getCenter() {
+        return this.position;
+    }
+}

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

@@ -0,0 +1,5 @@
+export { Graph } from './Graph';
+export { GraphNode } from './GraphNode';
+export { GraphEdge } from './GraphEdge';
+export * from './types';
+export * from './layouts';

package/dist/mobjects/graph/index.js

@@ -0,0 +1,5 @@
+export { Graph } from './Graph';
+export { GraphNode } from './GraphNode';
+export { GraphEdge } from './GraphEdge';
+export * from './types';
+export * from './layouts';

package/dist/mobjects/graph/layouts/circular.d.ts

@@ -0,0 +1,8 @@
+import { Vector2 } from '../../../core/math/Vector2/Vector2';
+import type { GraphNode } from '../GraphNode';
+import type { LayoutConfig } from '../types';
+/**
+ * Arranges nodes in a circular layout.
+ * Nodes are evenly distributed around a circle of the specified radius.
+ */
+export declare function circularLayout(nodes: GraphNode[], config?: LayoutConfig): Map<string, Vector2>;

package/dist/mobjects/graph/layouts/circular.js

@@ -0,0 +1,23 @@
+import { Vector2 } from '../../../core/math/Vector2/Vector2';
+const DEFAULT_RADIUS = 3;
+/**
+ * Arranges nodes in a circular layout.
+ * Nodes are evenly distributed around a circle of the specified radius.
+ */
+export function circularLayout(nodes, config = {}) {
+    const positions = new Map();
+    const radius = config.radius ?? DEFAULT_RADIUS;
+    const count = nodes.length;
+    if (count === 0)
+        return positions;
+    for (let i = 0; i < count; i++) {
+        const angle = (2 * Math.PI * i) / count - Math.PI / 2;
+        const x = radius * Math.cos(angle);
+        const y = radius * Math.sin(angle);
+        const node = nodes[i];
+        if (node) {
+            positions.set(node.id, new Vector2(x, y));
+        }
+    }
+    return positions;
+}

package/dist/mobjects/graph/layouts/forceDirected.d.ts

@@ -0,0 +1,9 @@
+import { Vector2 } from '../../../core/math/Vector2/Vector2';
+import type { GraphNode } from '../GraphNode';
+import type { GraphEdge } from '../GraphEdge';
+import type { LayoutConfig } from '../types';
+/**
+ * Applies force-directed layout using spring simulation.
+ * Nodes repel each other while edges act as springs.
+ */
+export declare function forceDirectedLayout(nodes: GraphNode[], edges: GraphEdge[], config?: LayoutConfig): Map<string, Vector2>;

package/dist/mobjects/graph/layouts/forceDirected.js

@@ -0,0 +1,102 @@
+import { Vector2 } from '../../../core/math/Vector2/Vector2';
+const DEFAULT_ITERATIONS = 50;
+const DEFAULT_SPRING_LENGTH = 1.5;
+const DEFAULT_REPULSION = 1.0;
+const DEFAULT_ATTRACTION = 0.1;
+const DEFAULT_DAMPING = 0.85;
+const DEFAULT_MIN_DISTANCE = 0.01;
+/**
+ * Applies force-directed layout using spring simulation.
+ * Nodes repel each other while edges act as springs.
+ */
+export function forceDirectedLayout(nodes, edges, config = {}) {
+    const positions = new Map();
+    const iterations = config.iterations ?? DEFAULT_ITERATIONS;
+    const springLength = config.springLength ?? DEFAULT_SPRING_LENGTH;
+    const repulsion = config.repulsion ?? DEFAULT_REPULSION;
+    const attraction = config.attraction ?? DEFAULT_ATTRACTION;
+    const damping = config.damping ?? DEFAULT_DAMPING;
+    const minDistance = config.minDistance ?? DEFAULT_MIN_DISTANCE;
+    if (nodes.length === 0)
+        return positions;
+    // Initialize node states with current positions or random
+    const states = new Map();
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if (node) {
+            // Start with a circular distribution to avoid overlap
+            const angle = (2 * Math.PI * i) / nodes.length;
+            const initialPos = new Vector2(Math.cos(angle) * 2, Math.sin(angle) * 2);
+            states.set(node.id, {
+                position: initialPos,
+                velocity: Vector2.ZERO
+            });
+        }
+    }
+    // Build edge lookup
+    const edgeSet = new Set();
+    for (const edge of edges) {
+        edgeSet.add(`${edge.source}-${edge.target}`);
+        edgeSet.add(`${edge.target}-${edge.source}`);
+    }
+    // Run simulation
+    for (let iter = 0; iter < iterations; iter++) {
+        const forces = new Map();
+        // Initialize forces
+        for (const node of nodes) {
+            forces.set(node.id, Vector2.ZERO);
+        }
+        // Calculate repulsion forces between all node pairs
+        for (let i = 0; i < nodes.length; i++) {
+            for (let j = i + 1; j < nodes.length; j++) {
+                const nodeA = nodes[i];
+                const nodeB = nodes[j];
+                if (!nodeA || !nodeB)
+                    continue;
+                const stateA = states.get(nodeA.id);
+                const stateB = states.get(nodeB.id);
+                if (!stateA || !stateB)
+                    continue;
+                const delta = stateA.position.subtract(stateB.position);
+                const distance = Math.max(delta.length(), minDistance);
+                const force = delta.normalize().multiply(repulsion / (distance * distance));
+                const forceA = forces.get(nodeA.id) ?? Vector2.ZERO;
+                const forceB = forces.get(nodeB.id) ?? Vector2.ZERO;
+                forces.set(nodeA.id, forceA.add(force));
+                forces.set(nodeB.id, forceB.subtract(force));
+            }
+        }
+        // Calculate attraction forces along edges
+        for (const edge of edges) {
+            const stateA = states.get(edge.source);
+            const stateB = states.get(edge.target);
+            if (!stateA || !stateB)
+                continue;
+            const delta = stateB.position.subtract(stateA.position);
+            const distance = delta.length();
+            const displacement = distance - springLength;
+            const force = delta.normalize().multiply(displacement * attraction);
+            const forceA = forces.get(edge.source) ?? Vector2.ZERO;
+            const forceB = forces.get(edge.target) ?? Vector2.ZERO;
+            forces.set(edge.source, forceA.add(force));
+            forces.set(edge.target, forceB.subtract(force));
+        }
+        // Apply forces and update positions
+        for (const node of nodes) {
+            const state = states.get(node.id);
+            const force = forces.get(node.id);
+            if (!state || !force)
+                continue;
+            state.velocity = state.velocity.add(force).multiply(damping);
+            state.position = state.position.add(state.velocity);
+        }
+    }
+    // Collect final positions
+    for (const node of nodes) {
+        const state = states.get(node.id);
+        if (state) {
+            positions.set(node.id, state.position);
+        }
+    }
+    return positions;
+}

package/dist/mobjects/graph/layouts/index.d.ts

@@ -0,0 +1,3 @@
+export { circularLayout } from './circular';
+export { treeLayout } from './tree';
+export { forceDirectedLayout } from './forceDirected';

package/dist/mobjects/graph/layouts/index.js

@@ -0,0 +1,3 @@
+export { circularLayout } from './circular';
+export { treeLayout } from './tree';
+export { forceDirectedLayout } from './forceDirected';

package/dist/mobjects/graph/layouts/tree.d.ts

@@ -0,0 +1,9 @@
+import { Vector2 } from '../../../core/math/Vector2/Vector2';
+import type { GraphNode } from '../GraphNode';
+import type { GraphEdge } from '../GraphEdge';
+import type { LayoutConfig } from '../types';
+/**
+ * Arranges nodes in a hierarchical tree layout.
+ * Assumes edges represent parent-child relationships.
+ */
+export declare function treeLayout(nodes: GraphNode[], edges: GraphEdge[], config?: LayoutConfig): Map<string, Vector2>;

package/dist/mobjects/graph/layouts/tree.js

@@ -0,0 +1,99 @@
+import { Vector2 } from '../../../core/math/Vector2/Vector2';
+const DEFAULT_LEVEL_HEIGHT = 1.5;
+const DEFAULT_SIBLING_SPACING = 1.0;
+/**
+ * Builds a tree structure from nodes and edges.
+ * Assumes directed edges from parent to child.
+ */
+function buildTree(nodes, edges) {
+    if (nodes.length === 0)
+        return undefined;
+    const hasIncoming = new Set();
+    for (const edge of edges) {
+        hasIncoming.add(edge.target);
+    }
+    const nodeMap = new Map();
+    for (const node of nodes) {
+        nodeMap.set(node.id, node);
+    }
+    // Build adjacency list (parent -> children)
+    const childrenMap = new Map();
+    for (const edge of edges) {
+        const children = childrenMap.get(edge.source) ?? [];
+        children.push(edge.target);
+        childrenMap.set(edge.source, children);
+    }
+    let rootId;
+    for (const node of nodes) {
+        if (!hasIncoming.has(node.id)) {
+            rootId = node.id;
+            break;
+        }
+    }
+    if (!rootId && nodes[0]) {
+        rootId = nodes[0].id;
+    }
+    if (!rootId)
+        return undefined;
+    // Build tree recursively
+    function buildNode(id, depth) {
+        const children = (childrenMap.get(id) ?? [])
+            .map(childId => buildNode(childId, depth + 1));
+        const width = children.length === 0
+            ? 1
+            : children.reduce((sum, c) => sum + c.width, 0);
+        return { id, children, depth, x: 0, width };
+    }
+    return buildNode(rootId, 0);
+}
+/**
+ * Recursively assigns x positions to tree nodes.
+ */
+function assignPositions(node, leftBound, spacing) {
+    if (node.children.length === 0) {
+        node.x = leftBound + node.width * spacing / 2;
+        return;
+    }
+    let currentLeft = leftBound;
+    for (const child of node.children) {
+        assignPositions(child, currentLeft, spacing);
+        currentLeft += child.width * spacing;
+    }
+    // Center parent over children
+    const firstChild = node.children[0];
+    const lastChild = node.children[node.children.length - 1];
+    if (firstChild && lastChild) {
+        node.x = (firstChild.x + lastChild.x) / 2;
+    }
+}
+/**
+ * Collects all positions from the tree.
+ */
+function collectPositions(node, levelHeight, positions) {
+    positions.set(node.id, new Vector2(node.x, node.depth * levelHeight));
+    for (const child of node.children) {
+        collectPositions(child, levelHeight, positions);
+    }
+}
+/**
+ * Arranges nodes in a hierarchical tree layout.
+ * Assumes edges represent parent-child relationships.
+ */
+export function treeLayout(nodes, edges, config = {}) {
+    const positions = new Map();
+    const levelHeight = config.levelHeight ?? DEFAULT_LEVEL_HEIGHT;
+    const siblingSpacing = config.siblingSpacing ?? DEFAULT_SIBLING_SPACING;
+    const tree = buildTree(nodes, edges);
+    if (!tree)
+        return positions;
+    assignPositions(tree, 0, siblingSpacing);
+    collectPositions(tree, levelHeight, positions);
+    const allX = Array.from(positions.values()).map(p => p.x);
+    const minX = Math.min(...allX);
+    const maxX = Math.max(...allX);
+    const centerOffset = (minX + maxX) / 2;
+    for (const [id, pos] of positions) {
+        positions.set(id, new Vector2(pos.x - centerOffset, pos.y));
+    }
+    return positions;
+}

package/dist/mobjects/graph/types.d.ts

@@ -0,0 +1,35 @@
+import { Color } from '../../core/math/color/Color';
+/** Unique identifier for graph nodes. */
+export type GraphNodeId = string;
+/** Configuration for creating a graph node. */
+export interface NodeConfig {
+    position?: {
+        x: number;
+        y: number;
+    };
+    radius?: number;
+    strokeColor?: Color;
+    strokeWidth?: number;
+    fillColor?: Color;
+    fillOpacity?: number;
+}
+/** Configuration for creating a graph edge. */
+export interface EdgeConfig {
+    strokeColor?: Color;
+    strokeWidth?: number;
+    curved?: boolean;
+}
+/** Supported layout algorithms. */
+export type LayoutType = 'force-directed' | 'tree' | 'circular';
+/** Configuration for graph layout algorithms. */
+export interface LayoutConfig {
+    radius?: number;
+    levelHeight?: number;
+    siblingSpacing?: number;
+    iterations?: number;
+    springLength?: number;
+    repulsion?: number;
+    attraction?: number;
+    damping?: number;
+    minDistance?: number;
+}

package/dist/mobjects/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Mobject';
+export * from './VMobject';
+export * from './VGroup';
+export * from './geometry';
+export * from './text';
+export * from './graph';

package/dist/mobjects/index.js

@@ -0,0 +1,6 @@
+export * from './Mobject';
+export * from './VMobject';
+export * from './VGroup';
+export * from './geometry';
+export * from './text';
+export * from './graph';