brepjs 8.8.2 → 8.8.4

package/dist/curveFns-VDZEhY97.js

@@ -0,0 +1,281 @@
+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();
+};
+import { g as getKernel } from "./occtBoundary-Ct0tN8cs.js";
+import { D as DisposalScope, c as castShape, d as isEdge, n as isWire } from "./shapeTypes-D34s68Xi.js";
+import { e as err, p as typeCastError, l as ok, u as unwrap } from "./errors-CHfaHQSt.js";
+let CURVE_TYPES_MAP = null;
+const getCurveTypesMap = (refresh) => {
+  if (CURVE_TYPES_MAP && !refresh) return CURVE_TYPES_MAP;
+  const oc = getKernel().oc;
+  const ga = oc.GeomAbs_CurveType;
+  CURVE_TYPES_MAP = /* @__PURE__ */ new Map([
+    [ga.GeomAbs_Line, "LINE"],
+    [ga.GeomAbs_Circle, "CIRCLE"],
+    [ga.GeomAbs_Ellipse, "ELLIPSE"],
+    [ga.GeomAbs_Hyperbola, "HYPERBOLA"],
+    [ga.GeomAbs_Parabola, "PARABOLA"],
+    [ga.GeomAbs_BezierCurve, "BEZIER_CURVE"],
+    [ga.GeomAbs_BSplineCurve, "BSPLINE_CURVE"],
+    [ga.GeomAbs_OffsetCurve, "OFFSET_CURVE"],
+    [ga.GeomAbs_OtherCurve, "OTHER_CURVE"]
+  ]);
+  return CURVE_TYPES_MAP;
+};
+const findCurveType = (type) => {
+  let shapeType = getCurveTypesMap().get(type);
+  if (!shapeType) shapeType = getCurveTypesMap(true).get(type);
+  if (!shapeType) return err(typeCastError("UNKNOWN_CURVE_TYPE", "Unknown curve type"));
+  return ok(shapeType);
+};
+function getAdaptor(shape) {
+  const oc = getKernel().oc;
+  const st = shape.wrapped.ShapeType();
+  const e = oc.TopAbs_ShapeEnum;
+  if (st === e.TopAbs_WIRE) {
+    return new oc.BRepAdaptor_CompCurve_2(shape.wrapped, false);
+  }
+  return new oc.BRepAdaptor_Curve_2(shape.wrapped);
+}
+function mapParam(adaptor, t) {
+  const first = Number(adaptor.FirstParameter());
+  const last = Number(adaptor.LastParameter());
+  return first + (last - first) * t;
+}
+function getCurveType(shape) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    const technicalType = adaptor.GetType && adaptor.GetType();
+    return unwrap(findCurveType(technicalType));
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function curveStartPoint(shape) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new 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) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new 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) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new 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) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new 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) {
+  var _stack = [];
+  try {
+    const oc = getKernel().oc;
+    const scope = __using(_stack, new 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) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new DisposalScope());
+    const adaptor = scope.register(getAdaptor(shape));
+    return adaptor.IsClosed();
+  } catch (_) {
+    var _error = _, _hasError = true;
+  } finally {
+    __callDispose(_stack, _error, _hasError);
+  }
+}
+function curveIsPeriodic(shape) {
+  var _stack = [];
+  try {
+    const scope = __using(_stack, new 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);
+  const result = adaptor.Period();
+  adaptor.delete();
+  return result;
+}
+function getOrientation(shape) {
+  const oc = getKernel().oc;
+  const orient = shape.wrapped.Orientation_1();
+  return orient === oc.TopAbs_Orientation.TopAbs_FORWARD ? "forward" : "backward";
+}
+function flipOrientation(shape) {
+  return castShape(shape.wrapped.Reversed());
+}
+function interpolateCurve(points, options = {}) {
+  if (points.length < 2) {
+    return err(typeCastError("INTERPOLATE_MIN_POINTS", "Interpolation requires at least 2 points"));
+  }
+  try {
+    const result = getKernel().interpolatePoints(points, options);
+    const cast = castShape(result);
+    if (!isEdge(cast)) {
+      return err(typeCastError("INTERPOLATE_NOT_EDGE", "Interpolation did not produce an edge"));
+    }
+    return ok(cast);
+  } catch (e) {
+    return err(
+      typeCastError(
+        "INTERPOLATE_FAILED",
+        `Interpolation failed: ${e instanceof Error ? e.message : String(e)}`
+      )
+    );
+  }
+}
+function approximateCurve(points, options = {}) {
+  if (points.length < 2) {
+    return err(typeCastError("APPROXIMATE_MIN_POINTS", "Approximation requires at least 2 points"));
+  }
+  try {
+    const result = getKernel().approximatePoints(points, options);
+    const cast = castShape(result);
+    if (!isEdge(cast)) {
+      return err(typeCastError("APPROXIMATE_NOT_EDGE", "Approximation did not produce an edge"));
+    }
+    return ok(cast);
+  } catch (e) {
+    return err(
+      typeCastError(
+        "APPROXIMATE_FAILED",
+        `Approximation failed: ${e instanceof Error ? e.message : String(e)}`
+      )
+    );
+  }
+}
+function offsetWire2D(wire, offset, kind = "arc") {
+  const oc = getKernel().oc;
+  const joinTypes = {
+    arc: oc.GeomAbs_JoinType.GeomAbs_Arc,
+    intersection: oc.GeomAbs_JoinType.GeomAbs_Intersection,
+    tangent: oc.GeomAbs_JoinType.GeomAbs_Tangent,
+    chamfer: oc.GeomAbs_JoinType.GeomAbs_Intersection
+    // sharp/miter corners
+  };
+  const resultShape = getKernel().offsetWire2D(wire.wrapped, offset, joinTypes[kind]);
+  const wrapped = castShape(resultShape);
+  if (!isWire(wrapped)) {
+    wrapped[Symbol.dispose]();
+    return err(typeCastError("OFFSET_NOT_WIRE", "Offset did not produce a Wire"));
+  }
+  return ok(wrapped);
+}
+export {
+  curveEndPoint as a,
+  getCurveType as b,
+  curveTangentAt as c,
+  curveStartPoint as d,
+  curveIsClosed as e,
+  findCurveType as f,
+  getOrientation as g,
+  curvePointAt as h,
+  curveLength as i,
+  approximateCurve as j,
+  curveIsPeriodic as k,
+  curvePeriod as l,
+  flipOrientation as m,
+  interpolateCurve as n,
+  offsetWire2D as o
+};

package/dist/{drawFns-WgXeXHH1.cjs → drawFns-B52K-9DJ.cjs}

@@ -1,20 +1,65 @@
 "use strict";
-const errors = require("./errors-NNmTtM5u.cjs");
-const vectors = require("./vectors-CGLqemPY.cjs");
-const occtBoundary = require("./occtBoundary-Cqfsau2c.cjs");
+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-BYb4tL5h.cjs");
+const vectors = require("./vectors-9rrStq8t.cjs");
+const occtBoundary = require("./occtBoundary-CN_uQJtA.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-BZnkU_aH.cjs");
+const faceFns = require("./faceFns-B8xnZw-f.cjs");
+const curveFns = require("./curveFns-KDpL9iyo.cjs");
+const surfaceBuilders = require("./surfaceBuilders-hupjYn0W.cjs");
+const shapeTypes = require("./shapeTypes-sXITvFkF.cjs");
+const Blueprint = require("./Blueprint-D1Dik12C.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-Cfibxk7U.cjs");
+const shapeFns = require("./shapeFns-ByLUl6KE.cjs");
+const loft = require("./loft-Bhnw5Rfr.cjs");
 const opentype = require("opentype.js");
-const cornerFinder = require("./cornerFinder-v4un1Fr9.cjs");
+const cornerFinder = require("./cornerFinder-DbRL42YI.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);