@ccpc/math 0.1.0

package/dist/intersections/analytic_x_algorithm.js

@@ -0,0 +1,83 @@
+import { MathError } from '../utils/math_error';
+import { getCurveKind } from './internal/kind';
+import { normalizePair } from './internal/pair';
+import { analyzeCurveXInfosQuality, postprocessCurveXInfos, swapCurveXInfos } from './internal/result';
+import { makeIntersectionTolerance } from './internal/tolerance';
+import { ArcArcPairSolver, ArcEllipseArcPairSolver, ArcEllipsePairSolver, CircleArcPairSolver, CircleCirclePairSolver, CircleEllipseArcPairSolver, CircleEllipsePairSolver, EllipseArcEllipseArcPairSolver, EllipseEllipseArcPairSolver, EllipseEllipsePairSolver, LineArcPairSolver, LineCirclePairSolver, LineEllipseArcPairSolver, LineEllipsePairSolver, LineLinePairSolver, } from './solvers/pair_solvers';
+import { PolylinePairIntersector } from './solvers/polyline_pair_intersector';
+export class AnalyticXAlgorithm {
+    constructor() {
+        this.map = {
+            'line|line': new LineLinePairSolver(),
+            'line|circle': new LineCirclePairSolver(),
+            'line|arc': new LineArcPairSolver(),
+            'line|ellipse': new LineEllipsePairSolver(),
+            'line|ellipseArc': new LineEllipseArcPairSolver(),
+            'circle|circle': new CircleCirclePairSolver(),
+            'circle|arc': new CircleArcPairSolver(),
+            'circle|ellipse': new CircleEllipsePairSolver(),
+            'circle|ellipseArc': new CircleEllipseArcPairSolver(),
+            'arc|arc': new ArcArcPairSolver(),
+            'arc|ellipse': new ArcEllipsePairSolver(),
+            'arc|ellipseArc': new ArcEllipseArcPairSolver(),
+            'ellipse|ellipse': new EllipseEllipsePairSolver(),
+            'ellipse|ellipseArc': new EllipseEllipseArcPairSolver(),
+            'ellipseArc|ellipseArc': new EllipseArcEllipseArcPairSolver(),
+        };
+        this.retryMap = {
+            'circle|ellipse': new PolylinePairIntersector(320, 96),
+            'circle|ellipseArc': new PolylinePairIntersector(320, 96),
+            'arc|ellipse': new PolylinePairIntersector(320, 96),
+            'arc|ellipseArc': new PolylinePairIntersector(320, 96),
+            'ellipse|ellipse': new PolylinePairIntersector(352, 96),
+            'ellipse|ellipseArc': new PolylinePairIntersector(352, 96),
+            'ellipseArc|ellipseArc': new PolylinePairIntersector(352, 96),
+        };
+    }
+    intersect(c1, c2) {
+        const k1 = getCurveKind(c1);
+        const k2 = getCurveKind(c2);
+        const pair = normalizePair(k1, k2);
+        const solver = this.map[pair.key];
+        if (!solver) {
+            MathError.throw(`AnalyticXAlgorithm: unsupported pair ${c1.getType()}|${c2.getType()}`);
+        }
+        const tol = makeIntersectionTolerance(c1, c2);
+        const diagBefore = PolylinePairIntersector.getDiagnostics();
+        const raw = pair.swapped ? solver.intersect(c2, c1) : solver.intersect(c1, c2);
+        const ordered = pair.swapped ? swapCurveXInfos(raw) : raw;
+        const primary = postprocessCurveXInfos(ordered, tol.pointTol);
+        const quality = analyzeCurveXInfosQuality(ordered, tol.pointTol);
+        if (!this.shouldRetry(pair.key, c1, c2, quality, diagBefore, PolylinePairIntersector.getDiagnostics())) {
+            return primary;
+        }
+        const retrySolver = this.retryMap[pair.key];
+        if (!retrySolver)
+            return primary;
+        const retryRaw = pair.swapped ? retrySolver.intersect(c2, c1) : retrySolver.intersect(c1, c2);
+        if (retryRaw.length === 0)
+            return primary;
+        const retryOrdered = pair.swapped ? swapCurveXInfos(retryRaw) : retryRaw;
+        return postprocessCurveXInfos([...ordered, ...retryOrdered], tol.pointTol);
+    }
+    shouldRetry(key, c1, c2, quality, before, after) {
+        if (!this.retryMap[key])
+            return false;
+        if (!this.boxesLikelyIntersect(c1, c2))
+            return false;
+        if (quality.rawCount === 0)
+            return true;
+        if (quality.duplicatePointCount > 0)
+            return true;
+        const certificationMissDelta = after.certificationMissCount - before.certificationMissCount;
+        const refineFailDelta = after.refineFailureCount - before.refineFailureCount;
+        const rejectDelta = after.certificationRejectCount - before.certificationRejectCount;
+        return certificationMissDelta > 0 || refineFailDelta > 0 || rejectDelta > 0;
+    }
+    boxesLikelyIntersect(c1, c2) {
+        const t = makeIntersectionTolerance(c1, c2);
+        const b1 = c1.boundingBox().expandByScalar(t.pointTol * 2);
+        const b2 = c2.boundingBox().expandByScalar(t.pointTol * 2);
+        return b1.intersects(b2);
+    }
+}

package/dist/intersections/curve_x_engine.d.ts

@@ -0,0 +1,9 @@
+import type { Curve2 } from '../curves/curve2';
+import type { CurveXInfo } from './types';
+export declare class CurveXEngine {
+    private readonly analytic;
+    private readonly numeric;
+    intersect(c1: Curve2, c2: Curve2): CurveXInfo[];
+    private shouldUseNumeric;
+}
+//# sourceMappingURL=curve_x_engine.d.ts.map

package/dist/intersections/curve_x_engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve_x_engine.d.ts","sourceRoot":"","sources":["../../src/intersections/curve_x_engine.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAI9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC,qBAAa,YAAY;IACrB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2B;IACpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAE3C,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE;IAkBtD,OAAO,CAAC,gBAAgB;CAG3B"}

package/dist/intersections/curve_x_engine.js

@@ -0,0 +1,27 @@
+import { MathError } from '../utils/math_error';
+import { AnalyticXAlgorithm } from './analytic_x_algorithm';
+import { NumericXAlgorithm } from './numeric_x_algorithm';
+export class CurveXEngine {
+    constructor() {
+        this.analytic = new AnalyticXAlgorithm();
+        this.numeric = new NumericXAlgorithm();
+    }
+    intersect(c1, c2) {
+        if (this.shouldUseNumeric(c1, c2)) {
+            return this.numeric.intersect(c1, c2);
+        }
+        try {
+            return this.analytic.intersect(c1, c2);
+        }
+        catch (error) {
+            if (error instanceof MathError &&
+                error.message.startsWith('AnalyticXAlgorithm: unsupported pair')) {
+                return this.numeric.intersect(c1, c2);
+            }
+            throw error;
+        }
+    }
+    shouldUseNumeric(c1, c2) {
+        return c1.isBSpline() || c2.isBSpline();
+    }
+}

package/dist/intersections/index.d.ts

@@ -0,0 +1,5 @@
+import type { Curve2 } from '../curves/curve2';
+export type { CurveXInfo } from './types';
+export declare function intersectCurveCurve(c1: Curve2, c2: Curve2): import("./types").CurveXInfo[];
+export declare function intersectCurveSelf(curve: Curve2): import("./types").CurveXInfo[];
+//# sourceMappingURL=index.d.ts.map

package/dist/intersections/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/intersections/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAI9C,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAIzC,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,kCAEzD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,kCAG/C"}

package/dist/intersections/index.js

@@ -0,0 +1,11 @@
+import { CurveXEngine } from './curve_x_engine';
+import { intersectBSplineSelf } from './solvers/bspline_self_solver';
+const curveXEngine = new CurveXEngine();
+export function intersectCurveCurve(c1, c2) {
+    return curveXEngine.intersect(c1, c2);
+}
+export function intersectCurveSelf(curve) {
+    if (!curve.isBSpline())
+        return [];
+    return intersectBSplineSelf(curve);
+}

package/dist/intersections/internal/certification.d.ts

@@ -0,0 +1,34 @@
+import { Interval } from '../../curves/interval';
+import type { Curve2 } from '../../curves/curve2';
+import type { Vec2 } from '../../core/vec2';
+export type ClosestPointLike = {
+    param: number;
+    distance: number;
+};
+export type ClosestPointProvider = (curve: Curve2, p: Vec2, tol: number) => ClosestPointLike | undefined;
+export type ParamPairCandidate = {
+    u1: number;
+    u2: number;
+    residual: number;
+};
+export type CertifiedParamPair = {
+    point: Vec2;
+    u1: number;
+    u2: number;
+    residual: number;
+};
+export type ResidualEnvelope = {
+    lowerBound: number;
+    upperBound: number;
+    minSample: number;
+    maxSample: number;
+};
+export type CertificationOutcome = {
+    pair: CertifiedParamPair;
+    usedDegenerateRescue: boolean;
+    envelopeUpperBound: number;
+};
+export declare function certifyParamPair(c1: Curve2, c2: Curve2, candidate: ParamPairCandidate, tol: number, closestPoint: ClosestPointProvider): CertificationOutcome | undefined;
+export declare function projectRangeToCurve(baseCurve: Curve2, otherCurve: Curve2, rangeOnBase: Interval, tol: number, closestPoint: ClosestPointProvider): Interval | undefined;
+export declare function certifyOverlapMonotone(baseCurve: Curve2, otherCurve: Curve2, rangeOnBase: Interval, tol: number, paramTol: number, closestPoint: ClosestPointProvider): boolean;
+//# sourceMappingURL=certification.d.ts.map

package/dist/intersections/internal/certification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"certification.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/certification.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AACjD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAE3C,MAAM,MAAM,gBAAgB,GAAG;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,KAAK,gBAAgB,GAAG,SAAS,CAAA;AAExG,MAAM,MAAM,kBAAkB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC7B,KAAK,EAAE,IAAI,CAAA;IACX,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IAC/B,IAAI,EAAE,kBAAkB,CAAA;IACxB,oBAAoB,EAAE,OAAO,CAAA;IAC7B,kBAAkB,EAAE,MAAM,CAAA;CAC7B,CAAA;AAED,wBAAgB,gBAAgB,CAC5B,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,kBAAkB,EAC7B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,oBAAoB,GACnC,oBAAoB,GAAG,SAAS,CAwBlC;AAED,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,QAAQ,EACrB,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,oBAAoB,GACnC,QAAQ,GAAG,SAAS,CAOtB;AAED,wBAAgB,sBAAsB,CAClC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,QAAQ,EACrB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,oBAAoB,WAuBrC"}

package/dist/intersections/internal/certification.js

@@ -0,0 +1,238 @@
+import { Interval } from '../../curves/interval';
+import { Precision } from '../../utils/precision';
+export function certifyParamPair(c1, c2, candidate, tol, closestPoint) {
+    const cp2 = closestPoint(c2, c1.pointAt(candidate.u1), tol * 2);
+    const cp1 = closestPoint(c1, c2.pointAt(candidate.u2), tol * 2);
+    if (!cp1 || !cp2)
+        return undefined;
+    if (cp1.distance > tol * 3 || cp2.distance > tol * 3)
+        return undefined;
+    const measured = measureParamPair(c1, c2, cp1.param, cp2.param);
+    if (measured.residual > tol * 3)
+        return undefined;
+    const envelope = estimateResidualEnvelopeAdaptive(c1, c2, measured.u1, measured.u2, 4);
+    if (envelope.upperBound <= tol * 6) {
+        return {
+            pair: measured,
+            usedDegenerateRescue: false,
+            envelopeUpperBound: envelope.upperBound,
+        };
+    }
+    if (!isNearDegenerate(c1, c2, measured.u1, measured.u2))
+        return undefined;
+    const rescued = tryDegenerateRescue(c1, c2, measured, tol, closestPoint);
+    if (!rescued)
+        return undefined;
+    return {
+        pair: rescued.pair,
+        usedDegenerateRescue: true,
+        envelopeUpperBound: rescued.envelope.upperBound,
+    };
+}
+export function projectRangeToCurve(baseCurve, otherCurve, rangeOnBase, tol, closestPoint) {
+    const startOnBase = baseCurve.pointAt(rangeOnBase.start);
+    const endOnBase = baseCurve.pointAt(rangeOnBase.end);
+    const cpStart = closestPoint(otherCurve, startOnBase, tol);
+    const cpEnd = closestPoint(otherCurve, endOnBase, tol);
+    if (!cpStart || !cpEnd)
+        return undefined;
+    return new Interval(Math.min(cpStart.param, cpEnd.param), Math.max(cpStart.param, cpEnd.param));
+}
+export function certifyOverlapMonotone(baseCurve, otherCurve, rangeOnBase, tol, paramTol, closestPoint) {
+    const samples = [0, 0.25, 0.5, 0.75, 1];
+    let pass = 0;
+    const paramsOnOther = [];
+    for (const t of samples) {
+        const u = rangeOnBase.start + (rangeOnBase.end - rangeOnBase.start) * t;
+        const p = baseCurve.pointAt(u);
+        const cp = closestPoint(otherCurve, p, tol);
+        if (!cp)
+            continue;
+        paramsOnOther.push(cp.param);
+        if (cp.distance <= tol * 2.5)
+            pass++;
+    }
+    if (pass < 4 || paramsOnOther.length < 4)
+        return false;
+    let nonDecreasing = true;
+    let nonIncreasing = true;
+    for (let i = 1; i < paramsOnOther.length; i++) {
+        if (paramsOnOther[i] < paramsOnOther[i - 1] - paramTol)
+            nonDecreasing = false;
+        if (paramsOnOther[i] > paramsOnOther[i - 1] + paramTol)
+            nonIncreasing = false;
+    }
+    return nonDecreasing || nonIncreasing;
+}
+function measureParamPair(c1, c2, u1, u2) {
+    const p1 = c1.pointAt(u1);
+    const p2 = c2.pointAt(u2);
+    return {
+        u1,
+        u2,
+        point: p1.added(p2).scale(0.5),
+        residual: p1.distanceTo(p2),
+    };
+}
+function estimateResidualEnvelopeAdaptive(c1, c2, u1, u2, maxDepth) {
+    let w1 = buildCertificationWindow(c1, u1, 1);
+    let w2 = buildCertificationWindow(c2, u2, 1);
+    let upper = Number.POSITIVE_INFINITY;
+    let lower = 0;
+    let minSample = Number.POSITIVE_INFINITY;
+    let maxSample = 0;
+    for (let depth = 0; depth <= maxDepth; depth++) {
+        const env = evaluateWindowEnvelope(c1, c2, w1, w2);
+        lower = Math.max(lower, env.lowerBound);
+        upper = Math.min(upper, env.upperBound);
+        minSample = Math.min(minSample, env.minSample);
+        maxSample = Math.max(maxSample, env.maxSample);
+        if (w1.length() <= Precision.CURVE_PARAM_EPS * 32 && w2.length() <= Precision.CURVE_PARAM_EPS * 32) {
+            break;
+        }
+        w1 = shrinkWindowAroundParam(c1, w1, u1, 0.5);
+        w2 = shrinkWindowAroundParam(c2, w2, u2, 0.5);
+    }
+    const half1 = 0.5 * (w1.end - w1.start);
+    const half2 = 0.5 * (w2.end - w2.start);
+    const l1 = maxTangentNorm(c1, w1);
+    const l2 = maxTangentNorm(c2, w2);
+    const drift = l1 * half1 + l2 * half2;
+    const conservativeUpper = Number.isFinite(upper) ? upper + drift * 0.25 : maxSample + drift;
+    const conservativeLower = Math.max(0, lower - drift * 0.25);
+    return {
+        lowerBound: conservativeLower,
+        upperBound: Math.max(conservativeUpper, maxSample),
+        minSample,
+        maxSample,
+    };
+}
+function tryDegenerateRescue(c1, c2, measured, tol, closestPoint) {
+    const w1 = buildCertificationWindow(c1, measured.u1, 2);
+    const w2 = buildCertificationWindow(c2, measured.u2, 2);
+    const grid = sampleInterval5(w1);
+    const grid2 = sampleInterval5(w2);
+    let best = measured;
+    for (const u of grid) {
+        const p1 = c1.pointAt(u);
+        for (const v of grid2) {
+            const p2 = c2.pointAt(v);
+            const d = p1.distanceTo(p2);
+            if (d >= best.residual)
+                continue;
+            best = {
+                u1: u,
+                u2: v,
+                point: p1.added(p2).scale(0.5),
+                residual: d,
+            };
+        }
+    }
+    const cp2 = closestPoint(c2, c1.pointAt(best.u1), tol * 3);
+    if (cp2) {
+        const cp1 = closestPoint(c1, c2.pointAt(cp2.param), tol * 3);
+        if (cp1) {
+            best = measureParamPair(c1, c2, cp1.param, cp2.param);
+        }
+    }
+    if (best.residual > tol * 2.8)
+        return undefined;
+    const envelope = evaluateWindowEnvelope(c1, c2, buildCertificationWindow(c1, best.u1, 1), buildCertificationWindow(c2, best.u2, 1));
+    if (envelope.upperBound > tol * 8)
+        return undefined;
+    return {
+        pair: best,
+        envelope,
+    };
+}
+function evaluateWindowEnvelope(c1, c2, w1, w2) {
+    const uSamples = sampleInterval5(w1);
+    const vSamples = sampleInterval5(w2);
+    let minSample = Number.POSITIVE_INFINITY;
+    let maxSample = 0;
+    for (const a of uSamples) {
+        const p1 = c1.pointAt(a);
+        for (const b of vSamples) {
+            const p2 = c2.pointAt(b);
+            const r = p1.distanceTo(p2);
+            if (r < minSample)
+                minSample = r;
+            if (r > maxSample)
+                maxSample = r;
+        }
+    }
+    const half1 = 0.5 * (w1.end - w1.start);
+    const half2 = 0.5 * (w2.end - w2.start);
+    const l1 = maxTangentNorm(c1, w1);
+    const l2 = maxTangentNorm(c2, w2);
+    const drift = l1 * half1 + l2 * half2;
+    return {
+        lowerBound: Math.max(0, minSample - drift),
+        upperBound: maxSample + drift,
+        minSample,
+        maxSample,
+    };
+}
+function buildCertificationWindow(curve, u, scale) {
+    const range = curve.getRange();
+    const span = Math.max(range.length(), Precision.CURVE_PARAM_EPS);
+    const half = Math.max(Precision.CURVE_PARAM_EPS * 16, span * 1e-4 * scale);
+    const start = Math.max(range.start, u - half);
+    const end = Math.min(range.end, u + half);
+    if (end <= start + Precision.CURVE_PARAM_EPS) {
+        const clamped = range.clamp(u);
+        return new Interval(clamped, clamped);
+    }
+    return new Interval(start, end);
+}
+function sampleInterval3(x) {
+    if (x.end - x.start <= Precision.CURVE_PARAM_EPS) {
+        return [x.start];
+    }
+    return [x.start, 0.5 * (x.start + x.end), x.end];
+}
+function sampleInterval5(x) {
+    if (x.end - x.start <= Precision.CURVE_PARAM_EPS) {
+        return [x.start];
+    }
+    const a = x.start;
+    const b = x.end;
+    return [
+        a,
+        a + 0.25 * (b - a),
+        a + 0.5 * (b - a),
+        a + 0.75 * (b - a),
+        b,
+    ];
+}
+function maxTangentNorm(curve, x) {
+    const samples = sampleInterval3(x);
+    let ret = Precision.CURVE_NEWTON_EPS;
+    for (const u of samples) {
+        const n = curve.tangentAt(u).len();
+        if (Number.isFinite(n))
+            ret = Math.max(ret, n);
+    }
+    return ret;
+}
+function isNearDegenerate(c1, c2, u1, u2) {
+    const t1 = c1.tangentAt(u1);
+    const t2 = c2.tangentAt(u2);
+    const n1 = t1.len();
+    const n2 = t2.len();
+    if (n1 <= Precision.CURVE_NEWTON_EPS || n2 <= Precision.CURVE_NEWTON_EPS)
+        return true;
+    const sin = Math.abs(t1.cross(t2)) / (n1 * n2);
+    return sin <= 1e-3;
+}
+function shrinkWindowAroundParam(curve, window, center, factor) {
+    const range = curve.getRange();
+    const half = Math.max(Precision.CURVE_PARAM_EPS * 8, 0.5 * window.length() * factor);
+    const u = range.clamp(center);
+    const start = Math.max(range.start, u - half);
+    const end = Math.min(range.end, u + half);
+    if (end <= start + Precision.CURVE_PARAM_EPS) {
+        return new Interval(u, u);
+    }
+    return new Interval(start, end);
+}

package/dist/intersections/internal/interval_clipping.d.ts

@@ -0,0 +1,29 @@
+import { Interval } from '../../curves/interval';
+import type { Curve2 } from '../../curves/curve2';
+export type ClipPointSeed = {
+    u1: number;
+    u2: number;
+};
+export type ClipOverlapSeed = {
+    range1: Interval;
+    range2: Interval;
+};
+export type IntervalClipOptions = {
+    pointTol: number;
+    seedParamTol: number;
+    maxDepth: number;
+    maxNodes: number;
+    pointSeedLimit: number;
+    overlapSeedLimit: number;
+};
+export type IntervalClipDiagnostics = {
+    nodesVisited: number;
+    aborted: boolean;
+};
+export type IntervalClipResult = {
+    pointSeeds: ClipPointSeed[];
+    overlapSeeds: ClipOverlapSeed[];
+    diagnostics: IntervalClipDiagnostics;
+};
+export declare function collectIntervalClipSeeds(c1: Curve2, c2: Curve2, options: IntervalClipOptions): IntervalClipResult;
+//# sourceMappingURL=interval_clipping.d.ts.map

package/dist/intersections/internal/interval_clipping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval_clipping.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/interval_clipping.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAKjD,MAAM,MAAM,aAAa,GAAG;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC1B,MAAM,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,QAAQ,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,CAAA;IACtB,gBAAgB,EAAE,MAAM,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IAClC,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC7B,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,YAAY,EAAE,eAAe,EAAE,CAAA;IAC/B,WAAW,EAAE,uBAAuB,CAAA;CACvC,CAAA;AAOD,wBAAgB,wBAAwB,CACpC,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,mBAAmB,GAC7B,kBAAkB,CAoHpB"}

package/dist/intersections/internal/interval_clipping.js

@@ -0,0 +1,123 @@
+import { Interval } from '../../curves/interval';
+import { Precision } from '../../utils/precision';
+import { intersectSegments, lerp, makeSegment, segmentBoxesMayIntersect, segmentDistance } from './segment';
+export function collectIntervalClipSeeds(c1, c2, options) {
+    const r1 = c1.getRange();
+    const r2 = c2.getRange();
+    if (r1.length() <= Precision.CURVE_PARAM_EPS || r2.length() <= Precision.CURVE_PARAM_EPS) {
+        return {
+            pointSeeds: [],
+            overlapSeeds: [],
+            diagnostics: { nodesVisited: 0, aborted: false },
+        };
+    }
+    const pointSeeds = [];
+    const overlapSeeds = [];
+    const state = {
+        nodes: 0,
+        aborted: false,
+    };
+    const cache1 = new Map();
+    const cache2 = new Map();
+    const getPoint = (curve, cache, u) => {
+        const key = u.toPrecision(15);
+        const found = cache.get(key);
+        if (found)
+            return found;
+        const p = curve.pointAt(u);
+        cache.set(key, p);
+        return p;
+    };
+    const recurse = (u0, u1, v0, v1, depth) => {
+        if (state.aborted)
+            return;
+        if (state.nodes++ > options.maxNodes) {
+            state.aborted = true;
+            return;
+        }
+        if (u1 - u0 <= Precision.CURVE_PARAM_EPS && v1 - v0 <= Precision.CURVE_PARAM_EPS)
+            return;
+        const p10 = getPoint(c1, cache1, u0);
+        const p11 = getPoint(c1, cache1, u1);
+        const p20 = getPoint(c2, cache2, v0);
+        const p21 = getPoint(c2, cache2, v1);
+        const s1 = makeSegment(p10, p11);
+        const s2 = makeSegment(p20, p21);
+        if (!segmentBoxesMayIntersect(s1, s2, options.pointTol))
+            return;
+        const hit = intersectSegments(s1, s2);
+        if (hit.kind === 'point') {
+            addPointSeed(pointSeeds, lerp(u0, u1, hit.t1), lerp(v0, v1, hit.t2), options.seedParamTol, options.pointSeedLimit);
+        }
+        else if (hit.kind === 'overlap') {
+            addOverlapSeed(overlapSeeds, {
+                range1: new Interval(lerp(u0, u1, hit.t1s), lerp(u0, u1, hit.t1e)),
+                range2: new Interval(lerp(v0, v1, hit.t2s), lerp(v0, v1, hit.t2e)),
+            }, options.overlapSeedLimit);
+            addPointSeed(pointSeeds, 0.5 * (lerp(u0, u1, hit.t1s) + lerp(u0, u1, hit.t1e)), 0.5 * (lerp(v0, v1, hit.t2s) + lerp(v0, v1, hit.t2e)), options.seedParamTol, options.pointSeedLimit);
+        }
+        const dist = segmentDistance(s1, s2);
+        const uSpan = u1 - u0;
+        const vSpan = v1 - v0;
+        const paramTiny = uSpan <= Precision.CURVE_PARAM_EPS * 32 && vSpan <= Precision.CURVE_PARAM_EPS * 32;
+        const geomTiny = Math.max(s1.len, s2.len) <= options.pointTol * 1.25;
+        if (depth >= options.maxDepth || paramTiny || geomTiny) {
+            if (dist <= options.pointTol * 1.75) {
+                addPointSeed(pointSeeds, 0.5 * (u0 + u1), 0.5 * (v0 + v1), options.seedParamTol, options.pointSeedLimit);
+            }
+            return;
+        }
+        if (dist > Math.max(s1.len, s2.len) + options.pointTol * 3)
+            return;
+        const splitU = s1.len >= s2.len;
+        if (splitU) {
+            const um = 0.5 * (u0 + u1);
+            if (um <= u0 + Precision.CURVE_PARAM_EPS || um >= u1 - Precision.CURVE_PARAM_EPS)
+                return;
+            recurse(u0, um, v0, v1, depth + 1);
+            recurse(um, u1, v0, v1, depth + 1);
+            return;
+        }
+        const vm = 0.5 * (v0 + v1);
+        if (vm <= v0 + Precision.CURVE_PARAM_EPS || vm >= v1 - Precision.CURVE_PARAM_EPS)
+            return;
+        recurse(u0, u1, v0, vm, depth + 1);
+        recurse(u0, u1, vm, v1, depth + 1);
+    };
+    recurse(r1.start, r1.end, r2.start, r2.end, 0);
+    return {
+        pointSeeds,
+        overlapSeeds,
+        diagnostics: {
+            nodesVisited: state.nodes,
+            aborted: state.aborted,
+        },
+    };
+}
+function addPointSeed(seeds, u1, u2, paramTol, limit) {
+    if (limit > 0 && seeds.length >= limit)
+        return;
+    for (const seed of seeds) {
+        if (Math.abs(seed.u1 - u1) <= paramTol && Math.abs(seed.u2 - u2) <= paramTol) {
+            return;
+        }
+    }
+    seeds.push({ u1, u2 });
+}
+function addOverlapSeed(seeds, next, limit) {
+    for (let i = 0; i < seeds.length; i++) {
+        const cur = seeds[i];
+        const overlap1 = next.range1.intersect(cur.range1, Precision.CURVE_PARAM_EPS * 8);
+        const overlap2 = next.range2.intersect(cur.range2, Precision.CURVE_PARAM_EPS * 8);
+        if (overlap1.length === 0 || overlap2.length === 0)
+            continue;
+        seeds[i] = {
+            range1: new Interval(Math.min(cur.range1.start, next.range1.start), Math.max(cur.range1.end, next.range1.end)),
+            range2: new Interval(Math.min(cur.range2.start, next.range2.start), Math.max(cur.range2.end, next.range2.end)),
+        };
+        return;
+    }
+    if (limit > 0 && seeds.length >= limit)
+        return;
+    seeds.push(next);
+}

package/dist/intersections/internal/kind.d.ts

@@ -0,0 +1,4 @@
+import type { Curve2 } from '../../curves/curve2';
+import type { CurveKind } from './pair';
+export declare function getCurveKind(curve: Curve2): CurveKind;
+//# sourceMappingURL=kind.d.ts.map

package/dist/intersections/internal/kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kind.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/kind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAEvC,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAQrD"}

package/dist/intersections/internal/kind.js

@@ -0,0 +1,16 @@
+import { MathError } from '../../utils/math_error';
+export function getCurveKind(curve) {
+    if (curve.isLine())
+        return 'line';
+    if (curve.isCircle())
+        return 'circle';
+    if (curve.isArc())
+        return 'arc';
+    if (curve.isEllipse())
+        return 'ellipse';
+    if (curve.isEllipseArc())
+        return 'ellipseArc';
+    if (curve.isBSpline())
+        return 'bspline';
+    MathError.throw(`CurveX: unsupported curve type ${curve.getType()}`);
+}

package/dist/intersections/internal/pair.d.ts

@@ -0,0 +1,9 @@
+export type CurveKind = 'line' | 'circle' | 'arc' | 'ellipse' | 'ellipseArc' | 'bspline';
+export type PairKey = `${CurveKind}|${CurveKind}`;
+type PairNormalizeResult = {
+    key: PairKey;
+    swapped: boolean;
+};
+export declare function normalizePair(k1: CurveKind, k2: CurveKind): PairNormalizeResult;
+export {};
+//# sourceMappingURL=pair.d.ts.map

package/dist/intersections/internal/pair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pair.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/pair.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAA;AAExF,MAAM,MAAM,OAAO,GAAG,GAAG,SAAS,IAAI,SAAS,EAAE,CAAA;AAEjD,KAAK,mBAAmB,GAAG;IACvB,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,OAAO,CAAA;CACnB,CAAA;AAWD,wBAAgB,aAAa,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,GAAG,mBAAmB,CAK/E"}

package/dist/intersections/internal/pair.js

@@ -0,0 +1,14 @@
+const kindOrder = {
+    line: 0,
+    circle: 1,
+    arc: 2,
+    ellipse: 3,
+    ellipseArc: 4,
+    bspline: 5,
+};
+export function normalizePair(k1, k2) {
+    if (kindOrder[k1] <= kindOrder[k2]) {
+        return { key: `${k1}|${k2}`, swapped: false };
+    }
+    return { key: `${k2}|${k1}`, swapped: true };
+}

package/dist/intersections/internal/result.d.ts

@@ -0,0 +1,20 @@
+import { Interval } from '../../curves/interval';
+import type { CurveXInfo } from '../types';
+export type CurveXQuality = {
+    rawCount: number;
+    uniqueCount: number;
+    overlapCount: number;
+    uniquePointCount: number;
+    duplicatePointCount: number;
+};
+export declare function swapCurveXInfos(items: CurveXInfo[]): {
+    point: import("../..").Vec2;
+    u1: number;
+    u2: number;
+    isOverlap: boolean;
+    range1: Interval | undefined;
+    range2: Interval | undefined;
+}[];
+export declare function postprocessCurveXInfos(items: CurveXInfo[], pointTol?: number): CurveXInfo[];
+export declare function analyzeCurveXInfosQuality(items: CurveXInfo[], pointTol?: number): CurveXQuality;
+//# sourceMappingURL=result.d.ts.map

package/dist/intersections/internal/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/intersections/internal/result.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAEhD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,MAAM,MAAM,aAAa,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,MAAM,CAAA;IACnB,YAAY,EAAE,MAAM,CAAA;IACpB,gBAAgB,EAAE,MAAM,CAAA;IACxB,mBAAmB,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE;;;;;;;IASlD;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,QAAQ,SAAiC,gBAIpG;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE,QAAQ,SAAiC,GAAG,aAAa,CAmBvH"}