brepjs 13.0.0 → 13.2.0

package/dist/primitiveFns-u3Bbdvlw.js

@@ -1,806 +0,0 @@
-import { Y 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-D38b_BKF.js";
-import { C as isErr, _ as andThen, d as validationError, i as kernelError, k as ok, l as typeCastError, t as BrepErrorCode, w as isOk, y as err } from "./errors-B1fl3mAU.js";
-import { _ as DEG2RAD, v as HASH_CODE_MAX } from "./vecOps-B9-MTeC8.js";
-import { _ as downcast } from "./faceFns-Bne5RIvn.js";
-import { I as getFaces, L as getOrCreateCache, v as translate, z as getWires } from "./arrayAccess-CccV7jov.js";
-import { a as makeNonPlanarFace, c as makeBSplineApproximation, d as makeEllipse, f as makeEllipseArc, g as makeThreePointArc, h as makeTangentArc, i as makeNewFaceWithinFace, l as makeBezierCurve, m as makeLine, o as makePolygon, p as makeHelix, r as makeFace, s as assembleWire, t as addHolesInFace, u as makeCircle } from "./surfaceBuilders-DiCVk_Un.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-FaTmd_PS.js";
-//#region src/topology/threeHelpers.ts
-/**
-* Convert a ShapeMesh into BufferGeometry-compatible typed arrays.
-*
-* The returned arrays can be used directly with Three.js:
-* ```ts
-* const geo = new THREE.BufferGeometry();
-* geo.setAttribute('position', new THREE.BufferAttribute(data.position, 3));
-* geo.setAttribute('normal', new THREE.BufferAttribute(data.normal, 3));
-* geo.setIndex(new THREE.BufferAttribute(data.index, 1));
-* ```
-*/
-function toBufferGeometryData(mesh) {
-	return {
-		position: mesh.vertices,
-		normal: mesh.normals,
-		index: mesh.triangles
-	};
-}
-/**
-* Convert a ShapeMesh into grouped BufferGeometry data with face material groups.
-*
-* Each face becomes a separate group, allowing per-face materials in Three.js:
-* ```ts
-* const data = toGroupedBufferGeometryData(mesh);
-* const geo = new THREE.BufferGeometry();
-* geo.setAttribute('position', new THREE.BufferAttribute(data.position, 3));
-* geo.setAttribute('normal', new THREE.BufferAttribute(data.normal, 3));
-* geo.setIndex(new THREE.BufferAttribute(data.index, 1));
-* for (const g of data.groups) {
-*   geo.addGroup(g.start, g.count, g.materialIndex);
-* }
-* ```
-*/
-function toGroupedBufferGeometryData(mesh) {
-	return {
-		position: mesh.vertices,
-		normal: mesh.normals,
-		index: mesh.triangles,
-		groups: mesh.faceGroups.map((g, i) => ({
-			start: g.start,
-			count: g.count,
-			materialIndex: i,
-			faceId: g.faceId
-		}))
-	};
-}
-/**
-* Convert an EdgeMesh into position data for THREE.LineSegments.
-*
-* ```ts
-* const geo = new THREE.BufferGeometry();
-* geo.setAttribute('position', new THREE.BufferAttribute(data.position, 3));
-* const lines = new THREE.LineSegments(geo, material);
-* ```
-*/
-function toLineGeometryData(mesh) {
-	return { position: mesh.lines };
-}
-//#endregion
-//#region src/topology/chamferAngleFns.ts
-/**
-* Chamfer with distance + angle — functional API.
-*
-* Provides chamferDistAngle() which chamfers edges using a distance
-* measured along one face and an angle to determine the chamfer on the other.
-*/
-/**
-* Chamfer edges of a shape using distance + angle.
-*
-* The distance is measured along the face that contains the edge, and the
-* angle (in degrees) determines how the chamfer cuts into the adjacent face.
-*
-* @param shape   - The 3D shape to chamfer.
-* @param edges   - Edges to chamfer (must not be empty).
-* @param distance - Chamfer distance along the face (must be positive).
-* @param angleDeg - Chamfer angle in degrees (must be in range (0, 90)).
-* @returns Ok with the chamfered shape, or Err on invalid input or kernel failure.
-*
-* @remarks Uses `BRepFilletAPI_MakeChamfer.AddDA(dist, angle, edge, face)` internally.
-*/
-function chamferDistAngle(shape, edges, distance, angleDeg) {
-	if (edges.length === 0) return err(validationError("CHAMFER_ANGLE_NO_EDGES", "chamferDistAngle requires at least one edge", void 0, { edgeCount: 0 }));
-	if (distance <= 0) return err(validationError("CHAMFER_ANGLE_BAD_DISTANCE", `distance must be positive, got ${distance}`, void 0, { distance }));
-	if (angleDeg <= 0 || angleDeg >= 90) return err(validationError("CHAMFER_ANGLE_BAD_ANGLE", `angleDeg must be in range (0, 90), got ${angleDeg}`, void 0, { angleDeg }));
-	let raw;
-	try {
-		const kernel = getKernel();
-		const rawEdges = edges.map((e) => e.wrapped);
-		raw = kernel.chamferDistAngle(shape.wrapped, rawEdges, distance, angleDeg);
-	} catch (e) {
-		return err(kernelError("CHAMFER_ANGLE_FAILED", `chamferDistAngle kernel call failed: ${e instanceof Error ? e.message : String(e)}`, e, {
-			distance,
-			angleDeg,
-			edgeCount: edges.length
-		}));
-	}
-	const downcastResult = downcast(raw);
-	if (isErr(downcastResult)) return downcastResult;
-	const wrapped = castShape(downcastResult.value);
-	if (!isShape3D(wrapped)) {
-		wrapped[Symbol.dispose]();
-		return err(typeCastError("CHAMFER_ANGLE_NOT_3D", "chamferDistAngle did not produce a 3D shape"));
-	}
-	return ok(wrapped);
-}
-//#endregion
-//#region src/topology/adjacencyFns.ts
-/**
-* Topology adjacency queries — find related sub-shapes within a parent shape.
-*
-* Uses cached topology extraction and an edge→faces adjacency map
-* (built once per parent shape and cached) to avoid redundant WASM calls.
-*/
-function wrapAll(shapes, type) {
-	return shapes.map((s) => castShapeWithKnownType(s, type));
-}
-/**
-* Iterate sub-shapes of `parentKernel` of the given `type`, deduplicate by
-* hash+isSame, and return branded handles of type `T`.
-*
-* Used by edgesOfFace, wiresOfFace, and verticesOfEdge — all of which need
-* the same deduplicated-children pattern on a raw KernelShape.
-*/
-function deduplicatedSubShapes(parentKernel, type) {
-	const kernel = getKernel();
-	const items = kernel.iterShapes(parentKernel, type);
-	const results = [];
-	const seen = /* @__PURE__ */ new Map();
-	for (const item of items) {
-		const hash = kernel.hashCode(item, HASH_CODE_MAX);
-		const bucket = seen.get(hash);
-		if (!bucket) {
-			seen.set(hash, [item]);
-			results.push(item);
-		} else if (!bucket.some((r) => kernel.isSame(r, item))) {
-			bucket.push(item);
-			results.push(item);
-		}
-	}
-	return wrapAll(results, type);
-}
-/**
-* Build or retrieve the cached edge→faces adjacency map for a parent shape.
-* Maps edge hash codes to edge-face pairs, storing the edge alongside each
-* face so facesOfEdge can verify via isSame without re-extracting face edges.
-*/
-function getEdgeToFacesMap(parent) {
-	const cache = getOrCreateCache(parent);
-	if (cache.edgeToFaces) return cache.edgeToFaces;
-	const kernel = getKernel();
-	const edgeToFaces = /* @__PURE__ */ new Map();
-	const allFaces = kernel.iterShapes(parent.wrapped, "face");
-	for (const f of allFaces) {
-		const edges = kernel.iterShapes(f, "edge");
-		for (const e of edges) {
-			const hash = kernel.hashCode(e, HASH_CODE_MAX);
-			let bucket = edgeToFaces.get(hash);
-			if (!bucket) {
-				bucket = [];
-				edgeToFaces.set(hash, bucket);
-			}
-			if (!bucket.some((entry) => kernel.isSame(entry.edge, e) && kernel.isSame(entry.face, f))) bucket.push({
-				edge: e,
-				face: f
-			});
-		}
-	}
-	cache.edgeToFaces = edgeToFaces;
-	return edgeToFaces;
-}
-/**
-* Get all faces adjacent to a given edge within a parent shape.
-*
-* An edge typically borders exactly two faces in a solid, or one face
-* if the edge is on a boundary.
-*
-* @param parent - The parent shape to search within.
-* @param edge - The edge whose adjacent faces to find.
-* @returns Array of unique faces containing the given edge.
-*/
-function facesOfEdge(parent, edge) {
-	const kernel = getKernel();
-	const edgeToFaces = getEdgeToFacesMap(parent);
-	const hash = kernel.hashCode(edge.wrapped, HASH_CODE_MAX);
-	const bucket = edgeToFaces.get(hash) ?? [];
-	const results = [];
-	const seen = /* @__PURE__ */ new Map();
-	for (const entry of bucket) {
-		if (!kernel.isSame(entry.edge, edge.wrapped)) continue;
-		const fHash = kernel.hashCode(entry.face, HASH_CODE_MAX);
-		const fBucket = seen.get(fHash);
-		if (!fBucket) {
-			seen.set(fHash, [entry.face]);
-			results.push(entry.face);
-		} else if (!fBucket.some((r) => kernel.isSame(r, entry.face))) {
-			fBucket.push(entry.face);
-			results.push(entry.face);
-		}
-	}
-	return wrapAll(results, "face");
-}
-/**
-* Get all edges bounding a face.
-*
-* @param face - The face whose edges to enumerate.
-* @returns Array of unique edges forming the face boundary.
-*/
-function edgesOfFace(face) {
-	return deduplicatedSubShapes(face.wrapped, "edge");
-}
-/**
-* Get all wires of a face (outer wire + inner hole wires).
-* All wires bounding a face are closed by definition.
-*
-* @param face - The face whose wires to enumerate.
-*/
-function wiresOfFace(face) {
-	return deduplicatedSubShapes(face.wrapped, "wire");
-}
-/**
-* Get the start and end vertices of an edge.
-*
-* @param edge - The edge whose vertices to retrieve.
-* @returns Array of 1-2 vertices (1 if degenerate/closed, 2 otherwise).
-*/
-function verticesOfEdge(edge) {
-	return deduplicatedSubShapes(edge.wrapped, "vertex");
-}
-/**
-* Get all faces that share at least one edge with the given face.
-*
-* The returned list does not include the input face itself.
-* Uses the cached edge→faces adjacency map for the parent shape.
-*
-* @param parent - The parent shape to search within.
-* @param face - The face whose neighbors to find.
-* @returns Array of unique adjacent faces (excluding the input face).
-*/
-function adjacentFaces(parent, face) {
-	const kernel = getKernel();
-	const edgeToFaces = getEdgeToFacesMap(parent);
-	const faceEdgeHandles = deduplicatedSubShapes(face.wrapped, "edge");
-	const neighborRaw = [];
-	const seen = /* @__PURE__ */ new Map();
-	for (const edgeHandle of faceEdgeHandles) {
-		const hash = kernel.hashCode(edgeHandle.wrapped, HASH_CODE_MAX);
-		const entries = edgeToFaces.get(hash) ?? [];
-		for (const entry of entries) {
-			if (kernel.isSame(entry.face, face.wrapped)) continue;
-			const fHash = kernel.hashCode(entry.face, HASH_CODE_MAX);
-			const bucket = seen.get(fHash);
-			if (!bucket) {
-				seen.set(fHash, [entry.face]);
-				neighborRaw.push(entry.face);
-			} else if (!bucket.some((r) => kernel.isSame(r, entry.face))) {
-				bucket.push(entry.face);
-				neighborRaw.push(entry.face);
-			}
-		}
-	}
-	return wrapAll(neighborRaw, "face");
-}
-/**
-* Get all edges shared between two faces.
-*
-* @param face1 - The first face.
-* @param face2 - The second face.
-* @returns Array of edges present in both faces (via isSame comparison).
-*/
-function sharedEdges(face1, face2) {
-	const kernel = getKernel();
-	const edges1 = kernel.iterShapes(face1.wrapped, "edge");
-	const edges2 = kernel.iterShapes(face2.wrapped, "edge");
-	const edge2Map = /* @__PURE__ */ new Map();
-	for (const e2 of edges2) {
-		const hash = kernel.hashCode(e2, HASH_CODE_MAX);
-		let bucket = edge2Map.get(hash);
-		if (!bucket) {
-			bucket = [];
-			edge2Map.set(hash, bucket);
-		}
-		bucket.push(e2);
-	}
-	const shared = [];
-	for (const e1 of edges1) if (edge2Map.get(kernel.hashCode(e1, 2147483647))?.some((e2) => kernel.isSame(e1, e2))) shared.push(e1);
-	return wrapAll(shared, "edge");
-}
-//#endregion
-//#region src/topology/healingFns.ts
-/**
-* Shape healing and validation functions.
-*
-* Uses ShapeFix_Solid, ShapeFix_Face, ShapeFix_Wire, and BRepCheck_Analyzer
-* to validate and repair shapes.
-*/
-/**
-* Check if a shape is valid according to kernel geometry and topology checks.
-*/
-function isValid(shape) {
-	return getKernel().isValid(shape.wrapped);
-}
-/**
-* Attempt to heal/fix a solid shape.
-*
-* Uses ShapeFix_Solid to repair topology issues like gaps, wrong orientation, etc.
-*/
-function healSolid(solid) {
-	if (!isSolid(solid)) return err(validationError("NOT_A_SOLID", "Input shape is not a solid"));
-	const alreadyValid = isValid(solid);
-	try {
-		const result = getKernel().healSolid(solid.wrapped);
-		if (!result) {
-			if (alreadyValid) return ok(solid);
-			return err(kernelError(BrepErrorCode.HEAL_NO_EFFECT, "Solid healing had no effect — shape is still invalid"));
-		}
-		const cast = castShape(result);
-		if (!isSolid(cast)) return err(kernelError("HEAL_RESULT_NOT_SOLID", "Healed result is not a solid"));
-		if (!isValid(cast)) return err(kernelError("HEAL_SOLID_INCOMPLETE", "Healed result is still invalid after ShapeFix_Solid"));
-		return ok(cast);
-	} catch (e) {
-		return err(kernelError("HEAL_SOLID_FAILED", "Solid healing failed", e));
-	}
-}
-/**
-* Attempt to heal/fix a face.
-*
-* Uses ShapeFix_Face to repair wire ordering, orientation, and geometry issues.
-*/
-function healFace(face) {
-	if (!isFace(face)) return err(validationError("NOT_A_FACE", "Input shape is not a face"));
-	try {
-		const cast = castShape(getKernel().healFace(face.wrapped));
-		if (!isFace(cast)) return err(kernelError("HEAL_RESULT_NOT_FACE", "Healed result is not a face"));
-		return ok(cast);
-	} catch (e) {
-		return err(kernelError("HEAL_FACE_FAILED", "Face healing failed", e));
-	}
-}
-/**
-* Attempt to heal/fix a wire.
-*
-* Uses ShapeFix_Wire to repair edge connectivity, gaps, and self-intersections.
-* Requires a face for surface context; pass `undefined` to use a default planar context.
-*/
-function healWire(wire, face) {
-	if (!isWire(wire)) return err(validationError("NOT_A_WIRE", "Input shape is not a wire"));
-	try {
-		const cast = castShape(getKernel().healWire(wire.wrapped, face?.wrapped));
-		if (!isWire(cast)) return err(kernelError("HEAL_RESULT_NOT_WIRE", "Healed result is not a wire"));
-		return ok(cast);
-	} catch (e) {
-		return err(kernelError("HEAL_WIRE_FAILED", "Wire healing failed", e));
-	}
-}
-/**
-* Attempt to heal any shape by dispatching to the appropriate fixer.
-*
-* Supports solids, faces, and wires. For other shape types, returns the
-* input unchanged.
-*/
-function heal(shape) {
-	if (isSolid(shape)) return healSolid(shape);
-	if (isFace(shape)) return healFace(shape);
-	if (isWire(shape)) return healWire(shape);
-	return ok(shape);
-}
-/**
-* Automatically heal a shape using the appropriate shape-level fixer.
-*
-* If the shape is already valid, returns it unchanged with a no-op report.
-* Uses ShapeFix_Solid/Face/Wire depending on shape type, which internally
-* handles sub-shape healing and reconstruction.
-*/
-function autoHeal(shape, options) {
-	const fixWires = options?.fixWires !== false;
-	const fixFaces = options?.fixFaces !== false;
-	const fixSolids = options?.fixSolids !== false;
-	const fixSelfIntersection = options?.fixSelfIntersection === true;
-	const sewTolerance = options?.sewTolerance;
-	const steps = [];
-	const diagnostics = [];
-	if (isValid(shape)) return ok({
-		shape,
-		report: {
-			isValid: true,
-			alreadyValid: true,
-			wiresHealed: 0,
-			facesHealed: 0,
-			solidHealed: false,
-			steps: ["Shape already valid"],
-			diagnostics: [{
-				name: "validation",
-				attempted: true,
-				succeeded: true
-			}]
-		}
-	});
-	steps.push("Shape invalid — applying shape-level healing");
-	const wiresBefore = getWires(shape).length;
-	const facesBefore = getFaces(shape).length;
-	let current = shape;
-	let solidHealed = false;
-	if (sewTolerance !== void 0) try {
-		current = castShape(getKernel().sew([current.wrapped], sewTolerance));
-		steps.push(`Applied sewing with tolerance ${sewTolerance}`);
-		diagnostics.push({
-			name: "sew",
-			attempted: true,
-			succeeded: true,
-			detail: `tolerance=${sewTolerance}`
-		});
-	} catch (e) {
-		const detail = e instanceof Error ? e.message : String(e);
-		steps.push(`Sewing failed: ${detail}`);
-		diagnostics.push({
-			name: "sew",
-			attempted: true,
-			succeeded: false,
-			detail
-		});
-	}
-	if (fixSelfIntersection && fixWires) {
-		const wires = getWires(current);
-		let fixCount = 0;
-		for (const wire of wires) try {
-			getKernel().fixSelfIntersection(wire.wrapped);
-			fixCount++;
-		} catch {}
-		steps.push(`Self-intersection fix: ${fixCount}/${wires.length} wires`);
-		diagnostics.push({
-			name: "fixSelfIntersection",
-			attempted: true,
-			succeeded: fixCount > 0,
-			detail: `${fixCount}/${wires.length} wires fixed`
-		});
-	}
-	if (isSolid(current) && fixSolids || isFace(current) && fixFaces || isWire(current) && fixWires) {
-		const healResult = heal(current);
-		if (isOk(healResult)) {
-			current = healResult.value;
-			if (isSolid(shape)) {
-				solidHealed = true;
-				steps.push("Applied ShapeFix_Solid");
-				diagnostics.push({
-					name: "healSolid",
-					attempted: true,
-					succeeded: true
-				});
-			} else if (isFace(shape)) {
-				steps.push("Applied ShapeFix_Face");
-				diagnostics.push({
-					name: "healFace",
-					attempted: true,
-					succeeded: true
-				});
-			} else {
-				steps.push("Applied ShapeFix_Wire");
-				diagnostics.push({
-					name: "healWire",
-					attempted: true,
-					succeeded: true
-				});
-			}
-		} else {
-			steps.push("Shape-level healing failed");
-			diagnostics.push({
-				name: "healShape",
-				attempted: true,
-				succeeded: false
-			});
-		}
-	} else diagnostics.push({
-		name: "healShape",
-		attempted: false,
-		succeeded: false,
-		detail: "skipped by options"
-	});
-	const wiresAfter = getWires(current).length;
-	const facesAfter = getFaces(current).length;
-	const wiresHealed = Math.abs(wiresAfter - wiresBefore);
-	const facesHealed = Math.abs(facesAfter - facesBefore);
-	if (wiresHealed > 0) steps.push(`Wire count changed by ${wiresHealed}`);
-	if (facesHealed > 0) steps.push(`Face count changed by ${facesHealed}`);
-	const valid = isValid(current);
-	steps.push(valid ? "Final validation: valid" : "Final validation: still invalid");
-	diagnostics.push({
-		name: "finalValidation",
-		attempted: true,
-		succeeded: valid
-	});
-	return ok({
-		shape: current,
-		report: {
-			isValid: valid,
-			alreadyValid: false,
-			wiresHealed,
-			facesHealed,
-			solidHealed,
-			steps,
-			diagnostics
-		}
-	});
-}
-//#endregion
-//#region src/topology/primitiveFns.ts
-/**
-* Create a box with the given dimensions.
-*
-* @param width  - Size along X.
-* @param depth  - Size along Y.
-* @param height - Size along Z.
-*/
-function box(width, depth, height, options) {
-	const solid = createSolid(getKernel().makeBox(width, depth, height));
-	const center = options?.at ?? (options?.centered ? [
-		0,
-		0,
-		0
-	] : void 0);
-	if (center) return translate(solid, [
-		center[0] - width / 2,
-		center[1] - depth / 2,
-		center[2] - height / 2
-	]);
-	return solid;
-}
-/**
-* Create a cylinder with the given radius and height.
-*/
-function cylinder(radius, height, options) {
-	const at = options?.at ?? [
-		0,
-		0,
-		0
-	];
-	const axis = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	let solid = makeCylinder(radius, height, at, axis);
-	if (options?.centered) {
-		const halfShift = [
-			-axis[0] * height * .5,
-			-axis[1] * height * .5,
-			-axis[2] * height * .5
-		];
-		solid = translate(solid, halfShift);
-	}
-	return solid;
-}
-/**
-* Create a sphere with the given radius.
-*/
-function sphere(radius, options) {
-	let solid = makeSphere(radius);
-	if (options?.at) solid = translate(solid, options.at);
-	return solid;
-}
-/**
-* Create a cone (or frustum) with the given radii and height.
-*
-* @param bottomRadius - Radius at the base.
-* @param topRadius    - Radius at the top (0 for a full cone).
-* @param height       - Height of the cone.
-*/
-function cone(bottomRadius, topRadius, height, options) {
-	const at = options?.at ?? [
-		0,
-		0,
-		0
-	];
-	const axis = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	let solid = makeCone(bottomRadius, topRadius, height, at, axis);
-	if (options?.centered) {
-		const halfShift = [
-			-axis[0] * height * .5,
-			-axis[1] * height * .5,
-			-axis[2] * height * .5
-		];
-		solid = translate(solid, halfShift);
-	}
-	return solid;
-}
-/**
-* Create a torus with the given major and minor radii.
-*/
-function torus(majorRadius, minorRadius, options) {
-	return makeTorus(majorRadius, minorRadius, options?.at ?? [
-		0,
-		0,
-		0
-	], options?.axis ?? [
-		0,
-		0,
-		1
-	]);
-}
-/**
-* Create an ellipsoid with the given axis half-lengths.
-*
-* @param rx - Half-length along X.
-* @param ry - Half-length along Y.
-* @param rz - Half-length along Z.
-*/
-function ellipsoid(rx, ry, rz, options) {
-	let solid = makeEllipsoid(rx, ry, rz);
-	if (options?.at) solid = translate(solid, options.at);
-	return solid;
-}
-/** Create a straight edge between two 3D points. */
-function line(from, to) {
-	return makeLine(from, to);
-}
-/** Create a circular edge with the given radius. */
-function circle(radius, options) {
-	const axisDir = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	return makeCircle(radius, options?.at ?? [
-		0,
-		0,
-		0
-	], axisDir);
-}
-/**
-* Create an elliptical edge.
-*
-* @returns An error if `minorRadius` exceeds `majorRadius`.
-*/
-function ellipse(majorRadius, minorRadius, options) {
-	const axisDir = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	return makeEllipse(majorRadius, minorRadius, options?.at ?? [
-		0,
-		0,
-		0
-	], axisDir, options?.xDir);
-}
-/**
-* Create a helical wire.
-*
-* @param pitch  - Vertical distance per full turn.
-* @param height - Total height.
-* @param radius - Helix radius.
-*/
-function helix(pitch, height, radius, options) {
-	return makeHelix(pitch, height, radius, options?.at ?? [
-		0,
-		0,
-		0
-	], options?.axis ?? [
-		0,
-		0,
-		1
-	], options?.lefthand ?? false);
-}
-/** Create a circular arc edge passing through three points. */
-function threePointArc(p1, p2, p3) {
-	return makeThreePointArc(p1, p2, p3);
-}
-/**
-* Create an elliptical arc edge between two angles.
-*
-* All angles are in **degrees** (unlike the legacy `makeEllipseArc` which used radians).
-*
-* @param startAngle - Start angle in degrees.
-* @param endAngle   - End angle in degrees.
-*/
-function ellipseArc(majorRadius, minorRadius, startAngle, endAngle, options) {
-	const axisDir = options?.axis ?? [
-		0,
-		0,
-		1
-	];
-	return makeEllipseArc(majorRadius, minorRadius, startAngle * DEG2RAD, endAngle * DEG2RAD, options?.at ?? [
-		0,
-		0,
-		0
-	], axisDir, options?.xDir);
-}
-/**
-* Create a B-spline edge that approximates a set of 3D points.
-*
-* @returns An error if the approximation algorithm fails.
-*/
-function bsplineApprox(points, config) {
-	return makeBSplineApproximation(points, config);
-}
-/**
-* Create a Bezier curve edge from control points.
-*
-* @param points - Two or more control points.
-*/
-function bezier(points) {
-	return makeBezierCurve(points);
-}
-/**
-* Create a circular arc edge tangent to a direction at the start point.
-*/
-function tangentArc(startPoint, startTgt, endPoint) {
-	return makeTangentArc(startPoint, startTgt, endPoint);
-}
-/**
-* Assemble edges and/or wires into a single connected wire.
-*/
-function wire(listOfEdges) {
-	return assembleWire(listOfEdges);
-}
-/**
-* Assemble edges into a wire and verify it forms a closed loop.
-*
-* Combines {@link wire} + the `closedWire` smart constructor in a single step.
-* Returns an error if the edges cannot be assembled or the wire is not closed.
-*
-* @example
-* ```ts
-* const cw = unwrap(wireLoop([e1, e2, e3, e4]));
-* const f = unwrap(face(cw)); // ClosedWire accepted directly
-* ```
-*/
-function wireLoop(listOfEdges) {
-	return andThen(assembleWire(listOfEdges), (w) => {
-		if (isClosedWire(w)) return ok(w);
-		return err(validationError("WIRE_NOT_CLOSED", "Assembled wire is not closed: start and end points do not coincide"));
-	});
-}
-/**
-* Create a planar face from a closed wire, optionally with holes.
-* The resulting face is always oriented (consistent normal direction).
-*/
-function face(w, holes) {
-	return makeFace(w, holes);
-}
-/**
-* Create a non-planar face from a wire using surface filling.
-* The resulting face is always oriented.
-*/
-function filledFace(w) {
-	return makeNonPlanarFace(w);
-}
-/**
-* Create a face bounded by a wire on an existing face's surface.
-* The resulting face inherits orientation from the origin face.
-*/
-function subFace(originFace, w) {
-	return makeNewFaceWithinFace(originFace, w);
-}
-/**
-* Create a polygonal face from three or more coplanar points.
-* The resulting face is always oriented.
-*/
-function polygon(points) {
-	return makePolygon(points);
-}
-/** Create a vertex at a 3D point. */
-function vertex(point) {
-	return makeVertex(point);
-}
-/**
-* Build a compound from multiple shapes.
-*/
-function compound(shapeArray) {
-	return makeCompound(shapeArray);
-}
-/**
-* Weld faces and shells into a single solid.
-* The resulting solid is always validated.
-*/
-function solid(facesOrShells) {
-	return makeSolid(facesOrShells);
-}
-/**
-* Create an offset shape from a face.
-*/
-function offsetFace(f, distance, tolerance) {
-	return makeOffset(f, distance, tolerance);
-}
-/**
-* Weld faces and shells into a single shell.
-*/
-function sewShells(facesOrShells, ignoreType) {
-	return weldShellsAndFaces(facesOrShells, ignoreType);
-}
-function addHoles(f, holes) {
-	return addHolesInFace(f, holes);
-}
-//#endregion
-export { healFace as A, chamferDistAngle as B, threePointArc as C, wireLoop as D, wire as E, edgesOfFace as F, toGroupedBufferGeometryData as H, facesOfEdge as I, sharedEdges as L, healWire as M, isValid as N, autoHeal as O, adjacentFaces as P, verticesOfEdge as R, tangentArc as S, vertex as T, toLineGeometryData as U, toBufferGeometryData as V, polygon as _, circle as a, sphere as b, cylinder as c, ellipsoid as d, face as f, offsetFace as g, line as h, bsplineApprox as i, healSolid as j, heal as k, ellipse as l, helix as m, bezier as n, compound as o, filledFace as p, box as r, cone as s, addHoles as t, ellipseArc as u, sewShells as v, torus as w, subFace as x, solid as y, wiresOfFace as z };