@ccpc/math 0.1.0 → 0.1.7

package/dist/curves/line2.d.ts

@@ -1,64 +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 { IDBLine2 } from '../serialize/dump_types';
-import type { IClosestPointResult } from '../types/type_define';
-import { Curve2 } from './curve2';
-import { Interval } from './interval';
-export declare class Line2 extends Curve2 {
-    static readonly type = EN_GEO_TYPE.Line2;
-    private _start;
-    private _end;
-    private _dir;
-    private _len;
-    /**
-     * 构造线段。
-     * @param start 起点。
-     * @param end 终点。
-     */
-    constructor(start: Vec2, end: Vec2);
-    /** 起点（返回副本） */
-    get start(): Vec2;
-    /** 终点（返回副本） */
-    get end(): Vec2;
-    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): Line2[];
-    trim(range: Interval): Line2[];
-    reverse(): this;
-    transform(m: Mat3): this;
-    transformed(m: Mat3): this;
-    closestPoint(p: Vec2): IClosestPointResult;
-    boundingBox(): Box2;
-    isValid(eps?: number): boolean;
-    isLine(): this is Line2;
-    /**
-     * 结构等价判断（字段级）。
-     * @param other 对比线段。
-     * @param eps 数值容差。
-     * @returns 起点与终点分别近似相等时返回 `true`。
-     */
-    equals(other: Line2, eps?: number): boolean;
-    clone(): this;
-    dump(): IDBLine2;
-    static load(data: IDBLine2): Line2;
-    /**
-     * 参数吸附到端点，避免边界浮点抖动。
-     * @param u 输入参数。
-     * @returns 吸附后的参数。
-     */
-    private snapParam;
-    /**
-     * 重建方向与长度缓存。
-     * - `_dir`：单位方向向量
-     * - `_len`：线段长度
-     */
-    private rebuildCache;
-}
-//# sourceMappingURL=line2.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"line2.d.ts","sourceRoot":"","sources":["../../src/curves/line2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,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,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAG/D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAKa,KAAM,SAAQ,MAAM;IAC7B,gBAAuB,IAAI,qBAAoB;IAE/C,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,IAAI,CAAQ;IAEpB;;;;OAIG;gBACS,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;IAUlC,eAAe;IACf,IAAW,KAAK,SAEf;IAED,eAAe;IACf,IAAW,GAAG,SAEb;IAEe,OAAO,CAAC,CAAC,EAAE,MAAM;IAKjB,SAAS,CAAC,CAAC,EAAE,MAAM;IAKnB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAShC,WAAW,CAAC,CAAC,EAAE,MAAM;IAKrB,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAIvB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAA6B;IAMzD,KAAK,CAAC,CAAC,EAAE,MAAM;IAWf,IAAI,CAAC,KAAK,EAAE,QAAQ;IAUpB,OAAO;IASP,SAAS,CAAC,CAAC,EAAE,IAAI;IAcjB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI1B,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,mBAAmB;IAW1C,WAAW;IAIX,OAAO,CAAC,GAAG,SAA6B;IAQxC,MAAM,IAAI,IAAI,IAAI,KAAK;IAIvC;;;;;OAKG;IACI,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,SAAgB;IAI/B,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,QAAQ;WAQlB,IAAI,CAAC,IAAI,EAAE,QAAQ;IAOjC;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAOjB;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAOvB"}

package/dist/curves/line2.js

@@ -1,193 +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 Line2_1;
-import { EN_GEO_TYPE } from '../constants/geom_type';
-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 { Curve2 } from './curve2';
-import { Interval } from './interval';
-let Line2 = Line2_1 = class Line2 extends Curve2 {
-    /**
-     * 构造线段。
-     * @param start 起点。
-     * @param end 终点。
-     */
-    constructor(start, end) {
-        super();
-        this._start = start.clone();
-        this._end = end.clone();
-        this._dir = Vec2.zero();
-        this._len = 0;
-        this.rebuildCache();
-        this.setRange(new Interval(0, this._len));
-    }
-    /** 起点（返回副本） */
-    get start() {
-        return this._start.clone();
-    }
-    /** 终点（返回副本） */
-    get end() {
-        return this._end.clone();
-    }
-    pointAt(u) {
-        const uu = this.snapParam(u);
-        return this._start.added(this._dir.scaled(uu));
-    }
-    tangentAt(u) {
-        this.snapParam(u);
-        return this._dir.clone();
-    }
-    derivatives(u, n) {
-        MathError.assert(Number.isInteger(n) && n >= 0, 'Line2.derivatives: n must be a non-negative integer');
-        const ret = [this.pointAt(u)];
-        for (let i = 1; i <= n; i++) {
-            ret.push(i === 1 ? this._dir.clone() : Vec2.zero());
-        }
-        return ret;
-    }
-    curvatureAt(u) {
-        this.snapParam(u);
-        return 0;
-    }
-    length(range) {
-        if (!range)
-            return this._len;
-        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
-        return range.length();
-    }
-    lengthAtParam(u) {
-        return this.snapParam(u);
-    }
-    paramAtLength(s, tol = Precision.CURVE_LENGTH_EPS) {
-        MathError.assert(Number.isFinite(tol) && tol > 0, 'Line2.paramAtLength: tol must be > 0');
-        MathError.assert(s >= -tol && s <= this._len + tol, `Line2.paramAtLength: s out of range [0, ${this._len}]`);
-        return Math.min(this._len, Math.max(0, s));
-    }
-    split(u) {
-        const splitParts = this._range.split(u, Precision.CURVE_PARAM_EPS);
-        if (splitParts.length === 0)
-            return [];
-        const p = this.pointAt(u);
-        const left = new Line2_1(this._start, p);
-        const right = new Line2_1(p, this._end);
-        return [left, right].filter((seg) => seg.length() > Precision.CURVE_LENGTH_EPS);
-    }
-    trim(range) {
-        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
-        if (range.length() <= Precision.CURVE_PARAM_EPS)
-            return [];
-        if (range.length() <= Precision.CURVE_LENGTH_EPS)
-            return [];
-        const s = this.pointAt(range.start);
-        const e = this.pointAt(range.end);
-        return [new Line2_1(s, e)];
-    }
-    reverse() {
-        const t = this._start;
-        this._start = this._end;
-        this._end = t;
-        this.rebuildCache();
-        this.setRange(new Interval(0, this._len));
-        return this;
-    }
-    transform(m) {
-        const newStart = m.transformedPoint(this._start);
-        const newEnd = m.transformedPoint(this._end);
-        const nextLen = newStart.distanceTo(newEnd);
-        MathError.assert(nextLen > Precision.CURVE_LENGTH_EPS, 'Line2.transform: degenerate line after transform');
-        this._start = newStart;
-        this._end = newEnd;
-        this.rebuildCache();
-        this.setRange(new Interval(0, this._len));
-        return this;
-    }
-    transformed(m) {
-        return this.clone().transform(m);
-    }
-    closestPoint(p) {
-        const sp = p.subtracted(this._start);
-        const u = Math.min(this._len, Math.max(0, sp.dot(this._dir)));
-        const point = this.pointAt(u);
-        return {
-            point,
-            param: u,
-            distance: point.distanceTo(p),
-        };
-    }
-    boundingBox() {
-        return Box2.fromPoints([this._start, this._end]);
-    }
-    isValid(eps = Precision.CURVE_LENGTH_EPS) {
-        return Number.isFinite(this._start.x) &&
-            Number.isFinite(this._start.y) &&
-            Number.isFinite(this._end.x) &&
-            Number.isFinite(this._end.y) &&
-            this._start.distanceTo(this._end) > eps;
-    }
-    isLine() {
-        return true;
-    }
-    /**
-     * 结构等价判断（字段级）。
-     * @param other 对比线段。
-     * @param eps 数值容差。
-     * @returns 起点与终点分别近似相等时返回 `true`。
-     */
-    equals(other, eps = Precision.EPS) {
-        return this._start.equals(other._start, eps) && this._end.equals(other._end, eps);
-    }
-    clone() {
-        return new Line2_1(this._start, this._end);
-    }
-    dump() {
-        return {
-            type: Line2_1.type,
-            start: { x: this._start.x, y: this._start.y },
-            end: { x: this._end.x, y: this._end.y },
-        };
-    }
-    static load(data) {
-        return new Line2_1(new Vec2(data.start.x, data.start.y), new Vec2(data.end.x, data.end.y));
-    }
-    /**
-     * 参数吸附到端点，避免边界浮点抖动。
-     * @param u 输入参数。
-     * @returns 吸附后的参数。
-     */
-    snapParam(u) {
-        this._range.assertContains(u, Precision.CURVE_PARAM_EPS);
-        if (Math.abs(u - this._range.start) <= Precision.CURVE_PARAM_EPS)
-            return this._range.start;
-        if (Math.abs(u - this._range.end) <= Precision.CURVE_PARAM_EPS)
-            return this._range.end;
-        return u;
-    }
-    /**
-     * 重建方向与长度缓存。
-     * - `_dir`：单位方向向量
-     * - `_len`：线段长度
-     */
-    rebuildCache() {
-        const v = this._end.subtracted(this._start);
-        const len = v.len();
-        MathError.assert(len > Precision.CURVE_LENGTH_EPS, 'Line2: start and end must not coincide');
-        this._len = len;
-        this._dir = v.scale(1 / len);
-    }
-};
-Line2.type = EN_GEO_TYPE.Line2;
-Line2 = Line2_1 = __decorate([
-    RegisterGeom
-    /**
-     * 二维线段曲线。
-     * 参数域固定为 `[0, len]`，其中 `len = |end - start|`。
-     */
-], Line2);
-export { Line2 };

package/dist/curves/period_interval.d.ts

@@ -1,129 +0,0 @@
-import { Interval } from './interval';
-export declare class PeriodInterval extends Interval {
-    /** 周期长度，必须 > 0 */
-    readonly period: number;
-    /**
-     * 创建周期区间。
-     * @param start 区间起点，可为任意实数。
-     * @param end 区间终点，可为任意实数。
-     * @param period 周期长度，必须大于 0。
-     */
-    constructor(start?: number, end?: number, period?: number);
-    /**
-     * 将参数归一化到 `[0, period)`。
-     * @param u 待归一化参数。
-     * @returns 归一化后的参数值。
-     */
-    normalize(u: number): number;
-    /**
-     * 将参数归一化到指定周期窗口 `[start, start + period)`。
-     * @param u 待归一化参数。
-     * @param start 周期窗口起点，默认当前区间起点。
-     * @returns 与 `u` 周期等价，且落在窗口内的参数。
-     */
-    normalizeInPeriod(u: number, start?: number): number;
-    /**
-     * 区间整体平移（按周期等价）。
-     * @param offset 平移量。
-     * @returns 平移后的新区间实例。
-     */
-    shift(offset: number): PeriodInterval;
-    /**
-     * 计算周期区间长度（沿正方向）。
-     * @returns 区间跨度，范围在 `[0, period]`。
-     */
-    length(): number;
-    /**
-     * 判断参数是否落在周期区间内。
-     * @param u 待判断参数。
-     * @param eps 边界比较容差。
-     * @returns 落在区间内（含容差）返回 `true`。
-     */
-    contains(u: number, eps?: number): boolean;
-    /**
-     * 将参数限制到区间内。
-     * @param u 输入参数。
-     * @returns 已在区间内返回归一化参数；否则返回最近边界参数。
-     */
-    clamp(u: number): number;
-    /**
-     * 判断两个周期区间是否近似相等。
-     * @param other 对比区间。
-     * @param eps 数值比较容差。
-     * @returns 周期一致且区间位置/长度一致时返回 `true`。
-     */
-    equals(other: PeriodInterval, eps?: number): boolean;
-    /**
-     * 计算周期交集。
-     * @param other 参与求交的周期区间。
-     * @param eps 交并判定容差。
-     * @returns 交集结果，按线性分段返回 `PeriodInterval[]`（最多 2 段）。
-     */
-    intersect(other: PeriodInterval, eps?: number): PeriodInterval[];
-    /**
-     * 计算周期并集。
-     * @param other 参与求并的周期区间。
-     * @param eps 交并判定容差。
-     * @returns 并集结果，按线性分段返回 `PeriodInterval[]`（1 到 2 段）。
-     */
-    union(other: PeriodInterval, eps?: number): PeriodInterval[];
-    /**
-     * 以参数 `u` 对周期区间切分。
-     * @param u 切分参数。
-     * @param eps 边界判定容差。
-     * @returns 边界或区间外返回 `[]`；内部切分返回两段区间。
-     */
-    split(u: number, eps?: number): PeriodInterval[];
-    /**
-     * 克隆当前周期区间。
-     * @returns 与当前数值等价的新实例。
-     */
-    clone(): PeriodInterval;
-    /**
-     * 当前区间沿正方向长度。
-     * @returns `_end - _start`。
-     */
-    private span;
-    /**
-     * 判断是否为整周期闭合区间。
-     * @param eps 比较容差。
-     * @returns 近似等于整周期长度时返回 `true`。
-     */
-    private isFull;
-    /**
-     * 计算两参数在圆周上的最短距离。
-     * @param a 参数 a。
-     * @param b 参数 b。
-     * @returns 最短圆周距离。
-     */
-    private circularDistance;
-    /**
-     * 计算从 `a` 到 `b` 的正方向差值。
-     * @param a 起点参数。
-     * @param b 终点参数。
-     * @returns 归一化到 `[0, period)` 的正向差值。
-     */
-    private forwardDelta;
-    /**
-     * 转为 `[0, period]` 上的普通线性区间段。
-     * @param eps 判定整周期与边界贴合的容差。
-     * @returns 线性区间段数组。
-     */
-    private toLinearSegments;
-    /**
-     * 规范化输入到内部表示。
-     * @param start 输入起点。
-     * @param end 输入终点。
-     * @param period 周期长度。
-     * @returns 规范化后的 `{ start, end }`，满足 `start in [0, period)` 且 `end = start + len`。
-     */
-    private static canonicalize;
-    /**
-     * 正模运算。
-     * @param x 被取模值。
-     * @param m 模（周期）。
-     * @returns 结果范围在 `[0, m)`。
-     */
-    private static mod;
-}
-//# sourceMappingURL=period_interval.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"period_interval.d.ts","sourceRoot":"","sources":["../../src/curves/period_interval.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAAa,cAAe,SAAQ,QAAQ;IACxC,kBAAkB;IAClB,SAAgB,MAAM,EAAE,MAAM,CAAA;IAE9B;;;;;OAKG;gBACS,KAAK,SAAI,EAAE,GAAG,SAAI,EAAE,MAAM,SAAc;IAQpD;;;;OAIG;IACI,SAAS,CAAC,CAAC,EAAE,MAAM;IAI1B;;;;;OAKG;IACI,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,SAAa;IAItD;;;;OAIG;IACI,KAAK,CAAC,MAAM,EAAE,MAAM;IAI3B;;;OAGG;IACa,MAAM;IAItB;;;;;OAKG;IACa,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAgB;IAMvD;;;;OAIG;IACa,KAAK,CAAC,CAAC,EAAE,MAAM;IAU/B;;;;;OAKG;IACa,MAAM,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAgB;IAOjE;;;;;OAKG;IACa,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAgB,GAAG,cAAc,EAAE;IAcvF;;;;;OAKG;IACa,KAAK,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAgB,GAAG,cAAc,EAAE;IAqBnF;;;;;OAKG;IACa,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAgB,GAAG,cAAc,EAAE;IAavE;;;OAGG;IACa,KAAK;IAIrB;;;OAGG;IACH,OAAO,CAAC,IAAI;IAIZ;;;;OAIG;IACH,OAAO,CAAC,MAAM;IAId;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,GAAG;CAIrB"}

package/dist/curves/period_interval.js

@@ -1,240 +0,0 @@
-/*
- * Linea Math - Curves
- * PeriodInterval: 周期参数区间
- */
-import { MathError } from '../utils/math_error';
-import { Precision } from '../utils/precision';
-import { Interval } from './interval';
-export class PeriodInterval extends Interval {
-    /**
-     * 创建周期区间。
-     * @param start 区间起点，可为任意实数。
-     * @param end 区间终点，可为任意实数。
-     * @param period 周期长度，必须大于 0。
-     */
-    constructor(start = 0, end = 0, period = Math.PI * 2) {
-        MathError.assert(Number.isFinite(start) && Number.isFinite(end), 'PeriodInterval: start/end must be finite');
-        MathError.assert(period > 0, 'PeriodInterval: period must be > 0');
-        const canonical = PeriodInterval.canonicalize(start, end, period);
-        super(canonical.start, canonical.end);
-        this.period = period;
-    }
-    /**
-     * 将参数归一化到 `[0, period)`。
-     * @param u 待归一化参数。
-     * @returns 归一化后的参数值。
-     */
-    normalize(u) {
-        return PeriodInterval.mod(u, this.period);
-    }
-    /**
-     * 将参数归一化到指定周期窗口 `[start, start + period)`。
-     * @param u 待归一化参数。
-     * @param start 周期窗口起点，默认当前区间起点。
-     * @returns 与 `u` 周期等价，且落在窗口内的参数。
-     */
-    normalizeInPeriod(u, start = this.start) {
-        return start + PeriodInterval.mod(u - start, this.period);
-    }
-    /**
-     * 区间整体平移（按周期等价）。
-     * @param offset 平移量。
-     * @returns 平移后的新区间实例。
-     */
-    shift(offset) {
-        return new PeriodInterval(this._start + offset, this._start + this.span() + offset, this.period);
-    }
-    /**
-     * 计算周期区间长度（沿正方向）。
-     * @returns 区间跨度，范围在 `[0, period]`。
-     */
-    length() {
-        return this.span();
-    }
-    /**
-     * 判断参数是否落在周期区间内。
-     * @param u 待判断参数。
-     * @param eps 边界比较容差。
-     * @returns 落在区间内（含容差）返回 `true`。
-     */
-    contains(u, eps = Precision.EPS) {
-        if (this.isFull(eps))
-            return true;
-        const d = this.forwardDelta(this._start, this.normalize(u));
-        return d <= this.span() + eps || this.period - d <= eps;
-    }
-    /**
-     * 将参数限制到区间内。
-     * @param u 输入参数。
-     * @returns 已在区间内返回归一化参数；否则返回最近边界参数。
-     */
-    clamp(u) {
-        const t = this.normalize(u);
-        if (this.contains(t))
-            return t;
-        const end = this.normalize(this._start + this.span());
-        const dStart = this.circularDistance(t, this._start);
-        const dEnd = this.circularDistance(t, end);
-        return dStart <= dEnd ? this._start : end;
-    }
-    /**
-     * 判断两个周期区间是否近似相等。
-     * @param other 对比区间。
-     * @param eps 数值比较容差。
-     * @returns 周期一致且区间位置/长度一致时返回 `true`。
-     */
-    equals(other, eps = Precision.EPS) {
-        if (!Precision.equal(this.period, other.period, eps))
-            return false;
-        if (this.isFull(eps) && other.isFull(eps))
-            return true;
-        return Precision.equal(this._start, other._start, eps) &&
-            Precision.equal(this.span(), other.span(), eps);
-    }
-    /**
-     * 计算周期交集。
-     * @param other 参与求交的周期区间。
-     * @param eps 交并判定容差。
-     * @returns 交集结果，按线性分段返回 `PeriodInterval[]`（最多 2 段）。
-     */
-    intersect(other, eps = Precision.EPS) {
-        if (!Precision.equal(this.period, other.period, eps)) {
-            MathError.throw('PeriodInterval.intersect: period mismatch');
-        }
-        const ret = [];
-        for (const a of this.toLinearSegments(eps)) {
-            for (const b of other.toLinearSegments(eps)) {
-                ret.push(...a.intersect(b, eps));
-            }
-        }
-        return Interval.merge(ret, eps).map((seg) => new PeriodInterval(seg.start, seg.end, this.period));
-    }
-    /**
-     * 计算周期并集。
-     * @param other 参与求并的周期区间。
-     * @param eps 交并判定容差。
-     * @returns 并集结果，按线性分段返回 `PeriodInterval[]`（1 到 2 段）。
-     */
-    union(other, eps = Precision.EPS) {
-        if (!Precision.equal(this.period, other.period, eps)) {
-            MathError.throw('PeriodInterval.union: period mismatch');
-        }
-        const merged = Interval.merge([
-            ...this.toLinearSegments(eps),
-            ...other.toLinearSegments(eps),
-        ], eps);
-        if (merged.length >= 2) {
-            const first = merged[0];
-            const last = merged[merged.length - 1];
-            if (Precision.equal(first.start, 0, eps) && Precision.equal(last.end, this.period, eps)) {
-                const stitched = new Interval(last.start, this.period + first.end);
-                return [stitched, ...merged.slice(1, -1)].map((seg) => new PeriodInterval(seg.start, seg.end, this.period));
-            }
-        }
-        return merged.map((seg) => new PeriodInterval(seg.start, seg.end, this.period));
-    }
-    /**
-     * 以参数 `u` 对周期区间切分。
-     * @param u 切分参数。
-     * @param eps 边界判定容差。
-     * @returns 边界或区间外返回 `[]`；内部切分返回两段区间。
-     */
-    split(u, eps = Precision.EPS) {
-        if (!this.contains(u, eps))
-            return [];
-        const d = this.forwardDelta(this._start, this.normalize(u));
-        const len = this.span();
-        if (d <= eps || d >= len - eps)
-            return [];
-        const mid = this._start + d;
-        return [
-            new PeriodInterval(this._start, mid, this.period),
-            new PeriodInterval(mid, this._start + len, this.period),
-        ];
-    }
-    /**
-     * 克隆当前周期区间。
-     * @returns 与当前数值等价的新实例。
-     */
-    clone() {
-        return new PeriodInterval(this._start, this._start + this.span(), this.period);
-    }
-    /**
-     * 当前区间沿正方向长度。
-     * @returns `_end - _start`。
-     */
-    span() {
-        return this._end - this._start;
-    }
-    /**
-     * 判断是否为整周期闭合区间。
-     * @param eps 比较容差。
-     * @returns 近似等于整周期长度时返回 `true`。
-     */
-    isFull(eps = Precision.EPS) {
-        return Precision.equal(this.span(), this.period, eps);
-    }
-    /**
-     * 计算两参数在圆周上的最短距离。
-     * @param a 参数 a。
-     * @param b 参数 b。
-     * @returns 最短圆周距离。
-     */
-    circularDistance(a, b) {
-        const d = Math.abs(a - b);
-        return Math.min(d, this.period - d);
-    }
-    /**
-     * 计算从 `a` 到 `b` 的正方向差值。
-     * @param a 起点参数。
-     * @param b 终点参数。
-     * @returns 归一化到 `[0, period)` 的正向差值。
-     */
-    forwardDelta(a, b) {
-        return PeriodInterval.mod(b - a, this.period);
-    }
-    /**
-     * 转为 `[0, period]` 上的普通线性区间段。
-     * @param eps 判定整周期与边界贴合的容差。
-     * @returns 线性区间段数组。
-     */
-    toLinearSegments(eps = Precision.EPS) {
-        if (this.isFull(eps)) {
-            return [new Interval(0, this.period)];
-        }
-        const s = this._start;
-        const e = this._start + this.span();
-        if (e <= this.period + eps) {
-            return [new Interval(s, Math.min(e, this.period))];
-        }
-        return [
-            new Interval(s, this.period),
-            new Interval(0, e - this.period),
-        ];
-    }
-    /**
-     * 规范化输入到内部表示。
-     * @param start 输入起点。
-     * @param end 输入终点。
-     * @param period 周期长度。
-     * @returns 规范化后的 `{ start, end }`，满足 `start in [0, period)` 且 `end = start + len`。
-     */
-    static canonicalize(start, end, period) {
-        const s = PeriodInterval.mod(start, period);
-        let len = PeriodInterval.mod(end - start, period);
-        if (Precision.equal(len, 0, Precision.EPS) && !Precision.equal(start, end, Precision.EPS)) {
-            len = period;
-        }
-        return { start: s, end: s + len };
-    }
-    /**
-     * 正模运算。
-     * @param x 被取模值。
-     * @param m 模（周期）。
-     * @returns 结果范围在 `[0, m)`。
-     */
-    static mod(x, m) {
-        const r = x % m;
-        return r < 0 ? r + m : r;
-    }
-}

package/dist/discretize/discretize_defaults.d.ts

@@ -1,12 +0,0 @@
-export declare const DISCRETIZE_DEFAULTS: Readonly<{
-    chordTol: 0.001;
-    angleTolRad: number;
-    maxSegmentLength: number;
-    minSegments: 8;
-    maxSegments: 4096;
-    includeEnd: true;
-}>;
-export declare const DISCRETIZE_INTERNAL_DEFAULTS: Readonly<{
-    minSegmentLengthInternal: number;
-}>;
-//# sourceMappingURL=discretize_defaults.d.ts.map

package/dist/discretize/discretize_defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"discretize_defaults.d.ts","sourceRoot":"","sources":["../../src/discretize/discretize_defaults.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;EAO9B,CAAA;AAEF,eAAO,MAAM,4BAA4B;;EAEvC,CAAA"}

package/dist/discretize/discretize_defaults.js

@@ -1,12 +0,0 @@
-import { Precision } from '../utils/precision';
-export const DISCRETIZE_DEFAULTS = Object.freeze({
-    chordTol: 1e-3,
-    angleTolRad: Math.PI / 180,
-    maxSegmentLength: Number.POSITIVE_INFINITY,
-    minSegments: 8,
-    maxSegments: 4096,
-    includeEnd: true,
-});
-export const DISCRETIZE_INTERNAL_DEFAULTS = Object.freeze({
-    minSegmentLengthInternal: Precision.CURVE_LENGTH_EPS,
-});