brepjs 8.8.2 → 8.8.3

package/dist/{boolean2D-q5FOdOQW.cjs → boolean2D-BQk8LNmZ.cjs}

@@ -1,16 +1,61 @@
 "use strict";
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    if (async) dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else if (async) {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        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);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
 const vectors = require("./vectors-CGLqemPY.cjs");
 const errors = require("./errors-NNmTtM5u.cjs");
-const faceFns = require("./faceFns-CxaLWOjc.cjs");
+const faceFns = require("./faceFns-DNQss51F.cjs");
 const occtBoundary = require("./occtBoundary-Cqfsau2c.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const loft = require("./loft-CVb-IjEI.cjs");
-const shapeTypes = require("./shapeTypes-CIijJxCz.cjs");
-const curveFns = require("./curveFns-6ovDM_sR.cjs");
-const surfaceBuilders = require("./surfaceBuilders-CC0ZQGix.cjs");
+const loft = require("./loft-CjEEqz2P.cjs");
+const shapeTypes = require("./shapeTypes-CWuX602K.cjs");
+const curveFns = require("./curveFns-BsAHC3Qv.cjs");
+const surfaceBuilders = require("./surfaceBuilders-CLal3WlK.cjs");
 const result = require("./result.cjs");
-const helpers = require("./helpers-CRfqaW0Y.cjs");
-const Blueprint = require("./Blueprint-BmbNUnGI.cjs");
+const helpers = require("./helpers-aylLv0_I.cjs");
+const Blueprint = require("./Blueprint-BmFJ4caY.cjs");
 function* pointsIteration(intersector) {
   const nPoints = intersector.NbPoints();
   if (!nPoints) return;
@@ -20,56 +65,77 @@ function* pointsIteration(intersector) {
   }
 }
 function* commonSegmentsIteration(intersector) {
-  const nSegments = intersector.NbSegments();
-  if (!nSegments) return;
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  for (let i = 1; i <= nSegments; i++) {
-    const h1 = new oc.Handle_Geom2d_Curve_1();
-    const h2 = r(new oc.Handle_Geom2d_Curve_1());
-    try {
-      intersector.Segment(i, h1, h2);
-    } catch {
-      continue;
+  var _stack = [];
+  try {
+    const nSegments = intersector.NbSegments();
+    if (!nSegments) return;
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    for (let i = 1; i <= nSegments; i++) {
+      const h1 = new oc.Handle_Geom2d_Curve_1();
+      const h2 = scope.register(new oc.Handle_Geom2d_Curve_1());
+      try {
+        intersector.Segment(i, h1, h2);
+      } catch {
+        continue;
+      }
+      yield new Blueprint.Curve2D(h1);
     }
-    yield new Blueprint.Curve2D(h1);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
   }
 }
 const intersectCurves = (first, second, precision = 1e-9) => {
-  if (first.boundingBox.isOut(second.boundingBox))
-    return errors.ok({ intersections: [], commonSegments: [], commonSegmentsPoints: [] });
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  const intersector = r(new oc.Geom2dAPI_InterCurveCurve_1());
-  let intersections;
-  let commonSegments;
+  var _stack = [];
   try {
-    intersector.Init_1(first.wrapped, second.wrapped, precision);
-    intersections = Array.from(pointsIteration(intersector));
-    commonSegments = Array.from(commonSegmentsIteration(intersector));
-  } catch (e) {
-    return errors.err(errors.computationError("INTERSECTION_FAILED", "Intersections failed between curves", e));
-  }
-  const segmentsAsPoints = commonSegments.filter((c) => helpers.samePoint(c.firstPoint, c.lastPoint, precision)).map((c) => c.firstPoint);
-  if (segmentsAsPoints.length) {
-    intersections.push(...segmentsAsPoints);
-    commonSegments = commonSegments.filter((c) => !helpers.samePoint(c.firstPoint, c.lastPoint, precision));
-  }
-  const commonSegmentsPoints = commonSegments.flatMap((c) => [c.firstPoint, c.lastPoint]);
-  return errors.ok({ intersections, commonSegments, commonSegmentsPoints });
+    if (first.boundingBox.isOut(second.boundingBox))
+      return errors.ok({ intersections: [], commonSegments: [], commonSegmentsPoints: [] });
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const intersector = scope.register(new oc.Geom2dAPI_InterCurveCurve_1());
+    let intersections;
+    let commonSegments;
+    try {
+      intersector.Init_1(first.wrapped, second.wrapped, precision);
+      intersections = Array.from(pointsIteration(intersector));
+      commonSegments = Array.from(commonSegmentsIteration(intersector));
+    } catch (e) {
+      return errors.err(errors.computationError("INTERSECTION_FAILED", "Intersections failed between curves", e));
+    }
+    const segmentsAsPoints = commonSegments.filter((c) => helpers.samePoint(c.firstPoint, c.lastPoint, precision)).map((c) => c.firstPoint);
+    if (segmentsAsPoints.length) {
+      intersections.push(...segmentsAsPoints);
+      commonSegments = commonSegments.filter((c) => !helpers.samePoint(c.firstPoint, c.lastPoint, precision));
+    }
+    const commonSegmentsPoints = commonSegments.flatMap((c) => [c.firstPoint, c.lastPoint]);
+    return errors.ok({ intersections, commonSegments, commonSegmentsPoints });
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 };
 const selfIntersections = (curve, precision = 1e-9) => {
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  const intersector = r(new oc.Geom2dAPI_InterCurveCurve_1());
-  let intersections;
+  var _stack = [];
   try {
-    intersector.Init_1(curve.wrapped, curve.wrapped, precision);
-    intersections = Array.from(pointsIteration(intersector));
-  } catch (e) {
-    return errors.err(errors.computationError("SELF_INTERSECTION_FAILED", "Self intersection failed", e));
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const intersector = scope.register(new oc.Geom2dAPI_InterCurveCurve_1());
+    let intersections;
+    try {
+      intersector.Init_1(curve.wrapped, curve.wrapped, precision);
+      intersections = Array.from(pointsIteration(intersector));
+    } catch (e) {
+      return errors.err(errors.computationError("SELF_INTERSECTION_FAILED", "Self intersection failed", e));
+    }
+    return errors.ok(intersections);
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
   }
-  return errors.ok(intersections);
 };
 const offsetEndPoints = (firstPoint, lastPoint, offset) => {
   const tangent = helpers.normalize2d(helpers.subtract2d(lastPoint, firstPoint));
@@ -81,58 +147,65 @@ const offsetEndPoints = (firstPoint, lastPoint, offset) => {
   };
 };
 const make2dOffset = (curve, offset) => {
-  const r = shapeTypes.gcWithScope();
-  const curveType = curve.geomType;
-  if (curveType === "CIRCLE") {
-    const circle = r(r(curve.adaptor()).Circle());
-    const radius = circle.Radius();
-    const orientationCorrection = circle.IsDirect() ? 1 : -1;
-    const orientedOffset = offset * orientationCorrection;
-    const newRadius = Number(radius) + orientedOffset;
-    if (newRadius < 1e-10) {
-      const centerPos = r(circle.Location());
-      const center = [centerPos.X(), centerPos.Y()];
-      const offsetViaCenter = (point) => {
-        const [x, y] = helpers.normalize2d(helpers.subtract2d(point, center));
-        return helpers.add2d(point, [orientedOffset * x, orientedOffset * y]);
-      };
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const curveType = curve.geomType;
+    if (curveType === "CIRCLE") {
+      const circle = scope.register(scope.register(curve.adaptor()).Circle());
+      const radius = circle.Radius();
+      const orientationCorrection = circle.IsDirect() ? 1 : -1;
+      const orientedOffset = offset * orientationCorrection;
+      const newRadius = Number(radius) + orientedOffset;
+      if (newRadius < 1e-10) {
+        const centerPos = scope.register(circle.Location());
+        const center = [centerPos.X(), centerPos.Y()];
+        const offsetViaCenter = (point) => {
+          const [x, y] = helpers.normalize2d(helpers.subtract2d(point, center));
+          return helpers.add2d(point, [orientedOffset * x, orientedOffset * y]);
+        };
+        return {
+          collapsed: true,
+          firstPoint: offsetViaCenter(curve.firstPoint),
+          lastPoint: offsetViaCenter(curve.lastPoint)
+        };
+      }
+      const oc2 = occtBoundary.getKernel().oc;
+      const newCircle = new oc2.gp_Circ2d_3(circle.Axis(), newRadius);
+      const newInnerCurve = new oc2.Geom2d_Circle_1(newCircle);
+      newCircle.delete();
+      const newCurve = new oc2.Geom2d_TrimmedCurve(
+        new oc2.Handle_Geom2d_Curve_2(newInnerCurve),
+        curve.firstParameter,
+        curve.lastParameter,
+        true,
+        true
+      );
+      return new Blueprint.Curve2D(new oc2.Handle_Geom2d_Curve_2(newCurve));
+    }
+    if (curveType === "LINE") {
+      const { firstPoint, lastPoint } = offsetEndPoints(curve.firstPoint, curve.lastPoint, offset);
+      return Blueprint.make2dSegmentCurve(firstPoint, lastPoint);
+    }
+    const oc = occtBoundary.getKernel().oc;
+    const offsetCurve = new Blueprint.Curve2D(
+      new oc.Handle_Geom2d_Curve_2(new oc.Geom2d_OffsetCurve(curve.wrapped, offset, true))
+    );
+    const approximation = Blueprint.approximateAsBSpline(offsetCurve.adaptor());
+    const selfIntersects = errors.unwrap(selfIntersections(approximation));
+    if (selfIntersects.length) {
       return {
         collapsed: true,
-        firstPoint: offsetViaCenter(curve.firstPoint),
-        lastPoint: offsetViaCenter(curve.lastPoint)
+        firstPoint: approximation.firstPoint,
+        lastPoint: approximation.lastPoint
       };
     }
-    const oc2 = occtBoundary.getKernel().oc;
-    const newCircle = new oc2.gp_Circ2d_3(circle.Axis(), newRadius);
-    const newInnerCurve = new oc2.Geom2d_Circle_1(newCircle);
-    newCircle.delete();
-    const newCurve = new oc2.Geom2d_TrimmedCurve(
-      new oc2.Handle_Geom2d_Curve_2(newInnerCurve),
-      curve.firstParameter,
-      curve.lastParameter,
-      true,
-      true
-    );
-    return new Blueprint.Curve2D(new oc2.Handle_Geom2d_Curve_2(newCurve));
-  }
-  if (curveType === "LINE") {
-    const { firstPoint, lastPoint } = offsetEndPoints(curve.firstPoint, curve.lastPoint, offset);
-    return Blueprint.make2dSegmentCurve(firstPoint, lastPoint);
-  }
-  const oc = occtBoundary.getKernel().oc;
-  const offsetCurve = new Blueprint.Curve2D(
-    new oc.Handle_Geom2d_Curve_2(new oc.Geom2d_OffsetCurve(curve.wrapped, offset, true))
-  );
-  const approximation = Blueprint.approximateAsBSpline(offsetCurve.adaptor());
-  const selfIntersects = errors.unwrap(selfIntersections(approximation));
-  if (selfIntersects.length) {
-    return {
-      collapsed: true,
-      firstPoint: approximation.firstPoint,
-      lastPoint: approximation.lastPoint
-    };
+    return approximation;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
   }
-  return approximation;
 };
 function removeCorner(firstCurve, secondCurve, radius) {
   const sinAngle = helpers.crossProduct2d(firstCurve.tangentAt(1), secondCurve.tangentAt(0));
@@ -1037,7 +1110,6 @@ class Sketch {
     twistAngle,
     origin
   } = {}) {
-    const gc = shapeTypes.localGC()[1];
     const direction = extrusionDirection ? occtBoundary.toVec3(extrusionDirection) : this.defaultDirection;
     const extrusionVec = vecOps.vecScale(vecOps.vecNormalize(direction), extrusionDistance);
     const originVec = origin ? occtBoundary.toVec3(origin) : this.defaultOrigin;
@@ -1045,7 +1117,6 @@ class Sketch {
       const solid2 = errors.unwrap(
         loft.complexExtrude(this.wire, [...originVec], [...extrusionVec], extrusionProfile)
       );
-      gc();
       this.delete();
       return solid2;
     }
@@ -1053,13 +1124,11 @@ class Sketch {
       const solid2 = errors.unwrap(
         loft.twistExtrude(this.wire, twistAngle, [...originVec], [...extrusionVec], extrusionProfile)
       );
-      gc();
       this.delete();
       return solid2;
     }
     const face = errors.unwrap(surfaceBuilders.makeFace(this.wire));
     const solid = loft.basicFaceExtrusion(face, [...extrusionVec]);
-    gc();
     this.delete();
     return solid;
   }
@@ -1649,38 +1718,54 @@ class FaceSketcher extends BaseSketcher2d {
    * @ignore
    */
   buildWire() {
-    const [r, gc] = shapeTypes.localGC();
-    const oc = occtBoundary.getKernel().oc;
-    const geomSurf = r(this._adaptSurface());
-    const edges = this.pendingCurves.map((curve) => {
-      return r(shapeTypes.createEdge(r(new oc.BRepBuilderAPI_MakeEdge_30(curve.wrapped, geomSurf)).Edge()));
-    });
-    const wire = errors.unwrap(surfaceBuilders.assembleWire(edges));
-    oc.BRepLib.BuildCurves3d_2(wire.wrapped);
-    gc();
-    return wire;
+    var _stack = [];
+    try {
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      const oc = occtBoundary.getKernel().oc;
+      const geomSurf = scope.register(this._adaptSurface());
+      const edges = this.pendingCurves.map((curve) => {
+        return scope.register(
+          shapeTypes.createEdge(
+            scope.register(new oc.BRepBuilderAPI_MakeEdge_30(curve.wrapped, geomSurf)).Edge()
+          )
+        );
+      });
+      const wire = errors.unwrap(surfaceBuilders.assembleWire(edges));
+      oc.BRepLib.BuildCurves3d_2(wire.wrapped);
+      return wire;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
   }
   /** Finish drawing and return the resulting {@link Sketch} (does not close the path). */
   done() {
-    const [r, gc] = shapeTypes.localGC();
-    const wire = this.buildWire();
-    const sketch = new Sketch(wire);
-    if (curveFns.curveIsClosed(wire)) {
-      const face = r(sketch.clone().face());
-      const origin = faceFns.pointOnSurface(face, 0.5, 0.5);
-      const normal = faceFns.normalAt(face);
-      const direction = vecOps.vecScale(normal, -1);
-      sketch.defaultOrigin = [origin[0], origin[1], origin[2]];
-      sketch.defaultDirection = [direction[0], direction[1], direction[2]];
-    } else {
-      const startPoint = curveFns.curveStartPoint(wire);
-      const normal = faceFns.normalAt(this.face, [startPoint[0], startPoint[1], startPoint[2]]);
-      sketch.defaultOrigin = [startPoint[0], startPoint[1], startPoint[2]];
-      sketch.defaultDirection = [normal[0], normal[1], normal[2]];
+    var _stack = [];
+    try {
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
+      const wire = this.buildWire();
+      const sketch = new Sketch(wire);
+      if (curveFns.curveIsClosed(wire)) {
+        const face = scope.register(sketch.clone().face());
+        const origin = faceFns.pointOnSurface(face, 0.5, 0.5);
+        const normal = faceFns.normalAt(face);
+        const direction = vecOps.vecScale(normal, -1);
+        sketch.defaultOrigin = [origin[0], origin[1], origin[2]];
+        sketch.defaultDirection = [direction[0], direction[1], direction[2]];
+      } else {
+        const startPoint = curveFns.curveStartPoint(wire);
+        const normal = faceFns.normalAt(this.face, [startPoint[0], startPoint[1], startPoint[2]]);
+        sketch.defaultOrigin = [startPoint[0], startPoint[1], startPoint[2]];
+        sketch.defaultDirection = [normal[0], normal[1], normal[2]];
+      }
+      sketch.baseFace = this.face;
+      return sketch;
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
     }
-    sketch.baseFace = this.face;
-    gc();
-    return sketch;
   }
   /** Close the path with a straight line to the start point and return the Sketch. */
   close() {