brepjs 18.119.2 → 18.119.3

package/dist/primitiveFns-Cxo3xDKY.js

@@ -0,0 +1,558 @@
+import { K as getKernel, W as _usingCtx, d as createSolid, n as castResultShape } from "./shapeTypes-t49f64Dx.js";
+import { E as ok, d as validationError, g as err, m as andThen, t as BrepErrorCode } from "./errors-MHLiNE-C.js";
+import { n as isClosedWire } from "./validityTypes-DiTgeCD9.js";
+import { n as HASH_CODE_MAX, t as DEG2RAD } from "./constants-ITRzCnCp.js";
+import { C as propagateAllMetadata, S as hasAnyMetadata, T as propagateMetadataThroughRelocation, 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, w as propagateMetadataByHash, x as collectInputFaceHashes } from "./solidBuilders-DTgqQC3W.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-BryY-i0F.js";
+//#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 = collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = getKernel().translateWithHistory(shape.wrapped, v[0], v[1], v[2], inputFaceHashes, HASH_CODE_MAX);
+	const result = castResultShape(resultShape);
+	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 = collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = getKernel().rotateWithHistory(shape.wrapped, angle * DEG2RAD, inputFaceHashes, HASH_CODE_MAX, direction, position);
+	const result = castResultShape(resultShape);
+	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 = collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = getKernel().mirrorWithHistory(shape.wrapped, planeOrigin, planeNormal, inputFaceHashes, HASH_CODE_MAX);
+	const result = castResultShape(resultShape);
+	propagateAllMetadata(evolution, [shape], result);
+	return result;
+}
+/** Scale a shape uniformly. Returns a new shape. */
+function scale(shape, factor, center = [
+	0,
+	0,
+	0
+]) {
+	const inputFaceHashes = collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = getKernel().scaleWithHistory(shape.wrapped, center, factor, inputFaceHashes, HASH_CODE_MAX);
+	const result = castResultShape(resultShape);
+	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 = 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 err(validationError(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 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 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 err(validationError(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 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 err(validationError(BrepErrorCode.VALIDATION_FAILED, "applyMatrix: singular matrix (determinant ≈ 0). Cannot apply a non-invertible transform."));
+	if (isOrthogonalMatrix(linear)) {
+		const inputFaceHashes = collectInputFaceHashes([shape]);
+		const { shape: resultShape, evolution } = getKernel().generalTransformWithHistory(shape.wrapped, linear, translation, true, inputFaceHashes, HASH_CODE_MAX);
+		const result = castResultShape(resultShape);
+		propagateAllMetadata(evolution, [shape], result);
+		return ok(result);
+	}
+	const result = castResultShape(getKernel().generalTransformNonOrthogonal(shape.wrapped, linear, translation));
+	propagateMetadataByHash([shape], result);
+	return 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 } = 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 = castResultShape(getKernel().locate(shape.wrapped, trsf));
+	} finally {
+		cleanup();
+	}
+	if (hasAnyMetadata(shape)) 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 = collectInputFaceHashes([shape]);
+	const { shape: resultShape, evolution } = getKernel().applyComposedTransformWithHistory(shape.wrapped, composed.trsf, inputFaceHashes, HASH_CODE_MAX);
+	const result = castResultShape(resultShape);
+	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 = createSolid(getKernel().makeBox(width, depth, height));
+	const center = options?.at ?? (options?.centered ? [
+		0,
+		0,
+		0
+	] : void 0);
+	if (center) try {
+		var _usingCtx$1 = _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 = makeCylinder(radius, height, at, axis);
+	if (options?.centered) try {
+		var _usingCtx3 = _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 = makeSphere(radius);
+	if (options?.at) try {
+		var _usingCtx4 = _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 = makeCone(bottomRadius, topRadius, height, at, axis);
+	if (options?.centered) try {
+		var _usingCtx5 = _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 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 = makeEllipsoid(rx, ry, rz);
+	if (options?.at) try {
+		var _usingCtx6 = _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 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 { locate as A, threePointArc as C, wireLoop as D, wire as E, transformCopy as F, translate as I, resize as M, rotate as N, applyMatrix as O, scale as P, tangentArc as S, vertex as T, 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, mirror as j, composeTransforms 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 };

package/dist/projection.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_cameraFns = require("./cameraFns-Czr5vABD.cjs");
+const require_cameraFns = require("./cameraFns-2-haLzLi.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-D9tdBYLM.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-CG_J66Hl.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-Cu4ag5bh.cjs");
-const require_cornerFinder = require("./cornerFinder-DETRDOMz.cjs");
+const require_helpers = require("./helpers-BfkBvokP.cjs");
+const require_cornerFinder = require("./cornerFinder-mfsUMi5g.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-BiN4qQZP.js";
-import { t as cornerFinder } from "./cornerFinder-Cqg-Dz74.js";
+import { n as edgeFinder, r as faceFinder, t as getSingleFace } from "./helpers-Du_OdHuy.js";
+import { t as cornerFinder } from "./cornerFinder-CPFM7bA0.js";
 export { cornerFinder, edgeFinder, faceFinder, getSingleFace };

package/dist/{refResolveFns-3bw9-U-e.js → refResolveFns-BbRLD8LA.js}

@@ -1,9 +1,9 @@
-import { g as disposeTransientSubShape, it as getKernel, o as castShapeWithKnownType } from "./shapeTypes-CnKFSfDT.js";
-import { C as vertexPosition, c as getFaces } from "./topologyQueryFns-DNqT88yx.js";
-import { i as faceGeomType, l as normalAt, r as faceCenter } from "./faceFns-CB6uzvOg.js";
-import { n as getHashCode } from "./shapeFns-BrHFNLMA.js";
-import { n as measureArea, s as measureLength } from "./measureFns-CC7HhAH3.js";
-import { a as facesOfVertex, c as verticesOfFace, i as facesOfEdge, o as sharedEdges, s as verticesOfEdge, t as adjacentFaceHashes } from "./adjacencyFns-BdM5p58J.js";
+import { K as getKernel, g as disposeTransientSubShape, o as castShapeWithKnownType } from "./shapeTypes-t49f64Dx.js";
+import { C as vertexPosition, c as getFaces } from "./topologyQueryFns-BkQ6Q7gN.js";
+import { i as faceGeomType, l as normalAt, r as faceCenter } from "./faceFns-DJj9Nb6T.js";
+import { n as getHashCode } from "./shapeFns-BTFx-os7.js";
+import { n as measureArea, s as measureLength } from "./measureFns-CMnbcUZC.js";
+import { a as facesOfVertex, c as verticesOfFace, i as facesOfEdge, o as sharedEdges, s as verticesOfEdge, t as adjacentFaceHashes } from "./adjacencyFns-DLityMyV.js";
 //#region src/topology/shapeRef/scoring.ts
 /**
 * Default face scorer combining surface type, normal alignment, centroid proximity,

package/dist/{refResolveFns-BxmgIhQM.cjs → refResolveFns-CVDLwh12.cjs}

@@ -1,9 +1,9 @@
-const require_shapeTypes = require("./shapeTypes-Bpsu5KJO.cjs");
-const require_topologyQueryFns = require("./topologyQueryFns-C3fhJndG.cjs");
-const require_faceFns = require("./faceFns-CPswi9Cm.cjs");
-const require_shapeFns = require("./shapeFns-qm9VRo4i.cjs");
-const require_measureFns = require("./measureFns-B5Zzg1qM.cjs");
-const require_adjacencyFns = require("./adjacencyFns-Brrc7jlS.cjs");
+const require_shapeTypes = require("./shapeTypes-CkcIL7zv.cjs");
+const require_topologyQueryFns = require("./topologyQueryFns-Bia7o8l_.cjs");
+const require_faceFns = require("./faceFns-BK4r7Dxk.cjs");
+const require_shapeFns = require("./shapeFns-D_5TgiUi.cjs");
+const require_measureFns = require("./measureFns-CJGrmhHT.cjs");
+const require_adjacencyFns = require("./adjacencyFns-DSxuQYnb.cjs");
 //#region src/topology/shapeRef/scoring.ts
 /**
 * Default face scorer combining surface type, normal alignment, centroid proximity,

package/dist/result.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_bug = require("./bug-O02CsAmt.cjs");
-const require_errors = require("./errors-CJU8CHng.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
 exports.BrepBugError = require_bug.BrepBugError;
 exports.BrepErrorCode = require_errors.BrepErrorCode;
 exports.OK = require_errors.OK;

package/dist/result.js

@@ -1,3 +1,3 @@
 import { n as bug, t as BrepBugError } from "./bug-BdOHwn_e.js";
-import { C as isOk, D as match, E as mapErr, F as tryCatchAsync, I as unwrap, L as unwrapErr, O as ok, P as tryCatch, R as unwrapOr, S as isErr, _ as collect, a as moduleInitError, c as sketcherStateError, d as validationError, g as andThen, i as kernelError, j as pipeline, l as typeCastError, m as OK, n as computationError, o as queryError, r as ioError, t as BrepErrorCode, v as err, w as map, y as flatMap, z as unwrapOrElse } from "./errors-B3CDG537.js";
+import { E as ok, F as unwrapErr, I as unwrapOr, L as unwrapOrElse, M as tryCatch, N as tryCatchAsync, P as unwrap, S as map, T as match, _ as flatMap, a as moduleInitError, b as isErr, c as sketcherStateError, d as validationError, f as OK, g as err, h as collect, i as kernelError, k as pipeline, l as typeCastError, m as andThen, n as computationError, o as queryError, r as ioError, t as BrepErrorCode, w as mapErr, x as isOk } from "./errors-MHLiNE-C.js";
 export { BrepBugError, BrepErrorCode, OK, andThen, bug, collect, computationError, err, flatMap, ioError, isErr, isOk, kernelError, map, mapErr, match, moduleInitError, ok, pipeline, queryError, sketcherStateError, tryCatch, tryCatchAsync, typeCastError, unwrap, unwrapErr, unwrapOr, unwrapOrElse, validationError };

package/dist/rolldown-runtime-DakpK96I.cjs

@@ -0,0 +1,43 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});