brepjs 15.2.0 → 15.2.2

package/dist/{shapeTypes-BLV4Ktdb.js → shapeTypes-Ct7W6h2X.js}

@@ -1,4 +1,4 @@
-import { _ as serializeCurve2d$2, a as curveTypeName, c as intersectCurves2dFn, d as makeEllipse2d$2, f as makeLine2d$2, g as scaleCurve2d$2, h as rotateCurve2d$2, i as curveBounds, l as makeBezier2d$2, m as mirrorAtPoint, n as addCurveToBBox, o as deserializeCurve2d$2, p as mirrorAcrossAxis, r as createBBox2d, s as evaluateCurve2d$2, u as makeCircle2d$2, v as tangentCurve2d, y as translateCurve2d$2 } from "./occtWasmAdapter-BBr9e9ej.js";
+import { _ as serializeCurve2d$2, a as curveTypeName, c as intersectCurves2dFn, d as makeEllipse2d$2, f as makeLine2d$2, g as scaleCurve2d$2, h as rotateCurve2d$2, i as curveBounds, l as makeBezier2d$2, m as mirrorAtPoint, n as addCurveToBBox, o as deserializeCurve2d$2, p as mirrorAcrossAxis, r as createBBox2d, s as evaluateCurve2d$2, u as makeCircle2d$2, v as tangentCurve2d, y as translateCurve2d$2 } from "./occtWasmAdapter-BRiWV_v0.js";
 import { A as ok, b as err } from "./errors-DboJwVCf.js";
 //#region src/kernel/kernel2dTypes.ts
 /** Check if the kernel supports 2D geometry operations. */
@@ -3197,612 +3197,793 @@ function createAxis3$1(oc, ox, oy, oz, zx, zy, zz, xx, xy, xz) {
 }
 //#endregion
 //#region src/kernel/occt/kernel2dOps.ts
-function mapContinuity(oc, continuity) {
-	switch (continuity) {
-		case "C0": return oc.GeomAbs_Shape.GeomAbs_C0;
-		case "C1": return oc.GeomAbs_Shape.GeomAbs_C1;
-		case "C2": return oc.GeomAbs_Shape.GeomAbs_C2;
-		case "C3": return oc.GeomAbs_Shape.GeomAbs_C3;
-	}
+var noop$1 = () => {};
+/** Cast opaque Curve2dHandle to internal Curve2dObj. */
+function c2d$1(handle) {
+	return handle;
 }
-/**
-* Extract a numeric value from an OCCT Emscripten enum.
-* Emscripten returns enum objects with a `.value` property, not raw numbers.
-*/
-function unwrapOcctEnum(val) {
-	return typeof val === "number" ? val : Number(val?.value ?? val);
+/** Unwrap trimmed curve wrappers to get the basis geometry. */
+function c2dBasis$1(handle) {
+	let c = c2d$1(handle);
+	while (c.__bk2d === "trimmed") c = c.basis;
+	return c;
 }
-/**
-* Get the GeomAbs_CurveType index for a 2D curve via a temporary adaptor.
-* Caller avoids repeating the adaptor-create / GetType / unwrap / delete cycle.
-*/
-function getCurve2dTypeIndex(oc, curve) {
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	const idx = unwrapOcctEnum(adaptor.GetType());
-	adaptor.delete();
-	return idx;
+/** Cast opaque BBox2dHandle to internal BBox2d. */
+function bb2d$1(handle) {
+	return handle;
 }
-/** Wrap a raw Geom2d_Curve in a Handle_Geom2d_Curve. */
-function wrapCurve2dHandle$1(oc, handle) {
-	const inner = handle.get();
-	return new oc.Handle_Geom2d_Curve_2(inner);
+function createPoint2d$1(x, y) {
+	return {
+		x,
+		y
+	};
 }
-/** Create a Geom2dAdaptor_Curve for algorithmic queries. Caller must delete. */
-function createCurve2dAdaptor$1(oc, handle) {
-	return new oc.Geom2dAdaptor_Curve_2(handle);
+function createDirection2d$1(x, y) {
+	const l = Math.sqrt(x * x + y * y);
+	if (l < 1e-15) throw new Error("occt: createDirection2d called with zero-length vector");
+	return {
+		x: x / l,
+		y: y / l
+	};
 }
-function createPoint2d$1(oc, x, y) {
-	return new oc.gp_Pnt2d_3(x, y);
+function createVector2d$1(x, y) {
+	return {
+		x,
+		y
+	};
 }
-function createDirection2d$1(oc, x, y) {
-	return new oc.gp_Dir2d_5(x, y);
+function createAxis2d$1(px, py, dx, dy) {
+	return {
+		px,
+		py,
+		dx,
+		dy,
+		delete: noop$1
+	};
 }
-function createVector2d$1(oc, x, y) {
-	return new oc.gp_Vec2d_4(x, y);
+function wrapCurve2dHandle$1(handle) {
+	return handle;
 }
-function createAxis2d$1(oc, px, py, dx, dy) {
-	const pnt = new oc.gp_Pnt2d_3(px, py);
-	const dir = new oc.gp_Dir2d_5(dx, dy);
-	const axis = new oc.gp_Ax2d_2(pnt, dir);
-	pnt.delete();
-	dir.delete();
-	return axis;
+function createCurve2dAdaptor$1(handle) {
+	return handle;
 }
-function makeLine2d$1(oc, x1, y1, x2, y2) {
-	const p1 = new oc.gp_Pnt2d_3(x1, y1);
-	const p2 = new oc.gp_Pnt2d_3(x2, y2);
-	const maker = new oc.GCE2d_MakeSegment_1(p1, p2);
-	const curve = maker.Value();
-	maker.delete();
-	p1.delete();
-	p2.delete();
-	return curve;
+function makeLine2d$1(x1, y1, x2, y2) {
+	return makeLine2d$2(x1, y1, x2, y2);
 }
-function makeCircle2d$1(oc, cx, cy, radius, sense = true) {
-	const center = new oc.gp_Pnt2d_3(cx, cy);
-	const maker = new oc.GCE2d_MakeCircle_7(center, radius, sense);
-	const curve = maker.Value();
-	maker.delete();
-	center.delete();
-	return curve;
+function makeCircle2d$1(cx, cy, radius, sense) {
+	return makeCircle2d$2(cx, cy, radius, sense);
 }
-function makeArc2dThreePoints$1(oc, x1, y1, xm, ym, x2, y2) {
-	const p1 = new oc.gp_Pnt2d_3(x1, y1);
-	const pm = new oc.gp_Pnt2d_3(xm, ym);
-	const p2 = new oc.gp_Pnt2d_3(x2, y2);
-	const maker = new oc.GCE2d_MakeArcOfCircle_4(p1, pm, p2);
-	try {
-		if (!maker.IsDone()) throw new Error("makeArc2dThreePoints: construction failed (collinear points?)");
-		return maker.Value();
-	} finally {
-		maker.delete();
-		p2.delete();
-		pm.delete();
-		p1.delete();
+function makeArc2dThreePoints$1(x1, y1, xm, ym, x2, y2) {
+	const d = 2 * (x1 * (ym - y2) + xm * (y2 - y1) + x2 * (y1 - ym));
+	if (Math.abs(d) < 1e-12) return makeLine2d$2(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 = makeCircle2d$2(cx, cy, radius, sense);
+	if (!sense) {
+		const tStart = -a1;
+		let tEnd = -a2;
+		if (tEnd < tStart - 1e-9) tEnd += 2 * Math.PI;
+		return {
+			__bk2d: "trimmed",
+			basis: circle,
+			tStart,
+			tEnd
+		};
 	}
+	let tEnd = a2;
+	if (tEnd < a1 - 1e-9) tEnd += 2 * Math.PI;
+	return {
+		__bk2d: "trimmed",
+		basis: circle,
+		tStart: a1,
+		tEnd
+	};
 }
-function makeArc2dTangent$1(oc, startX, startY, tangentX, tangentY, endX, endY) {
-	const start = new oc.gp_Pnt2d_3(startX, startY);
-	const tangent = new oc.gp_Vec2d_4(tangentX, tangentY);
-	const end = new oc.gp_Pnt2d_3(endX, endY);
-	const maker = new oc.GCE2d_MakeArcOfCircle_5(start, tangent, end);
-	try {
-		if (!maker.IsDone()) throw new Error("makeArc2dTangent: construction failed");
-		return maker.Value();
-	} finally {
-		maker.delete();
-		end.delete();
-		tangent.delete();
-		start.delete();
+function makeArc2dTangent$1(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$2(sx, sy, ex, ey);
+	const t = -(dx * dx + dy * dy) / 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;
 	}
+	return makeArc2dThreePoints$1(sx, sy, cx + radius * Math.cos(aMid), cy + radius * Math.sin(aMid), ex, ey);
 }
-function makeEllipse2d$1(oc, cx, cy, majorRadius, minorRadius, xDirX = 1, xDirY = 0, sense = true) {
-	const center = new oc.gp_Pnt2d_3(cx, cy);
-	const dir = new oc.gp_Dir2d_5(xDirX, xDirY);
-	const ax = new oc.gp_Ax2d_2(center, dir);
-	const elips = new oc.gp_Elips2d_2(ax, majorRadius, minorRadius, sense);
-	const maker = new oc.GCE2d_MakeEllipse_1(elips);
-	try {
-		if (!maker.IsDone()) throw new Error("makeEllipse2d: construction failed");
-		return maker.Value();
-	} finally {
-		maker.delete();
-		elips.delete();
-		ax.delete();
-		dir.delete();
-		center.delete();
-	}
+function makeEllipse2d$1(cx, cy, major, minor, xDirX, xDirY, sense) {
+	return makeEllipse2d$2(cx, cy, major, minor, xDirX, xDirY, sense);
 }
-function makeEllipseArc2d$1(oc, cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX = 1, xDirY = 0, sense = true) {
-	const center = new oc.gp_Pnt2d_3(cx, cy);
-	const dir = new oc.gp_Dir2d_5(xDirX, xDirY);
-	const ax = new oc.gp_Ax2d_2(center, dir);
-	const elips = new oc.gp_Elips2d_2(ax, majorRadius, minorRadius, true);
-	const maker = new oc.GCE2d_MakeArcOfEllipse_1(elips, startAngle, endAngle, sense);
-	try {
-		if (!maker.IsDone()) throw new Error("makeEllipseArc2d: construction failed");
-		return maker.Value();
-	} finally {
-		maker.delete();
-		elips.delete();
-		ax.delete();
-		dir.delete();
-		center.delete();
-	}
+function makeEllipseArc2d$1(cx, cy, major, minor, start, end, xDirX, xDirY, sense) {
+	return {
+		__bk2d: "trimmed",
+		basis: makeEllipse2d$2(cx, cy, major, minor, xDirX, xDirY, sense),
+		tStart: start,
+		tEnd: end
+	};
 }
-function makeBezier2d$1(oc, points) {
-	const arr = new oc.TColgp_Array1OfPnt2d_2(1, points.length);
-	for (let i = 0; i < points.length; i++) {
-		const p = points[i];
-		const gpPnt = new oc.gp_Pnt2d_3(p[0], p[1]);
-		arr.SetValue_1(i + 1, gpPnt);
-		gpPnt.delete();
-	}
-	const bezier = new oc.Geom2d_BezierCurve_1(arr);
-	arr.delete();
-	return new oc.Handle_Geom2d_Curve_2(bezier);
+function makeBezier2d$1(points) {
+	return makeBezier2d$2(points);
 }
-function makeBSpline2d$1(oc, points, options = {}) {
-	const { degMin = 1, degMax = 3, continuity = "C2", tolerance = .001, smoothing = null } = options;
-	const pnts = new oc.TColgp_Array1OfPnt2d_2(1, points.length);
-	for (let i = 0; i < points.length; i++) {
-		const p = points[i];
-		const gpPnt = new oc.gp_Pnt2d_3(p[0], p[1]);
-		pnts.SetValue_1(i + 1, gpPnt);
-		gpPnt.delete();
-	}
-	let splineBuilder;
-	if (smoothing) splineBuilder = new oc.Geom2dAPI_PointsToBSpline_6(pnts, smoothing[0], smoothing[1], smoothing[2], degMax, mapContinuity(oc, continuity), tolerance);
-	else splineBuilder = new oc.Geom2dAPI_PointsToBSpline_2(pnts, degMin, degMax, mapContinuity(oc, continuity), tolerance);
-	pnts.delete();
-	if (!splineBuilder.IsDone()) {
-		splineBuilder.delete();
-		throw new Error("B-spline 2D approximation failed");
+function makeBSpline2d$1(points, _options) {
+	const n = points.length;
+	const degree = Math.min(3, n - 1);
+	const knots = [];
+	const mults = [];
+	knots.push(0);
+	mults.push(degree + 1);
+	const nInternal = n - degree - 1;
+	for (let i = 1; i <= nInternal; i++) {
+		knots.push(i / (nInternal + 1));
+		mults.push(1);
 	}
-	const curve = splineBuilder.Curve();
-	splineBuilder.delete();
-	return curve;
+	knots.push(1);
+	mults.push(degree + 1);
+	return {
+		__bk2d: "bspline",
+		poles: [...points],
+		knots,
+		multiplicities: mults,
+		degree,
+		isPeriodic: false
+	};
 }
-function evaluateCurve2d$1(_oc, curve, param) {
-	const p = curve.get().Value(param);
-	const result = [p.X(), p.Y()];
-	p.delete();
-	return result;
+function evaluateCurve2d$1(curve, param) {
+	return evaluateCurve2d$2(c2d$1(curve), param);
 }
-function evaluateCurve2dD1$1(oc, curve, param) {
-	const inner = curve.get();
-	const pnt = new oc.gp_Pnt2d_1();
-	const vec = new oc.gp_Vec2d_1();
-	inner.D1(param, pnt, vec);
-	const result = {
-		point: [pnt.X(), pnt.Y()],
-		tangent: [vec.X(), vec.Y()]
+function evaluateCurve2dD1$1(curve, param) {
+	return {
+		point: evaluateCurve2d$2(c2d$1(curve), param),
+		tangent: tangentCurve2d(c2d$1(curve), param)
 	};
-	pnt.delete();
-	vec.delete();
-	return result;
 }
-function getCurve2dBounds$1(_oc, curve) {
-	const inner = curve.get();
+function getCurve2dBounds$1(curve) {
+	return curveBounds(c2d$1(curve));
+}
+function getCurve2dType$1(curve) {
+	return curveTypeName(c2dBasis$1(curve));
+}
+function trimCurve2d$1(curve, start, end) {
 	return {
-		first: inner.FirstParameter(),
-		last: inner.LastParameter()
+		__bk2d: "trimmed",
+		basis: c2d$1(curve),
+		tStart: start,
+		tEnd: end
 	};
 }
-var CURVE_TYPE_NAMES = [
-	"LINE",
-	"CIRCLE",
-	"ELLIPSE",
-	"HYPERBOLA",
-	"PARABOLA",
-	"BEZIER_CURVE",
-	"BSPLINE_CURVE",
-	"OFFSET_CURVE",
-	"OTHER_CURVE"
-];
-function getCurve2dType$1(oc, curve) {
-	return CURVE_TYPE_NAMES[getCurve2dTypeIndex(oc, curve)] ?? "OTHER_CURVE";
+function copyCurve2d$1(curve) {
+	return JSON.parse(JSON.stringify(curve));
 }
-function trimCurve2d$1(oc, curve, start, end) {
-	const trimmed = new oc.Geom2d_TrimmedCurve(curve, start, end, true, true);
-	return new oc.Handle_Geom2d_Curve_2(trimmed);
+function offsetCurve2d$1(curve, offset) {
+	const c = c2d$1(curve);
+	const bounds = curveBounds(c);
+	const N = 30;
+	const poles = [];
+	for (let i = 0; i <= N; i++) {
+		const t = bounds.first + (bounds.last - bounds.first) * i / N;
+		const [px, py] = evaluateCurve2d$2(c, t);
+		const [tvx, tvy] = tangentCurve2d(c, t);
+		const tLen = Math.sqrt(tvx * tvx + tvy * tvy);
+		if (tLen > 1e-12) poles.push([px - tvy / tLen * offset, py + tvx / tLen * offset]);
+		else poles.push([px, py]);
+	}
+	return makeBSpline2d$1(poles);
 }
-function reverseCurve2d$1(_oc, curve) {
-	curve.get().Reverse();
+function translateCurve2d$1(curve, dx, dy) {
+	return translateCurve2d$2(c2d$1(curve), dx, dy);
 }
-function copyCurve2d$1(_oc, curve) {
-	return curve.get().Copy();
+function rotateCurve2d$1(curve, angle, cx, cy) {
+	return rotateCurve2d$2(c2d$1(curve), angle, cx, cy);
 }
-function offsetCurve2d$1(oc, curve, offset) {
-	const offsetCurve = new oc.Geom2d_OffsetCurve_1(curve, offset, true);
-	return new oc.Handle_Geom2d_Curve_2(offsetCurve);
+function scaleCurve2d$1(curve, factor, cx, cy) {
+	return scaleCurve2d$2(c2d$1(curve), factor, cx, cy);
 }
-function transformCurve(oc, curve, trsf) {
-	const gtrsf = new oc.gp_GTrsf2d_2(trsf);
-	const result = oc.GeomLib.GTransform(curve, gtrsf);
-	gtrsf.delete();
-	trsf.delete();
-	return result;
+function mirrorCurve2dAtPoint$1(curve, cx, cy) {
+	return mirrorAtPoint(c2d$1(curve), cx, cy);
 }
-function translateCurve2d$1(oc, curve, dx, dy) {
-	const v = new oc.gp_Vec2d_4(dx, dy);
-	const trsf = new oc.gp_Trsf2d_1();
-	trsf.SetTranslation_1(v);
-	v.delete();
-	return transformCurve(oc, curve, trsf);
-}
-function rotateCurve2d$1(oc, curve, angle, cx, cy) {
-	const center = new oc.gp_Pnt2d_3(cx, cy);
-	const trsf = new oc.gp_Trsf2d_1();
-	trsf.SetRotation(center, angle);
-	center.delete();
-	return transformCurve(oc, curve, trsf);
+function mirrorCurve2dAcrossAxis$1(curve, ox, oy, dx, dy) {
+	return mirrorAcrossAxis(c2d$1(curve), ox, oy, dx, dy);
 }
-function scaleCurve2d$1(oc, curve, factor, cx, cy) {
-	const center = new oc.gp_Pnt2d_3(cx, cy);
-	const trsf = new oc.gp_Trsf2d_1();
-	trsf.SetScale(center, factor);
-	center.delete();
-	return transformCurve(oc, curve, trsf);
+function affinityTransform2d$1(curve, ox, oy, dx, dy, ratio) {
+	return transformCurve2dGeneral$1(curve, createAffinityGTrsf2d$1(ox, oy, dx, dy, ratio));
 }
-function mirrorCurve2dAtPoint$1(oc, curve, cx, cy) {
-	const center = new oc.gp_Pnt2d_3(cx, cy);
-	const trsf = new oc.gp_Trsf2d_1();
-	trsf.SetMirror_1(center);
-	center.delete();
-	return transformCurve(oc, curve, trsf);
-}
-function mirrorCurve2dAcrossAxis$1(oc, curve, originX, originY, dirX, dirY) {
-	const origin = new oc.gp_Pnt2d_3(originX, originY);
-	const dir = new oc.gp_Dir2d_5(dirX, dirY);
-	const ax = new oc.gp_Ax2d_2(origin, dir);
-	const trsf = new oc.gp_Trsf2d_1();
-	trsf.SetMirror_2(ax);
-	ax.delete();
-	dir.delete();
-	origin.delete();
-	return transformCurve(oc, curve, trsf);
-}
-function affinityTransform2d$1(oc, curve, axisOriginX, axisOriginY, axisDirX, axisDirY, ratio) {
-	const origin = new oc.gp_Pnt2d_3(axisOriginX, axisOriginY);
-	const dir = new oc.gp_Dir2d_5(axisDirX, axisDirY);
-	const ax = new oc.gp_Ax2d_2(origin, dir);
-	const gtrsf = new oc.gp_GTrsf2d_1();
-	gtrsf.SetAffinity(ax, ratio);
-	ax.delete();
-	dir.delete();
-	origin.delete();
-	const result = oc.GeomLib.GTransform(curve, gtrsf);
-	gtrsf.delete();
-	return result;
+function _gtrsf$1(m, tx, ty) {
+	return {
+		m,
+		tx,
+		ty,
+		delete: noop$1
+	};
 }
-/** Helper: wrap a gp_Trsf2d in a gp_GTrsf2d and delete the trsf. */
-function wrapTrsf2dAsGTrsf2d(oc, trsf) {
-	const gtrsf = new oc.gp_GTrsf2d_2(trsf);
-	trsf.delete();
-	return gtrsf;
+function createIdentityGTrsf2d$1() {
+	return _gtrsf$1([
+		1,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		1
+	], 0, 0);
 }
-function createIdentityGTrsf2d$1(oc) {
-	return new oc.gp_GTrsf2d_1();
+function createAffinityGTrsf2d$1(ox, oy, dx, dy, ratio) {
+	const len = Math.sqrt(dx * dx + dy * dy);
+	if (len < 1e-15) return createIdentityGTrsf2d$1();
+	const px = -dy / len, py = dx / len;
+	const k = ratio - 1;
+	const m = [
+		1 + k * px * px,
+		k * px * py,
+		0,
+		k * py * px,
+		1 + k * py * py,
+		0,
+		0,
+		0,
+		1
+	];
+	return _gtrsf$1(m, ox - m[0] * ox - m[1] * oy, oy - m[3] * ox - m[4] * oy);
 }
-function createAffinityGTrsf2d$1(oc, originX, originY, dirX, dirY, ratio) {
-	const origin = new oc.gp_Pnt2d_3(originX, originY);
-	const dir = new oc.gp_Dir2d_5(dirX, dirY);
-	const ax = new oc.gp_Ax2d_2(origin, dir);
-	const gtrsf = new oc.gp_GTrsf2d_1();
-	gtrsf.SetAffinity(ax, ratio);
-	ax.delete();
-	dir.delete();
-	origin.delete();
-	return gtrsf;
-}
-function createTranslationGTrsf2d$1(oc, dx, dy) {
-	const v = new oc.gp_Vec2d_4(dx, dy);
-	const trsf = new oc.gp_Trsf2d_1();
-	trsf.SetTranslation_1(v);
-	v.delete();
-	return wrapTrsf2dAsGTrsf2d(oc, trsf);
-}
-function createMirrorGTrsf2d$1(oc, cx, cy, mode, originX = 0, originY = 0, dirX = 1, dirY = 0) {
-	const trsf = new oc.gp_Trsf2d_1();
-	if (mode === "point") {
-		const p = new oc.gp_Pnt2d_3(cx, cy);
-		trsf.SetMirror_1(p);
-		p.delete();
-	} else {
-		const p = new oc.gp_Pnt2d_3(originX, originY);
-		const dir = new oc.gp_Dir2d_5(dirX, dirY);
-		const ax = new oc.gp_Ax2d_2(p, dir);
-		trsf.SetMirror_2(ax);
-		ax.delete();
-		dir.delete();
-		p.delete();
-	}
-	return wrapTrsf2dAsGTrsf2d(oc, trsf);
-}
-function createRotationGTrsf2d$1(oc, angle, cx, cy) {
-	const p = new oc.gp_Pnt2d_3(cx, cy);
-	const trsf = new oc.gp_Trsf2d_1();
-	trsf.SetRotation(p, angle);
-	p.delete();
-	return wrapTrsf2dAsGTrsf2d(oc, trsf);
-}
-function createScaleGTrsf2d$1(oc, factor, cx, cy) {
-	const p = new oc.gp_Pnt2d_3(cx, cy);
-	const trsf = new oc.gp_Trsf2d_1();
-	trsf.SetScale(p, factor);
-	p.delete();
-	return wrapTrsf2dAsGTrsf2d(oc, trsf);
-}
-function setGTrsf2dTranslationPart$1(oc, gtrsf, dx, dy) {
-	const xy = new oc.gp_XY_2(dx, dy);
-	gtrsf.SetTranslationPart(xy);
-	xy.delete();
+function createTranslationGTrsf2d$1(dx, dy) {
+	return _gtrsf$1([
+		1,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		1
+	], dx, dy);
 }
-function multiplyGTrsf2d$1(_oc, base, other) {
-	base.Multiply(other);
+function createMirrorGTrsf2d$1(cx, cy, mode, ox, oy, dx, dy) {
+	if (mode === "axis" && dx !== void 0 && dy !== void 0) {
+		const len = Math.sqrt(dx * dx + dy * dy);
+		const nx = dx / len, ny = dy / len;
+		const m = [
+			2 * nx * nx - 1,
+			2 * nx * ny,
+			0,
+			2 * nx * ny,
+			2 * ny * ny - 1,
+			0,
+			0,
+			0,
+			1
+		];
+		const apx = ox ?? cx, apy = oy ?? cy;
+		return _gtrsf$1(m, apx - m[0] * apx - m[1] * apy, apy - m[3] * apx - m[4] * apy);
+	}
+	return _gtrsf$1([
+		-1,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		0,
+		0,
+		1
+	], 2 * cx, 2 * cy);
 }
-function transformCurve2dGeneral$1(oc, curve, gtrsf) {
-	return oc.GeomLib.GTransform(curve, gtrsf);
+function createRotationGTrsf2d$1(angle, cx, cy) {
+	const c = Math.cos(angle), s = Math.sin(angle);
+	return _gtrsf$1([
+		c,
+		-s,
+		0,
+		s,
+		c,
+		0,
+		0,
+		0,
+		1
+	], cx - c * cx + s * cy, cy - s * cx - c * cy);
+}
+function createScaleGTrsf2d$1(factor, cx, cy) {
+	return _gtrsf$1([
+		factor,
+		0,
+		0,
+		0,
+		factor,
+		0,
+		0,
+		0,
+		1
+	], cx * (1 - factor), cy * (1 - factor));
+}
+function setGTrsf2dTranslationPart$1(gtrsf, dx, dy) {
+	gtrsf.tx = dx;
+	gtrsf.ty = dy;
+}
+function multiplyGTrsf2d$1(base, other) {
+	const a = base.m, b = other.m;
+	base.m = [
+		a[0] * b[0] + a[1] * b[3] + a[2] * b[6],
+		a[0] * b[1] + a[1] * b[4] + a[2] * b[7],
+		a[0] * b[2] + a[1] * b[5] + a[2] * b[8],
+		a[3] * b[0] + a[4] * b[3] + a[5] * b[6],
+		a[3] * b[1] + a[4] * b[4] + a[5] * b[7],
+		a[3] * b[2] + a[4] * b[5] + a[5] * b[8],
+		a[6] * b[0] + a[7] * b[3] + a[8] * b[6],
+		a[6] * b[1] + a[7] * b[4] + a[8] * b[7],
+		a[6] * b[2] + a[7] * b[5] + a[8] * b[8]
+	];
+	const oldTx = base.tx, oldTy = base.ty;
+	const otx = Number(other.tx) || 0, oty = Number(other.ty) || 0;
+	base.tx = a[0] * otx + a[1] * oty + oldTx;
+	base.ty = a[3] * otx + a[4] * oty + oldTy;
+}
+function transformCurve2dGeneral$1(curve, gtrsf) {
+	const c = c2d$1(curve);
+	const m = gtrsf.m ?? [
+		1,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		1
+	];
+	const tx = Number(gtrsf.tx) || 0, ty = Number(gtrsf.ty) || 0;
+	if (Math.abs(m[0] - 1) < 1e-12 && Math.abs(m[4] - 1) < 1e-12 && Math.abs(m[1]) < 1e-12 && Math.abs(m[3]) < 1e-12) return translateCurve2d$2(c, tx, ty);
+	const bounds = curveBounds(c);
+	const N = 20;
+	const pts = [];
+	for (let i = 0; i <= N; i++) {
+		const [px, py] = evaluateCurve2d$2(c, bounds.first + (bounds.last - bounds.first) * i / N);
+		pts.push([m[0] * px + m[1] * py + tx, m[3] * px + m[4] * py + ty]);
+	}
+	return makeBezier2d$2(pts);
+}
+function intersectCurves2d$1(c1, c2, tolerance) {
+	const result = intersectCurves2dFn(c2d$1(c1), c2d$1(c2), tolerance);
+	const segments = result.segments.map((s) => Object.assign(s, { delete() {} }));
+	return {
+		points: result.points,
+		segments
+	};
+}
+function projectPointOnCurve2d$1(curve, x, y) {
+	const c = c2d$1(curve);
+	const bounds = curveBounds(c);
+	if (c.__bk2d === "line") {
+		const ddx = x - c.ox;
+		const ddy = y - c.oy;
+		const t = Math.max(bounds.first, Math.min(bounds.last, ddx * c.dx + ddy * c.dy));
+		const [px, py] = evaluateCurve2d$2(c, t);
+		return {
+			param: t,
+			distance: Math.sqrt((px - x) ** 2 + (py - y) ** 2)
+		};
+	}
+	if (c.__bk2d === "circle") {
+		const angle = Math.atan2(y - c.cy, x - c.cx);
+		let t = c.sense ? angle : -angle;
+		while (t < 0) t += 2 * Math.PI;
+		while (t > 2 * Math.PI) t -= 2 * Math.PI;
+		const [px, py] = evaluateCurve2d$2(c, t);
+		return {
+			param: t,
+			distance: Math.sqrt((px - x) ** 2 + (py - y) ** 2)
+		};
+	}
+	if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
+	let bestT = bounds.first;
+	let bestDist = Infinity;
+	const N = 200;
+	const dt = (bounds.last - bounds.first) / N;
+	for (let i = 0; i <= N; i++) {
+		const t = bounds.first + i * dt;
+		const [px, py] = evaluateCurve2d$2(c, t);
+		const dd = (px - x) ** 2 + (py - y) ** 2;
+		if (dd < bestDist) {
+			bestDist = dd;
+			bestT = t;
+		}
+	}
+	for (let iter = 0; iter < 10; iter++) {
+		const [px, py] = evaluateCurve2d$2(c, bestT);
+		const [tvx, tvy] = tangentCurve2d(c, bestT);
+		const dot = (px - x) * tvx + (py - y) * tvy;
+		const ddenom = tvx * tvx + tvy * tvy;
+		if (ddenom < 1e-20) break;
+		const step = dot / ddenom;
+		const newT = Math.max(bounds.first, Math.min(bounds.last, bestT - step));
+		if (Math.abs(newT - bestT) < 1e-14) break;
+		bestT = newT;
+	}
+	const [fx, fy] = evaluateCurve2d$2(c, bestT);
+	return {
+		param: bestT,
+		distance: Math.sqrt((fx - x) ** 2 + (fy - y) ** 2)
+	};
+}
+function distanceBetweenCurves2d$1(c1, c2, p1s, p1e, p2s, p2e) {
+	const curve1 = c2d$1(c1);
+	const curve2 = c2d$1(c2);
+	let bestT1 = p1s;
+	let bestT2 = p2s;
+	let minDistSq = Infinity;
+	const N = 50;
+	for (let i = 0; i <= N; i++) {
+		const t1 = p1s + (p1e - p1s) * i / N;
+		const [x1, y1] = evaluateCurve2d$2(curve1, t1);
+		for (let j = 0; j <= N; j++) {
+			const t2 = p2s + (p2e - p2s) * j / N;
+			const [x2, y2] = evaluateCurve2d$2(curve2, t2);
+			const dd = (x2 - x1) ** 2 + (y2 - y1) ** 2;
+			if (dd < minDistSq) {
+				minDistSq = dd;
+				bestT1 = t1;
+				bestT2 = t2;
+			}
+		}
+	}
+	let t1 = bestT1;
+	let t2 = bestT2;
+	for (let iter = 0; iter < 20; iter++) {
+		const [x2, y2] = evaluateCurve2d$2(curve2, t2);
+		const proj1 = projectPointOnCurve2d$1(c1, x2, y2);
+		if (proj1) {
+			const newT1 = Math.max(p1s, Math.min(p1e, proj1.param));
+			const converged1 = Math.abs(newT1 - t1) < 1e-12;
+			t1 = newT1;
+			if (converged1) break;
+		}
+		const [x1, y1] = evaluateCurve2d$2(curve1, t1);
+		const proj2 = projectPointOnCurve2d$1(c2, x1, y1);
+		if (proj2) {
+			const newT2 = Math.max(p2s, Math.min(p2e, proj2.param));
+			const converged2 = Math.abs(newT2 - t2) < 1e-12;
+			t2 = newT2;
+			if (converged2) break;
+		}
+	}
+	const [fx1, fy1] = evaluateCurve2d$2(curve1, t1);
+	const [fx2, fy2] = evaluateCurve2d$2(curve2, t2);
+	return Math.sqrt((fx2 - fx1) ** 2 + (fy2 - fy1) ** 2);
 }
-function intersectCurves2d$1(oc, c1, c2, tolerance) {
-	const intersector = new oc.Geom2dAPI_InterCurveCurve_1();
-	intersector.Init_1(c1, c2, tolerance);
-	const points = [];
-	const nPoints = intersector.NbPoints();
-	for (let i = 1; i <= nPoints; i++) {
-		const p = intersector.Point(i);
-		points.push([p.X(), p.Y()]);
-		p.delete();
-	}
-	const segments = [];
-	const nSegments = intersector.NbSegments();
-	for (let i = 1; i <= nSegments; i++) {
-		const h1 = new oc.Handle_Geom2d_Curve_1();
-		const h2 = new oc.Handle_Geom2d_Curve_1();
-		try {
-			intersector.Segment(i, h1, h2);
-			segments.push(h1);
-			h2.delete();
-		} catch {
-			h1.delete();
-			h2.delete();
+function approximateCurve2dAsBSpline$1(curve, tol, cont, maxSeg) {
+	const c = c2d$1(curve);
+	const bounds = curveBounds(c);
+	const degree = Math.max(3, {
+		C0: 1,
+		C1: 2,
+		C2: 3,
+		C3: 4
+	}[cont] ?? 4);
+	let curN = Math.max(100, maxSeg * 10);
+	let poles = [];
+	let maxErr = Infinity;
+	for (let attempt = 0; attempt < 3 && maxErr > tol; attempt++) {
+		poles = [];
+		for (let i = 0; i <= curN; i++) {
+			const t = bounds.first + (bounds.last - bounds.first) * i / curN;
+			poles.push(evaluateCurve2d$2(c, t));
+		}
+		maxErr = 0;
+		for (let i = 0; i < curN; i++) {
+			const [ex, ey] = evaluateCurve2d$2(c, bounds.first + (bounds.last - bounds.first) * (i + .5) / curN);
+			const p0 = poles[i];
+			const p1 = poles[i + 1];
+			const mx = (p0[0] + p1[0]) / 2;
+			const my = (p0[1] + p1[1]) / 2;
+			const err = Math.sqrt((ex - mx) ** 2 + (ey - my) ** 2);
+			if (err > maxErr) maxErr = err;
 		}
+		if (maxErr > tol) curN = Math.min(curN * 2, 500);
 	}
-	intersector.delete();
-	return {
-		points,
-		segments
-	};
+	return makeBSpline2d$1(poles, { degMax: degree });
 }
-function projectPointOnCurve2d$1(oc, curve, x, y) {
-	const pnt = new oc.gp_Pnt2d_3(x, y);
-	const projector = new oc.Geom2dAPI_ProjectPointOnCurve_2(pnt, curve);
-	pnt.delete();
-	let result = null;
-	try {
-		if (projector.NbPoints() > 0) result = {
-			param: projector.LowerDistanceParameter(),
-			distance: projector.LowerDistance()
+function decomposeBSpline2dToBeziers$1(curve) {
+	const c = c2dBasis$1(curve);
+	if (c.__bk2d === "bezier") return [curve];
+	if (c.__bk2d !== "bspline") return decomposeBSpline2dToBeziers$1(approximateCurve2dAsBSpline$1(curve, 1e-6, "C2", 10));
+	const trimBounds = curveBounds(c2d$1(curve));
+	const first = trimBounds.first;
+	const last = trimBounds.last;
+	const internalKnots = [];
+	for (const k of c.knots) if (k > first + 1e-12 && k < last - 1e-12) internalKnots.push(k);
+	const breakpoints = [
+		first,
+		...internalKnots,
+		last
+	];
+	const result = [];
+	for (let i = 0; i < breakpoints.length - 1; i++) {
+		const t0 = breakpoints[i];
+		const t1 = breakpoints[i + 1];
+		const span = t1 - t0;
+		if (span < 1e-15) continue;
+		const p0 = evaluateCurve2d$2(c, t0);
+		const p3 = evaluateCurve2d$2(c, t1);
+		const tan0 = tangentCurve2d(c, t0);
+		const tan3 = tangentCurve2d(c, t1);
+		const s = span / 3;
+		const bezier = {
+			__bk2d: "bezier",
+			poles: [
+				p0,
+				[p0[0] + tan0[0] * s, p0[1] + tan0[1] * s],
+				[p3[0] - tan3[0] * s, p3[1] - tan3[1] * s],
+				p3
+			]
 		};
-	} catch {}
-	projector.delete();
-	return result;
-}
-function distanceBetweenCurves2d$1(oc, c1, c2, p1Start, p1End, p2Start, p2End) {
-	const extrema = new oc.Geom2dAPI_ExtremaCurveCurve(c1, c2, p1Start, p1End, p2Start, p2End);
-	let distance;
-	try {
-		distance = extrema.LowerDistance();
-	} catch {
-		distance = Infinity;
+		result.push(bezier);
 	}
-	extrema.delete();
-	return distance;
-}
-function approximateCurve2dAsBSpline$1(oc, curve, tolerance, continuity, maxSegments) {
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	const convert = new oc.Geom2dConvert_ApproxCurve_2(adaptor.ShallowCopy(), tolerance, mapContinuity(oc, continuity), maxSegments, 3);
-	const result = convert.Curve();
-	convert.delete();
-	adaptor.delete();
-	return result;
-}
-function decomposeBSpline2dToBeziers$1(oc, curve) {
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	const handle = adaptor.BSpline();
-	adaptor.delete();
-	const convert = new oc.Geom2dConvert_BSplineCurveToBezierCurve_1(handle);
-	const arcs = [];
-	const nArcs = convert.NbArcs();
-	for (let i = 1; i <= nArcs; i++) arcs.push(convert.Arc(i));
-	convert.delete();
-	return arcs;
+	return result.length > 0 ? result : [curve];
 }
-function createBoundingBox2d$1(oc) {
-	return new oc.Bnd_Box2d();
+function createBoundingBox2d$1() {
+	return createBBox2d();
 }
-function addCurveToBBox2d$1(oc, bbox, curve, tolerance) {
-	oc.BndLib_Add2dCurve.Add_3(curve, tolerance, bbox);
+function addCurveToBBox2d$1(bbox, curve, tol) {
+	addCurveToBBox(bb2d$1(bbox), c2d$1(curve), tol);
 }
-function getBBox2dBounds$1(_oc, bbox) {
+function getBBox2dBounds$1(bbox) {
+	const b = bb2d$1(bbox);
 	return {
-		xMin: bbox.GetXMin(),
-		yMin: bbox.GetYMin(),
-		xMax: bbox.GetXMax(),
-		yMax: bbox.GetYMax()
+		xMin: b.xMin,
+		yMin: b.yMin,
+		xMax: b.xMax,
+		yMax: b.yMax
 	};
 }
-function mergeBBox2d$1(_oc, target, other) {
-	target.Add_1(other);
+function mergeBBox2d$1(target, other) {
+	const t = bb2d$1(target), o = bb2d$1(other);
+	t.xMin = Math.min(t.xMin, o.xMin);
+	t.yMin = Math.min(t.yMin, o.yMin);
+	t.xMax = Math.max(t.xMax, o.xMax);
+	t.yMax = Math.max(t.yMax, o.yMax);
 }
-function isBBox2dOut$1(_oc, a, b) {
-	return a.IsOut_4(b);
+function isBBox2dOut$1(a, b) {
+	const ba = bb2d$1(a), bbb = bb2d$1(b);
+	return ba.xMax < bbb.xMin || bbb.xMax < ba.xMin || ba.yMax < bbb.yMin || bbb.yMax < ba.yMin;
 }
-function isBBox2dOutPoint$1(oc, bbox, x, y) {
-	const pnt = new oc.gp_Pnt2d_3(x, y);
-	const result = bbox.IsOut_1(pnt);
-	pnt.delete();
-	return result;
+function isBBox2dOutPoint$1(bbox, x, y) {
+	const b = bb2d$1(bbox);
+	return x < b.xMin || x > b.xMax || y < b.yMin || y > b.yMax;
 }
-function getCurve2dCircleData$1(oc, curve) {
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	if (unwrapOcctEnum(adaptor.GetType()) !== 1) {
-		adaptor.delete();
-		return null;
-	}
-	const circle = adaptor.Circle();
-	const center = circle.Location();
-	const result = {
-		cx: center.X(),
-		cy: center.Y(),
-		radius: circle.Radius(),
-		isDirect: circle.IsDirect()
+function getCurve2dCircleData$1(curve) {
+	const c = c2dBasis$1(curve);
+	if (c.__bk2d === "circle") return {
+		cx: c.cx,
+		cy: c.cy,
+		radius: c.radius,
+		isDirect: c.sense
 	};
-	center.delete();
-	circle.delete();
-	adaptor.delete();
-	return result;
+	return null;
 }
-function getCurve2dEllipseData$1(oc, curve) {
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	if (unwrapOcctEnum(adaptor.GetType()) !== 2) {
-		adaptor.delete();
-		return null;
-	}
-	const elips = adaptor.Ellipse();
-	const xAxis = elips.XAxis();
-	const xDir = xAxis.Direction();
-	const result = {
-		majorRadius: elips.MajorRadius(),
-		minorRadius: elips.MinorRadius(),
-		xAxisAngle: Math.atan2(xDir.Y(), xDir.X()),
-		isDirect: elips.IsDirect()
+function getCurve2dEllipseData$1(curve) {
+	const c = c2dBasis$1(curve);
+	if (c.__bk2d === "ellipse") return {
+		majorRadius: c.majorRadius,
+		minorRadius: c.minorRadius,
+		xAxisAngle: c.xDirAngle,
+		isDirect: c.sense
 	};
-	xDir.delete();
-	xAxis.delete();
-	elips.delete();
-	adaptor.delete();
-	return result;
+	return null;
 }
-function getCurve2dBezierPoles$1(oc, curve) {
-	if (getCurve2dTypeIndex(oc, curve) !== 5) return null;
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	const bezier = adaptor.Bezier().get();
-	const poles = [];
-	const nbPoles = bezier.NbPoles();
-	for (let i = 1; i <= nbPoles; i++) {
-		const p = bezier.Pole(i);
-		poles.push([p.X(), p.Y()]);
-		p.delete();
-	}
-	adaptor.delete();
-	return poles;
+function getCurve2dBezierPoles$1(curve) {
+	const c = c2dBasis$1(curve);
+	if (c.__bk2d === "bezier") return [...c.poles];
+	return null;
 }
-function getCurve2dBezierDegree$1(oc, curve) {
-	if (getCurve2dTypeIndex(oc, curve) !== 5) return null;
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	const degree = adaptor.Bezier().get().Degree();
-	adaptor.delete();
-	return degree;
+function getCurve2dBezierDegree$1(curve) {
+	const c = c2dBasis$1(curve);
+	if (c.__bk2d === "bezier") return c.poles.length - 1;
+	return null;
 }
-function getCurve2dBSplineData$1(oc, curve) {
-	if (getCurve2dTypeIndex(oc, curve) !== 6) return null;
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	const bspline = adaptor.BSpline().get();
-	const poles = [];
-	const polesArr = bspline.Poles_2();
-	for (let i = polesArr.Lower(); i <= polesArr.Upper(); i++) {
-		const p = polesArr.Value(i);
-		poles.push([p.X(), p.Y()]);
-	}
-	const knots = [];
-	const knotsArr = bspline.Knots_2();
-	for (let i = knotsArr.Lower(); i <= knotsArr.Upper(); i++) knots.push(knotsArr.Value(i));
-	const multiplicities = [];
-	const multsArr = bspline.Multiplicities_2();
-	for (let i = multsArr.Lower(); i <= multsArr.Upper(); i++) multiplicities.push(multsArr.Value(i));
-	const result = {
-		poles,
-		knots,
-		multiplicities,
-		degree: bspline.Degree(),
-		isPeriodic: bspline.IsPeriodic()
+function getCurve2dBSplineData$1(curve) {
+	const c = c2dBasis$1(curve);
+	if (c.__bk2d === "bspline") return {
+		poles: [...c.poles],
+		knots: [...c.knots],
+		multiplicities: [...c.multiplicities],
+		degree: c.degree,
+		isPeriodic: c.isPeriodic
 	};
-	adaptor.delete();
-	return result;
+	return null;
 }
-function serializeCurve2d$1(oc, curve) {
-	return oc.GeomToolsWrapper.Write(curve);
-}
-function deserializeCurve2d$1(oc, data) {
-	return oc.GeomToolsWrapper.Read(data);
-}
-function splitCurve2d$1(oc, curve, params) {
-	const inner = curve.get();
-	const first = inner.FirstParameter();
-	const last = inner.LastParameter();
-	const sorted = [...params].sort((a, b) => a - b);
-	const boundaries = [];
-	let prev = first;
-	for (const p of sorted) if (p > first && p < last) {
-		boundaries.push([prev, p]);
-		prev = p;
-	}
-	boundaries.push([prev, last]);
-	const adaptor = new oc.Geom2dAdaptor_Curve_2(curve);
-	const geomType = unwrapOcctEnum(adaptor.GetType());
-	const results = boundaries.map(([start, end]) => {
-		if (geomType === 5) {
-			const curveCopy = new oc.Geom2d_BezierCurve_1(adaptor.Bezier().get().Poles_2());
-			curveCopy.Segment(start, end);
-			return new oc.Handle_Geom2d_Curve_2(curveCopy);
-		}
-		if (geomType === 6) {
-			const bspline = adaptor.BSpline().get();
-			const curveCopy = new oc.Geom2d_BSplineCurve_1(bspline.Poles_2(), bspline.Knots_2(), bspline.Multiplicities_2(), bspline.Degree(), bspline.IsPeriodic());
-			curveCopy.Segment(start, end, 1e-9);
-			return new oc.Handle_Geom2d_Curve_2(curveCopy);
-		}
-		const trimmed = new oc.Geom2d_TrimmedCurve(curve, start, end, true, true);
-		return new oc.Handle_Geom2d_Curve_2(trimmed);
+function serializeCurve2d$1(curve) {
+	return serializeCurve2d$2(c2d$1(curve));
+}
+function deserializeCurve2d$1(data) {
+	return deserializeCurve2d$2(data);
+}
+function splitCurve2d$1(curve, params) {
+	const c = c2d$1(curve);
+	const bounds = curveBounds(c);
+	const sortedParams = [
+		bounds.first,
+		...[...params].sort((a, b) => a - b),
+		bounds.last
+	];
+	const result = [];
+	for (let i = 0; i < sortedParams.length - 1; i++) result.push({
+		__bk2d: "trimmed",
+		basis: c,
+		tStart: sortedParams[i],
+		tEnd: sortedParams[i + 1]
 	});
-	adaptor.delete();
-	return results;
+	return result;
 }
-function liftCurve2dToPlane$1(oc, curve, planeOrigin, planeZ, planeX) {
-	const origin = new oc.gp_Pnt_3(planeOrigin[0], planeOrigin[1], planeOrigin[2]);
-	const zDir = new oc.gp_Dir_5(planeZ[0], planeZ[1], planeZ[2]);
-	const xDir = new oc.gp_Dir_5(planeX[0], planeX[1], planeX[2]);
-	const ax = new oc.gp_Ax2_2(origin, zDir, xDir);
-	const curve3d = oc.GeomLib.To3d(ax, curve);
-	const edgeBuilder = new oc.BRepBuilderAPI_MakeEdge_24(curve3d);
+/** Create a straight 3D edge between two points. */
+function makeLineEdge3d(oc, p1, p2) {
+	const gp1 = new oc.gp_Pnt_3(p1[0], p1[1], p1[2]);
+	const gp2 = new oc.gp_Pnt_3(p2[0], p2[1], p2[2]);
+	const builder = new oc.BRepBuilderAPI_MakeEdge_3(gp1, gp2);
+	const edge = builder.Edge();
+	builder.delete();
+	gp1.delete();
+	gp2.delete();
+	return edge;
+}
+/** Create a circular arc edge through 3 points. */
+function makeCircleArcEdge3d(oc, startPt, midPt, endPt) {
+	const gpStart = new oc.gp_Pnt_3(startPt[0], startPt[1], startPt[2]);
+	const gpMid = new oc.gp_Pnt_3(midPt[0], midPt[1], midPt[2]);
+	const gpEnd = new oc.gp_Pnt_3(endPt[0], endPt[1], endPt[2]);
+	const arcGeom = new oc.GC_MakeArcOfCircle_4(gpStart, gpMid, gpEnd).Value().get();
+	const curveHandle = new oc.Handle_Geom_Curve_2(arcGeom);
+	const edgeBuilder = new oc.BRepBuilderAPI_MakeEdge_24(curveHandle);
 	const edge = edgeBuilder.Edge();
 	edgeBuilder.delete();
-	curve3d.delete();
-	ax.delete();
-	xDir.delete();
-	zDir.delete();
-	origin.delete();
+	curveHandle.delete();
+	gpStart.delete();
+	gpMid.delete();
+	gpEnd.delete();
 	return edge;
 }
-function buildEdgeOnSurface$1(oc, curve, surface) {
-	const edgeMaker = new oc.BRepBuilderAPI_MakeEdge_30(curve, surface);
-	const edge = edgeMaker.Edge();
-	edgeMaker.delete();
+/** Interpolate a 3D BSpline through the given points and return an edge. */
+function interpolatePoints3d(oc, points) {
+	const pnts = new oc.TColgp_Array1OfPnt_2(1, points.length);
+	const reusePnt = new oc.gp_Pnt_1();
+	for (let i = 0; i < points.length; i++) {
+		const p = points[i];
+		reusePnt.SetCoord_2(p[0], p[1], p[2]);
+		pnts.SetValue_1(i + 1, reusePnt);
+	}
+	reusePnt.delete();
+	const interp = new oc.GeomAPI_PointsToBSpline_2(pnts, 3, 8, oc.GeomAbs_Shape.GeomAbs_C2, 1e-6);
+	pnts.delete();
+	if (!interp.IsDone()) {
+		interp.delete();
+		throw new Error("Interpolation failed — GeomAPI_PointsToBSpline did not converge");
+	}
+	const curve3d = interp.Curve();
+	const geomHandle = new oc.Handle_Geom_Curve_2(curve3d.get());
+	const builder = new oc.BRepBuilderAPI_MakeEdge_24(geomHandle);
+	const edge = builder.Edge();
+	builder.delete();
+	interp.delete();
 	return edge;
 }
+function liftCurve2dToPlane$1(oc, curve, planeOrigin, planeZ, planeX) {
+	const c = c2d$1(curve);
+	const y = [
+		planeZ[1] * planeX[2] - planeZ[2] * planeX[1],
+		planeZ[2] * planeX[0] - planeZ[0] * planeX[2],
+		planeZ[0] * planeX[1] - planeZ[1] * planeX[0]
+	];
+	const lift = (u, v) => [
+		planeOrigin[0] + u * planeX[0] + v * y[0],
+		planeOrigin[1] + u * planeX[1] + v * y[1],
+		planeOrigin[2] + u * planeX[2] + v * y[2]
+	];
+	if (c.__bk2d === "line") return makeLineEdge3d(oc, lift(c.ox, c.oy), lift(c.ox + c.dx * c.len, c.oy + c.dy * c.len));
+	if (c.__bk2d === "circle" || c.__bk2d === "trimmed") {
+		let basis = c;
+		while (basis.__bk2d === "trimmed") basis = basis.basis;
+		if (basis.__bk2d === "circle") {
+			const circ = basis;
+			const center3d = lift(circ.cx, circ.cy);
+			const axisDir = circ.sense ? planeZ : [
+				-planeZ[0],
+				-planeZ[1],
+				-planeZ[2]
+			];
+			if (c.__bk2d === "circle") {
+				const gpCenter = new oc.gp_Pnt_3(center3d[0], center3d[1], center3d[2]);
+				const gpDir = new oc.gp_Dir_5(axisDir[0], axisDir[1], axisDir[2]);
+				const gpAx2 = new oc.gp_Ax2_4(gpCenter, gpDir);
+				const gpCirc = new oc.gp_Circ_2(gpAx2, circ.radius);
+				const builder = new oc.BRepBuilderAPI_MakeEdge_8(gpCirc);
+				const edge = builder.Edge();
+				builder.delete();
+				gpCirc.delete();
+				gpAx2.delete();
+				gpDir.delete();
+				gpCenter.delete();
+				return edge;
+			}
+			const bounds = curveBounds(c);
+			const [su, sv] = evaluateCurve2d$2(c, bounds.first);
+			const [mu, mv] = evaluateCurve2d$2(c, (bounds.first + bounds.last) / 2);
+			const [eu, ev] = evaluateCurve2d$2(c, bounds.last);
+			return makeCircleArcEdge3d(oc, lift(su, sv), lift(mu, mv), lift(eu, ev));
+		}
+	}
+	if (c.__bk2d === "bezier" || c.__bk2d === "bspline") {
+		const pts3d = c.poles.map(([u, v]) => lift(u, v));
+		if (pts3d.length === 2) return makeLineEdge3d(oc, pts3d[0], pts3d[1]);
+		return interpolatePoints3d(oc, pts3d);
+	}
+	const bounds = curveBounds(c);
+	const nSamples = 60;
+	const pts3d = [];
+	for (let i = 0; i <= nSamples; i++) {
+		const [u, v] = evaluateCurve2d$2(c, bounds.first + (bounds.last - bounds.first) * i / nSamples);
+		pts3d.push(lift(u, v));
+	}
+	return interpolatePoints3d(oc, pts3d);
+}
+function buildEdgeOnSurface$1(oc, curve, surface) {
+	const c = c2d$1(curve);
+	const bounds = curveBounds(c);
+	const N = 60;
+	const pts3d = [];
+	for (let i = 0; i <= N; i++) {
+		const [u, v] = evaluateCurve2d$2(c, bounds.first + (bounds.last - bounds.first) * i / N);
+		const gpPnt = surface.get().Value(u, v);
+		pts3d.push([
+			gpPnt.X(),
+			gpPnt.Y(),
+			gpPnt.Z()
+		]);
+		gpPnt.delete();
+	}
+	return interpolatePoints3d(oc, pts3d);
+}
 function extractSurfaceFromFace$1(oc, face) {
 	return oc.BRep_Tool.Surface_2(face);
 }
 function extractCurve2dFromEdge$1(oc, edge, face) {
 	const adaptor = new oc.BRepAdaptor_Curve2d_2(edge, face);
-	const curveHandle = adaptor.Curve();
-	const first = adaptor.FirstParameter();
-	const last = adaptor.LastParameter();
+	const first = Number(adaptor.FirstParameter());
+	const last = Number(adaptor.LastParameter());
+	const N = 30;
+	const points = [];
+	for (let i = 0; i <= N; i++) {
+		const t = first + (last - first) * i / N;
+		const pt = adaptor.Value(t);
+		points.push([pt.X(), pt.Y()]);
+		pt.delete();
+	}
 	adaptor.delete();
-	const trimmed = new oc.Geom2d_TrimmedCurve(curveHandle, first, last, true, true);
-	return new oc.Handle_Geom2d_Curve_2(trimmed);
+	return makeBSpline2d$1(points);
 }
 function buildCurves3d$1(oc, wire) {
 	oc.BRepLib.BuildCurves3d_2(wire);
@@ -5486,172 +5667,170 @@ var DefaultAdapter = class {
 		return exportSTEPConfigured$1(this.oc, shapes, options);
 	}
 	wrapCurve2dHandle(handle) {
-		return wrapCurve2dHandle$1(this.oc, handle);
+		return wrapCurve2dHandle$1(handle);
 	}
 	createCurve2dAdaptor(handle) {
-		return createCurve2dAdaptor$1(this.oc, handle);
+		return createCurve2dAdaptor$1(handle);
 	}
 	createPoint2d(x, y) {
-		return createPoint2d$1(this.oc, x, y);
+		return createPoint2d$1(x, y);
 	}
 	createDirection2d(x, y) {
-		return createDirection2d$1(this.oc, x, y);
+		return createDirection2d$1(x, y);
 	}
 	createVector2d(x, y) {
-		return createVector2d$1(this.oc, x, y);
+		return createVector2d$1(x, y);
 	}
 	createAxis2d(px, py, dx, dy) {
-		return createAxis2d$1(this.oc, px, py, dx, dy);
+		return createAxis2d$1(px, py, dx, dy);
 	}
 	makeLine2d(x1, y1, x2, y2) {
-		return makeLine2d$1(this.oc, x1, y1, x2, y2);
+		return makeLine2d$1(x1, y1, x2, y2);
 	}
 	makeCircle2d(cx, cy, radius, sense) {
-		return makeCircle2d$1(this.oc, cx, cy, radius, sense);
+		return makeCircle2d$1(cx, cy, radius, sense);
 	}
 	makeArc2dThreePoints(x1, y1, xm, ym, x2, y2) {
-		return makeArc2dThreePoints$1(this.oc, x1, y1, xm, ym, x2, y2);
+		return makeArc2dThreePoints$1(x1, y1, xm, ym, x2, y2);
 	}
 	makeArc2dTangent(startX, startY, tangentX, tangentY, endX, endY) {
-		return makeArc2dTangent$1(this.oc, startX, startY, tangentX, tangentY, endX, endY);
+		return makeArc2dTangent$1(startX, startY, tangentX, tangentY, endX, endY);
 	}
 	makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense) {
-		return makeEllipse2d$1(this.oc, cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense);
+		return makeEllipse2d$1(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense);
 	}
 	makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense) {
-		return makeEllipseArc2d$1(this.oc, cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense);
+		return makeEllipseArc2d$1(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense);
 	}
 	makeBezier2d(points) {
-		return makeBezier2d$1(this.oc, points);
+		return makeBezier2d$1(points);
 	}
 	makeBSpline2d(points, options) {
-		return makeBSpline2d$1(this.oc, points, options);
+		return makeBSpline2d$1(points, options);
 	}
 	evaluateCurve2d(curve, param) {
-		return evaluateCurve2d$1(this.oc, curve, param);
+		return evaluateCurve2d$1(curve, param);
 	}
 	evaluateCurve2dD1(curve, param) {
-		return evaluateCurve2dD1$1(this.oc, curve, param);
+		return evaluateCurve2dD1$1(curve, param);
 	}
 	getCurve2dBounds(curve) {
-		return getCurve2dBounds$1(this.oc, curve);
+		return getCurve2dBounds$1(curve);
 	}
 	getCurve2dType(curve) {
-		return getCurve2dType$1(this.oc, curve);
+		return getCurve2dType$1(curve);
 	}
 	trimCurve2d(curve, start, end) {
-		return trimCurve2d$1(this.oc, curve, start, end);
-	}
-	reverseCurve2d(curve) {
-		reverseCurve2d$1(this.oc, curve);
+		return trimCurve2d$1(curve, start, end);
 	}
+	reverseCurve2d(curve) {}
 	copyCurve2d(curve) {
-		return copyCurve2d$1(this.oc, curve);
+		return copyCurve2d$1(curve);
 	}
 	offsetCurve2d(curve, offset) {
-		return offsetCurve2d$1(this.oc, curve, offset);
+		return offsetCurve2d$1(curve, offset);
 	}
 	translateCurve2d(curve, dx, dy) {
-		return translateCurve2d$1(this.oc, curve, dx, dy);
+		return translateCurve2d$1(curve, dx, dy);
 	}
 	rotateCurve2d(curve, angle, cx, cy) {
-		return rotateCurve2d$1(this.oc, curve, angle, cx, cy);
+		return rotateCurve2d$1(curve, angle, cx, cy);
 	}
 	scaleCurve2d(curve, factor, cx, cy) {
-		return scaleCurve2d$1(this.oc, curve, factor, cx, cy);
+		return scaleCurve2d$1(curve, factor, cx, cy);
 	}
 	mirrorCurve2dAtPoint(curve, cx, cy) {
-		return mirrorCurve2dAtPoint$1(this.oc, curve, cx, cy);
+		return mirrorCurve2dAtPoint$1(curve, cx, cy);
 	}
 	mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY) {
-		return mirrorCurve2dAcrossAxis$1(this.oc, curve, originX, originY, dirX, dirY);
+		return mirrorCurve2dAcrossAxis$1(curve, originX, originY, dirX, dirY);
 	}
 	affinityTransform2d(curve, axisOriginX, axisOriginY, axisDirX, axisDirY, ratio) {
-		return affinityTransform2d$1(this.oc, curve, axisOriginX, axisOriginY, axisDirX, axisDirY, ratio);
+		return affinityTransform2d$1(curve, axisOriginX, axisOriginY, axisDirX, axisDirY, ratio);
 	}
 	createIdentityGTrsf2d() {
-		return createIdentityGTrsf2d$1(this.oc);
+		return createIdentityGTrsf2d$1();
 	}
 	createAffinityGTrsf2d(originX, originY, dirX, dirY, ratio) {
-		return createAffinityGTrsf2d$1(this.oc, originX, originY, dirX, dirY, ratio);
+		return createAffinityGTrsf2d$1(originX, originY, dirX, dirY, ratio);
 	}
 	createTranslationGTrsf2d(dx, dy) {
-		return createTranslationGTrsf2d$1(this.oc, dx, dy);
+		return createTranslationGTrsf2d$1(dx, dy);
 	}
 	createMirrorGTrsf2d(cx, cy, mode, originX, originY, dirX, dirY) {
-		return createMirrorGTrsf2d$1(this.oc, cx, cy, mode, originX, originY, dirX, dirY);
+		return createMirrorGTrsf2d$1(cx, cy, mode, originX, originY, dirX, dirY);
 	}
 	createRotationGTrsf2d(angle, cx, cy) {
-		return createRotationGTrsf2d$1(this.oc, angle, cx, cy);
+		return createRotationGTrsf2d$1(angle, cx, cy);
 	}
 	createScaleGTrsf2d(factor, cx, cy) {
-		return createScaleGTrsf2d$1(this.oc, factor, cx, cy);
+		return createScaleGTrsf2d$1(factor, cx, cy);
 	}
 	setGTrsf2dTranslationPart(gtrsf, dx, dy) {
-		setGTrsf2dTranslationPart$1(this.oc, gtrsf, dx, dy);
+		setGTrsf2dTranslationPart$1(gtrsf, dx, dy);
 	}
 	multiplyGTrsf2d(base, other) {
-		multiplyGTrsf2d$1(this.oc, base, other);
+		multiplyGTrsf2d$1(base, other);
 	}
 	transformCurve2dGeneral(curve, gtrsf) {
-		return transformCurve2dGeneral$1(this.oc, curve, gtrsf);
+		return transformCurve2dGeneral$1(curve, gtrsf);
 	}
 	intersectCurves2d(c1, c2, tolerance) {
-		return intersectCurves2d$1(this.oc, c1, c2, tolerance);
+		return intersectCurves2d$1(c1, c2, tolerance);
 	}
 	projectPointOnCurve2d(curve, x, y) {
-		return projectPointOnCurve2d$1(this.oc, curve, x, y);
+		return projectPointOnCurve2d$1(curve, x, y);
 	}
 	distanceBetweenCurves2d(c1, c2, p1Start, p1End, p2Start, p2End) {
-		return distanceBetweenCurves2d$1(this.oc, c1, c2, p1Start, p1End, p2Start, p2End);
+		return distanceBetweenCurves2d$1(c1, c2, p1Start, p1End, p2Start, p2End);
 	}
 	approximateCurve2dAsBSpline(curve, tolerance, continuity, maxSegments) {
-		return approximateCurve2dAsBSpline$1(this.oc, curve, tolerance, continuity, maxSegments);
+		return approximateCurve2dAsBSpline$1(curve, tolerance, continuity, maxSegments);
 	}
 	decomposeBSpline2dToBeziers(curve) {
-		return decomposeBSpline2dToBeziers$1(this.oc, curve);
+		return decomposeBSpline2dToBeziers$1(curve);
 	}
 	createBoundingBox2d() {
-		return createBoundingBox2d$1(this.oc);
+		return createBoundingBox2d$1();
 	}
 	addCurveToBBox2d(bbox, curve, tolerance) {
-		addCurveToBBox2d$1(this.oc, bbox, curve, tolerance);
+		addCurveToBBox2d$1(bbox, curve, tolerance);
 	}
 	getBBox2dBounds(bbox) {
-		return getBBox2dBounds$1(this.oc, bbox);
+		return getBBox2dBounds$1(bbox);
 	}
 	mergeBBox2d(target, other) {
-		mergeBBox2d$1(this.oc, target, other);
+		mergeBBox2d$1(target, other);
 	}
 	isBBox2dOut(a, b) {
-		return isBBox2dOut$1(this.oc, a, b);
+		return isBBox2dOut$1(a, b);
 	}
 	isBBox2dOutPoint(bbox, x, y) {
-		return isBBox2dOutPoint$1(this.oc, bbox, x, y);
+		return isBBox2dOutPoint$1(bbox, x, y);
 	}
 	getCurve2dCircleData(curve) {
-		return getCurve2dCircleData$1(this.oc, curve);
+		return getCurve2dCircleData$1(curve);
 	}
 	getCurve2dEllipseData(curve) {
-		return getCurve2dEllipseData$1(this.oc, curve);
+		return getCurve2dEllipseData$1(curve);
 	}
 	getCurve2dBezierPoles(curve) {
-		return getCurve2dBezierPoles$1(this.oc, curve);
+		return getCurve2dBezierPoles$1(curve);
 	}
 	getCurve2dBezierDegree(curve) {
-		return getCurve2dBezierDegree$1(this.oc, curve);
+		return getCurve2dBezierDegree$1(curve);
 	}
 	getCurve2dBSplineData(curve) {
-		return getCurve2dBSplineData$1(this.oc, curve);
+		return getCurve2dBSplineData$1(curve);
 	}
 	serializeCurve2d(curve) {
-		return serializeCurve2d$1(this.oc, curve);
+		return serializeCurve2d$1(curve);
 	}
 	deserializeCurve2d(data) {
-		return deserializeCurve2d$1(this.oc, data);
+		return deserializeCurve2d$1(data);
 	}
 	splitCurve2d(curve, params) {
-		return splitCurve2d$1(this.oc, curve, params);
+		return splitCurve2d$1(curve, params);
 	}
 	liftCurve2dToPlane(curve, planeOrigin, planeZ, planeX) {
 		return liftCurve2dToPlane$1(this.oc, curve, planeOrigin, planeZ, planeX);