@ccpc/math 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 genewanggang-sudo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,21 @@
+# @ccpc/math
+
+2D geometry and curve math library for Linea.
+
+## Install
+
+```bash
+pnpm add @ccpc/math
+```
+
+## Usage
+
+```ts
+import { Vec2, Line2, Circle2, BSpline2 } from '@ccpc/math'
+```
+
+## Build
+
+```bash
+pnpm --filter "@ccpc/math" build
+```

package/dist/constants/geom_type.d.ts

@@ -0,0 +1,13 @@
+export declare enum EN_GEO_TYPE {
+    Vec2 = "Vec2",
+    Mat3 = "Mat3",
+    Box2 = "Box2",
+    Coord2D = "Coord2D",
+    Line2 = "Line2",
+    Circle2 = "Circle2",
+    Arc2 = "Arc2",
+    Ellipse2 = "Ellipse2",
+    EllipseArc2 = "EllipseArc2",
+    BSpline2 = "BSpline2"
+}
+//# sourceMappingURL=geom_type.d.ts.map

package/dist/constants/geom_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geom_type.d.ts","sourceRoot":"","sources":["../../src/constants/geom_type.ts"],"names":[],"mappings":"AAKA,oBAAY,WAAW;IACnB,IAAI,SAAS;IACb,IAAI,SAAS;IACb,IAAI,SAAS;IACb,OAAO,YAAY;IAEnB,KAAK,UAAU;IACf,OAAO,YAAY;IACnB,IAAI,SAAS;IACb,QAAQ,aAAa;IACrB,WAAW,gBAAgB;IAC3B,QAAQ,aAAa;CACxB"}

package/dist/constants/geom_type.js

@@ -0,0 +1,17 @@
+/*
+ * Linea Math - Types
+ * 用于序列化的几何类型枚举
+ */
+export var EN_GEO_TYPE;
+(function (EN_GEO_TYPE) {
+    EN_GEO_TYPE["Vec2"] = "Vec2";
+    EN_GEO_TYPE["Mat3"] = "Mat3";
+    EN_GEO_TYPE["Box2"] = "Box2";
+    EN_GEO_TYPE["Coord2D"] = "Coord2D";
+    EN_GEO_TYPE["Line2"] = "Line2";
+    EN_GEO_TYPE["Circle2"] = "Circle2";
+    EN_GEO_TYPE["Arc2"] = "Arc2";
+    EN_GEO_TYPE["Ellipse2"] = "Ellipse2";
+    EN_GEO_TYPE["EllipseArc2"] = "EllipseArc2";
+    EN_GEO_TYPE["BSpline2"] = "BSpline2";
+})(EN_GEO_TYPE || (EN_GEO_TYPE = {}));

package/dist/constants/math_const.d.ts

@@ -0,0 +1,9 @@
+export declare class MathConst {
+    /** 负无穷，表示无界最小值 */
+    static readonly MIN: number;
+    /** 正无穷，表示无界最大值 */
+    static readonly MAX: number;
+    /** 2 * PI */
+    static readonly PI2: number;
+}
+//# sourceMappingURL=math_const.d.ts.map

package/dist/constants/math_const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math_const.d.ts","sourceRoot":"","sources":["../../src/constants/math_const.ts"],"names":[],"mappings":"AAKA,qBAAa,SAAS;IAClB,kBAAkB;IAClB,gBAAuB,GAAG,SAA2B;IAErD,kBAAkB;IAClB,gBAAuB,GAAG,SAA2B;IAErD,aAAa;IACb,gBAAuB,GAAG,SAAc;CAC3C"}

package/dist/constants/math_const.js

@@ -0,0 +1,12 @@
+/*
+ * Linea Math - Constants
+ * MathConst: 数学常量集中定义
+ */
+export class MathConst {
+}
+/** 负无穷，表示无界最小值 */
+MathConst.MIN = Number.NEGATIVE_INFINITY;
+/** 正无穷，表示无界最大值 */
+MathConst.MAX = Number.POSITIVE_INFINITY;
+/** 2 * PI */
+MathConst.PI2 = Math.PI * 2;

package/dist/core/box2.d.ts

@@ -0,0 +1,71 @@
+import { GeomBase } from './geom_base';
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import type { IDBBox2 } from '../serialize/dump_types';
+import { Vec2 } from './vec2';
+import { Mat3 } from './mat3';
+export declare class Box2 extends GeomBase {
+    /** 序列化类型标识 */
+    static readonly type = EN_GEO_TYPE.Box2;
+    /** 最小/最大边界 */
+    readonly minX: number;
+    readonly minY: number;
+    readonly maxX: number;
+    readonly maxY: number;
+    /** 创建 Box2（默认为空盒） */
+    constructor();
+    constructor(b: Box2);
+    constructor(min: Vec2, max: Vec2);
+    constructor(points: readonly Vec2[]);
+    constructor(minX: number, minY: number, maxX: number, maxY: number);
+    /** 空盒 */
+    static empty(): Box2;
+    /** 由最小/最大点创建 */
+    static fromMinMax(min: Vec2, max: Vec2): Box2;
+    /** 由点集创建 */
+    static fromPoints(points: readonly Vec2[]): Box2;
+    /** 克隆 */
+    clone(): Box2;
+    /** 是否为空盒 */
+    isEmpty(): boolean;
+    /** 是否为有限数 */
+    isFinite(): boolean;
+    /** 宽度 */
+    width(): number;
+    /** 高度 */
+    height(): number;
+    /** 尺寸 */
+    size(): Vec2;
+    /** 中心点 */
+    center(): Vec2;
+    /** 是否包含点 */
+    containsPoint(v: Vec2): boolean;
+    /** 是否包含盒 */
+    containsBox(b: Box2): boolean;
+    /** 是否相交 */
+    intersects(b: Box2): boolean;
+    /** 扩展以包含点 */
+    expandByPoint(v: Vec2): Box2;
+    /** 按标量扩展 */
+    expandByScalar(s: number): Box2;
+    /** 合并盒 */
+    union(b: Box2): Box2;
+    /** 平移 */
+    translate(dx: number, dy: number): Box2;
+    /** 变换（返回新对象） */
+    transform(m: Mat3): Box2;
+    /** 变换（返回新对象） */
+    transformed(m: Mat3): Box2;
+    /** 点到盒子的最短距离 */
+    distanceToPoint(p: Vec2): number;
+    /** 将点限制在盒子范围内 */
+    clampPoint(p: Vec2): Vec2;
+    /** 交集盒 */
+    intersect(b: Box2): Box2;
+    /** 近似相等 */
+    equals(b: Box2, eps?: number): boolean;
+    /** 序列化为结构对象 */
+    dump(): IDBBox2;
+    /** 从结构对象反序列化 */
+    static load(data: IDBBox2): Box2;
+}
+//# sourceMappingURL=box2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"box2.d.ts","sourceRoot":"","sources":["../../src/core/box2.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,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAG7B,qBACa,IAAK,SAAQ,QAAQ;IAC9B,cAAc;IACd,gBAAuB,IAAI,oBAAmB;IAE9C,cAAc;IACd,SAAgB,IAAI,EAAE,MAAM,CAAA;IAC5B,SAAgB,IAAI,EAAE,MAAM,CAAA;IAC5B,SAAgB,IAAI,EAAE,MAAM,CAAA;IAC5B,SAAgB,IAAI,EAAE,MAAM,CAAA;IAE5B,qBAAqB;;gBAET,CAAC,EAAE,IAAI;gBACP,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;gBACpB,MAAM,EAAE,SAAS,IAAI,EAAE;gBACvB,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IA2ClE,SAAS;WACK,KAAK;IAInB,gBAAgB;WACF,UAAU,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;IAI7C,YAAY;WACE,UAAU,CAAC,MAAM,EAAE,SAAS,IAAI,EAAE;IAehD,SAAS;IACF,KAAK;IAIZ,YAAY;IACL,OAAO;IAId,aAAa;IACN,QAAQ;IASf,SAAS;IACF,KAAK;IAIZ,SAAS;IACF,MAAM;IAIb,SAAS;IACF,IAAI;IAIX,UAAU;IACH,MAAM;IAQb,YAAY;IACL,aAAa,CAAC,CAAC,EAAE,IAAI;IAU5B,YAAY;IACL,WAAW,CAAC,CAAC,EAAE,IAAI;IAU1B,WAAW;IACJ,UAAU,CAAC,CAAC,EAAE,IAAI;IAUzB,aAAa;IACN,aAAa,CAAC,CAAC,EAAE,IAAI;IAY5B,YAAY;IACL,cAAc,CAAC,CAAC,EAAE,MAAM;IAU/B,UAAU;IACH,KAAK,CAAC,CAAC,EAAE,IAAI;IAWpB,SAAS;IACF,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAUvC,gBAAgB;IACT,SAAS,CAAC,CAAC,EAAE,IAAI;IAaxB,gBAAgB;IACT,WAAW,CAAC,CAAC,EAAE,IAAI;IAI1B,gBAAgB;IACT,eAAe,CAAC,CAAC,EAAE,IAAI;IAW9B,iBAAiB;IACV,UAAU,CAAC,CAAC,EAAE,IAAI;IAOzB,UAAU;IACH,SAAS,CAAC,CAAC,EAAE,IAAI;IASxB,WAAW;IACJ,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,SAAgB;IAW1C,eAAe;IACR,IAAI,IAAI,OAAO;IAUtB,gBAAgB;WACF,IAAI,CAAC,IAAI,EAAE,OAAO;CAGnC"}

package/dist/core/box2.js

@@ -0,0 +1,243 @@
+/*
+ * Linea Math - Core
+ * Box2：二维轴对齐包围盒（AABB），不可变设计
+ */
+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 Box2_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';
+let Box2 = Box2_1 = class Box2 extends GeomBase {
+    constructor(a0, a1, a2, a3) {
+        super();
+        if (a0 instanceof Box2_1) {
+            this.minX = a0.minX;
+            this.minY = a0.minY;
+            this.maxX = a0.maxX;
+            this.maxY = a0.maxY;
+            return;
+        }
+        if (a0 instanceof Vec2 && a1 instanceof Vec2) {
+            this.minX = a0.x;
+            this.minY = a0.y;
+            this.maxX = a1.x;
+            this.maxY = a1.y;
+            return;
+        }
+        if (Array.isArray(a0)) {
+            const b = Box2_1.fromPoints(a0);
+            this.minX = b.minX;
+            this.minY = b.minY;
+            this.maxX = b.maxX;
+            this.maxY = b.maxY;
+            return;
+        }
+        const minX = typeof a0 === 'number' ? a0 : Infinity;
+        const minY = typeof a1 === 'number' ? a1 : Infinity;
+        const maxX = typeof a2 === 'number' ? a2 : -Infinity;
+        const maxY = typeof a3 === 'number' ? a3 : -Infinity;
+        this.minX = minX;
+        this.minY = minY;
+        this.maxX = maxX;
+        this.maxY = maxY;
+    }
+    /** 空盒 */
+    static empty() {
+        return new Box2_1();
+    }
+    /** 由最小/最大点创建 */
+    static fromMinMax(min, max) {
+        return new Box2_1(min.x, min.y, max.x, max.y);
+    }
+    /** 由点集创建 */
+    static fromPoints(points) {
+        if (points.length === 0)
+            return Box2_1.empty();
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const p of points) {
+            if (p.x < minX)
+                minX = p.x;
+            if (p.y < minY)
+                minY = p.y;
+            if (p.x > maxX)
+                maxX = p.x;
+            if (p.y > maxY)
+                maxY = p.y;
+        }
+        return new Box2_1(minX, minY, maxX, maxY);
+    }
+    /** 克隆 */
+    clone() {
+        return new Box2_1(this.minX, this.minY, this.maxX, this.maxY);
+    }
+    /** 是否为空盒 */
+    isEmpty() {
+        return this.minX > this.maxX || this.minY > this.maxY;
+    }
+    /** 是否为有限数 */
+    isFinite() {
+        return (Number.isFinite(this.minX) &&
+            Number.isFinite(this.minY) &&
+            Number.isFinite(this.maxX) &&
+            Number.isFinite(this.maxY));
+    }
+    /** 宽度 */
+    width() {
+        return this.isEmpty() ? 0 : this.maxX - this.minX;
+    }
+    /** 高度 */
+    height() {
+        return this.isEmpty() ? 0 : this.maxY - this.minY;
+    }
+    /** 尺寸 */
+    size() {
+        return new Vec2(this.width(), this.height());
+    }
+    /** 中心点 */
+    center() {
+        if (this.isEmpty())
+            return Vec2.zero();
+        return new Vec2((this.minX + this.maxX) / 2, (this.minY + this.maxY) / 2);
+    }
+    /** 是否包含点 */
+    containsPoint(v) {
+        if (this.isEmpty())
+            return false;
+        return (v.x >= this.minX &&
+            v.x <= this.maxX &&
+            v.y >= this.minY &&
+            v.y <= this.maxY);
+    }
+    /** 是否包含盒 */
+    containsBox(b) {
+        if (this.isEmpty() || b.isEmpty())
+            return false;
+        return (b.minX >= this.minX &&
+            b.maxX <= this.maxX &&
+            b.minY >= this.minY &&
+            b.maxY <= this.maxY);
+    }
+    /** 是否相交 */
+    intersects(b) {
+        if (this.isEmpty() || b.isEmpty())
+            return false;
+        return (b.maxX >= this.minX &&
+            b.minX <= this.maxX &&
+            b.maxY >= this.minY &&
+            b.minY <= this.maxY);
+    }
+    /** 扩展以包含点 */
+    expandByPoint(v) {
+        if (this.isEmpty()) {
+            return new Box2_1(v.x, v.y, v.x, v.y);
+        }
+        return new Box2_1(Math.min(this.minX, v.x), Math.min(this.minY, v.y), Math.max(this.maxX, v.x), Math.max(this.maxY, v.y));
+    }
+    /** 按标量扩展 */
+    expandByScalar(s) {
+        if (this.isEmpty())
+            return this.clone();
+        return new Box2_1(this.minX - s, this.minY - s, this.maxX + s, this.maxY + s);
+    }
+    /** 合并盒 */
+    union(b) {
+        if (this.isEmpty())
+            return b.clone();
+        if (b.isEmpty())
+            return this.clone();
+        return new Box2_1(Math.min(this.minX, b.minX), Math.min(this.minY, b.minY), Math.max(this.maxX, b.maxX), Math.max(this.maxY, b.maxY));
+    }
+    /** 平移 */
+    translate(dx, dy) {
+        if (this.isEmpty())
+            return this.clone();
+        return new Box2_1(this.minX + dx, this.minY + dy, this.maxX + dx, this.maxY + dy);
+    }
+    /** 变换（返回新对象） */
+    transform(m) {
+        if (this.isEmpty())
+            return this.clone();
+        const p1 = m.transformedPoint(new Vec2(this.minX, this.minY));
+        const p2 = m.transformedPoint(new Vec2(this.minX, this.maxY));
+        const p3 = m.transformedPoint(new Vec2(this.maxX, this.minY));
+        const p4 = m.transformedPoint(new Vec2(this.maxX, this.maxY));
+        const minX = Math.min(p1.x, p2.x, p3.x, p4.x);
+        const minY = Math.min(p1.y, p2.y, p3.y, p4.y);
+        const maxX = Math.max(p1.x, p2.x, p3.x, p4.x);
+        const maxY = Math.max(p1.y, p2.y, p3.y, p4.y);
+        return new Box2_1(minX, minY, maxX, maxY);
+    }
+    /** 变换（返回新对象） */
+    transformed(m) {
+        return this.transform(m);
+    }
+    /** 点到盒子的最短距离 */
+    distanceToPoint(p) {
+        if (this.isEmpty())
+            return Infinity;
+        const dx = p.x < this.minX ? this.minX - p.x :
+            p.x > this.maxX ? p.x - this.maxX : 0;
+        const dy = p.y < this.minY ? this.minY - p.y :
+            p.y > this.maxY ? p.y - this.maxY : 0;
+        return Math.hypot(dx, dy);
+    }
+    /** 将点限制在盒子范围内 */
+    clampPoint(p) {
+        if (this.isEmpty())
+            return p.clone();
+        const x = Math.min(this.maxX, Math.max(this.minX, p.x));
+        const y = Math.min(this.maxY, Math.max(this.minY, p.y));
+        return new Vec2(x, y);
+    }
+    /** 交集盒 */
+    intersect(b) {
+        if (this.isEmpty() || b.isEmpty())
+            return Box2_1.empty();
+        const minX = Math.max(this.minX, b.minX);
+        const minY = Math.max(this.minY, b.minY);
+        const maxX = Math.min(this.maxX, b.maxX);
+        const maxY = Math.min(this.maxY, b.maxY);
+        return minX > maxX || minY > maxY ? Box2_1.empty() : new Box2_1(minX, minY, maxX, maxY);
+    }
+    /** 近似相等 */
+    equals(b, eps = Precision.EPS) {
+        if (this.isEmpty() && b.isEmpty())
+            return true;
+        if (this.isEmpty() || b.isEmpty())
+            return false;
+        return (Precision.equal(this.minX, b.minX, eps) &&
+            Precision.equal(this.minY, b.minY, eps) &&
+            Precision.equal(this.maxX, b.maxX, eps) &&
+            Precision.equal(this.maxY, b.maxY, eps));
+    }
+    /** 序列化为结构对象 */
+    dump() {
+        return {
+            type: Box2_1.type,
+            minX: this.minX,
+            minY: this.minY,
+            maxX: this.maxX,
+            maxY: this.maxY,
+        };
+    }
+    /** 从结构对象反序列化 */
+    static load(data) {
+        return new Box2_1(data.minX, data.minY, data.maxX, data.maxY);
+    }
+};
+/** 序列化类型标识 */
+Box2.type = EN_GEO_TYPE.Box2;
+Box2 = Box2_1 = __decorate([
+    RegisterGeom
+], Box2);
+export { Box2 };

package/dist/core/coord2d.d.ts

@@ -0,0 +1,62 @@
+import { GeomBase } from './geom_base';
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import type { IDBCoord2D } from '../serialize/dump_types';
+import { Vec2 } from './vec2';
+import { Mat3 } from './mat3';
+export declare class Coord2D extends GeomBase {
+    /** 序列化类型标识 */
+    static readonly type = EN_GEO_TYPE.Coord2D;
+    /** 原点 */
+    private _origin;
+    /** X 轴基向量（世界坐标） */
+    private _xAxis;
+    /** Y 轴基向量（世界坐标） */
+    private _yAxis;
+    /** 创建坐标系 */
+    constructor();
+    constructor(c: Coord2D);
+    constructor(m: Mat3);
+    constructor(origin: Vec2, xAxis?: Vec2, yAxis?: Vec2);
+    /** 克隆 */
+    clone(): Coord2D;
+    /** 获取原点 */
+    getOrigin(): Vec2;
+    /** 获取 X 轴方向 */
+    getDx(): Vec2;
+    /** 获取 Y 轴方向 */
+    getDy(): Vec2;
+    /** 是否为可用基（不退化） */
+    isValid(eps?: number): boolean;
+    /** 坐标系近似相等 */
+    equals(c: Coord2D, eps?: number): boolean;
+    /** 局部坐标 -> 世界坐标 */
+    toWorld(p: Vec2): Vec2;
+    /** 世界坐标 -> 局部坐标 */
+    toLocal(p: Vec2, eps?: number): Vec2;
+    /** 转为变换矩阵（列向量 + 右乘约定） */
+    toMat3(): Mat3;
+    /** 变换坐标系（就地修改） */
+    transform(m: Mat3): this;
+    /** 变换坐标系（返回新对象） */
+    transformed(m: Mat3): Coord2D;
+    /**
+     * 逆坐标系（世界 <-> 局部）
+     * - 用于把世界坐标转换为该坐标系的局部坐标
+     */
+    inverse(eps?: number): Coord2D;
+    /** 设置原点（就地修改） */
+    setOrigin(origin: Vec2): this;
+    /** 设置 X 轴（就地修改） */
+    setXAxis(xAxis: Vec2): this;
+    /** 设置 Y 轴（就地修改） */
+    setYAxis(yAxis: Vec2): this;
+    /** 获取缩放（轴长度） */
+    getScale(): Vec2;
+    /** 设置缩放（保持轴方向不变） */
+    setScale(sx: number, sy: number, eps?: number): this;
+    /** 序列化为结构对象 */
+    dump(): IDBCoord2D;
+    /** 从结构对象反序列化 */
+    static load(data: IDBCoord2D): Coord2D;
+}
+//# sourceMappingURL=coord2d.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"coord2d.d.ts","sourceRoot":"","sources":["../../src/core/coord2d.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AACzD,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAC7B,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAI7B,qBACa,OAAQ,SAAQ,QAAQ;IACjC,cAAc;IACd,gBAAuB,IAAI,uBAAsB;IAEjD,SAAS;IACT,OAAO,CAAC,OAAO,CAAM;IAErB,mBAAmB;IACnB,OAAO,CAAC,MAAM,CAAM;IAEpB,mBAAmB;IACnB,OAAO,CAAC,MAAM,CAAM;IAEpB,YAAY;;gBAEA,CAAC,EAAE,OAAO;gBACV,CAAC,EAAE,IAAI;gBACP,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,IAAI;IA6BpD,SAAS;IACF,KAAK;IAIZ,WAAW;IACJ,SAAS;IAIhB,eAAe;IACR,KAAK;IAIZ,eAAe;IACR,KAAK;IAIZ,kBAAkB;IACX,OAAO,CAAC,GAAG,SAAoB;IAKtC,cAAc;IACP,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,SAAgB;IAQ7C,mBAAmB;IACZ,OAAO,CAAC,CAAC,EAAE,IAAI;IAMtB,mBAAmB;IACZ,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,SAAoB;IAa/C,yBAAyB;IAClB,MAAM;IAQb,kBAAkB;IACX,SAAS,CAAC,CAAC,EAAE,IAAI;IAOxB,mBAAmB;IACZ,WAAW,CAAC,CAAC,EAAE,IAAI;IAI1B;;;OAGG;IACI,OAAO,CAAC,GAAG,SAAoB;IAKtC,iBAAiB;IACV,SAAS,CAAC,MAAM,EAAE,IAAI;IAK7B,mBAAmB;IACZ,QAAQ,CAAC,KAAK,EAAE,IAAI;IAK3B,mBAAmB;IACZ,QAAQ,CAAC,KAAK,EAAE,IAAI;IAK3B,gBAAgB;IACT,QAAQ;IAIf,oBAAoB;IACb,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,SAAoB;IAM/D,eAAe;IACR,IAAI,IAAI,UAAU;IASzB,gBAAgB;WACF,IAAI,CAAC,IAAI,EAAE,UAAU;CAOtC"}

package/dist/core/coord2d.js

@@ -0,0 +1,155 @@
+/*
+ * Linea Math - Core
+ * Coord2D: 2D 坐标系（原点 + 基向量），不可变
+ */
+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 Coord2D_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 { Mat3 } from './mat3';
+import { Precision } from '../utils/precision';
+import { MathError } from '../utils/math_error';
+let Coord2D = Coord2D_1 = class Coord2D extends GeomBase {
+    constructor(a0, a1, a2) {
+        super();
+        if (a0 instanceof Coord2D_1) {
+            this._origin = a0._origin;
+            this._xAxis = a0._xAxis;
+            this._yAxis = a0._yAxis;
+            return;
+        }
+        if (a0 instanceof Mat3) {
+            const e = a0.toArray();
+            this._origin = new Vec2(e[2], e[5]);
+            this._xAxis = new Vec2(e[0], e[3]);
+            this._yAxis = new Vec2(e[1], e[4]);
+            return;
+        }
+        const origin = a0 ?? Vec2.zero();
+        const xAxis = a1 ?? Vec2.unitX();
+        const yAxis = a2 ?? xAxis.perped();
+        this._origin = origin;
+        this._xAxis = xAxis;
+        this._yAxis = yAxis;
+    }
+    /** 克隆 */
+    clone() {
+        return new Coord2D_1(this._origin, this._xAxis, this._yAxis);
+    }
+    /** 获取原点 */
+    getOrigin() {
+        return this._origin;
+    }
+    /** 获取 X 轴方向 */
+    getDx() {
+        return this._xAxis;
+    }
+    /** 获取 Y 轴方向 */
+    getDy() {
+        return this._yAxis;
+    }
+    /** 是否为可用基（不退化） */
+    isValid(eps = Precision.LEN_EPS) {
+        const det = this._xAxis.cross(this._yAxis);
+        return Math.abs(det) > eps;
+    }
+    /** 坐标系近似相等 */
+    equals(c, eps = Precision.EPS) {
+        return (this._origin.equals(c._origin, eps) &&
+            this._xAxis.equals(c._xAxis, eps) &&
+            this._yAxis.equals(c._yAxis, eps));
+    }
+    /** 局部坐标 -> 世界坐标 */
+    toWorld(p) {
+        return this._origin
+            .added(this._xAxis.scaled(p.x))
+            .added(this._yAxis.scaled(p.y));
+    }
+    /** 世界坐标 -> 局部坐标 */
+    toLocal(p, eps = Precision.LEN_EPS) {
+        const dx = p.x - this._origin.x;
+        const dy = p.y - this._origin.y;
+        const det = this._xAxis.cross(this._yAxis);
+        if (Math.abs(det) <= eps) {
+            MathError.throw('Coord2D.toLocal: basis is degenerate');
+        }
+        const invDet = 1 / det;
+        const x = (dx * this._yAxis.y - dy * this._yAxis.x) * invDet;
+        const y = (dy * this._xAxis.x - dx * this._xAxis.y) * invDet;
+        return new Vec2(x, y);
+    }
+    /** 转为变换矩阵（列向量 + 右乘约定） */
+    toMat3() {
+        return new Mat3(this._xAxis.x, this._yAxis.x, this._origin.x, this._xAxis.y, this._yAxis.y, this._origin.y, 0, 0, 1);
+    }
+    /** 变换坐标系（就地修改） */
+    transform(m) {
+        this._origin = this._origin.clone().applyMat3(m);
+        this._xAxis = m.transformedVector(this._xAxis);
+        this._yAxis = m.transformedVector(this._yAxis);
+        return this;
+    }
+    /** 变换坐标系（返回新对象） */
+    transformed(m) {
+        return this.clone().transform(m);
+    }
+    /**
+     * 逆坐标系（世界 <-> 局部）
+     * - 用于把世界坐标转换为该坐标系的局部坐标
+     */
+    inverse(eps = Precision.LEN_EPS) {
+        const inv = this.toMat3().inverted(eps);
+        return new Coord2D_1(inv);
+    }
+    /** 设置原点（就地修改） */
+    setOrigin(origin) {
+        this._origin = origin;
+        return this;
+    }
+    /** 设置 X 轴（就地修改） */
+    setXAxis(xAxis) {
+        this._xAxis = xAxis;
+        return this;
+    }
+    /** 设置 Y 轴（就地修改） */
+    setYAxis(yAxis) {
+        this._yAxis = yAxis;
+        return this;
+    }
+    /** 获取缩放（轴长度） */
+    getScale() {
+        return new Vec2(this._xAxis.len(), this._yAxis.len());
+    }
+    /** 设置缩放（保持轴方向不变） */
+    setScale(sx, sy, eps = Precision.LEN_EPS) {
+        this._xAxis = this._xAxis.clone().setLength(sx, eps);
+        this._yAxis = this._yAxis.clone().setLength(sy, eps);
+        return this;
+    }
+    /** 序列化为结构对象 */
+    dump() {
+        return {
+            type: Coord2D_1.type,
+            origin: { x: this._origin.x, y: this._origin.y },
+            xAxis: { x: this._xAxis.x, y: this._xAxis.y },
+            yAxis: { x: this._yAxis.x, y: this._yAxis.y },
+        };
+    }
+    /** 从结构对象反序列化 */
+    static load(data) {
+        return new Coord2D_1(new Vec2(data.origin.x, data.origin.y), new Vec2(data.xAxis.x, data.xAxis.y), new Vec2(data.yAxis.x, data.yAxis.y));
+    }
+};
+/** 序列化类型标识 */
+Coord2D.type = EN_GEO_TYPE.Coord2D;
+Coord2D = Coord2D_1 = __decorate([
+    RegisterGeom
+], Coord2D);
+export { Coord2D };

package/dist/core/geom_base.d.ts

@@ -0,0 +1,19 @@
+import type { IDB } from '../serialize/dump_types';
+import type { IDumpable } from '../serialize/geom_mgr';
+import type { Ctor } from '../types/type_guard';
+export interface IGeom extends IDumpable {
+    getType(): string;
+    clone(): IGeom;
+}
+export declare abstract class GeomBase implements IGeom {
+    abstract dump(): IDB;
+    abstract clone(): IGeom;
+    /** 获取实例类型标识 */
+    getType(): string;
+    /**
+     * 运行时类型守卫：判断当前实例是否为目标构造器类型。
+     * 使用后可触发 TypeScript 类型收窄。
+     */
+    isType<T extends GeomBase>(ctor: Ctor<T>): this is T;
+}
+//# sourceMappingURL=geom_base.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geom_base.d.ts","sourceRoot":"","sources":["../../src/core/geom_base.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,KAAK,EAAE,SAAS,EAAa,MAAM,uBAAuB,CAAA;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAA;AAE/C,MAAM,WAAW,KAAM,SAAQ,SAAS;IACpC,OAAO,IAAI,MAAM,CAAA;IACjB,KAAK,IAAI,KAAK,CAAA;CACjB;AAED,8BAAsB,QAAS,YAAW,KAAK;aAC3B,IAAI,IAAI,GAAG;aACX,KAAK,IAAI,KAAK;IAE9B,eAAe;IACR,OAAO;IAKd;;;OAGG;IACI,MAAM,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC;CAG9D"}