brepjs 8.8.2 → 8.8.3

package/dist/{curveFns-6ovDM_sR.cjs → curveFns-BsAHC3Qv.cjs}

@@ -1,6 +1,51 @@
 "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 result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
 const occtBoundary = require("./occtBoundary-Cqfsau2c.cjs");
-const shapeTypes = require("./shapeTypes-CIijJxCz.cjs");
+const shapeTypes = require("./shapeTypes-CWuX602K.cjs");
 const errors = require("./errors-NNmTtM5u.cjs");
 let CURVE_TYPES_MAP = null;
 const getCurveTypesMap = (refresh) => {
@@ -41,55 +86,111 @@ function mapParam(adaptor, t) {
   return first + (last - first) * t;
 }
 function getCurveType(shape) {
-  const r = shapeTypes.gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const technicalType = adaptor.GetType && adaptor.GetType();
-  return errors.unwrap(findCurveType(technicalType));
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    const technicalType = adaptor.GetType && adaptor.GetType();
+    return errors.unwrap(findCurveType(technicalType));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function curveStartPoint(shape) {
-  const r = shapeTypes.gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const pnt = r(adaptor.Value(adaptor.FirstParameter()));
-  return [pnt.X(), pnt.Y(), pnt.Z()];
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    const pnt = scope.register(adaptor.Value(adaptor.FirstParameter()));
+    return [pnt.X(), pnt.Y(), pnt.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function curveEndPoint(shape) {
-  const r = shapeTypes.gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const pnt = r(adaptor.Value(adaptor.LastParameter()));
-  return [pnt.X(), pnt.Y(), pnt.Z()];
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    const pnt = scope.register(adaptor.Value(adaptor.LastParameter()));
+    return [pnt.X(), pnt.Y(), pnt.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function curvePointAt(shape, position = 0.5) {
-  const r = shapeTypes.gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const pnt = r(adaptor.Value(mapParam(adaptor, position)));
-  return [pnt.X(), pnt.Y(), pnt.Z()];
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    const pnt = scope.register(adaptor.Value(mapParam(adaptor, position)));
+    return [pnt.X(), pnt.Y(), pnt.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function curveTangentAt(shape, position = 0.5) {
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  const param = mapParam(adaptor, position);
-  const tmpPnt = r(new oc.gp_Pnt_1());
-  const tmpVec = r(new oc.gp_Vec_1());
-  adaptor.D1(param, tmpPnt, tmpVec);
-  return [tmpVec.X(), tmpVec.Y(), tmpVec.Z()];
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    const param = mapParam(adaptor, position);
+    const tmpPnt = scope.register(new oc.gp_Pnt_1());
+    const tmpVec = scope.register(new oc.gp_Vec_1());
+    adaptor.D1(param, tmpPnt, tmpVec);
+    return [tmpVec.X(), tmpVec.Y(), tmpVec.Z()];
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function curveLength(shape) {
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  const props = r(new oc.GProp_GProps_1());
-  oc.BRepGProp.LinearProperties(shape.wrapped, props, true, false);
-  return props.Mass();
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const props = scope.register(new oc.GProp_GProps_1());
+    oc.BRepGProp.LinearProperties(shape.wrapped, props, true, false);
+    return props.Mass();
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function curveIsClosed(shape) {
-  const r = shapeTypes.gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  return adaptor.IsClosed();
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    return adaptor.IsClosed();
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function curveIsPeriodic(shape) {
-  const r = shapeTypes.gcWithScope();
-  const adaptor = r(getAdaptor(shape));
-  return adaptor.IsPeriodic();
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    return adaptor.IsPeriodic();
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function curvePeriod(shape) {
   const adaptor = getAdaptor(shape);

package/dist/{drawFns-WgXeXHH1.cjs → drawFns-CsmUF97U.cjs}

@@ -1,20 +1,65 @@
 "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 errors = require("./errors-NNmTtM5u.cjs");
 const vectors = require("./vectors-CGLqemPY.cjs");
 const occtBoundary = require("./occtBoundary-Cqfsau2c.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const boolean2D = require("./boolean2D-q5FOdOQW.cjs");
-const faceFns = require("./faceFns-CxaLWOjc.cjs");
-const curveFns = require("./curveFns-6ovDM_sR.cjs");
-const surfaceBuilders = require("./surfaceBuilders-CC0ZQGix.cjs");
-const shapeTypes = require("./shapeTypes-CIijJxCz.cjs");
-const Blueprint = require("./Blueprint-BmbNUnGI.cjs");
+const boolean2D = require("./boolean2D-BQk8LNmZ.cjs");
+const faceFns = require("./faceFns-DNQss51F.cjs");
+const curveFns = require("./curveFns-BsAHC3Qv.cjs");
+const surfaceBuilders = require("./surfaceBuilders-CLal3WlK.cjs");
+const shapeTypes = require("./shapeTypes-CWuX602K.cjs");
+const Blueprint = require("./Blueprint-BmFJ4caY.cjs");
 const result = require("./result.cjs");
-const helpers = require("./helpers-CRfqaW0Y.cjs");
-const shapeFns = require("./shapeFns-C785aeVn.cjs");
-const loft = require("./loft-CVb-IjEI.cjs");
+const helpers = require("./helpers-aylLv0_I.cjs");
+const shapeFns = require("./shapeFns-D4CRxxmF.cjs");
+const loft = require("./loft-CjEEqz2P.cjs");
 const opentype = require("opentype.js");
-const cornerFinder = require("./cornerFinder-v4un1Fr9.cjs");
+const cornerFinder = require("./cornerFinder-XAV2ywVS.cjs");
 const stitchCurves = (curves, precision = 1e-7) => {
   const startPoints = new boolean2D.Flatbush(curves.length);
   curves.forEach((c) => {
@@ -315,8 +360,9 @@ class Sketcher {
   }
   /** Draw a smooth cubic Bezier spline to an absolute end point, blending tangent with the previous edge. */
   smoothSplineTo(end, config) {
-    const [r, gc] = shapeTypes.localGC();
+    var _stack = [];
     try {
+      const scope = __using(_stack, new shapeTypes.DisposalScope());
       const { endTangent, startTangent, startFactor, endFactor } = boolean2D.defaultsSplineOptions(config);
       const endPoint = vectors.planeToWorld(this.plane, end);
       const previousEdge = this.pendingEdges.length ? this.pendingEdges[this.pendingEdges.length - 1] : null;
@@ -329,17 +375,14 @@ class Sketcher {
         startPoleDirection = vectors.planeToWorld(this.plane, [1, 0]);
       } else if (curveFns.getCurveType(previousEdge) === "BEZIER_CURVE") {
         const oc = occtBoundary.getKernel().oc;
-        const adaptor = r(new oc.BRepAdaptor_Curve_2(previousEdge.wrapped));
+        const adaptor = scope.register(new oc.BRepAdaptor_Curve_2(previousEdge.wrapped));
         const rawCurve = adaptor.Bezier().get();
         const previousPole = occtBoundary.toVec3(rawCurve.Pole(rawCurve.NbPoles() - 1));
         startPoleDirection = vecOps.vecSub(this.pointer, previousPole);
       } else {
         startPoleDirection = curveFns.curveTangentAt(previousEdge, 1);
       }
-      const poleDistance = vecOps.vecScale(
-        vecOps.vecNormalize(startPoleDirection),
-        startFactor * defaultDistance
-      );
+      const poleDistance = vecOps.vecScale(vecOps.vecNormalize(startPoleDirection), startFactor * defaultDistance);
       const startControl = vecOps.vecAdd(this.pointer, poleDistance);
       let endPoleDirection;
       if (endTangent === "symmetric") {
@@ -354,8 +397,10 @@ class Sketcher {
       );
       this._updatePointer(endPoint);
       return this;
+    } catch (_) {
+      var _error = _, _hasError = true;
     } finally {
-      gc();
+      __callDispose(_stack, _error, _hasError);
     }
   }
   /** Draw a smooth cubic Bezier spline to a relative end point, blending tangent with the previous edge. */
@@ -408,32 +453,44 @@ class Sketcher {
   }
 }
 const guessFaceFromWires = (wires) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const faceBuilder = r(
-    new oc.BRepOffsetAPI_MakeFilling(3, 15, 2, false, 1e-5, 1e-4, 0.01, 0.1, 8, 9)
-  );
-  wires.forEach((wire, wireIndex) => {
-    shapeFns.getEdges(wire).forEach((edge) => {
-      faceBuilder.Add_1(edge.wrapped, oc.GeomAbs_Shape.GeomAbs_C0, wireIndex === 0);
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const faceBuilder = scope.register(
+      new oc.BRepOffsetAPI_MakeFilling(3, 15, 2, false, 1e-5, 1e-4, 0.01, 0.1, 8, 9)
+    );
+    wires.forEach((wire, wireIndex) => {
+      shapeFns.getEdges(wire).forEach((edge) => {
+        faceBuilder.Add_1(edge.wrapped, oc.GeomAbs_Shape.GeomAbs_C0, wireIndex === 0);
+      });
     });
-  });
-  const progress = r(new oc.Message_ProgressRange_1());
-  faceBuilder.Build(progress);
-  const newFace = errors.unwrap(faceFns.cast(faceBuilder.Shape()));
-  gc();
-  if (!shapeTypes.isFace(newFace)) {
-    result.bug("guessFaceFromWires", "Failed to create a face");
-  }
-  return newFace;
+    const progress = scope.register(new oc.Message_ProgressRange_1());
+    faceBuilder.Build(progress);
+    const newFace = errors.unwrap(faceFns.cast(faceBuilder.Shape()));
+    if (!shapeTypes.isFace(newFace)) {
+      result.bug("guessFaceFromWires", "Failed to create a face");
+    }
+    return newFace;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 };
 const fixWire = (wire, baseFace) => {
-  const oc = occtBoundary.getKernel().oc;
-  const [r, gc] = shapeTypes.localGC();
-  const wireFixer = r(new oc.ShapeFix_Wire_2(wire.wrapped, baseFace.wrapped, 1e-9));
-  wireFixer.FixEdgeCurves();
-  gc();
-  return wire;
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const wireFixer = scope.register(new oc.ShapeFix_Wire_2(wire.wrapped, baseFace.wrapped, 1e-9));
+    wireFixer.FixEdgeCurves();
+    return wire;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 };
 const faceFromWires = (wires) => {
   let baseFace;
@@ -511,7 +568,6 @@ class CompoundSketch {
     twistAngle,
     origin
   } = {}) {
-    const [, gc] = shapeTypes.localGC();
     const rawVec = extrusionDirection ? occtBoundary.toVec3(extrusionDirection) : this.outerSketch.defaultDirection;
     const normVec = vecOps.vecNormalize(rawVec);
     const extrusionVec = vecOps.vecScale(normVec, extrusionDistance);
@@ -542,7 +598,6 @@ class CompoundSketch {
     } else {
       result2 = loft.basicFaceExtrusion(this.face(), extrusionVec);
     }
-    gc();
     return result2;
   }
   /**
@@ -686,22 +741,28 @@ const sketchFaceOffset = (face, offset2) => {
   return sketch;
 };
 const sketchParametricFunction = (func, planeConfig = {}, { pointsCount = 400, start = 0, stop = 1 } = {}, approximationConfig = {}) => {
-  const [r, gc] = shapeTypes.localGC();
-  const plane = planeConfig.plane && typeof planeConfig.plane !== "string" ? { ...planeConfig.plane } : vectors.resolvePlane(planeConfig.plane ?? "XY", planeConfig.origin);
-  const stepSize = (stop - start) / pointsCount;
-  const points = [...Array(pointsCount + 1).keys()].map((t) => {
-    const point = func(start + t * stepSize);
-    return vectors.planeToWorld(plane, point);
-  });
-  const wire = errors.unwrap(
-    surfaceBuilders.assembleWire([r(errors.unwrap(surfaceBuilders.makeBSplineApproximation(points, approximationConfig)))])
-  );
-  const sketch = new boolean2D.Sketch(wire, {
-    defaultOrigin: [...plane.origin],
-    defaultDirection: [...plane.zDir]
-  });
-  gc();
-  return sketch;
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const plane = planeConfig.plane && typeof planeConfig.plane !== "string" ? { ...planeConfig.plane } : vectors.resolvePlane(planeConfig.plane ?? "XY", planeConfig.origin);
+    const stepSize = (stop - start) / pointsCount;
+    const points = [...Array(pointsCount + 1).keys()].map((t) => {
+      const point = func(start + t * stepSize);
+      return vectors.planeToWorld(plane, point);
+    });
+    const wire = errors.unwrap(
+      surfaceBuilders.assembleWire([scope.register(errors.unwrap(surfaceBuilders.makeBSplineApproximation(points, approximationConfig)))])
+    );
+    const sketch = new boolean2D.Sketch(wire, {
+      defaultOrigin: [...plane.origin],
+      defaultDirection: [...plane.zDir]
+    });
+    return sketch;
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 };
 const sketchHelix = (pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1], lefthand = false) => {
   const centerVec3 = occtBoundary.toVec3(center);
@@ -1150,31 +1211,38 @@ const getEdgesFromOc = (shape) => {
   return shapeFns.getEdges(shapeTypes.castShape(shape));
 };
 function makeProjectedEdges(shape, camera, withHiddenLines = true) {
-  const oc = occtBoundary.getKernel().oc;
-  const r = shapeTypes.gcWithScope();
-  const hiddenLineRemoval = r(new oc.HLRBRep_Algo_1());
-  hiddenLineRemoval.Add_2(shape.wrapped, 0);
-  const ax2 = r(occtBoundary.makeOcAx2(camera.position, camera.direction, camera.xAxis));
-  const projector = r(new oc.HLRAlgo_Projector_2(ax2));
-  hiddenLineRemoval.Projector_1(projector);
-  hiddenLineRemoval.Update();
-  hiddenLineRemoval.Hide_1();
-  const hlrShapes = r(
-    new oc.HLRBRep_HLRToShape(r(new oc.Handle_HLRBRep_Algo_2(hiddenLineRemoval)))
-  );
-  const visible = [
-    ...getEdgesFromOc(hlrShapes.VCompound_1()),
-    ...getEdgesFromOc(hlrShapes.Rg1LineVCompound_1()),
-    ...getEdgesFromOc(hlrShapes.OutLineVCompound_1())
-  ];
-  visible.forEach((e) => oc.BRepLib.BuildCurves3d_2(e.wrapped));
-  const hidden = withHiddenLines ? [
-    ...getEdgesFromOc(hlrShapes.HCompound_1()),
-    ...getEdgesFromOc(hlrShapes.Rg1LineHCompound_1()),
-    ...getEdgesFromOc(hlrShapes.OutLineHCompound_1())
-  ] : [];
-  hidden.forEach((e) => oc.BRepLib.BuildCurves3d_2(e.wrapped));
-  return { visible, hidden };
+  var _stack = [];
+  try {
+    const oc = occtBoundary.getKernel().oc;
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const hiddenLineRemoval = scope.register(new oc.HLRBRep_Algo_1());
+    hiddenLineRemoval.Add_2(shape.wrapped, 0);
+    const ax2 = scope.register(occtBoundary.makeOcAx2(camera.position, camera.direction, camera.xAxis));
+    const projector = scope.register(new oc.HLRAlgo_Projector_2(ax2));
+    hiddenLineRemoval.Projector_1(projector);
+    hiddenLineRemoval.Update();
+    hiddenLineRemoval.Hide_1();
+    const hlrShapes = scope.register(
+      new oc.HLRBRep_HLRToShape(scope.register(new oc.Handle_HLRBRep_Algo_2(hiddenLineRemoval)))
+    );
+    const visible = [
+      ...getEdgesFromOc(hlrShapes.VCompound_1()),
+      ...getEdgesFromOc(hlrShapes.Rg1LineVCompound_1()),
+      ...getEdgesFromOc(hlrShapes.OutLineVCompound_1())
+    ];
+    visible.forEach((e) => oc.BRepLib.BuildCurves3d_2(e.wrapped));
+    const hidden = withHiddenLines ? [
+      ...getEdgesFromOc(hlrShapes.HCompound_1()),
+      ...getEdgesFromOc(hlrShapes.Rg1LineHCompound_1()),
+      ...getEdgesFromOc(hlrShapes.OutLineHCompound_1())
+    ] : [];
+    hidden.forEach((e) => oc.BRepLib.BuildCurves3d_2(e.wrapped));
+    return { visible, hidden };
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function createCamera(position = [0, 0, 0], direction = [0, 0, 1], xAxis) {
   const dirLength = vecOps.vecLength(direction);
@@ -1498,15 +1566,21 @@ const drawParametricFunction = (func, { pointsCount = 400, start = 0, stop = 1,
   return drawPointsInterpolation(points, approximationConfig, { closeShape });
 };
 const edgesToDrawing = (edges) => {
-  const [r, gc] = shapeTypes.localGC();
-  const planeSketch = drawRectangle(1e3, 1e3).sketchOnPlane();
-  const planeFace = r(errors.unwrap(surfaceBuilders.makeFace(planeSketch.wire)));
-  const curves = edges.map((e) => Blueprint.edgeToCurve(e, planeFace));
-  gc();
-  const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint.Blueprint(s));
-  if (stitchedCurves.length === 0) return new Drawing();
-  if (stitchedCurves.length === 1) return new Drawing(stitchedCurves[0]);
-  return new Drawing(new boolean2D.Blueprints(stitchedCurves));
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const planeSketch = drawRectangle(1e3, 1e3).sketchOnPlane();
+    const planeFace = scope.register(errors.unwrap(surfaceBuilders.makeFace(planeSketch.wire)));
+    const curves = edges.map((e) => Blueprint.edgeToCurve(e, planeFace));
+    const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint.Blueprint(s));
+    if (stitchedCurves.length === 0) return new Drawing();
+    if (stitchedCurves.length === 1) return new Drawing(stitchedCurves[0]);
+    return new Drawing(new boolean2D.Blueprints(stitchedCurves));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 };
 function drawProjection(shape, projectionCamera = "front") {
   let camera;
@@ -1522,15 +1596,21 @@ function drawProjection(shape, projectionCamera = "front") {
   };
 }
 function drawFaceOutline(face) {
-  const [r, gc] = shapeTypes.localGC();
-  const clonedFace = r(shapeTypes.createFace(errors.unwrap(faceFns.downcast(face.wrapped))));
-  const faceOuterWire = r(faceFns.outerWire(clonedFace));
-  const curves = shapeFns.getEdges(faceOuterWire).map((e) => Blueprint.edgeToCurve(e, face));
-  gc();
-  const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint.Blueprint(s));
-  if (stitchedCurves.length === 0) return new Drawing();
-  if (stitchedCurves.length === 1) return new Drawing(stitchedCurves[0]);
-  return new Drawing(new boolean2D.Blueprints(stitchedCurves));
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new shapeTypes.DisposalScope());
+    const clonedFace = scope.register(shapeTypes.createFace(errors.unwrap(faceFns.downcast(face.wrapped))));
+    const faceOuterWire = scope.register(faceFns.outerWire(clonedFace));
+    const curves = shapeFns.getEdges(faceOuterWire).map((e) => Blueprint.edgeToCurve(e, face));
+    const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint.Blueprint(s));
+    if (stitchedCurves.length === 0) return new Drawing();
+    if (stitchedCurves.length === 1) return new Drawing(stitchedCurves[0]);
+    return new Drawing(new boolean2D.Blueprints(stitchedCurves));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
 }
 function sketchExtrude(sketch, height, config) {
   return sketch.extrude(height, config);