locusing 0.1.0 → 0.1.1

package/dist/index.d.mts

@@ -1,3 +1,5 @@
+import Matter from 'matter-js';
+
 /**
  * @locusing/math - 数学工具库
  *
@@ -17,6 +19,42 @@ declare const UL: Vector2;
 declare const UR: Vector2;
 declare const DL: Vector2;
 declare const DR: Vector2;
+/**
+ * Manim 风格方向常量（数学坐标系，Y 向上为正）
+ *
+ * 用于 Frame 模式渲染，原点在画布中心
+ *
+ * @example
+ * ```typescript
+ * import { Dir, scale } from 'locusing';
+ *
+ * // 正方形向上移动 2 单位
+ * square(1).move(scale(Dir.UP, 2));
+ *
+ * // 圆形在右下角
+ * circle(0.5).move(scale(Dir.DR, 3));
+ * ```
+ */
+declare const Dir: {
+    /** 原点 [0, 0] */
+    ORIGIN: Vector2;
+    /** 向上 [0, 1] */
+    UP: Vector2;
+    /** 向下 [0, -1] */
+    DOWN: Vector2;
+    /** 向左 [-1, 0] */
+    LEFT: Vector2;
+    /** 向右 [1, 0] */
+    RIGHT: Vector2;
+    /** 左上 [-1, 1] */
+    UL: Vector2;
+    /** 右上 [1, 1] */
+    UR: Vector2;
+    /** 左下 [-1, -1] */
+    DL: Vector2;
+    /** 右下 [1, -1] */
+    DR: Vector2;
+};
 declare function add(a: Vector2, b: Vector2): Vector2;
 declare function sub(a: Vector2, b: Vector2): Vector2;
 declare function mul(v: Vector2, scalar: number): Vector2;
@@ -24,7 +62,7 @@ declare function div(v: Vector2, scalar: number): Vector2;
 declare function dot$1(a: Vector2, b: Vector2): number;
 declare function cross(a: Vector2, b: Vector2): number;
 declare function length(v: Vector2): number;
-declare function normalize(v: Vector2): Vector2;
+declare function normalize$1(v: Vector2): Vector2;
 declare function distance(a: Vector2, b: Vector2): number;
 declare function angle(v: Vector2): number;
 declare function angleBetween(a: Vector2, b: Vector2): number;
@@ -75,6 +113,39 @@ declare const easing: {
     easeOutElastic: (t: number) => number;
     easeInBounce: (t: number) => number;
     easeOutBounce: (t: number) => number;
+    /**
+     * thereAndBack - 去而复返
+     *
+     * 从 0 开始，到 0.5 时达到 1，然后回到 0
+     */
+    thereAndBack: (t: number) => number;
+    /**
+     * thereAndBackWithPause - 去而复返（带停顿）
+     *
+     * 类似 thereAndBack，但在中间有一段停留时间
+     * @param pauseRatio - 停顿占总时间的比例，默认 1/3
+     */
+    thereAndBackWithPause: (t: number, pauseRatio?: number) => number;
+    /**
+     * runningStart - 起跑式
+     *
+     * 先后退一点，再向前冲（类似起跑动作）
+     * @param pullFactor - 后退程度，默认 -0.3
+     */
+    runningStart: (t: number, pullFactor?: number) => number;
+    /**
+     * wiggle - 摇摆
+     *
+     * 产生摇摆效果，适合强调动画
+     */
+    wiggle: (t: number, wiggles?: number) => number;
+    /**
+     * exponentialDecay - 指数衰减
+     *
+     * 快速到达目标后缓慢稳定
+     * @param halfLife - 半衰期，值越小衰减越快，默认 0.1
+     */
+    exponentialDecay: (t: number, halfLife?: number) => number;
 };
 declare const PI: number;
 declare const TAU: number;
@@ -108,7 +179,7 @@ interface TextStyle extends Style {
     textAnchor?: 'start' | 'middle' | 'end';
     dominantBaseline?: 'auto' | 'middle' | 'hanging' | 'central';
 }
-type ShapeType = 'group' | 'path' | 'rect' | 'circle' | 'ellipse' | 'line' | 'polyline' | 'polygon' | 'text' | 'arc';
+type ShapeType = 'group' | 'path' | 'rect' | 'circle' | 'ellipse' | 'line' | 'polyline' | 'polygon' | 'text' | 'arc' | 'tex';
 type PathCommand = {
     type: 'M';
     x: number;
@@ -231,11 +302,41 @@ interface ArcShape extends BaseShape {
     startAngle: number;
     endAngle: number;
 }
-type Shape = GroupShape | PathShape | RectShape | CircleShape | EllipseShape | LineShape | PolylineShape | PolygonShape | TextShape | ArcShape;
+interface TexShape extends BaseShape {
+    type: 'tex';
+    x: number;
+    y: number;
+    latex: string;
+    html: string;
+    fontSize: number;
+    color: string;
+}
+type Shape = GroupShape | PathShape | RectShape | CircleShape | EllipseShape | LineShape | PolylineShape | PolygonShape | TextShape | ArcShape | TexShape;
+interface FrameConfig {
+    /** 逻辑宽度（默认 16） */
+    width: number;
+    /** 逻辑高度（默认 9，16:9 比例） */
+    height: number;
+}
 interface RenderOptions {
+    /** 画布像素宽度 */
     width?: number;
+    /** 画布像素高度 */
     height?: number;
+    /** 背景颜色 */
     background?: string;
+    /**
+     * Frame 配置（Manim 风格坐标系）
+     *
+     * 启用后：
+     * - 原点在画布中心
+     * - Y 轴向上为正
+     * - 图形使用逻辑坐标，自动映射到像素
+     *
+     * 可以是 boolean（使用默认 16:9 frame）或 FrameConfig 对象
+     */
+    frame?: boolean | FrameConfig;
+    /** 手绘风格 */
     rough?: boolean;
     roughness?: number;
     bowing?: number;
@@ -295,6 +396,46 @@ declare class Diagram {
     /** 移动到指定位置 */
     position(x: number, y: number): Diagram;
     position(v: Vector2): Diagram;
+    /**
+     * 移动图形（Manim 风格）
+     *
+     * 将图形中心移动到指定位置。与 position() 相同，
+     * 但命名更符合 Manim 习惯。
+     *
+     * @example
+     * ```typescript
+     * import { square, Dir, mul } from 'locusing';
+     *
+     * // 移动到 (2, 3)
+     * square(1).move([2, 3]);
+     *
+     * // 使用方向常量
+     * square(1).move(mul(Dir.UP, 2));  // 向上移动 2 单位
+     * square(1).move(mul(Dir.RIGHT, 3));  // 向右移动 3 单位
+     *
+     * // 组合方向
+     * import { add } from 'locusing';
+     * square(1).move(add(mul(Dir.UP, 2), mul(Dir.RIGHT, 3)));  // 右上方
+     * ```
+     */
+    move(x: number, y: number): Diagram;
+    move(v: Vector2): Diagram;
+    /**
+     * 相对移动（偏移）
+     *
+     * 将图形从当前位置移动指定偏移量。
+     *
+     * @example
+     * ```typescript
+     * // 向右偏移 2 单位
+     * square(1).shift([2, 0]);
+     *
+     * // 使用方向常量
+     * square(1).shift(mul(Dir.UP, 1.5));
+     * ```
+     */
+    shift(x: number, y: number): Diagram;
+    shift(v: Vector2): Diagram;
     /** 旋转（弧度） */
     rotate(radians: number, center?: Vector2): Diagram;
     /** 旋转（度数） */
@@ -310,6 +451,8 @@ declare class Diagram {
     add(...others: Diagram[]): Diagram;
     /** 获取中心点 */
     center(): Vector2;
+    /** Manim 风格别名：获取中心点 */
+    getCenter(): Vector2;
     /** 获取包围盒 */
     bounds(): {
         x: number;
@@ -317,10 +460,73 @@ declare class Diagram {
         width: number;
         height: number;
     };
+    /** 获取宽度 */
+    width(): number;
+    /** Manim 风格别名：获取宽度 */
+    getWidth(): number;
+    /** 获取高度 */
+    height(): number;
+    /** Manim 风格别名：获取高度 */
+    getHeight(): number;
+    /** 获取左边缘 x 坐标 */
+    getLeft(): number;
+    /** 获取右边缘 x 坐标 */
+    getRight(): number;
+    /** 获取上边缘 y 坐标 */
+    getTop(): number;
+    /** 获取下边缘 y 坐标 */
+    getBottom(): number;
+    /** 获取左边缘点 */
+    getLeftEdge(): Vector2;
+    /** 获取右边缘点 */
+    getRightEdge(): Vector2;
+    /** 获取上边缘点 */
+    getTopEdge(): Vector2;
+    /** 获取下边缘点 */
+    getBottomEdge(): Vector2;
     /** 获取指定方向的边缘点 */
     edge(direction: Vector2): Vector2;
     /** 获取相对于另一个图形的位置 */
     nextTo(other: Diagram, direction: Vector2, buffer?: number): Diagram;
+    /**
+     * 获取子对象列表
+     *
+     * Manim 风格：返回直接子对象的 Diagram 数组
+     */
+    get submobjects(): Diagram[];
+    /**
+     * 获取所有后代对象（包括自身）
+     *
+     * Manim 风格：递归获取所有子对象
+     */
+    getFamily(): Diagram[];
+    /**
+     * 获取所有后代对象（不包括自身）
+     */
+    getFamilyWithoutSelf(): Diagram[];
+    /**
+     * 按索引获取子对象
+     */
+    getSubmobjectAt(index: number): Diagram | undefined;
+    /**
+     * 获取子对象数量
+     */
+    get length(): number;
+    /**
+     * 对所有子对象应用变换
+     */
+    applyToFamily(fn: (diagram: Diagram) => Diagram): Diagram;
+    /**
+     * 将图形中心对齐到原点
+     */
+    centerOnOrigin(): Diagram;
+    /**
+     * 将图形对齐到另一个图形的指定边缘
+     *
+     * @param other - 参考图形
+     * @param direction - 对齐方向
+     */
+    alignTo(other: Diagram, direction: Vector2): Diagram;
     /** 克隆图形 */
     clone(): Diagram;
     /** 复制到指定位置 */
@@ -333,7 +539,16 @@ declare class Diagram {
  * 提供 square, circle, line, polygon, text 等图元创建函数
  */
 
-/** 创建矩形 */
+/**
+ * 创建矩形
+ *
+ * @param width 宽度
+ * @param height 高度
+ * @param options 可选配置
+ * @param options.rx 圆角 X 半径（默认 0）
+ * @param options.ry 圆角 Y 半径（默认 0）
+ * @param options.centered 是否以原点居中（默认 true）
+ */
 declare function rect(width: number, height: number, options?: {
     rx?: number;
     ry?: number;
@@ -348,11 +563,24 @@ declare function square(size: number, options?: {
 declare function circle(radius: number): Diagram;
 /** 创建椭圆 */
 declare function ellipse(rx: number, ry: number): Diagram;
-/** 创建点（小圆） */
+/**
+ * 创建点（小圆）
+ *
+ * @param position 位置（默认 `[0, 0]`）
+ * @param radius 半径（默认 `4`）
+ */
 declare function dot(position?: Vector2, radius?: number): Diagram;
 /** 创建直线 */
 declare function line(from: Vector2, to: Vector2): Diagram;
-/** 创建箭头 */
+/**
+ * 创建箭头
+ *
+ * @param from 起点 `[x, y]`
+ * @param to 终点 `[x, y]`
+ * @param options 可选配置
+ * @param options.headSize 箭头大小（默认 `10`）
+ * @param options.headAngle 箭头角度（默认 `PI / 6`）
+ */
 declare function arrow(from: Vector2, to: Vector2, options?: {
     headSize?: number;
     headAngle?: number;
@@ -378,6 +606,322 @@ declare function polyline(...points: Vector2[]): Diagram;
 declare function arc(radius: number, startAngle: number, endAngle: number): Diagram;
 /** 创建扇形 */
 declare function sector(radius: number, startAngle: number, endAngle: number): Diagram;
+/**
+ * 创建环形扇区（AnnularSector）
+ *
+ * 环形扇区是由两个同心圆弧和两条半径线围成的区域。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.geometry.arc.AnnularSector.html
+ *
+ * @param innerRadius - 内半径
+ * @param outerRadius - 外半径
+ * @param startAngle - 起始角度（弧度）
+ * @param endAngle - 结束角度（弧度）
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建一个 90 度的环形扇区
+ * const sector = annularSector(50, 100, 0, Math.PI / 2)
+ *   .fill('#58C4DD')
+ *   .stroke('#FFFFFF');
+ * ```
+ */
+declare function annularSector(innerRadius: number, outerRadius: number, startAngle: number, endAngle: number): Diagram;
+/**
+ * 创建圆环（Annulus）
+ *
+ * 圆环是由两个同心圆围成的环形区域。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.geometry.arc.Annulus.html
+ *
+ * @param innerRadius - 内半径
+ * @param outerRadius - 外半径
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建一个圆环
+ * const ring = annulus(50, 100)
+ *   .fill('#FC6255')
+ *   .stroke('none');
+ * ```
+ */
+declare function annulus(innerRadius: number, outerRadius: number): Diagram;
+/**
+ * 创建两点间的弧线（ArcBetweenPoints）
+ *
+ * 在两点之间创建一条弧线，通过指定弧度来控制弧线的弯曲程度。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.geometry.arc.ArcBetweenPoints.html
+ *
+ * @param start - 起点坐标
+ * @param end - 终点坐标
+ * @param arcAngle - 弧线弯曲的角度（弧度），正值向左弯曲，负值向右弯曲
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建一条向上弯曲的弧线
+ * const arc = arcBetweenPoints([0, 0], [200, 0], Math.PI / 3)
+ *   .stroke('#58C4DD')
+ *   .strokeWidth(2);
+ * ```
+ */
+declare function arcBetweenPoints(start: Vector2, end: Vector2, arcAngle?: number): Diagram;
+/**
+ * 创建向量（Vector）
+ *
+ * 向量是从原点或指定起点出发的带箭头的线段。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.geometry.line.Vector.html
+ *
+ * @param direction - 向量的方向和大小（相对于起点的偏移）
+ * @param options - 可选配置
+ * @param options.origin - 向量起点，默认为原点 [0, 0]
+ * @param options.color - 向量颜色，默认为黄色 '#FFFF00'
+ * @param options.headSize - 箭头大小，默认为 10
+ * @param options.headAngle - 箭头角度，默认为 PI/6
+ * @param options.strokeWidth - 线条宽度，默认为 3
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建一个从原点指向 (100, 50) 的黄色向量
+ * const v = vector([100, 50]);
+ *
+ * // 创建一个从 (50, 50) 出发的红色向量
+ * const v2 = vector([80, 40], { origin: [50, 50], color: '#FC6255' });
+ * ```
+ */
+declare function vector(direction: Vector2, options?: {
+    origin?: Vector2;
+    color?: string;
+    headSize?: number;
+    headAngle?: number;
+    strokeWidth?: number;
+}): Diagram;
+/**
+ * 创建两点间的花括号（BraceBetweenPoints）
+ *
+ * 在两点之间创建一个装饰性的花括号形状。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.svg.brace.Brace.html
+ *
+ * @param start - 起点坐标
+ * @param end - 终点坐标
+ * @param options - 可选配置
+ * @param options.direction - 花括号朝向的方向向量，正值表示垂直于连线向外
+ * @param options.sharpness - 花括号尖锐程度，值越大越尖锐，默认 0.3
+ * @param options.tipExtent - 中间尖端的伸出程度，默认 0.2
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 在两点之间创建一个向下的花括号
+ * const br = braceBetweenPoints([100, 150], [300, 150])
+ *   .stroke('#FFFF00')
+ *   .strokeWidth(2);
+ * ```
+ */
+declare function braceBetweenPoints(start: Vector2, end: Vector2, options?: {
+    direction?: number;
+    sharpness?: number;
+    tipExtent?: number;
+}): Diagram;
+/**
+ * 创建花括号（Brace）
+ *
+ * 为一个图形对象或两点区间创建装饰性的花括号。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.svg.brace.Brace.html
+ *
+ * @param target - 目标图形或两点数组
+ * @param options - 可选配置
+ * @param options.direction - 花括号朝向，可以是 'UP', 'DOWN', 'LEFT', 'RIGHT' 或自定义向量
+ * @param options.sharpness - 花括号尖锐程度
+ * @param options.buff - 与目标的间距
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 为方块底部添加花括号
+ * const sq = square(100).translate(200, 150);
+ * const br = brace(sq, { direction: 'DOWN' }).stroke('#FFFF00');
+ * ```
+ */
+declare function brace(target: Diagram | [Vector2, Vector2], options?: {
+    direction?: Vector2 | 'UP' | 'DOWN' | 'LEFT' | 'RIGHT';
+    sharpness?: number;
+    buff?: number;
+}): Diagram;
+/**
+ * 创建带标签的花括号（BraceLabel）
+ *
+ * 花括号加上在尖端位置的文本标签。
+ *
+ * @param target - 目标图形或两点数组
+ * @param label - 标签文本
+ * @param options - 可选配置
+ * @param options.direction - 花括号朝向
+ * @param options.fontSize - 标签字体大小
+ * @param options.labelColor - 标签颜色
+ * @param options.sharpness - 花括号尖锐程度
+ * @param options.buff - 与目标的间距
+ * @param options.labelBuff - 标签与花括号尖端的间距
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 为方块添加带标签的花括号
+ * const sq = square(100).translate(200, 150);
+ * const bl = braceLabel(sq, 'width', { direction: 'DOWN' });
+ * ```
+ */
+declare function braceLabel(target: Diagram | [Vector2, Vector2], label: string, options?: {
+    direction?: Vector2 | 'UP' | 'DOWN' | 'LEFT' | 'RIGHT';
+    fontSize?: number;
+    labelColor?: string;
+    sharpness?: number;
+    buff?: number;
+    labelBuff?: number;
+}): Diagram;
+/**
+ * 创建带标签的点（LabeledDot）
+ *
+ * 在指定位置创建一个带有文本标签的圆点。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.geometry.arc.LabeledDot.html
+ *
+ * @param label - 标签文本
+ * @param position - 点的位置，默认为原点
+ * @param options - 可选配置
+ * @param options.radius - 点的半径，如不指定则根据标签大小自动计算
+ * @param options.fontSize - 标签字体大小
+ * @param options.dotColor - 点的填充颜色
+ * @param options.labelColor - 标签颜色
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建一个标签为 "A" 的点
+ * const dotA = labeledDot('A', [100, 100]);
+ *
+ * // 创建一个自定义颜色的标签点
+ * const dotB = labeledDot('B', [200, 100], {
+ *   dotColor: '#FC6255',
+ *   labelColor: '#FFFFFF'
+ * });
+ * ```
+ */
+declare function labeledDot(label: string, position?: Vector2, options?: {
+    radius?: number;
+    fontSize?: number;
+    dotColor?: string;
+    labelColor?: string;
+}): Diagram;
+/**
+ * 创建弯曲箭头（CurvedArrow）
+ *
+ * 在两点之间创建一条弯曲的箭头。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.geometry.line.CurvedArrow.html
+ *
+ * @param start - 起点坐标
+ * @param end - 终点坐标
+ * @param options - 可选配置
+ * @param options.angle - 弧线弯曲角度，默认 PI/4
+ * @param options.headSize - 箭头大小，默认 10
+ * @param options.headAngle - 箭头张角，默认 PI/6
+ * @param options.color - 颜色，默认灰色
+ * @param options.strokeWidth - 线条宽度，默认 2
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建弯曲箭头
+ * const arrow = curvedArrow([100, 150], [300, 150])
+ *   .stroke('#58C4DD');
+ * ```
+ */
+declare function curvedArrow(start: Vector2, end: Vector2, options?: {
+    angle?: number;
+    headSize?: number;
+    headAngle?: number;
+    color?: string;
+    strokeWidth?: number;
+}): Diagram;
+/**
+ * 创建弯曲双向箭头（CurvedDoubleArrow）
+ *
+ * 在两点之间创建一条两端都有箭头的弯曲线。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.geometry.line.CurvedDoubleArrow.html
+ *
+ * @param start - 起点坐标
+ * @param end - 终点坐标
+ * @param options - 可选配置
+ * @param options.angle - 弧线弯曲角度，默认 PI/4
+ * @param options.headSize - 箭头大小，默认 10
+ * @param options.headAngle - 箭头张角，默认 PI/6
+ * @param options.color - 颜色，默认灰色
+ * @param options.strokeWidth - 线条宽度，默认 2
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建弯曲双向箭头
+ * const arrow = curvedDoubleArrow([100, 150], [300, 150])
+ *   .stroke('#FC6255');
+ * ```
+ */
+declare function curvedDoubleArrow(start: Vector2, end: Vector2, options?: {
+    angle?: number;
+    headSize?: number;
+    headAngle?: number;
+    color?: string;
+    strokeWidth?: number;
+}): Diagram;
+/**
+ * 创建肘形线（Elbow）
+ *
+ * 创建一个 L 形状的直角转折线，常用于标记直角。
+ * 参考 Manim: https://docs.manim.community/en/stable/reference/manim.mobject.geometry.line.Elbow.html
+ *
+ * @param width - 肘形线的宽度（两边长度）
+ * @param options - 可选配置
+ * @param options.angle - 旋转角度，默认 0（水平向右，垂直向上）
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建默认肘形线
+ * const elb = elbow(20).translate(100, 100);
+ *
+ * // 创建旋转 45 度的肘形线
+ * const elb2 = elbow(20, { angle: Math.PI / 4 });
+ * ```
+ */
+declare function elbow(width: number, options?: {
+    angle?: number;
+}): Diagram;
+/**
+ * 创建切线（TangentLine）
+ *
+ * 这是一个简化版的切线实现，用于在指定点创建一条切线。
+ * 由于完整的切线需要对曲线求导，这里提供一个基于两点的简化版本。
+ *
+ * @param point - 切点坐标
+ * @param direction - 切线方向向量
+ * @param options - 可选配置
+ * @param options.length - 切线长度，默认 100
+ * @param options.centered - 是否以切点为中心，默认 true
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建一条水平切线
+ * const tangent = tangentLine([200, 150], [1, 0], { length: 80 });
+ *
+ * // 创建一条 45 度切线
+ * const tangent2 = tangentLine([200, 150], [1, -1], { length: 60 });
+ * ```
+ */
+declare function tangentLine(point: Vector2, direction: Vector2, options?: {
+    length?: number;
+    centered?: boolean;
+}): Diagram;
 /** 创建路径 */
 declare function path(commands: PathCommand[]): Diagram;
 /** 从 SVG 路径字符串创建 */
@@ -390,46 +934,256 @@ declare function text(content: string, options?: {
     fontStyle?: string;
     anchor?: 'start' | 'middle' | 'end';
 }): Diagram;
-/** 创建 LaTeX 公式（占位符，需要 MathJax 支持） */
+/** 创建 LaTeX 公式 */
 declare function tex(latex: string, options?: {
     fontSize?: number;
+    color?: string;
 }): Diagram;
-/** 组合多个图形 */
-declare function combine(...diagrams: Diagram[]): Diagram;
-/** 创建空组 */
-declare function group(): Diagram;
-
 /**
- * @locusing/core - SVG 渲染器
+ * 创建段落文本（Paragraph）
  *
- * 将 Diagram 渲染为 SVG 元素
+ * 创建多行文本，支持对齐方式和行高设置。
+ *
+ * @param lines - 文本行数组
+ * @param options - 可选配置
+ * @param options.alignment - 对齐方式：'left', 'center', 'right'
+ * @param options.lineHeight - 行高倍数，默认 1.4
+ * @param options.fontSize - 字体大小
+ * @param options.fontFamily - 字体
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * const para = paragraph([
+ *   'First line of text',
+ *   'Second line of text',
+ *   'Third line of text'
+ * ], { alignment: 'left', fontSize: 14 });
+ * ```
  */
-
+declare function paragraph(lines: string[], options?: {
+    alignment?: 'left' | 'center' | 'right';
+    lineHeight?: number;
+    fontSize?: number;
+    fontFamily?: string;
+}): Diagram;
 /**
- * 渲染 Diagram 到 SVG 元素
+ * 创建项目列表（BulletedList）
+ *
+ * 创建带有项目符号的列表。
+ *
+ * @param items - 列表项数组
+ * @param options - 可选配置
+ * @param options.bulletChar - 项目符号字符，默认 '•'
+ * @param options.indent - 缩进距离，默认 20
+ * @param options.fontSize - 字体大小
+ * @param options.lineHeight - 行高倍数
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * const list = bulletedList([
+ *   'First item',
+ *   'Second item',
+ *   'Third item'
+ * ]);
+ * ```
  */
-declare function renderToSVG(diagram: Diagram, container: SVGSVGElement | HTMLElement, options?: RenderOptions): SVGSVGElement;
+declare function bulletedList(items: string[], options?: {
+    bulletChar?: string;
+    indent?: number;
+    fontSize?: number;
+    lineHeight?: number;
+    fontFamily?: string;
+}): Diagram;
 /**
- * 将 Diagram 转换为 SVG 字符串
+ * 创建代码块（Code）
+ *
+ * 创建用于显示代码的文本块，使用等宽字体。
+ * 注意：这是一个简化版本，不包含语法高亮。
+ *
+ * @param source - 代码源文本
+ * @param options - 可选配置
+ * @param options.fontSize - 字体大小
+ * @param options.theme - 主题：'dark' 或 'light'
+ * @param options.showLineNumbers - 是否显示行号
+ * @param options.lineNumberWidth - 行号宽度
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * const codeBlock = code(`
+ * function hello() {
+ *   console.log("Hello, World!");
+ * }
+ * `, { theme: 'dark', showLineNumbers: true });
+ * ```
  */
-declare function toSVGString(diagram: Diagram, options?: RenderOptions): string;
-
+declare function code(source: string, options?: {
+    fontSize?: number;
+    theme?: 'dark' | 'light';
+    showLineNumbers?: boolean;
+    lineNumberWidth?: number;
+    lineHeight?: number;
+}): Diagram;
 /**
- * @locusing/core - Rough.js 渲染器
+ * 创建标记文本（MarkupText）
  *
- * 将 Diagram 渲染为手绘风格的 SVG
+ * 支持基本标记的富文本。支持的标记：
+ * - <b>粗体</b>
+ * - <i>斜体</i>
+ * - <color=red>颜色</color>
+ *
+ * 注意：这是一个简化版本，实际渲染为普通文本。
+ * 完整的标记支持需要更复杂的解析和渲染逻辑。
+ *
+ * @param content - 包含标记的文本内容
+ * @param options - 可选配置
+ * @param options.fontSize - 字体大小
+ * @param options.fontFamily - 字体
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 注意：标记会被解析但渲染为普通文本
+ * const richText = markupText('Normal and <b>bold</b> text', { fontSize: 16 });
+ * ```
  */
-
+declare function markupText(content: string, options?: {
+    fontSize?: number;
+    fontFamily?: string;
+}): Diagram;
 /**
- * Rough.js 渲染选项
+ * 创建十字形标记（CrossMark）
+ *
+ * 创建一个 X 或 + 形状的十字标记。
+ * 注意：函数名为 crossMark 以避免与向量叉积运算 cross 冲突。
+ *
+ * @param size - 十字的大小（对角线长度或臂长）
+ * @param options - 可选配置
+ * @param options.strokeWidth - 线条宽度
+ * @param options.style - 样式：'x' 为 X 形，'plus' 为 + 形
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 创建 X 形十字
+ * const x = crossMark(40).stroke('#FC6255').translate(100, 100);
+ *
+ * // 创建 + 形十字
+ * const plus = crossMark(40, { style: 'plus' }).stroke('#58C4DD');
+ * ```
  */
-interface RoughRenderOptions extends RenderOptions {
-    roughness?: number;
-    bowing?: number;
-    seed?: number;
-    fillStyle?: 'hachure' | 'solid' | 'zigzag' | 'cross-hatch' | 'dots' | 'dashed' | 'zigzag-line';
-    fillWeight?: number;
-    hachureAngle?: number;
+declare function crossMark(size: number, options?: {
+    strokeWidth?: number;
+    style?: 'x' | 'plus';
+}): Diagram;
+/**
+ * 创建正多角星（RegularPolygram）
+ *
+ * 创建正多角星形，通过密度参数控制星形的尖锐程度。
+ * 与 star 不同，regularPolygram 使用顶点跳跃数来定义形状。
+ *
+ * @param numVertices - 顶点数量
+ * @param density - 连接密度（跳跃数），决定星形的形状
+ * @param radius - 外接圆半径
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 五角星（密度 2）
+ * const star5 = regularPolygram(5, 2, 50).fill('#FFFF00');
+ *
+ * // 七角星（密度 3）
+ * const star7 = regularPolygram(7, 3, 50).fill('#FC6255');
+ * ```
+ */
+declare function regularPolygram(numVertices: number, density: number, radius: number): Diagram;
+/**
+ * 创建镂空图形（Cutout）
+ *
+ * 从外部图形中挖出内部图形的形状。
+ * 注意：这是一个简化实现，通过组合图形和设置填充规则来模拟镂空效果。
+ * 实际的布尔运算需要更复杂的路径操作。
+ *
+ * @param outer - 外部图形
+ * @param inner - 内部图形（被挖出的部分）
+ * @returns Diagram 对象
+ *
+ * @example
+ * ```typescript
+ * // 在正方形中挖出圆形
+ * const sq = square(100);
+ * const circ = circle(30);
+ * const result = cutout(sq, circ).fill('#58C4DD');
+ * ```
+ */
+declare function cutout(outer: Diagram, inner: Diagram): Diagram;
+/** 组合多个图形 */
+declare function combine(...diagrams: Diagram[]): Diagram;
+/** 创建空组 */
+declare function group$1(): Diagram;
+
+/**
+ * @locusing/core - SVG 渲染器
+ *
+ * 将 Diagram 渲染为 SVG 元素
+ *
+ * 支持两种坐标模式：
+ * 1. 像素模式（默认）：原点在左上角，Y 向下
+ * 2. Frame 模式（Manim 风格）：原点在中心，Y 向上
+ */
+
+/**
+ * 渲染 Diagram 到 SVG 元素
+ *
+ * @param diagram - 要渲染的图形
+ * @param container - SVG 元素或 HTML 容器
+ * @param options - 渲染选项
+ * @returns SVG 元素
+ *
+ * @example
+ * ```typescript
+ * // 像素模式（默认）
+ * renderToSVG(diagram, container, { width: 800, height: 600 });
+ *
+ * // Frame 模式（Manim 风格）
+ * renderToSVG(diagram, container, {
+ *   width: 800,
+ *   height: 600,
+ *   frame: true  // 使用默认 16:9 frame
+ * });
+ *
+ * // 自定义 Frame
+ * renderToSVG(diagram, container, {
+ *   width: 800,
+ *   height: 600,
+ *   frame: { width: 20, height: 10 }
+ * });
+ * ```
+ */
+declare function renderToSVG(diagram: Diagram, container: SVGSVGElement | HTMLElement, options?: RenderOptions): SVGSVGElement;
+/**
+ * 将 Diagram 转换为 SVG 字符串
+ */
+declare function toSVGString(diagram: Diagram, options?: RenderOptions): string;
+
+/**
+ * @locusing/core - Rough.js 渲染器
+ *
+ * 将 Diagram 渲染为手绘风格的 SVG
+ */
+
+/**
+ * Rough.js 渲染选项
+ */
+interface RoughRenderOptions extends RenderOptions {
+    roughness?: number;
+    bowing?: number;
+    seed?: number;
+    fillStyle?: 'hachure' | 'solid' | 'zigzag' | 'cross-hatch' | 'dots' | 'dashed' | 'zigzag-line';
+    fillWeight?: number;
+    hachureAngle?: number;
     hachureGap?: number;
 }
 /**
@@ -579,6 +1333,279 @@ declare const easingMap: Record<string, string>;
  */
 declare function getGSAPEasing(easing: string): string;
 
+/**
+ * Camera - 基础相机系统
+ *
+ * 控制 SVG 视口的位置和缩放
+ */
+
+/**
+ * 相机配置
+ */
+interface CameraConfig {
+    /** 视口中心位置 */
+    frameCenter?: Vector2;
+    /** 视口宽度 */
+    frameWidth?: number;
+    /** 视口高度 */
+    frameHeight?: number;
+}
+/**
+ * 视口帧
+ */
+interface Frame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Camera 类
+ *
+ * 管理 SVG 视口，支持平移和缩放
+ */
+declare class Camera {
+    protected _center: Vector2;
+    protected _width: number;
+    protected _height: number;
+    /**
+     * 创建相机
+     * @param config - 相机配置
+     */
+    constructor(config?: CameraConfig);
+    /**
+     * 获取视口中心
+     */
+    get center(): Vector2;
+    /**
+     * 设置视口中心
+     */
+    set center(value: Vector2);
+    /**
+     * 获取视口宽度
+     */
+    get width(): number;
+    /**
+     * 设置视口宽度
+     */
+    set width(value: number);
+    /**
+     * 获取视口高度
+     */
+    get height(): number;
+    /**
+     * 设置视口高度
+     */
+    set height(value: number);
+    /**
+     * 获取可视区域
+     */
+    getFrame(): Frame;
+    /**
+     * 移动相机到指定位置
+     * @param point - 目标位置
+     */
+    moveTo(point: Vector2): this;
+    /**
+     * 相对移动相机
+     * @param delta - 移动增量
+     */
+    moveBy(delta: Vector2): this;
+    /**
+     * 缩放视口
+     * @param factor - 缩放因子（>1 缩小视野，<1 放大视野）
+     */
+    zoom(factor: number): this;
+    /**
+     * 设置视口大小
+     * @param width - 宽度
+     * @param height - 高度
+     */
+    setSize(width: number, height: number): this;
+    /**
+     * 重置相机到初始状态
+     */
+    reset(): this;
+    /**
+     * 获取 SVG viewBox 字符串
+     */
+    getViewBox(): string;
+    /**
+     * 应用相机设置到 SVG 元素
+     * @param svg - SVG 元素
+     */
+    applyToSVG(svg: SVGSVGElement): void;
+    /**
+     * 将屏幕坐标转换为世界坐标
+     * @param screenPoint - 屏幕坐标
+     * @param svgWidth - SVG 元素宽度
+     * @param svgHeight - SVG 元素高度
+     */
+    screenToWorld(screenPoint: Vector2, svgWidth: number, svgHeight: number): Vector2;
+    /**
+     * 将世界坐标转换为屏幕坐标
+     * @param worldPoint - 世界坐标
+     * @param svgWidth - SVG 元素宽度
+     * @param svgHeight - SVG 元素高度
+     */
+    worldToScreen(worldPoint: Vector2, svgWidth: number, svgHeight: number): Vector2;
+    /**
+     * 检查点是否在视口内
+     * @param point - 要检查的点
+     */
+    isPointInView(point: Vector2): boolean;
+    /**
+     * 获取当前缩放级别
+     * @param baseWidth - 基准宽度（默认 400）
+     */
+    getZoomLevel(baseWidth?: number): number;
+    /**
+     * 设置缩放级别
+     * @param level - 目标缩放级别
+     * @param baseWidth - 基准宽度（默认 400）
+     */
+    setZoomLevel(level: number, baseWidth?: number): this;
+    /**
+     * 克隆相机
+     */
+    clone(): Camera;
+}
+/**
+ * 创建相机
+ * @param config - 相机配置
+ */
+declare function createCamera(config?: CameraConfig): Camera;
+
+/**
+ * MovingCamera - 支持动画的相机
+ *
+ * 扩展基础相机，添加平滑移动和动画功能
+ */
+
+/**
+ * 移动相机配置
+ */
+interface MovingCameraConfig extends CameraConfig {
+    /** 默认动画时长 */
+    defaultDuration?: number;
+    /** 默认缓动函数 */
+    defaultEasing?: string;
+}
+/**
+ * 相机动画选项
+ */
+interface CameraAnimationOptions$1 {
+    /** 动画时长（秒） */
+    duration?: number;
+    /** 缓动函数名称 */
+    easing?: string;
+    /** 动画完成回调 */
+    onComplete?: () => void;
+    /** 动画更新回调 */
+    onUpdate?: (progress: number) => void;
+}
+/**
+ * 相机动画状态
+ */
+interface CameraAnimationState {
+    /** 是否正在动画 */
+    isAnimating: boolean;
+    /** 起始帧 */
+    startFrame: Frame;
+    /** 目标帧 */
+    endFrame: Frame;
+    /** 开始时间 */
+    startTime: number;
+    /** 动画时长 */
+    duration: number;
+    /** 缓动函数 */
+    easing: (t: number) => number;
+    /** 完成回调 */
+    onComplete?: (() => void) | undefined;
+    /** 更新回调 */
+    onUpdate?: ((progress: number) => void) | undefined;
+}
+/**
+ * MovingCamera 类
+ *
+ * 支持平滑动画的相机
+ */
+declare class MovingCamera extends Camera {
+    protected defaultDuration: number;
+    protected defaultEasing: string;
+    protected animationState: CameraAnimationState | null;
+    protected animationFrameId: number | null;
+    /**
+     * 创建移动相机
+     * @param config - 相机配置
+     */
+    constructor(config?: MovingCameraConfig);
+    /**
+     * 平滑移动到位置
+     * @param point - 目标位置
+     * @param options - 动画选项
+     */
+    animateMoveTo(point: Vector2, options?: CameraAnimationOptions$1): Promise<void>;
+    /**
+     * 平滑缩放
+     * @param factor - 缩放因子
+     * @param options - 动画选项
+     */
+    animateZoom(factor: number, options?: CameraAnimationOptions$1): Promise<void>;
+    /**
+     * 平滑设置缩放级别
+     * @param level - 目标缩放级别
+     * @param options - 动画选项
+     */
+    animateZoomLevel(level: number, options?: CameraAnimationOptions$1): Promise<void>;
+    /**
+     * 平滑移动并缩放到框定指定区域
+     * @param frame - 目标区域
+     * @param options - 动画选项
+     */
+    animateToFrame(frame: Frame, options?: CameraAnimationOptions$1): Promise<void>;
+    /**
+     * 聚焦到图形（根据图形边界框调整视口）
+     * @param target - 目标图形
+     * @param padding - 边距比例（0-1）
+     * @param options - 动画选项
+     */
+    focusOn(target: Diagram, padding?: number, options?: CameraAnimationOptions$1): Promise<void>;
+    /**
+     * 获取图形边界（简化实现）
+     */
+    protected getDiagramBounds(_target: Diagram): Frame;
+    /**
+     * 停止当前动画
+     */
+    stopAnimation(): void;
+    /**
+     * 检查是否正在动画
+     */
+    isAnimating(): boolean;
+    /**
+     * 启动动画
+     */
+    protected startAnimation(startFrame: Frame, endFrame: Frame, duration: number, easingName: string, onComplete?: () => void, onUpdate?: (progress: number) => void): Promise<void>;
+    /**
+     * 动画帧更新
+     */
+    protected animateFrame: () => void;
+    /**
+     * 获取缓动函数
+     */
+    protected getEasingFunction(name: string): (t: number) => number;
+    /**
+     * 克隆移动相机
+     */
+    clone(): MovingCamera;
+}
+/**
+ * 创建移动相机
+ * @param config - 相机配置
+ */
+declare function createMovingCamera(config?: MovingCameraConfig): MovingCamera;
+
 /**
  * @locusing/animate - Scene 场景管理
  *
@@ -591,32 +1618,96 @@ interface SceneConfig {
     background?: string;
     fps?: number;
     rough?: boolean;
+    /** 相机配置 */
+    camera?: CameraConfig;
 }
 /**
  * Scene 类 - Manim 风格的场景管理
  *
- * 使用方式：
+ * 使用方式一：继承并实现 construct 方法
  * ```typescript
  * class MyScene extends Scene {
  *   construct() {
- *     const sq = square(100).fill('#EA580C');
+ *     const sq = square(0.5).fill('#EA580C');
  *     this.play(Create(sq));
  *     this.wait(1);
  *     this.play(FadeOut(sq));
  *   }
  * }
+ * // 在编辑器或文档中使用
+ * play(MyScene);
+ * ```
+ *
+ * 使用方式二：传入容器直接使用
+ * ```typescript
+ * const scene = new MyScene();
+ * scene.setup(svgElement, { width: 800, height: 600 });
+ * scene.construct();
  * ```
  */
+/** 内部配置类型（不包含 camera，因为 camera 作为独立实例管理） */
+interface InternalSceneConfig {
+    width: number;
+    height: number;
+    background: string;
+    fps: number;
+    rough: boolean;
+}
+/** Updater 函数类型 */
+type UpdaterFunction = (diagram: Diagram, dt: number) => void;
+/** Updater 配置 */
+interface UpdaterConfig {
+    /** Updater 函数 */
+    fn: UpdaterFunction;
+    /** 关联的图形 */
+    diagram: Diagram;
+}
 declare abstract class Scene {
-    protected container: HTMLElement;
+    protected container: HTMLElement | SVGSVGElement;
     protected svg: SVGSVGElement;
-    protected config: Required<SceneConfig>;
+    /** Y 轴翻转组，所有内容都渲染到这个组中 */
+    protected flipGroup: SVGGElement;
+    protected config: InternalSceneConfig;
     protected timeline: Timeline;
     protected objects: Map<string, Diagram>;
     protected currentTime: number;
-    constructor(container: HTMLElement, config?: SceneConfig);
+    protected _isSetup: boolean;
+    /** Frame 逻辑尺寸（用于坐标系统） */
+    protected frameWidth: number;
+    protected frameHeight: number;
+    /** 相机实例 */
+    camera: Camera;
+    /** Updaters 列表 */
+    protected updaters: UpdaterConfig[];
+    /** 上一帧时间（用于计算 dt） */
+    protected lastFrameTime: number;
+    /** 动画帧 ID */
+    protected animationFrameId: number | null;
+    /**
+     * 创建 Scene 实例
+     * @param container - 可选的容器元素。如果不传，需要后续调用 setup() 方法
+     * @param config - 场景配置
+     */
+    constructor(container?: HTMLElement | SVGSVGElement, config?: SceneConfig);
+    /**
+     * 初始化场景（内部方法）
+     */
+    private initScene;
+    /**
+     * 更新相机的 viewBox 到 SVG
+     * 在相机移动或缩放后调用此方法
+     */
+    updateCameraViewBox(): void;
+    /**
+     * 设置场景（延迟初始化）
+     * 用于编辑器和文档中的使用场景，在实例化后调用
+     *
+     * @param svgOrContainer - SVG 元素或容器元素
+     * @param config - 场景配置
+     */
+    setup(svgOrContainer: SVGSVGElement | HTMLElement, config?: SceneConfig): void;
     /** 子类实现此方法来构建动画 */
-    abstract construct(): void;
+    abstract construct(): void | Promise<void>;
     /**
      * 添加图形到场景（不带动画）
      */
@@ -636,12 +1727,60 @@ declare abstract class Scene {
      * 等待指定时间
      */
     wait(seconds?: number): void;
+    /**
+     * 为图形添加 updater
+     *
+     * Updater 会在每一帧被调用，用于创建动态效果
+     *
+     * @param diagram - 要添加 updater 的图形
+     * @param fn - updater 函数，接收图形和时间增量
+     *
+     * @example
+     * ```typescript
+     * const dot = circle(0.1).fill('#EA580C');
+     * this.add(dot);
+     *
+     * // 让 dot 跟随鼠标或按时间变化
+     * this.addUpdater(dot, (d, dt) => {
+     *   const t = this.getTime();
+     *   return d.move([Math.cos(t), Math.sin(t)]);
+     * });
+     * ```
+     */
+    addUpdater(diagram: Diagram, fn: UpdaterFunction): void;
+    /**
+     * 移除图形的 updater
+     */
+    removeUpdater(diagram: Diagram, fn?: UpdaterFunction): void;
+    /**
+     * 清除所有 updaters
+     */
+    clearUpdaters(): void;
+    /**
+     * 获取当前时间（秒）
+     */
+    getTime(): number;
+    /**
+     * 启动帧循环（用于 updaters）
+     */
+    protected startFrameLoop(): void;
+    /**
+     * 停止帧循环
+     */
+    protected stopFrameLoop(): void;
     /**
      * 运行场景
      */
     render(): Promise<void>;
     /**
-     * 渲染单个图形到 SVG
+     * 启动动画播放
+     * 调用此方法开始播放 construct() 中构建的动画
+     *
+     * @returns Promise 在动画完成后 resolve
+     */
+    start(): Promise<void>;
+    /**
+     * 渲染单个图形到 SVG（使用 Frame 模式）
      */
     protected renderDiagram(diagram: Diagram): SVGElement | null;
     /**
@@ -659,7 +1798,7 @@ declare abstract class Scene {
     /**
      * 获取配置
      */
-    getConfig(): Required<SceneConfig>;
+    getConfig(): InternalSceneConfig;
     /**
      * 导出为 SVG 字符串
      */
@@ -842,6 +1981,61 @@ declare class ValueTracker {
     };
 }
 
+/**
+ * MovingCameraScene - 支持相机动画的场景
+ *
+ * 扩展基础 Scene，使用 MovingCamera 实现平滑的相机移动和缩放动画
+ */
+
+interface MovingCameraSceneConfig extends Omit<SceneConfig, 'camera'> {
+    /** 移动相机配置 */
+    camera?: MovingCameraConfig;
+}
+/**
+ * MovingCameraScene 类
+ *
+ * 支持相机动画的场景，使用 MovingCamera 替代普通 Camera
+ *
+ * @example
+ * ```typescript
+ * class MyScene extends MovingCameraScene {
+ *   construct() {
+ *     const sq = square(1).fill(Colors.BLUE);
+ *     this.add(sq);
+ *
+ *     // 相机缩放动画
+ *     this.play(CameraZoom(this.camera, 2));
+ *
+ *     // 相机移动到对象
+ *     this.play(CameraMove(this.camera, sq.center()));
+ *   }
+ * }
+ * ```
+ */
+declare abstract class MovingCameraScene extends Scene {
+    /** 移动相机实例（覆盖父类的 camera 类型） */
+    camera: MovingCamera;
+    /**
+     * 创建 MovingCameraScene 实例
+     * @param container - 可选的容器元素
+     * @param config - 场景配置
+     */
+    constructor(container?: HTMLElement | SVGSVGElement, config?: MovingCameraSceneConfig);
+    /**
+     * 初始化场景（重写以使用 MovingCamera）
+     */
+    setup(svgOrContainer: SVGSVGElement | HTMLElement, config?: MovingCameraSceneConfig): void;
+}
+/**
+ * 创建简单的 MovingCameraScene（不需要继承）
+ */
+declare function createMovingCameraScene(container: HTMLElement, buildFn: (scene: SimpleMovingCameraScene) => void, config?: MovingCameraSceneConfig): SimpleMovingCameraScene;
+declare class SimpleMovingCameraScene extends MovingCameraScene {
+    private buildFn;
+    constructor(container: HTMLElement, buildFn: (scene: SimpleMovingCameraScene) => void, config?: MovingCameraSceneConfig);
+    construct(): void;
+}
+
 /**
  * 创建类动画 - Create, Write, DrawBorderThenFill
  */
@@ -878,6 +2072,24 @@ declare function GrowFromEdge(target: Diagram, edge?: 'LEFT' | 'RIGHT' | 'TOP' |
  * SpinInFromNothing - 旋转出现
  */
 declare function SpinInFromNothing(target: Diagram, options?: CreateOptions): Animation;
+/**
+ * Uncreate - 逆向创建动画
+ *
+ * Create 的反向效果，让图形从终点向起点擦除
+ */
+declare function Uncreate(target: Diagram, options?: CreateOptions): Animation;
+/**
+ * Unwrite - 逆向书写动画
+ *
+ * Write 的反向效果，逐字消失文本
+ */
+declare function Unwrite(target: Diagram, options?: CreateOptions): Animation;
+/**
+ * ShrinkToCenter - 收缩到中心消失
+ *
+ * GrowFromCenter 的反向效果，图形收缩到中心点并消失
+ */
+declare function ShrinkToCenter(target: Diagram, options?: CreateOptions): Animation;
 
 /**
  * 淡入淡出动画 - FadeIn, FadeOut
@@ -954,15 +2166,47 @@ declare function Morphing(source: Diagram, target: Diagram, options?: TransformO
  * 智能匹配源和目标中的相似形状进行变换
  */
 declare function TransformMatchingShapes(source: Diagram, target: Diagram, options?: TransformOptions): Animation;
-
 /**
- * 移动动画 - Shift, MoveTo, MoveAlongPath
+ * TransformMatchingTex 选项
  */
-
+interface TransformMatchingTexOptions extends TransformOptions {
+    /** 键映射：将源中的符号映射到目标中的对应符号 */
+    keyMap?: Record<string, string>;
+}
 /**
- * Shift - 平移动画
+ * TransformMatchingTex - 匹配 TeX 变换
+ *
+ * 智能匹配 LaTeX 公式中的相同部分进行变换
  */
-declare function Shift(target: Diagram, offset: Vector2, options?: AnimationConfig): Animation;
+declare function TransformMatchingTex(source: Diagram, target: Diagram, options?: TransformMatchingTexOptions): Animation;
+/**
+ * ClockwiseTransform - 顺时针变换
+ *
+ * 图形沿顺时针方向旋转变换到目标状态
+ */
+declare function ClockwiseTransform(source: Diagram, target: Diagram, options?: TransformOptions): Animation;
+/**
+ * CounterclockwiseTransform - 逆时针变换
+ *
+ * 图形沿逆时针方向旋转变换到目标状态
+ */
+declare function CounterclockwiseTransform(source: Diagram, target: Diagram, options?: TransformOptions): Animation;
+/**
+ * TransformFromCopy - 从副本变换
+ *
+ * 创建源图形的副本，然后将副本变换到目标位置
+ * 源图形保持不变
+ */
+declare function TransformFromCopy(source: Diagram, target: Diagram, options?: TransformOptions): Animation;
+
+/**
+ * 移动动画 - Shift, MoveTo, MoveAlongPath
+ */
+
+/**
+ * Shift - 平移动画
+ */
+declare function Shift(target: Diagram, offset: Vector2, options?: AnimationConfig): Animation;
 /**
  * MoveTo - 移动到指定位置
  */
@@ -984,16 +2228,35 @@ declare function Rotating(target: Diagram, options?: AnimationConfig & {
     angularVelocity?: number;
     aboutPoint?: Vector2;
 }): Animation;
-/**
- * Scale - 缩放动画
- */
-declare function Scale(target: Diagram, factor: number | [number, number], options?: AnimationConfig & {
-    aboutPoint?: Vector2;
-}): Animation;
 /**
  * ScaleInPlace - 原地缩放
  */
 declare function ScaleInPlace(target: Diagram, factor: number, options?: AnimationConfig): Animation;
+/**
+ * Swap 选项
+ */
+interface SwapOptions extends AnimationConfig {
+    /** 交换路径类型 */
+    path?: 'arc' | 'straight';
+}
+/**
+ * CyclicReplace - 循环替换位置
+ *
+ * 多个图形循环交换位置（A→B, B→C, C→A）
+ */
+declare function CyclicReplace(diagrams: Diagram[], options?: AnimationConfig): Animation;
+/**
+ * Swap - 交换两个图形位置
+ *
+ * 两个图形互换位置，可选直线或弧线路径
+ */
+declare function Swap(a: Diagram, b: Diagram, options?: SwapOptions): Animation;
+/**
+ * FadeToColor - 渐变到目标颜色
+ *
+ * 图形颜色平滑过渡到目标颜色
+ */
+declare function FadeToColor(target: Diagram, color: string, options?: AnimationConfig): Animation;
 
 /**
  * 指示动画 - Indicate, Circumscribe, Wiggle, Flash
@@ -1033,6 +2296,68 @@ declare function ShowPassingFlash(target: Diagram, options?: IndicateOptions): A
 declare function Blink(target: Diagram, options?: IndicateOptions & {
     times?: number;
 }): Animation;
+/**
+ * ApplyWave 选项
+ */
+interface ApplyWaveOptions extends IndicateOptions {
+    /** 波浪方向: 'horizontal' | 'vertical' */
+    direction?: 'horizontal' | 'vertical';
+    /** 波浪幅度 */
+    amplitude?: number;
+    /** 波浪频率 */
+    frequency?: number;
+}
+/**
+ * ApplyWave - 波浪效果
+ *
+ * 对图形应用波浪状变形效果
+ */
+declare function ApplyWave(target: Diagram, options?: ApplyWaveOptions): Animation;
+/**
+ * FocusOn 选项
+ */
+interface FocusOnOptions extends IndicateOptions {
+    /** 聚焦缩放比例 */
+    scaleAbout?: number;
+    /** 周围区域暗化程度 */
+    dimSurroundings?: number;
+}
+/**
+ * FocusOn - 聚焦效果
+ *
+ * 放大目标图形，同时淡化背景
+ */
+declare function FocusOn(target: Diagram, options?: FocusOnOptions): Animation;
+/**
+ * SpiralIn 选项
+ */
+interface SpiralInOptions extends IndicateOptions {
+    /** 螺旋圈数 */
+    spirals?: number;
+    /** 起始距离 */
+    startDistance?: number;
+}
+/**
+ * SpiralIn - 螺旋进入
+ *
+ * 图形从外部螺旋进入到目标位置
+ */
+declare function SpiralIn(target: Diagram, options?: SpiralInOptions): Animation;
+/**
+ * PhaseFlow 选项
+ */
+interface PhaseFlowOptions extends IndicateOptions {
+    /** 相位函数 */
+    phaseFunc?: (x: number, y: number, t: number) => [number, number];
+    /** 流动速度 */
+    flowSpeed?: number;
+}
+/**
+ * PhaseFlow - 相位流动
+ *
+ * 基于相位函数的流动效果，常用于向量场可视化
+ */
+declare function PhaseFlow(target: Diagram, options?: PhaseFlowOptions): Animation;
 
 /**
  * 组合动画 - AnimationGroup, Succession, LaggedStart
@@ -1091,6 +2416,131 @@ declare function UpdateFromAlphaFunc(target: Diagram, updateFn: (diagram: Diagra
  */
 declare function Homotopy(target: Diagram, homotopyFn: (x: number, y: number, t: number) => [number, number], options?: AnimationConfig): Animation;
 
+/**
+ * 文本动画 - AddTextLetterByLetter, RemoveTextLetterByLetter, Typewriter
+ *
+ * Phase 2 Batch 2: 文本相关的动画效果
+ */
+
+/**
+ * 文本动画选项
+ */
+interface TextAnimationOptions extends AnimationConfig {
+    /** 每个字符的显示时间 */
+    timePerChar?: number;
+}
+/**
+ * 打字机动画选项
+ */
+interface TypewriterOptions extends TextAnimationOptions {
+    /** 是否显示光标 */
+    cursor?: boolean;
+    /** 光标字符 */
+    cursorChar?: string;
+    /** 光标闪烁间隔（秒） */
+    cursorBlinkInterval?: number;
+}
+/**
+ * AddTextLetterByLetter - 逐字显示文本
+ *
+ * 从第一个字符开始，逐个显示文本内容
+ */
+declare function AddTextLetterByLetter(target: Diagram, options?: TextAnimationOptions): Animation;
+/**
+ * RemoveTextLetterByLetter - 逐字移除文本
+ *
+ * 从最后一个字符开始，逐个隐藏文本内容
+ */
+declare function RemoveTextLetterByLetter(target: Diagram, options?: TextAnimationOptions): Animation;
+/**
+ * Typewriter - 打字机效果
+ *
+ * 模拟打字机逐字输入的效果，可选显示闪烁光标
+ */
+declare function Typewriter(target: Diagram, options?: TypewriterOptions): Animation;
+
+/**
+ * Camera Animations - 相机动画效果
+ *
+ * 提供相机缩放、移动等动画效果
+ */
+
+interface CameraAnimationOptions {
+    /** 动画时长（秒） */
+    duration?: number;
+}
+/**
+ * 相机缩放动画
+ *
+ * @param camera - 相机实例
+ * @param factor - 缩放因子（>1 视野变大/缩小，<1 视野变小/放大）
+ * @param options - 动画选项
+ *
+ * @example
+ * ```typescript
+ * // 视野扩大 2 倍（缩小显示）
+ * this.play(CameraZoom(this.camera, 2));
+ *
+ * // 视野缩小到一半（放大显示）
+ * this.play(CameraZoom(this.camera, 0.5));
+ * ```
+ */
+declare function CameraZoom(camera: Camera, factor: number, options?: CameraAnimationOptions): Animation;
+/**
+ * 相机移动动画
+ *
+ * @param camera - 相机实例
+ * @param target - 目标位置（点坐标或 Diagram）
+ * @param options - 动画选项
+ *
+ * @example
+ * ```typescript
+ * // 移动到指定坐标
+ * this.play(CameraMove(this.camera, [3, 2]));
+ *
+ * // 移动到图形的中心
+ * this.play(CameraMove(this.camera, mySquare));
+ * ```
+ */
+declare function CameraMove(camera: Camera, targetPosition: Vector2 | Diagram, options?: CameraAnimationOptions): Animation;
+/**
+ * 相机自动缩放动画
+ *
+ * 自动调整相机视野以包含所有指定的对象
+ *
+ * @param camera - 相机实例
+ * @param targets - 要包含的对象列表
+ * @param options - 动画选项
+ *
+ * @example
+ * ```typescript
+ * // 自动缩放以包含所有对象
+ * this.play(CameraAutoZoom(this.camera, [square, circle], { margin: 0.5 }));
+ * ```
+ */
+declare function CameraAutoZoom(camera: Camera, targets: Diagram[], options?: CameraAnimationOptions & {
+    margin?: number;
+}): Animation;
+/**
+ * 相机重置动画
+ *
+ * 将相机恢复到默认状态（原点居中，16x9 视野）
+ *
+ * @param camera - 相机实例
+ * @param options - 动画选项
+ */
+declare function CameraReset(camera: Camera, options?: CameraAnimationOptions): Animation;
+/**
+ * 相机帧动画
+ *
+ * 直接设置相机的视口帧
+ *
+ * @param camera - 相机实例
+ * @param targetFrame - 目标帧
+ * @param options - 动画选项
+ */
+declare function CameraSetFrame(camera: Camera, targetFrame: Frame, options?: CameraAnimationOptions): Animation;
+
 /**
  * @locusing/geometry - 坐标系
  *
@@ -1109,6 +2559,9 @@ interface AxesConfig {
     axisColor?: string;
     gridColor?: string;
     labelSize?: number;
+    tickSize?: number;
+    strokeWidth?: number;
+    headSize?: number;
 }
 /**
  * Axes - 二维坐标系
@@ -1167,6 +2620,10 @@ declare class NumberLine {
         showTicks?: boolean;
         showLabels?: boolean;
         color?: string;
+        tickSize?: number;
+        strokeWidth?: number;
+        labelSize?: number;
+        headSize?: number;
     });
     private build;
     n2p(n: number): Vector2;
@@ -1185,6 +2642,8 @@ declare function PolarAxes(config?: {
     origin?: Vector2;
     divisions?: number;
     color?: string;
+    strokeWidth?: number;
+    headSize?: number;
 }): Diagram;
 
 /**
@@ -1212,15 +2671,17 @@ declare function parallelLine(point: Vector2, lineStart: Vector2, lineEnd: Vecto
 /**
  * 角度标记
  */
-declare function angleMarker(vertex: Vector2, a: Vector2, b: Vector2, options?: {
+declare function angleMarker(p1: Vector2, vertex: Vector2, p2: Vector2, options?: {
     radius?: number;
     color?: string;
     label?: string;
+    labelSize?: number;
+    strokeWidth?: number;
 }): Diagram;
 /**
  * 直角标记
  */
-declare function rightAngleMarker(vertex: Vector2, a: Vector2, b: Vector2, size?: number): Diagram;
+declare function rightAngleMarker(p1: Vector2, vertex: Vector2, p2: Vector2, size?: number, strokeWidth?: number): Diagram;
 /**
  * 过三点的圆
  */
@@ -1252,7 +2713,7 @@ declare function orthocenter(a: Vector2, b: Vector2, c: Vector2): Vector2;
 /**
  * 中线
  */
-declare function median(vertex: Vector2, opposite1: Vector2, opposite2: Vector2): Diagram;
+declare function median$1(vertex: Vector2, opposite1: Vector2, opposite2: Vector2): Diagram;
 /**
  * 角平分线
  */
@@ -1408,4 +2869,2994 @@ declare function polarConstraint(cx: number, cy: number, minRadius: number, maxR
  */
 declare function functionConstraint(fn: (x: number) => number, minX: number, maxX: number): (p: Vector2) => Vector2;
 
-export { type Animation, type AnimationConfig, AnimationGroup, type AnimationGroupOptions, type AnimationOptions, type AnimationStatus, ApplyMethod, type ArcShape, Axes, type AxesConfig, type BaseShape, Blink, type ButtonConfig, type CircleShape, Circumscribe, type CircumscribeOptions, Create, type CreateOptions, DEGREES, DL, DOWN, DR, Diagram, DrawBorderThenFill, type EasingFunction, type EllipseShape, FadeIn, FadeInFrom, FadeInFromDown, FadeInFromLeft, FadeInFromRight, FadeInFromUp, type FadeOptions, FadeOut, FadeOutTo, FadeTransform, Flash, type FlashOptions, type GroupShape, GrowFromCenter, GrowFromEdge, GrowFromPoint, Homotopy, IDENTITY, Indicate, type IndicateOptions, Interactive, type InteractiveOptions, LEFT, LaggedStart, LaggedStartMap, type LineShape, type LocatorConfig, type LocatorOptions, type Matrix3, Morphing, MoveAlongPath, type MoveOptions, MoveTo, MoveToTarget, NumberLine, NumberPlane, ORIGIN, PI, type PathCommand, type PathShape, type Point, PolarAxes, type PolygonShape, type PolylineShape, RIGHT, type RectShape, type RenderOptions, ReplacementTransform, Rotate, type RotateOptions, Rotating, type RoughRenderOptions, Scale, ScaleInPlace, type ScaleOptions, Scene, type SceneConfig, type Shape, type ShapeType, Shift, ShowPassingFlash, type SliderConfig, type SliderOptions, SpinInFromNothing, type Style, Succession, TAU, type TextShape, type TextStyle, Timeline, type TimelineOptions, Transform, TransformMatchingShapes, type TransformOptions, UL, UP, UR, UpdateFromAlphaFunc, UpdateFromFunc, V2, V3, ValueTracker, type Vector2, type Vector3, Wait, Wiggle, type WiggleOptions, Write, add, altitude, angle, angleBetween, angleBisector, angleMarker, applyMatrix, arc, arrow, centroid, circle, circleConstraint, circleIntersections, circumscribedCircle, clamp, combine, createInteractive, createScene, createTimeline, cross, cubicBezier, degToRad, distance, div, dot, doubleArrow, easing, easingMap, ellipse, equilateralTriangle, footOfPerpendicular, functionConstraint, getGSAPEasing, gridConstraint, group, inscribedCircle, length, lerp, lerpNumber, line, lineConstraint, lineIntersection, mapRange, matrixMultiply, median, midpoint, mul, normalize, orthocenter, parallelLine, path, pathFromString, perpendicular, perpendicularBisector, perpendicularLine, polarConstraint, polygon, polyline, quadraticBezier, radToDeg, rect, rectConstraint, reflect, reflectOverPoint, reflectPoint, reflectPointOverLine, regularPolygon, renderToRough, renderToSVG, rightAngleMarker, rotate, rotationMatrix, roughPresets, sampleParametric, scaleMatrix, sector, square, star, sub, tex, text, toSVGString, translationMatrix, triangle, dot$1 as vectorDot };
+/**
+ * ManimColor - 颜色处理类
+ *
+ * 提供颜色转换、操作和插值功能
+ */
+/**
+ * RGB 颜色值
+ */
+type RGB = [number, number, number];
+/**
+ * HSL 颜色值
+ */
+type HSL = [number, number, number];
+/**
+ * ManimColor 类
+ *
+ * 支持多种格式的颜色输入和操作
+ */
+declare class ManimColor {
+    private r;
+    private g;
+    private b;
+    /**
+     * 创建颜色
+     * @param value - 颜色值，支持 hex 字符串、RGB 数组或数字
+     */
+    constructor(value: string | number | RGB);
+    /**
+     * 转换为 Hex 格式
+     */
+    toHex(): string;
+    /**
+     * 转换为 RGB 数组
+     */
+    toRGB(): RGB;
+    /**
+     * 转换为 HSL 数组
+     */
+    toHSL(): HSL;
+    /**
+     * 转换为 CSS rgb() 格式
+     */
+    toRGBString(): string;
+    /**
+     * 提亮颜色
+     * @param amount - 提亮程度 (0-1)
+     */
+    lighten(amount: number): ManimColor;
+    /**
+     * 加深颜色
+     * @param amount - 加深程度 (0-1)
+     */
+    darken(amount: number): ManimColor;
+    /**
+     * 增加饱和度
+     * @param amount - 增加程度 (0-1)
+     */
+    saturate(amount: number): ManimColor;
+    /**
+     * 降低饱和度
+     * @param amount - 降低程度 (0-1)
+     */
+    desaturate(amount: number): ManimColor;
+    /**
+     * 颜色插值
+     * @param other - 目标颜色
+     * @param t - 插值系数 (0-1)
+     */
+    interpolate(other: ManimColor, t: number): ManimColor;
+    /**
+     * 混合颜色
+     * @param other - 另一个颜色
+     * @param weight - 混合权重 (0-1)，0 表示完全使用当前颜色
+     */
+    mix(other: ManimColor, weight?: number): ManimColor;
+    /**
+     * 获取补色
+     */
+    complement(): ManimColor;
+    /**
+     * 调整透明度（返回 rgba 字符串）
+     * @param alpha - 透明度 (0-1)
+     */
+    withAlpha(alpha: number): string;
+    /**
+     * 从 HSL 创建颜色
+     */
+    static fromHSL(h: number, s: number, l: number): ManimColor;
+    /**
+     * 创建随机颜色
+     */
+    static random(): ManimColor;
+    /**
+     * 创建渐变色数组
+     * @param color1 - 起始颜色
+     * @param color2 - 结束颜色
+     * @param steps - 步数
+     */
+    static gradient(color1: ManimColor, color2: ManimColor, steps: number): ManimColor[];
+}
+/**
+ * 颜色插值函数（工具函数）
+ * @param color1 - 起始颜色 (hex)
+ * @param color2 - 结束颜色 (hex)
+ * @param t - 插值系数 (0-1)
+ */
+declare function interpolateColor(color1: string, color2: string, t: number): string;
+/**
+ * 颜色渐变函数（工具函数）
+ * @param colors - 颜色数组
+ * @param t - 插值系数 (0-1)
+ */
+declare function colorGradient(colors: string[], t: number): string;
+
+/**
+ * Manim 预定义颜色常量
+ *
+ * 包含 Manim 标准颜色和扩展颜色
+ */
+/**
+ * Manim 标准颜色集
+ */
+declare const Colors: {
+    readonly WHITE: "#FFFFFF";
+    readonly BLACK: "#000000";
+    readonly GRAY_A: "#F1F5F9";
+    readonly GRAY_B: "#CBD5E1";
+    readonly GRAY_C: "#94A3B8";
+    readonly GRAY_D: "#64748B";
+    readonly GRAY_E: "#334155";
+    readonly GREY_A: "#F1F5F9";
+    readonly GREY_B: "#CBD5E1";
+    readonly GREY_C: "#94A3B8";
+    readonly GREY_D: "#64748B";
+    readonly GREY_E: "#334155";
+    readonly LIGHT_GRAY: "#CBD5E1";
+    readonly LIGHT_GREY: "#CBD5E1";
+    readonly DARK_GRAY: "#64748B";
+    readonly DARK_GREY: "#64748B";
+    readonly BLUE: "#38BDF8";
+    readonly BLUE_A: "#E0F2FE";
+    readonly BLUE_B: "#BAE6FD";
+    readonly BLUE_C: "#38BDF8";
+    readonly BLUE_D: "#0284C7";
+    readonly BLUE_E: "#0C4A6E";
+    readonly PURE_BLUE: "#3B82F6";
+    readonly DARK_BLUE: "#1E40AF";
+    readonly TEAL: "#2DD4BF";
+    readonly TEAL_A: "#CCFBF1";
+    readonly TEAL_B: "#99F6E4";
+    readonly TEAL_C: "#2DD4BF";
+    readonly TEAL_D: "#0F766E";
+    readonly TEAL_E: "#134E4A";
+    readonly GREEN: "#4ADE80";
+    readonly GREEN_A: "#DCFCE7";
+    readonly GREEN_B: "#86EFAC";
+    readonly GREEN_C: "#4ADE80";
+    readonly GREEN_D: "#16A34A";
+    readonly GREEN_E: "#14532D";
+    readonly PURE_GREEN: "#22C55E";
+    readonly YELLOW: "#FACC15";
+    readonly YELLOW_A: "#FEF9C3";
+    readonly YELLOW_B: "#FEF08A";
+    readonly YELLOW_C: "#FACC15";
+    readonly YELLOW_D: "#CA8A04";
+    readonly YELLOW_E: "#713F12";
+    readonly GOLD: "#FBBF24";
+    readonly GOLD_A: "#FDE68A";
+    readonly GOLD_B: "#FCD34D";
+    readonly GOLD_C: "#FBBF24";
+    readonly GOLD_D: "#B45309";
+    readonly GOLD_E: "#78350F";
+    readonly RED: "#FB7185";
+    readonly RED_A: "#FFE4E6";
+    readonly RED_B: "#FECDD3";
+    readonly RED_C: "#FB7185";
+    readonly RED_D: "#E11D48";
+    readonly RED_E: "#881337";
+    readonly PURE_RED: "#F43F5E";
+    readonly MAROON: "#C084FC";
+    readonly MAROON_A: "#E9D5FF";
+    readonly MAROON_B: "#D8B4FE";
+    readonly MAROON_C: "#C084FC";
+    readonly MAROON_D: "#9333EA";
+    readonly MAROON_E: "#581C87";
+    readonly PURPLE: "#A78BFA";
+    readonly PURPLE_A: "#EDE9FE";
+    readonly PURPLE_B: "#DDD6FE";
+    readonly PURPLE_C: "#A78BFA";
+    readonly PURPLE_D: "#7C3AED";
+    readonly PURPLE_E: "#4C1D95";
+    readonly PINK: "#E879F9";
+    readonly PINK_A: "#FAE8FF";
+    readonly PINK_B: "#F0ABFC";
+    readonly PINK_C: "#E879F9";
+    readonly PINK_D: "#C026D3";
+    readonly PINK_E: "#701A75";
+    readonly LIGHT_PINK: "#F5D0FE";
+    readonly ORANGE: "#FB923C";
+    readonly ORANGE_A: "#FFEDD5";
+    readonly ORANGE_B: "#FDBA74";
+    readonly ORANGE_C: "#FB923C";
+    readonly ORANGE_D: "#EA580C";
+    readonly ORANGE_E: "#7C2D12";
+    readonly LIGHT_BROWN: "#D6D3D1";
+    readonly DARK_BROWN: "#57534E";
+    /** 用于坐标轴 - 使用低饱和度的颜色避免抢眼 */
+    readonly X_COLOR: "#94A3B8";
+    /** 用于坐标轴 */
+    readonly Y_COLOR: "#94A3B8";
+    /** 用于坐标轴 */
+    readonly Z_COLOR: "#94A3B8";
+    /** 文本默认颜色 */
+    readonly TEXT_COLOR: "#F8FAFC";
+    /** 背景默认颜色 - 深空灰蓝 */
+    readonly BACKGROUND_COLOR: "#0F172A";
+    /** Manim 默认背景色兼容 */
+    readonly MANIM_BACKGROUND: "#0F172A";
+};
+/**
+ * 颜色类型
+ */
+type ColorName = keyof typeof Colors;
+/**
+ * 根据名称获取颜色
+ */
+declare function getColor(name: ColorName): string;
+/**
+ * 颜色色阶（用于渐变和可视化）
+ */
+declare const ColorScales: {
+    /** 蓝-红渐变 */
+    readonly BLUE_TO_RED: readonly ["#38BDF8", "#2DD4BF", "#4ADE80", "#FACC15", "#FB923C", "#FB7185"];
+    /** 冷色调 */
+    readonly COOL: readonly ["#0C4A6E", "#38BDF8", "#2DD4BF", "#4ADE80"];
+    /** 暖色调 */
+    readonly WARM: readonly ["#FACC15", "#FB923C", "#FB7185", "#C084FC"];
+    /** 彩虹 */
+    readonly RAINBOW: readonly ["#FB7185", "#FB923C", "#FACC15", "#4ADE80", "#38BDF8", "#A78BFA"];
+    /** 灰度 */
+    readonly GRAYSCALE: readonly ["#FFFFFF", "#F1F5F9", "#CBD5E1", "#94A3B8", "#64748B", "#334155", "#000000"];
+    /** 蓝色色阶 */
+    readonly BLUES: readonly ["#E0F2FE", "#BAE6FD", "#38BDF8", "#0284C7", "#0C4A6E"];
+    /** 红色色阶 */
+    readonly REDS: readonly ["#FFE4E6", "#FECDD3", "#FB7185", "#E11D48", "#881337"];
+    /** 绿色色阶 */
+    readonly GREENS: readonly ["#DCFCE7", "#86EFAC", "#4ADE80", "#16A34A", "#14532D"];
+};
+/**
+ * 3B1B 风格颜色（3Blue1Brown 视频常用）
+ */
+declare const ThreeB1BColors: {
+    /** 3B1B 蓝色 */
+    readonly BLUE: "#58C4DD";
+    /** 3B1B 棕色 */
+    readonly BROWN: "#CD853F";
+    /** 3B1B 金色 */
+    readonly GOLD: "#FFD700";
+    /** 3B1B 绿色 */
+    readonly GREEN: "#83C167";
+    /** 3B1B 红色 */
+    readonly RED: "#FC6255";
+    /** 3B1B 紫色 */
+    readonly PURPLE: "#9A72AC";
+    /** 3B1B 黄色 */
+    readonly YELLOW: "#FFFF00";
+    /** 3B1B 背景色 */
+    readonly BACKGROUND: "#1a1a2e";
+};
+
+/**
+ * @locusing/theme - 主题系统类型定义
+ *
+ * 定义 Design Tokens 作为统一风格的唯一事实来源
+ * 参考: plan/09-integration-principles-unified-rendering.md
+ */
+
+/** 语义颜色 tokens */
+interface SemanticColors {
+    /** 主色调 */
+    primary: string;
+    /** 次要色调 */
+    secondary: string;
+    /** 强调色 */
+    accent: string;
+    /** 成功色 */
+    success: string;
+    /** 警告色 */
+    warning: string;
+    /** 错误色 */
+    error: string;
+    /** 信息色 */
+    info: string;
+}
+/** 背景颜色 tokens */
+interface BackgroundColors {
+    /** 主背景 */
+    default: string;
+    /** 表面背景（卡片、面板等） */
+    surface: string;
+    /** 悬浮层背景 */
+    overlay: string;
+}
+/** 文本颜色 tokens */
+interface TextColors {
+    /** 默认文本 */
+    default: string;
+    /** 次要文本 */
+    muted: string;
+    /** 反色文本 */
+    inverse: string;
+}
+/** 坐标轴颜色 tokens */
+interface AxisColors {
+    /** X 轴颜色 */
+    x: string;
+    /** Y 轴颜色 */
+    y: string;
+    /** Z 轴颜色（3D） */
+    z: string;
+}
+/** 颜色 tokens 集合 */
+interface ColorTokens {
+    /** 语义颜色 */
+    semantic: SemanticColors;
+    /** 背景颜色 */
+    background: BackgroundColors;
+    /** 文本颜色 */
+    text: TextColors;
+    /** 坐标轴颜色 */
+    axis: AxisColors;
+    /** 扩展调色板（可自定义） */
+    palette: Record<string, string>;
+}
+/** 线宽 tokens */
+interface StrokeWidthTokens {
+    /** 细线 (1px) */
+    thin: number;
+    /** 默认线宽 (2px) */
+    default: number;
+    /** 粗线 (3px) */
+    thick: number;
+    /** 加粗线 (4px) */
+    bold: number;
+    /** 超粗线 (6px) */
+    heavy: number;
+}
+/** 虚线模式 tokens */
+interface DashPatterns {
+    /** 点线 */
+    dotted: string;
+    /** 短虚线 */
+    dashed: string;
+    /** 长虚线 */
+    longDash: string;
+    /** 点划线 */
+    dashDot: string;
+}
+/** 描边 tokens 集合 */
+interface StrokeTokens {
+    /** 线宽 */
+    width: StrokeWidthTokens;
+    /** 线端样式 */
+    linecap: 'butt' | 'round' | 'square';
+    /** 拐角样式 */
+    linejoin: 'miter' | 'round' | 'bevel';
+    /** 虚线模式 */
+    dash: DashPatterns;
+}
+/** 字体族 tokens */
+interface FontFamilyTokens {
+    /** 默认字体 */
+    default: string;
+    /** 等宽字体 */
+    mono: string;
+    /** 数学字体（LaTeX 渲染用） */
+    math: string;
+}
+/** 字号 tokens */
+interface FontSizeTokens {
+    /** 超小 (10px) */
+    xs: number;
+    /** 小 (12px) */
+    sm: number;
+    /** 中等 (14px) */
+    md: number;
+    /** 大 (16px) */
+    lg: number;
+    /** 超大 (20px) */
+    xl: number;
+    /** 标题 (24px) */
+    '2xl': number;
+}
+/** 字重 tokens */
+interface FontWeightTokens {
+    /** 正常 */
+    normal: number;
+    /** 中等 */
+    medium: number;
+    /** 粗体 */
+    bold: number;
+}
+/** 排版 tokens 集合 */
+interface TypographyTokens {
+    /** 字体族 */
+    fontFamily: FontFamilyTokens;
+    /** 字号 */
+    fontSize: FontSizeTokens;
+    /** 字重 */
+    fontWeight: FontWeightTokens;
+}
+/** 间距 tokens */
+interface SpacingTokens {
+    /** 无间距 */
+    none: number;
+    /** 超小间距 (2px) */
+    xs: number;
+    /** 小间距 (4px) */
+    sm: number;
+    /** 中等间距 (8px) */
+    md: number;
+    /** 大间距 (16px) */
+    lg: number;
+    /** 超大间距 (24px) */
+    xl: number;
+    /** 特大间距 (32px) */
+    '2xl': number;
+}
+/** 布局 tokens 集合 */
+interface LayoutTokens {
+    /** 间距 */
+    spacing: SpacingTokens;
+    /** 网格大小（Frame 模式下的逻辑单位） */
+    gridSize: number;
+    /** 默认 buffer 距离（nextTo 等方法使用） */
+    buffer: number;
+}
+/** 动画时长 tokens */
+interface DurationTokens {
+    /** 快速 (0.15s) */
+    fast: number;
+    /** 默认 (0.3s) */
+    default: number;
+    /** 中等 (0.5s) */
+    medium: number;
+    /** 慢速 (1s) */
+    slow: number;
+    /** 非常慢 (2s) */
+    verySlow: number;
+}
+/** 缓动函数 tokens */
+interface EasingTokens {
+    /** 线性 */
+    linear: string;
+    /** 缓入 */
+    easeIn: string;
+    /** 缓出 */
+    easeOut: string;
+    /** 缓入缓出 */
+    easeInOut: string;
+    /** 弹性 */
+    elastic: string;
+    /** 反弹 */
+    bounce: string;
+    /** 平滑（Manim 默认） */
+    smooth: string;
+}
+/** 动画 tokens 集合 */
+interface AnimationTokens {
+    /** 动画时长 */
+    duration: DurationTokens;
+    /** 缓动函数 */
+    easing: EasingTokens;
+    /** 默认错开延迟（stagger） */
+    staggerDelay: number;
+}
+/** 主题 tokens 集合（所有 Design Tokens） */
+interface ThemeTokens {
+    /** 颜色 tokens */
+    color: ColorTokens;
+    /** 描边 tokens */
+    stroke: StrokeTokens;
+    /** 排版 tokens */
+    typography: TypographyTokens;
+    /** 布局 tokens */
+    layout: LayoutTokens;
+    /** 动画 tokens */
+    animation: AnimationTokens;
+}
+/** 预计算的样式快捷方式 */
+interface ThemeStyles {
+    /** 默认描边样式（线条、路径等） */
+    defaultStroke: Style;
+    /** 默认填充样式（形状等） */
+    defaultFill: Style;
+    /** 默认文本样式 */
+    defaultText: TextStyle;
+    /** 坐标轴样式 */
+    axis: Style;
+    /** 网格线样式 */
+    grid: Style;
+}
+/** 完整的主题定义 */
+interface Theme {
+    /** 主题名称 */
+    name: string;
+    /** Design Tokens */
+    tokens: ThemeTokens;
+    /** 预计算的样式 */
+    styles: ThemeStyles;
+}
+/** 深度 Partial 类型（用于主题覆盖） */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+/** 主题覆盖选项 */
+type ThemeOverrides = DeepPartial<ThemeTokens>;
+
+/**
+ * @locusing/theme - 预定义主题
+ *
+ * 提供默认主题和 Manim 风格主题
+ */
+
+/** 默认主题 tokens */
+declare const defaultTokens: ThemeTokens;
+/** 默认主题（深色背景） */
+declare const defaultTheme: Theme;
+/** Manim/3B1B 风格主题 */
+declare const manimTheme: Theme;
+/** 浅色主题 */
+declare const lightTheme: Theme;
+/**
+ * 创建自定义主题
+ *
+ * @param name 主题名称
+ * @param overrides 要覆盖的 tokens
+ * @param baseTheme 基础主题（默认为 defaultTheme）
+ * @returns 新的主题
+ *
+ * @example
+ * ```typescript
+ * const myTheme = createTheme('custom', {
+ *   color: {
+ *     semantic: { primary: '#FF0000' }
+ *   },
+ *   stroke: {
+ *     width: { default: 3 }
+ *   }
+ * });
+ * ```
+ */
+declare function createTheme(name: string, overrides: ThemeOverrides, baseTheme?: Theme): Theme;
+/** 所有预定义主题 */
+declare const themes: {
+    readonly default: Theme;
+    readonly manim: Theme;
+    readonly light: Theme;
+};
+/** 主题名称类型 */
+type ThemeName = keyof typeof themes;
+/**
+ * 根据名称获取主题
+ */
+declare function getTheme(name: ThemeName): Theme;
+
+/**
+ * @locusing/theme - 主题上下文
+ *
+ * 提供全局主题管理和样式生成工具
+ */
+
+/**
+ * 获取当前主题
+ */
+declare function getCurrentTheme(): Theme;
+/**
+ * 设置当前主题
+ */
+declare function setCurrentTheme(theme: Theme): void;
+/**
+ * 使用主题覆盖创建临时主题并设置
+ */
+declare function applyThemeOverrides(overrides: ThemeOverrides): Theme;
+/**
+ * 重置为默认主题
+ */
+declare function resetTheme(): void;
+/**
+ * 从当前主题获取默认描边样式
+ */
+declare function getDefaultStrokeStyle(): Style;
+/**
+ * 从当前主题获取默认填充样式
+ */
+declare function getDefaultFillStyle(): Style;
+/**
+ * 从当前主题获取默认文本样式
+ */
+declare function getDefaultTextStyle(): TextStyle;
+/**
+ * 获取主题 tokens
+ */
+declare function getTokens(): ThemeTokens;
+/**
+ * 创建基于语义颜色的样式
+ */
+declare function semanticStyle(semantic: keyof ThemeTokens['color']['semantic'], options?: {
+    filled?: boolean;
+    strokeWidth?: keyof ThemeTokens['stroke']['width'];
+    opacity?: number;
+}): Style;
+/**
+ * 创建虚线样式
+ */
+declare function dashedStyle(pattern?: keyof ThemeTokens['stroke']['dash'], options?: {
+    color?: string;
+    strokeWidth?: keyof ThemeTokens['stroke']['width'];
+}): Style;
+/**
+ * 创建坐标轴样式（X/Y/Z）
+ */
+declare function axisColorStyle(axis: 'x' | 'y' | 'z', options?: {
+    filled?: boolean;
+    strokeWidth?: keyof ThemeTokens['stroke']['width'];
+}): Style;
+/**
+ * 获取动画时长
+ */
+declare function getDuration(speed?: keyof ThemeTokens['animation']['duration']): number;
+/**
+ * 获取缓动函数
+ */
+declare function getEasing(type?: keyof ThemeTokens['animation']['easing']): string;
+/**
+ * 获取间距值
+ */
+declare function getSpacing(size?: keyof ThemeTokens['layout']['spacing']): number;
+/**
+ * 获取默认 buffer 值
+ */
+declare function getBuffer(): number;
+
+/**
+ * Graph - 图论可视化
+ *
+ * 支持无向图和有向图的可视化
+ */
+
+/**
+ * 顶点配置
+ */
+interface VertexConfig {
+    /** 顶点半径 */
+    radius?: number;
+    /** 顶点颜色 */
+    color?: string;
+    /** 标签字体大小 */
+    labelSize?: number;
+    /** 标签颜色 */
+    labelColor?: string;
+}
+/**
+ * 边配置
+ */
+interface EdgeConfig {
+    /** 边宽度 */
+    strokeWidth?: number;
+    /** 边颜色 */
+    color?: string;
+    /** 是否弯曲 */
+    curved?: boolean;
+    /** 弯曲程度 */
+    curvature?: number;
+    /** 箭头大小（有向图） */
+    headSize?: number;
+}
+/**
+ * 布局类型
+ */
+type LayoutType = 'circular' | 'spring' | 'tree' | 'grid' | 'random';
+/**
+ * 自定义布局函数
+ */
+type LayoutFunction = (vertices: string[], edges: [string, string][]) => Map<string, Vector2>;
+/**
+ * 图配置
+ */
+interface GraphConfig {
+    /** 顶点列表 */
+    vertices: string[] | number;
+    /** 边列表 */
+    edges: [string | number, string | number][];
+    /** 布局类型或自定义布局函数 */
+    layout?: LayoutType | LayoutFunction;
+    /** 是否有向图 */
+    directed?: boolean;
+    /** 是否显示标签 */
+    labels?: boolean;
+    /** 顶点配置 */
+    vertexConfig?: VertexConfig;
+    /** 边配置 */
+    edgeConfig?: EdgeConfig;
+    /** 布局缩放 */
+    scale?: number;
+    /** 布局中心 */
+    center?: Vector2;
+}
+/**
+ * Graph 类
+ *
+ * 表示一个图结构并提供可视化
+ */
+declare class Graph {
+    protected _vertices: string[];
+    protected _edges: [string, string][];
+    protected _positions: Map<string, Vector2>;
+    protected _directed: boolean;
+    protected _showLabels: boolean;
+    protected _vertexConfig: Required<VertexConfig>;
+    protected _edgeConfig: Required<EdgeConfig>;
+    protected _scale: number;
+    protected _center: Vector2;
+    constructor(config: GraphConfig);
+    /**
+     * 计算布局
+     */
+    protected computeLayout(layout?: LayoutType | LayoutFunction): Map<string, Vector2>;
+    /**
+     * 获取顶点位置
+     */
+    getVertexPosition(id: string): Vector2 | undefined;
+    /**
+     * 设置顶点位置
+     */
+    setVertexPosition(id: string, position: Vector2): this;
+    /**
+     * 获取所有顶点
+     */
+    getVertices(): string[];
+    /**
+     * 获取所有边
+     */
+    getEdges(): [string, string][];
+    /**
+     * 添加顶点
+     */
+    addVertex(id: string, position?: Vector2): this;
+    /**
+     * 添加边
+     */
+    addEdge(from: string, to: string): this;
+    /**
+     * 移除顶点
+     */
+    removeVertex(id: string): this;
+    /**
+     * 移除边
+     */
+    removeEdge(from: string, to: string): this;
+    /**
+     * 高亮路径
+     */
+    highlightPath(path: string[], color?: string): Diagram;
+    /**
+     * 转换为 Diagram
+     */
+    toDiagram(): Diagram;
+}
+/**
+ * DiGraph 类 - 有向图
+ */
+declare class DiGraph extends Graph {
+    constructor(config: Omit<GraphConfig, 'directed'>);
+    /**
+     * 获取入边
+     */
+    getInEdges(vertex: string): [string, string][];
+    /**
+     * 获取出边
+     */
+    getOutEdges(vertex: string): [string, string][];
+    /**
+     * 获取入度
+     */
+    getInDegree(vertex: string): number;
+    /**
+     * 获取出度
+     */
+    getOutDegree(vertex: string): number;
+}
+/**
+ * 圆形布局
+ */
+declare function circularLayout(vertices: string[], scale?: number, startAngle?: number): Map<string, Vector2>;
+/**
+ * 弹簧布局（力导向）
+ */
+declare function springLayout(vertices: string[], edges: [string, string][], scale?: number, iterations?: number): Map<string, Vector2>;
+/**
+ * 树形布局
+ */
+declare function treeLayout(vertices: string[], edges: [string, string][], scale?: number): Map<string, Vector2>;
+/**
+ * 网格布局
+ */
+declare function gridLayout(vertices: string[], scale?: number, columns?: number): Map<string, Vector2>;
+/**
+ * 随机布局
+ */
+declare function randomLayout(vertices: string[], scale?: number): Map<string, Vector2>;
+/**
+ * 创建无向图
+ */
+declare function graph(config: GraphConfig): Graph;
+/**
+ * 创建有向图
+ */
+declare function digraph(config: Omit<GraphConfig, 'directed'>): DiGraph;
+
+/**
+ * Dagre 布局适配器
+ *
+ * 将 Dagre 的布局算法集成到 Locusing，只使用其计算能力
+ * 渲染仍由 Locusing 统一控制
+ *
+ * 参考: plan/09-integration-principles-unified-rendering.md
+ */
+
+/** Dagre 布局方向 */
+type DagreRankDir = 'TB' | 'BT' | 'LR' | 'RL';
+/** Dagre 边路由模式 */
+type DagreEdgeRouting = 'polyline' | 'ortho' | 'spline';
+/** Dagre 节点对齐 */
+type DagreAlign = 'UL' | 'UR' | 'DL' | 'DR';
+/** Dagre 排名器算法 */
+type DagreRanker = 'network-simplex' | 'tight-tree' | 'longest-path';
+/** Dagre 布局配置 */
+interface DagreLayoutConfig {
+    /** 布局方向 (TB=上到下, BT=下到上, LR=左到右, RL=右到左) */
+    rankDir?: DagreRankDir;
+    /** 节点对齐方式 */
+    align?: DagreAlign;
+    /** 节点水平间距 */
+    nodeSep?: number;
+    /** 边间距 */
+    edgeSep?: number;
+    /** 层级间距 */
+    rankSep?: number;
+    /** 边距 */
+    marginX?: number;
+    marginY?: number;
+    /** 排名算法 */
+    ranker?: DagreRanker;
+}
+/** 边路由点 */
+interface EdgeRoute {
+    /** 边的起点 */
+    source: string;
+    /** 边的终点 */
+    target: string;
+    /** 路由点列表 */
+    points: Vector2[];
+}
+/** Dagre 布局结果 */
+interface DagreLayoutResult {
+    /** 节点位置 */
+    positions: Map<string, Vector2>;
+    /** 边路由 */
+    routes: EdgeRoute[];
+    /** 图的宽度 */
+    width: number;
+    /** 图的高度 */
+    height: number;
+}
+/**
+ * 使用 Dagre 进行层次布局
+ *
+ * @param vertices 顶点 ID 列表
+ * @param edges 边列表 [source, target]
+ * @param config 布局配置
+ * @returns 布局结果（节点位置和边路由）
+ *
+ * @example
+ * ```typescript
+ * const result = dagreLayout(
+ *   ['A', 'B', 'C', 'D'],
+ *   [['A', 'B'], ['A', 'C'], ['B', 'D'], ['C', 'D']],
+ *   { rankDir: 'TB', rankSep: 50 }
+ * );
+ *
+ * // 使用位置创建 Graph
+ * const graph = new Graph({
+ *   vertices: ['A', 'B', 'C', 'D'],
+ *   edges: [['A', 'B'], ['A', 'C'], ['B', 'D'], ['C', 'D']],
+ *   layout: (v, e) => result.positions
+ * });
+ * ```
+ */
+declare function dagreLayout(vertices: string[], edges: [string, string][], config?: DagreLayoutConfig): DagreLayoutResult;
+/**
+ * 创建 Dagre 布局函数（适配 Graph.layout 接口）
+ *
+ * @param config 布局配置
+ * @returns 符合 LayoutFunction 签名的函数
+ *
+ * @example
+ * ```typescript
+ * const graph = new Graph({
+ *   vertices: ['A', 'B', 'C'],
+ *   edges: [['A', 'B'], ['B', 'C']],
+ *   layout: createDagreLayoutFn({ rankDir: 'LR' })
+ * });
+ * ```
+ */
+declare function createDagreLayoutFn(config?: DagreLayoutConfig): (vertices: string[], edges: [string, string][]) => Map<string, Vector2>;
+/**
+ * 层次布局（简化接口）
+ *
+ * 与现有布局函数保持一致的 API
+ */
+declare function hierarchicalLayout(vertices: string[], edges: [string, string][], scale?: number, direction?: DagreRankDir): Map<string, Vector2>;
+/**
+ * 正交布局（适合流程图）
+ */
+declare function orthogonalLayout(vertices: string[], edges: [string, string][], scale?: number, direction?: DagreRankDir): Map<string, Vector2>;
+/**
+ * 带分组的层次布局
+ */
+declare function groupedHierarchicalLayout(vertices: string[], edges: [string, string][], groups: Map<string, string[]>, config?: DagreLayoutConfig): DagreLayoutResult;
+
+/**
+ * Table - 表格可视化
+ *
+ * 支持数据表格的创建和样式配置
+ */
+
+/**
+ * 表格配置
+ */
+interface TableConfig {
+    /** 表格数据 (行 × 列) */
+    data: (string | number | Diagram)[][];
+    /** 行高（统一或每行）*/
+    rowHeights?: number | number[];
+    /** 列宽（统一或每列）*/
+    colWidths?: number | number[];
+    /** 水平线（true=全部, 数组=指定行后） */
+    hLines?: boolean | number[];
+    /** 垂直线（true=全部, 数组=指定列后） */
+    vLines?: boolean | number[];
+    /** 是否有表头行 */
+    headerRow?: boolean;
+    /** 是否有表头列 */
+    headerCol?: boolean;
+    /** 单元格内边距 */
+    cellPadding?: number;
+    /** 字体大小 */
+    fontSize?: number;
+    /** 文字颜色 */
+    textColor?: string;
+    /** 边框颜色 */
+    lineColor?: string;
+    /** 边框宽度 */
+    lineWidth?: number;
+    /** 表头背景色 */
+    headerBackground?: string;
+    /** 交替行背景色 */
+    alternateRowColor?: string;
+}
+/**
+ * 表格单元格信息
+ */
+interface CellInfo {
+    diagram: Diagram;
+    row: number;
+    col: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Table 类 - 表格可视化
+ */
+declare class Table {
+    protected _data: (string | number | Diagram)[][];
+    protected _rowHeights: number[];
+    protected _colWidths: number[];
+    protected _hLines: number[];
+    protected _vLines: number[];
+    protected _headerRow: boolean;
+    protected _headerCol: boolean;
+    protected _cellPadding: number;
+    protected _fontSize: number;
+    protected _textColor: string;
+    protected _lineColor: string;
+    protected _lineWidth: number;
+    protected _headerBackground: string | undefined;
+    protected _alternateRowColor: string | undefined;
+    protected _cells: CellInfo[][];
+    protected _totalWidth: number;
+    protected _totalHeight: number;
+    /**
+     * 创建表格
+     */
+    constructor(config: TableConfig);
+    /**
+     * 构建单元格
+     */
+    protected buildCells(): CellInfo[][];
+    /**
+     * 获取单元格
+     */
+    getCell(row: number, col: number): Diagram | undefined;
+    /**
+     * 获取整行
+     */
+    getRow(row: number): Diagram[];
+    /**
+     * 获取整列
+     */
+    getCol(col: number): Diagram[];
+    /**
+     * 高亮单元格
+     */
+    highlightCell(row: number, col: number, color?: string): Diagram;
+    /**
+     * 高亮整行
+     */
+    highlightRow(row: number, color?: string): Diagram;
+    /**
+     * 高亮整列
+     */
+    highlightCol(col: number, color?: string): Diagram;
+    /**
+     * 获取行数
+     */
+    get numRows(): number;
+    /**
+     * 获取列数
+     */
+    get numCols(): number;
+    /**
+     * 获取总宽度
+     */
+    get width(): number;
+    /**
+     * 获取总高度
+     */
+    get height(): number;
+    /**
+     * 转换为 Diagram
+     */
+    toDiagram(): Diagram;
+}
+/**
+ * 创建表格
+ */
+declare function table(config: TableConfig): Table;
+/**
+ * 创建整数表格
+ */
+declare function integerTable(data: number[][], config?: Omit<TableConfig, 'data'>): Table;
+/**
+ * 创建小数表格
+ */
+declare function decimalTable(data: number[][], config?: Omit<TableConfig, 'data'> & {
+    precision?: number;
+}): Table;
+/**
+ * 创建数学表格（LaTeX 字符串）
+ */
+declare function mathTable(data: string[][], config?: Omit<TableConfig, 'data'>): Table;
+
+/**
+ * Matrix Display - 矩阵可视化
+ *
+ * 支持矩阵的创建和样式配置，包括括号显示
+ */
+
+/**
+ * 矩阵配置
+ */
+interface MatrixConfig {
+    /** 矩阵数据 */
+    data: (number | string)[][];
+    /** 括号类型 */
+    brackets?: 'round' | 'square' | 'curly' | 'pipe' | 'none';
+    /** 水平间距 */
+    hBuff?: number;
+    /** 垂直间距 */
+    vBuff?: number;
+    /** 字体大小 */
+    fontSize?: number;
+    /** 文字颜色 */
+    textColor?: string;
+    /** 括号颜色 */
+    bracketColor?: string;
+    /** 括号宽度 */
+    bracketWidth?: number;
+}
+/**
+ * 矩阵元素信息
+ */
+interface EntryInfo {
+    diagram: Diagram;
+    row: number;
+    col: number;
+    x: number;
+    y: number;
+}
+/**
+ * MatrixDisplay 类 - 矩阵可视化
+ */
+declare class MatrixDisplay {
+    protected _data: (number | string)[][];
+    protected _brackets: 'round' | 'square' | 'curly' | 'pipe' | 'none';
+    protected _hBuff: number;
+    protected _vBuff: number;
+    protected _fontSize: number;
+    protected _textColor: string;
+    protected _bracketColor: string;
+    protected _bracketWidth: number;
+    protected _entries: EntryInfo[][];
+    protected _numRows: number;
+    protected _numCols: number;
+    protected _contentWidth: number;
+    protected _contentHeight: number;
+    /**
+     * 创建矩阵显示
+     */
+    constructor(config: MatrixConfig);
+    /**
+     * 构建矩阵条目
+     */
+    protected buildEntries(): EntryInfo[][];
+    /**
+     * 获取矩阵元素
+     */
+    getEntry(row: number, col: number): Diagram | undefined;
+    /**
+     * 获取整行
+     */
+    getRow(row: number): Diagram[];
+    /**
+     * 获取整列
+     */
+    getColumn(col: number): Diagram[];
+    /**
+     * 高亮元素
+     */
+    highlightEntry(row: number, col: number, color?: string): Diagram;
+    /**
+     * 获取括号
+     */
+    getBrackets(): [Diagram, Diagram];
+    /**
+     * 获取行数
+     */
+    get numRows(): number;
+    /**
+     * 获取列数
+     */
+    get numCols(): number;
+    /**
+     * 获取总宽度
+     */
+    get width(): number;
+    /**
+     * 获取总高度
+     */
+    get height(): number;
+    /**
+     * 转换为 Diagram
+     */
+    toDiagram(): Diagram;
+}
+/**
+ * 创建矩阵显示
+ */
+declare function matrix(data: (number | string)[][], config?: Omit<MatrixConfig, 'data'>): MatrixDisplay;
+/**
+ * 创建整数矩阵
+ */
+declare function integerMatrix(data: number[][], config?: Omit<MatrixConfig, 'data'>): MatrixDisplay;
+/**
+ * 创建小数矩阵
+ */
+declare function decimalMatrix(data: number[][], config?: Omit<MatrixConfig, 'data'> & {
+    precision?: number;
+}): MatrixDisplay;
+/**
+ * 创建行列式
+ */
+declare function determinant(data: number[][], config?: Omit<MatrixConfig, 'data' | 'brackets'>): MatrixDisplay;
+
+/**
+ * D3 Scale 适配器
+ *
+ * 遵循 "Compute-first" 原则：
+ * - D3 只负责计算比例尺映射
+ * - Locusing 负责所有渲染
+ */
+/** 比例尺基础接口 */
+interface Scale<Domain, Range> {
+    /** 将域值映射到范围值 */
+    (value: Domain): Range;
+    /** 获取域 */
+    domain(): Domain[];
+    /** 获取范围 */
+    range(): Range[];
+    /** 复制比例尺 */
+    copy(): Scale<Domain, Range>;
+}
+/** 连续比例尺（支持反转和插值） */
+interface ContinuousScale extends Scale<number, number> {
+    /** 将范围值反转映射到域值 */
+    invert(value: number): number;
+    /** 生成刻度值 */
+    ticks(count?: number): number[];
+    /** 格式化刻度标签 */
+    tickFormat(count?: number, specifier?: string): (d: number) => string;
+    /** 设置是否截断到范围 */
+    clamp(clamp: boolean): ContinuousScale;
+    /** 设置是否使用漂亮的域值 */
+    nice(count?: number): ContinuousScale;
+}
+/** 序数比例尺 */
+interface OrdinalScale<Domain extends string | number> extends Scale<Domain, string> {
+    /** 未知值的返回值 */
+    unknown(): string | undefined;
+}
+/** 带状比例尺（用于柱状图） */
+interface BandScale<Domain extends string | number> extends Scale<Domain, number> {
+    /** 获取带宽 */
+    bandwidth(): number;
+    /** 获取步长 */
+    step(): number;
+    /** 设置内边距 */
+    paddingInner(padding: number): BandScale<Domain>;
+    /** 设置外边距 */
+    paddingOuter(padding: number): BandScale<Domain>;
+    /** 设置对齐方式 */
+    align(align: number): BandScale<Domain>;
+}
+/** 点比例尺 */
+interface PointScale<Domain extends string | number> extends Scale<Domain, number> {
+    /** 获取步长 */
+    step(): number;
+    /** 设置外边距 */
+    padding(padding: number): PointScale<Domain>;
+    /** 设置对齐方式 */
+    align(align: number): PointScale<Domain>;
+}
+/** 比例尺配置 */
+interface ScaleConfig<Domain, Range> {
+    domain: Domain[];
+    range: Range[];
+}
+/** 连续比例尺配置 */
+interface ContinuousScaleConfig extends ScaleConfig<number, number> {
+    clamp?: boolean;
+    nice?: boolean | number;
+}
+/** 带状比例尺配置 */
+interface BandScaleConfig<D extends string | number> extends ScaleConfig<D, number> {
+    paddingInner?: number;
+    paddingOuter?: number;
+    align?: number;
+}
+/**
+ * 创建线性比例尺
+ *
+ * @example
+ * ```ts
+ * const x = linearScale({ domain: [0, 100], range: [0, 800] });
+ * x(50); // 400
+ * x.invert(400); // 50
+ * x.ticks(5); // [0, 20, 40, 60, 80, 100]
+ * ```
+ */
+declare function linearScale(config: ContinuousScaleConfig): ContinuousScale;
+/**
+ * 创建对数比例尺
+ *
+ * @example
+ * ```ts
+ * const x = logScale({ domain: [1, 1000], range: [0, 300] });
+ * x(10); // 100
+ * x(100); // 200
+ * ```
+ */
+declare function logScale(config: ContinuousScaleConfig & {
+    base?: number;
+}): ContinuousScale;
+/**
+ * 创建幂比例尺
+ *
+ * @example
+ * ```ts
+ * const x = powScale({ domain: [0, 100], range: [0, 400], exponent: 2 });
+ * x(50); // 100 (因为 (50/100)^2 * 400 = 100)
+ * ```
+ */
+declare function powScale(config: ContinuousScaleConfig & {
+    exponent?: number;
+}): ContinuousScale;
+/**
+ * 创建平方根比例尺（指数为 0.5 的幂比例尺）
+ *
+ * @example
+ * ```ts
+ * const radius = sqrtScale({ domain: [0, 100], range: [0, 50] });
+ * // 用于气泡图：面积与数据成正比
+ * ```
+ */
+declare function sqrtScale(config: ContinuousScaleConfig): ContinuousScale;
+/**
+ * 创建序数比例尺
+ *
+ * @example
+ * ```ts
+ * const color = ordinalScale({
+ *   domain: ['A', 'B', 'C'],
+ *   range: ['#ff0000', '#00ff00', '#0000ff']
+ * });
+ * color('A'); // '#ff0000'
+ * color('B'); // '#00ff00'
+ * ```
+ */
+declare function ordinalScale<D extends string | number>(config: ScaleConfig<D, string>): OrdinalScale<D>;
+/**
+ * 创建带状比例尺（用于柱状图）
+ *
+ * @example
+ * ```ts
+ * const x = bandScale({
+ *   domain: ['A', 'B', 'C', 'D'],
+ *   range: [0, 400],
+ *   paddingInner: 0.1
+ * });
+ * x('A'); // 柱子起始位置
+ * x.bandwidth(); // 柱子宽度
+ * ```
+ */
+declare function bandScale<D extends string | number>(config: BandScaleConfig<D>): BandScale<D>;
+/**
+ * 创建点比例尺（用于散点图离散轴）
+ *
+ * @example
+ * ```ts
+ * const x = pointScale({
+ *   domain: ['Q1', 'Q2', 'Q3', 'Q4'],
+ *   range: [0, 300]
+ * });
+ * x('Q1'); // 第一个点的位置
+ * x.step(); // 点之间的间距
+ * ```
+ */
+declare function pointScale<D extends string | number>(config: ScaleConfig<D, number> & {
+    padding?: number;
+    align?: number;
+}): PointScale<D>;
+/** 预设颜色方案 */
+type ColorScheme = 'category10' | 'accent' | 'dark2' | 'paired' | 'pastel1' | 'pastel2' | 'set1' | 'set2' | 'set3' | 'tableau10';
+/**
+ * 创建分类颜色比例尺
+ *
+ * @example
+ * ```ts
+ * const color = categoryScale(['A', 'B', 'C'], 'category10');
+ * color('A'); // '#1f77b4'
+ * color('B'); // '#ff7f0e'
+ * ```
+ */
+declare function categoryScale<D extends string | number>(domain: D[], scheme?: ColorScheme): OrdinalScale<D>;
+/**
+ * 创建坐标轴比例尺对
+ *
+ * @example
+ * ```ts
+ * const { x, y } = createAxisScales({
+ *   xDomain: [0, 100],
+ *   yDomain: [0, 50],
+ *   width: 800,
+ *   height: 400,
+ *   margin: { left: 40, right: 20, top: 20, bottom: 30 }
+ * });
+ * ```
+ */
+declare function createAxisScales(config: {
+    xDomain: [number, number];
+    yDomain: [number, number];
+    width: number;
+    height: number;
+    margin?: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    xNice?: boolean;
+    yNice?: boolean;
+}): {
+    x: ContinuousScale;
+    y: ContinuousScale;
+};
+
+/**
+ * D3 Shape 适配器
+ *
+ * 遵循 "Compute-first" 原则：
+ * - D3 只负责计算形状的几何数据
+ * - Locusing 负责所有渲染
+ *
+ * 与 D3 不同的是，这些函数返回坐标点数组而非 SVG 路径字符串
+ */
+
+/** 数据点 */
+interface DataPoint {
+    x: number;
+    y: number;
+    [key: string]: unknown;
+}
+/** 曲线类型 */
+type CurveType = 'linear' | 'step' | 'stepBefore' | 'stepAfter' | 'basis' | 'cardinal' | 'catmullRom' | 'monotoneX' | 'monotoneY' | 'natural';
+/** 折线配置 */
+interface LineConfig<T = DataPoint> {
+    /** X 值访问器 */
+    x?: (d: T, i: number) => number;
+    /** Y 值访问器 */
+    y?: (d: T, i: number) => number;
+    /** 是否定义（用于过滤无效点） */
+    defined?: (d: T, i: number) => boolean;
+    /** 曲线类型 */
+    curve?: CurveType;
+    /** Cardinal/CatmullRom 张力参数 */
+    tension?: number;
+}
+/** 面积配置 */
+interface AreaConfig<T = DataPoint> {
+    /** X 值访问器 */
+    x?: (d: T, i: number) => number;
+    /** Y0 值访问器（基线） */
+    y0?: (d: T, i: number) => number;
+    /** Y1 值访问器（顶线） */
+    y1?: (d: T, i: number) => number;
+    /** 是否定义 */
+    defined?: (d: T, i: number) => boolean;
+    /** 曲线类型 */
+    curve?: CurveType;
+    /** 张力参数 */
+    tension?: number;
+}
+/** 弧形配置 */
+interface ArcConfig {
+    /** 内半径 */
+    innerRadius: number;
+    /** 外半径 */
+    outerRadius: number;
+    /** 起始角度（弧度） */
+    startAngle: number;
+    /** 结束角度（弧度） */
+    endAngle: number;
+    /** 填充角度 */
+    padAngle?: number;
+    /** 圆角半径 */
+    cornerRadius?: number;
+}
+/** 饼图数据 */
+interface PieData<T = unknown> {
+    data: T;
+    value: number;
+    index: number;
+    startAngle: number;
+    endAngle: number;
+    padAngle: number;
+}
+/** 饼图配置 */
+interface PieConfig<T = number> {
+    /** 值访问器 */
+    value?: (d: T, i: number) => number;
+    /** 排序比较器 */
+    sort?: ((a: T, b: T) => number) | null;
+    /** 按值排序 */
+    sortValues?: ((a: number, b: number) => number) | null;
+    /** 起始角度 */
+    startAngle?: number;
+    /** 结束角度 */
+    endAngle?: number;
+    /** 填充角度 */
+    padAngle?: number;
+}
+/** 堆叠数据 */
+interface StackData<T = Record<string, number>> {
+    key: string;
+    index: number;
+    data: Array<[number, number, T]>;
+}
+/** 堆叠配置 */
+interface StackConfig<T = Record<string, number>> {
+    /** 键列表 */
+    keys: string[];
+    /** 值访问器 */
+    value?: (d: T, key: string) => number;
+    /** 排序键 */
+    order?: 'none' | 'ascending' | 'descending' | 'insideOut' | 'reverse';
+    /** 偏移类型 */
+    offset?: 'none' | 'expand' | 'diverging' | 'silhouette' | 'wiggle';
+}
+/** 面积结果 */
+interface AreaResult {
+    /** 顶线点 */
+    topLine: Vector2[];
+    /** 底线点 */
+    bottomLine: Vector2[];
+    /** 闭合多边形（顶线 + 反转底线） */
+    polygon: Vector2[];
+}
+/**
+ * 生成折线点序列
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { x: 0, y: 10 },
+ *   { x: 1, y: 20 },
+ *   { x: 2, y: 15 },
+ *   { x: 3, y: 25 }
+ * ];
+ *
+ * const points = linePoints(data, {
+ *   x: d => xScale(d.x),
+ *   y: d => yScale(d.y),
+ *   curve: 'monotoneX'
+ * });
+ *
+ * // 使用 Locusing 渲染
+ * const line = Curve.from_points(points);
+ * ```
+ */
+declare function linePoints<T = DataPoint>(data: T[], config?: LineConfig<T>): Vector2[];
+/**
+ * 生成多段折线（支持数据中断）
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { x: 0, y: 10, valid: true },
+ *   { x: 1, y: null, valid: false },  // 中断
+ *   { x: 2, y: 15, valid: true },
+ *   { x: 3, y: 25, valid: true }
+ * ];
+ *
+ * const segments = lineSegments(data, {
+ *   defined: d => d.valid,
+ *   x: d => d.x,
+ *   y: d => d.y ?? 0
+ * });
+ * // 返回两段: [[p0], [p2, p3]]
+ * ```
+ */
+declare function lineSegments<T = DataPoint>(data: T[], config?: LineConfig<T>): Vector2[][];
+/**
+ * 生成面积图数据
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { x: 0, y: 10 },
+ *   { x: 1, y: 20 },
+ *   { x: 2, y: 15 }
+ * ];
+ *
+ * const area = areaPoints(data, {
+ *   x: d => xScale(d.x),
+ *   y0: () => yScale(0),      // 基线
+ *   y1: d => yScale(d.y),     // 数据线
+ *   curve: 'monotoneX'
+ * });
+ *
+ * // 使用闭合多边形渲染
+ * const polygon = Polygon.from_points(area.polygon);
+ * ```
+ */
+declare function areaPoints<T = DataPoint>(data: T[], config?: AreaConfig<T>): AreaResult;
+/**
+ * 生成弧形路径点
+ *
+ * @example
+ * ```ts
+ * const arc = arcPoints({
+ *   innerRadius: 50,
+ *   outerRadius: 100,
+ *   startAngle: 0,
+ *   endAngle: Math.PI / 2
+ * });
+ *
+ * const polygon = Polygon.from_points(arc);
+ * ```
+ */
+declare function arcPoints(config: ArcConfig): Vector2[];
+/**
+ * 计算弧形质心（用于标签定位）
+ */
+declare function arcCentroid(config: ArcConfig): Vector2;
+/**
+ * 生成饼图布局数据
+ *
+ * @example
+ * ```ts
+ * const data = [30, 50, 20];
+ * const slices = pieLayout(data);
+ *
+ * slices.forEach(slice => {
+ *   const points = arcPoints({
+ *     innerRadius: 0,
+ *     outerRadius: 100,
+ *     startAngle: slice.startAngle,
+ *     endAngle: slice.endAngle
+ *   });
+ *   // 渲染每个扇形
+ * });
+ * ```
+ */
+declare function pieLayout<T = number>(data: T[], config?: PieConfig<T>): PieData<T>[];
+/**
+ * 创建圆环图数据
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { label: 'A', value: 30 },
+ *   { label: 'B', value: 50 },
+ *   { label: 'C', value: 20 }
+ * ];
+ *
+ * const donut = donutLayout(data, {
+ *   value: d => d.value,
+ *   innerRadius: 50,
+ *   outerRadius: 100
+ * });
+ *
+ * donut.forEach(({ slice, points, centroid }) => {
+ *   // points: 弧形多边形
+ *   // centroid: 标签位置
+ * });
+ * ```
+ */
+declare function donutLayout<T>(data: T[], config: PieConfig<T> & {
+    innerRadius: number;
+    outerRadius: number;
+}): Array<{
+    slice: PieData<T>;
+    points: Vector2[];
+    centroid: Vector2;
+}>;
+/**
+ * 计算堆叠数据
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { month: 'Jan', a: 10, b: 20, c: 15 },
+ *   { month: 'Feb', a: 15, b: 25, c: 20 },
+ *   { month: 'Mar', a: 20, b: 15, c: 25 }
+ * ];
+ *
+ * const stacked = stackLayout(data, {
+ *   keys: ['a', 'b', 'c'],
+ *   offset: 'none'
+ * });
+ *
+ * // 每个系列的堆叠区域
+ * stacked.forEach(series => {
+ *   series.data.forEach(([y0, y1, originalData]) => {
+ *     // y0: 底部, y1: 顶部
+ *   });
+ * });
+ * ```
+ */
+declare function stackLayout<T extends Record<string, unknown> = Record<string, number>>(data: T[], config: StackConfig<T>): StackData<T>[];
+/**
+ * 生成堆叠面积图数据
+ */
+declare function stackedAreaPoints<T extends Record<string, unknown>>(data: T[], config: StackConfig<T> & {
+    x: (d: T, i: number) => number;
+    y: (value: number) => number;
+    curve?: CurveType;
+}): Map<string, AreaResult>;
+/**
+ * 对贝塞尔曲线进行细分采样
+ *
+ * @example
+ * ```ts
+ * const points = sampleCubicBezier(
+ *   [0, 0], [1, 2], [3, 2], [4, 0],
+ *   20  // 采样点数
+ * );
+ * ```
+ */
+declare function sampleCubicBezier(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, samples?: number): Vector2[];
+
+/**
+ * D3 Array 适配器
+ *
+ * 遵循 "Compute-first" 原则：
+ * - D3 只负责数据计算和转换
+ * - Locusing 负责所有渲染
+ */
+/** 范围 */
+type Extent<T> = [T, T] | [undefined, undefined];
+/** 分箱配置 */
+interface BinConfig<T = number> {
+    /** 值访问器 */
+    value?: (d: T) => number;
+    /** 阈值数量或数组 */
+    thresholds?: number | number[] | ((values: number[]) => number[]);
+    /** 域范围 */
+    domain?: [number, number];
+}
+/** 分箱结果 */
+interface Bin<T = number> {
+    /** 箱内数据 */
+    data: T[];
+    /** 箱起始值 */
+    x0: number;
+    /** 箱结束值 */
+    x1: number;
+    /** 数据数量 */
+    length: number;
+}
+/** 分组配置 */
+interface GroupConfig<T, K extends string | number = string> {
+    /** 分组键访问器 */
+    key: (d: T) => K;
+    /** 值访问器（可选） */
+    value?: (d: T) => number;
+    /** 聚合方法 */
+    aggregate?: 'sum' | 'mean' | 'count' | 'min' | 'max' | 'median';
+}
+/** 分组结果 */
+interface GroupResult<T, K extends string | number = string> {
+    key: K;
+    values: T[];
+    aggregate?: number;
+}
+/** 滚动计算配置 */
+interface RollingConfig {
+    /** 窗口大小 */
+    window: number;
+    /** 计算类型 */
+    type: 'mean' | 'sum' | 'min' | 'max' | 'median';
+    /** 是否居中窗口 */
+    center?: boolean;
+}
+/**
+ * 计算数值范围
+ *
+ * @example
+ * ```ts
+ * const data = [3, 1, 4, 1, 5, 9, 2, 6];
+ * const [min, max] = extent(data); // [1, 9]
+ *
+ * // 带访问器
+ * const points = [{ x: 1, y: 5 }, { x: 3, y: 2 }];
+ * const [minY, maxY] = extent(points, d => d.y); // [2, 5]
+ * ```
+ */
+declare function extent<T>(data: T[], accessor?: (d: T) => number): Extent<number>;
+/**
+ * 计算最小值
+ */
+declare function min<T>(data: T[], accessor?: (d: T) => number): number | undefined;
+/**
+ * 计算最大值
+ */
+declare function max<T>(data: T[], accessor?: (d: T) => number): number | undefined;
+/**
+ * 计算总和
+ */
+declare function sum<T>(data: T[], accessor?: (d: T) => number): number;
+/**
+ * 计算平均值
+ */
+declare function mean<T>(data: T[], accessor?: (d: T) => number): number | undefined;
+/**
+ * 计算中位数
+ */
+declare function median<T>(data: T[], accessor?: (d: T) => number): number | undefined;
+/**
+ * 计算分位数
+ *
+ * @example
+ * ```ts
+ * const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ * quantile(data, 0.25); // Q1 = 3
+ * quantile(data, 0.5);  // Q2 = 5.5
+ * quantile(data, 0.75); // Q3 = 8
+ * ```
+ */
+declare function quantile<T>(data: T[], p: number, accessor?: (d: T) => number): number | undefined;
+/**
+ * 计算方差
+ */
+declare function variance<T>(data: T[], accessor?: (d: T) => number): number | undefined;
+/**
+ * 计算标准差
+ */
+declare function deviation<T>(data: T[], accessor?: (d: T) => number): number | undefined;
+/**
+ * 对数据进行分箱（用于直方图）
+ *
+ * @example
+ * ```ts
+ * const data = [1, 2, 2, 3, 3, 3, 4, 5, 5, 6, 7, 8, 9, 10];
+ *
+ * const bins = histogram(data, { thresholds: 5 });
+ * // 返回 5 个箱，每个箱包含落入范围的数据
+ *
+ * bins.forEach(bin => {
+ *   const barWidth = xScale(bin.x1) - xScale(bin.x0);
+ *   const barHeight = yScale(bin.length);
+ *   // 渲染柱状图
+ * });
+ * ```
+ */
+declare function histogram<T = number>(data: T[], config?: BinConfig<T>): Bin<T>[];
+/**
+ * 自动计算漂亮的分箱阈值
+ *
+ * @example
+ * ```ts
+ * const data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ * const thresholds = niceThresholds(data, 5);
+ * // 可能返回 [0, 2, 4, 6, 8, 10]
+ * ```
+ */
+declare function niceThresholds(data: number[], count?: number): number[];
+/**
+ * 按键分组数据
+ *
+ * @example
+ * ```ts
+ * const sales = [
+ *   { product: 'A', amount: 100 },
+ *   { product: 'B', amount: 200 },
+ *   { product: 'A', amount: 150 },
+ *   { product: 'B', amount: 100 }
+ * ];
+ *
+ * const grouped = group(sales, {
+ *   key: d => d.product,
+ *   value: d => d.amount,
+ *   aggregate: 'sum'
+ * });
+ * // [{ key: 'A', values: [...], aggregate: 250 },
+ * //  { key: 'B', values: [...], aggregate: 300 }]
+ * ```
+ */
+declare function group<T, K extends string | number = string>(data: T[], config: GroupConfig<T, K>): GroupResult<T, K>[];
+/**
+ * 多级分组
+ *
+ * @example
+ * ```ts
+ * const data = [
+ *   { year: 2020, quarter: 'Q1', value: 100 },
+ *   { year: 2020, quarter: 'Q2', value: 150 },
+ *   { year: 2021, quarter: 'Q1', value: 200 }
+ * ];
+ *
+ * const nested = groupMulti(data, [
+ *   d => d.year,
+ *   d => d.quarter
+ * ]);
+ * // Map { 2020 => Map { Q1 => [...], Q2 => [...] }, 2021 => Map { Q1 => [...] } }
+ * ```
+ */
+declare function groupMulti<T>(data: T[], keys: Array<(d: T) => string | number>): Map<unknown, unknown>;
+/**
+ * 按值排序分组结果
+ */
+declare function sortGroups<T, K extends string | number>(groups: GroupResult<T, K>[], order?: 'ascending' | 'descending'): GroupResult<T, K>[];
+/**
+ * 计算滚动统计量
+ *
+ * @example
+ * ```ts
+ * const prices = [100, 102, 98, 103, 105, 101, 99, 104];
+ *
+ * // 5日移动平均
+ * const ma5 = rolling(prices, {
+ *   window: 5,
+ *   type: 'mean'
+ * });
+ *
+ * // 结果: [undefined, undefined, undefined, undefined, 101.6, 101.8, 101.2, 102.4]
+ * ```
+ */
+declare function rolling<T>(data: T[], config: RollingConfig & {
+    accessor?: (d: T) => number;
+}): (number | undefined)[];
+/**
+ * 生成等间距数组
+ *
+ * @example
+ * ```ts
+ * range(0, 10, 2);  // [0, 2, 4, 6, 8]
+ * range(5);         // [0, 1, 2, 3, 4]
+ * ```
+ */
+declare function range(start: number, stop?: number, step?: number): number[];
+/**
+ * 生成漂亮的刻度值
+ *
+ * @example
+ * ```ts
+ * ticks(0, 100, 5);  // [0, 20, 40, 60, 80, 100]
+ * ticks(0.3, 2.7, 5);  // [0.5, 1, 1.5, 2, 2.5]
+ * ```
+ */
+declare function ticks(start: number, stop: number, count: number): number[];
+/**
+ * 计算漂亮的刻度间隔
+ */
+declare function tickStep(start: number, stop: number, count: number): number;
+/**
+ * 转置二维数组
+ *
+ * @example
+ * ```ts
+ * const matrix = [[1, 2, 3], [4, 5, 6]];
+ * transpose(matrix);  // [[1, 4], [2, 5], [3, 6]]
+ * ```
+ */
+declare function transpose<T>(matrix: T[][]): T[][];
+/**
+ * 合并多个数组
+ *
+ * @example
+ * ```ts
+ * const a = [1, 2];
+ * const b = [3, 4];
+ * const c = [5, 6];
+ * merge([a, b, c]);  // [1, 2, 3, 4, 5, 6]
+ * ```
+ */
+declare function merge<T>(arrays: T[][]): T[];
+/**
+ * 对数组进行排列
+ *
+ * @example
+ * ```ts
+ * const data = ['c', 'a', 'b'];
+ * const order = permute(data, [1, 2, 0]);  // ['a', 'b', 'c']
+ * ```
+ */
+declare function permute<T>(array: T[], indices: number[]): T[];
+/**
+ * 打乱数组（Fisher-Yates）
+ *
+ * @example
+ * ```ts
+ * const data = [1, 2, 3, 4, 5];
+ * shuffle(data);  // 随机顺序
+ * ```
+ */
+declare function shuffle<T>(array: T[]): T[];
+/**
+ * 二分查找插入位置（左侧）
+ *
+ * @example
+ * ```ts
+ * const data = [1, 2, 3, 4, 5];
+ * bisectLeft(data, 3);  // 2
+ * ```
+ */
+declare function bisectLeft<T>(array: T[], x: number, accessor?: (d: T) => number): number;
+/**
+ * 二分查找插入位置（右侧）
+ */
+declare function bisectRight<T>(array: T[], x: number, accessor?: (d: T) => number): number;
+/**
+ * 二分查找最近值的索引
+ */
+declare function bisectCenter<T>(array: T[], x: number, accessor?: (d: T) => number): number;
+/**
+ * 找到最近的值
+ *
+ * @example
+ * ```ts
+ * const data = [1, 5, 10, 20];
+ * nearest(data, 7);  // 5
+ * nearest(data, 8);  // 10
+ * ```
+ */
+declare function nearest<T>(array: T[], x: number, accessor?: (d: T) => number): T | undefined;
+/**
+ * 计算累计和
+ *
+ * @example
+ * ```ts
+ * const values = [1, 2, 3, 4, 5];
+ * cumsum(values);  // [1, 3, 6, 10, 15]
+ * ```
+ */
+declare function cumsum<T>(data: T[], accessor?: (d: T) => number): number[];
+/**
+ * 计算差分
+ *
+ * @example
+ * ```ts
+ * const values = [1, 3, 6, 10, 15];
+ * diff(values);  // [2, 3, 4, 5]
+ * ```
+ */
+declare function diff<T>(data: T[], accessor?: (d: T) => number): number[];
+/**
+ * 归一化到 [0, 1]
+ *
+ * @example
+ * ```ts
+ * const values = [10, 20, 30, 40, 50];
+ * normalize(values);  // [0, 0.25, 0.5, 0.75, 1]
+ * ```
+ */
+declare function normalize<T>(data: T[], accessor?: (d: T) => number): number[];
+
+/**
+ * 3D Types - 3D 类型定义
+ */
+
+/**
+ * 3D 相机配置
+ */
+interface ThreeDCameraConfig {
+    /** 仰角 (弧度, 0 = 水平, PI/2 = 顶视) */
+    phi?: number;
+    /** 方位角 (弧度) */
+    theta?: number;
+    /** 相机距离 */
+    distance?: number;
+    /** 焦距 (影响透视强度) */
+    focalLength?: number;
+    /** 相机目标点 */
+    target?: Vector3;
+}
+/**
+ * 3D 坐标轴配置
+ */
+interface ThreeDAxesConfig {
+    /** X 轴范围 */
+    xRange?: [number, number];
+    /** Y 轴范围 */
+    yRange?: [number, number];
+    /** Z 轴范围 */
+    zRange?: [number, number];
+    /** 轴线颜色 */
+    axisColor?: string;
+    /** X 轴颜色 */
+    xColor?: string;
+    /** Y 轴颜色 */
+    yColor?: string;
+    /** Z 轴颜色 */
+    zColor?: string;
+    /** 轴线宽度 */
+    axisWidth?: number;
+    /** 是否显示网格 */
+    showGrid?: boolean;
+    /** 网格颜色 */
+    gridColor?: string;
+    /** 单位长度 (像素) */
+    unitSize?: number;
+}
+/**
+ * 曲面配置
+ */
+interface SurfaceConfig {
+    /** U 参数范围 */
+    uRange?: [number, number];
+    /** V 参数范围 */
+    vRange?: [number, number];
+    /** U 方向分辨率 */
+    uResolution?: number;
+    /** V 方向分辨率 */
+    vResolution?: number;
+    /** 填充颜色 */
+    fillColor?: string;
+    /** 边框颜色 */
+    strokeColor?: string;
+    /** 边框宽度 */
+    strokeWidth?: number;
+    /** 是否使用棋盘格 */
+    checkerboard?: boolean;
+    /** 棋盘格颜色1 */
+    checkerColor1?: string;
+    /** 棋盘格颜色2 */
+    checkerColor2?: string;
+    /** 不透明度 */
+    opacity?: number;
+}
+/**
+ * 3D 图元配置
+ */
+interface Primitive3DConfig {
+    /** 填充颜色 */
+    fillColor?: string;
+    /** 边框颜色 */
+    strokeColor?: string;
+    /** 边框宽度 */
+    strokeWidth?: number;
+    /** 不透明度 */
+    opacity?: number;
+}
+/**
+ * 球体配置
+ */
+interface SphereConfig extends Primitive3DConfig {
+    /** 经度分辨率 */
+    longitudeResolution?: number;
+    /** 纬度分辨率 */
+    latitudeResolution?: number;
+    /** 是否使用棋盘格 */
+    checkerboard?: boolean;
+}
+/**
+ * 立方体配置
+ */
+interface CubeConfig extends Primitive3DConfig {
+    /** 面不透明度 */
+    faceOpacity?: number;
+}
+/**
+ * 圆柱配置
+ */
+interface CylinderConfig extends Primitive3DConfig {
+    /** 分辨率 */
+    resolution?: number;
+}
+/**
+ * 圆锥配置
+ */
+interface ConeConfig extends Primitive3DConfig {
+    /** 分辨率 */
+    resolution?: number;
+}
+/**
+ * 投影结果
+ */
+interface ProjectionResult {
+    /** 投影后的 2D 点 */
+    point: Vector2;
+    /** 深度值 (用于排序) */
+    depth: number;
+    /** 是否在视野内 */
+    visible: boolean;
+}
+/**
+ * 3D 多边形面
+ */
+interface Face3D {
+    /** 顶点索引 */
+    vertices: number[];
+    /** 填充颜色 */
+    fillColor: string;
+    /** 边框颜色 */
+    strokeColor: string;
+    /** 深度值 (用于排序) */
+    depth: number;
+}
+
+/**
+ * ThreeDCamera - 3D 相机
+ *
+ * 处理 3D 到 2D 的投影变换
+ */
+
+/**
+ * 3D 相机类
+ *
+ * 使用球坐标系定位相机，支持透视投影
+ */
+declare class ThreeDCamera {
+    /** 仰角 (弧度) */
+    phi: number;
+    /** 方位角 (弧度) */
+    theta: number;
+    /** 相机距离 */
+    distance: number;
+    /** 焦距 */
+    focalLength: number;
+    /** 相机目标点 */
+    target: Vector3;
+    /**
+     * 创建 3D 相机
+     */
+    constructor(config?: ThreeDCameraConfig);
+    /**
+     * 设置相机位置
+     */
+    setPosition(phi: number, theta: number, distance?: number): void;
+    /**
+     * 绕目标点旋转
+     */
+    orbitAround(dphi: number, dtheta: number): void;
+    /**
+     * 获取相机位置 (世界坐标)
+     */
+    getPosition(): Vector3;
+    /**
+     * 投影 3D 点到 2D
+     *
+     * 使用透视投影
+     */
+    project(point: Vector3): Vector2;
+    /**
+     * 获取投影结果 (包含深度信息)
+     */
+    projectWithDepth(point: Vector3): ProjectionResult;
+    /**
+     * 获取深度值 (用于排序)
+     */
+    getDepth(point: Vector3): number;
+    /**
+     * 批量投影点
+     */
+    projectPoints(points: Vector3[]): Vector2[];
+    /**
+     * 克隆相机
+     */
+    clone(): ThreeDCamera;
+}
+/**
+ * 创建 3D 相机
+ */
+declare function createThreeDCamera(config?: ThreeDCameraConfig): ThreeDCamera;
+
+/**
+ * ThreeDAxes - 3D 坐标轴
+ *
+ * 绘制 3D 坐标系和网格
+ */
+
+/**
+ * 3D 坐标轴类
+ */
+declare class ThreeDAxes {
+    protected _xRange: [number, number];
+    protected _yRange: [number, number];
+    protected _zRange: [number, number];
+    protected _xColor: string;
+    protected _yColor: string;
+    protected _zColor: string;
+    protected _axisWidth: number;
+    protected _showGrid: boolean;
+    protected _gridColor: string;
+    protected _unitSize: number;
+    /**
+     * 创建 3D 坐标轴
+     */
+    constructor(config?: ThreeDAxesConfig);
+    /**
+     * 转换为 Diagram
+     */
+    toDiagram(camera: ThreeDCamera, centerX: number, centerY: number): Diagram;
+    /**
+     * 绘制网格
+     */
+    protected drawGrid(camera: ThreeDCamera, centerX: number, centerY: number): Diagram[];
+    /**
+     * 将世界坐标转换为屏幕坐标
+     */
+    worldToScreen(point: Vector3, camera: ThreeDCamera, centerX: number, centerY: number): [number, number];
+    /**
+     * 获取单位大小
+     */
+    get unitSize(): number;
+}
+/**
+ * 创建 3D 坐标轴
+ */
+declare function createThreeDAxes(config?: ThreeDAxesConfig): ThreeDAxes;
+
+/**
+ * 3D Primitives - 3D 基础图元
+ *
+ * 提供 3D 图形的创建函数
+ */
+
+/**
+ * 3D 点
+ */
+declare function dot3D(position: Vector3, camera: ThreeDCamera, centerX: number, centerY: number, scale: number, config?: Primitive3DConfig & {
+    radius?: number;
+}): Diagram;
+/**
+ * 3D 线段
+ */
+declare function line3D(from: Vector3, to: Vector3, camera: ThreeDCamera, centerX: number, centerY: number, scale: number, config?: Primitive3DConfig): Diagram;
+/**
+ * 3D 箭头
+ */
+declare function arrow3D(from: Vector3, to: Vector3, camera: ThreeDCamera, centerX: number, centerY: number, scale: number, config?: Primitive3DConfig & {
+    headSize?: number;
+}): Diagram;
+/**
+ * 3D 立方体
+ */
+declare function cube3D(sideLength: number, camera: ThreeDCamera, centerX: number, centerY: number, scale: number, config?: CubeConfig): Diagram;
+/**
+ * 3D 球体 (线框)
+ */
+declare function sphere3D(radius: number, camera: ThreeDCamera, centerX: number, centerY: number, scale: number, config?: SphereConfig): Diagram;
+/**
+ * 3D 圆柱体
+ */
+declare function cylinder3D(radiusVal: number, height: number, camera: ThreeDCamera, centerX: number, centerY: number, scale: number, config?: CylinderConfig): Diagram;
+/**
+ * 3D 圆锥体
+ */
+declare function cone3D(baseRadius: number, height: number, camera: ThreeDCamera, centerX: number, centerY: number, scale: number, config?: ConeConfig): Diagram;
+
+/**
+ * Diagramatics Compatibility Layer
+ *
+ * 提供与 Diagramatics (https://diagramatics.photon-ray.xyz/) 兼容的 API 别名
+ *
+ * Diagramatics usage guide 中使用的标识符：
+ * - square, circle, V2 → Locusing 已有同名
+ * - diagram_combine → Locusing 的 combine
+ * - draw_to_svg → Locusing 的 renderToSVG / toSVGString
+ * - Interactive → Locusing 已有同名
+ */
+
+/**
+ * diagram_combine - Diagramatics 风格的组合函数
+ *
+ * 等价于 Locusing 的 combine()
+ *
+ * @example
+ * ```typescript
+ * const combined = diagram_combine(circle(1), square(0.5));
+ * ```
+ */
+declare const diagram_combine: typeof combine;
+/**
+ * draw_to_svg - Diagramatics 风格的渲染函数
+ *
+ * 将 Diagram 渲染到 SVG 元素
+ *
+ * @param diagram - 要渲染的 Diagram
+ * @param svg - 目标 SVG 元素
+ * @param options - 渲染选项
+ *
+ * @example
+ * ```typescript
+ * const svg = document.querySelector('svg');
+ * draw_to_svg(myDiagram, svg, { width: 800, height: 600 });
+ * ```
+ */
+declare function draw_to_svg(diagram: Diagram, svg: SVGSVGElement, options?: RenderOptions): void;
+/**
+ * draw_to_svg_string - 将 Diagram 渲染为 SVG 字符串
+ *
+ * @param diagram - 要渲染的 Diagram
+ * @param options - 渲染选项
+ * @returns SVG 字符串
+ */
+declare function draw_to_svg_string(diagram: Diagram, options?: RenderOptions): string;
+/**
+ * Diagramatics 中的 empty() 函数
+ * 创建一个空的组合
+ */
+declare function empty(): Diagram;
+
+/**
+ * Manim Compatibility Layer
+ *
+ * 提供与 Manim Community (https://docs.manim.community/) 兼容的 API 别名
+ *
+ * 主要映射：
+ * - Mobject → Diagram (薄包装)
+ * - VMobject → Diagram
+ * - VGroup → group/combine
+ * - MathTex → tex
+ * - rate_functions → easing
+ */
+
+/**
+ * Mobject - Manim 的基础对象类型
+ *
+ * 在 Locusing 中，Diagram 是基础对象类型
+ * Mobject 作为 Diagram 的类型别名提供
+ */
+type Mobject = Diagram;
+/**
+ * VMobject - Manim 的矢量对象类型
+ *
+ * 在 Locusing 中等价于 Diagram
+ */
+type VMobject = Diagram;
+/**
+ * VGroup - Manim 的矢量对象组
+ *
+ * 等价于 Locusing 的 group/combine
+ *
+ * @example
+ * ```typescript
+ * const vgroup = VGroup(circle(1), square(0.5));
+ * ```
+ */
+declare function VGroup(...diagrams: Diagram[]): Diagram;
+/**
+ * Group - Manim 的对象组
+ *
+ * 等价于 VGroup
+ */
+declare const Group: typeof VGroup;
+/**
+ * MathTex - Manim 的数学 LaTeX 渲染
+ *
+ * 等价于 Locusing 的 tex()
+ *
+ * @param latex - LaTeX 字符串
+ * @param options - 选项
+ *
+ * @example
+ * ```typescript
+ * const formula = MathTex('E = mc^2');
+ * ```
+ */
+declare function MathTex(latex: string, options?: {
+    fontSize?: number;
+}): Diagram;
+/**
+ * Tex - Manim 的 LaTeX 渲染（与 MathTex 类似）
+ */
+declare const Tex: typeof MathTex;
+/**
+ * Manim rate_functions 到 Locusing easing 的映射
+ *
+ * Manim 的 rate_functions 模块提供了多种缓动函数
+ * 这里提供与 Manim 兼容的命名
+ */
+declare const rate_functions: {
+    /**
+     * linear - 线性（无缓动）
+     */
+    linear: (t: number) => number;
+    /**
+     * smooth - 平滑（等价于 ease_in_out_sine）
+     */
+    smooth: (t: number) => number;
+    /**
+     * rush_into - 快速进入（等价于 ease_in）
+     */
+    rush_into: (t: number) => number;
+    /**
+     * rush_from - 快速离开（等价于 ease_out）
+     */
+    rush_from: (t: number) => number;
+    /**
+     * slow_into - 缓慢进入
+     */
+    slow_into: (t: number) => number;
+    /**
+     * double_smooth - 双重平滑（使用 easeInOutCubic 近似）
+     */
+    double_smooth: (t: number) => number;
+    /**
+     * there_and_back - 往返
+     */
+    there_and_back: (t: number) => number;
+    /**
+     * there_and_back_with_pause - 往返带暂停
+     */
+    there_and_back_with_pause: (t: number, pauseRatio?: number) => number;
+    /**
+     * running_start - 带助跑的开始
+     */
+    running_start: (t: number, pullFactor?: number) => number;
+    /**
+     * not_quite_there - 未完全到达
+     */
+    not_quite_there: (t: number, proportion?: number) => number;
+    /**
+     * wiggle - 摆动
+     */
+    wiggle: (t: number, wiggles?: number) => number;
+    /**
+     * squish_rate_func - 压缩速率函数到指定区间
+     */
+    squish_rate_func: (func: (t: number) => number, a?: number, b?: number) => (t: number) => number;
+    /**
+     * lingering - 徘徊（慢结束）
+     */
+    lingering: (t: number) => number;
+    /**
+     * exponential_decay - 指数衰减
+     */
+    exponential_decay: (t: number, half_life?: number) => number;
+    ease_in_sine: (t: number) => number;
+    ease_out_sine: (t: number) => number;
+    ease_in_out_sine: (t: number) => number;
+    ease_in_quad: (t: number) => number;
+    ease_out_quad: (t: number) => number;
+    ease_in_out_quad: (t: number) => number;
+    ease_in_cubic: (t: number) => number;
+    ease_out_cubic: (t: number) => number;
+    ease_in_out_cubic: (t: number) => number;
+    ease_in_expo: (t: number) => number;
+    ease_out_expo: (t: number) => number;
+    ease_in_out_expo: (t: number) => number;
+    ease_in_back: (t: number) => number;
+    ease_out_back: (t: number) => number;
+    ease_in_out_back: (t: number) => number;
+    ease_in_elastic: (t: number) => number;
+    ease_out_elastic: (t: number) => number;
+    ease_out_bounce: (t: number) => number;
+    ease_in_bounce: (t: number) => number;
+};
+
+/**
+ * @locusing/physics - 类型定义
+ *
+ * 2D 物理系统的类型定义
+ */
+
+/** Matter.js Body 类型别名 */
+type MatterBody = Matter.Body;
+/** Matter.js Constraint 类型别名 */
+type MatterConstraint = Matter.Constraint;
+/** 刚体形状类型 */
+type BodyShapeType = 'rectangle' | 'circle' | 'polygon';
+/** 刚体配置基础 */
+interface BodyOptionsBase {
+    /** 位置 */
+    position?: Vector2;
+    /** 旋转角度（弧度） */
+    angle?: number;
+    /** 是否静态（不受力影响） */
+    isStatic?: boolean;
+    /** 密度 */
+    density?: number;
+    /** 摩擦系数 */
+    friction?: number;
+    /** 弹性系数（反弹） */
+    restitution?: number;
+    /** 空气阻力 */
+    frictionAir?: number;
+    /** 标签（用于识别） */
+    label?: string;
+}
+/** 矩形刚体配置 */
+interface RectBodyOptions extends BodyOptionsBase {
+    type: 'rectangle';
+    width: number;
+    height: number;
+}
+/** 圆形刚体配置 */
+interface CircleBodyOptions extends BodyOptionsBase {
+    type: 'circle';
+    radius: number;
+}
+/** 多边形刚体配置 */
+interface PolygonBodyOptions extends BodyOptionsBase {
+    type: 'polygon';
+    vertices: Vector2[];
+}
+/** 刚体配置联合类型 */
+type BodyOptions = RectBodyOptions | CircleBodyOptions | PolygonBodyOptions;
+/** 约束类型 */
+type ConstraintType = 'distance' | 'point' | 'spring';
+/** 约束配置基础 */
+interface ConstraintOptionsBase {
+    /** 刚度 */
+    stiffness?: number;
+    /** 阻尼 */
+    damping?: number;
+    /** 标签 */
+    label?: string;
+}
+/** 距离约束配置 */
+interface DistanceConstraintOptions extends ConstraintOptionsBase {
+    type: 'distance';
+    /** 固定长度（不设置则使用当前距离） */
+    length?: number;
+    /** 连接点 A 的偏移 */
+    pointA?: Vector2;
+    /** 连接点 B 的偏移 */
+    pointB?: Vector2;
+}
+/** 点约束配置（固定到世界坐标点） */
+interface PointConstraintOptions extends ConstraintOptionsBase {
+    type: 'point';
+    /** 世界坐标点 */
+    point: Vector2;
+    /** 连接点偏移 */
+    pointA?: Vector2;
+}
+/** 弹簧约束配置 */
+interface SpringConstraintOptions extends ConstraintOptionsBase {
+    type: 'spring';
+    /** 静止长度 */
+    length?: number;
+    /** 连接点 A 的偏移 */
+    pointA?: Vector2;
+    /** 连接点 B 的偏移 */
+    pointB?: Vector2;
+}
+/** 约束配置联合类型 */
+type ConstraintOptions = DistanceConstraintOptions | PointConstraintOptions | SpringConstraintOptions;
+/** 物理世界配置 */
+interface WorldConfig {
+    /** 重力（默认 [0, 1]，向下） */
+    gravity?: Vector2;
+    /** 时间步长（默认 1/60） */
+    timeStep?: number;
+    /** 速度迭代次数 */
+    velocityIterations?: number;
+    /** 位置迭代次数 */
+    positionIterations?: number;
+}
+/** 物理体包装 */
+interface PhysicsBody {
+    /** 内部 Matter.js Body 引用 */
+    readonly _body: MatterBody;
+    /** 唯一 ID */
+    readonly id: number;
+    /** 标签 */
+    readonly label: string;
+    /** 获取当前位置 */
+    getPosition(): Vector2;
+    /** 获取当前角度 */
+    getAngle(): number;
+    /** 获取当前速度 */
+    getVelocity(): Vector2;
+    /** 获取当前角速度 */
+    getAngularVelocity(): number;
+    /** 设置位置 */
+    setPosition(position: Vector2): void;
+    /** 设置角度 */
+    setAngle(angle: number): void;
+    /** 设置速度 */
+    setVelocity(velocity: Vector2): void;
+    /** 设置角速度 */
+    setAngularVelocity(velocity: number): void;
+    /** 施加力 */
+    applyForce(force: Vector2, point?: Vector2): void;
+    /** 施加冲量 */
+    applyImpulse(impulse: Vector2, point?: Vector2): void;
+    /** 是否静态 */
+    isStatic(): boolean;
+    /** 设置静态 */
+    setStatic(isStatic: boolean): void;
+}
+/** 物理约束包装 */
+interface PhysicsConstraint {
+    /** 内部 Matter.js Constraint 引用 */
+    readonly _constraint: MatterConstraint;
+    /** 唯一 ID */
+    readonly id: number;
+    /** 标签 */
+    readonly label: string;
+    /** 设置刚度 */
+    setStiffness(stiffness: number): void;
+    /** 设置阻尼 */
+    setDamping(damping: number): void;
+    /** 设置长度 */
+    setLength(length: number): void;
+}
+/** Diagram 与物理体的绑定 */
+interface PhysicsBinding {
+    /** 物理体 */
+    body: PhysicsBody;
+    /** 绑定的 Diagram */
+    diagram: Diagram;
+    /** 位置偏移 */
+    offset?: Vector2;
+    /** 是否同步旋转 */
+    syncRotation?: boolean;
+}
+/** 物理状态 */
+interface PhysicsState {
+    /** 位置 */
+    position: Vector2;
+    /** 角度 */
+    angle: number;
+    /** 速度 */
+    velocity: Vector2;
+    /** 角速度 */
+    angularVelocity: number;
+}
+/** 碰撞事件 */
+interface CollisionEvent {
+    /** 碰撞体 A */
+    bodyA: PhysicsBody;
+    /** 碰撞体 B */
+    bodyB: PhysicsBody;
+    /** 碰撞点 */
+    contacts: Vector2[];
+}
+/** 物理事件监听器 */
+interface PhysicsEventListeners {
+    /** 碰撞开始 */
+    onCollisionStart?: (event: CollisionEvent) => void;
+    /** 碰撞结束 */
+    onCollisionEnd?: (event: CollisionEvent) => void;
+    /** 碰撞激活中 */
+    onCollisionActive?: (event: CollisionEvent) => void;
+    /** 每帧更新后 */
+    onAfterUpdate?: (time: number) => void;
+}
+
+/**
+ * @locusing/physics - Physics2DWorld
+ *
+ * 2D 物理世界管理器，封装 Matter.js
+ */
+
+/**
+ * 2D 物理世界
+ *
+ * 封装 Matter.js，提供与 Locusing Diagram 的集成
+ *
+ * @example
+ * ```typescript
+ * const world = new Physics2DWorld({ gravity: [0, 9.8] });
+ *
+ * // 创建刚体
+ * const ball = world.createBody({
+ *   type: 'circle',
+ *   radius: 0.5,
+ *   position: [0, 3]
+ * });
+ *
+ * // 绑定到 Diagram
+ * const ballDiagram = circle(0.5);
+ * world.bind(ball, ballDiagram);
+ *
+ * // 在场景中使用
+ * scene.addUpdater(() => {
+ *   world.step();
+ *   return world.syncDiagrams();
+ * });
+ * ```
+ */
+declare class Physics2DWorld {
+    private engine;
+    private world;
+    private bodies;
+    private constraints;
+    private bindings;
+    private listeners;
+    private timeStep;
+    constructor(config?: WorldConfig);
+    /**
+     * 创建刚体
+     */
+    createBody(options: BodyOptions): PhysicsBody;
+    /**
+     * 创建矩形刚体（快捷方法）
+     */
+    createRect(width: number, height: number, options?: Omit<BodyOptions, 'type' | 'width' | 'height'>): PhysicsBody;
+    /**
+     * 创建圆形刚体（快捷方法）
+     */
+    createCircle(radius: number, options?: Omit<BodyOptions, 'type' | 'radius'>): PhysicsBody;
+    /**
+     * 创建多边形刚体（快捷方法）
+     */
+    createPolygon(vertices: Vector2[], options?: Omit<BodyOptions, 'type' | 'vertices'>): PhysicsBody;
+    /**
+     * 移除刚体
+     */
+    removeBody(body: PhysicsBody): void;
+    /**
+     * 获取所有刚体
+     */
+    getBodies(): PhysicsBody[];
+    /**
+     * 创建约束
+     */
+    createConstraint(bodyA: PhysicsBody, bodyB: PhysicsBody | null, options: ConstraintOptions): PhysicsConstraint;
+    /**
+     * 创建距离约束（快捷方法）
+     */
+    createDistanceConstraint(bodyA: PhysicsBody, bodyB: PhysicsBody, options?: Partial<Omit<ConstraintOptions, 'type'>>): PhysicsConstraint;
+    /**
+     * 创建弹簧约束（快捷方法）
+     */
+    createSpring(bodyA: PhysicsBody, bodyB: PhysicsBody, options?: Partial<Omit<SpringConstraintOptions, 'type'>>): PhysicsConstraint;
+    /**
+     * 创建固定点约束（快捷方法）
+     */
+    createPinConstraint(body: PhysicsBody, point: Vector2, options?: Partial<Omit<ConstraintOptions, 'type' | 'point'>>): PhysicsConstraint;
+    /**
+     * 移除约束
+     */
+    removeConstraint(constraint: PhysicsConstraint): void;
+    /**
+     * 绑定物理体到 Diagram
+     */
+    bind(body: PhysicsBody, diagram: Diagram, options?: {
+        offset?: Vector2;
+        syncRotation?: boolean;
+    }): PhysicsBinding;
+    /**
+     * 解除绑定
+     */
+    unbind(body: PhysicsBody): void;
+    /**
+     * 获取绑定的 Diagram
+     */
+    getBoundDiagram(body: PhysicsBody): Diagram | undefined;
+    /**
+     * 同步所有绑定的 Diagram
+     * @returns 更新后的 Diagram 数组
+     */
+    syncDiagrams(): Diagram[];
+    /**
+     * 获取物理体状态
+     */
+    getState(body: PhysicsBody): PhysicsState;
+    /**
+     * 步进模拟
+     */
+    step(delta?: number): void;
+    /**
+     * 设置重力
+     */
+    setGravity(gravity: Vector2): void;
+    /**
+     * 获取重力
+     */
+    getGravity(): Vector2;
+    /**
+     * 清空物理世界
+     */
+    clear(): void;
+    /**
+     * 设置事件监听器
+     */
+    on(listeners: PhysicsEventListeners): void;
+    private setupCollisionEvents;
+    /**
+     * 创建鼠标约束（用于拖拽）
+     * @returns 控制鼠标约束的函数
+     */
+    createMouseConstraint(): {
+        startDrag: (body: PhysicsBody, worldPoint: Vector2) => void;
+        moveTo: (worldPoint: Vector2) => void;
+        endDrag: () => void;
+        getCurrentBody: () => PhysicsBody | null;
+    };
+    /**
+     * 检测点击位置的刚体
+     */
+    queryPoint(point: Vector2): PhysicsBody | null;
+}
+/**
+ * 创建物理世界（工厂函数）
+ */
+declare function createPhysicsWorld(config?: WorldConfig): Physics2DWorld;
+
+/**
+ * @locusing/physics - 预设场景
+ *
+ * 提供常用物理场景的快速创建
+ */
+
+/** 单摆配置 */
+interface PendulumConfig {
+    /** 摆长 */
+    length?: number;
+    /** 摆球半径 */
+    ballRadius?: number;
+    /** 初始角度（弧度） */
+    initialAngle?: number;
+    /** 固定点位置 */
+    pivot?: Vector2;
+}
+/** 弹簧配置 */
+interface SpringConfig {
+    /** 弹簧静止长度 */
+    length?: number;
+    /** 质量块大小 */
+    massSize?: number;
+    /** 弹簧刚度 */
+    stiffness?: number;
+    /** 阻尼 */
+    damping?: number;
+    /** 固定点位置 */
+    anchor?: Vector2;
+    /** 是否水平（默认垂直） */
+    horizontal?: boolean;
+}
+/** 碰撞场景配置 */
+interface CollisionConfig {
+    /** 地面 Y 坐标 */
+    groundY?: number;
+    /** 地面宽度 */
+    groundWidth?: number;
+    /** 墙壁（左右边界） */
+    walls?: {
+        left?: number;
+        right?: number;
+        height?: number;
+    };
+}
+/** 多体系统配置 */
+interface MultiBodyConfig extends CollisionConfig {
+    /** 球的数量 */
+    count?: number;
+    /** 球的半径 */
+    radius?: number;
+    /** 初始区域 */
+    spawnArea?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+/**
+ * 创建单摆场景
+ */
+declare function createPendulum(config?: PendulumConfig, worldConfig?: WorldConfig): {
+    world: Physics2DWorld;
+    ball: PhysicsBody;
+    pivot: Vector2;
+};
+/**
+ * 创建弹簧振子场景
+ */
+declare function createSpringMass(config?: SpringConfig, worldConfig?: WorldConfig): {
+    world: Physics2DWorld;
+    mass: PhysicsBody;
+    anchor: Vector2;
+};
+/**
+ * 创建带边界的碰撞场景
+ */
+declare function createCollisionScene(config?: CollisionConfig, worldConfig?: WorldConfig): {
+    world: Physics2DWorld;
+    ground: PhysicsBody;
+    walls: PhysicsBody[];
+};
+/**
+ * 创建多体碰撞场景
+ */
+declare function createMultiBodyScene(config?: MultiBodyConfig, worldConfig?: WorldConfig): {
+    world: Physics2DWorld;
+    bodies: PhysicsBody[];
+    ground: PhysicsBody;
+    walls: PhysicsBody[];
+};
+/**
+ * 创建牛顿摆场景
+ */
+declare function createNewtonsCradle(config?: {
+    ballCount?: number;
+    ballRadius?: number;
+    stringLength?: number;
+    spacing?: number;
+    pivot?: Vector2;
+}, worldConfig?: WorldConfig): {
+    world: Physics2DWorld;
+    balls: PhysicsBody[];
+    pivots: Vector2[];
+};
+/**
+ * 创建多米诺骨牌场景
+ */
+declare function createDominoes(config?: {
+    count?: number;
+    spacing?: number;
+    width?: number;
+    height?: number;
+    startX?: number;
+    groundY?: number;
+}, worldConfig?: WorldConfig): {
+    world: Physics2DWorld;
+    dominoes: PhysicsBody[];
+    ground: PhysicsBody;
+    trigger: PhysicsBody;
+};
+
+export { AddTextLetterByLetter, type Animation, type AnimationConfig, AnimationGroup, type AnimationGroupOptions, type AnimationOptions, type AnimationStatus, type AnimationTokens, ApplyMethod, ApplyWave, type ApplyWaveOptions, type ArcConfig, type ArcShape, type AreaConfig, type AreaResult, Axes, type AxesConfig, type AxisColors, type BackgroundColors, type BandScale, type BandScaleConfig, type BaseShape, type Bin, type BinConfig, Blink, type BodyOptions, type BodyOptionsBase, type BodyShapeType, type ButtonConfig, Camera, type CameraAnimationOptions$1 as CameraAnimationOptions, type CameraAnimationState, CameraAutoZoom, type CameraConfig, CameraMove, CameraReset, CameraSetFrame, CameraZoom, type CircleBodyOptions, type CircleShape, Circumscribe, type CircumscribeOptions, ClockwiseTransform, type CollisionConfig, type CollisionEvent, type ColorName, ColorScales, type ColorScheme, type ColorTokens, Colors, type ConeConfig, type ConstraintOptions, type ConstraintOptionsBase, type ConstraintType, type ContinuousScale, type ContinuousScaleConfig, CounterclockwiseTransform, Create, type CreateOptions, type CubeConfig, type CurveType, CyclicReplace, type CylinderConfig, DEGREES, DL, DOWN, DR, type DagreAlign, type DagreEdgeRouting, type DagreLayoutConfig, type DagreLayoutResult, type DagreRankDir, type DagreRanker, type DashPatterns, type DataPoint, type DeepPartial, DiGraph, Diagram, Dir, type DistanceConstraintOptions, DrawBorderThenFill, type DurationTokens, type EasingFunction, type EasingTokens, type EdgeConfig, type EdgeRoute, type EllipseShape, type Extent, type Face3D, FadeIn, FadeInFrom, FadeInFromDown, FadeInFromLeft, FadeInFromRight, FadeInFromUp, type FadeOptions, FadeOut, FadeOutTo, FadeToColor, FadeTransform, Flash, type FlashOptions, FocusOn, type FocusOnOptions, type FontFamilyTokens, type FontSizeTokens, type FontWeightTokens, type Frame, type FrameConfig, Graph, type GraphConfig, Group, type GroupConfig, type GroupResult, type GroupShape, GrowFromCenter, GrowFromEdge, GrowFromPoint, type HSL, Homotopy, IDENTITY, Indicate, type IndicateOptions, Interactive, type InteractiveOptions, LEFT, LaggedStart, LaggedStartMap, type LayoutFunction, type LayoutTokens, type LayoutType, type LineConfig, type LineShape, type LocatorConfig, type LocatorOptions, ManimColor, MathTex, type Matrix3, type MatrixConfig, MatrixDisplay, type Mobject, Morphing, MoveAlongPath, type MoveOptions, MoveTo, MoveToTarget, MovingCamera, type MovingCameraConfig, MovingCameraScene, type MovingCameraSceneConfig, type MultiBodyConfig, NumberLine, NumberPlane, ORIGIN, type OrdinalScale, PI, type PathCommand, type PathShape, type PendulumConfig, PhaseFlow, type PhaseFlowOptions, Physics2DWorld, type PhysicsBinding, type PhysicsBody, type PhysicsConstraint, type PhysicsEventListeners, type PhysicsState, type PieConfig, type PieData, type Point, type PointConstraintOptions, type PointScale, PolarAxes, type PolygonBodyOptions, type PolygonShape, type PolylineShape, type Primitive3DConfig, type ProjectionResult, type RGB, RIGHT, type RectBodyOptions, type RectShape, RemoveTextLetterByLetter, type RenderOptions, ReplacementTransform, type RollingConfig, Rotate, type RotateOptions, Rotating, type RoughRenderOptions, type Scale, type ScaleConfig, ScaleInPlace, type ScaleOptions, Scene, type SceneConfig, type SemanticColors, type Shape, type ShapeType, Shift, ShowPassingFlash, ShrinkToCenter, type SliderConfig, type SliderOptions, type SpacingTokens, type SphereConfig, SpinInFromNothing, SpiralIn, type SpiralInOptions, type SpringConfig, type SpringConstraintOptions, type StackConfig, type StackData, type StrokeTokens, type StrokeWidthTokens, type Style, Succession, type SurfaceConfig, Swap, type SwapOptions, TAU, Table, type TableConfig, Tex, type TexShape, type TextAnimationOptions, type TextColors, type TextShape, type TextStyle, type Theme, type ThemeName, type ThemeOverrides, type ThemeStyles, type ThemeTokens, ThreeB1BColors, ThreeDAxes, type ThreeDAxesConfig, ThreeDCamera, type ThreeDCameraConfig, Timeline, type TimelineOptions, Transform, TransformFromCopy, TransformMatchingShapes, TransformMatchingTex, type TransformMatchingTexOptions, type TransformOptions, Typewriter, type TypewriterOptions, type TypographyTokens, UL, UP, UR, Uncreate, Unwrite, UpdateFromAlphaFunc, UpdateFromFunc, type UpdaterConfig, type UpdaterFunction, V2, V3, VGroup, type VMobject, ValueTracker, type Vector2, type Vector3, type VertexConfig, Wait, Wiggle, type WiggleOptions, type WorldConfig, Write, add, altitude, angle, angleBetween, angleBisector, angleMarker, annularSector, annulus, applyMatrix, applyThemeOverrides, arc, arcBetweenPoints, arcCentroid, arcPoints, areaPoints, arrow, arrow3D, axisColorStyle, bandScale, bisectCenter, bisectLeft, bisectRight, brace, braceBetweenPoints, braceLabel, bulletedList, categoryScale, centroid, circle, circleConstraint, circleIntersections, circularLayout, circumscribedCircle, clamp, code, colorGradient, combine, cone3D, createAxisScales, createCamera, createCollisionScene, createDagreLayoutFn, createDominoes, createInteractive, createMovingCamera, createMovingCameraScene, createMultiBodyScene, createNewtonsCradle, createPendulum, createPhysicsWorld, createScene, createSpringMass, createTheme, createThreeDAxes, createThreeDCamera, createTimeline, cross, crossMark, cube3D, cubicBezier, cumsum, curvedArrow, curvedDoubleArrow, cutout, cylinder3D, deviation as d3Deviation, extent as d3Extent, group as d3Group, max as d3Max, mean as d3Mean, median as d3Median, merge as d3Merge, min as d3Min, normalize as d3Normalize, permute as d3Permute, quantile as d3Quantile, range as d3Range, sum as d3Sum, ticks as d3Ticks, transpose as d3Transpose, variance as d3Variance, dagreLayout, dashedStyle, decimalMatrix, decimalTable, defaultTheme, defaultTokens, degToRad, determinant, diagram_combine, diff, digraph, distance, div, donutLayout, dot, dot3D, doubleArrow, draw_to_svg, draw_to_svg_string, easing, easingMap, elbow, ellipse, empty, equilateralTriangle, footOfPerpendicular, functionConstraint, getBuffer, getColor, getCurrentTheme, getDefaultFillStyle, getDefaultStrokeStyle, getDefaultTextStyle, getDuration, getEasing, getGSAPEasing, getSpacing, getTheme, getTokens, graph, gridConstraint, gridLayout, group$1 as group, groupMulti, groupedHierarchicalLayout, hierarchicalLayout, histogram, inscribedCircle, integerMatrix, integerTable, interpolateColor, labeledDot, length, lerp, lerpNumber, lightTheme, line, line3D, lineConstraint, lineIntersection, linePoints, lineSegments, linearScale, logScale, manimTheme, mapRange, markupText, mathTable, matrix, matrixMultiply, median$1 as median, midpoint, mul, nearest, niceThresholds, normalize$1 as normalize, ordinalScale, orthocenter, orthogonalLayout, paragraph, parallelLine, path, pathFromString, perpendicular, perpendicularBisector, perpendicularLine, pieLayout, pointScale, polarConstraint, polygon, polyline, powScale, quadraticBezier, radToDeg, randomLayout, rate_functions, rect, rectConstraint, reflect, reflectOverPoint, reflectPoint, reflectPointOverLine, regularPolygon, regularPolygram, renderToRough, renderToSVG, resetTheme, rightAngleMarker, rolling, rotate, rotationMatrix, roughPresets, sampleCubicBezier, sampleParametric, scaleMatrix, sector, semanticStyle, setCurrentTheme, shuffle, sortGroups, sphere3D, springLayout, sqrtScale, square, stackLayout, stackedAreaPoints, star, sub, table, tangentLine, tex, text, themes, tickStep, toSVGString, translationMatrix, treeLayout, triangle, vector, dot$1 as vectorDot };