@ccpc/math 0.1.0 → 0.1.7

package/dist/core/vec2.js

@@ -1,297 +0,0 @@
-/*
- * Linea Math - Core
- * Vec2：二维向量，采用不可变设计，支持链式调用。
- */
-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 Vec2_1;
-import { GeomBase } from './geom_base';
-import { EN_GEO_TYPE } from '../constants/geom_type';
-import { RegisterGeom } from '../serialize/geom_mgr';
-import { Precision } from '../utils/precision';
-let Vec2 = Vec2_1 = class Vec2 extends GeomBase {
-    constructor(xOrObj = 0, y = 0) {
-        super();
-        if (typeof xOrObj === 'number') {
-            this.x = xOrObj;
-            this.y = y;
-        }
-        else {
-            this.x = xOrObj.x;
-            this.y = xOrObj.y;
-        }
-    }
-    /** 零向量 */
-    static zero() {
-        return new Vec2_1(0, 0);
-    }
-    /** 单位向量 X */
-    static unitX() {
-        return new Vec2_1(1, 0);
-    }
-    /** 单位向量 Y */
-    static unitY() {
-        return new Vec2_1(0, 1);
-    }
-    /** 克隆当前向量 */
-    clone() {
-        return new Vec2_1(this.x, this.y);
-    }
-    /** 返回替换 X 分量的新向量 */
-    withX(x) {
-        return new Vec2_1(x, this.y);
-    }
-    /** 返回替换 Y 分量的新向量 */
-    withY(y) {
-        return new Vec2_1(this.x, y);
-    }
-    /** 设置 X 分量（就地修改） */
-    setX(x) {
-        this.x = x;
-        return this;
-    }
-    /** 设置 Y 分量（就地修改） */
-    setY(y) {
-        this.y = y;
-        return this;
-    }
-    /** 向量相加（就地修改） */
-    add(v) {
-        this.x += v.x;
-        this.y += v.y;
-        return this;
-    }
-    /** 向量相加（返回新对象） */
-    added(v) {
-        return this.clone().add(v);
-    }
-    /** 向量相减（就地修改） */
-    subtract(v) {
-        this.x -= v.x;
-        this.y -= v.y;
-        return this;
-    }
-    /** 向量相减（返回新对象） */
-    subtracted(v) {
-        return this.clone().subtract(v);
-    }
-    /**
-     * 向量线性叠加：this + v * s
-     * - 常用于积分、插值、偏移等计算
-     */
-    addScaled(v, s) {
-        this.x += v.x * s;
-        this.y += v.y * s;
-        return this;
-    }
-    /** 向量线性叠加（返回新对象） */
-    addScaleded(v, s) {
-        return this.clone().addScaled(v, s);
-    }
-    /** 反向量（取相反方向） */
-    negate() {
-        this.x = -this.x;
-        this.y = -this.y;
-        return this;
-    }
-    /** 反向量（返回新对象） */
-    negated() {
-        return this.clone().negate();
-    }
-    /**
-     * 绕原点旋转（弧度）
-     * - 逆时针为正方向
-     */
-    rotate(rad) {
-        const c = Math.cos(rad);
-        const s = Math.sin(rad);
-        const x = this.x * c - this.y * s;
-        const y = this.x * s + this.y * c;
-        this.x = x;
-        this.y = y;
-        return this;
-    }
-    /** 绕原点旋转（返回新对象） */
-    rotated(rad) {
-        return this.clone().rotate(rad);
-    }
-    /**
-     * 绕指定点旋转（弧度）
-     * - 先平移到原点旋转，再平移回去
-     */
-    rotateAround(center, rad) {
-        const x = this.x - center.x;
-        const y = this.y - center.y;
-        const c = Math.cos(rad);
-        const s = Math.sin(rad);
-        this.x = x * c - y * s + center.x;
-        this.y = x * s + y * c + center.y;
-        return this;
-    }
-    /**
-     * 垂直向量（默认逆时针 90°）
-     * - (x, y) -> (-y, x)
-     * - 若需顺时针方向，可对结果取反
-     */
-    perp() {
-        const x = -this.y;
-        const y = this.x;
-        this.x = x;
-        this.y = y;
-        return this;
-    }
-    /** 垂直向量（返回新对象） */
-    perped() {
-        return this.clone().perp();
-    }
-    /** 标量缩放 */
-    scale(s) {
-        this.x *= s;
-        this.y *= s;
-        return this;
-    }
-    /** 标量缩放（返回新对象） */
-    scaled(s) {
-        return this.clone().scale(s);
-    }
-    /** 点积 */
-    dot(v) {
-        return this.x * v.x + this.y * v.y;
-    }
-    /** 叉积（返回标量） */
-    cross(v) {
-        return this.x * v.y - this.y * v.x;
-    }
-    /** 长度平方 */
-    lenSq() {
-        return this.x * this.x + this.y * this.y;
-    }
-    /** 向量长度 */
-    len() {
-        return Math.hypot(this.x, this.y);
-    }
-    /**
-     * 设置向量长度（保持方向）
-     * - 零向量返回零向量
-     */
-    setLength(len, eps = Precision.LEN_EPS) {
-        const l = this.len();
-        if (l < eps) {
-            this.x = 0;
-            this.y = 0;
-            return this;
-        }
-        return this.scale(len / l);
-    }
-    /** 设置向量长度（返回新对象） */
-    setLengthed(len, eps = Precision.LEN_EPS) {
-        return this.clone().setLength(len, eps);
-    }
-    /** 归一化，极短向量返回零向量 */
-    normalize(eps = Precision.LEN_EPS) {
-        const l = this.len();
-        if (l < eps) {
-            this.x = 0;
-            this.y = 0;
-            return this;
-        }
-        return this.scale(1 / l);
-    }
-    /** 归一化（返回新对象） */
-    normalized(eps = Precision.LEN_EPS) {
-        return this.clone().normalize(eps);
-    }
-    /**
-     * 应用 Mat3 变换（就地修改）
-     */
-    applyMat3(m) {
-        return m.transformPoint(this);
-    }
-    /** 应用 Mat3 变换（返回新对象） */
-    appliedMat3(m) {
-        return this.clone().applyMat3(m);
-    }
-    /** 到目标向量的距离 */
-    distanceTo(v) {
-        return Math.hypot(this.x - v.x, this.y - v.y);
-    }
-    /** 到目标向量的距离平方（避免开方，更高效） */
-    distanceToSq(v) {
-        const dx = this.x - v.x;
-        const dy = this.y - v.y;
-        return dx * dx + dy * dy;
-    }
-    /**
-     * 向量投影（投影到目标向量上）
-     * - 若目标向量为零向量，则返回零向量
-     * - 结果与目标向量共线
-     */
-    project(on, eps = Precision.LEN_EPS) {
-        const denom = on.lenSq();
-        if (Precision.nearlyZeroSq(denom, eps)) {
-            this.x = 0;
-            this.y = 0;
-            return this;
-        }
-        const scale = this.dot(on) / denom;
-        this.x = on.x * scale;
-        this.y = on.y * scale;
-        return this;
-    }
-    /** 向量投影（返回新对象） */
-    projected(on, eps = Precision.LEN_EPS) {
-        return this.clone().project(on, eps);
-    }
-    /**
-     * 返回向量的方向角（弧度）
-     * - 相对于 +X 轴的角度
-     * - 结果范围为 [-PI, PI]
-     */
-    angle() {
-        return Math.atan2(this.y, this.x);
-    }
-    /** 线性插值 */
-    lerp(v, t) {
-        return new Vec2_1(this.x + (v.x - this.x) * t, this.y + (v.y - this.y) * t);
-    }
-    /**
-     * 计算当前向量到目标向量的夹角（弧度）
-     * - 结果范围为 [-PI, PI]
-     * - 使用 atan2(cross, dot)，保留方向（顺时针/逆时针）
-     */
-    angleTo(v) {
-        const dot = this.dot(v);
-        const det = this.cross(v);
-        return Math.atan2(det, dot);
-    }
-    /** 判断分量是否为有限数 */
-    isFinite() {
-        return Number.isFinite(this.x) && Number.isFinite(this.y);
-    }
-    /** 判断是否近似相等 */
-    equals(v, eps = Precision.EPS) {
-        return Precision.equal(this.x, v.x, eps) && Precision.equal(this.y, v.y, eps);
-    }
-    /** 转为元组 */
-    toArray() {
-        return [this.x, this.y];
-    }
-    /** 序列化为结构对象 */
-    dump() {
-        return { type: Vec2_1.type, x: this.x, y: this.y };
-    }
-    /** 从结构对象反序列化 */
-    static load(data) {
-        return new Vec2_1(data.x, data.y);
-    }
-};
-/** 序列化类型标识 */
-Vec2.type = EN_GEO_TYPE.Vec2;
-Vec2 = Vec2_1 = __decorate([
-    RegisterGeom
-], Vec2);
-export { Vec2 };

package/dist/curves/arc2.d.ts

@@ -1,49 +0,0 @@
-import { EN_GEO_TYPE } from '../constants/geom_type';
-import { Box2 } from '../core/box2';
-import { Mat3 } from '../core/mat3';
-import { Vec2 } from '../core/vec2';
-import type { IDBArc2 } from '../serialize/dump_types';
-import type { IClosestPointResult } from '../types/type_define';
-import { CircleCurve2 } from './circle_curve2';
-import { Interval } from './interval';
-export declare class Arc2 extends CircleCurve2 {
-    static readonly type = EN_GEO_TYPE.Arc2;
-    private _clockwise;
-    constructor(center: Vec2, radius: number, startAngle: number, endAngle: number, clockwise?: boolean);
-    get clockwise(): boolean;
-    get startAngle(): number;
-    get endAngle(): number;
-    pointAt(u: number): Vec2;
-    tangentAt(u: number): Vec2;
-    derivatives(u: number, n: number): Vec2[];
-    curvatureAt(u: number): number;
-    length(range?: Interval): number;
-    lengthAtParam(u: number): number;
-    paramAtLength(s: number, tol?: number): number;
-    split(u: number): Arc2[];
-    trim(range: Interval): Arc2[];
-    reverse(): this;
-    transform(m: Mat3): this;
-    transformed(m: Mat3): this;
-    closestPoint(p: Vec2): IClosestPointResult;
-    boundingBox(): Box2;
-    isValid(eps?: number): boolean;
-    isClosed(): boolean;
-    isArc(): this is Arc2;
-    /**
-     * 结构等价判断（字段级）。
-     * @param other 对比圆弧。
-     * @param eps 数值容差。
-     * @returns 圆心、半径、方向和起终角参数近似相等时返回 `true`。
-     */
-    equals(other: Arc2, eps?: number): boolean;
-    clone(): this;
-    dump(): IDBArc2;
-    static load(data: IDBArc2): Arc2;
-    private angleAtParam;
-    private paramFromAngle;
-    private resetAngles;
-    private normalizeAngle;
-    private positiveMod;
-}
-//# sourceMappingURL=arc2.d.ts.map

package/dist/curves/arc2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arc2.d.ts","sourceRoot":"","sources":["../../src/curves/arc2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEpD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AAEtD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAG/D,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGrC,qBACa,IAAK,SAAQ,YAAY;IAClC,gBAAuB,IAAI,oBAAmB;IAE9C,OAAO,CAAC,UAAU,CAAS;gBAEf,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,UAAQ;IAOjG,IAAW,SAAS,YAEnB;IAED,IAAW,UAAU,WAEpB;IAED,IAAW,QAAQ,WAMlB;IAEe,OAAO,CAAC,CAAC,EAAE,MAAM;IAIjB,SAAS,CAAC,CAAC,EAAE,MAAM;IAMnB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAYhC,WAAW,CAAC,CAAC,EAAE,MAAM;IAKrB,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAKvB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAA6B;IAQzD,KAAK,CAAC,CAAC,EAAE,MAAM;IAUf,IAAI,CAAC,KAAK,EAAE,QAAQ;IAUpB,OAAO;IAOP,SAAS,CAAC,CAAC,EAAE,IAAI;IAiCjB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI1B,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,mBAAmB;IAgD1C,WAAW;IAiBX,OAAO,CAAC,GAAG,SAA6B;IAIxC,QAAQ,IAAI,OAAO;IAInB,KAAK,IAAI,IAAI,IAAI,IAAI;IAIrC;;;;;OAKG;IACI,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,SAAgB;IAQ9B,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,OAAO;WAWjB,IAAI,CAAC,IAAI,EAAE,OAAO;IAUhC,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,WAAW;IAiBnB,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,WAAW;CAItB"}

package/dist/curves/arc2.js

@@ -1,265 +0,0 @@
-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 Arc2_1;
-import { EN_GEO_TYPE } from '../constants/geom_type';
-import { MathConst } from '../constants/math_const';
-import { Box2 } from '../core/box2';
-import { Vec2 } from '../core/vec2';
-import { RegisterGeom } from '../serialize/geom_mgr';
-import { MathError } from '../utils/math_error';
-import { Precision } from '../utils/precision';
-import { CircleCurve2 } from './circle_curve2';
-import { PeriodInterval } from './period_interval';
-let Arc2 = Arc2_1 = class Arc2 extends CircleCurve2 {
-    constructor(center, radius, startAngle, endAngle, clockwise = false) {
-        super(center, radius);
-        MathError.assert(Number.isFinite(startAngle) && Number.isFinite(endAngle), 'Arc2: startAngle/endAngle must be finite');
-        this._clockwise = clockwise;
-        this.resetAngles(startAngle, endAngle, clockwise);
-    }
-    get clockwise() {
-        return this._clockwise;
-    }
-    get startAngle() {
-        return this.normalizeAngle(this._range.start);
-    }
-    get endAngle() {
-        const sweep = this._range.length();
-        const end = this._clockwise
-            ? this._range.start - sweep
-            : this._range.start + sweep;
-        return this.normalizeAngle(end);
-    }
-    pointAt(u) {
-        return this.pointAtAngle(this.angleAtParam(u));
-    }
-    tangentAt(u) {
-        const theta = this.angleAtParam(u);
-        const sign = this._clockwise ? -1 : 1;
-        return this.derivativeAtAngle(theta, 1, sign);
-    }
-    derivatives(u, n) {
-        MathError.assert(Number.isInteger(n) && n >= 0, 'Arc2.derivatives: n must be a non-negative integer');
-        const theta = this.angleAtParam(u);
-        const sign = this._clockwise ? -1 : 1;
-        const ret = [this.pointAtAngle(theta)];
-        for (let i = 1; i <= n; i++) {
-            ret.push(this.derivativeAtAngle(theta, i, sign));
-        }
-        return ret;
-    }
-    curvatureAt(u) {
-        this.angleAtParam(u);
-        return 1 / this._radius;
-    }
-    length(range) {
-        if (!range)
-            return this._range.length() * this._radius;
-        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
-        return range.length() * this._radius;
-    }
-    lengthAtParam(u) {
-        const uu = this.normalizeParamForEval(u);
-        return (uu - this._range.start) * this._radius;
-    }
-    paramAtLength(s, tol = Precision.CURVE_LENGTH_EPS) {
-        const total = this.length();
-        MathError.assert(Number.isFinite(tol) && tol > 0, 'Arc2.paramAtLength: tol must be > 0');
-        MathError.assert(s >= -tol && s <= total + tol, `Arc2.paramAtLength: s out of range [0, ${total}]`);
-        const clamped = Math.min(total, Math.max(0, s));
-        return this._range.start + clamped / this._radius;
-    }
-    split(u) {
-        const pieces = this._range.split(u, Precision.CURVE_PARAM_EPS);
-        if (pieces.length === 0)
-            return [];
-        const theta = this.angleAtParam(u);
-        const left = new Arc2_1(this._center, this._radius, this.startAngle, theta, this._clockwise);
-        const right = new Arc2_1(this._center, this._radius, theta, this.endAngle, this._clockwise);
-        return [left, right].filter((arc) => arc.length() > Precision.CURVE_LENGTH_EPS);
-    }
-    trim(range) {
-        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
-        if (range.length() <= Precision.CURVE_PARAM_EPS)
-            return [];
-        const s = this.angleAtParam(range.start);
-        const e = this.angleAtParam(range.end);
-        const arc = new Arc2_1(this._center, this._radius, s, e, this._clockwise);
-        return arc.length() <= Precision.CURVE_LENGTH_EPS ? [] : [arc];
-    }
-    reverse() {
-        const s = this.startAngle;
-        const e = this.endAngle;
-        this.resetAngles(e, s, !this._clockwise);
-        return this;
-    }
-    transform(m) {
-        MathError.assert(m.isSimilarity2D(Precision.CURVE_PARAM_EPS), 'Arc2.transform: matrix must be a 2D similarity transform');
-        const oldSweep = this._range.length();
-        const oldClockwise = this._clockwise;
-        const startPoint = this.pointAt(this._range.start);
-        const endPoint = this.pointAt(this._range.end);
-        const nextCenter = m.transformedPoint(this._center);
-        const nextStartPoint = m.transformedPoint(startPoint);
-        const nextEndPoint = m.transformedPoint(endPoint);
-        const nextRadius = this._radius * m.getSimilarityScale2D(Precision.CURVE_PARAM_EPS);
-        MathError.assert(nextRadius > Precision.CURVE_LENGTH_EPS, 'Arc2.transform: degenerate radius after transform');
-        const det = m.determinant();
-        const mirrored = det < 0;
-        const nextClockwise = mirrored ? !oldClockwise : oldClockwise;
-        const startAngle = Math.atan2(nextStartPoint.y - nextCenter.y, nextStartPoint.x - nextCenter.x);
-        let endAngle = Math.atan2(nextEndPoint.y - nextCenter.y, nextEndPoint.x - nextCenter.x);
-        if (Math.abs(oldSweep - MathConst.PI2) <= Precision.CURVE_PARAM_EPS) {
-            endAngle = startAngle + (nextClockwise ? -MathConst.PI2 : MathConst.PI2);
-        }
-        this._center = nextCenter;
-        this._radius = nextRadius;
-        this.resetAngles(startAngle, endAngle, nextClockwise);
-        MathError.assert(this.length() > Precision.CURVE_LENGTH_EPS || Math.abs(oldSweep) <= Precision.CURVE_PARAM_EPS, 'Arc2.transform: invalid transformed arc');
-        return this;
-    }
-    transformed(m) {
-        return this.clone().transform(m);
-    }
-    closestPoint(p) {
-        const range = this._range;
-        const v = p.subtracted(this._center);
-        let candidateU = this._range.start;
-        if (v.len() > Precision.CURVE_NEWTON_EPS) {
-            const theta = Math.atan2(v.y, v.x);
-            candidateU = this.paramFromAngle(theta);
-        }
-        const candidates = [];
-        if (this.containsParam(candidateU)) {
-            candidates.push(candidateU);
-        }
-        candidates.push(this._range.start, this._range.end);
-        let bestU = candidates[0];
-        let bestP = this.pointAt(bestU);
-        let bestD = bestP.distanceTo(p);
-        for (let i = 1; i < candidates.length; i++) {
-            const u = candidates[i];
-            const q = this.pointAt(u);
-            const d = q.distanceTo(p);
-            if (d < bestD - Precision.CURVE_LENGTH_EPS) {
-                bestU = u;
-                bestP = q;
-                bestD = d;
-                continue;
-            }
-            if (Math.abs(d - bestD) <= Precision.CURVE_LENGTH_EPS) {
-                const uu = range.normalizeInPeriod(u, range.start);
-                const bb = range.normalizeInPeriod(bestU, range.start);
-                if (uu < bb) {
-                    bestU = u;
-                    bestP = q;
-                    bestD = d;
-                }
-            }
-        }
-        return {
-            point: bestP,
-            param: bestU,
-            distance: bestD,
-        };
-    }
-    boundingBox() {
-        const points = [
-            this.pointAt(this._range.start),
-            this.pointAt(this._range.end),
-        ];
-        const axes = [0, Math.PI * 0.5, Math.PI, Math.PI * 1.5];
-        for (const theta of axes) {
-            const u = this.paramFromAngle(theta);
-            if (this.containsParam(u)) {
-                points.push(this.pointAt(u));
-            }
-        }
-        return Box2.fromPoints(points);
-    }
-    isValid(eps = Precision.CURVE_LENGTH_EPS) {
-        return this.isCircleStructValid(eps) && this._range.length() >= 0 && this._range.length() <= MathConst.PI2 + Precision.CURVE_PARAM_EPS;
-    }
-    isClosed() {
-        return Precision.equal(this._range.length(), MathConst.PI2, Precision.CURVE_PARAM_EPS);
-    }
-    isArc() {
-        return true;
-    }
-    /**
-     * 结构等价判断（字段级）。
-     * @param other 对比圆弧。
-     * @param eps 数值容差。
-     * @returns 圆心、半径、方向和起终角参数近似相等时返回 `true`。
-     */
-    equals(other, eps = Precision.EPS) {
-        return this._clockwise === other._clockwise &&
-            this._center.equals(other._center, eps) &&
-            Precision.equal(this._radius, other._radius, eps) &&
-            Precision.equal(this.startAngle, other.startAngle, eps) &&
-            Precision.equal(this.endAngle, other.endAngle, eps);
-    }
-    clone() {
-        return new Arc2_1(this._center, this._radius, this.startAngle, this.endAngle, this._clockwise);
-    }
-    dump() {
-        return {
-            type: Arc2_1.type,
-            center: { x: this._center.x, y: this._center.y },
-            radius: this._radius,
-            startAngle: this.startAngle,
-            endAngle: this.endAngle,
-            clockwise: this._clockwise,
-        };
-    }
-    static load(data) {
-        return new Arc2_1(new Vec2(data.center.x, data.center.y), data.radius, data.startAngle, data.endAngle, data.clockwise);
-    }
-    angleAtParam(u) {
-        const uu = this.normalizeParamForEval(u);
-        // 内部参数域总是递增；顺时针时通过镜像映射回几何角度。
-        if (!this._clockwise)
-            return uu;
-        return this._range.start - (uu - this._range.start);
-    }
-    paramFromAngle(theta) {
-        const range = this._range;
-        if (!this._clockwise) {
-            return range.normalizeInPeriod(theta, range.start);
-        }
-        // 反向参数化：关于 start 角做镜像。
-        const reflected = 2 * range.start - theta;
-        return range.normalizeInPeriod(reflected, range.start);
-    }
-    resetAngles(startAngle, endAngle, clockwise) {
-        const s = this.normalizeAngle(startAngle);
-        const startEqEnd = Precision.equal(startAngle, endAngle, Precision.CURVE_PARAM_EPS);
-        let sweep = 0;
-        if (!startEqEnd) {
-            const raw = clockwise ? (startAngle - endAngle) : (endAngle - startAngle);
-            sweep = this.positiveMod(raw);
-            if (Precision.equal(sweep, 0, Precision.CURVE_PARAM_EPS)) {
-                sweep = MathConst.PI2;
-            }
-        }
-        this._clockwise = clockwise;
-        this.setRange(new PeriodInterval(s, s + sweep, MathConst.PI2));
-    }
-    normalizeAngle(a) {
-        const r = a % MathConst.PI2;
-        return r < 0 ? r + MathConst.PI2 : r;
-    }
-    positiveMod(x) {
-        const r = x % MathConst.PI2;
-        return r < 0 ? r + MathConst.PI2 : r;
-    }
-};
-Arc2.type = EN_GEO_TYPE.Arc2;
-Arc2 = Arc2_1 = __decorate([
-    RegisterGeom
-], Arc2);
-export { Arc2 };