@ccpc/math 0.1.0 → 0.1.7

package/dist/intersections/solvers/pair_solvers.js

@@ -1,1078 +0,0 @@
-import { Vec2 } from '../../core/vec2';
-import { Interval } from '../../curves/interval';
-import { MathError } from '../../utils/math_error';
-import { Precision } from '../../utils/precision';
-import { collectIntervalClipSeeds } from '../internal/interval_clipping';
-import { curvePointTolerance } from '../internal/tolerance';
-import { LineLinePairSolver } from './line_line_pair_solver';
-import { PolylinePairIntersector } from './polyline_pair_intersector';
-function solveQuadratic(a, b, c) {
-    const eps = Precision.CURVE_NEWTON_EPS;
-    if (Math.abs(a) <= eps) {
-        if (Math.abs(b) <= eps)
-            return [];
-        return [-c / b];
-    }
-    const disc = b * b - 4 * a * c;
-    if (disc < -eps)
-        return [];
-    if (Math.abs(disc) <= eps)
-        return [-b / (2 * a)];
-    const sqrtDisc = Math.sqrt(Math.max(0, disc));
-    const q = -0.5 * (b + Math.sign(b || 1) * sqrtDisc);
-    const r1 = q / a;
-    const r2 = c / q;
-    return r1 <= r2 ? [r1, r2] : [r2, r1];
-}
-function assertLine(curve) {
-    MathError.assert(curve.isLine(), `Expected Line2, got ${curve.getType()}`);
-    return curve;
-}
-function assertCircle(curve) {
-    MathError.assert(curve.isCircle(), `Expected Circle2, got ${curve.getType()}`);
-    return curve;
-}
-function assertArc(curve) {
-    MathError.assert(curve.isArc(), `Expected Arc2, got ${curve.getType()}`);
-    return curve;
-}
-function assertEllipse(curve) {
-    MathError.assert(curve.isEllipse(), `Expected Ellipse2, got ${curve.getType()}`);
-    return curve;
-}
-function assertEllipseArc(curve) {
-    MathError.assert(curve.isEllipseArc(), `Expected EllipseArc2, got ${curve.getType()}`);
-    return curve;
-}
-function assertBSpline(curve) {
-    MathError.assert(curve.isBSpline(), `Expected BSpline2, got ${curve.getType()}`);
-    return curve;
-}
-function tryParamOnCurve(curve, point) {
-    const tol = curvePointTolerance(curve);
-    const cp = safeClosestPoint(curve, point, tol);
-    if (!cp)
-        return undefined;
-    if (cp.distance > tol * 16)
-        return undefined;
-    return curve.getRange().clamp(cp.param);
-}
-function safeClosestPoint(curve, point, tol) {
-    try {
-        return curve.closestPoint(point, tol);
-    }
-    catch {
-        PolylinePairIntersector.recordAnalyticClosestFallback();
-        return sampleClosestPoint(curve, point, 64);
-    }
-}
-function sampleClosestPoint(curve, point, sampleCount) {
-    const range = curve.getRange();
-    let bestParam = range.start;
-    let bestPoint = curve.pointAt(bestParam);
-    let bestDist = bestPoint.distanceTo(point);
-    const total = Math.max(8, sampleCount);
-    for (let i = 1; i <= total; i++) {
-        const t = i / total;
-        const u = range.start + (range.end - range.start) * t;
-        const q = curve.pointAt(u);
-        const d = q.distanceTo(point);
-        if (d < bestDist) {
-            bestDist = d;
-            bestParam = u;
-            bestPoint = q;
-        }
-    }
-    // Local Newton refinement around the best sampled parameter.
-    let u = bestParam;
-    for (let i = 0; i < 12; i++) {
-        const p = curve.pointAt(u);
-        const d1 = curve.derivativeAt(u, 1);
-        const d2 = curve.derivativeAt(u, 2);
-        const cp = p.subtracted(point);
-        const f = cp.dot(d1);
-        const fp = d1.dot(d1) + cp.dot(d2);
-        if (!Number.isFinite(f) || !Number.isFinite(fp) || Math.abs(fp) <= Precision.CURVE_NEWTON_EPS)
-            break;
-        const next = range.clamp(u - f / fp);
-        if (Math.abs(next - u) <= Precision.CURVE_PARAM_EPS * 4) {
-            u = next;
-            break;
-        }
-        u = next;
-    }
-    bestParam = u;
-    bestPoint = curve.pointAt(bestParam);
-    bestDist = bestPoint.distanceTo(point);
-    return {
-        point: bestPoint,
-        param: bestParam,
-        distance: bestDist,
-    };
-}
-function tryBuildPointInfo(c1, c2, point) {
-    const u1 = tryParamOnCurve(c1, point);
-    const u2 = tryParamOnCurve(c2, point);
-    if (u1 === undefined || u2 === undefined)
-        return undefined;
-    return {
-        point,
-        u1,
-        u2,
-        isOverlap: false,
-    };
-}
-function pushUniqueResult(items, candidate) {
-    if (!candidate)
-        return;
-    for (const item of items) {
-        if (Math.abs(item.u1 - candidate.u1) <= Precision.CURVE_PARAM_EPS * 8 &&
-            Math.abs(item.u2 - candidate.u2) <= Precision.CURVE_PARAM_EPS * 8 &&
-            item.isOverlap === candidate.isOverlap) {
-            return;
-        }
-    }
-    items.push(candidate);
-}
-function collectUniqueResults(candidates) {
-    const out = [];
-    for (const hit of candidates) {
-        pushUniqueResult(out, hit);
-    }
-    return out;
-}
-function lineCircleParamIntersections(line, center, radius) {
-    const p0 = line.start;
-    const p1 = line.end;
-    const v = p1.subtracted(p0);
-    const len = v.len();
-    if (len <= Precision.CURVE_LENGTH_EPS)
-        return [];
-    const d = v.scaled(1 / len);
-    const f = p0.subtracted(center);
-    const b = 2 * d.dot(f);
-    const c = f.lenSq() - radius * radius;
-    const roots = solveQuadratic(1, b, c);
-    const ret = [];
-    for (const s of roots) {
-        if (s < -Precision.CURVE_LENGTH_EPS || s > len + Precision.CURVE_LENGTH_EPS)
-            continue;
-        const uLine = Math.min(len, Math.max(0, s));
-        const point = p0.added(d.scaled(uLine));
-        ret.push({ point, uLine });
-    }
-    return ret;
-}
-function lineEllipseParamIntersections(line, ellipse) {
-    const p0 = line.start;
-    const p1 = line.end;
-    const v = p1.subtracted(p0);
-    const len = v.len();
-    if (len <= Precision.CURVE_LENGTH_EPS)
-        return [];
-    const d = v.scaled(1 / len);
-    const c = Math.cos(ellipse.rotation);
-    const s = Math.sin(ellipse.rotation);
-    const rel0 = p0.subtracted(ellipse.center);
-    const x0 = c * rel0.x + s * rel0.y;
-    const y0 = -s * rel0.x + c * rel0.y;
-    const dx = c * d.x + s * d.y;
-    const dy = -s * d.x + c * d.y;
-    const invRx2 = 1 / (ellipse.rx * ellipse.rx);
-    const invRy2 = 1 / (ellipse.ry * ellipse.ry);
-    const a = dx * dx * invRx2 + dy * dy * invRy2;
-    const b = 2 * (x0 * dx * invRx2 + y0 * dy * invRy2);
-    const cc = x0 * x0 * invRx2 + y0 * y0 * invRy2 - 1;
-    const roots = solveQuadratic(a, b, cc);
-    const ret = [];
-    for (const sLine of roots) {
-        if (sLine < -Precision.CURVE_LENGTH_EPS || sLine > len + Precision.CURVE_LENGTH_EPS)
-            continue;
-        const uLine = Math.min(len, Math.max(0, sLine));
-        const point = p0.added(d.scaled(uLine));
-        ret.push({ point, uLine });
-    }
-    return ret;
-}
-function clamp01(x) {
-    return Math.max(0, Math.min(1, x));
-}
-function linePointDistance(line, point) {
-    const dir = line.tangentAt(line.getRange().start);
-    const v = point.subtracted(line.start);
-    return Math.abs(v.cross(dir));
-}
-function splitByBreaks(curve) {
-    const range = curve.getRange();
-    const breaks = [range.start, ...curve.getContinuityBreakParams(Precision.CURVE_PARAM_EPS), range.end];
-    breaks.sort((a, b) => a - b);
-    const ret = [];
-    for (let i = 0; i < breaks.length - 1; i++) {
-        const u0 = breaks[i];
-        const u1 = breaks[i + 1];
-        if (u1 - u0 <= Precision.CURVE_PARAM_EPS * 4)
-            continue;
-        ret.push({ u0, u1 });
-    }
-    return ret;
-}
-function solveLineBSplineRoots(line, bspline) {
-    const lineStart = line.start;
-    const lineEnd = line.end;
-    const lineDir = lineEnd.subtracted(lineStart);
-    const lineLen = lineDir.len();
-    if (lineLen <= Precision.CURVE_LENGTH_EPS)
-        return [];
-    const lineUnit = lineDir.scaled(1 / lineLen);
-    // Signed distance to line support.
-    const f = (u) => bspline.pointAt(u).subtracted(lineStart).cross(lineUnit);
-    const df = (u) => bspline.derivativeAt(u, 1).cross(lineUnit);
-    const pointTol = curvePointTolerance(bspline) * 4;
-    const paramTol = Precision.CURVE_PARAM_EPS * 32;
-    const roots = [];
-    const intervals = splitByBreaks(bspline);
-    const tryPushRoot = (u) => {
-        const uu = bspline.getRange().clamp(u);
-        for (const r of roots) {
-            if (Math.abs(r - uu) <= paramTol)
-                return;
-        }
-        roots.push(uu);
-    };
-    for (const seg of intervals) {
-        const rootsOnSeg = solveScalarRootsOnInterval(f, df, seg.u0, seg.u1, {
-            valueTol: pointTol,
-            paramTol,
-            sampleCount: 64,
-        });
-        for (const u of rootsOnSeg) {
-            if (Math.abs(f(u)) <= pointTol * 2)
-                tryPushRoot(u);
-        }
-    }
-    roots.sort((a, b) => a - b);
-    const hits = [];
-    for (const uSpline of roots) {
-        const p = bspline.pointAt(uSpline);
-        const uLine = p.subtracted(lineStart).dot(lineUnit);
-        if (uLine < -pointTol || uLine > lineLen + pointTol)
-            continue;
-        if (linePointDistance(line, p) > pointTol * 3)
-            continue;
-        hits.push({
-            point: p,
-            u1: clamp01(uLine / lineLen) * lineLen,
-            u2: uSpline,
-            isOverlap: false,
-        });
-    }
-    return hits;
-}
-function solveScalarRootsOnInterval(f, df, u0, u1, options) {
-    const roots = [];
-    const samples = Math.max(8, options.sampleCount);
-    const du = (u1 - u0) / samples;
-    const pushRoot = (u) => {
-        const uu = Math.max(u0, Math.min(u1, u));
-        for (const r of roots) {
-            if (Math.abs(r - uu) <= options.paramTol)
-                return;
-        }
-        roots.push(uu);
-    };
-    const refineBracket = (a0, b0, fn, dfn) => {
-        let a = a0;
-        let b = b0;
-        let fa = fn(a);
-        let fb = fn(b);
-        let u = 0.5 * (a + b);
-        let fu = fn(u);
-        for (let it = 0; it < 32; it++) {
-            if (Math.abs(fu) <= options.valueTol || (b - a) <= options.paramTol)
-                return u;
-            const slope = dfn(u);
-            let next = Number.NaN;
-            if (Number.isFinite(slope) && Math.abs(slope) > Precision.CURVE_NEWTON_EPS) {
-                next = u - fu / slope;
-            }
-            if (!Number.isFinite(next) || next <= a || next >= b) {
-                next = 0.5 * (a + b);
-            }
-            const fnext = fn(next);
-            if (fa === 0 || fnext === 0 || fa * fnext <= 0) {
-                b = next;
-                fb = fnext;
-            }
-            else {
-                a = next;
-                fa = fnext;
-            }
-            if (Math.abs(fa) < Math.abs(fb)) {
-                u = a;
-                fu = fa;
-            }
-            else {
-                u = b;
-                fu = fb;
-            }
-        }
-        return u;
-    };
-    let prevU = u0;
-    let prevF = f(prevU);
-    let prevDf = df(prevU);
-    if (Math.abs(prevF) <= options.valueTol)
-        pushRoot(prevU);
-    for (let i = 1; i <= samples; i++) {
-        const curU = i === samples ? u1 : (u0 + du * i);
-        const curF = f(curU);
-        const curDf = df(curU);
-        if (Math.abs(curF) <= options.valueTol) {
-            pushRoot(curU);
-        }
-        if (prevF === 0 || curF === 0 || prevF * curF < 0) {
-            pushRoot(refineBracket(prevU, curU, f, df));
-        }
-        // Handle tangency: derivative changes sign but f does not.
-        if (prevDf === 0 || curDf === 0 || prevDf * curDf < 0) {
-            const uCritical = refineBracket(prevU, curU, df, () => 0);
-            if (Math.abs(f(uCritical)) <= options.valueTol * 2) {
-                pushRoot(uCritical);
-            }
-        }
-        prevU = curU;
-        prevF = curF;
-        prevDf = curDf;
-    }
-    roots.sort((a, b) => a - b);
-    return roots;
-}
-function probeImplicitInterval(f, u0, u1, baseSampleCount, valueTol) {
-    const probes = 24;
-    let signChanges = 0;
-    let nearZeroCount = 0;
-    let prev = f(u0);
-    for (let i = 1; i <= probes; i++) {
-        const t = i / probes;
-        const u = u0 + (u1 - u0) * t;
-        const cur = f(u);
-        if (Math.abs(cur) <= valueTol * 2) {
-            nearZeroCount++;
-        }
-        if (prev === 0 || cur === 0 || prev * cur < 0) {
-            signChanges++;
-        }
-        prev = cur;
-    }
-    const suggested = baseSampleCount + signChanges * 24 + nearZeroCount * 6;
-    return {
-        signChanges,
-        nearZeroCount,
-        sampleCount: Math.max(baseSampleCount, Math.min(320, suggested)),
-    };
-}
-function solveImplicitBSplineRoots(target, bspline, implicit, valueTolScale = 1) {
-    const pointTol = Math.max(curvePointTolerance(target), curvePointTolerance(bspline));
-    const paramTol = Precision.CURVE_PARAM_EPS * 32;
-    const valueTol = Math.max(pointTol * pointTol * 4, pointTol * valueTolScale * 4);
-    const targetProjectTol = pointTol * 8;
-    const range = bspline.getRange();
-    const intervals = splitByBreaks(bspline);
-    if (intervals.length === 0) {
-        intervals.push({ u0: range.start, u1: range.end });
-    }
-    const f = (u) => {
-        const p = bspline.pointAt(u);
-        return implicit(p).value;
-    };
-    const df = (u) => {
-        const p = bspline.pointAt(u);
-        const d1 = bspline.derivativeAt(u, 1);
-        const evalv = implicit(p);
-        return evalv.grad.dot(d1);
-    };
-    const allRoots = [];
-    const pushRootUnique = (roots, u) => {
-        let duplicate = false;
-        for (const r of roots) {
-            if (Math.abs(r - u) <= paramTol) {
-                duplicate = true;
-                break;
-            }
-        }
-        if (!duplicate)
-            roots.push(u);
-    };
-    for (const seg of intervals) {
-        const probe = probeImplicitInterval(f, seg.u0, seg.u1, 96, valueTol);
-        const roots = solveScalarRootsOnInterval(f, df, seg.u0, seg.u1, {
-            valueTol,
-            paramTol,
-            sampleCount: probe.sampleCount,
-        });
-        for (const u of roots)
-            pushRootUnique(allRoots, u);
-        // Second pass for oscillatory / near-tangent intervals:
-        // increase sampling density and merge extra roots.
-        if (probe.signChanges >= 2 || probe.nearZeroCount >= 2) {
-            const denseRoots = solveScalarRootsOnInterval(f, df, seg.u0, seg.u1, {
-                valueTol,
-                paramTol,
-                sampleCount: Math.min(640, probe.sampleCount * 2),
-            });
-            for (const u of denseRoots)
-                pushRootUnique(allRoots, u);
-        }
-    }
-    // Global dense isolation for missed tangent / close multi-roots.
-    const globalDenseRoots = isolateRootsByDenseSampling(f, df, range.start, range.end, valueTol, paramTol);
-    for (const u of globalDenseRoots) {
-        pushRootUnique(allRoots, u);
-    }
-    allRoots.sort((a, b) => a - b);
-    const out = [];
-    for (const uSpline of allRoots) {
-        const p = bspline.pointAt(uSpline);
-        const ev = implicit(p);
-        if (Math.abs(ev.value) > valueTol * 4)
-            continue;
-        const cpTarget = safeClosestPoint(target, p, targetProjectTol);
-        if (!cpTarget || cpTarget.distance > targetProjectTol * 2)
-            continue;
-        out.push({
-            point: p,
-            u1: target.getRange().clamp(cpTarget.param),
-            u2: uSpline,
-            isOverlap: false,
-        });
-    }
-    return out;
-}
-function isolateRootsByDenseSampling(f, df, u0, u1, valueTol, paramTol) {
-    const samples = 2048;
-    const us = new Array(samples + 1);
-    const fs = new Array(samples + 1);
-    for (let i = 0; i <= samples; i++) {
-        const t = i / samples;
-        const u = u0 + (u1 - u0) * t;
-        us[i] = u;
-        fs[i] = f(u);
-    }
-    const roots = [];
-    const pushRoot = (u) => {
-        for (const r of roots) {
-            if (Math.abs(r - u) <= paramTol)
-                return;
-        }
-        roots.push(u);
-    };
-    const bisect = (a0, b0) => {
-        let a = a0;
-        let b = b0;
-        let fa = f(a);
-        let fb = f(b);
-        if (Math.abs(fa) <= valueTol)
-            return a;
-        if (Math.abs(fb) <= valueTol)
-            return b;
-        if (fa * fb > 0)
-            return 0.5 * (a + b);
-        for (let it = 0; it < 48; it++) {
-            const m = 0.5 * (a + b);
-            const fm = f(m);
-            if (Math.abs(fm) <= valueTol || (b - a) <= paramTol)
-                return m;
-            if (fa * fm <= 0) {
-                b = m;
-                fb = fm;
-            }
-            else {
-                a = m;
-                fa = fm;
-            }
-        }
-        return 0.5 * (a + b);
-    };
-    const refineLocal = (a0, b0, seed) => {
-        let a = a0;
-        let b = b0;
-        let u = Math.max(a, Math.min(b, seed));
-        let fu = f(u);
-        for (let it = 0; it < 32; it++) {
-            if (Math.abs(fu) <= valueTol || (b - a) <= paramTol)
-                return u;
-            const slope = df(u);
-            let next = Number.NaN;
-            if (Number.isFinite(slope) && Math.abs(slope) > Precision.CURVE_NEWTON_EPS) {
-                next = u - fu / slope;
-            }
-            if (!Number.isFinite(next) || next <= a || next >= b) {
-                next = 0.5 * (a + b);
-            }
-            const fn = f(next);
-            if (f(a) * fn <= 0) {
-                b = next;
-            }
-            else {
-                a = next;
-            }
-            u = next;
-            fu = fn;
-        }
-        return u;
-    };
-    for (let i = 1; i <= samples; i++) {
-        const a = us[i - 1];
-        const b = us[i];
-        const fa = fs[i - 1];
-        const fb = fs[i];
-        if (Math.abs(fa) <= valueTol)
-            pushRoot(a);
-        if (Math.abs(fb) <= valueTol)
-            pushRoot(b);
-        if (fa === 0 || fb === 0 || fa * fb < 0) {
-            pushRoot(bisect(a, b));
-        }
-    }
-    // same-sign tangent / near-touch roots
-    for (let i = 1; i < samples; i++) {
-        const f0 = fs[i - 1];
-        const f1 = fs[i];
-        const f2 = fs[i + 1];
-        if (Math.sign(f0) === Math.sign(f2) && Math.abs(f1) <= Math.min(Math.abs(f0), Math.abs(f2)) && Math.abs(f1) <= valueTol * 4) {
-            const a = us[i - 1];
-            const b = us[i + 1];
-            pushRoot(refineLocal(a, b, us[i]));
-        }
-    }
-    roots.sort((a, b) => a - b);
-    return roots;
-}
-function normalizeClosedParam(curve, u) {
-    const range = curve.getRange();
-    const clamped = range.clamp(u);
-    if (!curve.isClosed())
-        return clamped;
-    const len = range.length();
-    if (len <= Precision.CURVE_PARAM_EPS)
-        return clamped;
-    if (Math.abs(clamped - range.end) <= Precision.CURVE_PARAM_EPS * 16)
-        return range.start;
-    return clamped;
-}
-function solveParametricImplicitRoots(paramCurve, target, implicit, valueTolScale = 1) {
-    const pointTol = Math.max(curvePointTolerance(paramCurve), curvePointTolerance(target));
-    const paramTol = Precision.CURVE_PARAM_EPS * 32;
-    const valueTol = Math.max(pointTol * pointTol * 4, pointTol * valueTolScale * 4);
-    const targetProjectTol = Math.max(pointTol * 128, valueTolScale * 1e-5, Precision.CURVE_LENGTH_EPS * 32);
-    const range = paramCurve.getRange();
-    const f = (u) => {
-        const p = paramCurve.pointAt(u);
-        return implicit(p).value;
-    };
-    const df = (u) => {
-        const p = paramCurve.pointAt(u);
-        const d1 = paramCurve.derivativeAt(u, 1);
-        const evalv = implicit(p);
-        return evalv.grad.dot(d1);
-    };
-    const roots = isolateRootsByDenseSampling(f, df, range.start, range.end, valueTol, paramTol);
-    const out = [];
-    for (const uCircle of roots) {
-        const uu = normalizeClosedParam(paramCurve, uCircle);
-        const p = paramCurve.pointAt(uu);
-        const ev = implicit(p);
-        if (Math.abs(ev.value) > valueTol * 8)
-            continue;
-        const cpTarget = safeClosestPoint(target, p, targetProjectTol);
-        if (!cpTarget || cpTarget.distance > targetProjectTol * 4)
-            continue;
-        pushUniqueResult(out, {
-            point: p,
-            u1: uu,
-            u2: normalizeClosedParam(target, cpTarget.param),
-            isOverlap: false,
-        });
-    }
-    return out;
-}
-function swapPairResults(items) {
-    return items.map((item) => ({
-        point: item.point,
-        u1: item.u2,
-        u2: item.u1,
-        isOverlap: item.isOverlap,
-        range1: item.range2,
-        range2: item.range1,
-    }));
-}
-function solveMutualParametricImplicitRoots(c1, c2, implicitOfC1, implicitOfC2, scale1, scale2) {
-    const forward = solveParametricImplicitRoots(c1, c2, implicitOfC2, scale2);
-    const reverse = swapPairResults(solveParametricImplicitRoots(c2, c1, implicitOfC1, scale1));
-    return collectUniqueResults([...forward, ...reverse]);
-}
-function intersectImplicitBSplinePair(target, bspline, implicit, valueTolScale = 1) {
-    return collectUniqueResults(solveImplicitBSplineRoots(target, bspline, implicit, valueTolScale));
-}
-function refineCurvePairNewton(c1, c2, u1Seed, u2Seed, pointTol) {
-    const r1 = c1.getRange();
-    const r2 = c2.getRange();
-    let u1 = r1.clamp(u1Seed);
-    let u2 = r2.clamp(u2Seed);
-    let best = measurePair(c1, c2, u1, u2);
-    for (let i = 0; i < 24; i++) {
-        const p1 = c1.pointAt(u1);
-        const p2 = c2.pointAt(u2);
-        const diff = p1.subtracted(p2);
-        if (diff.len() <= pointTol)
-            return measurePair(c1, c2, u1, u2);
-        const t1 = c1.derivativeAt(u1, 1);
-        const t2 = c2.derivativeAt(u2, 1);
-        const det = t1.cross(t2);
-        if (Math.abs(det) <= Precision.CURVE_NEWTON_EPS)
-            break;
-        const bx = -diff.x;
-        const by = -diff.y;
-        let du = (bx * (-t2.y) - by * (-t2.x)) / det;
-        let dv = (t1.x * by - t1.y * bx) / det;
-        if (!Number.isFinite(du) || !Number.isFinite(dv))
-            break;
-        const nextU1 = r1.clamp(u1 + du);
-        const nextU2 = r2.clamp(u2 + dv);
-        const cand = measurePair(c1, c2, nextU1, nextU2);
-        if (cand.residual < best.residual)
-            best = cand;
-        const delta = Math.abs(nextU1 - u1) + Math.abs(nextU2 - u2);
-        u1 = nextU1;
-        u2 = nextU2;
-        if (delta <= Precision.CURVE_PARAM_EPS * 8)
-            break;
-    }
-    if (best.residual > pointTol * 4)
-        return undefined;
-    return best;
-}
-function measurePair(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 seedFromClosestPass(c1, c2, pointTol) {
-    const seeds = [];
-    const push = (u1, u2) => {
-        for (const s of seeds) {
-            if (Math.abs(s.u1 - u1) <= Precision.CURVE_PARAM_EPS * 16 && Math.abs(s.u2 - u2) <= Precision.CURVE_PARAM_EPS * 16) {
-                return;
-            }
-        }
-        seeds.push({ u1, u2 });
-    };
-    const r1 = c1.getRange();
-    const r2 = c2.getRange();
-    const samples = 80;
-    for (let i = 0; i <= samples; i++) {
-        const u1 = r1.start + (r1.end - r1.start) * (i / samples);
-        const p1 = c1.pointAt(u1);
-        const cp2 = safeClosestPoint(c2, p1, pointTol * 2);
-        if (!cp2 || cp2.distance > pointTol * 2)
-            continue;
-        push(u1, r2.clamp(cp2.param));
-    }
-    for (let i = 0; i <= samples; i++) {
-        const u2 = r2.start + (r2.end - r2.start) * (i / samples);
-        const p2 = c2.pointAt(u2);
-        const cp1 = safeClosestPoint(c1, p2, pointTol * 2);
-        if (!cp1 || cp1.distance > pointTol * 2)
-            continue;
-        push(r1.clamp(cp1.param), u2);
-    }
-    return seeds;
-}
-function solveBSplineBSplineRoots(c1, c2) {
-    const pointTol = Math.max(curvePointTolerance(c1), curvePointTolerance(c2));
-    const clip = collectIntervalClipSeeds(c1, c2, {
-        pointTol,
-        seedParamTol: Precision.CURVE_PARAM_EPS * 16,
-        maxDepth: 16,
-        maxNodes: 12000,
-        pointSeedLimit: 2048,
-        overlapSeedLimit: 128,
-    });
-    const seeds = [];
-    const pushSeed = (u1, u2) => {
-        for (const s of seeds) {
-            if (Math.abs(s.u1 - u1) <= Precision.CURVE_PARAM_EPS * 16 && Math.abs(s.u2 - u2) <= Precision.CURVE_PARAM_EPS * 16) {
-                return;
-            }
-        }
-        seeds.push({ u1, u2 });
-    };
-    for (const s of clip.pointSeeds) {
-        pushSeed(s.u1, s.u2);
-    }
-    for (const o of clip.overlapSeeds) {
-        pushSeed(0.5 * (o.range1.start + o.range1.end), 0.5 * (o.range2.start + o.range2.end));
-    }
-    if (seeds.length < 8) {
-        for (const s of seedFromClosestPass(c1, c2, pointTol)) {
-            pushSeed(s.u1, s.u2);
-        }
-    }
-    const out = [];
-    for (const seed of seeds) {
-        const refined = refineCurvePairNewton(c1, c2, seed.u1, seed.u2, pointTol);
-        if (!refined)
-            continue;
-        pushUniqueResult(out, {
-            point: refined.point,
-            u1: refined.u1,
-            u2: refined.u2,
-            isOverlap: false,
-        });
-    }
-    return out;
-}
-function circleImplicit(circle) {
-    return (p) => {
-        const dx = p.x - circle.center.x;
-        const dy = p.y - circle.center.y;
-        return {
-            value: dx * dx + dy * dy - circle.radius * circle.radius,
-            grad: new Vec2(2 * dx, 2 * dy),
-        };
-    };
-}
-function ellipseImplicit(ellipse) {
-    const c = Math.cos(ellipse.rotation);
-    const s = Math.sin(ellipse.rotation);
-    const invRx2 = 1 / (ellipse.rx * ellipse.rx);
-    const invRy2 = 1 / (ellipse.ry * ellipse.ry);
-    return (p) => {
-        const dx = p.x - ellipse.center.x;
-        const dy = p.y - ellipse.center.y;
-        const x = c * dx + s * dy;
-        const y = -s * dx + c * dy;
-        const value = x * x * invRx2 + y * y * invRy2 - 1;
-        // grad_world = R * [2x/rx^2, 2y/ry^2]
-        const gxLocal = 2 * x * invRx2;
-        const gyLocal = 2 * y * invRy2;
-        const gx = c * gxLocal - s * gyLocal;
-        const gy = s * gxLocal + c * gyLocal;
-        return {
-            value,
-            grad: new Vec2(gx, gy),
-        };
-    };
-}
-function circleCircleIntersections(c1Center, c1Radius, c2Center, c2Radius) {
-    const delta = c2Center.subtracted(c1Center);
-    const d = delta.len();
-    const eps = Precision.CURVE_LENGTH_EPS;
-    if (d <= eps && Math.abs(c1Radius - c2Radius) <= eps) {
-        return { kind: 'overlap' };
-    }
-    if (d <= eps)
-        return { kind: 'none' };
-    if (d > c1Radius + c2Radius + eps)
-        return { kind: 'none' };
-    if (d < Math.abs(c1Radius - c2Radius) - eps)
-        return { kind: 'none' };
-    const a = (c1Radius * c1Radius - c2Radius * c2Radius + d * d) / (2 * d);
-    const h2 = c1Radius * c1Radius - a * a;
-    if (h2 < -eps)
-        return { kind: 'none' };
-    const base = c1Center.added(delta.scaled(a / d));
-    if (Math.abs(h2) <= eps)
-        return { kind: 'points', points: [base] };
-    const h = Math.sqrt(Math.max(0, h2));
-    const offset = new Vec2(-delta.y / d, delta.x / d).scale(h);
-    return {
-        kind: 'points',
-        points: [base.added(offset), base.subtracted(offset)],
-    };
-}
-function isSameSupportCircle(a, b) {
-    return a.center.distanceTo(b.center) <= Precision.CURVE_LENGTH_EPS &&
-        Math.abs(a.radius - b.radius) <= Precision.CURVE_LENGTH_EPS;
-}
-function createOverlapInfo(c1, c2, point, range1, range2) {
-    const u1 = tryParamOnCurve(c1, point);
-    const u2 = tryParamOnCurve(c2, point);
-    if (u1 === undefined || u2 === undefined)
-        return undefined;
-    return {
-        point,
-        u1,
-        u2,
-        isOverlap: true,
-        range1,
-        range2,
-    };
-}
-function sampleRangeContains(curve, other, sampleCount) {
-    const range = curve.getRange();
-    let hit = 0;
-    let representative;
-    for (let i = 0; i <= sampleCount; i++) {
-        const t = i / sampleCount;
-        const u = range.start + (range.end - range.start) * t;
-        const p = curve.pointAt(u);
-        const uOther = tryParamOnCurve(other, p);
-        if (uOther === undefined)
-            continue;
-        hit++;
-        representative = p;
-    }
-    return { hit, representative };
-}
-function estimateOverlapRange(base, other, sampleCount) {
-    const range = base.getRange();
-    let start;
-    let end;
-    for (let i = 0; i <= sampleCount; i++) {
-        const t = i / sampleCount;
-        const u = range.start + (range.end - range.start) * t;
-        const p = base.pointAt(u);
-        if (tryParamOnCurve(other, p) === undefined)
-            continue;
-        if (start === undefined)
-            start = u;
-        end = u;
-    }
-    if (start === undefined || end === undefined)
-        return undefined;
-    if (Math.abs(end - start) <= Precision.CURVE_PARAM_EPS * 8)
-        return undefined;
-    return new Interval(start, end);
-}
-function buildLineCandidatesResults(line, target, candidates) {
-    const out = [];
-    for (const c of candidates) {
-        const uTarget = tryParamOnCurve(target, c.point);
-        if (uTarget === undefined)
-            continue;
-        pushUniqueResult(out, {
-            point: c.point,
-            u1: c.uLine,
-            u2: uTarget,
-            isOverlap: false,
-        });
-    }
-    return out;
-}
-class ParametricImplicitPairSolver {
-    intersect(c1, c2) {
-        const param = this.asParam(c1);
-        const target = this.asTarget(c2);
-        return collectUniqueResults(solveParametricImplicitRoots(param, target, this.makeImplicit(target), this.valueTolScale(target)));
-    }
-}
-export class LineCirclePairSolver {
-    intersect(c1, c2) {
-        const line = assertLine(c1);
-        const circle = assertCircle(c2);
-        return buildLineCandidatesResults(line, circle, lineCircleParamIntersections(line, circle.center, circle.radius));
-    }
-}
-export class LineArcPairSolver {
-    intersect(c1, c2) {
-        const line = assertLine(c1);
-        const arc = assertArc(c2);
-        return buildLineCandidatesResults(line, arc, lineCircleParamIntersections(line, arc.center, arc.radius));
-    }
-}
-export class LineEllipsePairSolver {
-    intersect(c1, c2) {
-        const line = assertLine(c1);
-        const ellipse = assertEllipse(c2);
-        return buildLineCandidatesResults(line, ellipse, lineEllipseParamIntersections(line, ellipse));
-    }
-}
-export class LineEllipseArcPairSolver {
-    intersect(c1, c2) {
-        const line = assertLine(c1);
-        const ellipseArc = assertEllipseArc(c2);
-        return buildLineCandidatesResults(line, ellipseArc, lineEllipseParamIntersections(line, ellipseArc));
-    }
-}
-export class LineBSplinePairSolver {
-    intersect(c1, c2) {
-        const line = assertLine(c1);
-        const bspline = assertBSpline(c2);
-        return collectUniqueResults(solveLineBSplineRoots(line, bspline));
-    }
-}
-export class CircleCirclePairSolver {
-    intersect(c1, c2) {
-        const circle1 = assertCircle(c1);
-        const circle2 = assertCircle(c2);
-        const hit = circleCircleIntersections(circle1.center, circle1.radius, circle2.center, circle2.radius);
-        if (hit.kind === 'none')
-            return [];
-        if (hit.kind === 'overlap') {
-            const p = circle1.pointAt(circle1.getRange().start);
-            const overlap = createOverlapInfo(circle1, circle2, p, circle1.getRange(), circle2.getRange());
-            return overlap ? [overlap] : [];
-        }
-        const out = [];
-        for (const p of hit.points) {
-            pushUniqueResult(out, tryBuildPointInfo(circle1, circle2, p));
-        }
-        return out;
-    }
-}
-export class CircleArcPairSolver {
-    intersect(c1, c2) {
-        const circle = assertCircle(c1);
-        const arc = assertArc(c2);
-        if (isSameSupportCircle(circle, arc)) {
-            const p = arc.pointAt(arc.getRange().start);
-            const uStart = tryParamOnCurve(circle, arc.pointAt(arc.getRange().start));
-            const uEnd = tryParamOnCurve(circle, arc.pointAt(arc.getRange().end));
-            const range1 = (uStart !== undefined && uEnd !== undefined)
-                ? new Interval(uStart, uEnd)
-                : undefined;
-            const overlap = createOverlapInfo(circle, arc, p, range1, arc.getRange());
-            return overlap ? [overlap] : [];
-        }
-        const hit = circleCircleIntersections(circle.center, circle.radius, arc.center, arc.radius);
-        if (hit.kind !== 'points')
-            return [];
-        const out = [];
-        for (const p of hit.points) {
-            const uArc = tryParamOnCurve(arc, p);
-            if (uArc === undefined)
-                continue;
-            pushUniqueResult(out, tryBuildPointInfo(circle, arc, p));
-        }
-        return out;
-    }
-}
-export class CircleEllipsePairSolver extends ParametricImplicitPairSolver {
-    asParam(curve) { return assertCircle(curve); }
-    asTarget(curve) { return assertEllipse(curve); }
-    makeImplicit(target) { return ellipseImplicit(target); }
-    valueTolScale(target) { return Math.max(target.rx, target.ry); }
-}
-export class CircleEllipseArcPairSolver extends ParametricImplicitPairSolver {
-    asParam(curve) { return assertCircle(curve); }
-    asTarget(curve) { return assertEllipseArc(curve); }
-    makeImplicit(target) { return ellipseImplicit(target); }
-    valueTolScale(target) { return Math.max(target.rx, target.ry); }
-}
-export class CircleBSplinePairSolver {
-    intersect(c1, c2) {
-        const circle = assertCircle(c1);
-        const bspline = assertBSpline(c2);
-        return intersectImplicitBSplinePair(circle, bspline, circleImplicit(circle), circle.radius);
-    }
-}
-export class ArcArcPairSolver {
-    intersect(c1, c2) {
-        const arc1 = assertArc(c1);
-        const arc2 = assertArc(c2);
-        if (isSameSupportCircle(arc1, arc2)) {
-            const sample1 = sampleRangeContains(arc1, arc2, 64);
-            const sample2 = sampleRangeContains(arc2, arc1, 64);
-            const sharedCount = Math.max(sample1.hit, sample2.hit);
-            if (sharedCount >= 3) {
-                const p = sample1.representative ?? sample2.representative ?? arc1.pointAt(arc1.getRange().start);
-                const range1 = estimateOverlapRange(arc1, arc2, 128);
-                const range2 = estimateOverlapRange(arc2, arc1, 128);
-                const overlap = createOverlapInfo(arc1, arc2, p, range1, range2);
-                if (overlap)
-                    return [overlap];
-            }
-            const out = [];
-            const endpoints = [
-                arc1.pointAt(arc1.getRange().start),
-                arc1.pointAt(arc1.getRange().end),
-                arc2.pointAt(arc2.getRange().start),
-                arc2.pointAt(arc2.getRange().end),
-            ];
-            for (const p of endpoints) {
-                if (tryParamOnCurve(arc1, p) === undefined || tryParamOnCurve(arc2, p) === undefined)
-                    continue;
-                pushUniqueResult(out, tryBuildPointInfo(arc1, arc2, p));
-            }
-            return out;
-        }
-        const hit = circleCircleIntersections(arc1.center, arc1.radius, arc2.center, arc2.radius);
-        if (hit.kind !== 'points')
-            return [];
-        const out = [];
-        for (const p of hit.points) {
-            if (tryParamOnCurve(arc1, p) === undefined || tryParamOnCurve(arc2, p) === undefined)
-                continue;
-            pushUniqueResult(out, tryBuildPointInfo(arc1, arc2, p));
-        }
-        return out;
-    }
-}
-export class ArcEllipsePairSolver extends ParametricImplicitPairSolver {
-    asParam(curve) { return assertArc(curve); }
-    asTarget(curve) { return assertEllipse(curve); }
-    makeImplicit(target) { return ellipseImplicit(target); }
-    valueTolScale(target) { return Math.max(target.rx, target.ry); }
-}
-export class ArcEllipseArcPairSolver extends ParametricImplicitPairSolver {
-    asParam(curve) { return assertArc(curve); }
-    asTarget(curve) { return assertEllipseArc(curve); }
-    makeImplicit(target) { return ellipseImplicit(target); }
-    valueTolScale(target) { return Math.max(target.rx, target.ry); }
-}
-export class ArcBSplinePairSolver {
-    intersect(c1, c2) {
-        const arc = assertArc(c1);
-        const bspline = assertBSpline(c2);
-        return intersectImplicitBSplinePair(arc, bspline, circleImplicit(arc), arc.radius);
-    }
-}
-export class EllipseEllipsePairSolver {
-    intersect(c1, c2) {
-        const e1 = assertEllipse(c1);
-        const e2 = assertEllipse(c2);
-        return solveMutualParametricImplicitRoots(e1, e2, ellipseImplicit(e1), ellipseImplicit(e2), Math.max(e1.rx, e1.ry), Math.max(e2.rx, e2.ry));
-    }
-}
-export class EllipseEllipseArcPairSolver {
-    intersect(c1, c2) {
-        const ellipse = assertEllipse(c1);
-        const ellipseArc = assertEllipseArc(c2);
-        return collectUniqueResults(solveParametricImplicitRoots(ellipse, ellipseArc, ellipseImplicit(ellipseArc), Math.max(ellipseArc.rx, ellipseArc.ry)));
-    }
-}
-export class EllipseBSplinePairSolver {
-    intersect(c1, c2) {
-        const ellipse = assertEllipse(c1);
-        const bspline = assertBSpline(c2);
-        return intersectImplicitBSplinePair(ellipse, bspline, ellipseImplicit(ellipse), Math.max(ellipse.rx, ellipse.ry));
-    }
-}
-export class EllipseArcEllipseArcPairSolver {
-    intersect(c1, c2) {
-        const arc1 = assertEllipseArc(c1);
-        const arc2 = assertEllipseArc(c2);
-        return solveMutualParametricImplicitRoots(arc1, arc2, ellipseImplicit(arc1), ellipseImplicit(arc2), Math.max(arc1.rx, arc1.ry), Math.max(arc2.rx, arc2.ry));
-    }
-}
-export class EllipseArcBSplinePairSolver {
-    intersect(c1, c2) {
-        const ellipseArc = assertEllipseArc(c1);
-        const bspline = assertBSpline(c2);
-        return intersectImplicitBSplinePair(ellipseArc, bspline, ellipseImplicit(ellipseArc), Math.max(ellipseArc.rx, ellipseArc.ry));
-    }
-}
-export class BSplineBSplinePairSolver {
-    intersect(c1, c2) {
-        const bs1 = assertBSpline(c1);
-        const bs2 = assertBSpline(c2);
-        return solveBSplineBSplineRoots(bs1, bs2);
-    }
-}
-export { LineLinePairSolver };