@faicad/faijs 0.31.1 → 0.32.3

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

@@ -1,731 +0,0 @@
-/**
- * 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