brepjs 8.0.1 → 8.0.2

package/dist/2d/blueprints/booleanHelpers.d.ts

@@ -0,0 +1,32 @@
+import { Point2D, Curve2D } from '../lib/index.js';
+export declare const samePoint: (x: Point2D, y: Point2D) => boolean;
+/**
+ * Hash a point for Set/Map lookup using precision rounding.
+ * Must match PRECISION_INTERSECTION (1e-9) to avoid hash collisions for
+ * nearly-equal points.
+ */
+export declare function hashPoint(p: Point2D): string;
+/**
+ * Hash a segment by both orientations for bidirectional lookup.
+ * The smaller hash comes first so that (A,B) and (B,A) produce the same key.
+ */
+export declare function hashSegment(first: Point2D, last: Point2D): string;
+export type Segment = Curve2D[];
+export type IntersectionSegment = [Segment, Segment | 'same'];
+export declare function startOfSegment(s: Segment): Point2D;
+export declare function endOfSegment(s: Segment): Point2D;
+export declare function reverseSegment(segment: Segment): Segment;
+export declare function reverseSegments(segments: Segment[]): Segment[];
+export declare function curveMidPoint(curve: Curve2D): Point2D;
+/**
+ * Rotate the curves array so that it starts at the curve whose firstPoint
+ * matches the given point.
+ */
+export declare function rotateToStartAt(curves: Curve2D[], point: Point2D): Curve2D[];
+/**
+ * Rotate the curves array so that it starts at the curve matching the given
+ * segment. If the segment is oriented the other way, the curves are reversed
+ * first.
+ */
+export declare function rotateToStartAtSegment(curves: Curve2D[], segment: Curve2D): Curve2D[];
+//# sourceMappingURL=booleanHelpers.d.ts.map

package/dist/2d/blueprints/booleanHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleanHelpers.d.ts","sourceRoot":"","sources":["../../../src/2d/blueprints/booleanHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAQxD,eAAO,MAAM,SAAS,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OACH,CAAC;AAMjD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAE5C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAIjE;AAMD,MAAM,MAAM,OAAO,GAAG,OAAO,EAAE,CAAC;AAChC,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;AAE9D,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAMlD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAMhD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAMxD;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAE9D;AAMD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAGrD;AAsDD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,EAAE,CAG5E;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,CAwBrF"}

package/dist/2d/blueprints/booleanOperations.d.ts

@@ -1,5 +1,7 @@
 import { default as Blueprint } from './Blueprint.js';
 import { default as Blueprints } from './Blueprints.js';
+export type { Segment, IntersectionSegment } from './booleanHelpers.js';
+export { blueprintsIntersectionSegments } from './intersectionSegments.js';
 /**
  * Compute the boolean union of two simple blueprints.
  *
@@ -14,7 +16,7 @@ import { default as Blueprints } from './Blueprints.js';
  * @remarks Both blueprints must be closed. For compound or multi-blueprint
  * inputs, use {@link fuse2D} instead.
  */
-export declare const fuseBlueprints: (first: Blueprint, second: Blueprint) => null | Blueprint | Blueprints;
+export declare function fuseBlueprints(first: Blueprint, second: Blueprint): null | Blueprint | Blueprints;
 /**
  * Compute the boolean difference of two simple blueprints (first minus second).
  *
@@ -28,7 +30,7 @@ export declare const fuseBlueprints: (first: Blueprint, second: Blueprint) => nu
  *
  * @remarks Both blueprints must be closed. For compound inputs use {@link cut2D}.
  */
-export declare const cutBlueprints: (first: Blueprint, second: Blueprint) => null | Blueprint | Blueprints;
+export declare function cutBlueprints(first: Blueprint, second: Blueprint): null | Blueprint | Blueprints;
 /**
  * Compute the boolean intersection of two simple blueprints.
  *
@@ -41,5 +43,5 @@ export declare const cutBlueprints: (first: Blueprint, second: Blueprint) => nul
  *
  * @remarks Both blueprints must be closed. For compound inputs use {@link intersect2D}.
  */
-export declare const intersectBlueprints: (first: Blueprint, second: Blueprint) => null | Blueprint | Blueprints;
+export declare function intersectBlueprints(first: Blueprint, second: Blueprint): null | Blueprint | Blueprints;
 //# sourceMappingURL=booleanOperations.d.ts.map

package/dist/2d/blueprints/booleanOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"booleanOperations.d.ts","sourceRoot":"","sources":["../../../src/2d/blueprints/booleanOperations.ts"],"names":[],"mappings":"AAWA,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,UAAU,MAAM,iBAAiB,CAAC;AA4ezC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,SAAS,EAChB,QAAQ,SAAS,KAChB,IAAI,GAAG,SAAS,GAAG,UAqBrB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,SAAS,EAChB,QAAQ,SAAS,KAChB,IAAI,GAAG,SAAS,GAAG,UAqBrB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,SAAS,EAChB,QAAQ,SAAS,KAChB,IAAI,GAAG,SAAS,GAAG,UAqBrB,CAAC"}
+{"version":3,"file":"booleanOperations.d.ts","sourceRoot":"","sources":["../../../src/2d/blueprints/booleanOperations.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,UAAU,MAAM,iBAAiB,CAAC;AAKzC,YAAY,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,EAAE,8BAA8B,EAAE,MAAM,2BAA2B,CAAC;AAM3E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,UAAU,CAqBjG;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,UAAU,CAqBhG;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,GAChB,IAAI,GAAG,SAAS,GAAG,UAAU,CAqB/B"}

package/dist/2d/blueprints/intersectionSegments.d.ts

@@ -0,0 +1,12 @@
+import { default as Blueprint } from './Blueprint.js';
+import { IntersectionSegment } from './booleanHelpers.js';
+/**
+ * Given two closed blueprints, find their intersection points, split each
+ * blueprint's curves at those points, and pair up the resulting segments.
+ *
+ * Returns an array of paired segments (one from each blueprint) that share
+ * the same start/end intersection points, or `null` if the blueprints do not
+ * intersect.
+ */
+export declare function blueprintsIntersectionSegments(first: Blueprint, second: Blueprint): IntersectionSegment[] | null;
+//# sourceMappingURL=intersectionSegments.d.ts.map

package/dist/2d/blueprints/intersectionSegments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersectionSegments.d.ts","sourceRoot":"","sources":["../../../src/2d/blueprints/intersectionSegments.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAC;AAY5C,OAAO,KAAK,EAAW,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAgKxE;;;;;;;GAOG;AACH,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,GAChB,mBAAmB,EAAE,GAAG,IAAI,CAwE9B"}

package/dist/2d/blueprints/segmentAssembly.d.ts

@@ -0,0 +1,31 @@
+import { Curve2D } from '../lib/index.js';
+import { default as Blueprint } from './Blueprint.js';
+import { default as Blueprints } from './Blueprints.js';
+/**
+ * Split an array of curves into separate continuous paths. A discontinuity
+ * occurs where one curve's lastPoint does not match the next curve's
+ * firstPoint.
+ */
+export declare function splitPaths(curves: Curve2D[]): Curve2D[][];
+interface NoIntersectionResult {
+    readonly identical: false;
+    readonly firstCurveInSecond: boolean;
+    readonly secondCurveInFirst: boolean;
+}
+interface IdenticalResult {
+    readonly identical: true;
+}
+export type BooleanOperationResult = Blueprint | Blueprints | null | IdenticalResult | NoIntersectionResult;
+interface BooleanOperationConfig {
+    readonly firstInside: 'keep' | 'remove';
+    readonly secondInside: 'keep' | 'remove';
+}
+/**
+ * Core boolean operation between two simple (non-compound) blueprints.
+ *
+ * Segments both blueprints at their intersection points, then selects which
+ * segments to keep based on the `firstInside`/`secondInside` configuration.
+ */
+export declare function booleanOperation(first: Blueprint, second: Blueprint, config: BooleanOperationConfig): BooleanOperationResult;
+export {};
+//# sourceMappingURL=segmentAssembly.d.ts.map

package/dist/2d/blueprints/segmentAssembly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segmentAssembly.d.ts","sourceRoot":"","sources":["../../../src/2d/blueprints/segmentAssembly.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAC;AAU9C;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,CA6BzD;AAMD,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC;IAC1B,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;CACtC;AAED,UAAU,eAAe;IACvB,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;CAC1B;AAED,MAAM,MAAM,sBAAsB,GAC9B,SAAS,GACT,UAAU,GACV,IAAI,GACJ,eAAe,GACf,oBAAoB,CAAC;AAMzB,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC1C;AAmGD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,sBAAsB,GAC7B,sBAAsB,CAoDxB"}

package/dist/2d.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const Blueprint = require("./Blueprint-CVctc41Z.cjs");
-const boolean2D = require("./boolean2D-BdZATaHs.cjs");
+const Blueprint = require("./Blueprint-VGbo3izk.cjs");
+const boolean2D = require("./boolean2D-B1XrGVgx.cjs");
 function reverseCurve(curve) {
   const cloned = curve.clone();
   cloned.reverse();

package/dist/2d.js

@@ -1,6 +1,6 @@
-import { B as Blueprint } from "./Blueprint-D3JfGJTz.js";
-import { a, C, b } from "./Blueprint-D3JfGJTz.js";
-import { b as b2, C as C2, c, d, f, e, i, g, o, p, r } from "./boolean2D-hOw5Qay5.js";
+import { B as Blueprint } from "./Blueprint-B9fhnpFp.js";
+import { e, C, f } from "./Blueprint-B9fhnpFp.js";
+import { b, C as C2, c, d, f as f2, e as e2, i, g, o, p, r } from "./boolean2D-_WiqPxWZ.js";
 function reverseCurve(curve) {
   const cloned = curve.clone();
   cloned.reverse();
@@ -68,11 +68,11 @@ function sketch2DOnFace(bp, face, scaleMode) {
 }
 export {
   Blueprint,
-  b2 as Blueprints,
-  a as BoundingBox2d,
+  b as Blueprints,
+  e as BoundingBox2d,
   C2 as CompoundBlueprint,
   C as Curve2D,
-  b as axis2d,
+  f as axis2d,
   createBlueprint,
   curve2dBoundingBox,
   curve2dDistanceFrom,
@@ -84,8 +84,8 @@ export {
   curve2dTangentAt,
   c as cut2D,
   d as cutBlueprints,
-  f as fuse2D,
-  e as fuseBlueprints,
+  f2 as fuse2D,
+  e2 as fuseBlueprints,
   getBounds2D,
   getOrientation2D,
   i as intersect2D,

package/dist/{Blueprint-D3JfGJTz.js → Blueprint-B9fhnpFp.js}

@@ -1,13 +1,14 @@
-import { r as resolvePlane } from "./vectors-CBuaMeZv.js";
-import { g as getKernel, a as toVec3, c as makeOcAx2 } from "./occtBoundary-CwegMzqc.js";
-import { o as localGC, y as registerForCleanup, z as unregisterFromCleanup, n as gcWithScope, t as createEdge, s as createWire } from "./shapeTypes-BlSElW8z.js";
-import { u as uvBounds, a as faceGeomType, f as faceCenter, h as uvCoordinates } from "./faceFns-DHu-2JpA.js";
-import { j as findCurveType, m as getOrientation } from "./curveFns-CdVE4da7.js";
-import { u as unwrap, l as ok, e as err, b as computationError, x as validationError } from "./errors-wGhcJMpB.js";
-import { z as zip, o as makeFace } from "./shapeHelpers-BcoZf2N9.js";
-import { i as distance2d, s as samePoint, h as scalarMultiply2d, b as add2d, n as normalize2d, a as subtract2d, g as getSingleFace } from "./query-V6nV-VfL.js";
-import { c as cast } from "./cast-DQaUibmm.js";
+import { r as resolvePlane } from "./vectors-BVgXsYWl.js";
+import { g as getKernel, a as toVec3, m as makeOcAx2 } from "./occtBoundary-CqXvDhZY.js";
+import { t as localGC, u as createFace, e as isFace, y as registerForCleanup, z as unregisterFromCleanup, p as gcWithScope, o as createEdge, n as createWire } from "./shapeTypes-C9sUsmEW.js";
+import { u as uvBounds, a as faceGeomType, f as faceCenter, h as uvCoordinates } from "./faceFns-DDzCECn3.js";
+import { j as findCurveType, m as getOrientation } from "./curveFns-BshHA9Ys.js";
+import { e as err, o as occtError, l as ok, a as andThen, x as validationError, u as unwrap, b as computationError } from "./errors-wGhcJMpB.js";
+import { d as distance2d, s as samePoint, k as scalarMultiply2d, i as add2d, n as normalize2d, h as subtract2d, g as getSingleFace } from "./helpers-jku2V1DY.js";
+import { c as cast } from "./cast-C4Ff_1Qe.js";
 import { R as RAD2DEG, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
+import { a as getEdges } from "./shapeFns-DQtpzndX.js";
+import { m as makeLine, a as assembleWire$1 } from "./curveBuilders-CBlIWlbU.js";
 import { bug } from "./result.js";
 function makePlane(plane, origin) {
   if (plane && typeof plane !== "string") {
@@ -44,6 +45,86 @@ function mirror(shape, inputPlane, origin) {
   gc();
   return newShape;
 }
+function range(len) {
+  return Array.from(Array(len).keys());
+}
+function zip(arrays) {
+  const minLength = Math.min(...arrays.map((arr) => arr.length));
+  return range(minLength).map((i) => arrays.map((arr) => arr[i]));
+}
+function makeFace(wire, holes) {
+  const oc = getKernel().oc;
+  const faceBuilder = new oc.BRepBuilderAPI_MakeFace_15(wire.wrapped, false);
+  holes?.forEach((hole) => {
+    faceBuilder.Add(hole.wrapped);
+  });
+  if (!faceBuilder.IsDone()) {
+    faceBuilder.delete();
+    return err(
+      occtError("FACE_BUILD_FAILED", "Failed to build the face. Your wire might be non planar.")
+    );
+  }
+  const face = faceBuilder.Face();
+  faceBuilder.delete();
+  return ok(createFace(face));
+}
+function makeNewFaceWithinFace(originFace, wire) {
+  const oc = getKernel().oc;
+  const [r, gc] = localGC();
+  const surface = r(oc.BRep_Tool.Surface_2(originFace.wrapped));
+  const faceBuilder = r(new oc.BRepBuilderAPI_MakeFace_21(surface, wire.wrapped, true));
+  const face = faceBuilder.Face();
+  gc();
+  return createFace(face);
+}
+function makeNonPlanarFace(wire) {
+  const oc = getKernel().oc;
+  const [r, gc] = localGC();
+  const faceBuilder = r(
+    new oc.BRepOffsetAPI_MakeFilling(3, 15, 2, false, 1e-5, 1e-4, 0.01, 0.1, 8, 9)
+  );
+  getEdges(wire).forEach((edge) => {
+    faceBuilder.Add_1(
+      edge.wrapped,
+      oc.GeomAbs_Shape.GeomAbs_C0,
+      true
+    );
+  });
+  const progress = r(new oc.Message_ProgressRange_1());
+  faceBuilder.Build(progress);
+  return andThen(cast(faceBuilder.Shape()), (newFace) => {
+    gc();
+    if (!isFace(newFace)) {
+      return err(occtError("FACE_BUILD_FAILED", "Failed to create a face"));
+    }
+    return ok(newFace);
+  });
+}
+function addHolesInFace(face, holes) {
+  const oc = getKernel().oc;
+  const [r, gc] = localGC();
+  const faceMaker = r(new oc.BRepBuilderAPI_MakeFace_2(face.wrapped));
+  holes.forEach((wire) => {
+    faceMaker.Add(wire.wrapped);
+  });
+  const builtFace = r(faceMaker.Face());
+  const fixer = r(new oc.ShapeFix_Face_2(builtFace));
+  fixer.FixOrientation_1();
+  const newFace = fixer.Face();
+  gc();
+  return createFace(newFace);
+}
+function makePolygon(points) {
+  if (points.length < 3)
+    return err(
+      validationError("POLYGON_MIN_POINTS", "You need at least 3 points to make a polygon")
+    );
+  const edges = zip([points, [...points.slice(1), points[0]]]).map(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- zip returns untyped pairs
+    ([p1, p2]) => makeLine(p1, p2)
+  );
+  return andThen(assembleWire$1(edges), (wire) => makeFace(wire));
+}
 function isPoint2D(point) {
   return Array.isArray(point) && point.length === 2 && typeof point[0] === "number" && typeof point[1] === "number";
 }
@@ -1158,27 +1239,33 @@ class Blueprint {
   }
 }
 export {
+  removeDuplicatePoints as A,
   Blueprint as B,
   Curve2D as C,
-  BoundingBox2d as a,
-  axis2d as b,
-  make2dSegmentCurve as c,
-  approximateAsBSpline as d,
-  make2dCircle as e,
-  make2dThreePointArc as f,
-  make2dArcFromCenter as g,
-  asSVG as h,
-  isPoint2D as i,
-  make2dTangentArc as j,
-  make2dEllipseArc as k,
-  make2dBezierCurve as l,
-  makePlane as m,
-  mirror as n,
-  approximateAsSvgCompatibleCurve as o,
-  edgeToCurve as p,
-  make2dInerpolatedBSplineCurve as q,
-  removeDuplicatePoints as r,
-  make2dEllipse as s,
-  deserializeCurve2D as t,
-  viewbox as v
+  addHolesInFace as a,
+  makeNonPlanarFace as b,
+  makePolygon as c,
+  makeNewFaceWithinFace as d,
+  BoundingBox2d as e,
+  axis2d as f,
+  makePlane as g,
+  mirror as h,
+  make2dSegmentCurve as i,
+  make2dArcFromCenter as j,
+  approximateAsSvgCompatibleCurve as k,
+  edgeToCurve as l,
+  makeFace as m,
+  make2dInerpolatedBSplineCurve as n,
+  make2dCircle as o,
+  make2dEllipse as p,
+  deserializeCurve2D as q,
+  approximateAsBSpline as r,
+  isPoint2D as s,
+  make2dThreePointArc as t,
+  asSVG as u,
+  viewbox as v,
+  make2dEllipseArc as w,
+  make2dTangentArc as x,
+  make2dBezierCurve as y,
+  zip as z
 };

package/dist/{Blueprint-CVctc41Z.cjs → Blueprint-VGbo3izk.cjs}

@@ -1,14 +1,15 @@
 "use strict";
-const vectors = require("./vectors-ChWEZPwy.cjs");
-const occtBoundary = require("./occtBoundary-du8_ex-p.cjs");
-const shapeTypes = require("./shapeTypes-DKhwEnUM.cjs");
-const faceFns = require("./faceFns-BwK7FP7N.cjs");
-const curveFns = require("./curveFns-BilyYL_s.cjs");
+const vectors = require("./vectors-DK2hEKcI.cjs");
+const occtBoundary = require("./occtBoundary-6kQSl3cF.cjs");
+const shapeTypes = require("./shapeTypes-BJ3Hmskg.cjs");
+const faceFns = require("./faceFns-NDRFeekj.cjs");
+const curveFns = require("./curveFns-BrJDkaWi.cjs");
 const errors = require("./errors-DK1VAdP4.cjs");
-const shapeHelpers = require("./shapeHelpers-B2SXz1p4.cjs");
-const query = require("./query-hMSmOWJP.cjs");
-const cast = require("./cast-DkB0GKmQ.cjs");
+const helpers = require("./helpers-Ck8GJ58k.cjs");
+const cast = require("./cast-DIiyxDLo.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
+const shapeFns = require("./shapeFns-cN4qGpbO.cjs");
+const curveBuilders = require("./curveBuilders-BUoFO1UG.cjs");
 const result = require("./result.cjs");
 function makePlane(plane, origin) {
   if (plane && typeof plane !== "string") {
@@ -45,6 +46,86 @@ function mirror(shape, inputPlane, origin) {
   gc();
   return newShape;
 }
+function range(len) {
+  return Array.from(Array(len).keys());
+}
+function zip(arrays) {
+  const minLength = Math.min(...arrays.map((arr) => arr.length));
+  return range(minLength).map((i) => arrays.map((arr) => arr[i]));
+}
+function makeFace(wire, holes) {
+  const oc = occtBoundary.getKernel().oc;
+  const faceBuilder = new oc.BRepBuilderAPI_MakeFace_15(wire.wrapped, false);
+  holes?.forEach((hole) => {
+    faceBuilder.Add(hole.wrapped);
+  });
+  if (!faceBuilder.IsDone()) {
+    faceBuilder.delete();
+    return errors.err(
+      errors.occtError("FACE_BUILD_FAILED", "Failed to build the face. Your wire might be non planar.")
+    );
+  }
+  const face = faceBuilder.Face();
+  faceBuilder.delete();
+  return errors.ok(shapeTypes.createFace(face));
+}
+function makeNewFaceWithinFace(originFace, wire) {
+  const oc = occtBoundary.getKernel().oc;
+  const [r, gc] = shapeTypes.localGC();
+  const surface = r(oc.BRep_Tool.Surface_2(originFace.wrapped));
+  const faceBuilder = r(new oc.BRepBuilderAPI_MakeFace_21(surface, wire.wrapped, true));
+  const face = faceBuilder.Face();
+  gc();
+  return shapeTypes.createFace(face);
+}
+function makeNonPlanarFace(wire) {
+  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)
+  );
+  shapeFns.getEdges(wire).forEach((edge) => {
+    faceBuilder.Add_1(
+      edge.wrapped,
+      oc.GeomAbs_Shape.GeomAbs_C0,
+      true
+    );
+  });
+  const progress = r(new oc.Message_ProgressRange_1());
+  faceBuilder.Build(progress);
+  return errors.andThen(cast.cast(faceBuilder.Shape()), (newFace) => {
+    gc();
+    if (!shapeTypes.isFace(newFace)) {
+      return errors.err(errors.occtError("FACE_BUILD_FAILED", "Failed to create a face"));
+    }
+    return errors.ok(newFace);
+  });
+}
+function addHolesInFace(face, holes) {
+  const oc = occtBoundary.getKernel().oc;
+  const [r, gc] = shapeTypes.localGC();
+  const faceMaker = r(new oc.BRepBuilderAPI_MakeFace_2(face.wrapped));
+  holes.forEach((wire) => {
+    faceMaker.Add(wire.wrapped);
+  });
+  const builtFace = r(faceMaker.Face());
+  const fixer = r(new oc.ShapeFix_Face_2(builtFace));
+  fixer.FixOrientation_1();
+  const newFace = fixer.Face();
+  gc();
+  return shapeTypes.createFace(newFace);
+}
+function makePolygon(points) {
+  if (points.length < 3)
+    return errors.err(
+      errors.validationError("POLYGON_MIN_POINTS", "You need at least 3 points to make a polygon")
+    );
+  const edges = zip([points, [...points.slice(1), points[0]]]).map(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- zip returns untyped pairs
+    ([p1, p2]) => curveBuilders.makeLine(p1, p2)
+  );
+  return errors.andThen(curveBuilders.assembleWire(edges), (wire) => makeFace(wire));
+}
 function isPoint2D(point) {
   return Array.isArray(point) && point.length === 2 && typeof point[0] === "number" && typeof point[1] === "number";
 }
@@ -291,8 +372,8 @@ class Curve2D {
     }
     return Math.min(
       curveToPoint,
-      query.distance2d(point, this.firstPoint),
-      query.distance2d(point, this.lastPoint)
+      helpers.distance2d(point, this.firstPoint),
+      helpers.distance2d(point, this.lastPoint)
     );
   }
   distanceFromCurve(curve) {
@@ -348,8 +429,8 @@ class Curve2D {
       lowerDistance = projector.LowerDistance();
       lowerDistanceParameter = projector.LowerDistanceParameter();
     } catch {
-      if (query.samePoint(point, this.firstPoint, precision)) return errors.ok(this.firstParameter);
-      if (query.samePoint(point, this.lastPoint, precision)) return errors.ok(this.lastParameter);
+      if (helpers.samePoint(point, this.firstPoint, precision)) return errors.ok(this.firstParameter);
+      if (helpers.samePoint(point, this.lastPoint, precision)) return errors.ok(this.lastParameter);
       return errors.err(errors.computationError("PARAMETER_NOT_FOUND", "Failed to find parameter"));
     }
     if (lowerDistance > precision) {
@@ -412,7 +493,7 @@ class Curve2D {
     )
       parameters = parameters.slice(0, -1);
     if (!parameters.length) return [this];
-    return shapeHelpers.zip([
+    return zip([
       [firstParam, ...parameters],
       [...parameters, lastParam]
     ]).map(([first, last]) => {
@@ -489,7 +570,7 @@ function approximateAsSvgCompatibleCurve(curves, options = {
   return curves.flatMap((curve) => {
     const adaptor = r(curve.adaptor());
     const curveType = errors.unwrap(curveFns.findCurveType(adaptor.GetType()));
-    if (curveType === "ELLIPSE" || curveType === "CIRCLE" && query.samePoint(curve.firstPoint, curve.lastPoint)) {
+    if (curveType === "ELLIPSE" || curveType === "CIRCLE" && helpers.samePoint(curve.firstPoint, curve.lastPoint)) {
       return curve.splitAt([0.5]);
     }
     if (["LINE", "ELLIPSE", "CIRCLE"].includes(curveType)) {
@@ -520,7 +601,7 @@ const make2dSegmentCurve = (startPoint, endPoint) => {
   const [r, gc] = shapeTypes.localGC();
   const segment = r(new oc.GCE2d_MakeSegment_1(r(pnt(startPoint)), r(pnt(endPoint)))).Value();
   const curve = new Curve2D(segment);
-  if (!query.samePoint(curve.firstPoint, startPoint)) {
+  if (!helpers.samePoint(curve.firstPoint, startPoint)) {
     curve.reverse();
   }
   gc();
@@ -534,7 +615,7 @@ const make2dThreePointArc = (startPoint, midPoint, endPoint) => {
   ).Value();
   gc();
   const curve = new Curve2D(segment);
-  if (!query.samePoint(curve.firstPoint, startPoint)) {
+  if (!helpers.samePoint(curve.firstPoint, startPoint)) {
     curve.wrapped.get().SetTrim(curve.lastParameter, curve.firstParameter, true, true);
   }
   return curve;
@@ -547,7 +628,7 @@ const make2dTangentArc = (startPoint, tangent, endPoint) => {
   ).Value();
   gc();
   const curve = new Curve2D(segment);
-  if (!query.samePoint(curve.firstPoint, startPoint)) {
+  if (!helpers.samePoint(curve.firstPoint, startPoint)) {
     curve.wrapped.get().SetTrim(curve.lastParameter, curve.firstParameter, true, true);
   }
   return curve;
@@ -630,12 +711,12 @@ function make2dInerpolatedBSplineCurve(points, {
   return errors.ok(new Curve2D(splineBuilder.Curve()));
 }
 const make2dArcFromCenter = (startPoint, endPoint, center, longArc = false) => {
-  const midChord = query.scalarMultiply2d(query.add2d(startPoint, endPoint), 0.5);
-  const orientedRadius = query.distance2d(center, startPoint) * (longArc ? -1 : 1);
-  const midChordDir = query.normalize2d(query.subtract2d(midChord, center));
+  const midChord = helpers.scalarMultiply2d(helpers.add2d(startPoint, endPoint), 0.5);
+  const orientedRadius = helpers.distance2d(center, startPoint) * (longArc ? -1 : 1);
+  const midChordDir = helpers.normalize2d(helpers.subtract2d(midChord, center));
   return make2dThreePointArc(
     startPoint,
-    query.add2d(query.scalarMultiply2d(midChordDir, orientedRadius), center),
+    helpers.add2d(helpers.scalarMultiply2d(midChordDir, orientedRadius), center),
     endPoint
   );
 };
@@ -1021,7 +1102,7 @@ class Blueprint {
     const originPoint = origin || [...faceFns.faceCenter(face)];
     const originVec3 = occtBoundary.toVec3(originPoint);
     const sketch = this.translate(faceFns.uvCoordinates(face, originVec3)).sketchOnFace(face, "original");
-    return errors.unwrap(shapeHelpers.makeFace(sketch.wire));
+    return errors.unwrap(makeFace(sketch.wire));
   }
   /**
    * Cut a prism-shaped hole through a solid along a face using this blueprint.
@@ -1041,7 +1122,7 @@ class Blueprint {
   } = {}) {
     const oc = occtBoundary.getKernel().oc;
     const gc = shapeTypes.gcWithScope();
-    const foundFace = errors.unwrap(query.getSingleFace(face, shape));
+    const foundFace = errors.unwrap(helpers.getSingleFace(face, shape));
     const hole = this.subFace(foundFace, origin);
     const maker = gc(
       new oc.BRepFeat_MakeDPrism_1(
@@ -1133,7 +1214,7 @@ class Blueprint {
   }
   /** Check whether the first and last points coincide (the profile is closed). */
   isClosed() {
-    return query.samePoint(this.firstPoint, this.lastPoint);
+    return helpers.samePoint(this.firstPoint, this.lastPoint);
   }
   /**
    * Test whether this blueprint's curves intersect with another blueprint's curves.
@@ -1161,6 +1242,7 @@ class Blueprint {
 exports.Blueprint = Blueprint;
 exports.BoundingBox2d = BoundingBox2d;
 exports.Curve2D = Curve2D;
+exports.addHolesInFace = addHolesInFace;
 exports.approximateAsBSpline = approximateAsBSpline;
 exports.approximateAsSvgCompatibleCurve = approximateAsSvgCompatibleCurve;
 exports.asSVG = asSVG;
@@ -1177,7 +1259,12 @@ exports.make2dInerpolatedBSplineCurve = make2dInerpolatedBSplineCurve;
 exports.make2dSegmentCurve = make2dSegmentCurve;
 exports.make2dTangentArc = make2dTangentArc;
 exports.make2dThreePointArc = make2dThreePointArc;
+exports.makeFace = makeFace;
+exports.makeNewFaceWithinFace = makeNewFaceWithinFace;
+exports.makeNonPlanarFace = makeNonPlanarFace;
 exports.makePlane = makePlane;
+exports.makePolygon = makePolygon;
 exports.mirror = mirror;
 exports.removeDuplicatePoints = removeDuplicatePoints;
 exports.viewbox = viewbox;
+exports.zip = zip;