@faicad/faijs 0.13.0

package/dist/vendored/brepjs/kernel/geometry2d.js

@@ -0,0 +1,885 @@
+/* v8 ignore file -- excluded from coverage reports; prevents V8 instrumentation
+   overhead that causes 2D-heavy tests to timeout under coverage mode. */
+/**
+ * Pure-TypeScript 2D geometry implementation for Kernel2DCapability.
+ *
+ * All 2D curves are represented as plain objects with a `type` discriminant
+ * and `evaluate(t)` method. No WASM boundary crossing required.
+ *
+ * ADR-0006: Inline math here (distance, rotation, normalization, dot/cross
+ * products) operates on curve struct fields, not Point2D tuples. The canonical
+ * tuple-based functions live in src/utils/vec2d.ts. The struct-field patterns
+ * are not worth converting to tuple form — the temporary array allocations
+ * would degrade both readability and performance.
+ *
+ * @module
+ */
+// ---------------------------------------------------------------------------
+// Evaluation
+// ---------------------------------------------------------------------------
+export function evaluateCurve2d(c, t) {
+    switch (c.__bk2d) {
+        case 'line':
+            return [c.ox + c.dx * t, c.oy + c.dy * t];
+        case 'circle': {
+            const angle = c.sense ? t : -t;
+            return [c.cx + c.radius * Math.cos(angle), c.cy + c.radius * Math.sin(angle)];
+        }
+        case 'ellipse': {
+            const angle = c.sense ? t : -t;
+            const cos = Math.cos(c.xDirAngle);
+            const sin = Math.sin(c.xDirAngle);
+            const x = c.majorRadius * Math.cos(angle);
+            const y = c.minorRadius * Math.sin(angle);
+            return [c.cx + x * cos - y * sin, c.cy + x * sin + y * cos];
+        }
+        case 'bezier':
+            return evaluateBezier(c.poles, t);
+        case 'bspline':
+            return evaluateBSpline2d(c, t);
+        case 'trimmed': {
+            const mapped = c.tStart + t * (c.tEnd - c.tStart);
+            return evaluateCurve2d(c.basis, mapped);
+        }
+    }
+}
+export function tangentCurve2d(c, t) {
+    switch (c.__bk2d) {
+        case 'line':
+            return [c.dx, c.dy];
+        case 'circle': {
+            const angle = c.sense ? t : -t;
+            const sign = c.sense ? 1 : -1;
+            return [-c.radius * Math.sin(angle) * sign, c.radius * Math.cos(angle) * sign];
+        }
+        case 'ellipse': {
+            const angle = c.sense ? t : -t;
+            const sign = c.sense ? 1 : -1;
+            const cos = Math.cos(c.xDirAngle);
+            const sin = Math.sin(c.xDirAngle);
+            const dx = -c.majorRadius * Math.sin(angle) * sign;
+            const dy = c.minorRadius * Math.cos(angle) * sign;
+            return [dx * cos - dy * sin, dx * sin + dy * cos];
+        }
+        case 'bezier': {
+            // Numerical differentiation
+            const h = 1e-8;
+            const p0 = evaluateBezier(c.poles, Math.max(0, t - h));
+            const p1 = evaluateBezier(c.poles, Math.min(1, t + h));
+            const dt = Math.min(1, t + h) - Math.max(0, t - h);
+            return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
+        }
+        case 'bspline': {
+            const h = 1e-8;
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- known-valid
+            const kFirst = c.knots[0];
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- known-valid
+            const kLast = c.knots[c.knots.length - 1];
+            const p0 = evaluateBSpline2d(c, Math.max(kFirst, t - h));
+            const p1 = evaluateBSpline2d(c, Math.min(kLast, t + h));
+            const dt = Math.min(kLast, t + h) - Math.max(kFirst, t - h);
+            return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
+        }
+        case 'trimmed': {
+            const mapped = c.tStart + t * (c.tEnd - c.tStart);
+            const tan = tangentCurve2d(c.basis, mapped);
+            const scale = c.tEnd - c.tStart;
+            return [tan[0] * scale, tan[1] * scale];
+        }
+    }
+}
+export function curveBounds(c) {
+    switch (c.__bk2d) {
+        case 'line':
+            return { first: 0, last: c.len };
+        case 'circle':
+        case 'ellipse':
+            return { first: 0, last: 2 * Math.PI };
+        case 'bezier':
+            return { first: 0, last: 1 };
+        case 'bspline':
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- known-valid
+            return { first: c.knots[0], last: c.knots[c.knots.length - 1] };
+        case 'trimmed':
+            return { first: 0, last: 1 };
+    }
+}
+export function curveTypeName(c) {
+    switch (c.__bk2d) {
+        case 'line':
+            return 'LINE';
+        case 'circle':
+            return 'CIRCLE';
+        case 'ellipse':
+            return 'ELLIPSE';
+        case 'bezier':
+            return 'BEZIER_CURVE';
+        case 'bspline':
+            return 'BSPLINE_CURVE';
+        case 'trimmed':
+            return 'TRIMMED_' + curveTypeName(c.basis);
+    }
+}
+// ---------------------------------------------------------------------------
+// Construction helpers
+// ---------------------------------------------------------------------------
+export function makeLine2d(x1, y1, x2, y2) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    const len = Math.sqrt(dx * dx + dy * dy);
+    return {
+        __bk2d: 'line',
+        ox: x1,
+        oy: y1,
+        dx: len > 0 ? dx / len : 1,
+        dy: len > 0 ? dy / len : 0,
+        len,
+    };
+}
+export function makeCircle2d(cx, cy, radius, sense = true) {
+    return { __bk2d: 'circle', cx, cy, radius, sense };
+}
+export function makeArc2dThreePoints(x1, y1, xm, ym, x2, y2) {
+    // Circumscribed circle through 3 points
+    const d = 2 * (x1 * (ym - y2) + xm * (y2 - y1) + x2 * (y1 - ym));
+    if (Math.abs(d) < 1e-12) {
+        // Degenerate (collinear): return a line
+        return makeLine2d(x1, y1, x2, y2);
+    }
+    const cx = ((x1 * x1 + y1 * y1) * (ym - y2) +
+        (xm * xm + ym * ym) * (y2 - y1) +
+        (x2 * x2 + y2 * y2) * (y1 - ym)) /
+        d;
+    const cy = ((x1 * x1 + y1 * y1) * (x2 - xm) +
+        (xm * xm + ym * ym) * (x1 - x2) +
+        (x2 * x2 + y2 * y2) * (xm - x1)) /
+        d;
+    const radius = Math.sqrt((x1 - cx) ** 2 + (y1 - cy) ** 2);
+    // Compute angles for start (p1), mid (pm), and end (p2)
+    const a1 = Math.atan2(y1 - cy, x1 - cx);
+    const am = Math.atan2(ym - cy, xm - cx);
+    const a2 = Math.atan2(y2 - cy, x2 - cx);
+    // Determine sense: CCW if mid-point angle is between start and end going CCW
+    let da1m = am - a1;
+    if (da1m < 0)
+        da1m += 2 * Math.PI;
+    let da12 = a2 - a1;
+    if (da12 < 0)
+        da12 += 2 * Math.PI;
+    const sense = da1m < da12; // CCW if midpoint comes before endpoint
+    const circle = makeCircle2d(cx, cy, radius, sense);
+    if (!sense) {
+        // CW circle evaluates angle = -t, so parameter t = -angle.
+        const tStart = -a1;
+        let tEnd = -a2;
+        if (tEnd < tStart - 1e-9)
+            tEnd += 2 * Math.PI;
+        return { __bk2d: 'trimmed', basis: circle, tStart, tEnd };
+    }
+    // CCW: ensure tEnd >= tStart
+    let tEnd = a2;
+    if (tEnd < a1 - 1e-9)
+        tEnd += 2 * Math.PI;
+    return { __bk2d: 'trimmed', basis: circle, tStart: a1, tEnd };
+}
+export function makeArc2dTangent(sx, sy, tx, ty, ex, ey) {
+    const len = Math.sqrt(tx * tx + ty * ty);
+    const ntx = len > 0 ? tx / len : 0;
+    const nty = len > 0 ? ty / len : 0;
+    const dx = sx - ex;
+    const dy = sy - ey;
+    const denom = 2 * (dy * ntx - dx * nty);
+    if (Math.abs(denom) < 1e-12) {
+        return makeLine2d(sx, sy, ex, ey);
+    }
+    const chord2 = dx * dx + dy * dy;
+    const t = -chord2 / denom;
+    const cx = sx - t * nty;
+    const cy = sy + t * ntx;
+    const radius = Math.abs(t);
+    const a1 = Math.atan2(sy - cy, sx - cx);
+    const a2 = Math.atan2(ey - cy, ex - cx);
+    const ccwTanX = -(sy - cy) / radius;
+    const ccwTanY = (sx - cx) / radius;
+    const dotCcw = ntx * ccwTanX + nty * ccwTanY;
+    let aMid;
+    if (dotCcw > 0) {
+        let da = a2 - a1;
+        if (da <= 0)
+            da += 2 * Math.PI;
+        aMid = a1 + da / 2;
+    }
+    else {
+        let da = a2 - a1;
+        if (da >= 0)
+            da -= 2 * Math.PI;
+        aMid = a1 + da / 2;
+    }
+    const mx = cx + radius * Math.cos(aMid);
+    const my = cy + radius * Math.sin(aMid);
+    return makeArc2dThreePoints(sx, sy, mx, my, ex, ey);
+}
+export function makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX = 1, xDirY = 0, sense = true) {
+    return {
+        __bk2d: 'ellipse',
+        cx,
+        cy,
+        majorRadius,
+        minorRadius,
+        xDirAngle: Math.atan2(xDirY, xDirX),
+        sense,
+    };
+}
+export function makeBezier2d(poles) {
+    return { __bk2d: 'bezier', poles: [...poles] };
+}
+// ---------------------------------------------------------------------------
+// Transform helpers
+// ---------------------------------------------------------------------------
+export function translateCurve2d(c, dx, dy) {
+    switch (c.__bk2d) {
+        case 'line':
+            return { ...c, ox: c.ox + dx, oy: c.oy + dy };
+        case 'circle':
+            return { ...c, cx: c.cx + dx, cy: c.cy + dy };
+        case 'ellipse':
+            return { ...c, cx: c.cx + dx, cy: c.cy + dy };
+        case 'bezier':
+            return { ...c, poles: c.poles.map(([x, y]) => [x + dx, y + dy]) };
+        case 'bspline':
+            return { ...c, poles: c.poles.map(([x, y]) => [x + dx, y + dy]) };
+        case 'trimmed':
+            return { ...c, basis: translateCurve2d(c.basis, dx, dy) };
+    }
+}
+export function rotateCurve2d(c, angle, cx, cy) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const rotatePoint = (x, y) => {
+        const rx = x - cx;
+        const ry = y - cy;
+        return [cx + rx * cos - ry * sin, cy + rx * sin + ry * cos];
+    };
+    switch (c.__bk2d) {
+        case 'line': {
+            const [ox, oy] = rotatePoint(c.ox, c.oy);
+            const ndx = c.dx * cos - c.dy * sin;
+            const ndy = c.dx * sin + c.dy * cos;
+            return { ...c, ox, oy, dx: ndx, dy: ndy };
+        }
+        case 'circle': {
+            const [ncx, ncy] = rotatePoint(c.cx, c.cy);
+            return { ...c, cx: ncx, cy: ncy };
+        }
+        case 'ellipse': {
+            const [ncx, ncy] = rotatePoint(c.cx, c.cy);
+            return { ...c, cx: ncx, cy: ncy, xDirAngle: c.xDirAngle + angle };
+        }
+        case 'bezier':
+            return { ...c, poles: c.poles.map(([x, y]) => rotatePoint(x, y)) };
+        case 'bspline':
+            return { ...c, poles: c.poles.map(([x, y]) => rotatePoint(x, y)) };
+        case 'trimmed': {
+            const basis = rotateCurve2d(c.basis, angle, cx, cy);
+            // A circle carries no frame angle, so its rotation must land in the
+            // trim range: parameter IS the geometric angle (negated when
+            // sense=false). Without this shift, rotating an arc about its own
+            // circle center was a silent no-op.
+            if (basis.__bk2d === 'circle') {
+                const shift = basis.sense ? angle : -angle;
+                return { ...c, basis, tStart: c.tStart + shift, tEnd: c.tEnd + shift };
+            }
+            return { ...c, basis };
+        }
+    }
+}
+export function scaleCurve2d(c, factor, cx, cy) {
+    const scalePoint = (x, y) => [
+        cx + (x - cx) * factor,
+        cy + (y - cy) * factor,
+    ];
+    switch (c.__bk2d) {
+        case 'line': {
+            // Scale BOTH endpoints and recompute direction/length. Scaling only the
+            // origin (keeping dx/dy/len) left the endpoint wrong for factor != 1 —
+            // most damagingly for mirror (factor = -1, via mirrorAtPoint), which
+            // reflected the origin but kept the original direction, so the line
+            // pointed the wrong way. Consecutive glyph lines then no longer shared a
+            // vertex, leaving font wires disconnected/invalid (engraved-text bug).
+            const [ox, oy] = scalePoint(c.ox, c.oy);
+            const [ex, ey] = scalePoint(c.ox + c.dx * c.len, c.oy + c.dy * c.len);
+            const ndx = ex - ox;
+            const ndy = ey - oy;
+            const nlen = Math.sqrt(ndx * ndx + ndy * ndy);
+            return {
+                ...c,
+                ox,
+                oy,
+                dx: nlen > 0 ? ndx / nlen : c.dx,
+                dy: nlen > 0 ? ndy / nlen : c.dy,
+                len: nlen,
+            };
+        }
+        case 'circle': {
+            const [ncx, ncy] = scalePoint(c.cx, c.cy);
+            return { ...c, cx: ncx, cy: ncy, radius: c.radius * Math.abs(factor) };
+        }
+        case 'ellipse': {
+            const [ncx, ncy] = scalePoint(c.cx, c.cy);
+            return {
+                ...c,
+                cx: ncx,
+                cy: ncy,
+                majorRadius: c.majorRadius * Math.abs(factor),
+                minorRadius: c.minorRadius * Math.abs(factor),
+            };
+        }
+        case 'bezier':
+            return { ...c, poles: c.poles.map(([x, y]) => scalePoint(x, y)) };
+        case 'bspline':
+            return { ...c, poles: c.poles.map(([x, y]) => scalePoint(x, y)) };
+        case 'trimmed':
+            return { ...c, basis: scaleCurve2d(c.basis, factor, cx, cy) };
+    }
+}
+export function mirrorAtPoint(c, cx, cy) {
+    // A point mirror IS a half-turn. Routing through rotate keeps every curve
+    // type's parameterization exact: scale(-1) reflected conic centers but left
+    // their angular parameterization behind, so trimmed-arc endpoints came back
+    // point-reflected through the center.
+    return rotateCurve2d(c, Math.PI, cx, cy);
+}
+export function mirrorAcrossAxis(c, ox, oy, dx, dy) {
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len < 1e-15)
+        return c;
+    const nx = dx / len;
+    const ny = dy / len;
+    const reflectPoint = (x, y) => {
+        const rx = x - ox;
+        const ry = y - oy;
+        const dot = rx * nx + ry * ny;
+        return [ox + 2 * dot * nx - rx, oy + 2 * dot * ny - ry];
+    };
+    switch (c.__bk2d) {
+        case 'line': {
+            const [nox, noy] = reflectPoint(c.ox, c.oy);
+            const ndx = 2 * (c.dx * nx + c.dy * ny) * nx - c.dx;
+            const ndy = 2 * (c.dx * nx + c.dy * ny) * ny - c.dy;
+            return { ...c, ox: nox, oy: noy, dx: ndx, dy: ndy };
+        }
+        case 'circle': {
+            const [ncx, ncy] = reflectPoint(c.cx, c.cy);
+            return { ...c, cx: ncx, cy: ncy, sense: !c.sense };
+        }
+        case 'ellipse': {
+            const [ncx, ncy] = reflectPoint(c.cx, c.cy);
+            // Reflect the major-axis direction angle across the mirror axis
+            const cos2 = nx * nx - ny * ny;
+            const sin2 = 2 * nx * ny;
+            const newAngle = Math.atan2(sin2 * Math.cos(c.xDirAngle) - cos2 * Math.sin(c.xDirAngle), cos2 * Math.cos(c.xDirAngle) + sin2 * Math.sin(c.xDirAngle));
+            return { ...c, cx: ncx, cy: ncy, xDirAngle: newAngle, sense: !c.sense };
+        }
+        case 'bezier':
+            return { ...c, poles: c.poles.map(([x, y]) => reflectPoint(x, y)) };
+        case 'bspline':
+            return { ...c, poles: c.poles.map(([x, y]) => reflectPoint(x, y)) };
+        case 'trimmed': {
+            const basis = mirrorAcrossAxis(c.basis, ox, oy, dx, dy);
+            // Reflection maps a circle's geometric angle theta to 2*phi - theta
+            // (phi = axis angle). The sense flip on the basis absorbs the negation;
+            // the 2*phi rotation has nowhere to live on a frameless circle, so it
+            // lands in the trim range (sign follows the ORIGINAL sense).
+            if (c.basis.__bk2d === 'circle' && basis.__bk2d === 'circle') {
+                const phi = Math.atan2(ny, nx);
+                const shift = c.basis.sense ? -2 * phi : 2 * phi;
+                return { ...c, basis, tStart: c.tStart + shift, tEnd: c.tEnd + shift };
+            }
+            return { ...c, basis };
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// 2D Curve-Curve Intersection
+// ---------------------------------------------------------------------------
+/**
+ * Compute intersection points (and overlapping segments) between two 2D curves.
+ * Handles analytic cases (line-line, line-circle, circle-circle) and falls back
+ * to numerical sampling + Newton refinement for general curves.
+ */
+export function intersectCurves2dFn(c1, c2, tolerance) {
+    const b1 = unwrapCurve(c1);
+    const b2 = unwrapCurve(c2);
+    // Analytic: line-line
+    if (b1.__bk2d === 'line' && b2.__bk2d === 'line') {
+        return intersectLineLine(c1, b1, c2, b2, tolerance);
+    }
+    // Analytic: line-circle / circle-line
+    if (b1.__bk2d === 'line' && b2.__bk2d === 'circle') {
+        return { points: intersectLineCircle(c1, b1, c2, b2, tolerance), segments: [] };
+    }
+    if (b1.__bk2d === 'circle' && b2.__bk2d === 'line') {
+        return { points: intersectLineCircle(c2, b2, c1, b1, tolerance), segments: [] };
+    }
+    // Analytic: circle-circle
+    if (b1.__bk2d === 'circle' && b2.__bk2d === 'circle') {
+        return { points: intersectCircleCircle(c1, b1, c2, b2, tolerance), segments: [] };
+    }
+    // General: numerical (with self-intersection handling)
+    const isSelf = c1 === c2;
+    return numericalIntersect(c1, c2, tolerance, isSelf);
+}
+/** Unwrap trimmed wrappers to get the basis curve type. */
+function unwrapCurve(c) {
+    let cur = c;
+    while (cur.__bk2d === 'trimmed')
+        cur = cur.basis;
+    return cur;
+}
+/** Check if parameter t is within the curve's domain. */
+function inDomain(c, t, tol) {
+    const b = curveBounds(c);
+    return t >= b.first - tol && t <= b.last + tol;
+}
+/** Find the parameter on curve c closest to point (px, py), searching near tGuess. */
+function refineParam(c, px, py) {
+    const bounds = curveBounds(c);
+    if (!isFinite(bounds.first) || !isFinite(bounds.last))
+        return null;
+    const N = 80;
+    const dt = (bounds.last - bounds.first) / N;
+    let bestT = bounds.first;
+    let bestD = Infinity;
+    for (let i = 0; i <= N; i++) {
+        const t = bounds.first + i * dt;
+        const [ex, ey] = evaluateCurve2d(c, t);
+        const d = (ex - px) ** 2 + (ey - py) ** 2;
+        if (d < bestD) {
+            bestD = d;
+            bestT = t;
+        }
+    }
+    // bestD is squared geometric distance. Derive a scale-relative threshold
+    // from the curve's geometric extent (not parameter span, which has different units).
+    const [sx, sy] = evaluateCurve2d(c, bounds.first);
+    const [ex, ey] = evaluateCurve2d(c, bounds.last);
+    const [mx, my] = evaluateCurve2d(c, (bounds.first + bounds.last) / 2);
+    const geomExtent = Math.max(Math.sqrt((ex - sx) ** 2 + (ey - sy) ** 2), Math.sqrt((mx - sx) ** 2 + (my - sy) ** 2), 1e-6);
+    const maxDist = geomExtent * 0.1;
+    return bestD < maxDist * maxDist ? bestT : null;
+}
+function intersectLineLine(c1, l1, c2, l2, tol) {
+    const det = l1.dx * l2.dy - l1.dy * l2.dx;
+    if (Math.abs(det) >= 1e-14) {
+        // Non-parallel: solve for intersection
+        const ex = l2.ox - l1.ox;
+        const ey = l2.oy - l1.oy;
+        const t1 = (ex * l2.dy - ey * l2.dx) / det;
+        const t2 = (ex * l1.dy - ey * l1.dx) / det;
+        if (!inDomain(c1, t1, tol) || !inDomain(c2, t2, tol))
+            return { points: [], segments: [] };
+        return { points: [[l1.ox + t1 * l1.dx, l1.oy + t1 * l1.dy]], segments: [] };
+    }
+    // Parallel — check if collinear and overlapping
+    const ex = l2.ox - l1.ox;
+    const ey = l2.oy - l1.oy;
+    const cross = ex * l1.dy - ey * l1.dx;
+    if (Math.abs(cross) > tol)
+        return { points: [], segments: [] }; // parallel but not collinear
+    // Project c2 endpoints onto c1's parameter space
+    const b1 = curveBounds(c1);
+    const b2 = curveBounds(c2);
+    const p2s = evaluateCurve2d(c2, b2.first);
+    const p2e = evaluateCurve2d(c2, b2.last);
+    const t2sOn1 = (p2s[0] - l1.ox) * l1.dx + (p2s[1] - l1.oy) * l1.dy;
+    const t2eOn1 = (p2e[0] - l1.ox) * l1.dx + (p2e[1] - l1.oy) * l1.dy;
+    const overlapStart = Math.max(b1.first, Math.min(t2sOn1, t2eOn1));
+    const overlapEnd = Math.min(b1.last, Math.max(t2sOn1, t2eOn1));
+    if (overlapEnd - overlapStart < tol)
+        return { points: [], segments: [] }; // no meaningful overlap
+    // Return the overlapping segment as a line
+    const sx = l1.ox + overlapStart * l1.dx;
+    const sy = l1.oy + overlapStart * l1.dy;
+    const ex2 = l1.ox + overlapEnd * l1.dx;
+    const ey2 = l1.oy + overlapEnd * l1.dy;
+    const seg = makeLine2d(sx, sy, ex2, ey2);
+    return { points: [], segments: [seg] };
+}
+function intersectLineCircle(cLine, line, cCirc, circ, tol) {
+    // Vector from circle center to line origin
+    const fx = line.ox - circ.cx;
+    const fy = line.oy - circ.cy;
+    // Quadratic: |f + t*d|^2 = r^2
+    const a = line.dx * line.dx + line.dy * line.dy; // = 1 for normalized
+    const b = 2 * (fx * line.dx + fy * line.dy);
+    const c = fx * fx + fy * fy - circ.radius * circ.radius;
+    const disc = b * b - 4 * a * c;
+    if (disc < -tol)
+        return [];
+    const results = [];
+    const sqrtDisc = Math.sqrt(Math.max(0, disc));
+    const t1 = (-b - sqrtDisc) / (2 * a);
+    const t2 = (-b + sqrtDisc) / (2 * a);
+    for (const tLine of disc < tol * tol ? [t1] : [t1, t2]) {
+        if (!inDomain(cLine, tLine, tol))
+            continue;
+        const px = line.ox + tLine * line.dx;
+        const py = line.oy + tLine * line.dy;
+        // Check that the point is in the circle's domain
+        const tCirc = refineParam(cCirc, px, py);
+        if (tCirc === null)
+            continue;
+        const [cx2, cy2] = evaluateCurve2d(cCirc, tCirc);
+        if ((cx2 - px) ** 2 + (cy2 - py) ** 2 > tol * tol * 1e6)
+            continue;
+        results.push([px, py]);
+    }
+    return results;
+}
+function intersectConcentricArcs(c1, c2, tol) {
+    const b1 = curveBounds(c1);
+    const b2 = curveBounds(c2);
+    const isFullCircle1 = Math.abs(b1.last - b1.first - 2 * Math.PI) < 1e-10;
+    const isFullCircle2 = Math.abs(b2.last - b2.first - 2 * Math.PI) < 1e-10;
+    if (isFullCircle1 && isFullCircle2)
+        return [];
+    if (isFullCircle1) {
+        return [evaluateCurve2d(c2, b2.first), evaluateCurve2d(c2, b2.last)];
+    }
+    if (isFullCircle2) {
+        return [evaluateCurve2d(c1, b1.first), evaluateCurve2d(c1, b1.last)];
+    }
+    const pts = [];
+    const checks = [
+        [c2, evaluateCurve2d(c1, b1.first)],
+        [c2, evaluateCurve2d(c1, b1.last)],
+        [c1, evaluateCurve2d(c2, b2.first)],
+        [c1, evaluateCurve2d(c2, b2.last)],
+    ];
+    for (const [target, pt] of checks) {
+        const t = refineParam(target, pt[0], pt[1]);
+        if (t !== null) {
+            const [ex, ey] = evaluateCurve2d(target, t);
+            if ((ex - pt[0]) ** 2 + (ey - pt[1]) ** 2 < tol * tol * 100)
+                pts.push(pt);
+        }
+    }
+    const deduped = [];
+    for (const p of pts) {
+        if (!deduped.some(([ddx, ddy]) => (ddx - p[0]) ** 2 + (ddy - p[1]) ** 2 < tol * tol * 100)) {
+            deduped.push(p);
+        }
+    }
+    return deduped;
+}
+function intersectCircleCircle(c1, circ1, c2, circ2, tol) {
+    const dx = circ2.cx - circ1.cx;
+    const dy = circ2.cy - circ1.cy;
+    const d = Math.sqrt(dx * dx + dy * dy);
+    if (d > circ1.radius + circ2.radius + tol)
+        return [];
+    if (d < Math.abs(circ1.radius - circ2.radius) - tol)
+        return [];
+    if (d < 1e-14) {
+        if (Math.abs(circ1.radius - circ2.radius) > tol)
+            return [];
+        return intersectConcentricArcs(c1, c2, tol);
+    }
+    const a = (circ1.radius * circ1.radius - circ2.radius * circ2.radius + d * d) / (2 * d);
+    const h2 = circ1.radius * circ1.radius - a * a;
+    const h = Math.sqrt(Math.max(0, h2));
+    const mx = circ1.cx + (a * dx) / d;
+    const my = circ1.cy + (a * dy) / d;
+    const candidates = h < tol
+        ? [[mx, my]]
+        : [
+            [mx + (h * dy) / d, my - (h * dx) / d],
+            [mx - (h * dy) / d, my + (h * dx) / d],
+        ];
+    // Filter candidates that lie within both curves' domains
+    const results = [];
+    for (const [px, py] of candidates) {
+        const t1 = refineParam(c1, px, py);
+        const t2 = refineParam(c2, px, py);
+        if (t1 === null || t2 === null)
+            continue;
+        const [x1, y1] = evaluateCurve2d(c1, t1);
+        const [x2, y2] = evaluateCurve2d(c2, t2);
+        // Compare squared distances against squared tolerance to avoid sqrt
+        const tolSq = (tol * 10) ** 2;
+        if ((x1 - px) ** 2 + (y1 - py) ** 2 > tolSq)
+            continue;
+        if ((x2 - px) ** 2 + (y2 - py) ** 2 > tolSq)
+            continue;
+        results.push([px, py]);
+    }
+    return results;
+}
+/**
+ * Numerical intersection via sampling + Newton refinement.
+ * Samples both curves densely, finds close point pairs, refines with Newton.
+ */
+function numericalIntersect(c1, c2, tolerance, isSelf = false) {
+    const b1 = curveBounds(c1);
+    const b2 = curveBounds(c2);
+    if (!isFinite(b1.first) || !isFinite(b1.last) || !isFinite(b2.first) || !isFinite(b2.last)) {
+        return { points: [], segments: [] };
+    }
+    const N = 100;
+    const pts1 = [];
+    const pts2 = [];
+    for (let i = 0; i <= N; i++) {
+        const t1 = b1.first + ((b1.last - b1.first) * i) / N;
+        const [x1, y1] = evaluateCurve2d(c1, t1);
+        pts1.push({ t: t1, x: x1, y: y1 });
+        const t2 = b2.first + ((b2.last - b2.first) * i) / N;
+        const [x2, y2] = evaluateCurve2d(c2, t2);
+        pts2.push({ t: t2, x: x2, y: y2 });
+    }
+    // Pre-compute segment bounds for curve2 (avoids recomputing N times in inner loop)
+    const crossTol = Math.max(tolerance * 100, 0.5);
+    const seg2Bounds = new Float64Array(N * 6); // xmin, xmax, ymin, ymax, tmid, _pad per segment
+    for (let j = 0; j < N; j++) {
+        /* eslint-disable @typescript-eslint/no-non-null-assertion -- known array index */
+        const a = pts2[j], b = pts2[j + 1];
+        /* eslint-enable @typescript-eslint/no-non-null-assertion */
+        const off = j * 6;
+        seg2Bounds[off] = Math.min(a.x, b.x);
+        seg2Bounds[off + 1] = Math.max(a.x, b.x);
+        seg2Bounds[off + 2] = Math.min(a.y, b.y);
+        seg2Bounds[off + 3] = Math.max(a.y, b.y);
+        seg2Bounds[off + 4] = (a.t + b.t) / 2;
+    }
+    // Find segment pairs where curves are close
+    const candidates = [];
+    const selfMinSep = (b1.last - b1.first) / 5;
+    for (let i = 0; i < N; i++) {
+        /* eslint-disable @typescript-eslint/no-non-null-assertion -- known array index */
+        const p1a = pts1[i];
+        const p1b = pts1[i + 1];
+        /* eslint-enable @typescript-eslint/no-non-null-assertion */
+        // Hoist outer segment AABB (computed once per outer iteration)
+        const x1min = Math.min(p1a.x, p1b.x) - crossTol;
+        const x1max = Math.max(p1a.x, p1b.x) + crossTol;
+        const y1min = Math.min(p1a.y, p1b.y) - crossTol;
+        const y1max = Math.max(p1a.y, p1b.y) + crossTol;
+        const t1mid = (p1a.t + p1b.t) / 2;
+        for (let j = 0; j < N; j++) {
+            const off = j * 6;
+            /* eslint-disable @typescript-eslint/no-non-null-assertion -- typed array indices known valid */
+            if (x1max < seg2Bounds[off] || seg2Bounds[off + 1] < x1min)
+                continue;
+            if (y1max < seg2Bounds[off + 2] || seg2Bounds[off + 3] < y1min)
+                continue;
+            const t2mid = seg2Bounds[off + 4];
+            /* eslint-enable @typescript-eslint/no-non-null-assertion */
+            if (isSelf && Math.abs(t1mid - t2mid) < selfMinSep)
+                continue;
+            candidates.push({ t1: t1mid, t2: t2mid });
+        }
+    }
+    // Refine candidates via Newton iteration
+    const tol2 = tolerance * tolerance;
+    const found = [];
+    for (const { t1: t1Init, t2: t2Init } of candidates) {
+        let t1 = t1Init;
+        let t2 = t2Init;
+        for (let iter = 0; iter < 20; iter++) {
+            const [x1, y1] = evaluateCurve2d(c1, t1);
+            const [x2, y2] = evaluateCurve2d(c2, t2);
+            const dx = x1 - x2;
+            const dy = y1 - y2;
+            if (dx * dx + dy * dy < tol2)
+                break;
+            const d1 = tangentCurve2d(c1, t1);
+            const d2 = tangentCurve2d(c2, t2);
+            // Newton system: J * [dt1, dt2]^T = -[dx, dy]
+            // J = [d1x, -d2x; d1y, -d2y]
+            const det = d1[0] * -d2[1] - -d2[0] * d1[1];
+            if (Math.abs(det) < 1e-14)
+                break;
+            const dt1 = (-dx * -d2[1] - -dy * -d2[0]) / det;
+            const dt2 = (d1[0] * -dy - d1[1] * -dx) / det;
+            t1 += dt1;
+            t2 += dt2;
+            // Clamp to domain
+            t1 = Math.max(b1.first, Math.min(b1.last, t1));
+            t2 = Math.max(b2.first, Math.min(b2.last, t2));
+        }
+        const [x1, y1] = evaluateCurve2d(c1, t1);
+        const [x2, y2] = evaluateCurve2d(c2, t2);
+        // For self-intersection, only accept points where parameters are well-separated
+        if (isSelf && Math.abs(t1 - t2) < (b1.last - b1.first) * 0.05)
+            continue;
+        if ((x1 - x2) ** 2 + (y1 - y2) ** 2 < tolerance * tolerance * 1e6) {
+            const px = (x1 + x2) / 2;
+            const py = (y1 + y2) / 2;
+            // Deduplicate
+            let dup = false;
+            for (const [fx, fy] of found) {
+                if ((fx - px) ** 2 + (fy - py) ** 2 < tolerance * tolerance * 1e4) {
+                    dup = true;
+                    break;
+                }
+            }
+            if (!dup)
+                found.push([px, py]);
+        }
+    }
+    return { points: found, segments: [] };
+}
+// ---------------------------------------------------------------------------
+// Serialization
+// ---------------------------------------------------------------------------
+export function serializeCurve2d(c) {
+    return JSON.stringify(c);
+}
+export function deserializeCurve2d(data) {
+    return JSON.parse(data);
+}
+// ---------------------------------------------------------------------------
+// BBox helpers
+// ---------------------------------------------------------------------------
+export function createBBox2d() {
+    return { __bk2d_bbox: true, xMin: Infinity, yMin: Infinity, xMax: -Infinity, yMax: -Infinity };
+}
+export function addCurveToBBox(bbox, c, _tol) {
+    const basis = c.__bk2d === 'trimmed' ? c.basis : c;
+    // Analytic: lines need only 2 endpoints (no sampling)
+    if (basis.__bk2d === 'line') {
+        const bounds = curveBounds(c);
+        if (!isFinite(bounds.first) || !isFinite(bounds.last))
+            return;
+        const [x0, y0] = evaluateCurve2d(c, bounds.first);
+        const [x1, y1] = evaluateCurve2d(c, bounds.last);
+        bbox.xMin = Math.min(bbox.xMin, x0, x1);
+        bbox.yMin = Math.min(bbox.yMin, y0, y1);
+        bbox.xMax = Math.max(bbox.xMax, x0, x1);
+        bbox.yMax = Math.max(bbox.yMax, y0, y1);
+        return;
+    }
+    // Analytic: circles/arcs — endpoints + axis extremes
+    if (basis.__bk2d === 'circle') {
+        const bounds = curveBounds(c);
+        if (!isFinite(bounds.first) || !isFinite(bounds.last))
+            return;
+        const { cx, cy, radius, sense } = basis;
+        const [x0, y0] = evaluateCurve2d(c, bounds.first);
+        const [x1, y1] = evaluateCurve2d(c, bounds.last);
+        let xMin = Math.min(x0, x1), xMax = Math.max(x0, x1);
+        let yMin = Math.min(y0, y1), yMax = Math.max(y0, y1);
+        // Check axis-aligned extreme angles within the arc's parameter range
+        const tStart = c.__bk2d === 'trimmed' ? c.tStart : bounds.first;
+        const tEnd = c.__bk2d === 'trimmed' ? c.tEnd : bounds.last;
+        for (let k = 0; k < 4; k++) {
+            const angle = (k * Math.PI) / 2;
+            const t = sense ? angle : -angle;
+            // Check if t (or t + 2π) falls within [tStart, tEnd]
+            for (let wrap = 0; wrap <= 1; wrap++) {
+                const tt = t + wrap * 2 * Math.PI;
+                if (tt >= tStart - 1e-10 && tt <= tEnd + 1e-10) {
+                    const ex = cx + radius * Math.cos(angle);
+                    const ey = cy + radius * Math.sin(angle);
+                    xMin = Math.min(xMin, ex);
+                    xMax = Math.max(xMax, ex);
+                    yMin = Math.min(yMin, ey);
+                    yMax = Math.max(yMax, ey);
+                    break;
+                }
+            }
+        }
+        bbox.xMin = Math.min(bbox.xMin, xMin);
+        bbox.yMin = Math.min(bbox.yMin, yMin);
+        bbox.xMax = Math.max(bbox.xMax, xMax);
+        bbox.yMax = Math.max(bbox.yMax, yMax);
+        return;
+    }
+    // General: sample (bezier, bspline, ellipse)
+    const bounds = curveBounds(c);
+    if (!isFinite(bounds.first) || !isFinite(bounds.last))
+        return;
+    const nSamples = 20;
+    const dt = (bounds.last - bounds.first) / nSamples;
+    for (let i = 0; i <= nSamples; i++) {
+        const t = bounds.first + i * dt;
+        const [x, y] = evaluateCurve2d(c, t);
+        if (x < bbox.xMin)
+            bbox.xMin = x;
+        if (y < bbox.yMin)
+            bbox.yMin = y;
+        if (x > bbox.xMax)
+            bbox.xMax = x;
+        if (y > bbox.yMax)
+            bbox.yMax = y;
+    }
+}
+// ---------------------------------------------------------------------------
+// Private helpers
+// ---------------------------------------------------------------------------
+function evaluateBezier(poles, t) {
+    // De Casteljau
+    const n = poles.length;
+    const work = poles.map(([x, y]) => [x, y]);
+    /* eslint-disable @typescript-eslint/no-non-null-assertion -- array indices known valid by loop bounds */
+    for (let r = 1; r < n; r++) {
+        for (let i = 0; i < n - r; i++) {
+            const wi = work[i];
+            const wi1 = work[i + 1];
+            wi[0] = (1 - t) * wi[0] + t * wi1[0];
+            wi[1] = (1 - t) * wi[1] + t * wi1[1];
+        }
+    }
+    return work[0];
+    /* eslint-enable @typescript-eslint/no-non-null-assertion */
+}
+function evaluateBSpline2d(c, t) {
+    /* eslint-disable @typescript-eslint/no-non-null-assertion -- knot-vector indices known valid by loop bounds */
+    // Expand knots with multiplicities
+    const fullKnots = [];
+    for (let i = 0; i < c.knots.length; i++) {
+        const mult = c.multiplicities[i] ?? 1;
+        for (let j = 0; j < mult; j++) {
+            fullKnots.push(c.knots[i]);
+        }
+    }
+    // De Boor evaluation
+    const p = c.degree;
+    const n = c.poles.length;
+    const k = fullKnots.length;
+    // Clamp t to domain
+    const tClamped = Math.max(fullKnots[p], Math.min(fullKnots[k - p - 1], t));
+    // Find span
+    let span = p;
+    for (let i = p; i < k - p - 1; i++) {
+        if (tClamped >= fullKnots[i] && tClamped < fullKnots[i + 1]) {
+            span = i;
+            break;
+        }
+    }
+    if (tClamped >= fullKnots[k - p - 1])
+        span = k - p - 2;
+    // Extract relevant control points
+    const d = [];
+    for (let j = 0; j <= p; j++) {
+        const idx = Math.min(span - p + j, n - 1);
+        const pole = c.poles[Math.max(0, idx)];
+        d.push([pole[0], pole[1]]);
+    }
+    // De Boor recursion
+    for (let r = 1; r <= p; r++) {
+        for (let j = p; j >= r; j--) {
+            const i = span - p + j;
+            const left = fullKnots[i] ?? 0;
+            const right = fullKnots[i + p - r + 1] ?? 1;
+            const denom = right - left;
+            const alpha = denom > 1e-15 ? (tClamped - left) / denom : 0;
+            const dj = d[j];
+            const djPrev = d[j - 1];
+            dj[0] = (1 - alpha) * djPrev[0] + alpha * dj[0];
+            dj[1] = (1 - alpha) * djPrev[1] + alpha * dj[1];
+        }
+    }
+    return d[p];
+    /* eslint-enable @typescript-eslint/no-non-null-assertion */
+}
+//# sourceMappingURL=geometry2d.js.map