brepjs 18.119.2 → 18.119.4

package/dist/primitiveFns-B_rflH83.cjs

@@ -0,0 +1,773 @@
+const require_shapeTypes = require("./shapeTypes-CkcIL7zv.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
+const require_validityTypes = require("./validityTypes-ZGMVlv7b.cjs");
+const require_constants = require("./constants-BOVyEYGH.cjs");
+const require_solidBuilders = require("./solidBuilders-IiIzjKAr.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-Biqx51el.cjs");
+//#region src/topology/transformFns.ts
+/**
+* Immutable shape transforms — translate, rotate, scale, mirror, applyMatrix.
+* All functions return new shapes without disposing inputs.
+*/
+/** Translate a shape by a vector. Returns a new shape. */
+function translate(shape, v) {
+	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().translateWithHistory(shape.wrapped, v[0], v[1], v[2], inputFaceHashes, require_constants.HASH_CODE_MAX);
+	const result = require_shapeTypes.castResultShape(resultShape);
+	require_solidBuilders.propagateAllMetadata(evolution, [shape], result);
+	return result;
+}
+/** Rotate a shape around an axis. Angle is in degrees. Returns a new shape. */
+function rotate(shape, angle, position = [
+	0,
+	0,
+	0
+], direction = [
+	0,
+	0,
+	1
+]) {
+	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().rotateWithHistory(shape.wrapped, angle * require_constants.DEG2RAD, inputFaceHashes, require_constants.HASH_CODE_MAX, direction, position);
+	const result = require_shapeTypes.castResultShape(resultShape);
+	require_solidBuilders.propagateAllMetadata(evolution, [shape], result);
+	return result;
+}
+/** Mirror a shape through a plane defined by origin and normal. Returns a new shape. */
+function mirror(shape, planeNormal = [
+	0,
+	1,
+	0
+], planeOrigin = [
+	0,
+	0,
+	0
+]) {
+	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().mirrorWithHistory(shape.wrapped, planeOrigin, planeNormal, inputFaceHashes, require_constants.HASH_CODE_MAX);
+	const result = require_shapeTypes.castResultShape(resultShape);
+	require_solidBuilders.propagateAllMetadata(evolution, [shape], result);
+	return result;
+}
+/** Scale a shape uniformly. Returns a new shape. */
+function scale(shape, factor, center = [
+	0,
+	0,
+	0
+]) {
+	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().scaleWithHistory(shape.wrapped, center, factor, inputFaceHashes, require_constants.HASH_CODE_MAX);
+	const result = require_shapeTypes.castResultShape(resultShape);
+	require_solidBuilders.propagateAllMetadata(evolution, [shape], result);
+	return result;
+}
+/** Resize a shape to exact target dimensions with optional auto-proportional scaling. */
+function resize(shape, dimensions, options) {
+	const bbox = require_shapeTypes.getKernel().boundingBox(shape.wrapped);
+	const size = [
+		bbox.max[0] - bbox.min[0],
+		bbox.max[1] - bbox.min[1],
+		bbox.max[2] - bbox.min[2]
+	];
+	const auto = options?.auto === true;
+	function factor(dim, sz, baseFactor) {
+		if (dim !== void 0 && sz > 1e-12) return dim / sz;
+		if (dim === void 0 && auto) return baseFactor;
+		return 1;
+	}
+	let autoFactor = 1;
+	if (auto) {
+		if (dimensions[0] !== void 0 && size[0] > 1e-12) autoFactor = dimensions[0] / size[0];
+		else if (dimensions[1] !== void 0 && size[1] > 1e-12) autoFactor = dimensions[1] / size[1];
+		else if (dimensions[2] !== void 0 && size[2] > 1e-12) autoFactor = dimensions[2] / size[2];
+	}
+	const factors = [
+		factor(dimensions[0], size[0], autoFactor),
+		factor(dimensions[1], size[1], autoFactor),
+		factor(dimensions[2], size[2], autoFactor)
+	];
+	if (!(Math.abs(factors[0] - factors[1]) < 1e-6 && Math.abs(factors[1] - factors[2]) < 1e-6)) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.VALIDATION_FAILED, "resize: non-uniform scaling is not supported (WASM build lacks BRepBuilderAPI_GTransform).", void 0, void 0, "Use auto: true to scale proportionally, or set all three dimensions to achieve uniform scaling."));
+	return require_errors.ok(scale(shape, factors[0]));
+}
+/**
+* Parse a MatrixInput into a 3x3 linear part and translation vector.
+* Validates the bottom row of a Matrix4x4.
+*/
+function parseMatrixInput(input) {
+	if ("linear" in input) return require_errors.ok({
+		linear: input.linear,
+		translation: input.translation
+	});
+	const [r0, r1, r2, r3] = input;
+	const TOL = 1e-10;
+	if (Math.abs(r3[0]) > TOL || Math.abs(r3[1]) > TOL || Math.abs(r3[2]) > TOL || Math.abs(r3[3] - 1) > TOL) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.VALIDATION_FAILED, `applyMatrix: invalid bottom row [${String(r3[0])}, ${String(r3[1])}, ${String(r3[2])}, ${String(r3[3])}]. Must be [0, 0, 0, 1] for an affine transform.`));
+	return require_errors.ok({
+		linear: [
+			r0[0],
+			r0[1],
+			r0[2],
+			r1[0],
+			r1[1],
+			r1[2],
+			r2[0],
+			r2[1],
+			r2[2]
+		],
+		translation: [
+			r0[3],
+			r1[3],
+			r2[3]
+		]
+	});
+}
+/** Determinant of a 3x3 matrix given as 9 row-major values. */
+function det3x3(m) {
+	return m[0] * (m[4] * m[8] - m[5] * m[7]) - m[1] * (m[3] * m[8] - m[5] * m[6]) + m[2] * (m[3] * m[7] - m[4] * m[6]);
+}
+/**
+* Check if a 3x3 matrix is orthogonal (possibly with uniform scale).
+* M is orthogonal-with-scale if M^T * M = s^2 * I for some scalar s.
+*/
+function isOrthogonalMatrix(m) {
+	const TOL = 1e-8;
+	const d00 = m[0] * m[0] + m[3] * m[3] + m[6] * m[6];
+	const d11 = m[1] * m[1] + m[4] * m[4] + m[7] * m[7];
+	const d22 = m[2] * m[2] + m[5] * m[5] + m[8] * m[8];
+	const d01 = m[0] * m[1] + m[3] * m[4] + m[6] * m[7];
+	const d02 = m[0] * m[2] + m[3] * m[5] + m[6] * m[8];
+	const d12 = m[1] * m[2] + m[4] * m[5] + m[7] * m[8];
+	if (Math.abs(d01) > TOL) return false;
+	if (Math.abs(d02) > TOL) return false;
+	if (Math.abs(d12) > TOL) return false;
+	if (Math.abs(d00 - d11) > TOL) return false;
+	if (Math.abs(d00 - d22) > TOL) return false;
+	return true;
+}
+/**
+* Apply a 4x4 affine transformation matrix to a shape.
+* Equivalent to OpenSCAD's `multmatrix`.
+*
+* Uses the fast `kernel transform` path for orthogonal matrices (rotation, uniform scale, mirror)
+* and the general `gp_GTrsf` path for non-orthogonal transforms (shear, non-uniform scale).
+*/
+function applyMatrix(shape, matrix) {
+	const parsed = parseMatrixInput(matrix);
+	if (!parsed.ok) return parsed;
+	const { linear, translation } = parsed.value;
+	const d = det3x3(linear);
+	if (Math.abs(d) < 1e-12) return require_errors.err(require_errors.validationError(require_errors.BrepErrorCode.VALIDATION_FAILED, "applyMatrix: singular matrix (determinant ≈ 0). Cannot apply a non-invertible transform."));
+	if (isOrthogonalMatrix(linear)) {
+		const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = require_shapeTypes.getKernel().generalTransformWithHistory(shape.wrapped, linear, translation, true, inputFaceHashes, require_constants.HASH_CODE_MAX);
+		const result = require_shapeTypes.castResultShape(resultShape);
+		require_solidBuilders.propagateAllMetadata(evolution, [shape], result);
+		return require_errors.ok(result);
+	}
+	const result = require_shapeTypes.castResultShape(require_shapeTypes.getKernel().generalTransformNonOrthogonal(shape.wrapped, linear, translation));
+	require_solidBuilders.propagateMetadataByHash([shape], result);
+	return require_errors.ok(result);
+	/* v8 ignore stop */
+}
+/**
+* Compose multiple translate/rotate operations into a single kernel transform.
+* Operations are applied in order (first element applied first).
+* Call `.cleanup()` on the result when done to free the kernel object.
+*/
+function composeTransforms(ops) {
+	const kernelOps = ops.map((op) => {
+		if (op.type === "translate") return {
+			type: "translate",
+			x: op.v[0],
+			y: op.v[1],
+			z: op.v[2]
+		};
+		return {
+			type: "rotate",
+			angle: op.angle,
+			axis: op.axis,
+			center: op.center
+		};
+	});
+	const { handle, dispose } = require_shapeTypes.getKernel().composeTransform(kernelOps);
+	return {
+		trsf: handle,
+		cleanup: dispose
+	};
+}
+/**
+* Placement-only rigid move (translate / rotate) via the kernel's cheap location
+* re-tag — an O(1) `TopLoc_Location` swap on occt-wasm ≥3.6.0, falling back to a
+* copying transform on kernels without it. Unlike `translate` / `rotate` (which
+* deep-copy through the history-tracking path), `locate` shares the source
+* geometry and only re-tags its placement, then re-keys face metadata
+* (tags/colors) onto the moved faces so it survives — the same metadata
+* guarantee `translate` gives, at location-swap cost. For per-position placement
+* of one cached cell (template instancing), this is the move without the copy.
+*
+* Accepts a single op or an ordered list (applied first-to-last, e.g. rotate
+* then translate). Non-rigid ops (`scale`) aren't a placement and don't belong
+* here — use `applyMatrix` for those.
+*/
+function locate(shape, placement) {
+	const { trsf, cleanup } = composeTransforms("type" in placement ? [placement] : placement);
+	let moved;
+	try {
+		moved = require_shapeTypes.castResultShape(require_shapeTypes.getKernel().locate(shape.wrapped, trsf));
+	} finally {
+		cleanup();
+	}
+	if (require_solidBuilders.hasAnyMetadata(shape)) require_solidBuilders.propagateMetadataThroughRelocation(shape, moved);
+	return moved;
+}
+/**
+* Clone a shape and apply a pre-composed transform in a single kernel operation.
+* Much faster than separate clone() + translate() + rotate() calls.
+*/
+function transformCopy(shape, composed) {
+	const inputFaceHashes = require_solidBuilders.collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = require_shapeTypes.getKernel().applyComposedTransformWithHistory(shape.wrapped, composed.trsf, inputFaceHashes, require_constants.HASH_CODE_MAX);
+	const result = require_shapeTypes.castResultShape(resultShape);
+	require_solidBuilders.propagateAllMetadata(evolution, [shape], result);
+	return result;
+}
+//#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 = require_shapeTypes.createSolid(require_shapeTypes.getKernel().makeBox(width, depth, height));
+	const center = options?.at ?? (options?.centered ? [
+		0,
+		0,
+		0
+	] : void 0);
+	if (center) try {
+		var _usingCtx$1 = require_shapeTypes._usingCtx();
+		return translate(_usingCtx$1.u(solid), [
+			center[0] - width / 2,
+			center[1] - depth / 2,
+			center[2] - height / 2
+		]);
+	} catch (_) {
+		_usingCtx$1.e = _;
+	} finally {
+		_usingCtx$1.d();
+	}
+	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
+	];
+	const solid = require_solidBuilders.makeCylinder(radius, height, at, axis);
+	if (options?.centered) try {
+		var _usingCtx3 = require_shapeTypes._usingCtx();
+		const halfShift = [
+			-axis[0] * height * .5,
+			-axis[1] * height * .5,
+			-axis[2] * height * .5
+		];
+		return translate(_usingCtx3.u(solid), halfShift);
+	} catch (_) {
+		_usingCtx3.e = _;
+	} finally {
+		_usingCtx3.d();
+	}
+	return solid;
+}
+/**
+* Create a sphere with the given radius.
+*/
+function sphere(radius, options) {
+	const solid = require_solidBuilders.makeSphere(radius);
+	if (options?.at) try {
+		var _usingCtx4 = require_shapeTypes._usingCtx();
+		return translate(_usingCtx4.u(solid), options.at);
+	} catch (_) {
+		_usingCtx4.e = _;
+	} finally {
+		_usingCtx4.d();
+	}
+	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
+	];
+	const solid = require_solidBuilders.makeCone(bottomRadius, topRadius, height, at, axis);
+	if (options?.centered) try {
+		var _usingCtx5 = require_shapeTypes._usingCtx();
+		const halfShift = [
+			-axis[0] * height * .5,
+			-axis[1] * height * .5,
+			-axis[2] * height * .5
+		];
+		return translate(_usingCtx5.u(solid), halfShift);
+	} catch (_) {
+		_usingCtx5.e = _;
+	} finally {
+		_usingCtx5.d();
+	}
+	return solid;
+}
+/**
+* Create a torus with the given major and minor radii.
+*/
+function torus(majorRadius, minorRadius, options) {
+	return require_solidBuilders.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) {
+	const solid = require_solidBuilders.makeEllipsoid(rx, ry, rz);
+	if (options?.at) try {
+		var _usingCtx6 = require_shapeTypes._usingCtx();
+		return translate(_usingCtx6.u(solid), options.at);
+	} catch (_) {
+		_usingCtx6.e = _;
+	} finally {
+		_usingCtx6.d();
+	}
+	return solid;
+}
+/** Create a straight edge between two 3D points. */
+function line(from, to) {
+	return require_surfaceBuilders.makeLine(from, to);
+}
+/** Create a circular edge with the given radius. */
+function circle(radius, options) {
+	const axisDir = options?.axis ?? [
+		0,
+		0,
+		1
+	];
+	return require_surfaceBuilders.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 require_surfaceBuilders.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 require_surfaceBuilders.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 require_surfaceBuilders.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 require_surfaceBuilders.makeEllipseArc(majorRadius, minorRadius, startAngle * require_constants.DEG2RAD, endAngle * require_constants.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 require_surfaceBuilders.makeBSplineApproximation(points, config);
+}
+/**
+* Create a Bezier curve edge from control points.
+*
+* @param points - Two or more control points.
+*/
+function bezier(points) {
+	return require_surfaceBuilders.makeBezierCurve(points);
+}
+/**
+* Create a circular arc edge tangent to a direction at the start point.
+*/
+function tangentArc(startPoint, startTgt, endPoint) {
+	return require_surfaceBuilders.makeTangentArc(startPoint, startTgt, endPoint);
+}
+/**
+* Assemble edges and/or wires into a single connected wire.
+*/
+function wire(listOfEdges) {
+	return require_surfaceBuilders.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 require_errors.andThen(require_surfaceBuilders.assembleWire(listOfEdges), (w) => {
+		if (require_validityTypes.isClosedWire(w)) return require_errors.ok(w);
+		return require_errors.err(require_errors.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 require_surfaceBuilders.makeFace(w, holes);
+}
+/**
+* Create a non-planar face from a wire using surface filling.
+* The resulting face is always oriented.
+*/
+function filledFace(w) {
+	return require_surfaceBuilders.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 require_surfaceBuilders.makeNewFaceWithinFace(originFace, w);
+}
+/**
+* Create a polygonal face from three or more coplanar points.
+* The resulting face is always oriented.
+*/
+function polygon(points) {
+	return require_surfaceBuilders.makePolygon(points);
+}
+/** Create a vertex at a 3D point. */
+function vertex(point) {
+	return require_solidBuilders.makeVertex(point);
+}
+/**
+* Build a compound from multiple shapes.
+*/
+function compound(shapeArray) {
+	return require_solidBuilders.makeCompound(shapeArray);
+}
+/**
+* Weld faces and shells into a single solid.
+* The resulting solid is always validated.
+*/
+function solid(facesOrShells) {
+	return require_solidBuilders.makeSolid(facesOrShells);
+}
+/**
+* Create an offset shape from a face.
+*/
+function offsetFace(f, distance, tolerance) {
+	return require_solidBuilders.makeOffset(f, distance, tolerance);
+}
+/**
+* Weld faces and shells into a single shell.
+*/
+function sewShells(facesOrShells, ignoreType) {
+	return require_solidBuilders.weldShellsAndFaces(facesOrShells, ignoreType);
+}
+function addHoles(f, holes) {
+	return require_surfaceBuilders.addHolesInFace(f, holes);
+}
+//#endregion
+Object.defineProperty(exports, "addHoles", {
+	enumerable: true,
+	get: function() {
+		return addHoles;
+	}
+});
+Object.defineProperty(exports, "applyMatrix", {
+	enumerable: true,
+	get: function() {
+		return applyMatrix;
+	}
+});
+Object.defineProperty(exports, "bezier", {
+	enumerable: true,
+	get: function() {
+		return bezier;
+	}
+});
+Object.defineProperty(exports, "box", {
+	enumerable: true,
+	get: function() {
+		return box;
+	}
+});
+Object.defineProperty(exports, "bsplineApprox", {
+	enumerable: true,
+	get: function() {
+		return bsplineApprox;
+	}
+});
+Object.defineProperty(exports, "circle", {
+	enumerable: true,
+	get: function() {
+		return circle;
+	}
+});
+Object.defineProperty(exports, "composeTransforms", {
+	enumerable: true,
+	get: function() {
+		return composeTransforms;
+	}
+});
+Object.defineProperty(exports, "compound", {
+	enumerable: true,
+	get: function() {
+		return compound;
+	}
+});
+Object.defineProperty(exports, "cone", {
+	enumerable: true,
+	get: function() {
+		return cone;
+	}
+});
+Object.defineProperty(exports, "cylinder", {
+	enumerable: true,
+	get: function() {
+		return cylinder;
+	}
+});
+Object.defineProperty(exports, "ellipse", {
+	enumerable: true,
+	get: function() {
+		return ellipse;
+	}
+});
+Object.defineProperty(exports, "ellipseArc", {
+	enumerable: true,
+	get: function() {
+		return ellipseArc;
+	}
+});
+Object.defineProperty(exports, "ellipsoid", {
+	enumerable: true,
+	get: function() {
+		return ellipsoid;
+	}
+});
+Object.defineProperty(exports, "face", {
+	enumerable: true,
+	get: function() {
+		return face;
+	}
+});
+Object.defineProperty(exports, "filledFace", {
+	enumerable: true,
+	get: function() {
+		return filledFace;
+	}
+});
+Object.defineProperty(exports, "helix", {
+	enumerable: true,
+	get: function() {
+		return helix;
+	}
+});
+Object.defineProperty(exports, "line", {
+	enumerable: true,
+	get: function() {
+		return line;
+	}
+});
+Object.defineProperty(exports, "locate", {
+	enumerable: true,
+	get: function() {
+		return locate;
+	}
+});
+Object.defineProperty(exports, "mirror", {
+	enumerable: true,
+	get: function() {
+		return mirror;
+	}
+});
+Object.defineProperty(exports, "offsetFace", {
+	enumerable: true,
+	get: function() {
+		return offsetFace;
+	}
+});
+Object.defineProperty(exports, "polygon", {
+	enumerable: true,
+	get: function() {
+		return polygon;
+	}
+});
+Object.defineProperty(exports, "resize", {
+	enumerable: true,
+	get: function() {
+		return resize;
+	}
+});
+Object.defineProperty(exports, "rotate", {
+	enumerable: true,
+	get: function() {
+		return rotate;
+	}
+});
+Object.defineProperty(exports, "scale", {
+	enumerable: true,
+	get: function() {
+		return scale;
+	}
+});
+Object.defineProperty(exports, "sewShells", {
+	enumerable: true,
+	get: function() {
+		return sewShells;
+	}
+});
+Object.defineProperty(exports, "solid", {
+	enumerable: true,
+	get: function() {
+		return solid;
+	}
+});
+Object.defineProperty(exports, "sphere", {
+	enumerable: true,
+	get: function() {
+		return sphere;
+	}
+});
+Object.defineProperty(exports, "subFace", {
+	enumerable: true,
+	get: function() {
+		return subFace;
+	}
+});
+Object.defineProperty(exports, "tangentArc", {
+	enumerable: true,
+	get: function() {
+		return tangentArc;
+	}
+});
+Object.defineProperty(exports, "threePointArc", {
+	enumerable: true,
+	get: function() {
+		return threePointArc;
+	}
+});
+Object.defineProperty(exports, "torus", {
+	enumerable: true,
+	get: function() {
+		return torus;
+	}
+});
+Object.defineProperty(exports, "transformCopy", {
+	enumerable: true,
+	get: function() {
+		return transformCopy;
+	}
+});
+Object.defineProperty(exports, "translate", {
+	enumerable: true,
+	get: function() {
+		return translate;
+	}
+});
+Object.defineProperty(exports, "vertex", {
+	enumerable: true,
+	get: function() {
+		return vertex;
+	}
+});
+Object.defineProperty(exports, "wire", {
+	enumerable: true,
+	get: function() {
+		return wire;
+	}
+});
+Object.defineProperty(exports, "wireLoop", {
+	enumerable: true,
+	get: function() {
+		return wireLoop;
+	}
+});