brepjs 12.7.3 → 12.8.1

package/dist/{loft-DR1UN5uN.cjs → loft-hp3pc1M7.cjs}

@@ -34,8 +34,8 @@ var __callDispose = (stack, error, hasError) => {
   var next = (it) => {
     while (it = stack.pop()) {
       try {
-        var result = it[1] && it[1].call(it[2]);
-        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+        var result2 = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result2).then(next, (e) => (fail(e), next()));
       } catch (e) {
         fail(e);
       }
@@ -47,18 +47,18 @@ var __callDispose = (stack, error, hasError) => {
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
 const types = require("./types-CA_xrgDq.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const faceFns = require("./faceFns-BLTEPBKq.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
-const surfaceBuilders = require("./surfaceBuilders-Be_ENWSA.cjs");
-const solidBuilders = require("./solidBuilders-BzfRBizW.cjs");
+const faceFns = require("./faceFns-DB1Fc5gy.cjs");
+const result = require("./result-fAX0OZzI.cjs");
+const surfaceBuilders = require("./surfaceBuilders-5VA34a3_.cjs");
+const solidBuilders = require("./solidBuilders-994_MQwB.cjs");
 function buildLawFromProfile(extrusionLength, { profile, endFactor = 1 }) {
   if (profile !== "s-curve" && profile !== "linear") {
-    return errors.err(
-      errors.validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
+    return result.err(
+      result.validationError("UNSUPPORTED_PROFILE", `Unsupported extrusion profile: ${String(profile)}`)
     );
   }
   const law = shapeTypes.getKernel().buildExtrusionLaw(profile, extrusionLength, endFactor);
-  return errors.ok(law.Trim(0, extrusionLength, 1e-6));
+  return result.ok(law.Trim(0, extrusionLength, 1e-6));
 }
 const basicFaceExtrusion = (face, extrusionVec) => {
   const kernel = shapeTypes.getKernel();
@@ -66,7 +66,7 @@ const basicFaceExtrusion = (face, extrusionVec) => {
   const len = vecOps.vecLength(vec);
   const dir = len > 0 ? [vec[0] / len, vec[1] / len, vec[2] / len] : [0, 0, 1];
   const shape = kernel.extrude(face.wrapped, dir, len);
-  const solid = shapeTypes.createSolid(errors.unwrap(faceFns.downcast(shape)));
+  const solid = shapeTypes.createSolid(result.unwrap(faceFns.downcast(shape)));
   return solid;
 };
 const revolution = (face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) => {
@@ -79,12 +79,12 @@ const revolution = (face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360
     [...directionVec],
     angle * vecOps.DEG2RAD
   );
-  const result = errors.andThen(faceFns.cast(revolShape), (shape) => {
+  const result$1 = result.andThen(faceFns.cast(revolShape), (shape) => {
     if (!faceFns.isShape3D(shape))
-      return errors.err(errors.typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
-    return errors.ok(shape);
+      return result.err(result.typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
+    return result.ok(shape);
   });
-  return result;
+  return result$1;
 };
 function genericSweep(wire, spine, {
   frenet = false,
@@ -104,16 +104,16 @@ function genericSweep(wire, spine, {
   if (sweepMode === "simple" && !shellMode) {
     const kernel2 = shapeTypes.getKernel();
     const resultOc = kernel2.simplePipe(wire.wrapped, spine.wrapped);
-    const result2 = errors.andThen(faceFns.cast(resultOc), (shape2) => {
+    const result2 = result.andThen(faceFns.cast(resultOc), (shape2) => {
       if (!faceFns.isShape3D(shape2))
-        return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Simple pipe did not produce a 3D shape"));
-      return errors.ok(shape2);
+        return result.err(result.typeCastError("SWEEP_NOT_3D", "Simple pipe did not produce a 3D shape"));
+      return result.ok(shape2);
     });
     return result2;
   }
   const kernel = shapeTypes.getKernel();
   const withCorrection = transitionMode === "round" ? true : !!forceProfileSpineOthogonality;
-  const result = kernel.sweepPipeShell(wire.wrapped, spine.wrapped, {
+  const result$1 = kernel.sweepPipeShell(wire.wrapped, spine.wrapped, {
     transitionMode,
     contact: !!withContact,
     correction: withCorrection,
@@ -128,26 +128,26 @@ function genericSweep(wire, spine, {
     maxDegree,
     maxSegments
   });
-  if (shellMode && typeof result === "object" && "firstShape" in result) {
-    const shape2 = errors.unwrap(faceFns.cast(result.shape));
+  if (shellMode && typeof result$1 === "object" && "firstShape" in result$1) {
+    const shape2 = result.unwrap(faceFns.cast(result$1.shape));
     if (!faceFns.isShape3D(shape2)) {
-      return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
+      return result.err(result.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
     }
-    const startWire = errors.unwrap(faceFns.cast(result.firstShape));
-    const endWire = errors.unwrap(faceFns.cast(result.lastShape));
+    const startWire = result.unwrap(faceFns.cast(result$1.firstShape));
+    const endWire = result.unwrap(faceFns.cast(result$1.lastShape));
     if (!faceFns.isWire(startWire)) {
-      return errors.err(errors.typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
+      return result.err(result.typeCastError("SWEEP_START_NOT_WIRE", "Sweep did not produce a start Wire"));
     }
     if (!faceFns.isWire(endWire)) {
-      return errors.err(errors.typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
+      return result.err(result.typeCastError("SWEEP_END_NOT_WIRE", "Sweep did not produce an end Wire"));
     }
-    return errors.ok([shape2, startWire, endWire]);
+    return result.ok([shape2, startWire, endWire]);
   }
-  const shape = errors.unwrap(faceFns.cast(result));
+  const shape = result.unwrap(faceFns.cast(result$1));
   if (!faceFns.isShape3D(shape)) {
-    return errors.err(errors.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
+    return result.err(result.typeCastError("SWEEP_NOT_3D", "Sweep did not produce a 3D shape"));
   }
-  return errors.ok(shape);
+  return result.ok(shape);
 }
 function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
   var _stack = [];
@@ -157,10 +157,10 @@ function complexExtrude(wire, center, normal, profileShape, shellMode = false) {
     const normalVec = types.toVec3(normal);
     const endVec = vecOps.vecAdd(centerVec, normalVec);
     const mainSpineEdge = scope.register(surfaceBuilders.makeLine(centerVec, endVec));
-    const spine = scope.register(errors.unwrap(surfaceBuilders.assembleWire([mainSpineEdge])));
-    const law = profileShape ? scope.register(errors.unwrap(buildLawFromProfile(vecOps.vecLength(normalVec), profileShape))) : null;
-    const result = shellMode ? genericSweep(wire, spine, { law }, shellMode) : genericSweep(wire, spine, { law });
-    return result;
+    const spine = scope.register(result.unwrap(surfaceBuilders.assembleWire([mainSpineEdge])));
+    const law = profileShape ? scope.register(result.unwrap(buildLawFromProfile(vecOps.vecLength(normalVec), profileShape))) : null;
+    const result$1 = shellMode ? genericSweep(wire, spine, { law }, shellMode) : genericSweep(wire, spine, { law });
+    return result$1;
   } catch (_) {
     var _error = _, _hasError = true;
   } finally {
@@ -175,16 +175,16 @@ function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMod
     const normalVec = types.toVec3(normal);
     const endVec = vecOps.vecAdd(centerVec, normalVec);
     const mainSpineEdge = scope.register(surfaceBuilders.makeLine(centerVec, endVec));
-    const spine = scope.register(errors.unwrap(surfaceBuilders.assembleWire([mainSpineEdge])));
+    const spine = scope.register(result.unwrap(surfaceBuilders.assembleWire([mainSpineEdge])));
     const extrusionLength = vecOps.vecLength(normalVec);
     const pitch = 360 / angleDegrees * extrusionLength;
     const radius = 1;
     const auxiliarySpine = scope.register(
       surfaceBuilders.makeHelix(pitch, extrusionLength, radius, centerVec, normalVec)
     );
-    const law = profileShape ? scope.register(errors.unwrap(buildLawFromProfile(extrusionLength, profileShape))) : null;
-    const result = shellMode ? genericSweep(wire, spine, { auxiliarySpine, law }, shellMode) : genericSweep(wire, spine, { auxiliarySpine, law });
-    return result;
+    const law = profileShape ? scope.register(result.unwrap(buildLawFromProfile(extrusionLength, profileShape))) : null;
+    const result$1 = shellMode ? genericSweep(wire, spine, { auxiliarySpine, law }, shellMode) : genericSweep(wire, spine, { auxiliarySpine, law });
+    return result$1;
   } catch (_) {
     var _error = _, _hasError = true;
   } finally {
@@ -193,7 +193,7 @@ function twistExtrude(wire, angleDegrees, center, normal, profileShape, shellMod
 }
 const loft = (wires, { ruled = true, startPoint, endPoint } = {}, returnShell = false) => {
   if (wires.length === 0 && !startPoint && !endPoint) {
-    return errors.err(errors.validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
+    return result.err(result.validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
   }
   const kernel = shapeTypes.getKernel();
   const startVertex = startPoint ? solidBuilders.makeVertex(types.toVec3(startPoint)).wrapped : void 0;
@@ -208,14 +208,14 @@ const loft = (wires, { ruled = true, startPoint, endPoint } = {}, returnShell =
         ...endVertex ? { endVertex } : {}
       }
     );
-    const result = errors.andThen(faceFns.cast(shape), (s) => {
+    const result$1 = result.andThen(faceFns.cast(shape), (s) => {
       if (!faceFns.isShape3D(s))
-        return errors.err(errors.typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
-      return errors.ok(s);
+        return result.err(result.typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
+      return result.ok(s);
     });
-    return result;
+    return result$1;
   } catch {
-    return errors.err(errors.kernelError("LOFT_FAILED", "Loft operation failed"));
+    return result.err(result.kernelError("LOFT_FAILED", "Loft operation failed"));
   }
 };
 exports.basicFaceExtrusion = basicFaceExtrusion;

package/dist/{measurement-DoYXRaKI.cjs → measurement-BoNTUBAp.cjs}

@@ -1,6 +1,6 @@
 "use strict";
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const faceFns = require("./faceFns-BLTEPBKq.cjs");
+const faceFns = require("./faceFns-DB1Fc5gy.cjs");
 let cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {
   return cache.get(shape)?.get(key);

package/dist/{measurement-oWvhSVZG.js → measurement-D8EJ694A.js}

@@ -1,5 +1,5 @@
 import { B as getKernel } from "./shapeTypes-CpSaBLDv.js";
-import { u as uvBounds } from "./faceFns-B6ebRh5I.js";
+import { u as uvBounds } from "./faceFns-B8GnxjdY.js";
 let cache = /* @__PURE__ */ new WeakMap();
 function getCachedMeasurement(shape, key) {
   return cache.get(shape)?.get(key);

package/dist/measurement.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const measurement = require("./measurement-DoYXRaKI.cjs");
+const measurement = require("./measurement-BoNTUBAp.cjs");
 exports.createDistanceQuery = measurement.createDistanceQuery;
 exports.measureArea = measurement.measureArea;
 exports.measureDistance = measurement.measureDistance;

package/dist/measurement.js

@@ -1,4 +1,4 @@
-import { d, m, g, h, i, a, c, b } from "./measurement-oWvhSVZG.js";
+import { d, m, g, h, i, a, c, b } from "./measurement-D8EJ694A.js";
 export {
   d as createDistanceQuery,
   m as measureArea,

package/dist/{meshFns-3gy0empP.cjs → meshFns-BnV0ZR8w.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const errors = require("./errors-9fDehDNc.cjs");
-const shapeFns = require("./shapeFns-D-MOoqJd.cjs");
+const result = require("./result-fAX0OZzI.cjs");
+const shapeFns = require("./shapeFns-C2SnNvdH.cjs");
 function buildMeshCacheKey(tolerance, angularTolerance, skipNormals, includeUVs = false) {
   return `${tolerance}:${angularTolerance}:${skipNormals}:${includeUVs}`;
 }
@@ -86,7 +86,7 @@ function mesh(shape, {
     const cached = getMeshForShape(shape.wrapped, cacheKey);
     if (cached) return cached;
   }
-  const result = shapeTypes.getKernel().mesh(shape.wrapped, {
+  const result2 = shapeTypes.getKernel().mesh(shape.wrapped, {
     tolerance,
     angularTolerance,
     skipNormals,
@@ -95,11 +95,11 @@ function mesh(shape, {
   });
   const origins = shapeFns.getFaceOrigins(shape);
   const mesh2 = {
-    vertices: result.vertices,
-    normals: result.normals,
-    triangles: result.triangles,
-    uvs: result.uvs,
-    faceGroups: result.faceGroups.map((g) => ({
+    vertices: result2.vertices,
+    normals: result2.normals,
+    triangles: result2.triangles,
+    uvs: result2.uvs,
+    faceGroups: result2.faceGroups.map((g) => ({
       start: g.start,
       count: g.count,
       faceId: g.faceHash,
@@ -118,7 +118,7 @@ function meshEdges(shape, { tolerance = 1e-3, angularTolerance = 0.1, cache = tr
     if (cached) return cached;
   }
   const kernelResult = shapeTypes.getKernel().meshEdges(shape.wrapped, tolerance, angularTolerance);
-  const result = {
+  const result2 = {
     lines: kernelResult.lines,
     edgeGroups: kernelResult.edgeGroups.map((g) => ({
       start: g.start,
@@ -127,19 +127,19 @@ function meshEdges(shape, { tolerance = 1e-3, angularTolerance = 0.1, cache = tr
     }))
   };
   if (cache) {
-    setEdgeMeshForShape(shape.wrapped, cacheKey, result);
+    setEdgeMeshForShape(shape.wrapped, cacheKey, result2);
   }
-  return result;
+  return result2;
 }
 function exportSTEP(shape) {
   try {
     const stepString = shapeTypes.getKernel().exportSTEP([shape.wrapped]);
-    return errors.ok(new Blob([stepString], { type: "application/STEP" }));
+    return result.ok(new Blob([stepString], { type: "application/STEP" }));
   } catch (e) {
     const isWriteFailure = e instanceof Error && e.message.startsWith("STEP export failed");
     const code = isWriteFailure ? "STEP_EXPORT_FAILED" : "STEP_FILE_READ_ERROR";
     const msg = isWriteFailure ? "Failed to write STEP file" : "Failed to read exported STEP file";
-    return errors.err(errors.ioError(code, msg, e));
+    return result.err(result.ioError(code, msg, e));
   }
 }
 function exportSTL(shape, {
@@ -152,20 +152,20 @@ function exportSTL(shape, {
       shapeTypes.getKernel().meshShape(shape.wrapped, tolerance, angularTolerance);
     }
     const stlData = shapeTypes.getKernel().exportSTL(shape.wrapped, binary);
-    return errors.ok(new Blob([stlData], { type: "application/sla" }));
+    return result.ok(new Blob([stlData], { type: "application/sla" }));
   } catch (e) {
     const isWriteFailure = e instanceof Error && e.message.startsWith("STL export failed");
     const code = isWriteFailure ? "STL_EXPORT_FAILED" : "STL_FILE_READ_ERROR";
     const msg = isWriteFailure ? "Failed to write STL file" : "Failed to read exported STL file";
-    return errors.err(errors.ioError(code, msg, e));
+    return result.err(result.ioError(code, msg, e));
   }
 }
 function exportIGES(shape) {
   try {
     const igesString = shapeTypes.getKernel().exportIGES([shape.wrapped]);
-    return errors.ok(new Blob([igesString], { type: "application/iges" }));
+    return result.ok(new Blob([igesString], { type: "application/iges" }));
   } catch (e) {
-    return errors.err(errors.ioError("IGES_EXPORT_FAILED", "Failed to write IGES file", e));
+    return result.err(result.ioError("IGES_EXPORT_FAILED", "Failed to write IGES file", e));
   }
 }
 exports.clearMeshCache = clearMeshCache;

package/dist/{meshFns-DsLRd3tA.js → meshFns-nQjK38EC.js}

@@ -1,6 +1,6 @@
 import { B as getKernel } from "./shapeTypes-CpSaBLDv.js";
-import { o as ok, e as err, i as ioError } from "./errors-B7kgv0cd.js";
-import { g as getFaceOrigins } from "./shapeFns-D2PlLFE6.js";
+import { o as ok, e as err, i as ioError } from "./result-BaSD1fqR.js";
+import { g as getFaceOrigins } from "./shapeFns-FDuKkrDR.js";
 function buildMeshCacheKey(tolerance, angularTolerance, skipNormals, includeUVs = false) {
   return `${tolerance}:${angularTolerance}:${skipNormals}:${includeUVs}`;
 }

package/dist/{operations-Dcz6YlOt.js → operations-BfbkK6DU.js}

@@ -1,10 +1,10 @@
 import { B as getKernel, d as createKernelHandle, c as castShape, p as isShape3D, u as isWire, F as createSolid } from "./shapeTypes-CpSaBLDv.js";
 import { g as vecLength, v as vecAdd, j as vecNormalize, f as vecIsZero } from "./vecOps-ZDdZWbwT.js";
-import { e as err, y as validationError, r as unwrap, p as typeCastError, o as ok, B as BrepErrorCode, k as kernelError, i as ioError, b as computationError } from "./errors-B7kgv0cd.js";
-import { a as buildLawFromProfile } from "./loft-BcZUCGKi.js";
-import { j as fuseAll } from "./booleanFns-CcNUsgI8.js";
-import { t as toBREP } from "./shapeFns-D2PlLFE6.js";
-import { j as fromBREP } from "./faceFns-B6ebRh5I.js";
+import { e as err, z as validationError, v as unwrap, r as typeCastError, o as ok, A as BrepErrorCode, k as kernelError, i as ioError, d as computationError } from "./result-BaSD1fqR.js";
+import { a as buildLawFromProfile } from "./loft-Bhw-FMoL.js";
+import { j as fuseAll } from "./booleanFns-BCTjYZAg.js";
+import { t as toBREP } from "./shapeFns-FDuKkrDR.js";
+import { j as fromBREP } from "./faceFns-B8GnxjdY.js";
 function uuidv() {
   return (String([1e7]) + String(-1e3) + String(-4e3) + String(-8e3) + String(-1e11)).replace(
     /[018]/g,