@faicad/faijs 0.13.0

package/dist/vendored/brepjs/kernel/occtWasm/kernel2dOps.js

@@ -0,0 +1,731 @@
+/**
+ * 2D curve operations for the occt-wasm adapter.
+ *
+ * occt-wasm doesn't expose Geom2d via Embind, so these methods sit on top
+ * of the pure-TS `geometry2d` module (`ow2d`). Curve handles are opaque
+ * `Curve2dObj` instances passed through `c2dWrap` / `c2d` identity casts.
+ *
+ * @module
+ */
+import * as ow2d from '../../kernel/geometry2d.js';
+import { handle, unwrap } from './helpers.js';
+import { curveParameters, curvePointAtParam } from './curveOps.js';
+import { uvFromPoint } from './surfaceOps.js';
+// ─── Curve handle wrappers — identity casts at the kernel boundary ──────────
+function c2d(h) {
+    return h;
+}
+function c2dWrap(obj) {
+    return obj;
+}
+// ─── Constructors for plain-object 2D primitives ────────────────────────────
+export function createPoint2d(x, y) {
+    return { x, y };
+}
+export function createDirection2d(x, y) {
+    const l = Math.sqrt(x * x + y * y);
+    if (l < 1e-15) {
+        throw new Error('occt-wasm: createDirection2d called with zero-length vector');
+    }
+    return { x: x / l, y: y / l };
+}
+export function createVector2d(x, y) {
+    return { x, y };
+}
+export function createAxis2d(px, py, dx, dy) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- opaque type bridge
+    return { px, py, dx, dy, delete() { } };
+}
+export function wrapCurve2dHandle(h) {
+    return h;
+}
+// ─── Curve constructors ─────────────────────────────────────────────────────
+export function makeLine2d(x1, y1, x2, y2) {
+    return c2dWrap(ow2d.makeLine2d(x1, y1, x2, y2));
+}
+export function makeCircle2d(cx, cy, radius, sense) {
+    return c2dWrap(ow2d.makeCircle2d(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) {
+        return c2dWrap(ow2d.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);
+    const a1 = Math.atan2(y1 - cy, x1 - cx);
+    const am = Math.atan2(ym - cy, xm - cx);
+    const a2 = Math.atan2(y2 - cy, x2 - cx);
+    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;
+    const circle = ow2d.makeCircle2d(cx, cy, radius, sense);
+    if (!sense) {
+        const tStart = -a1;
+        let tEnd = -a2;
+        if (tEnd < tStart - 1e-9)
+            tEnd += 2 * Math.PI;
+        return c2dWrap({ __bk2d: 'trimmed', basis: circle, tStart, tEnd });
+    }
+    let tEnd = a2;
+    if (tEnd < a1 - 1e-9)
+        tEnd += 2 * Math.PI;
+    return c2dWrap({ __bk2d: 'trimmed', basis: circle, tStart: a1, tEnd });
+}
+export function makeArc2dTangent(startX, startY, tangentX, tangentY, endX, endY) {
+    const len = Math.sqrt(tangentX * tangentX + tangentY * tangentY);
+    const ntx = len > 0 ? tangentX / len : 0;
+    const nty = len > 0 ? tangentY / len : 0;
+    const dx = startX - endX;
+    const dy = startY - endY;
+    const denom = 2 * (dy * ntx - dx * nty);
+    if (Math.abs(denom) < 1e-12) {
+        return c2dWrap(ow2d.makeLine2d(startX, startY, endX, endY));
+    }
+    const chord2 = dx * dx + dy * dy;
+    const t = -chord2 / denom;
+    const cx = startX - t * nty;
+    const cy = startY + t * ntx;
+    const radius = Math.abs(t);
+    const a1 = Math.atan2(startY - cy, startX - cx);
+    const a2 = Math.atan2(endY - cy, endX - cx);
+    const ccwTanX = -(startY - cy) / radius;
+    const ccwTanY = (startX - cx) / radius;
+    const sense = ccwTanX * ntx + ccwTanY * nty > 0;
+    const circle = ow2d.makeCircle2d(cx, cy, radius, sense);
+    if (!sense) {
+        const tStart = -a1;
+        let tEnd = -a2;
+        if (tEnd < tStart - 1e-9)
+            tEnd += 2 * Math.PI;
+        return c2dWrap({ __bk2d: 'trimmed', basis: circle, tStart, tEnd });
+    }
+    let tEnd = a2;
+    if (tEnd < a1 - 1e-9)
+        tEnd += 2 * Math.PI;
+    return c2dWrap({ __bk2d: 'trimmed', basis: circle, tStart: a1, tEnd });
+}
+export function makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense) {
+    return c2dWrap(ow2d.makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX ?? 1, xDirY ?? 0, sense ?? true));
+}
+export function makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense) {
+    const full = ow2d.makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX ?? 1, xDirY ?? 0, sense ?? true);
+    // Evaluation negates the parameter for sense=false, so the trim range
+    // flips sign with it (same mapping as the circle-arc makers above).
+    if (!(sense ?? true)) {
+        const tStart = -startAngle;
+        let tEnd = -endAngle;
+        if (tEnd < tStart - 1e-9)
+            tEnd += 2 * Math.PI;
+        return c2dWrap({ __bk2d: 'trimmed', basis: full, tStart, tEnd });
+    }
+    let tEnd = endAngle;
+    if (tEnd < startAngle - 1e-9)
+        tEnd += 2 * Math.PI;
+    return c2dWrap({ __bk2d: 'trimmed', basis: full, tStart: startAngle, tEnd });
+}
+export function makeBezier2d(points) {
+    return c2dWrap(ow2d.makeBezier2d(points));
+}
+export function makeBSpline2d(points, options) {
+    // Build a genuine B-spline (poles = input points, clamped knot vector) so
+    // getCurve2dType reports BSPLINE_CURVE and decomposeBSpline2dToBeziers works.
+    // The pure-TS 2D system has no fitting solver, so this approximates (passes
+    // through the endpoints) rather than interpolating every point.
+    const poles = points;
+    const n = poles.length;
+    const degree = Math.max(1, Math.min(options?.degMax ?? 3, n - 1));
+    const knots = [0];
+    const mults = [degree + 1];
+    const nInternalKnots = n - degree - 1;
+    for (let i = 1; i <= nInternalKnots; i++) {
+        knots.push(i / (nInternalKnots + 1));
+        mults.push(1);
+    }
+    knots.push(1);
+    mults.push(degree + 1);
+    return c2dWrap({
+        __bk2d: 'bspline',
+        poles,
+        knots,
+        multiplicities: mults,
+        degree,
+        isPeriodic: false,
+    });
+}
+// ─── Curve evaluation / metadata ────────────────────────────────────────────
+export function evaluateCurve2d(curve, param) {
+    return ow2d.evaluateCurve2d(c2d(curve), param);
+}
+export function evaluateCurve2dD1(curve, param) {
+    return {
+        point: ow2d.evaluateCurve2d(c2d(curve), param),
+        tangent: ow2d.tangentCurve2d(c2d(curve), param),
+    };
+}
+export function getCurve2dBounds(curve) {
+    return ow2d.curveBounds(c2d(curve));
+}
+export function getCurve2dType(curve) {
+    let cu = c2d(curve);
+    while (cu.__bk2d === 'trimmed') {
+        cu = cu.basis;
+    }
+    return ow2d.curveTypeName(cu);
+}
+// ─── Curve transforms ───────────────────────────────────────────────────────
+export function trimCurve2d(curve, start, end) {
+    return c2dWrap({ __bk2d: 'trimmed', basis: c2d(curve), tStart: start, tEnd: end });
+}
+export function reverseCurve2d(_curve) {
+    // Curves are immutable in our pure-TS 2D system — reverse is a no-op.
+}
+export function copyCurve2d(curve) {
+    return c2dWrap(JSON.parse(JSON.stringify(c2d(curve))));
+}
+export function offsetCurve2d(curve, offset) {
+    // Approximate offset by sampling + shifting normals.
+    const c = c2d(curve);
+    const bounds = ow2d.curveBounds(c);
+    const pts = [];
+    for (let i = 0; i <= 20; i++) {
+        const t = bounds.first + ((bounds.last - bounds.first) * i) / 20;
+        const [px, py] = ow2d.evaluateCurve2d(c, t);
+        const [tx, ty] = ow2d.tangentCurve2d(c, t);
+        const len = Math.sqrt(tx * tx + ty * ty) || 1;
+        pts.push([px - (ty / len) * offset, py + (tx / len) * offset]);
+    }
+    return c2dWrap(ow2d.makeBezier2d(pts.length <= 25 ? pts : pts.filter((_, i) => i % 2 === 0 || i === pts.length - 1)));
+}
+export function translateCurve2d(curve, dx, dy) {
+    return c2dWrap(ow2d.translateCurve2d(c2d(curve), dx, dy));
+}
+export function rotateCurve2d(curve, angle, cx, cy) {
+    return c2dWrap(ow2d.rotateCurve2d(c2d(curve), angle, cx, cy));
+}
+export function scaleCurve2d(curve, factor, cx, cy) {
+    // geometry2d.scaleCurve2d already scales line endpoints and recomputes length;
+    // do not re-patch len here (it would double-apply).
+    return c2dWrap(ow2d.scaleCurve2d(c2d(curve), factor, cx, cy));
+}
+export function mirrorCurve2dAtPoint(curve, cx, cy) {
+    return c2dWrap(ow2d.mirrorAtPoint(c2d(curve), cx, cy));
+}
+export function mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY) {
+    return c2dWrap(ow2d.mirrorAcrossAxis(c2d(curve), originX, originY, dirX, dirY));
+}
+/**
+ * Directional affinity matching OCCT `gp_GTrsf2d::SetAffinity`: scales the
+ * component perpendicular to the axis `(dx, dy)` through `(ox, oy)` by `ratio`,
+ * leaving the parallel component fixed. Applied by sampling and refitting as a
+ * Bezier, since occt-wasm has no native Geom2d transform.
+ */
+export function affinityCurve2d(curve, ox, oy, dx, dy, ratio) {
+    const len = Math.sqrt(dx * dx + dy * dy);
+    if (len < 1e-15)
+        return curve;
+    const px = -dy / len, py = dx / len; // perpendicular to axis
+    const k = ratio - 1;
+    const a = 1 + k * px * px, b = k * px * py, d = k * py * px, e = 1 + k * py * py;
+    const tx = ox - a * ox - b * oy;
+    const ty = oy - d * ox - e * oy;
+    const c = c2d(curve);
+    const bounds = ow2d.curveBounds(c);
+    const N = 20;
+    const pts = [];
+    for (let i = 0; i <= N; i++) {
+        const t = bounds.first + ((bounds.last - bounds.first) * i) / N;
+        const [qx, qy] = ow2d.evaluateCurve2d(c, t);
+        pts.push([a * qx + b * qy + tx, d * qx + e * qy + ty]);
+    }
+    return c2dWrap(ow2d.makeBezier2d(pts));
+}
+export function affinityTransform2d(curve, ox, oy, dx, dy, ratio) {
+    return affinityCurve2d(curve, ox, oy, dx, dy, ratio);
+}
+// ─── 2D general transforms (GTrsf) ──────────────────────────────────────────
+export function createIdentityGTrsf2d() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- opaque type
+    return { type: 'identity2d', delete() { } };
+}
+export function createAffinityGTrsf2d(originX, originY, dirX, dirY, ratio) {
+    return {
+        type: 'affinity2d',
+        axOriginX: originX,
+        axOriginY: originY,
+        axDirX: dirX,
+        axDirY: dirY,
+        ratio,
+        delete() { },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- opaque type
+    };
+}
+export function createTranslationGTrsf2d(dx, dy) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- opaque type
+    return { type: 'translate2d', dx, dy, delete() { } };
+}
+export function createMirrorGTrsf2d(cx, cy, mode, originX, originY, dirX, dirY) {
+    return {
+        type: 'mirror2d',
+        cx,
+        cy,
+        mode,
+        originX,
+        originY,
+        dirX,
+        dirY,
+        delete() { },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- opaque type
+    };
+}
+export function createRotationGTrsf2d(angle, cx, cy) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- opaque type
+    return { type: 'rotate2d', angle, cx, cy, delete() { } };
+}
+export function createScaleGTrsf2d(factor, cx, cy) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- opaque type
+    return { type: 'scale2d', sx: factor, sy: factor, cx, cy, delete() { } };
+}
+export function setGTrsf2dTranslationPart(gtrsf, dx, dy) {
+    const t = gtrsf;
+    t['dx'] = (Number(t['dx']) || 0) + dx;
+    t['dy'] = (Number(t['dy']) || 0) + dy;
+}
+export function multiplyGTrsf2d(base, other) {
+    const b = base;
+    const o = other;
+    b['dx'] = (Number(b['dx']) || 0) + (Number(o['dx']) || 0);
+    b['dy'] = (Number(b['dy']) || 0) + (Number(o['dy']) || 0);
+    if (o['type'] === 'scale2d') {
+        b['type'] = 'scale2d';
+        b['sx'] = o['sx'];
+        b['sy'] = o['sy'];
+    }
+}
+export function transformCurve2dGeneral(curve, gtrsf) {
+    const t = gtrsf;
+    if (t['type'] === 'translate2d') {
+        return translateCurve2d(curve, Number(t['dx']) || 0, Number(t['dy']) || 0);
+    }
+    if (t['type'] === 'rotate2d') {
+        return rotateCurve2d(curve, Number(t['angle']) || 0, Number(t['cx']) || 0, Number(t['cy']) || 0);
+    }
+    if (t['type'] === 'scale2d') {
+        return scaleCurve2d(curve, Number(t['sx']) || 1, Number(t['cx']) || 0, Number(t['cy']) || 0);
+    }
+    if (t['type'] === 'mirror2d') {
+        if (t['mode'] === 'axis') {
+            return mirrorCurve2dAcrossAxis(curve, Number(t['originX']) || 0, Number(t['originY']) || 0, Number(t['dirX']) || 0, Number(t['dirY']) || 0);
+        }
+        return mirrorCurve2dAtPoint(curve, Number(t['cx']) || 0, Number(t['cy']) || 0);
+    }
+    if (t['type'] === 'affinity2d') {
+        return affinityCurve2d(curve, Number(t['axOriginX']) || 0, Number(t['axOriginY']) || 0, Number(t['axDirX']) || 0, Number(t['axDirY']) || 0, Number(t['ratio']) || 1);
+    }
+    if (Number(t['dx']) || Number(t['dy'])) {
+        return translateCurve2d(curve, Number(t['dx']) || 0, Number(t['dy']) || 0);
+    }
+    return curve;
+}
+// ─── Intersection / projection / split ──────────────────────────────────────
+export function intersectCurves2d(c1, c2, tolerance) {
+    const result = ow2d.intersectCurves2dFn(c2d(c1), c2d(c2), tolerance);
+    return { points: result.points, segments: result.segments.map((s) => c2dWrap(s)) };
+}
+// brepjs-patterns-disable: max-function-lines
+export function projectPointOnCurve2d(curve, x, y) {
+    const c = c2d(curve);
+    const bounds = ow2d.curveBounds(c);
+    const projectOnBasis = (basis, bFirst, bLast) => {
+        if (basis.__bk2d === 'line') {
+            const rawT = (x - basis.ox) * basis.dx + (y - basis.oy) * basis.dy;
+            const t = Math.max(bFirst, Math.min(bLast, rawT));
+            const [px, py] = ow2d.evaluateCurve2d(basis, t);
+            return { param: t, distance: Math.sqrt((px - x) ** 2 + (py - y) ** 2) };
+        }
+        // For circles and general curves: dense sampling.
+        const N = 200;
+        let bestT = bFirst;
+        let bestDist = Infinity;
+        for (let i = 0; i <= N; i++) {
+            const t = bFirst + ((bLast - bFirst) * i) / N;
+            const [px, py] = ow2d.evaluateCurve2d(basis, t);
+            const d = (px - x) ** 2 + (py - y) ** 2;
+            if (d < bestDist) {
+                bestDist = d;
+                bestT = t;
+            }
+        }
+        return { param: bestT, distance: Math.sqrt(bestDist) };
+    };
+    if (c.__bk2d === 'trimmed') {
+        const tStart = c.tStart;
+        const tEnd = c.tEnd;
+        const basisResult = projectOnBasis(c.basis, tStart, tEnd);
+        if (!basisResult)
+            return null;
+        const range = tEnd - tStart;
+        const trimmedT = range > 1e-15 ? (basisResult.param - tStart) / range : 0;
+        return { param: Math.max(0, Math.min(1, trimmedT)), distance: basisResult.distance };
+    }
+    return projectOnBasis(c, bounds.first, bounds.last);
+}
+export function distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End) {
+    const n = 20;
+    let minDist = Infinity;
+    for (let i = 0; i <= n; i++) {
+        const t1 = p1Start + (p1End - p1Start) * (i / n);
+        const [x1, y1] = ow2d.evaluateCurve2d(c2d(c1), t1);
+        for (let j = 0; j <= n; j++) {
+            const t2 = p2Start + (p2End - p2Start) * (j / n);
+            const [x2, y2] = ow2d.evaluateCurve2d(c2d(c2), t2);
+            const d = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+            if (d < minDist)
+                minDist = d;
+        }
+    }
+    return minDist;
+}
+export function approximateCurve2dAsBSpline(curve, maxSegments) {
+    const cu = c2d(curve);
+    const bounds = ow2d.curveBounds(cu);
+    const nPts = Math.min(Math.max(maxSegments + 1, 10), 100);
+    const poles = [];
+    for (let i = 0; i < nPts; i++) {
+        const t = bounds.first + ((bounds.last - bounds.first) * i) / (nPts - 1);
+        poles.push(ow2d.evaluateCurve2d(cu, t));
+    }
+    const degree = Math.min(3, nPts - 1);
+    const n = poles.length;
+    const knots = [];
+    const mults = [];
+    const nInternalKnots = n - degree - 1;
+    knots.push(0);
+    mults.push(degree + 1);
+    for (let i = 1; i <= nInternalKnots; i++) {
+        knots.push(i / (nInternalKnots + 1));
+        mults.push(1);
+    }
+    knots.push(1);
+    mults.push(degree + 1);
+    return c2dWrap({
+        __bk2d: 'bspline',
+        poles,
+        knots,
+        multiplicities: mults,
+        degree,
+        isPeriodic: false,
+    });
+}
+export function decomposeBSpline2dToBeziers(curve) {
+    let cu = c2d(curve);
+    while (cu.__bk2d === 'trimmed')
+        cu = cu.basis;
+    if (cu.__bk2d !== 'bspline')
+        return [curve];
+    const poles = cu.poles;
+    const p = cu.degree;
+    // Expand knots+multiplicities into the full knot vector U.
+    const U = [];
+    for (let i = 0; i < cu.knots.length; i++) {
+        const knot = cu.knots[i] ?? 0;
+        const mult = cu.multiplicities[i] ?? 0;
+        for (let j = 0; j < mult; j++)
+            U.push(knot);
+    }
+    const n = poles.length - 1;
+    const m = n + p + 1;
+    // A clamped, non-rational B-spline has |U| = n + p + 2. Bail to a single
+    // Bezier on the control polygon if the curve is malformed.
+    if (p < 1 || U.length !== m + 1) {
+        return [c2dWrap(ow2d.makeBezier2d(poles))];
+    }
+    // NURBS Book Algorithm A5.6 (DecomposeCurve): knot-insert every interior knot
+    // up to multiplicity p, yielding one Bezier segment (p+1 poles) per span.
+    const clone = (pt) => [pt[0], pt[1]];
+    const segments = [];
+    let a = p;
+    let b = p + 1;
+    let segPoles = [];
+    for (let i = 0; i <= p; i++)
+        segPoles[i] = clone(poles[i]);
+    let nextPoles = [];
+    while (b < m) {
+        const i0 = b;
+        while (b < m && U[b + 1] === U[b])
+            b++;
+        const mult = b - i0 + 1;
+        if (mult < p) {
+            const numer = U[b] - U[a];
+            const alphas = [];
+            for (let j = p; j > mult; j--) {
+                alphas[j - mult - 1] = numer / (U[a + j] - U[a]);
+            }
+            const r = p - mult;
+            for (let j = 1; j <= r; j++) {
+                const save = r - j;
+                const s = mult + j;
+                for (let k = p; k >= s; k--) {
+                    const alpha = alphas[k - s];
+                    const cur = segPoles[k];
+                    const prev = segPoles[k - 1];
+                    segPoles[k] = [
+                        alpha * cur[0] + (1 - alpha) * prev[0],
+                        alpha * cur[1] + (1 - alpha) * prev[1],
+                    ];
+                }
+                if (b < m)
+                    nextPoles[save] = clone(segPoles[p]);
+            }
+        }
+        segments.push(segPoles);
+        if (b < m) {
+            for (let i = p - mult; i <= p; i++) {
+                nextPoles[i] = clone(poles[b - p + i]);
+            }
+            segPoles = nextPoles;
+            nextPoles = [];
+            a = b;
+            b++;
+        }
+    }
+    return segments.map((sp) => c2dWrap(ow2d.makeBezier2d(sp)));
+}
+// ─── 2D bounding boxes ──────────────────────────────────────────────────────
+export function createBoundingBox2d() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- opaque type bridge
+    return ow2d.createBBox2d();
+}
+export function addCurveToBBox2d(bbox, curve, tolerance) {
+    ow2d.addCurveToBBox(bbox, c2d(curve), tolerance);
+}
+export function getBBox2dBounds(bbox) {
+    return { xMin: bbox.xMin, yMin: bbox.yMin, xMax: bbox.xMax, yMax: bbox.yMax };
+}
+export function mergeBBox2d(target, other) {
+    target.xMin = Math.min(target.xMin, other.xMin);
+    target.yMin = Math.min(target.yMin, other.yMin);
+    target.xMax = Math.max(target.xMax, other.xMax);
+    target.yMax = Math.max(target.yMax, other.yMax);
+}
+export function isBBox2dOut(a, b) {
+    return a.xMax < b.xMin || a.xMin > b.xMax || a.yMax < b.yMin || a.yMin > b.yMax;
+}
+export function isBBox2dOutPoint(bbox, x, y) {
+    return x < bbox.xMin || x > bbox.xMax || y < bbox.yMin || y > bbox.yMax;
+}
+// ─── Curve introspection ───────────────────────────────────────────────────
+export function getCurve2dCircleData(curve) {
+    let c = c2d(curve);
+    while (c.__bk2d === 'trimmed')
+        c = c.basis;
+    if (c.__bk2d === 'circle')
+        return { cx: c.cx, cy: c.cy, radius: c.radius, isDirect: c.sense };
+    return null;
+}
+export function getCurve2dEllipseData(curve) {
+    let c = c2d(curve);
+    while (c.__bk2d === 'trimmed')
+        c = c.basis;
+    if (c.__bk2d === 'ellipse')
+        return {
+            majorRadius: c.majorRadius,
+            minorRadius: c.minorRadius,
+            xAxisAngle: c.xDirAngle,
+            isDirect: c.sense,
+        };
+    return null;
+}
+export function getCurve2dBezierPoles(curve) {
+    let c = c2d(curve);
+    while (c.__bk2d === 'trimmed')
+        c = c.basis;
+    if (c.__bk2d === 'bezier')
+        return c.poles;
+    return null;
+}
+export function getCurve2dBezierDegree(curve) {
+    let c = c2d(curve);
+    while (c.__bk2d === 'trimmed')
+        c = c.basis;
+    if (c.__bk2d === 'bezier') {
+        return c.poles.length - 1;
+    }
+    return null;
+}
+export function serializeCurve2d(curve) {
+    return ow2d.serializeCurve2d(c2d(curve));
+}
+export function deserializeCurve2d(data) {
+    return c2dWrap(ow2d.deserializeCurve2d(data));
+}
+export function splitCurve2d(curve, params) {
+    const bounds = ow2d.curveBounds(c2d(curve));
+    const sorted = [bounds.first, ...params.sort((a, b) => a - b), bounds.last];
+    const result = [];
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const start = sorted[i] ?? bounds.first;
+        const end = sorted[i + 1] ?? bounds.last;
+        result.push(trimCurve2d(curve, start, end));
+    }
+    return result;
+}
+// ─── Lifting 2D curves to 3D edges ──────────────────────────────────────────
+// brepjs-patterns-disable: max-function-lines
+export function liftCurve2dToPlane(k, Module, curve, planeOrigin, planeZ, planeX) {
+    const cu = c2d(curve);
+    const [ox, oy, oz] = planeOrigin;
+    const [zx, zy, zz] = planeZ;
+    const [xx, xy, xz] = planeX;
+    const yx = zy * xz - zz * xy, yy = zz * xx - zx * xz, yz = zx * xy - zy * xx;
+    const lift = (u, v) => [
+        ox + u * xx + v * yx,
+        oy + u * xy + v * yy,
+        oz + u * xz + v * yz,
+    ];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- inspect curve internals
+    const bk2dType = cu.__bk2d;
+    if (bk2dType === 'line') {
+        const bounds = ow2d.curveBounds(cu);
+        const [u1, v1] = ow2d.evaluateCurve2d(cu, bounds.first);
+        const [u2, v2] = ow2d.evaluateCurve2d(cu, bounds.last);
+        const p1 = lift(u1, v1);
+        const p2 = lift(u2, v2);
+        return handle('edge', k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
+    }
+    if (bk2dType === 'trimmed') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- inspect trimmed basis
+        const trimmed = cu;
+        if (trimmed.basis && trimmed.basis.__bk2d === 'line') {
+            const [u1, v1] = ow2d.evaluateCurve2d(cu, 0);
+            const [u2, v2] = ow2d.evaluateCurve2d(cu, 1);
+            const p1 = lift(u1, v1);
+            const p2 = lift(u2, v2);
+            return handle('edge', k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
+        }
+        if (trimmed.basis && trimmed.basis.__bk2d === 'circle') {
+            // 3-point arc through three lifted points to ensure endpoint coordinates
+            // are bit-identical with the line branches' lifts (so MakeWire merges
+            // with default tolerance).
+            const bounds = ow2d.curveBounds(cu);
+            const [u1, v1] = ow2d.evaluateCurve2d(cu, bounds.first);
+            const [um, vm] = ow2d.evaluateCurve2d(cu, (bounds.first + bounds.last) / 2);
+            const [u2, v2] = ow2d.evaluateCurve2d(cu, bounds.last);
+            const p1 = lift(u1, v1);
+            const pm = lift(um, vm);
+            const p2 = lift(u2, v2);
+            return handle('edge', k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
+        }
+    }
+    if (bk2dType === 'circle') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- inspect circle data
+        const circleData = cu;
+        if (circleData.cx !== undefined && circleData.radius !== undefined) {
+            const [pcx, pcy, pcz] = lift(circleData.cx, circleData.cy);
+            return handle('edge', k.makeCircleEdge(pcx, pcy, pcz, zx, zy, zz, circleData.radius));
+        }
+        const bounds = ow2d.curveBounds(cu);
+        const [u1, v1] = ow2d.evaluateCurve2d(cu, bounds.first);
+        const [um, vm] = ow2d.evaluateCurve2d(cu, (bounds.first + bounds.last) / 2);
+        const [u2, v2] = ow2d.evaluateCurve2d(cu, bounds.last);
+        const p1 = lift(u1, v1);
+        const pm = lift(um, vm);
+        const p2 = lift(u2, v2);
+        return handle('edge', k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
+    }
+    // Fallback: sample + interpolate.
+    const bounds = ow2d.curveBounds(cu);
+    const nSamples = 24;
+    const dt = (bounds.last - bounds.first) / nSamples;
+    const pts = [];
+    for (let i = 0; i <= nSamples; i++) {
+        const [u, v] = ow2d.evaluateCurve2d(cu, bounds.first + i * dt);
+        const [px, py, pz] = lift(u, v);
+        pts.push(px, py, pz);
+    }
+    const vec = new Module.VectorDouble();
+    for (const p of pts)
+        vec.push_back(p);
+    try {
+        return handle('edge', k.interpolatePoints(vec, false));
+    }
+    finally {
+        vec.delete();
+    }
+}
+export function buildEdgeOnSurface(k, Module, curve, surface) {
+    const cu = c2d(curve);
+    const bounds = ow2d.curveBounds(cu);
+    // brepjs-patterns-disable: no-double-cast
+    const faceId = unwrap(surface);
+    const nSamples = 30;
+    const vec = new Module.VectorDouble();
+    for (let i = 0; i <= nSamples; i++) {
+        const t = bounds.first + ((bounds.last - bounds.first) * i) / nSamples;
+        const [u, v] = ow2d.evaluateCurve2d(cu, t);
+        const pt = k.pointOnSurface(faceId, u, v);
+        try {
+            vec.push_back(pt.get(0));
+            vec.push_back(pt.get(1));
+            vec.push_back(pt.get(2));
+        }
+        finally {
+            pt.delete();
+        }
+    }
+    try {
+        return handle('edge', k.interpolatePoints(vec, false));
+    }
+    finally {
+        vec.delete();
+    }
+}
+export function extractSurfaceFromFace(face) {
+    // occt-wasm uses faces as surface proxies — just pass through.
+    // brepjs-patterns-disable: no-double-cast
+    return face;
+}
+export function extractCurve2dFromEdge(k, edge, face) {
+    // occt-wasm exposes no native pcurve adaptor (BRepAdaptor_Curve2d), so
+    // reconstruct the edge's 2D curve on the face: sample the 3D edge, project each
+    // point onto the face surface via uvFromPoint (GeomAPI_ProjectPointOnSurf), and
+    // fit a 2D B-spline through the samples — the same projection approach brepkit
+    // uses. Accuracy: makeBSpline2d has no fitting solver and treats the samples as
+    // control poles, so a straight (LINE) edge is exact, while a curved pcurve (an
+    // arc/circle on a planar face, or any curved edge) is a smooth approximation
+    // that bows slightly inside the samples — the deviation shrinks as N rises.
+    // Point projection also snaps to the nearest UV branch, so a seam-crossing edge
+    // on a periodic surface (cylinder/cone) can jump branches.
+    const [first, last] = curveParameters(k, edge);
+    const N = 60;
+    const points = [];
+    for (let i = 0; i <= N; i++) {
+        const t = first + ((last - first) * i) / N;
+        const uv = uvFromPoint(k, face, curvePointAtParam(k, edge, t));
+        if (uv)
+            points.push(uv);
+    }
+    if (points.length < 2) {
+        throw new Error('occt-wasm: extractCurve2dFromEdge could not project the edge onto the face surface');
+    }
+    return makeBSpline2d(points);
+}
+export function buildCurves3d(k, wire) {
+    k.buildCurves3d(unwrap(wire));
+}
+export function fixWireOnFace(k, wire, face, tolerance) {
+    return handle('wire', k.fixWireOnFace(unwrap(wire), unwrap(face), tolerance));
+}
+//# sourceMappingURL=kernel2dOps.js.map