@esengine/ecs-framework-math 1.0.5 → 2.8.0

package/index.d.ts

@@ -1,1968 +0,0 @@
-/**
- * @esengine/ecs-framework-math v1.0.5
- * TypeScript definitions
- */
-/**
- * 2D向量类
- *
- * 提供完整的2D向量运算功能，包括：
- * - 基础运算（加减乘除）
- * - 向量运算（点积、叉积、归一化）
- * - 几何运算（距离、角度、投影）
- * - 变换操作（旋转、反射、插值）
- */
-declare class Vector2 {
-    /** X分量 */
-    x: number;
-    /** Y分量 */
-    y: number;
-    /**
-     * 创建2D向量
-     * @param x X分量，默认为0
-     * @param y Y分量，默认为0
-     */
-    constructor(x?: number, y?: number);
-    /** 零向量 (0, 0) */
-    static readonly ZERO: Vector2;
-    /** 单位向量 (1, 1) */
-    static readonly ONE: Vector2;
-    /** 右方向向量 (1, 0) */
-    static readonly RIGHT: Vector2;
-    /** 左方向向量 (-1, 0) */
-    static readonly LEFT: Vector2;
-    /** 上方向向量 (0, 1) */
-    static readonly UP: Vector2;
-    /** 下方向向量 (0, -1) */
-    static readonly DOWN: Vector2;
-    /**
-     * 获取向量长度（模）
-     */
-    get length(): number;
-    /**
-     * 获取向量长度的平方
-     */
-    get lengthSquared(): number;
-    /**
-     * 获取向量角度（弧度）
-     */
-    get angle(): number;
-    /**
-     * 检查是否为零向量
-     */
-    get isZero(): boolean;
-    /**
-     * 检查是否为单位向量
-     */
-    get isUnit(): boolean;
-    /**
-     * 设置向量分量
-     * @param x X分量
-     * @param y Y分量
-     * @returns 当前向量实例（链式调用）
-     */
-    set(x: number, y: number): this;
-    /**
-     * 复制另一个向量的值
-     * @param other 源向量
-     * @returns 当前向量实例（链式调用）
-     */
-    copy(other: Vector2): this;
-    /**
-     * 克隆当前向量
-     * @returns 新的向量实例
-     */
-    clone(): Vector2;
-    /**
-     * 向量加法
-     * @param other 另一个向量
-     * @returns 当前向量实例（链式调用）
-     */
-    add(other: Vector2): this;
-    /**
-     * 向量减法
-     * @param other 另一个向量
-     * @returns 当前向量实例（链式调用）
-     */
-    subtract(other: Vector2): this;
-    /**
-     * 向量数乘
-     * @param scalar 标量
-     * @returns 当前向量实例（链式调用）
-     */
-    multiply(scalar: number): this;
-    /**
-     * 向量数除
-     * @param scalar 标量
-     * @returns 当前向量实例（链式调用）
-     */
-    divide(scalar: number): this;
-    /**
-     * 向量取反
-     * @returns 当前向量实例（链式调用）
-     */
-    negate(): this;
-    /**
-     * 计算与另一个向量的点积
-     * @param other 另一个向量
-     * @returns 点积值
-     */
-    dot(other: Vector2): number;
-    /**
-     * 计算与另一个向量的叉积（2D中返回标量）
-     * @param other 另一个向量
-     * @returns 叉积值
-     */
-    cross(other: Vector2): number;
-    /**
-     * 向量归一化（转换为单位向量）
-     * @returns 当前向量实例（链式调用）
-     */
-    normalize(): this;
-    /**
-     * 获取归一化后的向量（不修改原向量）
-     * @returns 新的单位向量
-     */
-    normalized(): Vector2;
-    /**
-     * 计算到另一个向量的距离
-     * @param other 另一个向量
-     * @returns 距离值
-     */
-    distanceTo(other: Vector2): number;
-    /**
-     * 计算到另一个向量的距离平方
-     * @param other 另一个向量
-     * @returns 距离平方值
-     */
-    distanceToSquared(other: Vector2): number;
-    /**
-     * 计算与另一个向量的夹角（弧度）
-     * @param other 另一个向量
-     * @returns 夹角（0到π）
-     */
-    angleTo(other: Vector2): number;
-    /**
-     * 计算向量在另一个向量上的投影
-     * @param onto 投影目标向量
-     * @returns 新的投影向量
-     */
-    projectOnto(onto: Vector2): Vector2;
-    /**
-     * 计算向量在另一个向量上的投影长度
-     * @param onto 投影目标向量
-     * @returns 投影长度（带符号）
-     */
-    projectOntoLength(onto: Vector2): number;
-    /**
-     * 获取垂直向量（逆时针旋转90度）
-     * @returns 新的垂直向量
-     */
-    perpendicular(): Vector2;
-    /**
-     * 向量旋转
-     * @param angle 旋转角度（弧度）
-     * @returns 当前向量实例（链式调用）
-     */
-    rotate(angle: number): this;
-    /**
-     * 获取旋转后的向量（不修改原向量）
-     * @param angle 旋转角度（弧度）
-     * @returns 新的旋转后向量
-     */
-    rotated(angle: number): Vector2;
-    /**
-     * 围绕一个点旋转
-     * @param center 旋转中心点
-     * @param angle 旋转角度（弧度）
-     * @returns 当前向量实例（链式调用）
-     */
-    rotateAround(center: Vector2, angle: number): this;
-    /**
-     * 反射向量（关于法线）
-     * @param normal 法线向量（应为单位向量）
-     * @returns 当前向量实例（链式调用）
-     */
-    reflect(normal: Vector2): this;
-    /**
-     * 获取反射后的向量（不修改原向量）
-     * @param normal 法线向量（应为单位向量）
-     * @returns 新的反射向量
-     */
-    reflected(normal: Vector2): Vector2;
-    /**
-     * 线性插值
-     * @param target 目标向量
-     * @param t 插值参数（0到1）
-     * @returns 当前向量实例（链式调用）
-     */
-    lerp(target: Vector2, t: number): this;
-    /**
-     * 限制向量长度
-     * @param maxLength 最大长度
-     * @returns 当前向量实例（链式调用）
-     */
-    clampLength(maxLength: number): this;
-    /**
-     * 限制向量分量
-     * @param min 最小值向量
-     * @param max 最大值向量
-     * @returns 当前向量实例（链式调用）
-     */
-    clamp(min: Vector2, max: Vector2): this;
-    /**
-     * 检查两个向量是否相等
-     * @param other 另一个向量
-     * @param epsilon 容差，默认为Number.EPSILON
-     * @returns 是否相等
-     */
-    equals(other: Vector2, epsilon?: number): boolean;
-    /**
-     * 检查两个向量是否完全相等
-     * @param other 另一个向量
-     * @returns 是否完全相等
-     */
-    exactEquals(other: Vector2): boolean;
-    /**
-     * 向量加法（静态方法）
-     * @param a 向量a
-     * @param b 向量b
-     * @returns 新的结果向量
-     */
-    static add(a: Vector2, b: Vector2): Vector2;
-    /**
-     * 向量减法（静态方法）
-     * @param a 向量a
-     * @param b 向量b
-     * @returns 新的结果向量
-     */
-    static subtract(a: Vector2, b: Vector2): Vector2;
-    /**
-     * 向量数乘（静态方法）
-     * @param vector 向量
-     * @param scalar 标量
-     * @returns 新的结果向量
-     */
-    static multiply(vector: Vector2, scalar: number): Vector2;
-    /**
-     * 向量点积（静态方法）
-     * @param a 向量a
-     * @param b 向量b
-     * @returns 点积值
-     */
-    static dot(a: Vector2, b: Vector2): number;
-    /**
-     * 向量叉积（静态方法）
-     * @param a 向量a
-     * @param b 向量b
-     * @returns 叉积值
-     */
-    static cross(a: Vector2, b: Vector2): number;
-    /**
-     * 计算两点间距离（静态方法）
-     * @param a 点a
-     * @param b 点b
-     * @returns 距离值
-     */
-    static distance(a: Vector2, b: Vector2): number;
-    /**
-     * 线性插值（静态方法）
-     * @param a 起始向量
-     * @param b 目标向量
-     * @param t 插值参数（0到1）
-     * @returns 新的插值结果向量
-     */
-    static lerp(a: Vector2, b: Vector2, t: number): Vector2;
-    /**
-     * 从角度创建单位向量（静态方法）
-     * @param angle 角度（弧度）
-     * @returns 新的单位向量
-     */
-    static fromAngle(angle: number): Vector2;
-    /**
-     * 从极坐标创建向量（静态方法）
-     * @param length 长度
-     * @param angle 角度（弧度）
-     * @returns 新的向量
-     */
-    static fromPolar(length: number, angle: number): Vector2;
-    /**
-     * 获取两个向量中的最小分量向量（静态方法）
-     * @param a 向量a
-     * @param b 向量b
-     * @returns 新的最小分量向量
-     */
-    static min(a: Vector2, b: Vector2): Vector2;
-    /**
-     * 获取两个向量中的最大分量向量（静态方法）
-     * @param a 向量a
-     * @param b 向量b
-     * @returns 新的最大分量向量
-     */
-    static max(a: Vector2, b: Vector2): Vector2;
-    /**
-     * 转换为字符串
-     * @returns 字符串表示
-     */
-    toString(): string;
-    /**
-     * 转换为数组
-     * @returns [x, y] 数组
-     */
-    toArray(): [number, number];
-    /**
-     * 转换为普通对象
-     * @returns {x, y} 对象
-     */
-    toObject(): {
-        x: number;
-        y: number;
-    };
-}
-
-/**
- * 3x3变换矩阵类
- *
- * 用于2D变换（平移、旋转、缩放）的3x3矩阵
- * 矩阵布局：
- * [m00, m01, m02]   [scaleX * cos, -scaleY * sin, translateX]
- * [m10, m11, m12] = [scaleX * sin,  scaleY * cos, translateY]
- * [m20, m21, m22]   [0,            0,            1]
- */
-declare class Matrix3 {
-    /** 矩阵元素，按行优先存储 */
-    elements: Float32Array;
-    /**
-     * 创建3x3矩阵
-     * @param elements 矩阵元素数组（可选），默认为单位矩阵
-     */
-    constructor(elements?: ArrayLike<number>);
-    /** 单位矩阵 */
-    static readonly IDENTITY: Matrix3;
-    /** 零矩阵 */
-    static readonly ZERO: Matrix3;
-    /** 获取矩阵元素 */
-    get(row: number, col: number): number;
-    /** 设置矩阵元素 */
-    set(row: number, col: number, value: number): this;
-    get m00(): number;
-    set m00(value: number);
-    get m01(): number;
-    set m01(value: number);
-    get m02(): number;
-    set m02(value: number);
-    get m10(): number;
-    set m10(value: number);
-    get m11(): number;
-    set m11(value: number);
-    get m12(): number;
-    set m12(value: number);
-    get m20(): number;
-    set m20(value: number);
-    get m21(): number;
-    set m21(value: number);
-    get m22(): number;
-    set m22(value: number);
-    /**
-     * 设置矩阵为单位矩阵
-     * @returns 当前矩阵实例（链式调用）
-     */
-    identity(): this;
-    /**
-     * 设置矩阵为零矩阵
-     * @returns 当前矩阵实例（链式调用）
-     */
-    zero(): this;
-    /**
-     * 复制另一个矩阵的值
-     * @param other 源矩阵
-     * @returns 当前矩阵实例（链式调用）
-     */
-    copy(other: Matrix3): this;
-    /**
-     * 克隆当前矩阵
-     * @returns 新的矩阵实例
-     */
-    clone(): Matrix3;
-    /**
-     * 从数组设置矩阵元素
-     * @param elements 矩阵元素数组
-     * @returns 当前矩阵实例（链式调用）
-     */
-    fromArray(elements: ArrayLike<number>): this;
-    /**
-     * 矩阵加法
-     * @param other 另一个矩阵
-     * @returns 当前矩阵实例（链式调用）
-     */
-    add(other: Matrix3): this;
-    /**
-     * 矩阵减法
-     * @param other 另一个矩阵
-     * @returns 当前矩阵实例（链式调用）
-     */
-    subtract(other: Matrix3): this;
-    /**
-     * 矩阵标量乘法
-     * @param scalar 标量
-     * @returns 当前矩阵实例（链式调用）
-     */
-    multiplyScalar(scalar: number): this;
-    /**
-     * 矩阵乘法
-     * @param other 另一个矩阵
-     * @returns 当前矩阵实例（链式调用）
-     */
-    multiply(other: Matrix3): this;
-    /**
-     * 左乘另一个矩阵（other * this）
-     * @param other 左乘矩阵
-     * @returns 当前矩阵实例（链式调用）
-     */
-    premultiply(other: Matrix3): this;
-    /**
-     * 设置为平移矩阵
-     * @param x X方向平移
-     * @param y Y方向平移
-     * @returns 当前矩阵实例（链式调用）
-     */
-    makeTranslation(x: number, y: number): this;
-    /**
-     * 设置为旋转矩阵
-     * @param angle 旋转角度（弧度）
-     * @returns 当前矩阵实例（链式调用）
-     */
-    makeRotation(angle: number): this;
-    /**
-     * 设置为缩放矩阵
-     * @param scaleX X方向缩放
-     * @param scaleY Y方向缩放
-     * @returns 当前矩阵实例（链式调用）
-     */
-    makeScale(scaleX: number, scaleY: number): this;
-    /**
-     * 复合平移
-     * @param x X方向平移
-     * @param y Y方向平移
-     * @returns 当前矩阵实例（链式调用）
-     */
-    translate(x: number, y: number): this;
-    /**
-     * 复合旋转
-     * @param angle 旋转角度（弧度）
-     * @returns 当前矩阵实例（链式调用）
-     */
-    rotate(angle: number): this;
-    /**
-     * 复合缩放
-     * @param scaleX X方向缩放
-     * @param scaleY Y方向缩放
-     * @returns 当前矩阵实例（链式调用）
-     */
-    scale(scaleX: number, scaleY: number): this;
-    /**
-     * 矩阵转置
-     * @returns 当前矩阵实例（链式调用）
-     */
-    transpose(): this;
-    /**
-     * 计算矩阵行列式
-     * @returns 行列式值
-     */
-    determinant(): number;
-    /**
-     * 矩阵求逆
-     * @returns 当前矩阵实例（链式调用），如果矩阵不可逆则保持不变
-     */
-    invert(): this;
-    /**
-     * 变换向量（应用完整的3x3变换）
-     * @param vector 向量
-     * @returns 新的变换后的向量
-     */
-    transformVector(vector: Vector2): Vector2;
-    /**
-     * 变换向量（仅应用旋转和缩放，忽略平移）
-     * @param vector 向量
-     * @returns 新的变换后的向量
-     */
-    transformDirection(vector: Vector2): Vector2;
-    /**
-     * 批量变换向量数组
-     * @param vectors 向量数组
-     * @returns 变换后的向量数组
-     */
-    transformVectors(vectors: Vector2[]): Vector2[];
-    /**
-     * 获取平移分量
-     * @returns 平移向量
-     */
-    getTranslation(): Vector2;
-    /**
-     * 获取旋转角度
-     * @returns 旋转角度（弧度）
-     */
-    getRotation(): number;
-    /**
-     * 获取缩放分量
-     * @returns 缩放向量
-     */
-    getScale(): Vector2;
-    /**
-     * 分解变换矩阵为平移、旋转、缩放分量
-     * @returns {translation, rotation, scale}
-     */
-    decompose(): {
-        translation: Vector2;
-        rotation: number;
-        scale: Vector2;
-    };
-    /**
-     * 检查两个矩阵是否相等
-     * @param other 另一个矩阵
-     * @param epsilon 容差，默认为Number.EPSILON
-     * @returns 是否相等
-     */
-    equals(other: Matrix3, epsilon?: number): boolean;
-    /**
-     * 检查两个矩阵是否完全相等
-     * @param other 另一个矩阵
-     * @returns 是否完全相等
-     */
-    exactEquals(other: Matrix3): boolean;
-    /**
-     * 检查是否为单位矩阵
-     * @param epsilon 容差，默认为Number.EPSILON
-     * @returns 是否为单位矩阵
-     */
-    isIdentity(epsilon?: number): boolean;
-    /**
-     * 矩阵乘法（静态方法）
-     * @param a 矩阵a
-     * @param b 矩阵b
-     * @returns 新的结果矩阵
-     */
-    static multiply(a: Matrix3, b: Matrix3): Matrix3;
-    /**
-     * 创建平移矩阵（静态方法）
-     * @param x X方向平移
-     * @param y Y方向平移
-     * @returns 新的平移矩阵
-     */
-    static translation(x: number, y: number): Matrix3;
-    /**
-     * 创建旋转矩阵（静态方法）
-     * @param angle 旋转角度（弧度）
-     * @returns 新的旋转矩阵
-     */
-    static rotation(angle: number): Matrix3;
-    /**
-     * 创建缩放矩阵（静态方法）
-     * @param scaleX X方向缩放
-     * @param scaleY Y方向缩放
-     * @returns 新的缩放矩阵
-     */
-    static scale(scaleX: number, scaleY: number): Matrix3;
-    /**
-     * 创建TRS（平移-旋转-缩放）变换矩阵
-     * @param translation 平移向量
-     * @param rotation 旋转角度（弧度）
-     * @param scale 缩放向量
-     * @returns 新的TRS矩阵
-     */
-    static TRS(translation: Vector2, rotation: number, scale: Vector2): Matrix3;
-    /**
-     * 转换为字符串
-     * @returns 字符串表示
-     */
-    toString(): string;
-    /**
-     * 转换为数组
-     * @returns 矩阵元素数组
-     */
-    toArray(): number[];
-    /**
-     * 转换为CSS transform字符串
-     * @returns CSS transform字符串
-     */
-    toCSSTransform(): string;
-}
-
-/**
- * 2D矩形类
- *
- * 表示一个轴对齐的矩形，提供矩形相关的几何运算功能：
- * - 矩形创建和属性获取
- * - 包含检测（点、矩形）
- * - 相交检测和计算
- * - 变换和操作
- */
-declare class Rectangle {
-    /** 矩形左上角X坐标 */
-    x: number;
-    /** 矩形左上角Y坐标 */
-    y: number;
-    /** 矩形宽度 */
-    width: number;
-    /** 矩形高度 */
-    height: number;
-    /**
-     * 创建矩形
-     * @param x 左上角X坐标，默认为0
-     * @param y 左上角Y坐标，默认为0
-     * @param width 宽度，默认为0
-     * @param height 高度，默认为0
-     */
-    constructor(x?: number, y?: number, width?: number, height?: number);
-    /** 空矩形 */
-    static readonly EMPTY: Rectangle;
-    /** 获取左边界 */
-    get left(): number;
-    /** 获取右边界 */
-    get right(): number;
-    /** 获取上边界 */
-    get top(): number;
-    /** 获取下边界 */
-    get bottom(): number;
-    /** 获取中心X坐标 */
-    get centerX(): number;
-    /** 获取中心Y坐标 */
-    get centerY(): number;
-    /** 获取中心点 */
-    get center(): Vector2;
-    /** 获取左上角点 */
-    get topLeft(): Vector2;
-    /** 获取右上角点 */
-    get topRight(): Vector2;
-    /** 获取左下角点 */
-    get bottomLeft(): Vector2;
-    /** 获取右下角点 */
-    get bottomRight(): Vector2;
-    /** 获取面积 */
-    get area(): number;
-    /** 获取周长 */
-    get perimeter(): number;
-    /** 检查是否为空矩形 */
-    get isEmpty(): boolean;
-    /** 检查是否为正方形 */
-    get isSquare(): boolean;
-    /**
-     * 设置矩形属性
-     * @param x 左上角X坐标
-     * @param y 左上角Y坐标
-     * @param width 宽度
-     * @param height 高度
-     * @returns 当前矩形实例（链式调用）
-     */
-    set(x: number, y: number, width: number, height: number): this;
-    /**
-     * 复制另一个矩形的值
-     * @param other 源矩形
-     * @returns 当前矩形实例（链式调用）
-     */
-    copy(other: Rectangle): this;
-    /**
-     * 克隆当前矩形
-     * @returns 新的矩形实例
-     */
-    clone(): Rectangle;
-    /**
-     * 设置矩形位置
-     * @param x 新的X坐标
-     * @param y 新的Y坐标
-     * @returns 当前矩形实例（链式调用）
-     */
-    setPosition(x: number, y: number): this;
-    /**
-     * 设置矩形大小
-     * @param width 新的宽度
-     * @param height 新的高度
-     * @returns 当前矩形实例（链式调用）
-     */
-    setSize(width: number, height: number): this;
-    /**
-     * 设置矩形中心点
-     * @param centerX 中心X坐标
-     * @param centerY 中心Y坐标
-     * @returns 当前矩形实例（链式调用）
-     */
-    setCenter(centerX: number, centerY: number): this;
-    /**
-     * 平移矩形
-     * @param dx X方向偏移
-     * @param dy Y方向偏移
-     * @returns 当前矩形实例（链式调用）
-     */
-    translate(dx: number, dy: number): this;
-    /**
-     * 缩放矩形（从中心缩放）
-     * @param scaleX X方向缩放因子
-     * @param scaleY Y方向缩放因子，默认等于scaleX
-     * @returns 当前矩形实例（链式调用）
-     */
-    scale(scaleX: number, scaleY?: number): this;
-    /**
-     * 扩展矩形
-     * @param amount 扩展量（正值扩大，负值缩小）
-     * @returns 当前矩形实例（链式调用）
-     */
-    inflate(amount: number): this;
-    /**
-     * 扩展矩形（分别指定水平和垂直方向）
-     * @param horizontal 水平方向扩展量
-     * @param vertical 垂直方向扩展量
-     * @returns 当前矩形实例（链式调用）
-     */
-    inflateXY(horizontal: number, vertical: number): this;
-    /**
-     * 检查是否包含指定点
-     * @param point 点
-     * @returns 是否包含
-     */
-    containsPoint(point: Vector2): boolean;
-    /**
-     * 检查是否包含指定坐标
-     * @param x X坐标
-     * @param y Y坐标
-     * @returns 是否包含
-     */
-    contains(x: number, y: number): boolean;
-    /**
-     * 检查是否完全包含另一个矩形
-     * @param other 另一个矩形
-     * @returns 是否完全包含
-     */
-    containsRect(other: Rectangle): boolean;
-    /**
-     * 检查是否与另一个矩形相交
-     * @param other 另一个矩形
-     * @returns 是否相交
-     */
-    intersects(other: Rectangle): boolean;
-    /**
-     * 计算与另一个矩形的相交矩形
-     * @param other 另一个矩形
-     * @returns 相交矩形，如果不相交返回空矩形
-     */
-    intersection(other: Rectangle): Rectangle;
-    /**
-     * 计算与另一个矩形的并集矩形
-     * @param other 另一个矩形
-     * @returns 并集矩形
-     */
-    union(other: Rectangle): Rectangle;
-    /**
-     * 计算相交面积
-     * @param other 另一个矩形
-     * @returns 相交面积
-     */
-    intersectionArea(other: Rectangle): number;
-    /**
-     * 计算点到矩形的最短距离
-     * @param point 点
-     * @returns 最短距离
-     */
-    distanceToPoint(point: Vector2): number;
-    /**
-     * 计算两个矩形间的最短距离
-     * @param other 另一个矩形
-     * @returns 最短距离（相交时为0）
-     */
-    distanceToRect(other: Rectangle): number;
-    /**
-     * 获取矩形上距离指定点最近的点
-     * @param point 指定点
-     * @returns 最近点
-     */
-    closestPointTo(point: Vector2): Vector2;
-    /**
-     * 检查两个矩形是否相等
-     * @param other 另一个矩形
-     * @param epsilon 容差，默认为Number.EPSILON
-     * @returns 是否相等
-     */
-    equals(other: Rectangle, epsilon?: number): boolean;
-    /**
-     * 检查两个矩形是否完全相等
-     * @param other 另一个矩形
-     * @returns 是否完全相等
-     */
-    exactEquals(other: Rectangle): boolean;
-    /**
-     * 从中心点和大小创建矩形
-     * @param centerX 中心X坐标
-     * @param centerY 中心Y坐标
-     * @param width 宽度
-     * @param height 高度
-     * @returns 新的矩形实例
-     */
-    static fromCenter(centerX: number, centerY: number, width: number, height: number): Rectangle;
-    /**
-     * 从两个点创建矩形
-     * @param point1 第一个点
-     * @param point2 第二个点
-     * @returns 新的矩形实例
-     */
-    static fromPoints(point1: Vector2, point2: Vector2): Rectangle;
-    /**
-     * 从点数组创建包围矩形
-     * @param points 点数组
-     * @returns 包围矩形
-     */
-    static fromPointArray(points: Vector2[]): Rectangle;
-    /**
-     * 创建正方形
-     * @param x 左上角X坐标
-     * @param y 左上角Y坐标
-     * @param size 边长
-     * @returns 新的正方形矩形
-     */
-    static square(x: number, y: number, size: number): Rectangle;
-    /**
-     * 线性插值两个矩形
-     * @param a 起始矩形
-     * @param b 目标矩形
-     * @param t 插值参数（0到1）
-     * @returns 新的插值结果矩形
-     */
-    static lerp(a: Rectangle, b: Rectangle, t: number): Rectangle;
-    /**
-     * 转换为字符串
-     * @returns 字符串表示
-     */
-    toString(): string;
-    /**
-     * 转换为数组
-     * @returns [x, y, width, height] 数组
-     */
-    toArray(): [number, number, number, number];
-    /**
-     * 转换为普通对象
-     * @returns {x, y, width, height} 对象
-     */
-    toObject(): {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-    };
-    /**
-     * 获取四个顶点
-     * @returns 顶点数组 [topLeft, topRight, bottomRight, bottomLeft]
-     */
-    getVertices(): Vector2[];
-}
-
-/**
- * 2D圆形类
- *
- * 表示一个圆形，提供圆形相关的几何运算功能：
- * - 圆形创建和属性获取
- * - 包含检测（点、圆形）
- * - 相交检测和计算
- * - 变换和操作
- */
-declare class Circle {
-    /** 圆心X坐标 */
-    x: number;
-    /** 圆心Y坐标 */
-    y: number;
-    /** 半径 */
-    radius: number;
-    /**
-     * 创建圆形
-     * @param x 圆心X坐标，默认为0
-     * @param y 圆心Y坐标，默认为0
-     * @param radius 半径，默认为0
-     */
-    constructor(x?: number, y?: number, radius?: number);
-    /** 空圆形 */
-    static readonly EMPTY: Circle;
-    /** 单位圆 */
-    static readonly UNIT: Circle;
-    /** 获取圆心坐标 */
-    get center(): Vector2;
-    /** 设置圆心坐标 */
-    set center(value: Vector2);
-    /** 获取直径 */
-    get diameter(): number;
-    /** 设置直径 */
-    set diameter(value: number);
-    /** 获取面积 */
-    get area(): number;
-    /** 获取周长 */
-    get circumference(): number;
-    /** 获取包围矩形 */
-    get bounds(): Rectangle;
-    /** 检查是否为空圆形 */
-    get isEmpty(): boolean;
-    /**
-     * 设置圆形属性
-     * @param x 圆心X坐标
-     * @param y 圆心Y坐标
-     * @param radius 半径
-     * @returns 当前圆形实例（链式调用）
-     */
-    set(x: number, y: number, radius: number): this;
-    /**
-     * 复制另一个圆形的值
-     * @param other 源圆形
-     * @returns 当前圆形实例（链式调用）
-     */
-    copy(other: Circle): this;
-    /**
-     * 克隆当前圆形
-     * @returns 新的圆形实例
-     */
-    clone(): Circle;
-    /**
-     * 设置圆心位置
-     * @param x 新的X坐标
-     * @param y 新的Y坐标
-     * @returns 当前圆形实例（链式调用）
-     */
-    setPosition(x: number, y: number): this;
-    /**
-     * 设置圆心位置（使用向量）
-     * @param center 新的圆心位置
-     * @returns 当前圆形实例（链式调用）
-     */
-    setCenter(center: Vector2): this;
-    /**
-     * 设置半径
-     * @param radius 新的半径
-     * @returns 当前圆形实例（链式调用）
-     */
-    setRadius(radius: number): this;
-    /**
-     * 平移圆形
-     * @param dx X方向偏移
-     * @param dy Y方向偏移
-     * @returns 当前圆形实例（链式调用）
-     */
-    translate(dx: number, dy: number): this;
-    /**
-     * 平移圆形（使用向量）
-     * @param offset 偏移向量
-     * @returns 当前圆形实例（链式调用）
-     */
-    translateBy(offset: Vector2): this;
-    /**
-     * 缩放圆形
-     * @param scale 缩放因子
-     * @returns 当前圆形实例（链式调用）
-     */
-    scale(scale: number): this;
-    /**
-     * 扩展圆形
-     * @param amount 扩展量（正值扩大半径，负值缩小半径）
-     * @returns 当前圆形实例（链式调用）
-     */
-    inflate(amount: number): this;
-    /**
-     * 检查是否包含指定点
-     * @param point 点
-     * @returns 是否包含
-     */
-    containsPoint(point: Vector2): boolean;
-    /**
-     * 检查是否包含指定坐标
-     * @param x X坐标
-     * @param y Y坐标
-     * @returns 是否包含
-     */
-    contains(x: number, y: number): boolean;
-    /**
-     * 检查是否完全包含另一个圆形
-     * @param other 另一个圆形
-     * @returns 是否完全包含
-     */
-    containsCircle(other: Circle): boolean;
-    /**
-     * 检查点是否在圆的边界上
-     * @param point 点
-     * @param epsilon 容差，默认为Number.EPSILON
-     * @returns 是否在边界上
-     */
-    pointOnBoundary(point: Vector2, epsilon?: number): boolean;
-    /**
-     * 检查是否与另一个圆形相交
-     * @param other 另一个圆形
-     * @returns 是否相交
-     */
-    intersects(other: Circle): boolean;
-    /**
-     * 检查是否与矩形相交
-     * @param rect 矩形
-     * @returns 是否相交
-     */
-    intersectsRect(rect: Rectangle): boolean;
-    /**
-     * 计算与另一个圆形的相交面积
-     * @param other 另一个圆形
-     * @returns 相交面积
-     */
-    intersectionArea(other: Circle): number;
-    /**
-     * 计算圆心到点的距离
-     * @param point 点
-     * @returns 距离
-     */
-    distanceToPoint(point: Vector2): number;
-    /**
-     * 计算圆形边界到点的最短距离
-     * @param point 点
-     * @returns 最短距离（点在圆内时为负值）
-     */
-    distanceToPointFromBoundary(point: Vector2): number;
-    /**
-     * 计算两个圆心之间的距离
-     * @param other 另一个圆形
-     * @returns 圆心距离
-     */
-    distanceToCircle(other: Circle): number;
-    /**
-     * 计算两个圆形边界之间的最短距离
-     * @param other 另一个圆形
-     * @returns 最短距离（相交时为负值）
-     */
-    distanceToCircleFromBoundary(other: Circle): number;
-    /**
-     * 计算圆形到矩形的最短距离
-     * @param rect 矩形
-     * @returns 最短距离
-     */
-    distanceToRect(rect: Rectangle): number;
-    /**
-     * 获取圆形上距离指定点最近的点
-     * @param point 指定点
-     * @returns 最近点
-     */
-    closestPointTo(point: Vector2): Vector2;
-    /**
-     * 获取圆形上距离指定点最远的点
-     * @param point 指定点
-     * @returns 最远点
-     */
-    farthestPointFrom(point: Vector2): Vector2;
-    /**
-     * 获取指定角度上的圆周点
-     * @param angle 角度（弧度）
-     * @returns 圆周点
-     */
-    getPointAtAngle(angle: number): Vector2;
-    /**
-     * 获取点相对于圆心的角度
-     * @param point 点
-     * @returns 角度（弧度）
-     */
-    getAngleToPoint(point: Vector2): number;
-    /**
-     * 获取圆形与直线的交点
-     * @param lineStart 直线起点
-     * @param lineEnd 直线终点
-     * @returns 交点数组（0-2个点）
-     */
-    getLineIntersections(lineStart: Vector2, lineEnd: Vector2): Vector2[];
-    /**
-     * 检查两个圆形是否相等
-     * @param other 另一个圆形
-     * @param epsilon 容差，默认为Number.EPSILON
-     * @returns 是否相等
-     */
-    equals(other: Circle, epsilon?: number): boolean;
-    /**
-     * 检查两个圆形是否完全相等
-     * @param other 另一个圆形
-     * @returns 是否完全相等
-     */
-    exactEquals(other: Circle): boolean;
-    /**
-     * 从直径创建圆形
-     * @param x 圆心X坐标
-     * @param y 圆心Y坐标
-     * @param diameter 直径
-     * @returns 新的圆形实例
-     */
-    static fromDiameter(x: number, y: number, diameter: number): Circle;
-    /**
-     * 从三个点创建外接圆
-     * @param p1 第一个点
-     * @param p2 第二个点
-     * @param p3 第三个点
-     * @returns 外接圆，如果三点共线返回null
-     */
-    static fromThreePoints(p1: Vector2, p2: Vector2, p3: Vector2): Circle | null;
-    /**
-     * 从点数组创建最小包围圆
-     * @param points 点数组
-     * @returns 最小包围圆
-     */
-    static fromPointArray(points: Vector2[]): Circle;
-    /**
-     * 线性插值两个圆形
-     * @param a 起始圆形
-     * @param b 目标圆形
-     * @param t 插值参数（0到1）
-     * @returns 新的插值结果圆形
-     */
-    static lerp(a: Circle, b: Circle, t: number): Circle;
-    /**
-     * 转换为字符串
-     * @returns 字符串表示
-     */
-    toString(): string;
-    /**
-     * 转换为数组
-     * @returns [x, y, radius] 数组
-     */
-    toArray(): [number, number, number];
-    /**
-     * 转换为普通对象
-     * @returns {x, y, radius} 对象
-     */
-    toObject(): {
-        x: number;
-        y: number;
-        radius: number;
-    };
-}
-
-/**
- * 数学工具函数集合
- *
- * 提供常用的数学运算、插值、随机数生成等实用工具函数
- */
-declare class MathUtils {
-    /** 圆周率 */
-    static readonly PI: number;
-    /** 2π */
-    static readonly TWO_PI: number;
-    /** π/2 */
-    static readonly HALF_PI: number;
-    /** π/4 */
-    static readonly QUARTER_PI: number;
-    /** 角度到弧度转换系数 */
-    static readonly DEG_TO_RAD: number;
-    /** 弧度到角度转换系数 */
-    static readonly RAD_TO_DEG: number;
-    /** 黄金比例 */
-    static readonly GOLDEN_RATIO: number;
-    /** 默认浮点数比较容差 */
-    static readonly EPSILON: number;
-    /**
-     * 角度转弧度
-     * @param degrees 角度值
-     * @returns 弧度值
-     */
-    static degToRad(degrees: number): number;
-    /**
-     * 弧度转角度
-     * @param radians 弧度值
-     * @returns 角度值
-     */
-    static radToDeg(radians: number): number;
-    /**
-     * 规范化角度到[0, 2π)范围
-     * @param radians 角度（弧度）
-     * @returns 规范化后的角度
-     */
-    static normalizeAngle(radians: number): number;
-    /**
-     * 规范化角度到(-π, π]范围
-     * @param radians 角度（弧度）
-     * @returns 规范化后的角度
-     */
-    static normalizeAngleSigned(radians: number): number;
-    /**
-     * 计算两个角度之间的最短角度差
-     * @param from 起始角度（弧度）
-     * @param to 目标角度（弧度）
-     * @returns 角度差（-π到π）
-     */
-    static angleDifference(from: number, to: number): number;
-    /**
-     * 角度插值（处理角度环绕）
-     * @param from 起始角度（弧度）
-     * @param to 目标角度（弧度）
-     * @param t 插值参数（0到1）
-     * @returns 插值结果角度
-     */
-    static lerpAngle(from: number, to: number, t: number): number;
-    /**
-     * 限制数值在指定范围内
-     * @param value 待限制的值
-     * @param min 最小值
-     * @param max 最大值
-     * @returns 限制后的值
-     */
-    static clamp(value: number, min: number, max: number): number;
-    /**
-     * 限制数值在0到1之间
-     * @param value 待限制的值
-     * @returns 限制后的值
-     */
-    static clamp01(value: number): number;
-    /**
-     * 线性插值
-     * @param a 起始值
-     * @param b 目标值
-     * @param t 插值参数（0到1）
-     * @returns 插值结果
-     */
-    static lerp(a: number, b: number, t: number): number;
-    /**
-     * 反向线性插值（获取插值参数）
-     * @param a 起始值
-     * @param b 目标值
-     * @param value 当前值
-     * @returns 插值参数
-     */
-    static inverseLerp(a: number, b: number, value: number): number;
-    /**
-     * 重映射数值从一个范围到另一个范围
-     * @param value 输入值
-     * @param inMin 输入范围最小值
-     * @param inMax 输入范围最大值
-     * @param outMin 输出范围最小值
-     * @param outMax 输出范围最大值
-     * @returns 重映射后的值
-     */
-    static remap(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
-    /**
-     * 平滑阶跃函数（Hermite插值）
-     * @param t 输入参数（0到1）
-     * @returns 平滑输出（0到1）
-     */
-    static smoothStep(t: number): number;
-    /**
-     * 更平滑的阶跃函数
-     * @param t 输入参数（0到1）
-     * @returns 平滑输出（0到1）
-     */
-    static smootherStep(t: number): number;
-    /**
-     * 浮点数相等比较
-     * @param a 数值a
-     * @param b 数值b
-     * @param epsilon 容差，默认为EPSILON
-     * @returns 是否相等
-     */
-    static approximately(a: number, b: number, epsilon?: number): boolean;
-    /**
-     * 检查数值是否为零
-     * @param value 数值
-     * @param epsilon 容差，默认为EPSILON
-     * @returns 是否为零
-     */
-    static isZero(value: number, epsilon?: number): boolean;
-    /**
-     * 获取数值的符号
-     * @param value 数值
-     * @returns 1、-1或0
-     */
-    static sign(value: number): number;
-    /**
-     * 生成指定范围内的随机数
-     * @param min 最小值（包含）
-     * @param max 最大值（不包含）
-     * @returns 随机数
-     */
-    static random(min?: number, max?: number): number;
-    /**
-     * 生成指定范围内的随机整数
-     * @param min 最小值（包含）
-     * @param max 最大值（包含）
-     * @returns 随机整数
-     */
-    static randomInt(min: number, max: number): number;
-    /**
-     * 随机选择数组中的一个元素
-     * @param array 数组
-     * @returns 随机元素
-     */
-    static randomChoice<T>(array: T[]): T;
-    /**
-     * 生成随机布尔值
-     * @param probability 为true的概率（0到1），默认0.5
-     * @returns 随机布尔值
-     */
-    static randomBoolean(probability?: number): boolean;
-    /**
-     * 生成单位圆内的随机点
-     * @returns 随机向量
-     */
-    static randomInUnitCircle(): Vector2;
-    /**
-     * 生成单位圆上的随机点
-     * @returns 随机单位向量
-     */
-    static randomOnUnitCircle(): Vector2;
-    /**
-     * 快速平方根倒数（用于归一化）
-     * @param value 输入值
-     * @returns 平方根倒数
-     */
-    static fastInverseSqrt(value: number): number;
-    /**
-     * 快速幂运算（整数指数）
-     * @param base 底数
-     * @param exponent 指数（整数）
-     * @returns 幂运算结果
-     */
-    static fastPow(base: number, exponent: number): number;
-    /**
-     * 阶乘
-     * @param n 非负整数
-     * @returns 阶乘结果
-     */
-    static factorial(n: number): number;
-    /**
-     * 最大公约数
-     * @param a 整数a
-     * @param b 整数b
-     * @returns 最大公约数
-     */
-    static gcd(a: number, b: number): number;
-    /**
-     * 最小公倍数
-     * @param a 整数a
-     * @param b 整数b
-     * @returns 最小公倍数
-     */
-    static lcm(a: number, b: number): number;
-    /**
-     * 斐波那契数列
-     * @param n 项数
-     * @returns 第n项斐波那契数
-     */
-    static fibonacci(n: number): number;
-    /**
-     * 等差数列求和
-     * @param first 首项
-     * @param last 末项
-     * @param count 项数
-     * @returns 等差数列和
-     */
-    static arithmeticSum(first: number, last: number, count: number): number;
-    /**
-     * 等比数列求和
-     * @param first 首项
-     * @param ratio 公比
-     * @param count 项数
-     * @returns 等比数列和
-     */
-    static geometricSum(first: number, ratio: number, count: number): number;
-    /**
-     * 贝塞尔二次曲线
-     * @param p0 控制点0
-     * @param p1 控制点1
-     * @param p2 控制点2
-     * @param t 参数（0到1）
-     * @returns 曲线上的点
-     */
-    static quadraticBezier(p0: Vector2, p1: Vector2, p2: Vector2, t: number): Vector2;
-    /**
-     * 贝塞尔三次曲线
-     * @param p0 控制点0
-     * @param p1 控制点1
-     * @param p2 控制点2
-     * @param p3 控制点3
-     * @param t 参数（0到1）
-     * @returns 曲线上的点
-     */
-    static cubicBezier(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, t: number): Vector2;
-    /**
-     * Catmull-Rom样条插值
-     * @param p0 控制点0
-     * @param p1 控制点1
-     * @param p2 控制点2
-     * @param p3 控制点3
-     * @param t 参数（0到1）
-     * @returns 插值结果点
-     */
-    static catmullRom(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2, t: number): Vector2;
-    /**
-     * 简单伪随机噪声（基于种子）
-     * @param x 输入X
-     * @param y 输入Y
-     * @param seed 种子
-     * @returns 噪声值（0到1）
-     */
-    static noise(x: number, y?: number, seed?: number): number;
-    /**
-     * 平滑噪声
-     * @param x 输入X
-     * @param y 输入Y
-     * @param seed 种子
-     * @returns 平滑噪声值（0到1）
-     */
-    static smoothNoise(x: number, y?: number, seed?: number): number;
-    /**
-     * 将数值转换为指定精度
-     * @param value 数值
-     * @param precision 精度（小数位数）
-     * @returns 转换后的数值
-     */
-    static toPrecision(value: number, precision: number): number;
-    /**
-     * 检查数值是否在指定范围内
-     * @param value 数值
-     * @param min 最小值
-     * @param max 最大值
-     * @returns 是否在范围内
-     */
-    static inRange(value: number, min: number, max: number): boolean;
-    /**
-     * 获取数组中的最小值
-     * @param values 数值数组
-     * @returns 最小值
-     */
-    static min(...values: number[]): number;
-    /**
-     * 获取数组中的最大值
-     * @param values 数值数组
-     * @returns 最大值
-     */
-    static max(...values: number[]): number;
-    /**
-     * 计算数组的平均值
-     * @param values 数值数组
-     * @returns 平均值
-     */
-    static average(values: number[]): number;
-    /**
-     * 计算数组的中位数
-     * @param values 数值数组
-     * @returns 中位数
-     */
-    static median(values: number[]): number;
-}
-
-/**
- * 碰撞信息接口
- */
-interface CollisionInfo {
-    /** 是否发生碰撞 */
-    collided: boolean;
-    /** 碰撞法线（指向第二个对象） */
-    normal?: Vector2;
-    /** 穿透深度 */
-    penetration?: number;
-    /** 碰撞点 */
-    contactPoint?: Vector2;
-}
-/**
- * 碰撞检测器
- *
- * 提供各种几何体之间的碰撞检测功能
- */
-declare class CollisionDetector {
-    /**
-     * 点与圆形碰撞检测
-     * @param point 点
-     * @param circle 圆形
-     * @returns 碰撞信息
-     */
-    static pointCircle(point: Vector2, circle: Circle): CollisionInfo;
-    /**
-     * 点与矩形碰撞检测
-     * @param point 点
-     * @param rect 矩形
-     * @returns 碰撞信息
-     */
-    static pointRect(point: Vector2, rect: Rectangle): CollisionInfo;
-    /**
-     * 圆形与圆形碰撞检测
-     * @param circle1 第一个圆形
-     * @param circle2 第二个圆形
-     * @returns 碰撞信息
-     */
-    static circleCircle(circle1: Circle, circle2: Circle): CollisionInfo;
-    /**
-     * 圆形与矩形碰撞检测
-     * @param circle 圆形
-     * @param rect 矩形
-     * @returns 碰撞信息
-     */
-    static circleRect(circle: Circle, rect: Rectangle): CollisionInfo;
-    /**
-     * 矩形与矩形碰撞检测（AABB）
-     * @param rect1 第一个矩形
-     * @param rect2 第二个矩形
-     * @returns 碰撞信息
-     */
-    static rectRect(rect1: Rectangle, rect2: Rectangle): CollisionInfo;
-    /**
-     * 射线与圆形相交检测
-     * @param rayOrigin 射线起点
-     * @param rayDirection 射线方向（单位向量）
-     * @param circle 圆形
-     * @param maxDistance 最大检测距离，默认无限
-     * @returns 碰撞信息，包含距离信息
-     */
-    static rayCircle(rayOrigin: Vector2, rayDirection: Vector2, circle: Circle, maxDistance?: number): CollisionInfo & {
-        distance?: number;
-    };
-    /**
-     * 射线与矩形相交检测
-     * @param rayOrigin 射线起点
-     * @param rayDirection 射线方向（单位向量）
-     * @param rect 矩形
-     * @param maxDistance 最大检测距离，默认无限
-     * @returns 碰撞信息，包含距离信息
-     */
-    static rayRect(rayOrigin: Vector2, rayDirection: Vector2, rect: Rectangle, maxDistance?: number): CollisionInfo & {
-        distance?: number;
-    };
-    /**
-     * 线段与线段相交检测
-     * @param p1 第一条线段起点
-     * @param p2 第一条线段终点
-     * @param p3 第二条线段起点
-     * @param p4 第二条线段终点
-     * @returns 碰撞信息
-     */
-    static lineSegmentLineSegment(p1: Vector2, p2: Vector2, p3: Vector2, p4: Vector2): CollisionInfo;
-    /**
-     * 线段与圆形相交检测
-     * @param lineStart 线段起点
-     * @param lineEnd 线段终点
-     * @param circle 圆形
-     * @returns 碰撞信息
-     */
-    static lineSegmentCircle(lineStart: Vector2, lineEnd: Vector2, circle: Circle): CollisionInfo;
-    /**
-     * AABB包围盒快速排斥测试
-     * @param bounds1 第一个包围盒
-     * @param bounds2 第二个包围盒
-     * @returns 是否可能相交
-     */
-    static aabbTest(bounds1: Rectangle, bounds2: Rectangle): boolean;
-    /**
-     * 圆形包围盒快速排斥测试
-     * @param center1 第一个圆心
-     * @param radius1 第一个半径
-     * @param center2 第二个圆心
-     * @param radius2 第二个半径
-     * @returns 是否可能相交
-     */
-    static circleTest(center1: Vector2, radius1: number, center2: Vector2, radius2: number): boolean;
-}
-
-/**
- * 缓动函数集合
- *
- * 提供各种常用的缓动函数，用于创建平滑的动画效果
- * 所有函数接受时间参数 t (0-1)，返回缓动后的值 (通常0-1)
- */
-declare class Easing {
-    /**
-     * 线性缓动（无缓动）
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static linear(t: number): number;
-    /**
-     * 二次方缓入
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quadIn(t: number): number;
-    /**
-     * 二次方缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quadOut(t: number): number;
-    /**
-     * 二次方缓入缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quadInOut(t: number): number;
-    /**
-     * 三次方缓入
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static cubicIn(t: number): number;
-    /**
-     * 三次方缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static cubicOut(t: number): number;
-    /**
-     * 三次方缓入缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static cubicInOut(t: number): number;
-    /**
-     * 四次方缓入
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quartIn(t: number): number;
-    /**
-     * 四次方缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quartOut(t: number): number;
-    /**
-     * 四次方缓入缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quartInOut(t: number): number;
-    /**
-     * 五次方缓入
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quintIn(t: number): number;
-    /**
-     * 五次方缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quintOut(t: number): number;
-    /**
-     * 五次方缓入缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static quintInOut(t: number): number;
-    /**
-     * 正弦缓入
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static sineIn(t: number): number;
-    /**
-     * 正弦缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static sineOut(t: number): number;
-    /**
-     * 正弦缓入缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static sineInOut(t: number): number;
-    /**
-     * 指数缓入
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static expoIn(t: number): number;
-    /**
-     * 指数缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static expoOut(t: number): number;
-    /**
-     * 指数缓入缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static expoInOut(t: number): number;
-    /**
-     * 圆形缓入
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static circIn(t: number): number;
-    /**
-     * 圆形缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static circOut(t: number): number;
-    /**
-     * 圆形缓入缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static circInOut(t: number): number;
-    /**
-     * 回弹缓入
-     * @param t 时间参数 (0-1)
-     * @param s 回弹强度，默认1.70158
-     * @returns 缓动值
-     */
-    static backIn(t: number, s?: number): number;
-    /**
-     * 回弹缓出
-     * @param t 时间参数 (0-1)
-     * @param s 回弹强度，默认1.70158
-     * @returns 缓动值
-     */
-    static backOut(t: number, s?: number): number;
-    /**
-     * 回弹缓入缓出
-     * @param t 时间参数 (0-1)
-     * @param s 回弹强度，默认1.70158
-     * @returns 缓动值
-     */
-    static backInOut(t: number, s?: number): number;
-    /**
-     * 弹性缓入
-     * @param t 时间参数 (0-1)
-     * @param amplitude 振幅，默认1
-     * @param period 周期，默认0.3
-     * @returns 缓动值
-     */
-    static elasticIn(t: number, amplitude?: number, period?: number): number;
-    /**
-     * 弹性缓出
-     * @param t 时间参数 (0-1)
-     * @param amplitude 振幅，默认1
-     * @param period 周期，默认0.3
-     * @returns 缓动值
-     */
-    static elasticOut(t: number, amplitude?: number, period?: number): number;
-    /**
-     * 弹性缓入缓出
-     * @param t 时间参数 (0-1)
-     * @param amplitude 振幅，默认1
-     * @param period 周期，默认0.45
-     * @returns 缓动值
-     */
-    static elasticInOut(t: number, amplitude?: number, period?: number): number;
-    /**
-     * 跳跃缓入
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static bounceIn(t: number): number;
-    /**
-     * 跳跃缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static bounceOut(t: number): number;
-    /**
-     * 跳跃缓入缓出
-     * @param t 时间参数 (0-1)
-     * @returns 缓动值
-     */
-    static bounceInOut(t: number): number;
-    /**
-     * 创建自定义缓动函数（组合多个缓动）
-     * @param easingFunctions 缓动函数数组
-     * @param weights 权重数组，默认均等
-     * @returns 组合后的缓动函数
-     */
-    static combine(easingFunctions: ((t: number) => number)[], weights?: number[]): (t: number) => number;
-    /**
-     * 创建分段缓动函数
-     * @param segments 分段配置数组，每段包含 {duration, easing}
-     * @returns 分段缓动函数
-     */
-    static piecewise(segments: Array<{
-        duration: number;
-        easing: (t: number) => number;
-    }>): (t: number) => number;
-    /**
-     * 创建反向缓动函数
-     * @param easing 原缓动函数
-     * @returns 反向缓动函数
-     */
-    static reverse(easing: (t: number) => number): (t: number) => number;
-    /**
-     * 创建镜像缓动函数（先正向再反向）
-     * @param easing 原缓动函数
-     * @returns 镜像缓动函数
-     */
-    static mirror(easing: (t: number) => number): (t: number) => number;
-    /** 平滑进入（常用于UI动画） */
-    static readonly smoothIn: typeof Easing.quadOut;
-    /** 平滑退出（常用于UI动画） */
-    static readonly smoothOut: typeof Easing.quadIn;
-    /** 快速进入（常用于出现动画） */
-    static readonly quickIn: typeof Easing.cubicOut;
-    /** 快速退出（常用于消失动画） */
-    static readonly quickOut: typeof Easing.cubicIn;
-    /** 自然运动（模拟物理） */
-    static readonly natural: typeof Easing.quartOut;
-    /** 强调效果（吸引注意力） */
-    static readonly emphasize: typeof Easing.backOut;
-}
-
-/**
- * 插值器类型定义
- */
-type InterpolatorFunction<T> = (from: T, to: T, t: number) => T;
-/**
- * 关键帧数据结构
- */
-interface Keyframe<T> {
-    time: number;
-    value: T;
-    easing?: (t: number) => number;
-}
-/**
- * 带缓存的插值器类
- * 用于需要重复插值相同起始和目标值的情况
- */
-declare class CachedInterpolator<T> {
-    private from?;
-    private to?;
-    private interpolator;
-    private cache;
-    constructor(interpolator: InterpolatorFunction<T>);
-    /**
-     * 设置插值范围
-     * @param from 起始值
-     * @param to 目标值
-     */
-    setRange(from: T, to: T): void;
-    /**
-     * 获取插值结果
-     * @param t 插值参数
-     * @returns 插值结果
-     */
-    get(t: number): T;
-    /**
-     * 清空缓存
-     */
-    clearCache(): void;
-}
-/**
- * 插值工具类
- *
- * 提供各种类型的插值功能，用于创建平滑的数值变化
- */
-declare class Interpolation {
-    /**
-     * 数值线性插值
-     * @param from 起始值
-     * @param to 目标值
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果
-     */
-    static number(from: number, to: number, t: number): number;
-    /**
-     * 向量线性插值
-     * @param from 起始向量
-     * @param to 目标向量
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果向量
-     */
-    static vector2(from: Vector2, to: Vector2, t: number): Vector2;
-    /**
-     * 角度插值（处理角度环绕）
-     * @param from 起始角度（弧度）
-     * @param to 目标角度（弧度）
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果角度
-     */
-    static angle(from: number, to: number, t: number): number;
-    /**
-     * 颜色插值（RGB）
-     * @param from 起始颜色 [r, g, b, a?]
-     * @param to 目标颜色 [r, g, b, a?]
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果颜色
-     */
-    static color(from: number[], to: number[], t: number): number[];
-    /**
-     * 三次样条插值
-     * @param p0 控制点0
-     * @param p1 控制点1（起点）
-     * @param p2 控制点2（终点）
-     * @param p3 控制点3
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果
-     */
-    static cubicSpline(p0: number, p1: number, p2: number, p3: number, t: number): number;
-    /**
-     * Hermite插值
-     * @param p0 起始点
-     * @param m0 起始切线
-     * @param p1 结束点
-     * @param m1 结束切线
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果
-     */
-    static hermite(p0: number, m0: number, p1: number, m1: number, t: number): number;
-    /**
-     * 球面线性插值（适用于方向向量）
-     * @param from 起始单位向量
-     * @param to 目标单位向量
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果向量
-     */
-    static slerp(from: Vector2, to: Vector2, t: number): Vector2;
-    /**
-     * 创建带缓存的插值器
-     * 用于需要重复插值相同起始和目标值的情况
-     * @param interpolator 插值函数
-     * @returns 缓存插值器实例
-     */
-    static createCachedInterpolator<T>(interpolator: InterpolatorFunction<T>): CachedInterpolator<T>;
-    /**
-     * 样条曲线插值（通过多个控制点）
-     * @param points 控制点数组
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果
-     */
-    static spline(points: number[], t: number): number;
-    /**
-     * 向量样条曲线插值
-     * @param points 控制点数组
-     * @param t 插值参数 (0-1)
-     * @returns 插值结果向量
-     */
-    static vectorSpline(points: Vector2[], t: number): Vector2;
-    /**
-     * 关键帧动画插值
-     * @param keyframes 关键帧数组（按时间排序）
-     * @param time 当前时间
-     * @param interpolator 插值函数
-     * @returns 插值结果
-     */
-    static keyframe<T>(keyframes: Keyframe<T>[], time: number, interpolator: InterpolatorFunction<T>): T;
-    /**
-     * 路径插值（沿着由点组成的路径）
-     * @param path 路径点数组
-     * @param t 插值参数 (0-1)
-     * @param closed 是否为闭合路径
-     * @returns 路径上的点
-     */
-    static pathInterpolation(path: Vector2[], t: number, closed?: boolean): Vector2;
-    /**
-     * 计算路径总长度
-     * @param path 路径点数组
-     * @param closed 是否为闭合路径
-     * @returns 路径总长度
-     */
-    static getPathLength(path: Vector2[], closed?: boolean): number;
-    /**
-     * 创建数值插值器
-     * @param from 起始值
-     * @param to 目标值
-     * @returns 插值器函数
-     */
-    static createNumberInterpolator(from: number, to: number): (t: number) => number;
-    /**
-     * 创建向量插值器
-     * @param from 起始向量
-     * @param to 目标向量
-     * @returns 插值器函数
-     */
-    static createVectorInterpolator(from: Vector2, to: Vector2): (t: number) => Vector2;
-    /**
-     * 创建组合插值器（插值多个值）
-     * @param interpolators 插值器数组
-     * @returns 组合插值器函数
-     */
-    static createCompositeInterpolator<T>(interpolators: InterpolatorFunction<T>[]): (from: T[], to: T[], t: number) => T[];
-}
-
-export { CachedInterpolator, Circle, CollisionDetector, Easing, Interpolation, MathUtils, Matrix3, Rectangle, Vector2 };
-export type { CollisionInfo, InterpolatorFunction, Keyframe };