brepjs 18.35.3 → 18.35.4

package/dist/{occtWasmAdapter-R8zCS1h7.cjs → occtWasmAdapter-ZiJfgmS1.cjs}

@@ -1,4 +1,255 @@
 const require_vec3 = require("./vec3-CFwOI0ZI.cjs");
+//#region src/kernel/hullGeometry.ts
+function sub(a, b) {
+	return {
+		x: a.x - b.x,
+		y: a.y - b.y,
+		z: a.z - b.z
+	};
+}
+function cross(a, b) {
+	return {
+		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
+	};
+}
+function dot(a, b) {
+	return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function lengthVec(v) {
+	return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function distSq(a, b) {
+	const dx = a.x - b.x;
+	const dy = a.y - b.y;
+	const dz = a.z - b.z;
+	return dx * dx + dy * dy + dz * dz;
+}
+/** Safe array access — throws on out-of-bounds instead of returning undefined. */
+function at(arr, i) {
+	const v = arr[i];
+	if (v === void 0) throw new Error(`Index ${i} out of bounds`);
+	return v;
+}
+/** Safe number array access. */
+function atN(arr, i) {
+	const v = arr[i];
+	if (v === void 0) throw new Error(`Index ${i} out of bounds`);
+	return v;
+}
+function makeFace$1(points, a, b, c) {
+	const normal = cross(sub(at(points, b), at(points, a)), sub(at(points, c), at(points, a)));
+	const len = lengthVec(normal);
+	const n = len > 1e-14 ? {
+		x: normal.x / len,
+		y: normal.y / len,
+		z: normal.z / len
+	} : normal;
+	return {
+		a,
+		b,
+		c,
+		normal: n,
+		offset: dot(n, at(points, a)),
+		alive: true,
+		outsidePoints: []
+	};
+}
+function signedDist(face, point) {
+	return dot(face.normal, point) - face.offset;
+}
+function deduplicatePoints(points, tolerance) {
+	const tolSq = tolerance * tolerance;
+	const result = [];
+	for (const p of points) {
+		let isDuplicate = false;
+		for (const q of result) if (distSq(p, q) < tolSq) {
+			isDuplicate = true;
+			break;
+		}
+		if (!isDuplicate) result.push(p);
+	}
+	return result;
+}
+function findInitialTetrahedron(points) {
+	const n = points.length;
+	if (n < 4) return null;
+	let i0 = 0;
+	let i1 = 1;
+	let maxDist = distSq(at(points, 0), at(points, 1));
+	for (let i = 0; i < n; i++) for (let j = i + 1; j < n; j++) {
+		const d = distSq(at(points, i), at(points, j));
+		if (d > maxDist) {
+			maxDist = d;
+			i0 = i;
+			i1 = j;
+		}
+	}
+	if (maxDist < 1e-20) return null;
+	const lineDir = sub(at(points, i1), at(points, i0));
+	let i2 = -1;
+	let maxLineDist = -1;
+	for (let i = 0; i < n; i++) {
+		if (i === i0 || i === i1) continue;
+		const c = cross(lineDir, sub(at(points, i), at(points, i0)));
+		const d = dot(c, c);
+		if (d > maxLineDist) {
+			maxLineDist = d;
+			i2 = i;
+		}
+	}
+	if (i2 === -1 || maxLineDist < 1e-20) return null;
+	const planeNormal = cross(sub(at(points, i1), at(points, i0)), sub(at(points, i2), at(points, i0)));
+	const planeLen = lengthVec(planeNormal);
+	if (planeLen < 1e-14) return null;
+	const pn = {
+		x: planeNormal.x / planeLen,
+		y: planeNormal.y / planeLen,
+		z: planeNormal.z / planeLen
+	};
+	const planeOffset = dot(pn, at(points, i0));
+	let i3 = -1;
+	let maxPlaneDist = -1;
+	for (let i = 0; i < n; i++) {
+		if (i === i0 || i === i1 || i === i2) continue;
+		const d = Math.abs(dot(pn, at(points, i)) - planeOffset);
+		if (d > maxPlaneDist) {
+			maxPlaneDist = d;
+			i3 = i;
+		}
+	}
+	if (i3 === -1 || maxPlaneDist < 1e-14) return null;
+	if (dot(pn, at(points, i3)) - planeOffset > 0) return [
+		i0,
+		i2,
+		i1,
+		i3
+	];
+	return [
+		i0,
+		i1,
+		i2,
+		i3
+	];
+}
+/**
+* Compute the 3D convex hull of a point set.
+*
+* @throws if fewer than 4 non-coincident, non-coplanar points are supplied.
+*/
+function quickHull(inputPoints, tolerance) {
+	const points = deduplicatePoints(inputPoints, tolerance);
+	if (points.length < 4) throw new Error(points.length === 0 ? "No points provided for convex hull" : "Fewer than 4 non-coincident points; cannot form a 3D convex hull");
+	const tet = findInitialTetrahedron(points);
+	if (tet === null) throw new Error("All points are coplanar; cannot form a 3D convex hull");
+	const [t0, t1, t2, t3] = tet;
+	const centroid = {
+		x: (at(points, t0).x + at(points, t1).x + at(points, t2).x + at(points, t3).x) / 4,
+		y: (at(points, t0).y + at(points, t1).y + at(points, t2).y + at(points, t3).y) / 4,
+		z: (at(points, t0).z + at(points, t1).z + at(points, t2).z + at(points, t3).z) / 4
+	};
+	function makeOutwardFace(a, b, c) {
+		const face = makeFace$1(points, a, b, c);
+		const toCentroid = sub(centroid, {
+			x: (at(points, a).x + at(points, b).x + at(points, c).x) / 3,
+			y: (at(points, a).y + at(points, b).y + at(points, c).y) / 3,
+			z: (at(points, a).z + at(points, b).z + at(points, c).z) / 3
+		});
+		if (dot(face.normal, toCentroid) > 0) return makeFace$1(points, a, c, b);
+		return face;
+	}
+	const faces = [
+		makeOutwardFace(t0, t1, t2),
+		makeOutwardFace(t0, t2, t3),
+		makeOutwardFace(t0, t3, t1),
+		makeOutwardFace(t1, t3, t2)
+	];
+	const tetSet = new Set([
+		t0,
+		t1,
+		t2,
+		t3
+	]);
+	const epsilon = 1e-10;
+	for (let i = 0; i < points.length; i++) {
+		if (tetSet.has(i)) continue;
+		for (const face of faces) if (signedDist(face, at(points, i)) > epsilon) {
+			face.outsidePoints.push(i);
+			break;
+		}
+	}
+	for (let iteration = 0; iteration < points.length * 4; iteration++) {
+		let currentFace = null;
+		for (const face of faces) if (face.alive && face.outsidePoints.length > 0) {
+			currentFace = face;
+			break;
+		}
+		if (currentFace === null) break;
+		let furthestIdx = atN(currentFace.outsidePoints, 0);
+		let furthestDist = signedDist(currentFace, at(points, furthestIdx));
+		for (let i = 1; i < currentFace.outsidePoints.length; i++) {
+			const idx = atN(currentFace.outsidePoints, i);
+			const d = signedDist(currentFace, at(points, idx));
+			if (d > furthestDist) {
+				furthestDist = d;
+				furthestIdx = idx;
+			}
+		}
+		const visibleFaces = [];
+		for (const face of faces) if (face.alive && signedDist(face, at(points, furthestIdx)) > epsilon) visibleFaces.push(face);
+		const edgeCount = /* @__PURE__ */ new Map();
+		for (const face of visibleFaces) {
+			const edges = [
+				[face.a, face.b],
+				[face.b, face.c],
+				[face.c, face.a]
+			];
+			for (const [ea, eb] of edges) {
+				const key = ea < eb ? `${ea}-${eb}` : `${eb}-${ea}`;
+				const entry = edgeCount.get(key);
+				if (entry) entry.count++;
+				else edgeCount.set(key, {
+					a: ea,
+					b: eb,
+					count: 1
+				});
+			}
+		}
+		const horizonEdges = [];
+		for (const entry of edgeCount.values()) if (entry.count === 1) horizonEdges.push({
+			a: entry.a,
+			b: entry.b
+		});
+		const orphanedPoints = [];
+		for (const face of visibleFaces) {
+			for (const idx of face.outsidePoints) if (idx !== furthestIdx) orphanedPoints.push(idx);
+			face.alive = false;
+			face.outsidePoints = [];
+		}
+		const newFaces = [];
+		for (const edge of horizonEdges) {
+			const newFaceObj = makeFace$1(points, edge.a, edge.b, furthestIdx);
+			newFaces.push(newFaceObj);
+			faces.push(newFaceObj);
+		}
+		for (const idx of orphanedPoints) for (const face of newFaces) if (signedDist(face, at(points, idx)) > epsilon) {
+			face.outsidePoints.push(idx);
+			break;
+		}
+	}
+	const resultFaces = [];
+	for (const face of faces) if (face.alive) resultFaces.push([
+		face.a,
+		face.b,
+		face.c
+	]);
+	return {
+		faces: resultFaces,
+		points
+	};
+}
+//#endregion
 //#region src/kernel/geometry2d.ts
 function evaluateCurve2d$1(c, t) {
 	switch (c.__bk2d) {
@@ -2974,10 +3225,27 @@ function makeEllipseArc2d(cx, cy, majorRadius, minorRadius, startAngle, endAngle
 function makeBezier2d(points) {
 	return c2dWrap(makeBezier2d$1(points));
 }
-function makeBSpline2d(points) {
-	if (points.length <= 25) return c2dWrap(makeBezier2d$1(points));
-	const step = Math.max(1, Math.floor(points.length / 24));
-	return c2dWrap(makeBezier2d$1(points.filter((_, i) => i % step === 0 || i === points.length - 1)));
+function makeBSpline2d(points, options) {
+	const poles = points;
+	const n = poles.length;
+	const degree = Math.max(1, Math.min(options?.degMax ?? 3, n - 1));
+	const knots = [0];
+	const mults = [degree + 1];
+	const nInternalKnots = n - degree - 1;
+	for (let i = 1; i <= nInternalKnots; i++) {
+		knots.push(i / (nInternalKnots + 1));
+		mults.push(1);
+	}
+	knots.push(1);
+	mults.push(degree + 1);
+	return c2dWrap({
+		__bk2d: "bspline",
+		poles,
+		knots,
+		multiplicities: mults,
+		degree,
+		isPeriodic: false
+	});
 }
 function evaluateCurve2d(curve, param) {
 	return evaluateCurve2d$1(c2d(curve), param);
@@ -3222,16 +3490,53 @@ function approximateCurve2dAsBSpline(curve, maxSegments) {
 	});
 }
 function 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(trimCurve2d(curve, k0, k1));
+	let cu = c2d(curve);
+	while (cu.__bk2d === "trimmed" && cu.basis) cu = cu.basis;
+	if (cu.__bk2d !== "bspline") return [curve];
+	const poles = cu.poles;
+	const p = cu.degree;
+	const U = [];
+	for (let i = 0; i < cu.knots.length; i++) for (let j = 0; j < cu.multiplicities[i]; j++) U.push(cu.knots[i]);
+	const m = poles.length - 1 + p + 1;
+	if (p < 1 || U.length !== m + 1) return [c2dWrap(makeBezier2d$1(poles))];
+	const clone = (pt) => [pt[0], pt[1]];
+	const segments = [];
+	let a = p;
+	let b = p + 1;
+	let segPoles = [];
+	for (let i = 0; i <= p; i++) segPoles[i] = clone(poles[i]);
+	let nextPoles = [];
+	while (b < m) {
+		const i0 = b;
+		while (b < m && U[b + 1] === U[b]) b++;
+		const mult = b - i0 + 1;
+		if (mult < p) {
+			const numer = U[b] - U[a];
+			const alphas = [];
+			for (let j = p; j > mult; j--) alphas[j - mult - 1] = numer / (U[a + j] - U[a]);
+			const r = p - mult;
+			for (let j = 1; j <= r; j++) {
+				const save = r - j;
+				const s = mult + j;
+				for (let k = p; k >= s; k--) {
+					const alpha = alphas[k - s];
+					const cur = segPoles[k];
+					const prev = segPoles[k - 1];
+					segPoles[k] = [alpha * cur[0] + (1 - alpha) * prev[0], alpha * cur[1] + (1 - alpha) * prev[1]];
+				}
+				if (b < m) nextPoles[save] = clone(segPoles[p]);
+			}
+		}
+		segments.push(segPoles);
+		if (b < m) {
+			for (let i = p - mult; i <= p; i++) nextPoles[i] = clone(poles[b - p + i]);
+			segPoles = nextPoles;
+			nextPoles = [];
+			a = b;
+			b++;
+		}
 	}
-	return result.length > 0 ? result : [curve];
+	return segments.map((sp) => c2dWrap(makeBezier2d$1(sp)));
 }
 function createBoundingBox2d() {
 	return createBBox2d();
@@ -3684,124 +3989,41 @@ function applyComposedTransformWithHistory(transformFn, iterShapesFn, hashCodeFn
 }
 //#endregion
 //#region src/kernel/occtWasm/hullOps.ts
-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 hullFromPoints(k, Module, points, tolerance) {
+	if (points.length < 4) throw new Error("hullFromPoints: need at least 4 points");
+	const { points: hullPoints, faces } = quickHull(points, tolerance);
+	if (faces.length < 4) throw new Error("hullFromPoints: degenerate hull (fewer than 4 faces)");
+	return buildSolidFromFaces(k, Module, [...hullPoints], [...faces], tolerance);
 }
-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) {
-		const p = require_vec3.wasmIndex(pts, i1);
-		if (Math.hypot(p.x - p0.x, p.y - p0.y, p.z - p0.z) >= 1e-10) break;
-		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);
+/**
+* Sample surface vertices of each shape via tessellation. A coarse deflection
+* keeps the point count low — the convex hull only needs extreme points, and
+* fine meshes on curved surfaces explode the hull cost.
+*/
+function extractVertices(k, Module, shapes, tolerance) {
+	const deflection = Math.max(tolerance, 1);
+	const points = [];
+	for (const shape of shapes) {
+		const meshData = k.tessellate(unwrap(shape), deflection, deflection * .5);
+		try {
+			const posCount = meshData.positionCount;
+			const posPtr = meshData.getPositionsPtr() >> 2;
+			for (let i = 0; i < posCount; i += 3) points.push({
+				x: Module.HEAPF32[posPtr + i] ?? 0,
+				y: Module.HEAPF32[posPtr + i + 1] ?? 0,
+				z: Module.HEAPF32[posPtr + i + 2] ?? 0
+			});
+		} finally {
+			meshData.delete();
 		}
-		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;
+	}
+	return points;
 }
-function hullFromPoints(k, Module, points, tolerance) {
-	if (points.length < 4) throw new Error("hullFromPoints: need at least 4 points");
-	return buildSolidFromFaces(k, Module, points, computeConvexHullFaces(points), tolerance);
+function hull(k, Module, shapes, tolerance) {
+	if (shapes.length === 0) throw new Error("hull: no shapes provided");
+	const points = extractVertices(k, Module, shapes, tolerance);
+	if (points.length < 4) throw new Error("hull: fewer than 4 vertices extracted from input shapes");
+	return hullFromPoints(k, Module, points, tolerance);
 }
 //#endregion
 //#region src/kernel/occtWasm/occtWasmAdapter.ts
@@ -3957,8 +4179,8 @@ var OcctWasmAdapter = class OcctWasmAdapter {
 	solidFromShell(shell) {
 		return solidFromShell(this.k, shell);
 	}
-	hull(_shapes, _tolerance) {
-		notImplemented("hull");
+	hull(shapes, tolerance) {
+		return hull(this.k, this.Module, shapes, tolerance);
 	}
 	hullFromPoints(points, tolerance) {
 		return hullFromPoints(this.k, this.Module, points, tolerance);
@@ -4704,6 +4926,12 @@ Object.defineProperty(exports, "mirrorAtPoint", {
 		return mirrorAtPoint;
 	}
 });
+Object.defineProperty(exports, "quickHull", {
+	enumerable: true,
+	get: function() {
+		return quickHull;
+	}
+});
 Object.defineProperty(exports, "rotateCurve2d", {
 	enumerable: true,
 	get: function() {

package/dist/operations.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_historyFns = require("./historyFns-DrjICLPB.cjs");
-const require_extrudeFns = require("./extrudeFns-Bg-IXT_O.cjs");
+const require_historyFns = require("./historyFns-DoMVl9Wf.cjs");
+const require_extrudeFns = require("./extrudeFns-DympFQua.cjs");
 exports.addChild = require_historyFns.addChild;
 exports.addStep = require_historyFns.addStep;
 exports.circularPattern = require_historyFns.circularPattern;

package/dist/operations.js

@@ -1,3 +1,3 @@
-import { C as walkAssembly, D as exportAssemblySTEP, E as linearPattern, O as createAssembly, S as updateNode, T as gridPattern, _ as collectShapes, a as findStep, b as findNode, c as registerOperation, d as replayHistory, g as addChild, h as undoLast, l as registerShape, m as stepsFrom, n as createHistory, o as getShape, p as stepCount, r as createRegistry, s as modifyStep, t as addStep, u as replayFrom, v as countNodes, w as circularPattern, x as removeChild, y as createAssemblyNode } from "./historyFns-BSSA9qoA.js";
-import { c as sweep, i as complexExtrude, l as twistExtrude, s as supportExtrude } from "./extrudeFns-DWeYb6cu.js";
+import { C as walkAssembly, D as exportAssemblySTEP, E as linearPattern, O as createAssembly, S as updateNode, T as gridPattern, _ as collectShapes, a as findStep, b as findNode, c as registerOperation, d as replayHistory, g as addChild, h as undoLast, l as registerShape, m as stepsFrom, n as createHistory, o as getShape, p as stepCount, r as createRegistry, s as modifyStep, t as addStep, u as replayFrom, v as countNodes, w as circularPattern, x as removeChild, y as createAssemblyNode } from "./historyFns-D89ZUO18.js";
+import { c as sweep, i as complexExtrude, l as twistExtrude, s as supportExtrude } from "./extrudeFns-D49C5SBL.js";
 export { addChild, addStep, circularPattern, collectShapes, complexExtrude, countNodes, createAssembly, createAssemblyNode, createHistory, createRegistry, exportAssemblySTEP, findNode, findStep, getShape as getHistoryShape, gridPattern, linearPattern, modifyStep, registerOperation, registerShape, removeChild, replayFrom, replayHistory, stepCount, stepsFrom, supportExtrude, sweep, twistExtrude, undoLast, updateNode, walkAssembly };

package/dist/{primitiveFns-BjeLfI12.js → primitiveFns-BD6YZbCJ.js}

@@ -1,13 +1,13 @@
-import { Z as getKernel, _ as isSolid, c as createSolid, h as isShape3D, p as isFace, r as castShapeWithKnownType, t as castShape, x as isClosedWire, y as isWire } from "./shapeTypes-BH-9bXON.js";
+import { Z as getKernel, _ as isSolid, c as createSolid, h as isShape3D, p as isFace, r as castShapeWithKnownType, t as castShape, x as isClosedWire, y as isWire } from "./shapeTypes-BKeiP62J.js";
 import { A as ok, T as isOk, b as err, d as validationError, i as kernelError, l as typeCastError, t as BrepErrorCode, v as andThen, w as isErr } from "./errors-DNWJsfVU.js";
-import { c as getFaces, i as getCachedIsValid, l as getOrCreateCache, m as invalidateShapeCache, p as getWires, s as getEdges } from "./topologyQueryFns-B8uqQlEU.js";
+import { c as getFaces, i as getCachedIsValid, l as getOrCreateCache, m as invalidateShapeCache, p as getWires, s as getEdges } from "./topologyQueryFns-DhdAOL0M.js";
 import { n as HASH_CODE_MAX, t as DEG2RAD } from "./constants-ITRzCnCp.js";
-import { _ as downcast } from "./faceFns-DBEEcVC-.js";
-import { _ as propagateAllMetadata, g as collectInputFaceHashes, h as translate } from "./shapeFns-oS8Us7JQ.js";
+import { _ as downcast } from "./faceFns-DLjTsZIu.js";
+import { _ as propagateAllMetadata, g as collectInputFaceHashes, h as translate } from "./shapeFns-C8pitNme.js";
 import { t as firstOrThrow } from "./arrayAccess-DrUGPADn.js";
-import { _ as makeThreePointArc, a as makeNonPlanarFace, c as makeBSplineApproximation, d as makeCircle, f as makeEllipse, g as makeTangentArc, h as makeLine, i as makeNewFaceWithinFace, m as makeHelix, o as makePolygon, p as makeEllipseArc, r as makeFace, s as assembleWire, t as addHolesInFace, u as makeBezierCurve } from "./surfaceBuilders-xmm7fFbW.js";
-import { a as fuseAll, i as fuse, n as cut, r as cutAll } from "./booleanFns-BPWMgD1t.js";
-import { a as makeOffset, c as makeTorus, i as makeEllipsoid, l as makeVertex, n as makeCone, o as makeSolid, r as makeCylinder, s as makeSphere, t as makeCompound, u as weldShellsAndFaces } from "./solidBuilders-BiduNSRx.js";
+import { _ as makeThreePointArc, a as makeNonPlanarFace, c as makeBSplineApproximation, d as makeCircle, f as makeEllipse, g as makeTangentArc, h as makeLine, i as makeNewFaceWithinFace, m as makeHelix, o as makePolygon, p as makeEllipseArc, r as makeFace, s as assembleWire, t as addHolesInFace, u as makeBezierCurve } from "./surfaceBuilders-d4o4OoWy.js";
+import { a as fuseAll, i as fuse, n as cut, r as cutAll } from "./booleanFns-D7A-hqSP.js";
+import { a as makeOffset, c as makeTorus, i as makeEllipsoid, l as makeVertex, n as makeCone, o as makeSolid, r as makeCylinder, s as makeSphere, t as makeCompound, u as weldShellsAndFaces } from "./solidBuilders-DjPCyWCd.js";
 //#region src/topology/threeHelpers.ts
 /**
 * Convert a ShapeMesh into BufferGeometry-compatible typed arrays.

package/dist/{primitiveFns-DtY84t7q.cjs → primitiveFns-DFnQlGVV.cjs}

@@ -1,13 +1,13 @@
-const require_shapeTypes = require("./shapeTypes-BiX2PjaO.cjs");
+const require_shapeTypes = require("./shapeTypes-D5Nua1z1.cjs");
 const require_errors = require("./errors-CXJtc4I7.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-BoMkI1jZ.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-BNv_2PHm.cjs");
 const require_constants = require("./constants-BOVyEYGH.cjs");
-const require_faceFns = require("./faceFns-ThsHosgU.cjs");
-const require_shapeFns = require("./shapeFns-lDEvCF5Q.cjs");
+const require_faceFns = require("./faceFns-3HqgY1VN.cjs");
+const require_shapeFns = require("./shapeFns-CnNKfmw8.cjs");
 const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-s2Uo2ard.cjs");
-const require_booleanFns = require("./booleanFns-NkgP7bZA.cjs");
-const require_solidBuilders = require("./solidBuilders-DR3oU7Fb.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-6QimO9vi.cjs");
+const require_booleanFns = require("./booleanFns-CCJFmZf6.cjs");
+const require_solidBuilders = require("./solidBuilders-0ZZGbPt3.cjs");
 //#region src/topology/threeHelpers.ts
 /**
 * Convert a ShapeMesh into BufferGeometry-compatible typed arrays.

package/dist/projection.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_cameraFns = require("./cameraFns-Bb5fmsNi.cjs");
+const require_cameraFns = require("./cameraFns-D79etXJw.cjs");
 exports.PROJECTION_PLANES = require_cameraFns.PROJECTION_PLANES;
 exports.cameraFromPlane = require_cameraFns.cameraFromPlane;
 exports.cameraLookAt = require_cameraFns.cameraLookAt;

package/dist/projection.js

@@ -1,2 +1,2 @@
-import { a as makeProjectedEdges, i as projectEdges, n as cameraLookAt, o as PROJECTION_PLANES, r as createCamera, s as isProjectionPlane, t as cameraFromPlane } from "./cameraFns-B5FrSRRP.js";
+import { a as makeProjectedEdges, i as projectEdges, n as cameraLookAt, o as PROJECTION_PLANES, r as createCamera, s as isProjectionPlane, t as cameraFromPlane } from "./cameraFns-BvZw_Bje.js";
 export { PROJECTION_PLANES, cameraFromPlane, cameraLookAt, createCamera, isProjectionPlane, makeProjectedEdges, projectEdges };

package/dist/query.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_helpers = require("./helpers-D6XMORWy.cjs");
-const require_cornerFinder = require("./cornerFinder-Nd00yMHA.cjs");
+const require_helpers = require("./helpers-BSU8Ilxm.cjs");
+const require_cornerFinder = require("./cornerFinder-D3m1OkXN.cjs");
 exports.cornerFinder = require_cornerFinder.cornerFinder;
 exports.edgeFinder = require_helpers.edgeFinder;
 exports.faceFinder = require_helpers.faceFinder;

package/dist/query.js

@@ -1,3 +1,3 @@
-import { n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-D2RrISk0.js";
-import { t as cornerFinder } from "./cornerFinder-NT0nEY2D.js";
+import { n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-DI2r-O_h.js";
+import { t as cornerFinder } from "./cornerFinder-BPz7nFlt.js";
 export { cornerFinder, edgeFinder, faceFinder, getSingleFace };

package/dist/{shapeFns-oS8Us7JQ.js → shapeFns-C8pitNme.js}

@@ -1,6 +1,6 @@
-import { Z as getKernel, t as castShape } from "./shapeTypes-BH-9bXON.js";
+import { Z as getKernel, t as castShape } from "./shapeTypes-BKeiP62J.js";
 import { A as ok, b as err, d as validationError, t as BrepErrorCode } from "./errors-DNWJsfVU.js";
-import { C as kernelCall, c as getFaces, l as getOrCreateCache, r as getCacheEntry, w as kernelCallRaw } from "./topologyQueryFns-B8uqQlEU.js";
+import { C as kernelCall, c as getFaces, l as getOrCreateCache, r as getCacheEntry, w as kernelCallRaw } from "./topologyQueryFns-DhdAOL0M.js";
 import { n as HASH_CODE_MAX, t as DEG2RAD } from "./constants-ITRzCnCp.js";
 //#region src/topology/metadata/originTrackingFns.ts
 /**

package/dist/{shapeFns-lDEvCF5Q.cjs → shapeFns-CnNKfmw8.cjs}

@@ -1,6 +1,6 @@
-const require_shapeTypes = require("./shapeTypes-BiX2PjaO.cjs");
+const require_shapeTypes = require("./shapeTypes-D5Nua1z1.cjs");
 const require_errors = require("./errors-CXJtc4I7.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-BoMkI1jZ.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-BNv_2PHm.cjs");
 const require_constants = require("./constants-BOVyEYGH.cjs");
 //#region src/topology/metadata/originTrackingFns.ts
 /**

package/dist/shapeRef.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_shapeRefFns = require("./shapeRefFns-DHioZfFV.cjs");
+const require_shapeRefFns = require("./shapeRefFns-DtCBv52A.cjs");
 exports.assignRoles = require_shapeRefFns.assignRoles;
 exports.captureHint = require_shapeRefFns.captureHint;
 exports.createRef = require_shapeRefFns.createRef;

package/dist/shapeRef.js

@@ -1,2 +1,2 @@
-import { a as updateRoles, i as resolveRef, n as captureHint, o as defaultScorer, r as createRef, t as assignRoles } from "./shapeRefFns-C2DbyKEO.js";
+import { a as updateRoles, i as resolveRef, n as captureHint, o as defaultScorer, r as createRef, t as assignRoles } from "./shapeRefFns-BQlYDeCD.js";
 export { assignRoles, captureHint, createRef, defaultScorer, resolveRef, updateRoles };