brepjs 8.0.0 → 8.0.2

package/dist/{drawFns-CUyx50gi.cjs → drawFns-D2eDcf4k.cjs}

@@ -1,20 +1,21 @@
 "use strict";
 const errors = require("./errors-DK1VAdP4.cjs");
-const shapeHelpers = require("./shapeHelpers-B2SXz1p4.cjs");
-const vectors = require("./vectors-ChWEZPwy.cjs");
-const occtBoundary = require("./occtBoundary-du8_ex-p.cjs");
+const vectors = require("./vectors-DK2hEKcI.cjs");
+const occtBoundary = require("./occtBoundary-6kQSl3cF.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const boolean2D = require("./boolean2D-BdZATaHs.cjs");
-const faceFns = require("./faceFns-BwK7FP7N.cjs");
-const curveFns = require("./curveFns-BilyYL_s.cjs");
-const shapeTypes = require("./shapeTypes-DKhwEnUM.cjs");
-const cast = require("./cast-DkB0GKmQ.cjs");
-const Blueprint = require("./Blueprint-CVctc41Z.cjs");
+const boolean2D = require("./boolean2D-B1XrGVgx.cjs");
+const faceFns = require("./faceFns-NDRFeekj.cjs");
+const curveFns = require("./curveFns-BrJDkaWi.cjs");
+const curveBuilders = require("./curveBuilders-BUoFO1UG.cjs");
+const shapeTypes = require("./shapeTypes-BJ3Hmskg.cjs");
+const cast = require("./cast-DIiyxDLo.cjs");
+const Blueprint = require("./Blueprint-VGbo3izk.cjs");
 const result = require("./result.cjs");
-const query = require("./query-hMSmOWJP.cjs");
-const shapeFns = require("./shapeFns-BvOndshS.cjs");
-const loft = require("./loft-BzWFokmC.cjs");
+const helpers = require("./helpers-Ck8GJ58k.cjs");
+const shapeFns = require("./shapeFns-cN4qGpbO.cjs");
+const loft = require("./loft-DJXwxV_L.cjs");
 const opentype = require("opentype.js");
+const cornerFinder = require("./cornerFinder-BndBNtJE.cjs");
 const stitchCurves = (curves, precision = 1e-7) => {
   const startPoints = new boolean2D.Flatbush(curves.length);
   curves.forEach((c) => {
@@ -97,7 +98,7 @@ class Sketcher {
   /** Draw a straight line to an absolute 2D point on the sketch plane. */
   lineTo([x, y]) {
     const endPoint = vectors.planeToWorld(this.plane, [x, y]);
-    this.pendingEdges.push(shapeHelpers.makeLine(this.pointer, endPoint));
+    this.pendingEdges.push(curveBuilders.makeLine(this.pointer, endPoint));
     this._updatePointer(endPoint);
     return this;
   }
@@ -127,13 +128,13 @@ class Sketcher {
   /** Draw a line in polar coordinates (distance and angle in degrees) from the current point. */
   polarLine(distance, angle) {
     const angleInRads = angle * vecOps.DEG2RAD;
-    const [x, y] = query.polarToCartesian(distance, angleInRads);
+    const [x, y] = helpers.polarToCartesian(distance, angleInRads);
     return this.line(x, y);
   }
   /** Draw a line to a point given in polar coordinates [r, theta] from the origin. */
   polarLineTo([r, theta]) {
     const angleInRads = theta * vecOps.DEG2RAD;
-    const point = query.polarToCartesian(r, angleInRads);
+    const point = helpers.polarToCartesian(r, angleInRads);
     return this.lineTo(point);
   }
   /** Draw a line tangent to the previous edge, extending by the given distance. */
@@ -144,7 +145,7 @@ class Sketcher {
     const tangent = curveFns.curveTangentAt(previousEdge, 1);
     const scaledTangent = vecOps.vecScale(vecOps.vecNormalize(tangent), distance);
     const endPoint = vecOps.vecAdd(scaledTangent, this.pointer);
-    this.pendingEdges.push(shapeHelpers.makeLine(this.pointer, endPoint));
+    this.pendingEdges.push(curveBuilders.makeLine(this.pointer, endPoint));
     this._updatePointer(endPoint);
     return this;
   }
@@ -152,7 +153,7 @@ class Sketcher {
   threePointsArcTo(end, innerPoint) {
     const gpoint1 = vectors.planeToWorld(this.plane, innerPoint);
     const gpoint2 = vectors.planeToWorld(this.plane, end);
-    this.pendingEdges.push(shapeHelpers.makeThreePointArc(this.pointer, gpoint1, gpoint2));
+    this.pendingEdges.push(curveBuilders.makeThreePointArc(this.pointer, gpoint1, gpoint2));
     this._updatePointer(gpoint2);
     return this;
   }
@@ -169,7 +170,7 @@ class Sketcher {
       result.bug("Sketcher.tangentArcTo", "You need a previous edge to create a tangent arc");
     const prevEnd = curveFns.curveEndPoint(previousEdge);
     const prevTangent = curveFns.curveTangentAt(previousEdge, 1);
-    this.pendingEdges.push(shapeHelpers.makeTangentArc(prevEnd, prevTangent, endPoint));
+    this.pendingEdges.push(curveBuilders.makeTangentArc(prevEnd, prevTangent, endPoint));
     this._updatePointer(endPoint);
     return this;
   }
@@ -189,7 +190,7 @@ class Sketcher {
     const sagDirection = vecOps.vecNormalize(crossResult);
     const sagVector = vecOps.vecScale(sagDirection, sagitta);
     const sagPoint = vecOps.vecAdd(midPoint, sagVector);
-    this.pendingEdges.push(shapeHelpers.makeThreePointArc(this.pointer, sagPoint, endPoint));
+    this.pendingEdges.push(curveBuilders.makeThreePointArc(this.pointer, sagPoint, endPoint));
     this._updatePointer(endPoint);
     return this;
   }
@@ -210,7 +211,7 @@ class Sketcher {
   bulgeArcTo(end, bulge) {
     if (!bulge) return this.lineTo(end);
     const [px, py] = vectors.planeToLocal(this.plane, this.pointer);
-    const halfChord = query.distance2d([px, py], end) / 2;
+    const halfChord = helpers.distance2d([px, py], end) / 2;
     const bulgeAsSagitta = -bulge * halfChord;
     return this.sagittaArcTo(end, bulgeAsSagitta);
   }
@@ -229,7 +230,6 @@ class Sketcher {
   }
   /** Draw an elliptical arc to an absolute end point (SVG-style parameters). */
   ellipseTo(end, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep = false) {
-    const [, gc] = shapeTypes.localGC();
     const [startX, startY] = vectors.planeToLocal(this.plane, this.pointer);
     let rotationAngle = rotation;
     let majorRadius = horizontalRadius;
@@ -250,7 +250,7 @@ class Sketcher {
     );
     const xDir = vecOps.vecRotate(this.plane.xDir, this.plane.zDir, rotationAngle * vecOps.DEG2RAD);
     const arc = errors.unwrap(
-      shapeHelpers.makeEllipseArc(
+      curveBuilders.makeEllipseArc(
         rx,
         ry,
         clockwise ? startAngle : endAngle,
@@ -265,7 +265,6 @@ class Sketcher {
     }
     this.pendingEdges.push(arc);
     this._updatePointer(vectors.planeToWorld(this.plane, end));
-    gc();
     return this;
   }
   /** Draw an elliptical arc to a relative end point (SVG-style parameters). */
@@ -284,8 +283,8 @@ class Sketcher {
   halfEllipseTo(end, verticalRadius, sweep = false) {
     const [px, py] = vectors.planeToLocal(this.plane, this.pointer);
     const start = [px, py];
-    const angle = query.polarAngle2d(end, start);
-    const distance = query.distance2d(end, start);
+    const angle = helpers.polarAngle2d(end, start);
+    const distance = helpers.distance2d(end, start);
     return this.ellipseTo(end, distance / 2, verticalRadius, angle * vecOps.RAD2DEG, false, sweep);
   }
   /** Draw a half-ellipse arc to a relative end point with a given minor radius. */
@@ -303,7 +302,7 @@ class Sketcher {
     }
     const inWorldPoints = cp.map((p) => vectors.planeToWorld(this.plane, p));
     const endPoint = vectors.planeToWorld(this.plane, end);
-    this.pendingEdges.push(errors.unwrap(shapeHelpers.makeBezierCurve([this.pointer, ...inWorldPoints, endPoint])));
+    this.pendingEdges.push(errors.unwrap(curveBuilders.makeBezierCurve([this.pointer, ...inWorldPoints, endPoint])));
     this._updatePointer(endPoint);
     return this;
   }
@@ -352,7 +351,7 @@ class Sketcher {
       const endPoleDistance = vecOps.vecScale(vecOps.vecNormalize(endPoleDirection), endFactor * defaultDistance);
       const endControl = vecOps.vecSub(endPoint, endPoleDistance);
       this.pendingEdges.push(
-        errors.unwrap(shapeHelpers.makeBezierCurve([this.pointer, startControl, endControl, endPoint]))
+        errors.unwrap(curveBuilders.makeBezierCurve([this.pointer, startControl, endControl, endPoint]))
       );
       this._updatePointer(endPoint);
       return this;
@@ -373,12 +372,12 @@ class Sketcher {
     const mirroredRaw = Blueprint.mirror(clonedWrapped, normal, this.pointer);
     const mirroredWrapped = errors.unwrap(cast.downcast(mirroredRaw));
     const mirroredWire = shapeTypes.createWire(mirroredWrapped);
-    const combinedWire = errors.unwrap(shapeHelpers.assembleWire([wire, mirroredWire]));
+    const combinedWire = errors.unwrap(curveBuilders.assembleWire([wire, mirroredWire]));
     return combinedWire;
   }
   buildWire() {
     if (!this.pendingEdges.length) result.bug("Sketcher.buildWire", "No lines to convert into a wire");
-    let wire = errors.unwrap(shapeHelpers.assembleWire(this.pendingEdges));
+    let wire = errors.unwrap(curveBuilders.assembleWire(this.pendingEdges));
     if (this._mirrorWire) {
       wire = this._mirrorWireOnStartEnd(wire);
     }
@@ -440,7 +439,7 @@ const fixWire = (wire, baseFace) => {
 const faceFromWires = (wires) => {
   let baseFace;
   let holeWires;
-  const faceResult = shapeHelpers.makeFace(wires[0]);
+  const faceResult = Blueprint.makeFace(wires[0]);
   if (errors.isOk(faceResult)) {
     baseFace = faceResult.value;
     holeWires = wires.slice(1);
@@ -448,7 +447,7 @@ const faceFromWires = (wires) => {
     baseFace = guessFaceFromWires(wires);
     holeWires = wires.slice(1).map((w) => fixWire(w, baseFace));
   }
-  return shapeHelpers.addHolesInFace(baseFace, holeWires);
+  return Blueprint.addHolesInFace(baseFace, holeWires);
 };
 const solidFromShellGenerator = (sketches, shellGenerator) => {
   const shells = [];
@@ -462,7 +461,7 @@ const solidFromShellGenerator = (sketches, shellGenerator) => {
   });
   const startFace = faceFromWires(startWires);
   const endFace = faceFromWires(endWires);
-  const solid = errors.unwrap(shapeHelpers.makeSolid([startFace, ...shells, endFace]));
+  const solid = errors.unwrap(loft.makeSolid([startFace, ...shells, endFace]));
   return solid;
 };
 class CompoundSketch {
@@ -490,12 +489,12 @@ class CompoundSketch {
   /** Return all wires (outer + holes) combined into a compound shape. */
   get wires() {
     const wires = this.sketches.map((s) => s.wire);
-    return shapeHelpers.makeCompound(wires);
+    return loft.makeCompound(wires);
   }
   /** Build a face from the outer boundary with inner wires subtracted as holes. */
   face() {
     const baseFace = this.outerSketch.face();
-    const newFace = shapeHelpers.addHolesInFace(
+    const newFace = Blueprint.addHolesInFace(
       baseFace,
       this.innerSketches.map((s) => s.wire)
     );
@@ -574,7 +573,7 @@ class CompoundSketch {
     const baseFaceRaw = this.face();
     const baseFace = shapeTypes.createFace(errors.unwrap(cast.downcast(baseFaceRaw.wrapped)));
     shells.push(baseFace, otherCompound.face());
-    return errors.unwrap(shapeHelpers.makeSolid(shells));
+    return errors.unwrap(loft.makeSolid(shells));
   }
 }
 class Sketches {
@@ -585,12 +584,12 @@ class Sketches {
   /** Return all wires combined into a single compound shape. */
   wires() {
     const wires = this.sketches.map((s) => s instanceof boolean2D.Sketch ? s.wire : s.wires);
-    return shapeHelpers.makeCompound(wires);
+    return loft.makeCompound(wires);
   }
   /** Return all sketch faces combined into a single compound shape. */
   faces() {
     const faces = this.sketches.map((s) => s.face());
-    return shapeHelpers.makeCompound(faces);
+    return loft.makeCompound(faces);
   }
   /** Extrudes the sketch to a certain distance (along the default direction
    * and origin of the sketch).
@@ -604,19 +603,19 @@ class Sketches {
    */
   extrude(extrusionDistance, extrusionConfig = {}) {
     const extruded = this.sketches.map((s) => s.extrude(extrusionDistance, extrusionConfig));
-    return shapeHelpers.makeCompound(extruded);
+    return loft.makeCompound(extruded);
   }
   /**
    * Revolves the drawing on an axis (defined by its direction and an origin
    * (defaults to the sketch origin)
    */
   revolve(revolutionAxis, config) {
-    return shapeHelpers.makeCompound(this.sketches.map((s) => s.revolve(revolutionAxis, config)));
+    return loft.makeCompound(this.sketches.map((s) => s.revolve(revolutionAxis, config)));
   }
 }
 const sketchCircle = (radius, planeConfig = {}) => {
   const plane = planeConfig.plane && typeof planeConfig.plane !== "string" ? { ...planeConfig.plane } : vectors.resolvePlane(planeConfig.plane ?? "XY", planeConfig.origin);
-  const wire = errors.unwrap(shapeHelpers.assembleWire([shapeHelpers.makeCircle(radius, plane.origin, plane.zDir)]));
+  const wire = errors.unwrap(curveBuilders.assembleWire([curveBuilders.makeCircle(radius, plane.origin, plane.zDir)]));
   const sketch = new boolean2D.Sketch(wire, {
     defaultOrigin: [...plane.origin],
     defaultDirection: [...plane.zDir]
@@ -634,7 +633,7 @@ const sketchEllipse = (xRadius = 1, yRadius = 2, planeConfig = {}) => {
     minR = xRadius;
   }
   const wire = errors.unwrap(
-    shapeHelpers.assembleWire([errors.unwrap(shapeHelpers.makeEllipse(majR, minR, plane.origin, plane.zDir, xDir))])
+    curveBuilders.assembleWire([errors.unwrap(curveBuilders.makeEllipse(majR, minR, plane.origin, plane.zDir, xDir))])
   );
   const sketch = new boolean2D.Sketch(wire, {
     defaultOrigin: [...plane.origin],
@@ -696,7 +695,7 @@ const sketchParametricFunction = (func, planeConfig = {}, { pointsCount = 400, s
     return vectors.planeToWorld(plane, point);
   });
   const wire = errors.unwrap(
-    shapeHelpers.assembleWire([r(errors.unwrap(shapeHelpers.makeBSplineApproximation(points, approximationConfig)))])
+    curveBuilders.assembleWire([r(errors.unwrap(curveBuilders.makeBSplineApproximation(points, approximationConfig)))])
   );
   const sketch = new boolean2D.Sketch(wire, {
     defaultOrigin: [...plane.origin],
@@ -709,13 +708,13 @@ const sketchHelix = (pitch, height, radius, center = [0, 0, 0], dir = [0, 0, 1],
   const centerVec3 = occtBoundary.toVec3(center);
   const dirVec3 = occtBoundary.toVec3(dir);
   return new boolean2D.Sketch(
-    errors.unwrap(shapeHelpers.assembleWire([shapeHelpers.makeHelix(pitch, height, radius, centerVec3, dirVec3, lefthand)]))
+    errors.unwrap(curveBuilders.assembleWire([curveBuilders.makeHelix(pitch, height, radius, centerVec3, dirVec3, lefthand)]))
   );
 };
 const makeBaseBox = (xLength, yLength, zLength) => {
   return new Sketcher().movePointerTo([-xLength / 2, yLength / 2]).hLine(xLength).vLine(-yLength).hLine(-xLength).close().extrude(zLength);
 };
-const samePoint = (x, y) => query.samePoint(x, y, query.PRECISION_OFFSET * 10);
+const samePoint = (x, y) => helpers.samePoint(x, y, helpers.PRECISION_OFFSET * 10);
 const getIntersectionPoint = (line1Start, line1End, line2Start, line2End) => {
   const dx1 = line1Start[0] - line1End[0];
   const dy1 = line1Start[1] - line1End[1];
@@ -744,8 +743,8 @@ function joinBevel(appendCurve, previousLastPoint, firstPoint, previousCurve, _c
   appendCurve(bevelJoiner);
 }
 function joinMiter(appendCurve, previousLastPoint, firstPoint, previousCurve, curve) {
-  const previousOtherPoint = previousCurve.offset instanceof Blueprint.Curve2D ? query.subtract2d(previousLastPoint, previousCurve.offset.tangentAt(1)) : previousCurve.offset.firstPoint;
-  const nextOtherPoint = curve.offset instanceof Blueprint.Curve2D ? query.add2d(firstPoint, curve.offset.tangentAt(0)) : curve.offset.lastPoint;
+  const previousOtherPoint = previousCurve.offset instanceof Blueprint.Curve2D ? helpers.subtract2d(previousLastPoint, previousCurve.offset.tangentAt(1)) : previousCurve.offset.firstPoint;
+  const nextOtherPoint = curve.offset instanceof Blueprint.Curve2D ? helpers.add2d(firstPoint, curve.offset.tangentAt(0)) : curve.offset.lastPoint;
   const offsetIntersectionPoint = getIntersectionPoint(
     previousOtherPoint,
     previousLastPoint,
@@ -810,7 +809,7 @@ function rawOffsets(blueprint, offset2, offsetConfig = {}) {
     let intersections = [];
     if (previousCurve.offset instanceof Blueprint.Curve2D && curve.offset instanceof Blueprint.Curve2D) {
       const { intersections: pointIntersections, commonSegmentsPoints } = errors.unwrap(
-        boolean2D.intersectCurves(previousCurve.offset, curve.offset, query.PRECISION_OFFSET / 100)
+        boolean2D.intersectCurves(previousCurve.offset, curve.offset, helpers.PRECISION_OFFSET / 100)
       );
       intersections = [...pointIntersections, ...commonSegmentsPoints];
     }
@@ -818,10 +817,10 @@ function rawOffsets(blueprint, offset2, offsetConfig = {}) {
       let intersection = intersections[0];
       if (intersections.length > 1) {
         const originalEndpoint = previousCurve.original.lastPoint;
-        let minDist = query.squareDistance2d(intersection, originalEndpoint);
+        let minDist = helpers.squareDistance2d(intersection, originalEndpoint);
         for (let i = 1; i < intersections.length; i++) {
           const point = intersections[i];
-          const d = query.squareDistance2d(point, originalEndpoint);
+          const d = helpers.squareDistance2d(point, originalEndpoint);
           if (d < minDist) {
             minDist = d;
             intersection = point;
@@ -830,9 +829,9 @@ function rawOffsets(blueprint, offset2, offsetConfig = {}) {
       }
       const splitPreviousCurve = previousCurve.offset.splitAt(
         [intersection],
-        query.PRECISION_OFFSET
+        helpers.PRECISION_OFFSET
       )[0];
-      const splitCurve = curve.offset.splitAt([intersection], query.PRECISION_OFFSET).at(-1);
+      const splitCurve = curve.offset.splitAt([intersection], helpers.PRECISION_OFFSET).at(-1);
       if (!splitCurve) result.bug("offset.rawOffsets", "Split produced no trailing curve segment");
       appendCurve({
         offset: splitPreviousCurve,
@@ -873,7 +872,7 @@ function offsetBlueprint(blueprint, offset2, offsetConfig = {}) {
       testedPairs.add(pairKey);
       const secondCurve = offsettedArray[secondIndex];
       const { intersections: rawIntersections, commonSegmentsPoints } = errors.unwrap(
-        boolean2D.intersectCurves(firstCurve, secondCurve, query.PRECISION_OFFSET)
+        boolean2D.intersectCurves(firstCurve, secondCurve, helpers.PRECISION_OFFSET)
       );
       const intersections = [...rawIntersections, ...commonSegmentsPoints].filter(
         (intersection) => {
@@ -895,12 +894,12 @@ function offsetBlueprint(blueprint, offset2, offsetConfig = {}) {
   const splitCurves = offsettedArray.flatMap((curve, index) => {
     if (!allIntersections.has(index)) return curve;
     const intersections = allIntersections.get(index) || [];
-    const splitCurves2 = curve.splitAt(intersections, query.PRECISION_OFFSET * 100);
+    const splitCurves2 = curve.splitAt(intersections, helpers.PRECISION_OFFSET * 100);
     return splitCurves2;
   });
   const prunedCurves = splitCurves.filter((curve) => {
     const closeCurve = blueprint.curves.find(
-      (c) => c.distanceFrom(curve) < Math.abs(offset2) - query.PRECISION_OFFSET
+      (c) => c.distanceFrom(curve) < Math.abs(offset2) - helpers.PRECISION_OFFSET
     );
     return !closeCurve;
   });
@@ -971,7 +970,7 @@ function modifyCorners(makeCorner, blueprint, radius, finder) {
     result.bug("customCorners.modifyCorners", "Unexpected empty curve list during corner modification");
   if (
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    query.samePoint(curves[0].firstPoint, lastCurve.lastPoint) && curves.length > 1
+    helpers.samePoint(curves[0].firstPoint, lastCurve.lastPoint) && curves.length > 1
   ) {
     const firstCurve = curves.pop();
     const secondCurve = curves.shift();
@@ -1302,7 +1301,7 @@ class Drawing {
    * @category Drawing Modifications
    */
   fillet(radius, filter) {
-    const finder = filter && filter(query.cornerFinder());
+    const finder = filter && filter(cornerFinder.cornerFinder());
     return new Drawing(fillet2D(this.innerShape, radius, finder));
   }
   /**
@@ -1312,7 +1311,7 @@ class Drawing {
    * @category Drawing Modifications
    */
   chamfer(radius, filter) {
-    const finder = filter && filter(query.cornerFinder());
+    const finder = filter && filter(cornerFinder.cornerFinder());
     return new Drawing(chamfer2D(this.innerShape, radius, finder));
   }
   sketchOnPlane(inputPlane, origin) {
@@ -1459,7 +1458,7 @@ const drawPointsInterpolation = (points, approximationConfig = {}, options = {})
   const curves = [errors.unwrap(Blueprint.make2dInerpolatedBSplineCurve(points, approximationConfig))];
   const firstPoint = points[0];
   const lastPoint = points[points.length - 1];
-  if (options.closeShape && firstPoint && lastPoint && !query.samePoint(firstPoint, lastPoint)) {
+  if (options.closeShape && firstPoint && lastPoint && !helpers.samePoint(firstPoint, lastPoint)) {
     curves.push(Blueprint.make2dSegmentCurve(lastPoint, firstPoint));
   }
   return new Drawing(new Blueprint.Blueprint(curves));
@@ -1474,7 +1473,7 @@ const drawParametricFunction = (func, { pointsCount = 400, start = 0, stop = 1,
 const edgesToDrawing = (edges) => {
   const [r, gc] = shapeTypes.localGC();
   const planeSketch = drawRectangle(1e3, 1e3).sketchOnPlane();
-  const planeFace = r(errors.unwrap(shapeHelpers.makeFace(planeSketch.wire)));
+  const planeFace = r(errors.unwrap(Blueprint.makeFace(planeSketch.wire)));
   const curves = edges.map((e) => Blueprint.edgeToCurve(e, planeFace));
   gc();
   const stitchedCurves = stitchCurves(curves).map((s) => new Blueprint.Blueprint(s));

package/dist/{faceFns-DHu-2JpA.js → faceFns-DDzCECn3.js}

@@ -1,7 +1,7 @@
-import { g as getKernel, a as toVec3, d as toOcPnt } from "./occtBoundary-CwegMzqc.js";
-import { c as castShape, n as gcWithScope } from "./shapeTypes-BlSElW8z.js";
+import { g as getKernel, a as toVec3, b as toOcPnt } from "./occtBoundary-CqXvDhZY.js";
+import { c as castShape, p as gcWithScope } from "./shapeTypes-C9sUsmEW.js";
 import { u as unwrap, e as err, p as typeCastError, l as ok } from "./errors-wGhcJMpB.js";
-import { i as iterTopo, d as downcast } from "./cast-DQaUibmm.js";
+import { i as iterTopo, d as downcast } from "./cast-C4Ff_1Qe.js";
 function getSurfaceType(face) {
   const oc = getKernel().oc;
   const r = gcWithScope();

package/dist/{faceFns-BwK7FP7N.cjs → faceFns-NDRFeekj.cjs}

@@ -1,8 +1,8 @@
 "use strict";
-const occtBoundary = require("./occtBoundary-du8_ex-p.cjs");
-const shapeTypes = require("./shapeTypes-DKhwEnUM.cjs");
+const occtBoundary = require("./occtBoundary-6kQSl3cF.cjs");
+const shapeTypes = require("./shapeTypes-BJ3Hmskg.cjs");
 const errors = require("./errors-DK1VAdP4.cjs");
-const cast = require("./cast-DkB0GKmQ.cjs");
+const cast = require("./cast-DIiyxDLo.cjs");
 function getSurfaceType(face) {
   const oc = occtBoundary.getKernel().oc;
   const r = shapeTypes.gcWithScope();

package/dist/helpers-Ck8GJ58k.cjs

@@ -0,0 +1,203 @@
+"use strict";
+const result = require("./result.cjs");
+const shapeTypes = require("./shapeTypes-BJ3Hmskg.cjs");
+const errors = require("./errors-DK1VAdP4.cjs");
+const vecOps = require("./vecOps-CjRL1jau.cjs");
+const faceFns = require("./faceFns-NDRFeekj.cjs");
+const measurement = require("./measurement-LcGh4wV0.cjs");
+const shapeFns = require("./shapeFns-cN4qGpbO.cjs");
+const cast = require("./cast-DIiyxDLo.cjs");
+const occtBoundary = require("./occtBoundary-6kQSl3cF.cjs");
+const PRECISION_INTERSECTION = 1e-9;
+const PRECISION_OFFSET = 1e-8;
+const PRECISION_POINT = 1e-6;
+const samePoint = ([x0, y0], [x1, y1], precision = PRECISION_POINT) => {
+  return Math.abs(x0 - x1) <= precision && Math.abs(y0 - y1) <= precision;
+};
+const add2d = ([x0, y0], [x1, y1]) => {
+  return [x0 + x1, y0 + y1];
+};
+const subtract2d = ([x0, y0], [x1, y1]) => {
+  return [x0 - x1, y0 - y1];
+};
+const scalarMultiply2d = ([x0, y0], scalar) => {
+  return [x0 * scalar, y0 * scalar];
+};
+const distance2d = ([x0, y0], [x1, y1] = [0, 0]) => {
+  return Math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2);
+};
+const squareDistance2d = ([x0, y0], [x1, y1] = [0, 0]) => {
+  return (x0 - x1) ** 2 + (y0 - y1) ** 2;
+};
+function crossProduct2d([x0, y0], [x1, y1]) {
+  return x0 * y1 - y0 * x1;
+}
+const angle2d = ([x0, y0], [x1, y1] = [0, 0]) => {
+  return Math.atan2(y1 * x0 - y0 * x1, x0 * x1 + y0 * y1);
+};
+const polarAngle2d = ([x0, y0], [x1, y1] = [0, 0]) => {
+  return Math.atan2(y1 - y0, x1 - x0);
+};
+const normalize2d = ([x0, y0]) => {
+  const l = distance2d([x0, y0]);
+  if (l < 1e-12) {
+    result.bug("normalize2d", "Cannot normalize zero-length vector");
+  }
+  return [x0 / l, y0 / l];
+};
+const rotate2d = (point, angle, center = [0, 0]) => {
+  const [px0, py0] = point;
+  const [cx, cy] = center;
+  const px = px0 - cx;
+  const py = py0 - cy;
+  const sinA = Math.sin(angle);
+  const cosA = Math.cos(angle);
+  const xnew = px * cosA - py * sinA;
+  const ynew = px * sinA + py * cosA;
+  return [xnew + cx, ynew + cy];
+};
+const polarToCartesian = (r, theta) => {
+  const x = Math.cos(theta) * r;
+  const y = Math.sin(theta) * r;
+  return [x, y];
+};
+const cartesianToPolar = ([x, y]) => {
+  const r = distance2d([x, y]);
+  const theta = Math.atan2(y, x);
+  return [r, theta];
+};
+function createTypedFinder(topoKind, filters, rebuild, extend) {
+  const withFilter = (pred) => rebuild([...filters, pred]);
+  const shouldKeep = (element) => filters.every((f) => f(element));
+  const extractElements = (shape) => {
+    const result2 = [];
+    for (const raw of cast.iterTopo(shape.wrapped, topoKind)) {
+      const element = shapeTypes.castShape(errors.unwrap(cast.downcast(raw)));
+      if (shouldKeep(element)) {
+        result2.push(element);
+      }
+    }
+    return result2;
+  };
+  const emptyFinder = () => createTypedFinder(topoKind, [], rebuild, extend);
+  const base = {
+    _filters: filters,
+    _topoKind: topoKind,
+    when: (pred) => withFilter(pred),
+    inList: (elements) => {
+      const hashSet = /* @__PURE__ */ new Map();
+      for (const e of elements) {
+        const h = shapeFns.getHashCode(e);
+        const bucket = hashSet.get(h);
+        if (bucket) bucket.push(e);
+        else hashSet.set(h, [e]);
+      }
+      return withFilter((el) => {
+        const bucket = hashSet.get(shapeFns.getHashCode(el));
+        return !!bucket && bucket.some((e) => shapeFns.isSameShape(e, el));
+      });
+    },
+    not: (builderFn) => {
+      const inner = builderFn(emptyFinder());
+      return withFilter((el) => !inner.shouldKeep(el));
+    },
+    either: (fns) => {
+      const builtFinders = fns.map((fn) => fn(emptyFinder()));
+      return withFilter((el) => builtFinders.some((f) => f.shouldKeep(el)));
+    },
+    findAll: (shape) => extractElements(shape),
+    findUnique: (shape) => {
+      const elements = extractElements(shape);
+      if (elements.length !== 1) {
+        return errors.err(
+          errors.queryError(
+            "FINDER_NOT_UNIQUE",
+            `Finder expected a unique match but found ${elements.length} element(s)`
+          )
+        );
+      }
+      return errors.ok(elements[0]);
+    },
+    shouldKeep
+  };
+  const extensions = extend(base, withFilter);
+  return { ...base, ...extensions };
+}
+const DIRECTIONS = {
+  X: [1, 0, 0],
+  Y: [0, 1, 0],
+  Z: [0, 0, 1]
+};
+function resolveDir(dir) {
+  if (typeof dir === "string") return DIRECTIONS[dir] ?? [0, 0, 1];
+  return dir;
+}
+function distanceFromPointFilter(distance, point, tolerance) {
+  return (element) => {
+    const oc = occtBoundary.getKernel().oc;
+    const r = shapeTypes.gcWithScope();
+    const pnt = r(occtBoundary.toOcPnt(point));
+    const vtxMaker = r(new oc.BRepBuilderAPI_MakeVertex(pnt));
+    const vtx = vtxMaker.Vertex();
+    const distTool = r(new oc.BRepExtrema_DistShapeShape_1());
+    distTool.LoadS1(vtx);
+    distTool.LoadS2(element.wrapped);
+    const progress = r(new oc.Message_ProgressRange_1());
+    distTool.Perform(progress);
+    const d = distTool.Value();
+    return Math.abs(d - distance) < tolerance;
+  };
+}
+function faceDirectionFilter(dir, angle) {
+  const d = vecOps.vecNormalize(resolveDir(dir));
+  return (face) => {
+    const n = faceFns.normalAt(face);
+    const ang = Math.acos(Math.min(1, Math.abs(vecOps.vecDot(vecOps.vecNormalize(n), d))));
+    return Math.abs(ang - vecOps.DEG2RAD * angle) < 1e-6;
+  };
+}
+function buildFaceFinder(filters) {
+  return createTypedFinder(
+    "face",
+    filters,
+    buildFaceFinder,
+    (_base, withFilter) => ({
+      inDirection: (dir = "Z", angle = 0) => withFilter(faceDirectionFilter(dir, angle)),
+      parallelTo: (dir = "Z") => buildFaceFinder(filters).inDirection(dir, 0),
+      ofSurfaceType: (surfaceType) => withFilter((face) => errors.unwrap(faceFns.getSurfaceType(face)) === surfaceType),
+      ofArea: (area, tolerance = 1e-3) => withFilter((face) => Math.abs(measurement.measureArea(face) - area) < tolerance),
+      atDistance: (distance, point = [0, 0, 0]) => withFilter(distanceFromPointFilter(distance, point, 1e-6))
+    })
+  );
+}
+function faceFinder() {
+  return buildFaceFinder([]);
+}
+function getSingleFace(f, shape) {
+  if (typeof f === "object" && "_topoKind" in f) {
+    return f.findUnique(shape);
+  }
+  if (typeof f !== "function" && shapeTypes.isFace(f)) return errors.ok(f);
+  const fnResult = f(faceFinder());
+  return fnResult.findUnique(shape);
+}
+exports.PRECISION_INTERSECTION = PRECISION_INTERSECTION;
+exports.PRECISION_OFFSET = PRECISION_OFFSET;
+exports.add2d = add2d;
+exports.angle2d = angle2d;
+exports.cartesianToPolar = cartesianToPolar;
+exports.createTypedFinder = createTypedFinder;
+exports.crossProduct2d = crossProduct2d;
+exports.distance2d = distance2d;
+exports.distanceFromPointFilter = distanceFromPointFilter;
+exports.faceFinder = faceFinder;
+exports.getSingleFace = getSingleFace;
+exports.normalize2d = normalize2d;
+exports.polarAngle2d = polarAngle2d;
+exports.polarToCartesian = polarToCartesian;
+exports.resolveDir = resolveDir;
+exports.rotate2d = rotate2d;
+exports.samePoint = samePoint;
+exports.scalarMultiply2d = scalarMultiply2d;
+exports.squareDistance2d = squareDistance2d;
+exports.subtract2d = subtract2d;