brepjs 18.6.0 → 18.14.3

package/dist/occtWasmAdapter-CuZRRioz.cjs

@@ -1,3947 +0,0 @@
-//#region src/kernel/geometry2d.ts
-function evaluateCurve2d(c, t) {
-	switch (c.__bk2d) {
-		case "line": return [c.ox + c.dx * t, c.oy + c.dy * t];
-		case "circle": {
-			const angle = c.sense ? t : -t;
-			return [c.cx + c.radius * Math.cos(angle), c.cy + c.radius * Math.sin(angle)];
-		}
-		case "ellipse": {
-			const angle = c.sense ? t : -t;
-			const cos = Math.cos(c.xDirAngle);
-			const sin = Math.sin(c.xDirAngle);
-			const x = c.majorRadius * Math.cos(angle);
-			const y = c.minorRadius * Math.sin(angle);
-			return [c.cx + x * cos - y * sin, c.cy + x * sin + y * cos];
-		}
-		case "bezier": return evaluateBezier(c.poles, t);
-		case "bspline": return evaluateBSpline2d(c, t);
-		case "trimmed": {
-			const mapped = c.tStart + t * (c.tEnd - c.tStart);
-			return evaluateCurve2d(c.basis, mapped);
-		}
-	}
-}
-function tangentCurve2d(c, t) {
-	switch (c.__bk2d) {
-		case "line": return [c.dx, c.dy];
-		case "circle": {
-			const angle = c.sense ? t : -t;
-			const sign = c.sense ? 1 : -1;
-			return [-c.radius * Math.sin(angle) * sign, c.radius * Math.cos(angle) * sign];
-		}
-		case "ellipse": {
-			const angle = c.sense ? t : -t;
-			const sign = c.sense ? 1 : -1;
-			const cos = Math.cos(c.xDirAngle);
-			const sin = Math.sin(c.xDirAngle);
-			const dx = -c.majorRadius * Math.sin(angle) * sign;
-			const dy = c.minorRadius * Math.cos(angle) * sign;
-			return [dx * cos - dy * sin, dx * sin + dy * cos];
-		}
-		case "bezier": {
-			const h = 1e-8;
-			const p0 = evaluateBezier(c.poles, Math.max(0, t - h));
-			const p1 = evaluateBezier(c.poles, Math.min(1, t + h));
-			const dt = Math.min(1, t + h) - Math.max(0, t - h);
-			return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
-		}
-		case "bspline": {
-			const h = 1e-8;
-			const kFirst = c.knots[0];
-			const kLast = c.knots[c.knots.length - 1];
-			const p0 = evaluateBSpline2d(c, Math.max(kFirst, t - h));
-			const p1 = evaluateBSpline2d(c, Math.min(kLast, t + h));
-			const dt = Math.min(kLast, t + h) - Math.max(kFirst, t - h);
-			return [(p1[0] - p0[0]) / dt, (p1[1] - p0[1]) / dt];
-		}
-		case "trimmed": {
-			const mapped = c.tStart + t * (c.tEnd - c.tStart);
-			const tan = tangentCurve2d(c.basis, mapped);
-			const scale = c.tEnd - c.tStart;
-			return [tan[0] * scale, tan[1] * scale];
-		}
-	}
-}
-function curveBounds(c) {
-	switch (c.__bk2d) {
-		case "line": return {
-			first: 0,
-			last: c.len
-		};
-		case "circle":
-		case "ellipse": return {
-			first: 0,
-			last: 2 * Math.PI
-		};
-		case "bezier": return {
-			first: 0,
-			last: 1
-		};
-		case "bspline": return {
-			first: c.knots[0],
-			last: c.knots[c.knots.length - 1]
-		};
-		case "trimmed": return {
-			first: 0,
-			last: 1
-		};
-	}
-}
-function curveTypeName(c) {
-	switch (c.__bk2d) {
-		case "line": return "LINE";
-		case "circle": return "CIRCLE";
-		case "ellipse": return "ELLIPSE";
-		case "bezier": return "BEZIER_CURVE";
-		case "bspline": return "BSPLINE_CURVE";
-		case "trimmed": return "TRIMMED_" + curveTypeName(c.basis);
-	}
-}
-function makeLine2d(x1, y1, x2, y2) {
-	const dx = x2 - x1;
-	const dy = y2 - y1;
-	const len = Math.sqrt(dx * dx + dy * dy);
-	return {
-		__bk2d: "line",
-		ox: x1,
-		oy: y1,
-		dx: len > 0 ? dx / len : 1,
-		dy: len > 0 ? dy / len : 0,
-		len
-	};
-}
-function makeCircle2d(cx, cy, radius, sense = true) {
-	return {
-		__bk2d: "circle",
-		cx,
-		cy,
-		radius,
-		sense
-	};
-}
-function makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX = 1, xDirY = 0, sense = true) {
-	return {
-		__bk2d: "ellipse",
-		cx,
-		cy,
-		majorRadius,
-		minorRadius,
-		xDirAngle: Math.atan2(xDirY, xDirX),
-		sense
-	};
-}
-function makeBezier2d(poles) {
-	return {
-		__bk2d: "bezier",
-		poles: [...poles]
-	};
-}
-function translateCurve2d(c, dx, dy) {
-	switch (c.__bk2d) {
-		case "line": return {
-			...c,
-			ox: c.ox + dx,
-			oy: c.oy + dy
-		};
-		case "circle": return {
-			...c,
-			cx: c.cx + dx,
-			cy: c.cy + dy
-		};
-		case "ellipse": return {
-			...c,
-			cx: c.cx + dx,
-			cy: c.cy + dy
-		};
-		case "bezier": return {
-			...c,
-			poles: c.poles.map(([x, y]) => [x + dx, y + dy])
-		};
-		case "bspline": return {
-			...c,
-			poles: c.poles.map(([x, y]) => [x + dx, y + dy])
-		};
-		case "trimmed": return {
-			...c,
-			basis: translateCurve2d(c.basis, dx, dy)
-		};
-	}
-}
-function rotateCurve2d(c, angle, cx, cy) {
-	const cos = Math.cos(angle);
-	const sin = Math.sin(angle);
-	const rotatePoint = (x, y) => {
-		const rx = x - cx;
-		const ry = y - cy;
-		return [cx + rx * cos - ry * sin, cy + rx * sin + ry * cos];
-	};
-	switch (c.__bk2d) {
-		case "line": {
-			const [ox, oy] = rotatePoint(c.ox, c.oy);
-			const ndx = c.dx * cos - c.dy * sin;
-			const ndy = c.dx * sin + c.dy * cos;
-			return {
-				...c,
-				ox,
-				oy,
-				dx: ndx,
-				dy: ndy
-			};
-		}
-		case "circle": {
-			const [ncx, ncy] = rotatePoint(c.cx, c.cy);
-			return {
-				...c,
-				cx: ncx,
-				cy: ncy
-			};
-		}
-		case "ellipse": {
-			const [ncx, ncy] = rotatePoint(c.cx, c.cy);
-			return {
-				...c,
-				cx: ncx,
-				cy: ncy,
-				xDirAngle: c.xDirAngle + angle
-			};
-		}
-		case "bezier": return {
-			...c,
-			poles: c.poles.map(([x, y]) => rotatePoint(x, y))
-		};
-		case "bspline": return {
-			...c,
-			poles: c.poles.map(([x, y]) => rotatePoint(x, y))
-		};
-		case "trimmed": return {
-			...c,
-			basis: rotateCurve2d(c.basis, angle, cx, cy)
-		};
-	}
-}
-function scaleCurve2d(c, factor, cx, cy) {
-	const scalePoint = (x, y) => [cx + (x - cx) * factor, cy + (y - cy) * factor];
-	switch (c.__bk2d) {
-		case "line": {
-			const [ox, oy] = scalePoint(c.ox, c.oy);
-			return {
-				...c,
-				ox,
-				oy
-			};
-		}
-		case "circle": {
-			const [ncx, ncy] = scalePoint(c.cx, c.cy);
-			return {
-				...c,
-				cx: ncx,
-				cy: ncy,
-				radius: c.radius * Math.abs(factor)
-			};
-		}
-		case "ellipse": {
-			const [ncx, ncy] = scalePoint(c.cx, c.cy);
-			return {
-				...c,
-				cx: ncx,
-				cy: ncy,
-				majorRadius: c.majorRadius * Math.abs(factor),
-				minorRadius: c.minorRadius * Math.abs(factor)
-			};
-		}
-		case "bezier": return {
-			...c,
-			poles: c.poles.map(([x, y]) => scalePoint(x, y))
-		};
-		case "bspline": return {
-			...c,
-			poles: c.poles.map(([x, y]) => scalePoint(x, y))
-		};
-		case "trimmed": return {
-			...c,
-			basis: scaleCurve2d(c.basis, factor, cx, cy)
-		};
-	}
-}
-function mirrorAtPoint(c, cx, cy) {
-	return scaleCurve2d(c, -1, cx, cy);
-}
-function mirrorAcrossAxis(c, ox, oy, dx, dy) {
-	const len = Math.sqrt(dx * dx + dy * dy);
-	const nx = dx / len;
-	const ny = dy / len;
-	const reflectPoint = (x, y) => {
-		const rx = x - ox;
-		const ry = y - oy;
-		const dot = rx * nx + ry * ny;
-		return [ox + 2 * dot * nx - rx, oy + 2 * dot * ny - ry];
-	};
-	switch (c.__bk2d) {
-		case "line": {
-			const [nox, noy] = reflectPoint(c.ox, c.oy);
-			const ndx = 2 * (c.dx * nx + c.dy * ny) * nx - c.dx;
-			const ndy = 2 * (c.dx * nx + c.dy * ny) * ny - c.dy;
-			return {
-				...c,
-				ox: nox,
-				oy: noy,
-				dx: ndx,
-				dy: ndy
-			};
-		}
-		case "circle": {
-			const [ncx, ncy] = reflectPoint(c.cx, c.cy);
-			return {
-				...c,
-				cx: ncx,
-				cy: ncy,
-				sense: !c.sense
-			};
-		}
-		case "ellipse": {
-			const [ncx, ncy] = reflectPoint(c.cx, c.cy);
-			const cos2 = nx * nx - ny * ny;
-			const sin2 = 2 * nx * ny;
-			const newAngle = Math.atan2(sin2 * Math.cos(c.xDirAngle) - cos2 * Math.sin(c.xDirAngle), cos2 * Math.cos(c.xDirAngle) + sin2 * Math.sin(c.xDirAngle));
-			return {
-				...c,
-				cx: ncx,
-				cy: ncy,
-				xDirAngle: newAngle,
-				sense: !c.sense
-			};
-		}
-		case "bezier": return {
-			...c,
-			poles: c.poles.map(([x, y]) => reflectPoint(x, y))
-		};
-		case "bspline": return {
-			...c,
-			poles: c.poles.map(([x, y]) => reflectPoint(x, y))
-		};
-		case "trimmed": return {
-			...c,
-			basis: mirrorAcrossAxis(c.basis, ox, oy, dx, dy)
-		};
-	}
-}
-/**
-* Compute intersection points (and overlapping segments) between two 2D curves.
-* Handles analytic cases (line-line, line-circle, circle-circle) and falls back
-* to numerical sampling + Newton refinement for general curves.
-*/
-function intersectCurves2dFn(c1, c2, tolerance) {
-	const b1 = unwrapCurve(c1);
-	const b2 = unwrapCurve(c2);
-	if (b1.__bk2d === "line" && b2.__bk2d === "line") return intersectLineLine(c1, b1, c2, b2, tolerance);
-	if (b1.__bk2d === "line" && b2.__bk2d === "circle") return {
-		points: intersectLineCircle(c1, b1, c2, b2, tolerance),
-		segments: []
-	};
-	if (b1.__bk2d === "circle" && b2.__bk2d === "line") return {
-		points: intersectLineCircle(c2, b2, c1, b1, tolerance),
-		segments: []
-	};
-	if (b1.__bk2d === "circle" && b2.__bk2d === "circle") return {
-		points: intersectCircleCircle(c1, b1, c2, b2, tolerance),
-		segments: []
-	};
-	return numericalIntersect(c1, c2, tolerance, c1 === c2);
-}
-/** Unwrap trimmed wrappers to get the basis curve type. */
-function unwrapCurve(c) {
-	let cur = c;
-	while (cur.__bk2d === "trimmed") cur = cur.basis;
-	return cur;
-}
-/** Check if parameter t is within the curve's domain. */
-function inDomain(c, t, tol) {
-	const b = curveBounds(c);
-	return t >= b.first - tol && t <= b.last + tol;
-}
-/** Find the parameter on curve c closest to point (px, py), searching near tGuess. */
-function refineParam(c, px, py) {
-	const bounds = curveBounds(c);
-	if (!isFinite(bounds.first) || !isFinite(bounds.last)) return null;
-	const N = 80;
-	const dt = (bounds.last - bounds.first) / N;
-	let bestT = bounds.first;
-	let bestD = Infinity;
-	for (let i = 0; i <= N; i++) {
-		const t = bounds.first + i * dt;
-		const [ex, ey] = evaluateCurve2d(c, t);
-		const d = (ex - px) ** 2 + (ey - py) ** 2;
-		if (d < bestD) {
-			bestD = d;
-			bestT = t;
-		}
-	}
-	const [sx, sy] = evaluateCurve2d(c, bounds.first);
-	const [ex, ey] = evaluateCurve2d(c, bounds.last);
-	const [mx, my] = evaluateCurve2d(c, (bounds.first + bounds.last) / 2);
-	const maxDist = Math.max(Math.sqrt((ex - sx) ** 2 + (ey - sy) ** 2), Math.sqrt((mx - sx) ** 2 + (my - sy) ** 2), 1e-6) * .1;
-	return bestD < maxDist * maxDist ? bestT : null;
-}
-function intersectLineLine(c1, l1, c2, l2, tol) {
-	const det = l1.dx * l2.dy - l1.dy * l2.dx;
-	if (Math.abs(det) >= 1e-14) {
-		const ex = l2.ox - l1.ox;
-		const ey = l2.oy - l1.oy;
-		const t1 = (ex * l2.dy - ey * l2.dx) / det;
-		const t2 = (ex * l1.dy - ey * l1.dx) / det;
-		if (!inDomain(c1, t1, tol) || !inDomain(c2, t2, tol)) return {
-			points: [],
-			segments: []
-		};
-		return {
-			points: [[l1.ox + t1 * l1.dx, l1.oy + t1 * l1.dy]],
-			segments: []
-		};
-	}
-	const ex = l2.ox - l1.ox;
-	const ey = l2.oy - l1.oy;
-	const cross = ex * l1.dy - ey * l1.dx;
-	if (Math.abs(cross) > tol) return {
-		points: [],
-		segments: []
-	};
-	const b1 = curveBounds(c1);
-	const b2 = curveBounds(c2);
-	const p2s = evaluateCurve2d(c2, b2.first);
-	const p2e = evaluateCurve2d(c2, b2.last);
-	const t2sOn1 = (p2s[0] - l1.ox) * l1.dx + (p2s[1] - l1.oy) * l1.dy;
-	const t2eOn1 = (p2e[0] - l1.ox) * l1.dx + (p2e[1] - l1.oy) * l1.dy;
-	const overlapStart = Math.max(b1.first, Math.min(t2sOn1, t2eOn1));
-	const overlapEnd = Math.min(b1.last, Math.max(t2sOn1, t2eOn1));
-	if (overlapEnd - overlapStart < tol) return {
-		points: [],
-		segments: []
-	};
-	return {
-		points: [],
-		segments: [makeLine2d(l1.ox + overlapStart * l1.dx, l1.oy + overlapStart * l1.dy, l1.ox + overlapEnd * l1.dx, l1.oy + overlapEnd * l1.dy)]
-	};
-}
-function intersectLineCircle(cLine, line, cCirc, circ, tol) {
-	const fx = line.ox - circ.cx;
-	const fy = line.oy - circ.cy;
-	const a = line.dx * line.dx + line.dy * line.dy;
-	const b = 2 * (fx * line.dx + fy * line.dy);
-	const c = fx * fx + fy * fy - circ.radius * circ.radius;
-	const disc = b * b - 4 * a * c;
-	if (disc < -tol) return [];
-	const results = [];
-	const sqrtDisc = Math.sqrt(Math.max(0, disc));
-	const t1 = (-b - sqrtDisc) / (2 * a);
-	const t2 = (-b + sqrtDisc) / (2 * a);
-	for (const tLine of disc < tol * tol ? [t1] : [t1, t2]) {
-		if (!inDomain(cLine, tLine, tol)) continue;
-		const px = line.ox + tLine * line.dx;
-		const py = line.oy + tLine * line.dy;
-		const tCirc = refineParam(cCirc, px, py);
-		if (tCirc === null) continue;
-		const [cx2, cy2] = evaluateCurve2d(cCirc, tCirc);
-		if ((cx2 - px) ** 2 + (cy2 - py) ** 2 > tol * tol * 1e6) continue;
-		results.push([px, py]);
-	}
-	return results;
-}
-function intersectConcentricArcs(c1, c2, tol) {
-	const b1 = curveBounds(c1);
-	const b2 = curveBounds(c2);
-	const isFullCircle1 = Math.abs(b1.last - b1.first - 2 * Math.PI) < 1e-10;
-	const isFullCircle2 = Math.abs(b2.last - b2.first - 2 * Math.PI) < 1e-10;
-	if (isFullCircle1 && isFullCircle2) return [];
-	if (isFullCircle1) return [evaluateCurve2d(c2, b2.first), evaluateCurve2d(c2, b2.last)];
-	if (isFullCircle2) return [evaluateCurve2d(c1, b1.first), evaluateCurve2d(c1, b1.last)];
-	const pts = [];
-	const checks = [
-		[c2, evaluateCurve2d(c1, b1.first)],
-		[c2, evaluateCurve2d(c1, b1.last)],
-		[c1, evaluateCurve2d(c2, b2.first)],
-		[c1, evaluateCurve2d(c2, b2.last)]
-	];
-	for (const [target, pt] of checks) {
-		const t = refineParam(target, pt[0], pt[1]);
-		if (t !== null) {
-			const [ex, ey] = evaluateCurve2d(target, t);
-			if ((ex - pt[0]) ** 2 + (ey - pt[1]) ** 2 < tol * tol * 100) pts.push(pt);
-		}
-	}
-	const deduped = [];
-	for (const p of pts) if (!deduped.some(([ddx, ddy]) => (ddx - p[0]) ** 2 + (ddy - p[1]) ** 2 < tol * tol * 100)) deduped.push(p);
-	return deduped;
-}
-function intersectCircleCircle(c1, circ1, c2, circ2, tol) {
-	const dx = circ2.cx - circ1.cx;
-	const dy = circ2.cy - circ1.cy;
-	const d = Math.sqrt(dx * dx + dy * dy);
-	if (d > circ1.radius + circ2.radius + tol) return [];
-	if (d < Math.abs(circ1.radius - circ2.radius) - tol) return [];
-	if (d < 1e-14) {
-		if (Math.abs(circ1.radius - circ2.radius) > tol) return [];
-		return intersectConcentricArcs(c1, c2, tol);
-	}
-	const a = (circ1.radius * circ1.radius - circ2.radius * circ2.radius + d * d) / (2 * d);
-	const h2 = circ1.radius * circ1.radius - a * a;
-	const h = Math.sqrt(Math.max(0, h2));
-	const mx = circ1.cx + a * dx / d;
-	const my = circ1.cy + a * dy / d;
-	const candidates = h < tol ? [[mx, my]] : [[mx + h * dy / d, my - h * dx / d], [mx - h * dy / d, my + h * dx / d]];
-	const results = [];
-	for (const [px, py] of candidates) {
-		const t1 = refineParam(c1, px, py);
-		const t2 = refineParam(c2, px, py);
-		if (t1 === null || t2 === null) continue;
-		const [x1, y1] = evaluateCurve2d(c1, t1);
-		const [x2, y2] = evaluateCurve2d(c2, t2);
-		const tolSq = (tol * 10) ** 2;
-		if ((x1 - px) ** 2 + (y1 - py) ** 2 > tolSq) continue;
-		if ((x2 - px) ** 2 + (y2 - py) ** 2 > tolSq) continue;
-		results.push([px, py]);
-	}
-	return results;
-}
-/**
-* Numerical intersection via sampling + Newton refinement.
-* Samples both curves densely, finds close point pairs, refines with Newton.
-*/
-function numericalIntersect(c1, c2, tolerance, isSelf = false) {
-	const b1 = curveBounds(c1);
-	const b2 = curveBounds(c2);
-	if (!isFinite(b1.first) || !isFinite(b1.last) || !isFinite(b2.first) || !isFinite(b2.last)) return {
-		points: [],
-		segments: []
-	};
-	const N = 100;
-	const pts1 = [];
-	const pts2 = [];
-	for (let i = 0; i <= N; i++) {
-		const t1 = b1.first + (b1.last - b1.first) * i / N;
-		const [x1, y1] = evaluateCurve2d(c1, t1);
-		pts1.push({
-			t: t1,
-			x: x1,
-			y: y1
-		});
-		const t2 = b2.first + (b2.last - b2.first) * i / N;
-		const [x2, y2] = evaluateCurve2d(c2, t2);
-		pts2.push({
-			t: t2,
-			x: x2,
-			y: y2
-		});
-	}
-	const crossTol = Math.max(tolerance * 100, .5);
-	const seg2Bounds = new Float64Array(N * 6);
-	for (let j = 0; j < N; j++) {
-		const a = pts2[j], b = pts2[j + 1];
-		const off = j * 6;
-		seg2Bounds[off] = Math.min(a.x, b.x);
-		seg2Bounds[off + 1] = Math.max(a.x, b.x);
-		seg2Bounds[off + 2] = Math.min(a.y, b.y);
-		seg2Bounds[off + 3] = Math.max(a.y, b.y);
-		seg2Bounds[off + 4] = (a.t + b.t) / 2;
-	}
-	const candidates = [];
-	const selfMinSep = (b1.last - b1.first) / 5;
-	for (let i = 0; i < N; i++) {
-		const p1a = pts1[i];
-		const p1b = pts1[i + 1];
-		const x1min = Math.min(p1a.x, p1b.x) - crossTol;
-		const x1max = Math.max(p1a.x, p1b.x) + crossTol;
-		const y1min = Math.min(p1a.y, p1b.y) - crossTol;
-		const y1max = Math.max(p1a.y, p1b.y) + crossTol;
-		const t1mid = (p1a.t + p1b.t) / 2;
-		for (let j = 0; j < N; j++) {
-			const off = j * 6;
-			if (x1max < seg2Bounds[off] || seg2Bounds[off + 1] < x1min) continue;
-			if (y1max < seg2Bounds[off + 2] || seg2Bounds[off + 3] < y1min) continue;
-			const t2mid = seg2Bounds[off + 4];
-			if (isSelf && Math.abs(t1mid - t2mid) < selfMinSep) continue;
-			candidates.push({
-				t1: t1mid,
-				t2: t2mid
-			});
-		}
-	}
-	const tol2 = tolerance * tolerance;
-	const found = [];
-	for (const { t1: t1Init, t2: t2Init } of candidates) {
-		let t1 = t1Init;
-		let t2 = t2Init;
-		for (let iter = 0; iter < 20; iter++) {
-			const [x1, y1] = evaluateCurve2d(c1, t1);
-			const [x2, y2] = evaluateCurve2d(c2, t2);
-			const dx = x1 - x2;
-			const dy = y1 - y2;
-			if (dx * dx + dy * dy < tol2) break;
-			const d1 = tangentCurve2d(c1, t1);
-			const d2 = tangentCurve2d(c2, t2);
-			const det = d1[0] * -d2[1] - -d2[0] * d1[1];
-			if (Math.abs(det) < 1e-14) break;
-			const dt1 = (-dx * -d2[1] - -dy * -d2[0]) / det;
-			const dt2 = (d1[0] * -dy - d1[1] * -dx) / det;
-			t1 += dt1;
-			t2 += dt2;
-			t1 = Math.max(b1.first, Math.min(b1.last, t1));
-			t2 = Math.max(b2.first, Math.min(b2.last, t2));
-		}
-		const [x1, y1] = evaluateCurve2d(c1, t1);
-		const [x2, y2] = evaluateCurve2d(c2, t2);
-		if (isSelf && Math.abs(t1 - t2) < (b1.last - b1.first) * .05) continue;
-		if ((x1 - x2) ** 2 + (y1 - y2) ** 2 < tolerance * tolerance * 1e6) {
-			const px = (x1 + x2) / 2;
-			const py = (y1 + y2) / 2;
-			let dup = false;
-			for (const [fx, fy] of found) if ((fx - px) ** 2 + (fy - py) ** 2 < tolerance * tolerance * 1e4) {
-				dup = true;
-				break;
-			}
-			if (!dup) found.push([px, py]);
-		}
-	}
-	return {
-		points: found,
-		segments: []
-	};
-}
-function serializeCurve2d(c) {
-	return JSON.stringify(c);
-}
-function deserializeCurve2d(data) {
-	return JSON.parse(data);
-}
-function createBBox2d() {
-	return {
-		__bk2d_bbox: true,
-		xMin: Infinity,
-		yMin: Infinity,
-		xMax: -Infinity,
-		yMax: -Infinity
-	};
-}
-function addCurveToBBox(bbox, c, _tol) {
-	const basis = c.__bk2d === "trimmed" ? c.basis : c;
-	if (basis.__bk2d === "line") {
-		const bounds = curveBounds(c);
-		if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
-		const [x0, y0] = evaluateCurve2d(c, bounds.first);
-		const [x1, y1] = evaluateCurve2d(c, bounds.last);
-		bbox.xMin = Math.min(bbox.xMin, x0, x1);
-		bbox.yMin = Math.min(bbox.yMin, y0, y1);
-		bbox.xMax = Math.max(bbox.xMax, x0, x1);
-		bbox.yMax = Math.max(bbox.yMax, y0, y1);
-		return;
-	}
-	if (basis.__bk2d === "circle") {
-		const bounds = curveBounds(c);
-		if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
-		const { cx, cy, radius, sense } = basis;
-		const [x0, y0] = evaluateCurve2d(c, bounds.first);
-		const [x1, y1] = evaluateCurve2d(c, bounds.last);
-		let xMin = Math.min(x0, x1), xMax = Math.max(x0, x1);
-		let yMin = Math.min(y0, y1), yMax = Math.max(y0, y1);
-		const tStart = c.__bk2d === "trimmed" ? c.tStart : bounds.first;
-		const tEnd = c.__bk2d === "trimmed" ? c.tEnd : bounds.last;
-		for (let k = 0; k < 4; k++) {
-			const angle = k * Math.PI / 2;
-			const t = sense ? angle : -angle;
-			for (let wrap = 0; wrap <= 1; wrap++) {
-				const tt = t + wrap * 2 * Math.PI;
-				if (tt >= tStart - 1e-10 && tt <= tEnd + 1e-10) {
-					const ex = cx + radius * Math.cos(angle);
-					const ey = cy + radius * Math.sin(angle);
-					xMin = Math.min(xMin, ex);
-					xMax = Math.max(xMax, ex);
-					yMin = Math.min(yMin, ey);
-					yMax = Math.max(yMax, ey);
-					break;
-				}
-			}
-		}
-		bbox.xMin = Math.min(bbox.xMin, xMin);
-		bbox.yMin = Math.min(bbox.yMin, yMin);
-		bbox.xMax = Math.max(bbox.xMax, xMax);
-		bbox.yMax = Math.max(bbox.yMax, yMax);
-		return;
-	}
-	const bounds = curveBounds(c);
-	if (!isFinite(bounds.first) || !isFinite(bounds.last)) return;
-	const nSamples = 20;
-	const dt = (bounds.last - bounds.first) / nSamples;
-	for (let i = 0; i <= nSamples; i++) {
-		const [x, y] = evaluateCurve2d(c, bounds.first + i * dt);
-		if (x < bbox.xMin) bbox.xMin = x;
-		if (y < bbox.yMin) bbox.yMin = y;
-		if (x > bbox.xMax) bbox.xMax = x;
-		if (y > bbox.yMax) bbox.yMax = y;
-	}
-}
-function evaluateBezier(poles, t) {
-	const n = poles.length;
-	const work = poles.map(([x, y]) => [x, y]);
-	for (let r = 1; r < n; r++) for (let i = 0; i < n - r; i++) {
-		const wi = work[i];
-		const wi1 = work[i + 1];
-		wi[0] = (1 - t) * wi[0] + t * wi1[0];
-		wi[1] = (1 - t) * wi[1] + t * wi1[1];
-	}
-	return work[0];
-}
-function evaluateBSpline2d(c, t) {
-	const fullKnots = [];
-	for (let i = 0; i < c.knots.length; i++) {
-		const mult = c.multiplicities[i] ?? 1;
-		for (let j = 0; j < mult; j++) fullKnots.push(c.knots[i]);
-	}
-	const p = c.degree;
-	const n = c.poles.length;
-	const k = fullKnots.length;
-	const tClamped = Math.max(fullKnots[p], Math.min(fullKnots[k - p - 1], t));
-	let span = p;
-	for (let i = p; i < k - p - 1; i++) if (tClamped >= fullKnots[i] && tClamped < fullKnots[i + 1]) {
-		span = i;
-		break;
-	}
-	if (tClamped >= fullKnots[k - p - 1]) span = k - p - 2;
-	const d = [];
-	for (let j = 0; j <= p; j++) {
-		const idx = Math.min(span - p + j, n - 1);
-		const pole = c.poles[Math.max(0, idx)];
-		d.push([pole[0], pole[1]]);
-	}
-	for (let r = 1; r <= p; r++) for (let j = p; j >= r; j--) {
-		const i = span - p + j;
-		const left = fullKnots[i] ?? 0;
-		const denom = (fullKnots[i + p - r + 1] ?? 1) - left;
-		const alpha = denom > 1e-15 ? (tClamped - left) / denom : 0;
-		const dj = d[j];
-		const djPrev = d[j - 1];
-		dj[0] = (1 - alpha) * djPrev[0] + alpha * dj[0];
-		dj[1] = (1 - alpha) * djPrev[1] + alpha * dj[1];
-	}
-	return d[p];
-}
-//#endregion
-//#region src/kernel/occtWasm/occtWasmAdapter.ts
-var noop = () => {};
-function handle(type, id) {
-	return {
-		__occtWasm: true,
-		type,
-		id,
-		delete: noop,
-		HashCode(upperBound) {
-			return id % upperBound;
-		},
-		IsNull() {
-			return false;
-		}
-	};
-}
-function isOcctWasmHandle(shape) {
-	return typeof shape === "object" && shape !== null && shape.__occtWasm;
-}
-/** Extract the u32 id from a handle. */
-function unwrap(shape) {
-	if (isOcctWasmHandle(shape)) return shape.id;
-	if (typeof shape === "number") return shape;
-	throw new Error("occt-wasm: expected an OcctWasmHandle or number, got " + typeof shape);
-}
-/** Map a WASM shape type string to our ShapeType enum. */
-function mapShapeType(wasmType) {
-	switch (wasmType.toLowerCase()) {
-		case "vertex": return "vertex";
-		case "edge": return "edge";
-		case "wire": return "wire";
-		case "face": return "face";
-		case "shell": return "shell";
-		case "solid": return "solid";
-		case "compsolid": return "compsolid";
-		case "compound": return "compound";
-		default: return "compound";
-	}
-}
-/** Wrap a WASM u32 result as a typed handle, querying the kernel for type. */
-function wrapResult(kernel, id) {
-	return handle(mapShapeType(kernel.getShapeType(id)), id);
-}
-function makeVecU32(Module, values) {
-	const vec = new Module.VectorUint32();
-	for (const v of values) vec.push_back(v);
-	return vec;
-}
-function makeVecInt(Module, values) {
-	const vec = new Module.VectorInt();
-	for (const v of values) vec.push_back(v);
-	return vec;
-}
-function makeVecDouble(Module, values) {
-	const vec = new Module.VectorDouble();
-	for (const v of values) vec.push_back(v);
-	return vec;
-}
-function readVecInt(vec) {
-	const result = [];
-	const n = vec.size();
-	for (let i = 0; i < n; i++) result.push(vec.get(i));
-	return result;
-}
-/**
-* Parse an EvolutionData result from the WASM kernel into a ShapeEvolution.
-*
-* The C++ facade returns flat vectors of [inputHash, outputHash, inputHash, outputHash, ...]
-* for modified and generated, and a flat vector of deleted input hashes.
-*/
-function parseEvolution(evo) {
-	try {
-		const modifiedRaw = readVecInt(evo.modified);
-		const generatedRaw = readVecInt(evo.generated);
-		const deletedRaw = readVecInt(evo.deleted);
-		const parseMap = (raw) => {
-			const map = /* @__PURE__ */ new Map();
-			let i = 0;
-			while (i + 1 < raw.length) {
-				const inputHash = raw[i] ?? 0;
-				const count = raw[i + 1] ?? 0;
-				i += 2;
-				const outputs = [];
-				for (let j = 0; j < count && i < raw.length; j++, i++) outputs.push(raw[i] ?? 0);
-				map.set(inputHash, outputs);
-			}
-			return map;
-		};
-		const modified = parseMap(modifiedRaw);
-		const generated = parseMap(generatedRaw);
-		const deleted = new Set(deletedRaw);
-		return {
-			id: evo.resultId,
-			evolution: {
-				modified,
-				generated,
-				deleted
-			}
-		};
-	} finally {
-		evo.delete();
-	}
-}
-function notImplemented(method) {
-	throw new Error(`occt-wasm: ${method} is not yet implemented`);
-}
-function computePositionBounds(positions, vCount) {
-	if (vCount === 0) return {
-		min: [
-			0,
-			0,
-			0
-		],
-		max: [
-			0,
-			0,
-			0
-		]
-	};
-	let minX = Infinity, minY = Infinity, minZ = Infinity;
-	let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
-	for (let i = 0; i < vCount; i++) {
-		const o = i * 3;
-		const x = positions[o] ?? 0;
-		const y = positions[o + 1] ?? 0;
-		const z = positions[o + 2] ?? 0;
-		if (x < minX) minX = x;
-		if (y < minY) minY = y;
-		if (z < minZ) minZ = z;
-		if (x > maxX) maxX = x;
-		if (y > maxY) maxY = y;
-		if (z > maxZ) maxZ = z;
-	}
-	return {
-		min: [
-			minX,
-			minY,
-			minZ
-		],
-		max: [
-			maxX,
-			maxY,
-			maxZ
-		]
-	};
-}
-function buildGltfManifest(vCount, nCount, iCount, posBytes, nrmBytes, idxBytes, bufferLength, bounds) {
-	return {
-		asset: {
-			version: "2.0",
-			generator: "brepjs occt-wasm"
-		},
-		scene: 0,
-		scenes: [{ nodes: [0] }],
-		nodes: [{ mesh: 0 }],
-		meshes: [{ primitives: [{
-			attributes: {
-				POSITION: 0,
-				NORMAL: 1
-			},
-			indices: 2,
-			mode: 4
-		}] }],
-		buffers: [{ byteLength: bufferLength }],
-		bufferViews: [
-			{
-				buffer: 0,
-				byteOffset: 0,
-				byteLength: posBytes,
-				target: 34962
-			},
-			{
-				buffer: 0,
-				byteOffset: posBytes,
-				byteLength: nrmBytes,
-				target: 34962
-			},
-			{
-				buffer: 0,
-				byteOffset: posBytes + nrmBytes,
-				byteLength: idxBytes,
-				target: 34963
-			}
-		],
-		accessors: [
-			{
-				bufferView: 0,
-				componentType: 5126,
-				count: vCount,
-				type: "VEC3",
-				min: bounds.min,
-				max: bounds.max
-			},
-			{
-				bufferView: 1,
-				componentType: 5126,
-				count: nCount,
-				type: "VEC3"
-			},
-			{
-				bufferView: 2,
-				componentType: 5125,
-				count: iCount,
-				type: "SCALAR"
-			}
-		]
-	};
-}
-/**
-* Wrap an OcctKernelWasm instance so that every method call converts
-* C++ exceptions (WebAssembly.Exception) into readable JS Errors.
-*/
-function wrapKernelExceptions(kernel, mod) {
-	return new Proxy(kernel, { get(target, prop, receiver) {
-		const val = Reflect.get(target, prop, receiver);
-		if (typeof val !== "function") return val;
-		return function(...args) {
-			try {
-				return val.apply(target, args);
-			} catch (ex) {
-				const WasmException = WebAssembly.Exception;
-				if (WasmException && ex instanceof WasmException) try {
-					const [, msg] = mod.getExceptionMessage(ex);
-					throw new Error(msg, { cause: ex });
-				} catch (inner) {
-					if (inner instanceof Error && !(inner instanceof WasmException)) throw inner;
-				}
-				throw ex;
-			}
-		};
-	} });
-}
-/**
-* Resolve a callback-style radius/distance to a uniform number.
-* occt-wasm only supports uniform fillet/chamfer per call.
-*/
-function resolveUniformRadius(edges, radius) {
-	if (typeof radius === "number") return radius;
-	if (Array.isArray(radius)) return radius[0];
-	if (edges.length === 0) throw new Error("occt-wasm: no edges provided");
-	const val = radius(edges[0]);
-	return typeof val === "number" ? val : val[0];
-}
-/** Rotate a shape from Z-axis to an arbitrary direction. */
-function rotateZToDirection(k, shapeId, dir) {
-	const [dx, dy, dz] = dir;
-	const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
-	if (len < 1e-10) return shapeId;
-	const nx = dx / len, ny = dy / len, nz = dz / len;
-	if (Math.abs(nz - 1) < 1e-10) return shapeId;
-	if (Math.abs(nz + 1) < 1e-10) return k.rotate(shapeId, 0, 0, 0, 1, 0, 0, Math.PI);
-	const ax = -ny, ay = nx;
-	const axLen = Math.sqrt(ax * ax + ay * ay);
-	if (axLen < 1e-10) return shapeId;
-	const angle = Math.acos(Math.max(-1, Math.min(1, nz)));
-	return k.rotate(shapeId, 0, 0, 0, ax / axLen, ay / axLen, 0, angle);
-}
-/**
-* Collect 3D sample points from a shape for nearest-pair queries: every
-* topological vertex, plus tessellation vertices when the shape carries
-* surfaces. Used by distance() to approximate witness points.
-*/
-function collectDistanceSamples(k, mod, shapeId) {
-	const out = [];
-	const verts = k.getSubShapes(shapeId, "vertex");
-	try {
-		const n = verts.size();
-		for (let i = 0; i < n; i++) {
-			const p = k.vertexPosition(verts.get(i));
-			out.push([
-				p.get(0),
-				p.get(1),
-				p.get(2)
-			]);
-			p.delete();
-		}
-	} finally {
-		verts.delete();
-	}
-	const bb = k.getBoundingBox(shapeId, true);
-	const diag = Math.sqrt((bb.xmax - bb.xmin) ** 2 + (bb.ymax - bb.ymin) ** 2 + (bb.zmax - bb.zmin) ** 2);
-	const linDef = Math.max(diag * .01, 1e-4);
-	let mesh;
-	try {
-		mesh = k.tessellate(shapeId, linDef, .5);
-	} catch {
-		return out;
-	}
-	try {
-		const posCount = mesh.positionCount;
-		if (posCount > 0) {
-			const ptr = mesh.getPositionsPtr() >> 2;
-			const heap = mod.HEAPF32;
-			const MAX_MESH_SAMPLES = 256;
-			const vertexCount = Math.floor(posCount / 3);
-			const step = (vertexCount > MAX_MESH_SAMPLES ? Math.ceil(vertexCount / MAX_MESH_SAMPLES) : 1) * 3;
-			for (let i = 0; i < posCount; i += step) out.push([
-				heap[ptr + i] ?? 0,
-				heap[ptr + i + 1] ?? 0,
-				heap[ptr + i + 2] ?? 0
-			]);
-		}
-	} finally {
-		mesh.delete();
-	}
-	return out;
-}
-/** Read a 3D point on a surface via the WASM facade. */
-function pointAt(k, faceId, u, v) {
-	const p = k.pointOnSurface(faceId, u, v);
-	const r = [
-		p.get(0),
-		p.get(1),
-		p.get(2)
-	];
-	p.delete();
-	return r;
-}
-/**
-* Compute principal curvature directions at (u, v) via finite-difference
-* fundamental forms. The C++ facade exposes only k1 and k2 as scalars; this
-* helper recovers the corresponding tangent directions in 3D space.
-*
-* Step sizes are clamped so all sample points stay inside the parametric
-* domain, with a one-sided fallback near the boundary. For elementary
-* surfaces (plane, sphere) where curvature is direction-degenerate, returns
-* any orthonormal pair tangent to the surface.
-*/
-function computePrincipalDirections(k, faceId, u, v, maxK, minK) {
-	const { Pu, Pv, Puu, Pvv, Puv } = surfaceDerivatives(k, faceId, u, v);
-	const nx = Pu[1] * Pv[2] - Pu[2] * Pv[1];
-	const ny = Pu[2] * Pv[0] - Pu[0] * Pv[2];
-	const nz = Pu[0] * Pv[1] - Pu[1] * Pv[0];
-	const nlen = Math.sqrt(nx * nx + ny * ny + nz * nz);
-	const E = Pu[0] * Pu[0] + Pu[1] * Pu[1] + Pu[2] * Pu[2];
-	const F = Pu[0] * Pv[0] + Pu[1] * Pv[1] + Pu[2] * Pv[2];
-	const G = Pv[0] * Pv[0] + Pv[1] * Pv[1] + Pv[2] * Pv[2];
-	if (nlen < 1e-12 || E * G - F * F < 1e-24) return degenerateOrthoFrame(Pu, Pv);
-	const e = (Puu[0] * nx + Puu[1] * ny + Puu[2] * nz) / nlen;
-	const f = (Puv[0] * nx + Puv[1] * ny + Puv[2] * nz) / nlen;
-	const g = (Pvv[0] * nx + Pvv[1] * ny + Pvv[2] * nz) / nlen;
-	const det = E * G - F * F;
-	const w11 = (e * G - f * F) / det;
-	const w12 = (f * G - g * F) / det;
-	const w21 = (f * E - e * F) / det;
-	const w22 = (g * E - f * F) / det;
-	if (Math.abs(maxK - minK) < 1e-9 * (Math.abs(maxK) + Math.abs(minK) + 1)) return degenerateOrthoFrame(Pu, Pv);
-	const dirMax2D = eigenvector2x2(w11 - maxK, w12, w21, w22 - maxK);
-	const dirMin2D = eigenvector2x2(w11 - minK, w12, w21, w22 - minK);
-	return {
-		maxDirection: liftAndNormalize(dirMax2D, Pu, Pv),
-		minDirection: liftAndNormalize(dirMin2D, Pu, Pv)
-	};
-}
-/**
-* Sample a 9-point stencil around (u, v) and return central-difference
-* partial derivatives Pu, Pv, Puu, Pvv, Puv. Step size is 1e-3 of the
-* parametric range (clamped at 1e-6) — the sweet spot between truncation
-* error and float-eval noise. Near the boundary the stencil shifts inward
-* so all sample points stay in the domain.
-*/
-function surfaceDerivatives(k, faceId, u, v) {
-	const bounds = k.uvBounds(faceId);
-	const uMin = bounds.get(0);
-	const uMax = bounds.get(1);
-	const vMin = bounds.get(2);
-	const vMax = bounds.get(3);
-	bounds.delete();
-	const hu = Math.max(Math.max(uMax - uMin, 1e-12) * .001, 1e-6);
-	const hv = Math.max(Math.max(vMax - vMin, 1e-12) * .001, 1e-6);
-	const uc = Math.min(Math.max(u, uMin + hu), uMax - hu);
-	const vc = Math.min(Math.max(v, vMin + hv), vMax - hv);
-	const P = pointAt(k, faceId, uc, vc);
-	const Pup = pointAt(k, faceId, uc + hu, vc);
-	const Pum = pointAt(k, faceId, uc - hu, vc);
-	const Pvp = pointAt(k, faceId, uc, vc + hv);
-	const Pvm = pointAt(k, faceId, uc, vc - hv);
-	const Ppp = pointAt(k, faceId, uc + hu, vc + hv);
-	const Ppm = pointAt(k, faceId, uc + hu, vc - hv);
-	const Pmp = pointAt(k, faceId, uc - hu, vc + hv);
-	const Pmm = pointAt(k, faceId, uc - hu, vc - hv);
-	const huu = hu * hu;
-	const hvv = hv * hv;
-	const huv4 = 4 * hu * hv;
-	return {
-		Pu: [
-			(Pup[0] - Pum[0]) / (2 * hu),
-			(Pup[1] - Pum[1]) / (2 * hu),
-			(Pup[2] - Pum[2]) / (2 * hu)
-		],
-		Pv: [
-			(Pvp[0] - Pvm[0]) / (2 * hv),
-			(Pvp[1] - Pvm[1]) / (2 * hv),
-			(Pvp[2] - Pvm[2]) / (2 * hv)
-		],
-		Puu: [
-			(Pup[0] - 2 * P[0] + Pum[0]) / huu,
-			(Pup[1] - 2 * P[1] + Pum[1]) / huu,
-			(Pup[2] - 2 * P[2] + Pum[2]) / huu
-		],
-		Pvv: [
-			(Pvp[0] - 2 * P[0] + Pvm[0]) / hvv,
-			(Pvp[1] - 2 * P[1] + Pvm[1]) / hvv,
-			(Pvp[2] - 2 * P[2] + Pvm[2]) / hvv
-		],
-		Puv: [
-			(Ppp[0] - Ppm[0] - Pmp[0] + Pmm[0]) / huv4,
-			(Ppp[1] - Ppm[1] - Pmp[1] + Pmm[1]) / huv4,
-			(Ppp[2] - Ppm[2] - Pmp[2] + Pmm[2]) / huv4
-		]
-	};
-}
-/**
-* Return a non-zero eigenvector of the singular matrix [[a,b],[c,d]] (whose
-* eigenvalue is implicit — caller has already subtracted λ from the diagonal).
-* Picks the row with the larger magnitude for numerical stability.
-*/
-function eigenvector2x2(a, b, c, d) {
-	if (Math.abs(a) + Math.abs(b) >= Math.abs(c) + Math.abs(d)) {
-		if (Math.abs(a) + Math.abs(b) < 1e-12) return [1, 0];
-		return [-b, a];
-	}
-	if (Math.abs(c) + Math.abs(d) < 1e-12) return [0, 1];
-	return [-d, c];
-}
-/** Map a 2D tangent vector (a·Pu + b·Pv) to a unit 3D direction. */
-function liftAndNormalize(ab, Pu, Pv) {
-	const x = ab[0] * Pu[0] + ab[1] * Pv[0];
-	const y = ab[0] * Pu[1] + ab[1] * Pv[1];
-	const z = ab[0] * Pu[2] + ab[1] * Pv[2];
-	const len = Math.sqrt(x * x + y * y + z * z);
-	if (len < 1e-12) return [
-		1,
-		0,
-		0
-	];
-	return [
-		x / len,
-		y / len,
-		z / len
-	];
-}
-/**
-* Fallback when curvature is direction-degenerate: return an orthonormal
-* tangent frame derived from Pu and the Gram-Schmidt-corrected Pv.
-*/
-function degenerateOrthoFrame(Pu, Pv) {
-	const uLen = Math.sqrt(Pu[0] * Pu[0] + Pu[1] * Pu[1] + Pu[2] * Pu[2]);
-	if (uLen < 1e-12) return {
-		maxDirection: [
-			1,
-			0,
-			0
-		],
-		minDirection: [
-			0,
-			1,
-			0
-		]
-	};
-	const ux = Pu[0] / uLen, uy = Pu[1] / uLen, uz = Pu[2] / uLen;
-	const dot = ux * Pv[0] + uy * Pv[1] + uz * Pv[2];
-	const vx = Pv[0] - dot * ux;
-	const vy = Pv[1] - dot * uy;
-	const vz = Pv[2] - dot * uz;
-	const vLen = Math.sqrt(vx * vx + vy * vy + vz * vz);
-	if (vLen < 1e-12) {
-		const ax = Math.abs(ux) < .9 ? [
-			1,
-			0,
-			0
-		] : [
-			0,
-			1,
-			0
-		];
-		const ox = uy * ax[2] - uz * ax[1];
-		const oy = uz * ax[0] - ux * ax[2];
-		const oz = ux * ax[1] - uy * ax[0];
-		const oLen = Math.sqrt(ox * ox + oy * oy + oz * oz) || 1;
-		return {
-			maxDirection: [
-				ux,
-				uy,
-				uz
-			],
-			minDirection: [
-				ox / oLen,
-				oy / oLen,
-				oz / oLen
-			]
-		};
-	}
-	return {
-		maxDirection: [
-			ux,
-			uy,
-			uz
-		],
-		minDirection: [
-			vx / vLen,
-			vy / vLen,
-			vz / vLen
-		]
-	};
-}
-var OcctWasmAdapter = class {
-	oc;
-	kernelId = "occt-wasm";
-	Module;
-	k;
-	constructor(module, kernel) {
-		this.Module = module;
-		this.k = wrapKernelExceptions(kernel, module);
-		const k = this.k;
-		const makeNull = () => handle("compound", k.makeNullShape());
-		this.oc = Object.assign(Object.create(module), {
-			TopoDS_Solid: function() {
-				return makeNull();
-			},
-			TopoDS_Face: function() {
-				return makeNull();
-			},
-			TopoDS_Shape: function() {
-				return makeNull();
-			},
-			TopoDS_Wire: function() {
-				return makeNull();
-			},
-			TopoDS_Edge: function() {
-				return makeNull();
-			},
-			TopoDS_Vertex: function() {
-				return makeNull();
-			},
-			TopoDS_Shell: function() {
-				return makeNull();
-			},
-			TopoDS_Compound: function() {
-				return makeNull();
-			},
-			gp_Pnt_3: function(x, y, z) {
-				return handle("vertex", k.makeVertex(x, y, z));
-			},
-			BRepBuilderAPI_MakeEdge_3: function(p1, p2) {
-				const v1 = p1;
-				const v2 = p2;
-				const pos1 = k.vertexPosition(v1.id);
-				const pos2 = k.vertexPosition(v2.id);
-				const edgeId = k.makeLineEdge(pos1.get(0), pos1.get(1), pos1.get(2), pos2.get(0), pos2.get(1), pos2.get(2));
-				pos1.delete();
-				pos2.delete();
-				return {
-					Edge: () => handle("edge", edgeId),
-					delete() {}
-				};
-			}
-		});
-	}
-	dispose(h) {
-		if (isOcctWasmHandle(h)) this.k.release(h.id);
-		else if (typeof h.delete === "function") h.delete();
-	}
-	executeBatch(_json) {
-		notImplemented("executeBatch");
-	}
-	checkpoint() {
-		notImplemented("checkpoint");
-	}
-	checkpointCount() {
-		notImplemented("checkpointCount");
-	}
-	restoreCheckpoint(_cp) {
-		notImplemented("restoreCheckpoint");
-	}
-	discardCheckpoint(_cp) {
-		notImplemented("discardCheckpoint");
-	}
-	makeBox(width, height, depth) {
-		return handle("solid", this.k.makeBox(width, height, depth));
-	}
-	makeCylinder(radius, height, center, direction) {
-		let id = this.k.makeCylinder(radius, height);
-		if (direction) id = rotateZToDirection(this.k, id, direction);
-		if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) id = this.k.translate(id, center[0], center[1], center[2]);
-		return handle("solid", id);
-	}
-	makeSphere(radius, center) {
-		let id = this.k.makeSphere(radius);
-		if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) id = this.k.translate(id, center[0], center[1], center[2]);
-		return handle("solid", id);
-	}
-	makeCone(radius1, radius2, height, center, direction) {
-		let id = this.k.makeCone(radius1, radius2, height);
-		if (direction) id = rotateZToDirection(this.k, id, direction);
-		if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) id = this.k.translate(id, center[0], center[1], center[2]);
-		return handle("solid", id);
-	}
-	makeTorus(majorRadius, minorRadius, center, direction) {
-		let id = this.k.makeTorus(majorRadius, minorRadius);
-		if (direction) id = rotateZToDirection(this.k, id, direction);
-		if (center && (center[0] !== 0 || center[1] !== 0 || center[2] !== 0)) id = this.k.translate(id, center[0], center[1], center[2]);
-		return handle("solid", id);
-	}
-	makeEllipsoid(aLength, bLength, cLength) {
-		return handle("solid", this.k.makeEllipsoid(aLength, bLength, cLength));
-	}
-	makeBoxFromCorners(p1, p2) {
-		return handle("solid", this.k.makeBoxFromCorners(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
-	}
-	makeRectangle(width, height) {
-		return handle("face", this.k.makeRectangle(width, height));
-	}
-	fuse(shape, tool, _options) {
-		return wrapResult(this.k, this.k.fuse(unwrap(shape), unwrap(tool)));
-	}
-	cut(shape, tool, _options) {
-		return wrapResult(this.k, this.k.cut(unwrap(shape), unwrap(tool)));
-	}
-	intersect(shape, tool, _options) {
-		return wrapResult(this.k, this.k.intersect(unwrap(shape), unwrap(tool)));
-	}
-	section(shape, plane, _approximation) {
-		return wrapResult(this.k, this.k.section(unwrap(shape), unwrap(plane)));
-	}
-	fuseAll(shapes, _options) {
-		const vec = makeVecU32(this.Module, shapes.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.fuseAll(vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	cutAll(shape, tools, _options) {
-		const vec = makeVecU32(this.Module, tools.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.cutAll(unwrap(shape), vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	split(shape, tools) {
-		const vec = makeVecU32(this.Module, tools.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.split(unwrap(shape), vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	checkBoolean(shape, tool, _op) {
-		const issues = [];
-		if (this.k.isNull(unwrap(shape))) issues.push({
-			operand: "base",
-			issue: "null-shape",
-			message: "Base shape is null"
-		});
-		if (this.k.isNull(unwrap(tool))) issues.push({
-			operand: "tool",
-			issue: "null-shape",
-			message: "Tool shape is null"
-		});
-		if (issues.length === 0 && !this.k.isValid(unwrap(shape))) issues.push({
-			operand: "base",
-			issue: "not-valid",
-			message: "Base shape is not valid"
-		});
-		if (issues.length === 0 && !this.k.isValid(unwrap(tool))) issues.push({
-			operand: "tool",
-			issue: "not-valid",
-			message: "Tool shape is not valid"
-		});
-		return {
-			valid: issues.length === 0,
-			issues
-		};
-	}
-	meshBoolean(_positionsA, _indicesA, _positionsB, _indicesB, _op, _tolerance) {
-		throw new Error("occt-wasm: meshBoolean is not supported (use brepkit for mesh booleans)");
-	}
-	makeVertex(x, y, z) {
-		return handle("vertex", this.k.makeVertex(x, y, z));
-	}
-	makeEdge(curve, _start, _end) {
-		if (isOcctWasmHandle(curve)) notImplemented("makeEdge from curve handle");
-		notImplemented("makeEdge");
-	}
-	makeWire(edges) {
-		const vec = makeVecU32(this.Module, edges.map(unwrap));
-		try {
-			return handle("wire", this.k.makeWire(vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	makeFace(wire, _planar) {
-		return handle("face", this.k.makeFace(unwrap(wire)));
-	}
-	makeLineEdge(p1, p2) {
-		return handle("edge", this.k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
-	}
-	makeCircleEdge(center, normal, radius) {
-		return handle("edge", this.k.makeCircleEdge(center[0], center[1], center[2], normal[0], normal[1], normal[2], radius));
-	}
-	makeCircleArc(center, normal, radius, startAngle, endAngle) {
-		return handle("edge", this.k.makeCircleArc(center[0], center[1], center[2], normal[0], normal[1], normal[2], radius, startAngle, endAngle));
-	}
-	makeArcEdge(p1, p2, p3) {
-		return handle("edge", this.k.makeArcEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2], p3[0], p3[1], p3[2]));
-	}
-	makeEllipseEdge(center, normal, majorRadius, minorRadius, _xDir) {
-		return handle("edge", this.k.makeEllipseEdge(center[0], center[1], center[2], normal[0], normal[1], normal[2], majorRadius, minorRadius));
-	}
-	makeEllipseArc(center, normal, majorRadius, minorRadius, startAngle, endAngle, _xDir) {
-		return handle("edge", this.k.makeEllipseArc(center[0], center[1], center[2], normal[0], normal[1], normal[2], majorRadius, minorRadius, startAngle, endAngle));
-	}
-	makeBezierEdge(points) {
-		const flat = [];
-		for (const p of points) flat.push(p[0], p[1], p[2]);
-		const vec = makeVecDouble(this.Module, flat);
-		try {
-			return handle("edge", this.k.makeBezierEdge(vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	makeTangentArc(startPoint, startTangent, endPoint) {
-		const [x1, y1, z1] = startPoint;
-		const [tx, ty, tz] = startTangent;
-		const [x2, y2, z2] = endPoint;
-		return handle("edge", this.k.makeTangentArc(x1, y1, z1, tx, ty, tz, x2, y2, z2));
-	}
-	makeHelixWire(pitch, height, radius, center, direction, _leftHanded) {
-		const px = center ? center[0] : 0;
-		const py = center ? center[1] : 0;
-		const pz = center ? center[2] : 0;
-		const dx = direction ? direction[0] : 0;
-		const dy = direction ? direction[1] : 0;
-		const dz = direction ? direction[2] : 1;
-		return handle("wire", this.k.makeHelixWire(px, py, pz, dx, dy, dz, pitch, height, radius));
-	}
-	makeWireFromMixed(items) {
-		return this.makeWire(items);
-	}
-	makeCompound(shapes) {
-		const vec = makeVecU32(this.Module, shapes.map(unwrap));
-		try {
-			return handle("compound", this.k.makeCompound(vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	solidFromShell(shell) {
-		return handle("solid", this.k.solidFromShell(unwrap(shell)));
-	}
-	hull(_shapes, _tolerance) {
-		notImplemented("hull");
-	}
-	hullFromPoints(points, tolerance) {
-		if (points.length < 4) throw new Error("hullFromPoints: need at least 4 points");
-		const faces = computeConvexHullFaces(points);
-		return this.buildSolidFromFaces(points, faces, tolerance);
-	}
-	buildSolidFromFaces(points, faces, tolerance) {
-		const faceIds = [];
-		for (const [i0, i1, i2] of faces) {
-			const p0 = points[i0];
-			const p1 = points[i1];
-			const p2 = points[i2];
-			if (!p0 || !p1 || !p2) continue;
-			faceIds.push(this.k.buildTriFace(p0.x, p0.y, p0.z, p1.x, p1.y, p1.z, p2.x, p2.y, p2.z));
-		}
-		const vec = makeVecU32(this.Module, faceIds);
-		try {
-			let sewn = this.k.sewAndSolidify(vec, tolerance);
-			sewn = this.k.fixFaceOrientations(sewn);
-			return wrapResult(this.k, sewn);
-		} finally {
-			vec.delete();
-		}
-	}
-	makeNonPlanarFace(wire) {
-		return handle("face", this.k.makeNonPlanarFace(unwrap(wire)));
-	}
-	addHolesInFace(face, holeWires) {
-		const vec = makeVecU32(this.Module, holeWires.map(unwrap));
-		try {
-			return handle("face", this.k.addHolesInFace(unwrap(face), vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	removeHolesFromFace(face) {
-		const allWires = this.k.getSubShapes(unwrap(face), "wire");
-		const holeCount = allWires.size() - 1;
-		allWires.delete();
-		const indices = [];
-		for (let i = 0; i < holeCount; i++) indices.push(i);
-		const vec = makeVecInt(this.Module, indices);
-		try {
-			return handle("face", this.k.removeHolesFromFace(unwrap(face), vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	makeFaceOnSurface(surface, wire) {
-		const faceId = unwrap(surface);
-		return handle("face", this.k.makeFaceOnSurface(faceId, unwrap(wire)));
-	}
-	bsplineSurface(points, rows, cols) {
-		const vec = new this.Module.VectorDouble();
-		for (const [x, y, z] of points) {
-			vec.push_back(x);
-			vec.push_back(y);
-			vec.push_back(z);
-		}
-		try {
-			return handle("face", this.k.bsplineSurface(vec, rows, cols));
-		} finally {
-			vec.delete();
-		}
-	}
-	triangulatedSurface(points, rows, cols) {
-		const faceIds = [];
-		for (let r = 0; r < rows - 1; r++) for (let c = 0; c < cols - 1; c++) {
-			const i00 = r * cols + c;
-			const i10 = (r + 1) * cols + c;
-			const i01 = r * cols + (c + 1);
-			const i11 = (r + 1) * cols + (c + 1);
-			const p00 = points[i00];
-			const p10 = points[i10];
-			const p01 = points[i01];
-			const p11 = points[i11];
-			if (p00 && p10 && p01) faceIds.push(this.k.buildTriFace(p00[0], p00[1], p00[2], p10[0], p10[1], p10[2], p01[0], p01[1], p01[2]));
-			if (p10 && p11 && p01) faceIds.push(this.k.buildTriFace(p10[0], p10[1], p10[2], p11[0], p11[1], p11[2], p01[0], p01[1], p01[2]));
-		}
-		const vec = makeVecU32(this.Module, faceIds);
-		try {
-			return wrapResult(this.k, this.k.sewAndSolidify(vec, .001));
-		} finally {
-			vec.delete();
-		}
-	}
-	buildTriFace(a, b, c) {
-		const id = this.k.buildTriFace(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
-		if (id === 0) return null;
-		return handle("face", id);
-	}
-	sewAndSolidify(faces, tolerance) {
-		const vec = makeVecU32(this.Module, faces.map(unwrap));
-		try {
-			let sewn = this.k.sewAndSolidify(vec, tolerance);
-			sewn = this.k.fixFaceOrientations(sewn);
-			return handle("solid", sewn);
-		} finally {
-			vec.delete();
-		}
-	}
-	createPoint3d(_x, _y, _z) {
-		return {
-			x: _x,
-			y: _y,
-			z: _z,
-			__type: "point3d",
-			delete: noop
-		};
-	}
-	createDirection3d(x, y, z) {
-		return {
-			x,
-			y,
-			z,
-			__type: "direction3d",
-			delete: noop
-		};
-	}
-	createVector3d(x, y, z) {
-		return {
-			x,
-			y,
-			z,
-			__type: "vector3d",
-			delete: noop
-		};
-	}
-	createAxis1(cx, cy, cz, dx, dy, dz) {
-		return {
-			origin: {
-				x: cx,
-				y: cy,
-				z: cz
-			},
-			direction: {
-				x: dx,
-				y: dy,
-				z: dz
-			},
-			__type: "axis1",
-			delete: noop
-		};
-	}
-	createAxis2(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
-		return {
-			origin: {
-				x: ox,
-				y: oy,
-				z: oz
-			},
-			zDir: {
-				x: zx,
-				y: zy,
-				z: zz
-			},
-			xDir: xx !== void 0 ? {
-				x: xx,
-				y: xy,
-				z: xz
-			} : void 0,
-			__type: "axis2",
-			delete: noop
-		};
-	}
-	createAxis3(ox, oy, oz, zx, zy, zz, xx, xy, xz) {
-		return {
-			origin: {
-				x: ox,
-				y: oy,
-				z: oz
-			},
-			zDir: {
-				x: zx,
-				y: zy,
-				z: zz
-			},
-			xDir: xx !== void 0 ? {
-				x: xx,
-				y: xy,
-				z: xz
-			} : void 0,
-			__type: "axis3",
-			delete: noop
-		};
-	}
-	extrude(face, direction, length) {
-		const dx = direction[0] * length;
-		const dy = direction[1] * length;
-		const dz = direction[2] * length;
-		return wrapResult(this.k, this.k.extrude(unwrap(face), dx, dy, dz));
-	}
-	revolve(shape, axis, angle) {
-		const o = axis.origin;
-		const d = axis.direction;
-		return wrapResult(this.k, this.k.revolve(unwrap(shape), o.x, o.y, o.z, d.x, d.y, d.z, angle));
-	}
-	loft(wires, ruled, _startShape, _endShape) {
-		const vec = makeVecU32(this.Module, wires.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.loft(vec, true, ruled ?? false));
-		} finally {
-			vec.delete();
-		}
-	}
-	sweep(wire, spine, options) {
-		const mode = options?.transitionMode ?? 0;
-		return wrapResult(this.k, this.k.sweep(unwrap(wire), unwrap(spine), mode));
-	}
-	simplePipe(profile, spine) {
-		return wrapResult(this.k, this.k.simplePipe(unwrap(profile), unwrap(spine)));
-	}
-	helicalSweep(_profile, _axisOrigin, _axisDirection, _radius, _pitch, _turns) {
-		throw new Error("helicalSweep on occt-wasm requires profile positioning+orientation logic not yet implemented; brepkit has a native implementation");
-	}
-	sweepWithOptions(_profile, _pathEdge, _contactMode, _scaleValues, _segments) {
-		notImplemented("sweepWithOptions");
-	}
-	sweepPipeShell(profile, spine, options) {
-		const freenet = options?.frenet ?? false;
-		const smooth = options?.transitionMode === "round";
-		const shellMode = options?.shellMode ?? false;
-		const result = wrapResult(this.k, this.k.sweepPipeShell(unwrap(profile), unwrap(spine), freenet, smooth));
-		if (shellMode) {
-			const edges = this.k.getSubShapes(unwrap(result), "wire");
-			try {
-				return {
-					shape: result,
-					firstShape: edges.size() > 0 ? wrapResult(this.k, edges.get(0)) : result,
-					lastShape: edges.size() > 1 ? wrapResult(this.k, edges.get(edges.size() - 1)) : result
-				};
-			} finally {
-				edges.delete();
-			}
-		}
-		return result;
-	}
-	loftAdvanced(wires, options) {
-		const isSolid = options?.solid ?? true;
-		const ruled = options?.ruled ?? false;
-		const startV = options?.startVertex ? unwrap(options.startVertex) : 0;
-		const endV = options?.endVertex ? unwrap(options.endVertex) : 0;
-		const vec = makeVecU32(this.Module, wires.map(unwrap));
-		try {
-			if (startV || endV) return wrapResult(this.k, this.k.loftWithVertices(vec, isSolid, ruled, startV, endV));
-			return wrapResult(this.k, this.k.loft(vec, isSolid, ruled));
-		} finally {
-			vec.delete();
-		}
-	}
-	buildExtrusionLaw(profile, length, endFactor) {
-		const law = {
-			__occtWasmLaw: true,
-			profile,
-			length,
-			endFactor,
-			Trim(first, last, _tol) {
-				return {
-					...law,
-					trimFirst: first,
-					trimLast: last
-				};
-			},
-			delete() {}
-		};
-		return law;
-	}
-	revolveVec(shape, center, direction, angle) {
-		return wrapResult(this.k, this.k.revolveVec(unwrap(shape), center[0], center[1], center[2], direction[0], direction[1], direction[2], angle));
-	}
-	draftPrism(shape, _face, _baseFace, height, angleDeg, _fuse) {
-		const h = height ?? 10;
-		return wrapResult(this.k, this.k.draftPrism(unwrap(shape), 0, 0, h, angleDeg));
-	}
-	fillet(shape, edges, radius) {
-		const r = resolveUniformRadius(edges, radius);
-		const vec = makeVecU32(this.Module, edges.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.fillet(unwrap(shape), vec, r));
-		} finally {
-			vec.delete();
-		}
-	}
-	chamfer(shape, edges, distance) {
-		const d = resolveUniformRadius(edges, distance);
-		const vec = makeVecU32(this.Module, edges.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.chamfer(unwrap(shape), vec, d));
-		} finally {
-			vec.delete();
-		}
-	}
-	chamferDistAngle(shape, edges, distance, angleDeg) {
-		const vec = makeVecU32(this.Module, edges.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.chamferDistAngle(unwrap(shape), vec, distance, angleDeg));
-		} finally {
-			vec.delete();
-		}
-	}
-	shell(shape, faces, thickness, tolerance) {
-		const vec = makeVecU32(this.Module, faces.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.shell(unwrap(shape), vec, thickness, tolerance ?? .001));
-		} finally {
-			vec.delete();
-		}
-	}
-	thicken(shape, thickness) {
-		return wrapResult(this.k, this.k.thicken(unwrap(shape), thickness, .001));
-	}
-	offset(shape, distance, tolerance) {
-		return wrapResult(this.k, this.k.offset(unwrap(shape), distance, tolerance ?? 1e-6));
-	}
-	filletVariable(shape, spec) {
-		const parsed = JSON.parse(spec);
-		if (parsed.edgeId !== void 0 && parsed.startRadius !== void 0 && parsed.endRadius !== void 0) return wrapResult(this.k, this.k.filletVariable(unwrap(shape), parsed.edgeId, parsed.startRadius, parsed.endRadius));
-		notImplemented("filletVariable (complex spec)");
-	}
-	draft(shape, faces, pullDirection, _neutralPlane, angleDeg) {
-		let currentId = unwrap(shape);
-		for (const face of faces) {
-			const angleRad = (typeof angleDeg === "function" ? angleDeg(face) : angleDeg) * Math.PI / 180;
-			currentId = this.k.draft(currentId, unwrap(face), angleRad, pullDirection[0], pullDirection[1], pullDirection[2]);
-		}
-		return wrapResult(this.k, currentId);
-	}
-	defeature(shape, faces) {
-		const vec = makeVecU32(this.Module, faces.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.defeature(unwrap(shape), vec, .001));
-		} finally {
-			vec.delete();
-		}
-	}
-	offsetWire2D(wire, offset, joinType) {
-		let jt = 0;
-		if (joinType === "intersection" || joinType === 1) jt = 1;
-		else if (joinType === "tangent" || joinType === 2) jt = 2;
-		else if (typeof joinType === "number") jt = joinType;
-		return wrapResult(this.k, this.k.offsetWire2D(unwrap(wire), offset, jt));
-	}
-	simplify(shape) {
-		return wrapResult(this.k, this.k.simplify(unwrap(shape)));
-	}
-	reverseShape(shape) {
-		return wrapResult(this.k, this.k.reverseShape(unwrap(shape)));
-	}
-	composeTransform(ops) {
-		let matrix = [
-			1,
-			0,
-			0,
-			0,
-			0,
-			1,
-			0,
-			0,
-			0,
-			0,
-			1,
-			0,
-			0,
-			0,
-			0,
-			1
-		];
-		for (const op of ops) if (op.type === "translate") matrix = multiplyMatrices4x4([
-			1,
-			0,
-			0,
-			op.x,
-			0,
-			1,
-			0,
-			op.y,
-			0,
-			0,
-			1,
-			op.z,
-			0,
-			0,
-			0,
-			1
-		], matrix);
-		else {
-			const ax = op.axis ?? [
-				0,
-				0,
-				1
-			];
-			const cn = op.center ?? [
-				0,
-				0,
-				0
-			];
-			const rad = op.angle * Math.PI / 180;
-			const c = Math.cos(rad);
-			const s = Math.sin(rad);
-			const t = 1 - c;
-			const len = Math.sqrt(ax[0] ** 2 + ax[1] ** 2 + ax[2] ** 2);
-			const [ux, uy, uz] = [
-				ax[0] / len,
-				ax[1] / len,
-				ax[2] / len
-			];
-			const r00 = t * ux * ux + c;
-			const r01 = t * ux * uy - s * uz;
-			const r02 = t * ux * uz + s * uy;
-			const r10 = t * uy * ux + s * uz;
-			const r11 = t * uy * uy + c;
-			const r12 = t * uy * uz - s * ux;
-			const r20 = t * uz * ux - s * uy;
-			const r21 = t * uz * uy + s * ux;
-			const r22 = t * uz * uz + c;
-			matrix = multiplyMatrices4x4([
-				r00,
-				r01,
-				r02,
-				cn[0] - (r00 * cn[0] + r01 * cn[1] + r02 * cn[2]),
-				r10,
-				r11,
-				r12,
-				cn[1] - (r10 * cn[0] + r11 * cn[1] + r12 * cn[2]),
-				r20,
-				r21,
-				r22,
-				cn[2] - (r20 * cn[0] + r21 * cn[1] + r22 * cn[2]),
-				0,
-				0,
-				0,
-				1
-			], matrix);
-		}
-		return {
-			handle: {
-				__type: "transform_matrix",
-				matrix,
-				delete: noop
-			},
-			dispose: noop
-		};
-	}
-	transform(shape, trsf) {
-		const t = trsf;
-		let matrix;
-		if (Array.isArray(t)) matrix = t;
-		else if (typeof t === "object") {
-			if (Array.isArray(t["matrix"])) {
-				matrix = t["matrix"];
-				if (matrix.length === 16) matrix = matrix.slice(0, 12);
-			} else if (Array.isArray(t["elements"])) matrix = t["elements"];
-		}
-		if (matrix) {
-			if (matrix.length === 16) matrix = matrix.slice(0, 12);
-			if (matrix.length >= 12) {
-				const vec = makeVecDouble(this.Module, matrix);
-				try {
-					return wrapResult(this.k, this.k.transform(unwrap(shape), vec));
-				} finally {
-					vec.delete();
-				}
-			}
-		}
-		return handle(this.k.getShapeType(unwrap(shape)), this.k.copy(unwrap(shape)));
-	}
-	translate(shape, x, y, z) {
-		return wrapResult(this.k, this.k.translate(unwrap(shape), x, y, z));
-	}
-	rotate(shape, angle, axis, center) {
-		const ax = axis ?? [
-			0,
-			0,
-			1
-		];
-		const cn = center ?? [
-			0,
-			0,
-			0
-		];
-		return wrapResult(this.k, this.k.rotate(unwrap(shape), cn[0], cn[1], cn[2], ax[0], ax[1], ax[2], angle));
-	}
-	mirror(shape, origin, normal) {
-		return wrapResult(this.k, this.k.mirror(unwrap(shape), origin[0], origin[1], origin[2], normal[0], normal[1], normal[2]));
-	}
-	scale(shape, center, factor) {
-		return wrapResult(this.k, this.k.scale(unwrap(shape), center[0], center[1], center[2], factor));
-	}
-	generalTransform(shape, linear, translation, _isOrthogonal) {
-		const matrix = [
-			linear[0],
-			linear[1],
-			linear[2],
-			translation[0],
-			linear[3],
-			linear[4],
-			linear[5],
-			translation[1],
-			linear[6],
-			linear[7],
-			linear[8],
-			translation[2]
-		];
-		const vec = makeVecDouble(this.Module, matrix);
-		try {
-			return wrapResult(this.k, this.k.generalTransform(unwrap(shape), vec));
-		} finally {
-			vec.delete();
-		}
-	}
-	generalTransformNonOrthogonal(shape, linear, translation) {
-		return this.generalTransform(shape, linear, translation, false);
-	}
-	positionOnCurve(shape, spine, param) {
-		const ptVec = this.k.curvePointAtParam(unwrap(spine), param);
-		const tgVec = this.k.curveTangent(unwrap(spine), param);
-		const px = ptVec.get(0), py = ptVec.get(1), pz = ptVec.get(2);
-		const tx = tgVec.get(0), ty = tgVec.get(1), tz = tgVec.get(2);
-		ptVec.delete();
-		tgVec.delete();
-		let ux, uy, uz;
-		if (Math.abs(tx) < .9) {
-			ux = 0;
-			uy = tz;
-			uz = -ty;
-		} else {
-			ux = -tz;
-			uy = 0;
-			uz = tx;
-		}
-		const uLen = Math.sqrt(ux * ux + uy * uy + uz * uz);
-		ux /= uLen;
-		uy /= uLen;
-		uz /= uLen;
-		const vx = ty * uz - tz * uy;
-		const vy = tz * ux - tx * uz;
-		const vz = tx * uy - ty * ux;
-		const mat = new this.Module.VectorDouble();
-		mat.push_back(ux);
-		mat.push_back(vx);
-		mat.push_back(tx);
-		mat.push_back(px);
-		mat.push_back(uy);
-		mat.push_back(vy);
-		mat.push_back(ty);
-		mat.push_back(py);
-		mat.push_back(uz);
-		mat.push_back(vz);
-		mat.push_back(tz);
-		mat.push_back(pz);
-		try {
-			return wrapResult(this.k, this.k.transform(unwrap(shape), mat));
-		} finally {
-			mat.delete();
-		}
-	}
-	linearPattern(shape, direction, spacing, count) {
-		const compoundId = this.k.linearPattern(unwrap(shape), direction[0], direction[1], direction[2], spacing, count);
-		const subVec = this.k.getSubShapes(compoundId, "solid");
-		const results = [];
-		const n = subVec.size();
-		for (let i = 0; i < n; i++) results.push(handle("solid", subVec.get(i)));
-		subVec.delete();
-		if (results.length === 0) {
-			const iter = this.k.iterShapes(compoundId);
-			const n2 = iter.size();
-			for (let i = 0; i < n2; i++) results.push(wrapResult(this.k, iter.get(i)));
-			iter.delete();
-		}
-		return results;
-	}
-	circularPattern(shape, center, axis, angleStep, count) {
-		const compoundId = this.k.circularPattern(unwrap(shape), center[0], center[1], center[2], axis[0], axis[1], axis[2], angleStep, count);
-		const subVec = this.k.getSubShapes(compoundId, "solid");
-		const results = [];
-		try {
-			const n = subVec.size();
-			for (let i = 0; i < n; i++) results.push(handle("solid", subVec.get(i)));
-		} finally {
-			subVec.delete();
-		}
-		if (results.length === 0) {
-			const iter = this.k.iterShapes(compoundId);
-			try {
-				const n2 = iter.size();
-				for (let i = 0; i < n2; i++) results.push(wrapResult(this.k, iter.get(i)));
-			} finally {
-				iter.delete();
-			}
-		}
-		return results;
-	}
-	transformBatch(entries) {
-		return entries.map((entry) => {
-			switch (entry.type) {
-				case "translate": return this.translate(entry.shape, entry.x, entry.y, entry.z);
-				case "rotate": return this.rotate(entry.shape, entry.angle, entry.axis, entry.center);
-				case "scale": return this.scale(entry.shape, entry.center, entry.factor);
-				case "mirror": return this.mirror(entry.shape, entry.origin, entry.normal);
-				default: notImplemented("transformBatch unknown type");
-			}
-		});
-	}
-	translateWithHistory(shape, x, y, z, inputFaceHashes, hashUpperBound) {
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.translateWithHistory(unwrap(shape), x, y, z, hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	rotateWithHistory(shape, angle, inputFaceHashes, hashUpperBound, axis, center) {
-		const ax = axis ?? [
-			0,
-			0,
-			1
-		];
-		const cn = center ?? [
-			0,
-			0,
-			0
-		];
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.rotateWithHistory(unwrap(shape), cn[0], cn[1], cn[2], ax[0], ax[1], ax[2], angle, hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	mirrorWithHistory(shape, origin, normal, inputFaceHashes, hashUpperBound) {
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.mirrorWithHistory(unwrap(shape), origin[0], origin[1], origin[2], normal[0], normal[1], normal[2], hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	scaleWithHistory(shape, center, factor, inputFaceHashes, hashUpperBound) {
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.scaleWithHistory(unwrap(shape), center[0], center[1], center[2], factor, hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	generalTransformWithHistory(shape, linear, translation, _isOrthogonal, inputFaceHashes, _hashUpperBound) {
-		const result = this.generalTransform(shape, linear, translation, _isOrthogonal);
-		const modified = /* @__PURE__ */ new Map();
-		for (const h of inputFaceHashes) modified.set(h, [h]);
-		return {
-			shape: result,
-			evolution: {
-				modified,
-				generated: /* @__PURE__ */ new Map(),
-				deleted: /* @__PURE__ */ new Set()
-			}
-		};
-	}
-	fuseWithHistory(shape, tool, inputFaceHashes, hashUpperBound, _options) {
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.fuseWithHistory(unwrap(shape), unwrap(tool), hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution,
-				diagnostics: {
-					hasErrors: false,
-					hasWarnings: false,
-					messages: []
-				}
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	cutWithHistory(shape, tool, inputFaceHashes, hashUpperBound, _options) {
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.cutWithHistory(unwrap(shape), unwrap(tool), hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution,
-				diagnostics: {
-					hasErrors: false,
-					hasWarnings: false,
-					messages: []
-				}
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	intersectWithHistory(shape, tool, inputFaceHashes, hashUpperBound, _options) {
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.intersectWithHistory(unwrap(shape), unwrap(tool), hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution,
-				diagnostics: {
-					hasErrors: false,
-					hasWarnings: false,
-					messages: []
-				}
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	filletWithHistory(shape, edges, radius, inputFaceHashes, hashUpperBound) {
-		const r = resolveUniformRadius(edges, radius);
-		const edgeVec = makeVecU32(this.Module, edges.map(unwrap));
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.filletWithHistory(unwrap(shape), edgeVec, r, hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			edgeVec.delete();
-			hashVec.delete();
-		}
-	}
-	chamferWithHistory(shape, edges, distance, inputFaceHashes, hashUpperBound) {
-		const d = resolveUniformRadius(edges, distance);
-		const edgeVec = makeVecU32(this.Module, edges.map(unwrap));
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.chamferWithHistory(unwrap(shape), edgeVec, d, hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			edgeVec.delete();
-			hashVec.delete();
-		}
-	}
-	shellWithHistory(shape, faces, thickness, inputFaceHashes, hashUpperBound, tolerance) {
-		const faceVec = makeVecU32(this.Module, faces.map(unwrap));
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.shellWithHistory(unwrap(shape), faceVec, thickness, tolerance ?? .001, hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			faceVec.delete();
-			hashVec.delete();
-		}
-	}
-	thickenWithHistory(shape, thickness, inputFaceHashes, hashUpperBound) {
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.thickenWithHistory(unwrap(shape), thickness, .001, hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	offsetWithHistory(shape, distance, inputFaceHashes, hashUpperBound, tolerance) {
-		const hashVec = makeVecInt(this.Module, inputFaceHashes);
-		try {
-			const { id, evolution } = parseEvolution(this.k.offsetWithHistory(unwrap(shape), distance, tolerance ?? 1e-6, hashVec, hashUpperBound));
-			return {
-				shape: wrapResult(this.k, id),
-				evolution
-			};
-		} finally {
-			hashVec.delete();
-		}
-	}
-	draftWithHistory(shape, faces, pullDirection, _neutralPlane, angleDeg, _inputFaceHashes, _hashUpperBound) {
-		const [dx, dy, dz] = pullDirection;
-		let currentId = unwrap(shape);
-		for (const face of faces) {
-			const angleRad = (typeof angleDeg === "number" ? angleDeg : angleDeg(face)) * Math.PI / 180;
-			currentId = this.k.draft(currentId, unwrap(face), angleRad, dx, dy, dz);
-		}
-		return {
-			shape: wrapResult(this.k, currentId),
-			evolution: {
-				modified: /* @__PURE__ */ new Map(),
-				generated: /* @__PURE__ */ new Map(),
-				deleted: /* @__PURE__ */ new Set()
-			}
-		};
-	}
-	applyComposedTransformWithHistory(shape, transformHandle, inputFaceHashes, hashUpperBound) {
-		const result = this.transform(shape, transformHandle);
-		const outFaces = this.iterShapes(result, "face");
-		const modified = /* @__PURE__ */ new Map();
-		const limit = Math.min(inputFaceHashes.length, outFaces.length);
-		for (let i = 0; i < limit; i++) {
-			const outFace = outFaces[i];
-			const inHash = inputFaceHashes[i];
-			if (outFace !== void 0 && inHash !== void 0) modified.set(inHash, [this.hashCode(outFace, hashUpperBound)]);
-		}
-		return {
-			shape: result,
-			evolution: {
-				modified,
-				generated: /* @__PURE__ */ new Map(),
-				deleted: /* @__PURE__ */ new Set()
-			}
-		};
-	}
-	mesh(shape, options) {
-		const meshData = this.k.tessellate(unwrap(shape), options.tolerance, options.angularTolerance);
-		const posCount = meshData.positionCount;
-		const normCount = meshData.normalCount;
-		const idxCount = meshData.indexCount;
-		const posPtr = meshData.getPositionsPtr() >> 2;
-		const normPtr = meshData.getNormalsPtr() >> 2;
-		const idxPtr = meshData.getIndicesPtr() >> 2;
-		const vertices = new Float32Array(posCount);
-		for (let i = 0; i < posCount; i++) vertices[i] = this.Module.HEAPF32[posPtr + i] ?? 0;
-		const normals = new Float32Array(normCount);
-		if (!options.skipNormals) for (let i = 0; i < normCount; i++) normals[i] = this.Module.HEAPF32[normPtr + i] ?? 0;
-		const triangles = new Uint32Array(idxCount);
-		for (let i = 0; i < idxCount; i++) triangles[i] = this.Module.HEAPU32[idxPtr + i] ?? 0;
-		const faceGroups = [];
-		const fgCount = meshData.faceGroupCount;
-		if (fgCount > 0) {
-			const fgPtr = meshData.getFaceGroupsPtr() >> 2;
-			for (let i = 0; i < fgCount; i += 3) faceGroups.push({
-				start: this.Module.HEAP32[fgPtr + i] ?? 0,
-				count: this.Module.HEAP32[fgPtr + i + 1] ?? 0,
-				faceHash: this.Module.HEAP32[fgPtr + i + 2] ?? 0
-			});
-		}
-		meshData.delete();
-		return {
-			vertices,
-			normals: options.skipNormals ? new Float32Array(0) : normals,
-			triangles,
-			uvs: new Float32Array(0),
-			faceGroups
-		};
-	}
-	meshEdges(shape, tolerance, _angularTolerance) {
-		const edgeData = this.k.wireframe(unwrap(shape), tolerance);
-		const pointCount = edgeData.pointCount;
-		const ptr = edgeData.getPointsPtr() >> 2;
-		const lines = new Float32Array(pointCount);
-		for (let i = 0; i < pointCount; i++) lines[i] = this.Module.HEAPF32[ptr + i] ?? 0;
-		const edgeGroups = [];
-		const egCount = edgeData.edgeGroupCount;
-		if (egCount > 0) {
-			const egPtr = edgeData.getEdgeGroupsPtr() >> 2;
-			for (let i = 0; i < egCount; i += 3) edgeGroups.push({
-				start: this.Module.HEAP32[egPtr + i] ?? 0,
-				count: this.Module.HEAP32[egPtr + i + 1] ?? 0,
-				edgeHash: this.Module.HEAP32[egPtr + i + 2] ?? 0
-			});
-		}
-		edgeData.delete();
-		return {
-			lines,
-			edgeGroups
-		};
-	}
-	hasTriangulation(shape) {
-		return this.k.hasTriangulation(unwrap(shape));
-	}
-	meshShape(shape, tolerance, angularTolerance) {
-		this.k.meshShape(unwrap(shape), tolerance, angularTolerance).delete();
-	}
-	exportSTEP(shapes) {
-		if (shapes.length === 1) return this.k.exportStep(unwrap(shapes[0]));
-		const compound = this.makeCompound(shapes);
-		return this.k.exportStep(unwrap(compound));
-	}
-	exportSTL(shape, binary) {
-		const ascii = !binary;
-		const result = this.k.exportStl(unwrap(shape), .1, ascii);
-		if (binary) {
-			const buf = new ArrayBuffer(result.length);
-			const view = new Uint8Array(buf);
-			for (let i = 0; i < result.length; i++) view[i] = result.charCodeAt(i);
-			return buf;
-		}
-		return result;
-	}
-	importSTEP(data) {
-		const str = typeof data === "string" ? data : new TextDecoder().decode(data);
-		const id = this.k.importStep(str);
-		return [wrapResult(this.k, id)];
-	}
-	importSTL(data) {
-		const bytes = typeof data === "string" ? new TextEncoder().encode(data) : new Uint8Array(data);
-		const mod = this.Module;
-		if (mod.FS) mod.FS.writeFile("/tmp/import.stl", bytes);
-		else {
-			const str = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
-			const id = this.k.importStl(str);
-			return wrapResult(this.k, id);
-		}
-		const id = this.k.importStl("");
-		return wrapResult(this.k, id);
-	}
-	exportIGES(shapes) {
-		if (shapes.length === 1) return this.k.exportIges(unwrap(shapes[0]));
-		const compound = this.makeCompound(shapes);
-		return this.k.exportIges(unwrap(compound));
-	}
-	importIGES(data) {
-		const str = typeof data === "string" ? data : new TextDecoder().decode(data);
-		const id = this.k.importIges(str);
-		return [wrapResult(this.k, id)];
-	}
-	exportSTEPAssembly(parts, _options) {
-		if (parts.length === 0) return "";
-		const doc = this.createXCAFDocument(parts);
-		try {
-			return this.writeXCAFToSTEP(doc);
-		} finally {
-			doc.delete();
-		}
-	}
-	export3MF(_shape, _tolerance) {
-		throw new Error("export3MF is only available with the brepkit kernel");
-	}
-	exportGLB(shape, tolerance) {
-		const result = this.mesh(shape, {
-			tolerance,
-			angularTolerance: .5,
-			skipNormals: false
-		});
-		const positions = result.vertices;
-		const normals = result.normals;
-		const indices = result.triangles;
-		const vCount = positions.length / 3;
-		const nCount = normals.length / 3;
-		const iCount = indices.length;
-		const posBytes = positions.byteLength;
-		const nrmBytes = normals.byteLength;
-		const idxBytes = indices.byteLength;
-		const binLength = posBytes + nrmBytes + idxBytes;
-		const paddedBinLength = binLength + (4 - binLength % 4) % 4;
-		const manifest = buildGltfManifest(vCount, nCount, iCount, posBytes, nrmBytes, idxBytes, paddedBinLength, computePositionBounds(positions, vCount));
-		const jsonBytes = new TextEncoder().encode(JSON.stringify(manifest));
-		const paddedJsonLength = jsonBytes.byteLength + (4 - jsonBytes.byteLength % 4) % 4;
-		const totalLength = 20 + paddedJsonLength + 8 + paddedBinLength;
-		const glb = new ArrayBuffer(totalLength);
-		const view = new DataView(glb);
-		view.setUint32(0, 1179937895, true);
-		view.setUint32(4, 2, true);
-		view.setUint32(8, totalLength, true);
-		view.setUint32(12, paddedJsonLength, true);
-		view.setUint32(16, 1313821514, true);
-		const jsonDst = new Uint8Array(glb, 20, paddedJsonLength);
-		jsonDst.set(jsonBytes);
-		for (let i = jsonBytes.byteLength; i < paddedJsonLength; i++) jsonDst[i] = 32;
-		const binHeaderOffset = 20 + paddedJsonLength;
-		view.setUint32(binHeaderOffset, paddedBinLength, true);
-		view.setUint32(binHeaderOffset + 4, 5130562, true);
-		const binDataOffset = binHeaderOffset + 8;
-		new Uint8Array(glb, binDataOffset, posBytes).set(new Uint8Array(positions.buffer, positions.byteOffset, posBytes));
-		new Uint8Array(glb, binDataOffset + posBytes, nrmBytes).set(new Uint8Array(normals.buffer, normals.byteOffset, nrmBytes));
-		new Uint8Array(glb, binDataOffset + posBytes + nrmBytes, idxBytes).set(new Uint8Array(indices.buffer, indices.byteOffset, idxBytes));
-		return glb;
-	}
-	exportOBJ(shape, tolerance) {
-		const result = this.mesh(shape, {
-			tolerance,
-			angularTolerance: .5,
-			skipNormals: false
-		});
-		const v = result.vertices;
-		const n = result.normals;
-		const t = result.triangles;
-		const lines = ["# brepjs OBJ export"];
-		const vCount = v.length / 3;
-		for (let i = 0; i < vCount; i++) {
-			const o = i * 3;
-			lines.push(`v ${v[o] ?? 0} ${v[o + 1] ?? 0} ${v[o + 2] ?? 0}`);
-		}
-		const nCount = n.length / 3;
-		for (let i = 0; i < nCount; i++) {
-			const o = i * 3;
-			lines.push(`vn ${n[o] ?? 0} ${n[o + 1] ?? 0} ${n[o + 2] ?? 0}`);
-		}
-		const pushTri = (offset) => {
-			const a = (t[offset] ?? 0) + 1;
-			const b = (t[offset + 1] ?? 0) + 1;
-			const c = (t[offset + 2] ?? 0) + 1;
-			lines.push(`f ${a}//${a} ${b}//${b} ${c}//${c}`);
-		};
-		if (result.faceGroups.length > 0) for (const group of result.faceGroups) {
-			lines.push(`g face_${group.faceHash}`);
-			const count = group.count / 3;
-			for (let i = 0; i < count; i++) pushTri(group.start + i * 3);
-		}
-		else {
-			const triCount = t.length / 3;
-			for (let i = 0; i < triCount; i++) pushTri(i * 3);
-		}
-		return new TextEncoder().encode(lines.join("\n") + "\n").buffer;
-	}
-	exportPLY(shape, tolerance) {
-		const result = this.mesh(shape, {
-			tolerance,
-			angularTolerance: .5,
-			skipNormals: false
-		});
-		const v = result.vertices;
-		const n = result.normals;
-		const t = result.triangles;
-		const vCount = v.length / 3;
-		const triCount = t.length / 3;
-		const hasNormals = n.length === v.length;
-		const lines = [
-			"ply",
-			"format ascii 1.0",
-			"comment brepjs PLY export",
-			`element vertex ${vCount}`,
-			"property float x",
-			"property float y",
-			"property float z"
-		];
-		if (hasNormals) lines.push("property float nx", "property float ny", "property float nz");
-		lines.push(`element face ${triCount}`, "property list uchar int vertex_index", "end_header");
-		for (let i = 0; i < vCount; i++) {
-			const o = i * 3;
-			const x = v[o] ?? 0;
-			const y = v[o + 1] ?? 0;
-			const z = v[o + 2] ?? 0;
-			if (hasNormals) {
-				const nx = n[o] ?? 0;
-				const ny = n[o + 1] ?? 0;
-				const nz = n[o + 2] ?? 0;
-				lines.push(`${x} ${y} ${z} ${nx} ${ny} ${nz}`);
-			} else lines.push(`${x} ${y} ${z}`);
-		}
-		for (let i = 0; i < triCount; i++) {
-			const a = t[i * 3] ?? 0;
-			const b = t[i * 3 + 1] ?? 0;
-			const c = t[i * 3 + 2] ?? 0;
-			lines.push(`3 ${a} ${b} ${c}`);
-		}
-		return new TextEncoder().encode(lines.join("\n") + "\n").buffer;
-	}
-	import3MF(_data) {
-		throw new Error("import3MF is only available with the brepkit kernel");
-	}
-	importOBJ(_data) {
-		throw new Error("importOBJ is only available with the brepkit kernel");
-	}
-	importGLB(_data) {
-		throw new Error("importGLB is only available with the brepkit kernel");
-	}
-	toBREP(shape) {
-		return this.k.toBREP(unwrap(shape));
-	}
-	fromBREP(data) {
-		return wrapResult(this.k, this.k.fromBREP(data));
-	}
-	createXCAFDocument(shapes) {
-		const ids = new this.Module.VectorUint32();
-		const nameParts = [];
-		const colors = new this.Module.VectorDouble();
-		for (const entry of shapes) {
-			ids.push_back(unwrap(entry.shape));
-			nameParts.push(entry.name);
-			const [r, g, b, a] = entry.color ?? [
-				.5,
-				.5,
-				.5,
-				1
-			];
-			colors.push_back(r);
-			colors.push_back(g);
-			colors.push_back(b);
-			colors.push_back(a);
-		}
-		try {
-			const joinedNames = nameParts.join("\0");
-			return handle("compound", this.k.createXCAFDocument(ids, joinedNames, colors));
-		} finally {
-			ids.delete();
-			colors.delete();
-		}
-	}
-	writeXCAFToSTEP(doc, _options) {
-		const id = unwrap(doc);
-		const subs = this.k.getSubShapes(id, "solid");
-		const hasSolids = subs.size() > 0;
-		subs.delete();
-		if (!hasSolids) {
-			const faces = this.k.getSubShapes(id, "face");
-			const hasFaces = faces.size() > 0;
-			faces.delete();
-			if (!hasFaces) return "";
-		}
-		return this.k.writeXCAFToSTEP(id);
-	}
-	exportSTEPConfigured(shapes, _options) {
-		if (shapes.length === 0) return "";
-		const named = shapes.map((s) => ({
-			shape: s.shape,
-			name: s.name ?? "",
-			color: s.color
-		}));
-		const doc = this.createXCAFDocument(named);
-		try {
-			return this.writeXCAFToSTEP(doc);
-		} finally {
-			doc.delete();
-		}
-	}
-	volume(shape) {
-		return this.k.getVolume(unwrap(shape));
-	}
-	area(shape) {
-		return this.k.getSurfaceArea(unwrap(shape));
-	}
-	length(shape) {
-		return this.k.getLength(unwrap(shape));
-	}
-	centerOfMass(shape) {
-		const vec = this.k.getCenterOfMass(unwrap(shape));
-		const result = [
-			vec.get(0),
-			vec.get(1),
-			vec.get(2)
-		];
-		vec.delete();
-		return result;
-	}
-	linearCenterOfMass(shape) {
-		const vec = this.k.getLinearCenterOfMass(unwrap(shape));
-		const result = [
-			vec.get(0),
-			vec.get(1),
-			vec.get(2)
-		];
-		vec.delete();
-		return result;
-	}
-	boundingBox(shape) {
-		const bb = this.k.getBoundingBox(unwrap(shape), true);
-		return {
-			min: [
-				bb.xmin,
-				bb.ymin,
-				bb.zmin
-			],
-			max: [
-				bb.xmax,
-				bb.ymax,
-				bb.zmax
-			]
-		};
-	}
-	distance(shape1, shape2) {
-		const id1 = unwrap(shape1);
-		const id2 = unwrap(shape2);
-		const value = this.k.distanceBetween(id1, id2);
-		const samples1 = collectDistanceSamples(this.k, this.Module, id1);
-		const samples2 = collectDistanceSamples(this.k, this.Module, id2);
-		if (samples1.length === 0 || samples2.length === 0) return {
-			value,
-			point1: [
-				0,
-				0,
-				0
-			],
-			point2: [
-				0,
-				0,
-				0
-			]
-		};
-		let bestD2 = Infinity;
-		let bestP1 = samples1[0] ?? [
-			0,
-			0,
-			0
-		];
-		let bestP2 = samples2[0] ?? [
-			0,
-			0,
-			0
-		];
-		for (const p1 of samples1) for (const p2 of samples2) {
-			const dx = p2[0] - p1[0];
-			const dy = p2[1] - p1[1];
-			const dz = p2[2] - p1[2];
-			const d2 = dx * dx + dy * dy + dz * dz;
-			if (d2 < bestD2) {
-				bestD2 = d2;
-				bestP1 = p1;
-				bestP2 = p2;
-			}
-		}
-		return {
-			value,
-			point1: bestP1,
-			point2: bestP2
-		};
-	}
-	surfaceCurvature(face, u, v) {
-		const faceId = unwrap(face);
-		const vec = this.k.surfaceCurvature(faceId, u, v);
-		const mean = vec.get(0);
-		const gaussian = vec.get(1);
-		const maxK = vec.get(2);
-		const minK = vec.get(3);
-		vec.delete();
-		const { maxDirection, minDirection } = computePrincipalDirections(this.k, faceId, u, v, maxK, minK);
-		return {
-			gaussian,
-			mean,
-			max: maxK,
-			min: minK,
-			maxDirection,
-			minDirection
-		};
-	}
-	surfaceCenterOfMass(face) {
-		try {
-			const v = this.k.getSurfaceCenterOfMass(unwrap(face));
-			const result = [
-				v.get(0),
-				v.get(1),
-				v.get(2)
-			];
-			v.delete();
-			return result;
-		} catch {
-			return [
-				0,
-				0,
-				0
-			];
-		}
-	}
-	measureBulk(shape, includeLinear) {
-		const bb = this.boundingBox(shape);
-		return {
-			volume: this.volume(shape),
-			area: this.area(shape),
-			length: includeLinear ? this.length(shape) : 0,
-			centerOfMass: this.centerOfMass(shape),
-			boundingBox: bb
-		};
-	}
-	createDistanceQuery(referenceShape) {
-		const refId = unwrap(referenceShape);
-		const k = this.k;
-		return {
-			distanceTo(shape) {
-				return {
-					value: k.distanceBetween(refId, unwrap(shape)),
-					point1: [
-						0,
-						0,
-						0
-					],
-					point2: [
-						0,
-						0,
-						0
-					]
-				};
-			},
-			dispose: noop
-		};
-	}
-	iterShapes(shape, type) {
-		const vec = this.k.getSubShapes(unwrap(shape), type);
-		const results = [];
-		const n = vec.size();
-		for (let i = 0; i < n; i++) results.push(handle(type, vec.get(i)));
-		vec.delete();
-		return results;
-	}
-	iterShapeList(_list, _callback) {
-		throw new Error("iterShapeList is not applicable to occt-wasm: the arena model has no TopTools_ListOfShape handles");
-	}
-	shapeType(shape) {
-		if (isOcctWasmHandle(shape)) return shape.type;
-		return mapShapeType(this.k.getShapeType(unwrap(shape)));
-	}
-	isSame(a, b) {
-		return this.k.isSame(unwrap(a), unwrap(b));
-	}
-	isEqual(a, b) {
-		return this.k.isEqual(unwrap(a), unwrap(b));
-	}
-	downcast(shape, type) {
-		if (type) return handle(type, this.k.downcast(unwrap(shape), type));
-		return shape;
-	}
-	hashCode(shape, upperBound) {
-		return this.k.hashCode(unwrap(shape), upperBound);
-	}
-	isNull(shape) {
-		return this.k.isNull(unwrap(shape));
-	}
-	shapeOrientation(shape) {
-		return this.k.shapeOrientation(unwrap(shape)).toLowerCase();
-	}
-	edgeToFaceMap(shape) {
-		const vec = this.k.edgeToFaceMap(unwrap(shape), 1e6);
-		const data = readVecInt(vec);
-		vec.delete();
-		const map = {};
-		for (let i = 0; i + 1 < data.length; i += 2) {
-			const edgeHash = data[i];
-			const faceHash = data[i + 1];
-			if (!map[edgeHash]) map[edgeHash] = [];
-			map[edgeHash].push(faceHash);
-		}
-		return JSON.stringify(map);
-	}
-	sharedEdges(faceA, faceB) {
-		const vec = this.k.sharedEdges(unwrap(faceA), unwrap(faceB));
-		const results = [];
-		const n = vec.size();
-		for (let i = 0; i < n; i++) results.push(handle("edge", vec.get(i)));
-		vec.delete();
-		return results;
-	}
-	adjacentFaces(shape, face) {
-		const vec = this.k.adjacentFaces(unwrap(shape), unwrap(face));
-		const results = [];
-		const n = vec.size();
-		for (let i = 0; i < n; i++) results.push(handle("face", vec.get(i)));
-		vec.delete();
-		return results;
-	}
-	sew(shapes, tolerance) {
-		const vec = makeVecU32(this.Module, shapes.map(unwrap));
-		try {
-			return wrapResult(this.k, this.k.sew(vec, tolerance ?? 1e-6));
-		} finally {
-			vec.delete();
-		}
-	}
-	curveType(shape) {
-		const t = this.k.curveType(unwrap(shape));
-		return {
-			line: "LINE",
-			circle: "CIRCLE",
-			ellipse: "ELLIPSE",
-			hyperbola: "HYPERBOLA",
-			parabola: "PARABOLA",
-			bezier: "BEZIER_CURVE",
-			bspline: "BSPLINE_CURVE",
-			offset: "OFFSET_CURVE",
-			other: "OTHER_CURVE"
-		}[t] ?? t.toUpperCase();
-	}
-	curveParameters(shape) {
-		const vec = this.k.curveParameters(unwrap(shape));
-		const result = [vec.get(0), vec.get(1)];
-		vec.delete();
-		return result;
-	}
-	curvePointAtParam(shape, param) {
-		const vec = this.k.curvePointAtParam(unwrap(shape), param);
-		const result = [
-			vec.get(0),
-			vec.get(1),
-			vec.get(2)
-		];
-		vec.delete();
-		return result;
-	}
-	curveTangent(shape, param) {
-		const tvec = this.k.curveTangent(unwrap(shape), param);
-		const pvec = this.k.curvePointAtParam(unwrap(shape), param);
-		const result = {
-			point: [
-				pvec.get(0),
-				pvec.get(1),
-				pvec.get(2)
-			],
-			tangent: [
-				tvec.get(0),
-				tvec.get(1),
-				tvec.get(2)
-			]
-		};
-		tvec.delete();
-		pvec.delete();
-		return result;
-	}
-	curveIsClosed(shape) {
-		return this.k.curveIsClosed(unwrap(shape));
-	}
-	curveIsPeriodic(shape) {
-		return this.k.curveIsPeriodic(unwrap(shape));
-	}
-	curvePeriod(_shape) {
-		return 2 * Math.PI;
-	}
-	interpolatePoints(points, options) {
-		const flat = [];
-		for (const p of points) flat.push(p[0], p[1], p[2]);
-		const vec = makeVecDouble(this.Module, flat);
-		try {
-			return handle("edge", this.k.interpolatePoints(vec, options?.periodic ?? false));
-		} finally {
-			vec.delete();
-		}
-	}
-	approximatePoints(points, options) {
-		const flat = [];
-		for (const p of points) flat.push(p[0], p[1], p[2]);
-		const vec = makeVecDouble(this.Module, flat);
-		try {
-			return handle("edge", this.k.approximatePoints(vec, options?.tolerance ?? .001));
-		} finally {
-			vec.delete();
-		}
-	}
-	curveDegreeElevate(_edge, _elevateBy) {
-		notImplemented("curveDegreeElevate");
-	}
-	curveKnotInsert(_edge, _knot, _times) {
-		notImplemented("curveKnotInsert");
-	}
-	curveKnotRemove(_edge, _knot, _tolerance) {
-		notImplemented("curveKnotRemove");
-	}
-	curveSplit(_edge, _param) {
-		notImplemented("curveSplit");
-	}
-	createCurveAdaptor(_shape) {
-		notImplemented("createCurveAdaptor");
-	}
-	getBezierPenultimatePole(_edge) {
-		notImplemented("getBezierPenultimatePole");
-	}
-	vertexPosition(vertex) {
-		const vec = this.k.vertexPosition(unwrap(vertex));
-		const result = [
-			vec.get(0),
-			vec.get(1),
-			vec.get(2)
-		];
-		vec.delete();
-		return result;
-	}
-	surfaceType(face) {
-		return this.k.surfaceType(unwrap(face)).toLowerCase();
-	}
-	uvBounds(face) {
-		const vec = this.k.uvBounds(unwrap(face));
-		const result = {
-			uMin: vec.get(0),
-			uMax: vec.get(1),
-			vMin: vec.get(2),
-			vMax: vec.get(3)
-		};
-		vec.delete();
-		return result;
-	}
-	outerWire(face) {
-		return handle("wire", this.k.outerWire(unwrap(face)));
-	}
-	surfaceNormal(face, u, v) {
-		const vec = this.k.surfaceNormal(unwrap(face), u, v);
-		const result = [
-			vec.get(0),
-			vec.get(1),
-			vec.get(2)
-		];
-		vec.delete();
-		return result;
-	}
-	pointOnSurface(face, u, v) {
-		const vec = this.k.pointOnSurface(unwrap(face), u, v);
-		const result = [
-			vec.get(0),
-			vec.get(1),
-			vec.get(2)
-		];
-		vec.delete();
-		return result;
-	}
-	uvFromPoint(face, point) {
-		const vec = this.k.uvFromPoint(unwrap(face), point[0], point[1], point[2]);
-		if (vec.size() < 2) {
-			vec.delete();
-			return null;
-		}
-		const result = [vec.get(0), vec.get(1)];
-		vec.delete();
-		return result;
-	}
-	projectPointOnFace(face, point) {
-		const vec = this.k.projectPointOnFace(unwrap(face), point[0], point[1], point[2]);
-		const result = [
-			vec.get(0),
-			vec.get(1),
-			vec.get(2)
-		];
-		vec.delete();
-		return result;
-	}
-	classifyPointOnFace(face, u, v, _tolerance) {
-		return this.k.classifyPointOnFace(unwrap(face), u, v).toLowerCase();
-	}
-	classifyPointRobust(_shape, _point, _tolerance) {
-		notImplemented("classifyPointRobust");
-	}
-	classifyPointWinding(_shape, _point, _tolerance) {
-		notImplemented("classifyPointWinding");
-	}
-	approximateSurfaceLspia(_coords, _rows, _cols, _degreeU, _degreeV, _numCpsU, _numCpsV, _tolerance, _maxIterations) {
-		notImplemented("approximateSurfaceLspia");
-	}
-	untrimFace(_face, _samplesPerCurve, _interiorSamples) {
-		notImplemented("untrimFace");
-	}
-	getSurfaceCylinderData(_surface) {
-		notImplemented("getSurfaceCylinderData");
-	}
-	reverseSurfaceU(_surface) {
-		notImplemented("reverseSurfaceU");
-	}
-	detectSmallFeatures(_shape, _areaThreshold, _tolerance) {
-		notImplemented("detectSmallFeatures");
-	}
-	recognizeFeatures(_shape, _tolerance) {
-		notImplemented("recognizeFeatures");
-	}
-	projectEdges(shape, cameraOrigin, cameraDirection, cameraXAxis) {
-		const [ox, oy, oz] = cameraOrigin;
-		const [dx, dy, dz] = cameraDirection;
-		const hasXAxis = !!cameraXAxis;
-		const [xx, xy, xz] = cameraXAxis ?? [
-			1,
-			0,
-			0
-		];
-		const proj = this.k.projectEdges(unwrap(shape), ox, oy, oz, dx, dy, dz, xx, xy, xz, hasXAxis);
-		const wrapOrNull = (id) => id === 0 ? handle("compound", this.k.makeCompound(new this.Module.VectorUint32())) : handle("compound", id);
-		return {
-			visible: {
-				outline: wrapOrNull(proj.visibleOutline),
-				smooth: wrapOrNull(proj.visibleSmooth),
-				sharp: wrapOrNull(proj.visibleSharp)
-			},
-			hidden: {
-				outline: wrapOrNull(proj.hiddenOutline),
-				smooth: wrapOrNull(proj.hiddenSmooth),
-				sharp: wrapOrNull(proj.hiddenSharp)
-			}
-		};
-	}
-	isValid(shape) {
-		return this.k.isValid(unwrap(shape));
-	}
-	healSolid(shape) {
-		const id = this.k.healSolid(unwrap(shape), 1e-6);
-		if (id === 0) return null;
-		return wrapResult(this.k, id);
-	}
-	healFace(shape) {
-		return wrapResult(this.k, this.k.healFace(unwrap(shape), 1e-6));
-	}
-	healWire(wire, _face) {
-		return wrapResult(this.k, this.k.healWire(unwrap(wire), 1e-6));
-	}
-	mergeCoincidentVertices(_shape, _tolerance) {
-		return 0;
-	}
-	removeDegenerateEdges(shape, _tolerance) {
-		this.k.removeDegenerateEdges(unwrap(shape));
-		return 0;
-	}
-	fixFaceOrientations(shape) {
-		this.k.fixFaceOrientations(unwrap(shape));
-		return 0;
-	}
-	fixShape(shape) {
-		return wrapResult(this.k, this.k.fixShape(unwrap(shape)));
-	}
-	fixSelfIntersection(_wire) {
-		notImplemented("fixSelfIntersection");
-	}
-	createPoint2d(x, y) {
-		return {
-			x,
-			y
-		};
-	}
-	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
-		};
-	}
-	createVector2d(x, y) {
-		return {
-			x,
-			y
-		};
-	}
-	createAxis2d(px, py, dx, dy) {
-		return {
-			px,
-			py,
-			dx,
-			dy,
-			delete() {}
-		};
-	}
-	wrapCurve2dHandle(handle) {
-		return handle;
-	}
-	createCurve2dAdaptor(_handle) {
-		notImplemented("createCurve2dAdaptor");
-	}
-	makeLine2d(x1, y1, x2, y2) {
-		return c2dWrap(makeLine2d(x1, y1, x2, y2));
-	}
-	makeCircle2d(cx, cy, radius, sense) {
-		return c2dWrap(makeCircle2d(cx, cy, radius, sense));
-	}
-	makeArc2dThreePoints(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 c2dWrap(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 = 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
-		});
-	}
-	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(makeLine2d(startX, startY, endX, endY));
-		const t = -(dx * dx + dy * dy) / 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 = 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
-		});
-	}
-	makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX, xDirY, sense) {
-		return c2dWrap(makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX ?? 1, xDirY ?? 0, sense ?? true));
-	}
-	makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle, xDirX, xDirY, sense) {
-		return c2dWrap({
-			...makeEllipse2d(cx, cy, majorRadius, minorRadius, xDirX ?? 1, xDirY ?? 0, sense ?? true),
-			__bk2d: "ellipse",
-			startAngle,
-			endAngle
-		});
-	}
-	makeBezier2d(points) {
-		return c2dWrap(makeBezier2d(points));
-	}
-	makeBSpline2d(points, _options) {
-		if (points.length <= 25) return c2dWrap(makeBezier2d(points));
-		const step = Math.max(1, Math.floor(points.length / 24));
-		return c2dWrap(makeBezier2d(points.filter((_, i) => i % step === 0 || i === points.length - 1)));
-	}
-	evaluateCurve2d(curve, param) {
-		return evaluateCurve2d(c2d(curve), param);
-	}
-	evaluateCurve2dD1(curve, param) {
-		return {
-			point: evaluateCurve2d(c2d(curve), param),
-			tangent: tangentCurve2d(c2d(curve), param)
-		};
-	}
-	getCurve2dBounds(curve) {
-		return curveBounds(c2d(curve));
-	}
-	getCurve2dType(curve) {
-		let cu = c2d(curve);
-		while (cu.__bk2d === "trimmed" && cu.basis) cu = cu.basis;
-		return curveTypeName(cu);
-	}
-	trimCurve2d(curve, start, end) {
-		return c2dWrap({
-			__bk2d: "trimmed",
-			basis: c2d(curve),
-			tStart: start,
-			tEnd: end
-		});
-	}
-	reverseCurve2d(_curve) {}
-	copyCurve2d(curve) {
-		return c2dWrap(JSON.parse(JSON.stringify(c2d(curve))));
-	}
-	offsetCurve2d(curve, offset) {
-		const c = c2d(curve);
-		const bounds = curveBounds(c);
-		const pts = [];
-		for (let i = 0; i <= 20; i++) {
-			const t = bounds.first + (bounds.last - bounds.first) * i / 20;
-			const [px, py] = evaluateCurve2d(c, t);
-			const [tx, ty] = tangentCurve2d(c, t);
-			const len = Math.sqrt(tx * tx + ty * ty) || 1;
-			pts.push([px - ty / len * offset, py + tx / len * offset]);
-		}
-		return c2dWrap(makeBezier2d(pts.length <= 25 ? pts : pts.filter((_, i) => i % 2 === 0 || i === pts.length - 1)));
-	}
-	translateCurve2d(curve, dx, dy) {
-		return c2dWrap(translateCurve2d(c2d(curve), dx, dy));
-	}
-	rotateCurve2d(curve, angle, cx, cy) {
-		return c2dWrap(rotateCurve2d(c2d(curve), angle, cx, cy));
-	}
-	scaleCurve2d(curve, factor, cx, cy) {
-		const result = scaleCurve2d(c2d(curve), factor, cx, cy);
-		const r = result;
-		if (r.__bk2d === "line" && typeof r.len === "number") r.len = r.len * Math.abs(factor);
-		return c2dWrap(result);
-	}
-	mirrorCurve2dAtPoint(curve, cx, cy) {
-		return c2dWrap(mirrorAtPoint(c2d(curve), cx, cy));
-	}
-	mirrorCurve2dAcrossAxis(curve, originX, originY, dirX, dirY) {
-		return c2dWrap(mirrorAcrossAxis(c2d(curve), originX, originY, dirX, dirY));
-	}
-	affinityTransform2d(_curve, _axisOriginX, _axisOriginY, _axisDirX, _axisDirY, _ratio) {
-		return _curve;
-	}
-	createIdentityGTrsf2d() {
-		return {
-			type: "identity2d",
-			delete() {}
-		};
-	}
-	createAffinityGTrsf2d(originX, originY, dirX, dirY, ratio) {
-		return {
-			type: "affinity2d",
-			axOriginX: originX,
-			axOriginY: originY,
-			axDirX: dirX,
-			axDirY: dirY,
-			ratio,
-			delete() {}
-		};
-	}
-	createTranslationGTrsf2d(dx, dy) {
-		return {
-			type: "translate2d",
-			dx,
-			dy,
-			delete() {}
-		};
-	}
-	createMirrorGTrsf2d(cx, cy, mode, originX, originY, dirX, dirY) {
-		return {
-			type: "mirror2d",
-			cx,
-			cy,
-			mode,
-			originX,
-			originY,
-			dirX,
-			dirY,
-			delete() {}
-		};
-	}
-	createRotationGTrsf2d(angle, cx, cy) {
-		return {
-			type: "rotate2d",
-			angle,
-			cx,
-			cy,
-			delete() {}
-		};
-	}
-	createScaleGTrsf2d(factor, cx, cy) {
-		return {
-			type: "scale2d",
-			sx: factor,
-			sy: factor,
-			cx,
-			cy,
-			delete() {}
-		};
-	}
-	setGTrsf2dTranslationPart(gtrsf, dx, dy) {
-		const t = gtrsf;
-		t["dx"] = (Number(t["dx"]) || 0) + dx;
-		t["dy"] = (Number(t["dy"]) || 0) + dy;
-	}
-	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"];
-		}
-	}
-	transformCurve2dGeneral(curve, gtrsf) {
-		const t = gtrsf;
-		if (t["type"] === "translate2d") return this.translateCurve2d(curve, t["dx"] ?? 0, t["dy"] ?? 0);
-		if (t["type"] === "rotate2d") return this.rotateCurve2d(curve, t["angle"] ?? 0, t["cx"] ?? 0, t["cy"] ?? 0);
-		if (t["type"] === "scale2d") return this.scaleCurve2d(curve, t["sx"] ?? 1, t["cx"] ?? 0, t["cy"] ?? 0);
-		if (t["type"] === "mirror2d") return this.mirrorCurve2dAtPoint(curve, t["ox"] ?? 0, t["oy"] ?? 0);
-		if (t["type"] === "affinity2d") return this.scaleCurve2d(curve, Number(t["ratio"]) || 1, Number(t["axOriginX"]) || 0, Number(t["axOriginY"]) || 0);
-		if (Number(t["dx"]) || Number(t["dy"])) return this.translateCurve2d(curve, Number(t["dx"]) || 0, Number(t["dy"]) || 0);
-		return curve;
-	}
-	intersectCurves2d(c1, c2, tolerance) {
-		const result = intersectCurves2dFn(c2d(c1), c2d(c2), tolerance);
-		return {
-			points: result.points,
-			segments: result.segments.map((s) => c2dWrap(s))
-		};
-	}
-	projectPointOnCurve2d(curve, x, y) {
-		const c = c2d(curve);
-		const bounds = 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] = evaluateCurve2d(basis, t);
-				return {
-					param: t,
-					distance: Math.sqrt((px - x) ** 2 + (py - y) ** 2)
-				};
-			}
-			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] = 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" && c.basis) {
-			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);
-	}
-	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] = evaluateCurve2d(c2d(c1), t1);
-			for (let j = 0; j <= n; j++) {
-				const t2 = p2Start + (p2End - p2Start) * (j / n);
-				const [x2, y2] = evaluateCurve2d(c2d(c2), t2);
-				const d = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
-				if (d < minDist) minDist = d;
-			}
-		}
-		return minDist;
-	}
-	approximateCurve2dAsBSpline(curve, _tolerance, _continuity, maxSegments) {
-		const cu = c2d(curve);
-		const bounds = 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(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
-		});
-	}
-	decomposeBSpline2dToBeziers(curve) {
-		const knots = c2d(curve).knots ?? [];
-		if (knots.length < 2) return [curve];
-		const result = [];
-		for (let i = 0; i < knots.length - 1; i++) {
-			const k0 = knots[i];
-			const k1 = knots[i + 1];
-			if (Math.abs(k1 - k0) < 1e-15) continue;
-			result.push(this.trimCurve2d(curve, k0, k1));
-		}
-		return result.length > 0 ? result : [curve];
-	}
-	createBoundingBox2d() {
-		return createBBox2d();
-	}
-	addCurveToBBox2d(bbox, curve, tolerance) {
-		addCurveToBBox(bbox, c2d(curve), tolerance);
-	}
-	getBBox2dBounds(bbox) {
-		const b = bbox;
-		return {
-			xMin: b.xMin,
-			yMin: b.yMin,
-			xMax: b.xMax,
-			yMax: b.yMax
-		};
-	}
-	mergeBBox2d(target, other) {
-		const t = target;
-		const o = 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);
-	}
-	isBBox2dOut(a, b) {
-		const ba = a;
-		const bb = b;
-		return ba.xMax < bb.xMin || ba.xMin > bb.xMax || ba.yMax < bb.yMin || ba.yMin > bb.yMax;
-	}
-	isBBox2dOutPoint(bbox, x, y) {
-		const b = bbox;
-		return x < b.xMin || x > b.xMax || y < b.yMin || y > b.yMax;
-	}
-	getCurve2dCircleData(curve) {
-		let c = c2d(curve);
-		while (c.__bk2d === "trimmed" && c.basis) c = c.basis;
-		if (c.__bk2d === "circle") return {
-			cx: c.cx,
-			cy: c.cy,
-			radius: c.radius,
-			isDirect: c.sense !== false
-		};
-		return null;
-	}
-	getCurve2dEllipseData(curve) {
-		let c = c2d(curve);
-		while (c.__bk2d === "trimmed" && c.basis) c = c.basis;
-		if (c.__bk2d === "ellipse") return {
-			majorRadius: c.majorRadius,
-			minorRadius: c.minorRadius,
-			xAxisAngle: c.xDirAngle ?? 0,
-			isDirect: c.sense !== false
-		};
-		return null;
-	}
-	getCurve2dBezierPoles(curve) {
-		let c = c2d(curve);
-		while (c.__bk2d === "trimmed" && c.basis) c = c.basis;
-		if (c.__bk2d === "bezier" && Array.isArray(c.poles)) return c.poles;
-		return null;
-	}
-	getCurve2dBezierDegree(curve) {
-		let c = c2d(curve);
-		while (c.__bk2d === "trimmed" && c.basis) c = c.basis;
-		if (c["__bk2d"] === "bezier" && Array.isArray(c["poles"])) return c["poles"].length - 1;
-		return null;
-	}
-	getCurve2dBSplineData(_curve) {
-		notImplemented("getCurve2dBSplineData");
-	}
-	serializeCurve2d(curve) {
-		return serializeCurve2d(c2d(curve));
-	}
-	deserializeCurve2d(data) {
-		return c2dWrap(deserializeCurve2d(data));
-	}
-	splitCurve2d(curve, params) {
-		const bounds = 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(this.trimCurve2d(curve, start, end));
-		}
-		return result;
-	}
-	liftCurve2dToPlane(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
-		];
-		const bk2dType = cu.__bk2d;
-		if (bk2dType === "line") {
-			const bounds = curveBounds(cu);
-			const [u1, v1] = evaluateCurve2d(cu, bounds.first);
-			const [u2, v2] = evaluateCurve2d(cu, bounds.last);
-			const p1 = lift(u1, v1);
-			const p2 = lift(u2, v2);
-			return handle("edge", this.k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
-		}
-		if (bk2dType === "trimmed") {
-			const trimmed = cu;
-			if (trimmed.basis && trimmed.basis.__bk2d === "line") {
-				const [u1, v1] = evaluateCurve2d(cu, 0);
-				const [u2, v2] = evaluateCurve2d(cu, 1);
-				const p1 = lift(u1, v1);
-				const p2 = lift(u2, v2);
-				return handle("edge", this.k.makeLineEdge(p1[0], p1[1], p1[2], p2[0], p2[1], p2[2]));
-			}
-			if (trimmed.basis && trimmed.basis.__bk2d === "circle") {
-				const bounds = curveBounds(cu);
-				const [u1, v1] = evaluateCurve2d(cu, bounds.first);
-				const [um, vm] = evaluateCurve2d(cu, (bounds.first + bounds.last) / 2);
-				const [u2, v2] = evaluateCurve2d(cu, bounds.last);
-				const p1 = lift(u1, v1);
-				const pm = lift(um, vm);
-				const p2 = lift(u2, v2);
-				return handle("edge", this.k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
-			}
-		}
-		if (bk2dType === "circle") {
-			const circleData = cu;
-			if (circleData.cx !== void 0 && circleData.radius !== void 0) {
-				const [pcx, pcy, pcz] = lift(circleData.cx, circleData.cy);
-				return handle("edge", this.k.makeCircleEdge(pcx, pcy, pcz, zx, zy, zz, circleData.radius));
-			}
-			const bounds = curveBounds(cu);
-			const [u1, v1] = evaluateCurve2d(cu, bounds.first);
-			const [um, vm] = evaluateCurve2d(cu, (bounds.first + bounds.last) / 2);
-			const [u2, v2] = evaluateCurve2d(cu, bounds.last);
-			const p1 = lift(u1, v1);
-			const pm = lift(um, vm);
-			const p2 = lift(u2, v2);
-			return handle("edge", this.k.makeArcEdge(p1[0], p1[1], p1[2], pm[0], pm[1], pm[2], p2[0], p2[1], p2[2]));
-		}
-		const bounds = curveBounds(cu);
-		const nSamples = 24;
-		const dt = (bounds.last - bounds.first) / nSamples;
-		const pts = [];
-		for (let i = 0; i <= nSamples; i++) {
-			const [u, v] = evaluateCurve2d(cu, bounds.first + i * dt);
-			const [px, py, pz] = lift(u, v);
-			pts.push(px, py, pz);
-		}
-		const vec = new this.Module.VectorDouble();
-		for (const p of pts) vec.push_back(p);
-		try {
-			return handle("edge", this.k.interpolatePoints(vec, false));
-		} finally {
-			vec.delete();
-		}
-	}
-	buildEdgeOnSurface(curve, surface) {
-		const cu = c2d(curve);
-		const bounds = curveBounds(cu);
-		const faceId = unwrap(surface);
-		const nSamples = 30;
-		const vec = new this.Module.VectorDouble();
-		for (let i = 0; i <= nSamples; i++) {
-			const [u, v] = evaluateCurve2d(cu, bounds.first + (bounds.last - bounds.first) * i / nSamples);
-			const pt = this.k.pointOnSurface(faceId, u, v);
-			vec.push_back(pt.get(0));
-			vec.push_back(pt.get(1));
-			vec.push_back(pt.get(2));
-			pt.delete();
-		}
-		try {
-			return handle("edge", this.k.interpolatePoints(vec, false));
-		} finally {
-			vec.delete();
-		}
-	}
-	extractSurfaceFromFace(face) {
-		return face;
-	}
-	extractCurve2dFromEdge(_edge, _face) {
-		return c2dWrap(makeLine2d(0, 0, 1, 0));
-	}
-	buildCurves3d(wire) {
-		this.k.buildCurves3d(unwrap(wire));
-	}
-	fixWireOnFace(wire, face, tolerance) {
-		return handle("wire", this.k.fixWireOnFace(unwrap(wire), unwrap(face), tolerance));
-	}
-	fillSurface(_wires, _options) {
-		notImplemented("fillSurface");
-	}
-	getNurbsCurveData(edge) {
-		try {
-			const data = this.k.getNurbsCurveData(unwrap(edge));
-			try {
-				const nPoles = data.poles.size() / 3;
-				const poles = [];
-				for (let i = 0; i < nPoles; i++) poles.push([
-					data.poles.get(i * 3),
-					data.poles.get(i * 3 + 1),
-					data.poles.get(i * 3 + 2)
-				]);
-				const knots = [];
-				for (let i = 0; i < data.knots.size(); i++) knots.push(data.knots.get(i));
-				const multiplicities = [];
-				for (let i = 0; i < data.multiplicities.size(); i++) multiplicities.push(data.multiplicities.get(i));
-				const weights = [];
-				if (data.rational) for (let i = 0; i < data.weights.size(); i++) weights.push(data.weights.get(i));
-				else for (let i = 0; i < nPoles; i++) weights.push(1);
-				return {
-					degree: data.degree,
-					poles,
-					weights,
-					knots,
-					multiplicities,
-					isPeriodic: data.periodic,
-					isRational: data.rational
-				};
-			} finally {
-				data.delete();
-			}
-		} catch {
-			return null;
-		}
-	}
-};
-function multiplyMatrices4x4(a, b) {
-	const result = new Array(16).fill(0);
-	for (let i = 0; i < 4; i++) for (let j = 0; j < 4; j++) for (let k = 0; k < 4; k++) result[i * 4 + j] = result[i * 4 + j] + a[i * 4 + k] * b[k * 4 + j];
-	return result;
-}
-function findHorizonEdges(faces, visible) {
-	const visSet = new Set(visible);
-	const horizon = [];
-	for (const fi of visible) {
-		const f = faces[fi];
-		for (let ei = 0; ei < 3; ei++) {
-			const a = f[ei], b = f[(ei + 1) % 3];
-			if (faces.some((g, fj) => fj !== fi && !visSet.has(fj) && [
-				0,
-				1,
-				2
-			].some((ej) => g[ej] === b && g[(ej + 1) % 3] === a))) horizon.push([a, b]);
-		}
-	}
-	return horizon;
-}
-function computeConvexHullFaces(pts) {
-	const cross = (a, b) => ({
-		x: a.y * b.z - a.z * b.y,
-		y: a.z * b.x - a.x * b.z,
-		z: a.x * b.y - a.y * b.x
-	});
-	const sub = (a, b) => ({
-		x: a.x - b.x,
-		y: a.y - b.y,
-		z: a.z - b.z
-	});
-	const dot = (a, b) => a.x * b.x + a.y * b.y + a.z * b.z;
-	const n = pts.length;
-	const faces = [];
-	const p0 = pts[0];
-	let i1 = 1;
-	while (i1 < n && Math.hypot(pts[i1].x - p0.x, pts[i1].y - p0.y, pts[i1].z - p0.z) < 1e-10) i1++;
-	let i2 = i1 + 1;
-	const e01 = sub(pts[i1], p0);
-	while (i2 < n) {
-		const c = cross(e01, sub(pts[i2], p0));
-		if (Math.hypot(c.x, c.y, c.z) > 1e-10) break;
-		i2++;
-	}
-	let i3 = i2 + 1;
-	const norm = cross(e01, sub(pts[i2], p0));
-	while (i3 < n) {
-		if (Math.abs(dot(norm, sub(pts[i3], p0))) > 1e-10) break;
-		i3++;
-	}
-	if (i3 >= n) return [[
-		0,
-		1,
-		2
-	]];
-	if (dot(cross(sub(pts[i1], p0), sub(pts[i2], p0)), sub(pts[i3], p0)) > 0) faces.push([
-		0,
-		i1,
-		i2
-	], [
-		0,
-		i2,
-		i3
-	], [
-		0,
-		i3,
-		i1
-	], [
-		i1,
-		i3,
-		i2
-	]);
-	else faces.push([
-		0,
-		i2,
-		i1
-	], [
-		0,
-		i3,
-		i2
-	], [
-		0,
-		i1,
-		i3
-	], [
-		i2,
-		i3,
-		i1
-	]);
-	const used = new Set([
-		0,
-		i1,
-		i2,
-		i3
-	]);
-	for (let pi = 0; pi < n; pi++) {
-		if (used.has(pi)) continue;
-		const p = pts[pi];
-		const visible = [];
-		for (let fi = 0; fi < faces.length; fi++) {
-			const f = faces[fi];
-			if (dot(cross(sub(pts[f[1]], pts[f[0]]), sub(pts[f[2]], pts[f[0]])), sub(p, pts[f[0]])) > 1e-10) visible.push(fi);
-		}
-		if (visible.length === 0) continue;
-		const horizon = findHorizonEdges(faces, visible);
-		visible.sort((a2, b2) => b2 - a2);
-		for (const fi of visible) faces.splice(fi, 1);
-		for (const [a, b] of horizon) faces.push([
-			a,
-			b,
-			pi
-		]);
-	}
-	return faces;
-}
-function c2d(handle) {
-	return handle;
-}
-function c2dWrap(obj) {
-	return obj;
-}
-//#endregion
-Object.defineProperty(exports, "OcctWasmAdapter", {
-	enumerable: true,
-	get: function() {
-		return OcctWasmAdapter;
-	}
-});
-Object.defineProperty(exports, "addCurveToBBox", {
-	enumerable: true,
-	get: function() {
-		return addCurveToBBox;
-	}
-});
-Object.defineProperty(exports, "createBBox2d", {
-	enumerable: true,
-	get: function() {
-		return createBBox2d;
-	}
-});
-Object.defineProperty(exports, "curveBounds", {
-	enumerable: true,
-	get: function() {
-		return curveBounds;
-	}
-});
-Object.defineProperty(exports, "curveTypeName", {
-	enumerable: true,
-	get: function() {
-		return curveTypeName;
-	}
-});
-Object.defineProperty(exports, "deserializeCurve2d", {
-	enumerable: true,
-	get: function() {
-		return deserializeCurve2d;
-	}
-});
-Object.defineProperty(exports, "evaluateCurve2d", {
-	enumerable: true,
-	get: function() {
-		return evaluateCurve2d;
-	}
-});
-Object.defineProperty(exports, "intersectCurves2dFn", {
-	enumerable: true,
-	get: function() {
-		return intersectCurves2dFn;
-	}
-});
-Object.defineProperty(exports, "makeBezier2d", {
-	enumerable: true,
-	get: function() {
-		return makeBezier2d;
-	}
-});
-Object.defineProperty(exports, "makeCircle2d", {
-	enumerable: true,
-	get: function() {
-		return makeCircle2d;
-	}
-});
-Object.defineProperty(exports, "makeEllipse2d", {
-	enumerable: true,
-	get: function() {
-		return makeEllipse2d;
-	}
-});
-Object.defineProperty(exports, "makeLine2d", {
-	enumerable: true,
-	get: function() {
-		return makeLine2d;
-	}
-});
-Object.defineProperty(exports, "mirrorAcrossAxis", {
-	enumerable: true,
-	get: function() {
-		return mirrorAcrossAxis;
-	}
-});
-Object.defineProperty(exports, "mirrorAtPoint", {
-	enumerable: true,
-	get: function() {
-		return mirrorAtPoint;
-	}
-});
-Object.defineProperty(exports, "rotateCurve2d", {
-	enumerable: true,
-	get: function() {
-		return rotateCurve2d;
-	}
-});
-Object.defineProperty(exports, "scaleCurve2d", {
-	enumerable: true,
-	get: function() {
-		return scaleCurve2d;
-	}
-});
-Object.defineProperty(exports, "serializeCurve2d", {
-	enumerable: true,
-	get: function() {
-		return serializeCurve2d;
-	}
-});
-Object.defineProperty(exports, "tangentCurve2d", {
-	enumerable: true,
-	get: function() {
-		return tangentCurve2d;
-	}
-});
-Object.defineProperty(exports, "translateCurve2d", {
-	enumerable: true,
-	get: function() {
-		return translateCurve2d;
-	}
-});