@ccpc/math 0.1.0

package/dist/core/geom_base.js

@@ -0,0 +1,18 @@
+/*
+ * Linea Math - Core
+ * 几何基类：统一序列化协议
+ */
+export class GeomBase {
+    /** 获取实例类型标识 */
+    getType() {
+        const ctor = this.constructor;
+        return ctor.type;
+    }
+    /**
+     * 运行时类型守卫：判断当前实例是否为目标构造器类型。
+     * 使用后可触发 TypeScript 类型收窄。
+     */
+    isType(ctor) {
+        return this instanceof ctor;
+    }
+}

package/dist/core/mat3.d.ts

@@ -0,0 +1,101 @@
+import { GeomBase } from './geom_base';
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import type { IDBMat3 } from '../serialize/dump_types';
+import { Vec2 } from './vec2';
+import type { Num3x3 } from '../types/type_guard';
+import type { IMat3 } from '../types/type_define';
+export declare class Mat3 extends GeomBase implements IMat3 {
+    /** 序列化类型标识 */
+    static readonly type = EN_GEO_TYPE.Mat3;
+    /**
+     * 矩阵元素（列主序存储）
+     * 对外输入/输出使用行主序
+     */
+    elements: Num3x3;
+    /** 创建一个 3x3 矩阵（对外行主序输入，内部列主序存储） */
+    constructor(m00?: number, m01?: number, m02?: number, m10?: number, m11?: number, m12?: number, m20?: number, m21?: number, m22?: number);
+    /** 行主序 -> 列主序 */
+    private static toColumnMajor;
+    /** 列主序 -> 行主序 */
+    private static toRowMajor;
+    /** 使用行主序数组设置矩阵 */
+    private setFromRowMajor;
+    /** 取行列元素（row/col 从 0 开始） */
+    private at;
+    /** 单位矩阵 */
+    static identity(): Mat3;
+    /** 平移矩阵 */
+    static translation(tx: number, ty: number): Mat3;
+    /** 旋转矩阵（弧度） */
+    static rotation(rad: number): Mat3;
+    /** 缩放矩阵 */
+    static scaling(sx: number, sy: number): Mat3;
+    /** 克隆 */
+    clone(): Mat3;
+    /** 右乘：this * m（就地修改） */
+    multiply(m: Mat3): this;
+    /** 右乘：this * m（返回新对象） */
+    multiplied(m: Mat3): Mat3;
+    /** 左乘：m * this（就地修改） */
+    premultiply(m: Mat3): this;
+    /** 左乘：m * this（返回新对象） */
+    premultiplied(m: Mat3): Mat3;
+    /** 平移（右乘，就地修改） */
+    translate(tx: number, ty: number): this;
+    /** 平移（右乘，返回新对象） */
+    translated(tx: number, ty: number): Mat3;
+    /** 旋转（右乘，就地修改） */
+    rotate(rad: number): this;
+    /** 旋转（右乘，返回新对象） */
+    rotated(rad: number): Mat3;
+    /** 缩放（右乘，就地修改） */
+    scale(sx: number, sy: number): this;
+    /** 缩放（右乘，返回新对象） */
+    scaled(sx: number, sy: number): Mat3;
+    /** 变换点（就地修改） */
+    transformPoint(v: Vec2): Vec2;
+    /** 变换点（返回新对象） */
+    transformedPoint(v: Vec2): Vec2;
+    /** 变换向量（就地修改，不含平移） */
+    transformVector(v: Vec2): Vec2;
+    /** 变换向量（返回新对象，不含平移） */
+    transformedVector(v: Vec2): Vec2;
+    /** 行列式 */
+    determinant(): number;
+    /** 逆矩阵（就地修改，不可逆抛错） */
+    invert(eps?: number): this;
+    /** 逆矩阵（返回新对象） */
+    inverted(eps?: number): Mat3;
+    /** 近似相等 */
+    equals(m: Mat3, eps?: number): boolean;
+    /** 转为数组（行主序） */
+    toArray(): readonly [number, number, number, number, number, number, number, number, number];
+    /**
+     * 分解为平移/旋转/缩放
+     * - 假定矩阵不包含剪切
+     * - 旋转角为弧度
+     */
+    decompose(): {
+        translation: Vec2;
+        rotation: number;
+        scale: Vec2;
+    };
+    /**
+     * 判断矩阵是否为二维相似变换。
+     * 对线性部分 A 的要求：
+     * - 在容差内满足 A^T A = s^2 I
+     * - s > 0
+     * 允许镜像（det(A) < 0）。
+     */
+    isSimilarity2D(eps?: number): boolean;
+    /**
+     * 返回二维相似变换的统一缩放系数。
+     * 若矩阵不是二维相似变换则抛错。
+     */
+    getSimilarityScale2D(eps?: number): number;
+    /** 序列化为结构对象 */
+    dump(): IDBMat3;
+    /** 从结构对象反序列化 */
+    static load(data: IDBMat3): Mat3;
+}
+//# sourceMappingURL=mat3.d.ts.map

package/dist/core/mat3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mat3.d.ts","sourceRoot":"","sources":["../../src/core/mat3.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AACtD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAA;AAIjD,qBACa,IAAK,SAAQ,QAAS,YAAW,KAAK;IAC/C,cAAc;IACd,gBAAuB,IAAI,oBAAmB;IAE9C;;;OAGG;IACI,QAAQ,EAAE,MAAM,CAAA;IAEvB,mCAAmC;gBAE/B,GAAG,SAAI,EAAE,GAAG,SAAI,EAAE,GAAG,SAAI,EACzB,GAAG,SAAI,EAAE,GAAG,SAAI,EAAE,GAAG,SAAI,EACzB,GAAG,SAAI,EAAE,GAAG,SAAI,EAAE,GAAG,SAAI;IAU7B,iBAAiB;IACjB,OAAO,CAAC,MAAM,CAAC,aAAa;IAQ5B,iBAAiB;IACjB,OAAO,CAAC,MAAM,CAAC,UAAU;IAQzB,kBAAkB;IAClB,OAAO,CAAC,eAAe;IAKvB,4BAA4B;IAC5B,OAAO,CAAC,EAAE;IAIV,WAAW;WACG,QAAQ;IAItB,WAAW;WACG,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAQhD,eAAe;WACD,QAAQ,CAAC,GAAG,EAAE,MAAM;IAUlC,WAAW;WACG,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAQ5C,SAAS;IACF,KAAK;IASZ,wBAAwB;IACjB,QAAQ,CAAC,CAAC,EAAE,IAAI;IAavB,yBAAyB;IAClB,UAAU,CAAC,CAAC,EAAE,IAAI;IAIzB,wBAAwB;IACjB,WAAW,CAAC,CAAC,EAAE,IAAI;IAa1B,yBAAyB;IAClB,aAAa,CAAC,CAAC,EAAE,IAAI;IAI5B,kBAAkB;IACX,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIvC,mBAAmB;IACZ,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIxC,kBAAkB;IACX,MAAM,CAAC,GAAG,EAAE,MAAM;IAIzB,mBAAmB;IACZ,OAAO,CAAC,GAAG,EAAE,MAAM;IAI1B,kBAAkB;IACX,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAInC,mBAAmB;IACZ,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAIpC,gBAAgB;IACT,cAAc,CAAC,CAAC,EAAE,IAAI;IAQ7B,iBAAiB;IACV,gBAAgB,CAAC,CAAC,EAAE,IAAI;IAI/B,sBAAsB;IACf,eAAe,CAAC,CAAC,EAAE,IAAI;IAQ9B,uBAAuB;IAChB,iBAAiB,CAAC,CAAC,EAAE,IAAI;IAOhC,UAAU;IACH,WAAW;IAOlB,sBAAsB;IACf,MAAM,CAAC,GAAG,SAAoB;IA2BrC,iBAAiB;IACV,QAAQ,CAAC,GAAG,SAAoB;IAIvC,WAAW;IACJ,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,SAAgB;IAgB1C,gBAAgB;IACT,OAAO;IAId;;;;OAIG;IACI,SAAS;;;;;IAyBhB;;;;;;OAMG;IACI,cAAc,CAAC,GAAG,SAA4B;IAoBrD;;;OAGG;IACI,oBAAoB,CAAC,GAAG,SAA4B;IAQ3D,eAAe;IACR,IAAI,IAAI,OAAO;IAOtB,gBAAgB;WACF,IAAI,CAAC,IAAI,EAAE,OAAO;CAQnC"}

package/dist/core/mat3.js

@@ -0,0 +1,290 @@
+/*
+ * Linea Math - Core
+ * Mat3：二维仿射矩阵，列向量 + 右乘约定
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Mat3_1;
+import { GeomBase } from './geom_base';
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { RegisterGeom } from '../serialize/geom_mgr';
+import { Vec2 } from './vec2';
+import { Precision } from '../utils/precision';
+import { MathError } from '../utils/math_error';
+let Mat3 = Mat3_1 = class Mat3 extends GeomBase {
+    /** 创建一个 3x3 矩阵（对外行主序输入，内部列主序存储） */
+    constructor(m00 = 1, m01 = 0, m02 = 0, m10 = 0, m11 = 1, m12 = 0, m20 = 0, m21 = 0, m22 = 1) {
+        super();
+        this.elements = Mat3_1.toColumnMajor([
+            m00, m01, m02,
+            m10, m11, m12,
+            m20, m21, m22,
+        ]);
+    }
+    /** 行主序 -> 列主序 */
+    static toColumnMajor(e) {
+        return [
+            e[0], e[3], e[6],
+            e[1], e[4], e[7],
+            e[2], e[5], e[8],
+        ];
+    }
+    /** 列主序 -> 行主序 */
+    static toRowMajor(e) {
+        return [
+            e[0], e[3], e[6],
+            e[1], e[4], e[7],
+            e[2], e[5], e[8],
+        ];
+    }
+    /** 使用行主序数组设置矩阵 */
+    setFromRowMajor(e) {
+        this.elements = Mat3_1.toColumnMajor(e);
+        return this;
+    }
+    /** 取行列元素（row/col 从 0 开始） */
+    at(row, col) {
+        return this.elements[col * 3 + row];
+    }
+    /** 单位矩阵 */
+    static identity() {
+        return new Mat3_1();
+    }
+    /** 平移矩阵 */
+    static translation(tx, ty) {
+        return new Mat3_1(1, 0, tx, 0, 1, ty, 0, 0, 1);
+    }
+    /** 旋转矩阵（弧度） */
+    static rotation(rad) {
+        const c = Math.cos(rad);
+        const s = Math.sin(rad);
+        return new Mat3_1(c, -s, 0, s, c, 0, 0, 0, 1);
+    }
+    /** 缩放矩阵 */
+    static scaling(sx, sy) {
+        return new Mat3_1(sx, 0, 0, 0, sy, 0, 0, 0, 1);
+    }
+    /** 克隆 */
+    clone() {
+        const e = Mat3_1.toRowMajor(this.elements);
+        return new Mat3_1(e[0], e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8]);
+    }
+    /** 右乘：this * m（就地修改） */
+    multiply(m) {
+        const a00 = this.at(0, 0) * m.at(0, 0) + this.at(0, 1) * m.at(1, 0) + this.at(0, 2) * m.at(2, 0);
+        const a01 = this.at(0, 0) * m.at(0, 1) + this.at(0, 1) * m.at(1, 1) + this.at(0, 2) * m.at(2, 1);
+        const a02 = this.at(0, 0) * m.at(0, 2) + this.at(0, 1) * m.at(1, 2) + this.at(0, 2) * m.at(2, 2);
+        const a10 = this.at(1, 0) * m.at(0, 0) + this.at(1, 1) * m.at(1, 0) + this.at(1, 2) * m.at(2, 0);
+        const a11 = this.at(1, 0) * m.at(0, 1) + this.at(1, 1) * m.at(1, 1) + this.at(1, 2) * m.at(2, 1);
+        const a12 = this.at(1, 0) * m.at(0, 2) + this.at(1, 1) * m.at(1, 2) + this.at(1, 2) * m.at(2, 2);
+        const a20 = this.at(2, 0) * m.at(0, 0) + this.at(2, 1) * m.at(1, 0) + this.at(2, 2) * m.at(2, 0);
+        const a21 = this.at(2, 0) * m.at(0, 1) + this.at(2, 1) * m.at(1, 1) + this.at(2, 2) * m.at(2, 1);
+        const a22 = this.at(2, 0) * m.at(0, 2) + this.at(2, 1) * m.at(1, 2) + this.at(2, 2) * m.at(2, 2);
+        return this.setFromRowMajor([a00, a01, a02, a10, a11, a12, a20, a21, a22]);
+    }
+    /** 右乘：this * m（返回新对象） */
+    multiplied(m) {
+        return this.clone().multiply(m);
+    }
+    /** 左乘：m * this（就地修改） */
+    premultiply(m) {
+        const a00 = m.at(0, 0) * this.at(0, 0) + m.at(0, 1) * this.at(1, 0) + m.at(0, 2) * this.at(2, 0);
+        const a01 = m.at(0, 0) * this.at(0, 1) + m.at(0, 1) * this.at(1, 1) + m.at(0, 2) * this.at(2, 1);
+        const a02 = m.at(0, 0) * this.at(0, 2) + m.at(0, 1) * this.at(1, 2) + m.at(0, 2) * this.at(2, 2);
+        const a10 = m.at(1, 0) * this.at(0, 0) + m.at(1, 1) * this.at(1, 0) + m.at(1, 2) * this.at(2, 0);
+        const a11 = m.at(1, 0) * this.at(0, 1) + m.at(1, 1) * this.at(1, 1) + m.at(1, 2) * this.at(2, 1);
+        const a12 = m.at(1, 0) * this.at(0, 2) + m.at(1, 1) * this.at(1, 2) + m.at(1, 2) * this.at(2, 2);
+        const a20 = m.at(2, 0) * this.at(0, 0) + m.at(2, 1) * this.at(1, 0) + m.at(2, 2) * this.at(2, 0);
+        const a21 = m.at(2, 0) * this.at(0, 1) + m.at(2, 1) * this.at(1, 1) + m.at(2, 2) * this.at(2, 1);
+        const a22 = m.at(2, 0) * this.at(0, 2) + m.at(2, 1) * this.at(1, 2) + m.at(2, 2) * this.at(2, 2);
+        return this.setFromRowMajor([a00, a01, a02, a10, a11, a12, a20, a21, a22]);
+    }
+    /** 左乘：m * this（返回新对象） */
+    premultiplied(m) {
+        return this.clone().premultiply(m);
+    }
+    /** 平移（右乘，就地修改） */
+    translate(tx, ty) {
+        return this.multiply(Mat3_1.translation(tx, ty));
+    }
+    /** 平移（右乘，返回新对象） */
+    translated(tx, ty) {
+        return this.clone().translate(tx, ty);
+    }
+    /** 旋转（右乘，就地修改） */
+    rotate(rad) {
+        return this.multiply(Mat3_1.rotation(rad));
+    }
+    /** 旋转（右乘，返回新对象） */
+    rotated(rad) {
+        return this.clone().rotate(rad);
+    }
+    /** 缩放（右乘，就地修改） */
+    scale(sx, sy) {
+        return this.multiply(Mat3_1.scaling(sx, sy));
+    }
+    /** 缩放（右乘，返回新对象） */
+    scaled(sx, sy) {
+        return this.clone().scale(sx, sy);
+    }
+    /** 变换点（就地修改） */
+    transformPoint(v) {
+        const x = this.at(0, 0) * v.x + this.at(0, 1) * v.y + this.at(0, 2);
+        const y = this.at(1, 0) * v.x + this.at(1, 1) * v.y + this.at(1, 2);
+        v.x = x;
+        v.y = y;
+        return v;
+    }
+    /** 变换点（返回新对象） */
+    transformedPoint(v) {
+        return v.clone().applyMat3(this);
+    }
+    /** 变换向量（就地修改，不含平移） */
+    transformVector(v) {
+        const x = this.at(0, 0) * v.x + this.at(0, 1) * v.y;
+        const y = this.at(1, 0) * v.x + this.at(1, 1) * v.y;
+        v.x = x;
+        v.y = y;
+        return v;
+    }
+    /** 变换向量（返回新对象，不含平移） */
+    transformedVector(v) {
+        return new Vec2(this.at(0, 0) * v.x + this.at(0, 1) * v.y, this.at(1, 0) * v.x + this.at(1, 1) * v.y);
+    }
+    /** 行列式 */
+    determinant() {
+        const a = this.at(0, 0), b = this.at(0, 1), c = this.at(0, 2);
+        const d = this.at(1, 0), e = this.at(1, 1), f = this.at(1, 2);
+        const g = this.at(2, 0), h = this.at(2, 1), i = this.at(2, 2);
+        return a * e * i + b * f * g + c * d * h - c * e * g - b * d * i - a * f * h;
+    }
+    /** 逆矩阵（就地修改，不可逆抛错） */
+    invert(eps = Precision.LEN_EPS) {
+        const det = this.determinant();
+        if (Math.abs(det) <= eps) {
+            MathError.throw('Mat3.invert: matrix is not invertible');
+        }
+        const a = this.at(0, 0), b = this.at(0, 1), c = this.at(0, 2);
+        const d = this.at(1, 0), e = this.at(1, 1), f = this.at(1, 2);
+        const g = this.at(2, 0), h = this.at(2, 1), i = this.at(2, 2);
+        const A = e * i - f * h;
+        const B = c * h - b * i;
+        const C = b * f - c * e;
+        const D = f * g - d * i;
+        const E = a * i - c * g;
+        const F = c * d - a * f;
+        const G = d * h - e * g;
+        const H = b * g - a * h;
+        const I = a * e - b * d;
+        const invDet = 1 / det;
+        return this.setFromRowMajor([
+            A * invDet, B * invDet, C * invDet,
+            D * invDet, E * invDet, F * invDet,
+            G * invDet, H * invDet, I * invDet,
+        ]);
+    }
+    /** 逆矩阵（返回新对象） */
+    inverted(eps = Precision.LEN_EPS) {
+        return this.clone().invert(eps);
+    }
+    /** 近似相等 */
+    equals(m, eps = Precision.EPS) {
+        const a = this.elements;
+        const b = m.elements;
+        return (Precision.equal(a[0], b[0], eps) &&
+            Precision.equal(a[1], b[1], eps) &&
+            Precision.equal(a[2], b[2], eps) &&
+            Precision.equal(a[3], b[3], eps) &&
+            Precision.equal(a[4], b[4], eps) &&
+            Precision.equal(a[5], b[5], eps) &&
+            Precision.equal(a[6], b[6], eps) &&
+            Precision.equal(a[7], b[7], eps) &&
+            Precision.equal(a[8], b[8], eps));
+    }
+    /** 转为数组（行主序） */
+    toArray() {
+        return Mat3_1.toRowMajor(this.elements);
+    }
+    /**
+     * 分解为平移/旋转/缩放
+     * - 假定矩阵不包含剪切
+     * - 旋转角为弧度
+     */
+    decompose() {
+        const e = this.toArray();
+        const m00 = e[0], m01 = e[1], m02 = e[2];
+        const m10 = e[3], m11 = e[4], m12 = e[5];
+        const tx = m02;
+        const ty = m12;
+        const sx = Math.hypot(m00, m10);
+        let sy = Math.hypot(m01, m11);
+        const det = m00 * m11 - m01 * m10;
+        if (det < 0) {
+            sy = -sy;
+        }
+        const rotation = Math.atan2(m10, m00);
+        return {
+            translation: new Vec2(tx, ty),
+            rotation,
+            scale: new Vec2(sx, sy),
+        };
+    }
+    /**
+     * 判断矩阵是否为二维相似变换。
+     * 对线性部分 A 的要求：
+     * - 在容差内满足 A^T A = s^2 I
+     * - s > 0
+     * 允许镜像（det(A) < 0）。
+     */
+    isSimilarity2D(eps = Precision.CURVE_PARAM_EPS) {
+        const e = this.toArray();
+        if (!Precision.nearlyZero(e[6], eps) || !Precision.nearlyZero(e[7], eps) || !Precision.equal(e[8], 1, eps)) {
+            return false;
+        }
+        const a = e[0];
+        const b = e[1];
+        const c = e[3];
+        const d = e[4];
+        const col0Sq = a * a + c * c;
+        const col1Sq = b * b + d * d;
+        const colDot = a * b + c * d;
+        if (col0Sq <= eps * eps || col1Sq <= eps * eps)
+            return false;
+        if (!Precision.nearlyZero(colDot, eps))
+            return false;
+        return Precision.equal(col0Sq, col1Sq, eps);
+    }
+    /**
+     * 返回二维相似变换的统一缩放系数。
+     * 若矩阵不是二维相似变换则抛错。
+     */
+    getSimilarityScale2D(eps = Precision.CURVE_PARAM_EPS) {
+        MathError.assert(this.isSimilarity2D(eps), 'Mat3.getSimilarityScale2D: matrix is not a 2D similarity transform');
+        const e = this.toArray();
+        const col0Sq = e[0] * e[0] + e[3] * e[3];
+        const col1Sq = e[1] * e[1] + e[4] * e[4];
+        return Math.sqrt((col0Sq + col1Sq) * 0.5);
+    }
+    /** 序列化为结构对象 */
+    dump() {
+        return {
+            type: Mat3_1.type,
+            elements: this.toArray(),
+        };
+    }
+    /** 从结构对象反序列化 */
+    static load(data) {
+        const e = data.elements;
+        return new Mat3_1(e[0], e[1], e[2], e[3], e[4], e[5], e[6], e[7], e[8]);
+    }
+};
+/** 序列化类型标识 */
+Mat3.type = EN_GEO_TYPE.Mat3;
+Mat3 = Mat3_1 = __decorate([
+    RegisterGeom
+], Mat3);
+export { Mat3 };

package/dist/core/vec2.d.ts

@@ -0,0 +1,138 @@
+import { GeomBase } from './geom_base';
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import type { IDBVec2 } from '../serialize/dump_types';
+import type { IVec2 } from '../types/type_define';
+import type { Mat3 } from './mat3';
+export declare class Vec2 extends GeomBase implements IVec2 {
+    /** 序列化类型标识 */
+    static readonly type = EN_GEO_TYPE.Vec2;
+    /** X 分量 */
+    x: number;
+    /** Y 分量 */
+    y: number;
+    /** 创建一个向量实例 */
+    constructor();
+    constructor(x: number, y: number);
+    constructor(obj: IVec2);
+    /** 零向量 */
+    static zero(): Vec2;
+    /** 单位向量 X */
+    static unitX(): Vec2;
+    /** 单位向量 Y */
+    static unitY(): Vec2;
+    /** 克隆当前向量 */
+    clone(): Vec2;
+    /** 返回替换 X 分量的新向量 */
+    withX(x: number): Vec2;
+    /** 返回替换 Y 分量的新向量 */
+    withY(y: number): Vec2;
+    /** 设置 X 分量（就地修改） */
+    setX(x: number): this;
+    /** 设置 Y 分量（就地修改） */
+    setY(y: number): this;
+    /** 向量相加（就地修改） */
+    add(v: Vec2): this;
+    /** 向量相加（返回新对象） */
+    added(v: Vec2): Vec2;
+    /** 向量相减（就地修改） */
+    subtract(v: Vec2): this;
+    /** 向量相减（返回新对象） */
+    subtracted(v: Vec2): Vec2;
+    /**
+     * 向量线性叠加：this + v * s
+     * - 常用于积分、插值、偏移等计算
+     */
+    addScaled(v: Vec2, s: number): this;
+    /** 向量线性叠加（返回新对象） */
+    addScaleded(v: Vec2, s: number): Vec2;
+    /** 反向量（取相反方向） */
+    negate(): this;
+    /** 反向量（返回新对象） */
+    negated(): Vec2;
+    /**
+     * 绕原点旋转（弧度）
+     * - 逆时针为正方向
+     */
+    rotate(rad: number): this;
+    /** 绕原点旋转（返回新对象） */
+    rotated(rad: number): Vec2;
+    /**
+     * 绕指定点旋转（弧度）
+     * - 先平移到原点旋转，再平移回去
+     */
+    rotateAround(center: Vec2, rad: number): this;
+    /**
+     * 垂直向量（默认逆时针 90°）
+     * - (x, y) -> (-y, x)
+     * - 若需顺时针方向，可对结果取反
+     */
+    perp(): this;
+    /** 垂直向量（返回新对象） */
+    perped(): Vec2;
+    /** 标量缩放 */
+    scale(s: number): this;
+    /** 标量缩放（返回新对象） */
+    scaled(s: number): Vec2;
+    /** 点积 */
+    dot(v: Vec2): number;
+    /** 叉积（返回标量） */
+    cross(v: Vec2): number;
+    /** 长度平方 */
+    lenSq(): number;
+    /** 向量长度 */
+    len(): number;
+    /**
+     * 设置向量长度（保持方向）
+     * - 零向量返回零向量
+     */
+    setLength(len: number, eps?: number): this;
+    /** 设置向量长度（返回新对象） */
+    setLengthed(len: number, eps?: number): Vec2;
+    /** 归一化，极短向量返回零向量 */
+    normalize(eps?: number): this;
+    /** 归一化（返回新对象） */
+    normalized(eps?: number): Vec2;
+    /**
+     * 应用 Mat3 变换（就地修改）
+     */
+    applyMat3(m: Mat3): Vec2;
+    /** 应用 Mat3 变换（返回新对象） */
+    appliedMat3(m: Mat3): Vec2;
+    /** 到目标向量的距离 */
+    distanceTo(v: Vec2): number;
+    /** 到目标向量的距离平方（避免开方，更高效） */
+    distanceToSq(v: Vec2): number;
+    /**
+     * 向量投影（投影到目标向量上）
+     * - 若目标向量为零向量，则返回零向量
+     * - 结果与目标向量共线
+     */
+    project(on: Vec2, eps?: number): this;
+    /** 向量投影（返回新对象） */
+    projected(on: Vec2, eps?: number): Vec2;
+    /**
+     * 返回向量的方向角（弧度）
+     * - 相对于 +X 轴的角度
+     * - 结果范围为 [-PI, PI]
+     */
+    angle(): number;
+    /** 线性插值 */
+    lerp(v: Vec2, t: number): Vec2;
+    /**
+     * 计算当前向量到目标向量的夹角（弧度）
+     * - 结果范围为 [-PI, PI]
+     * - 使用 atan2(cross, dot)，保留方向（顺时针/逆时针）
+     */
+    angleTo(v: Vec2): number;
+    /** 判断分量是否为有限数 */
+    isFinite(): boolean;
+    /** 判断是否近似相等 */
+    equals(v: Vec2, eps?: number): boolean;
+    /** 转为元组 */
+    toArray(): readonly [number, number];
+    /** 序列化为结构对象 */
+    dump(): IDBVec2;
+    /** 从结构对象反序列化 */
+    static load(data: IDBVec2): Vec2;
+}
+//# sourceMappingURL=vec2.d.ts.map

package/dist/core/vec2.d.ts.map

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