brepjs 8.0.0 → 8.0.2

package/dist/{boolean2D-BdZATaHs.cjs → boolean2D-B1XrGVgx.cjs}

@@ -1,17 +1,17 @@
 "use strict";
-const vectors = require("./vectors-ChWEZPwy.cjs");
-const shapeHelpers = require("./shapeHelpers-B2SXz1p4.cjs");
+const vectors = require("./vectors-DK2hEKcI.cjs");
 const errors = require("./errors-DK1VAdP4.cjs");
-const cast = require("./cast-DkB0GKmQ.cjs");
-const occtBoundary = require("./occtBoundary-du8_ex-p.cjs");
+const cast = require("./cast-DIiyxDLo.cjs");
+const occtBoundary = require("./occtBoundary-6kQSl3cF.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const loft = require("./loft-BzWFokmC.cjs");
-const shapeTypes = require("./shapeTypes-DKhwEnUM.cjs");
-const curveFns = require("./curveFns-BilyYL_s.cjs");
-const faceFns = require("./faceFns-BwK7FP7N.cjs");
+const loft = require("./loft-DJXwxV_L.cjs");
+const shapeTypes = require("./shapeTypes-BJ3Hmskg.cjs");
+const curveFns = require("./curveFns-BrJDkaWi.cjs");
+const Blueprint = require("./Blueprint-VGbo3izk.cjs");
+const faceFns = require("./faceFns-NDRFeekj.cjs");
 const result = require("./result.cjs");
-const query = require("./query-hMSmOWJP.cjs");
-const Blueprint = require("./Blueprint-CVctc41Z.cjs");
+const helpers = require("./helpers-Ck8GJ58k.cjs");
+const curveBuilders = require("./curveBuilders-BUoFO1UG.cjs");
 function* pointsIteration(intersector) {
   const nPoints = intersector.NbPoints();
   if (!nPoints) return;
@@ -51,10 +51,10 @@ const intersectCurves = (first, second, precision = 1e-9) => {
   } catch (e) {
     return errors.err(errors.computationError("INTERSECTION_FAILED", "Intersections failed between curves", e));
   }
-  const segmentsAsPoints = commonSegments.filter((c) => query.samePoint(c.firstPoint, c.lastPoint, precision)).map((c) => c.firstPoint);
+  const segmentsAsPoints = commonSegments.filter((c) => helpers.samePoint(c.firstPoint, c.lastPoint, precision)).map((c) => c.firstPoint);
   if (segmentsAsPoints.length) {
     intersections.push(...segmentsAsPoints);
-    commonSegments = commonSegments.filter((c) => !query.samePoint(c.firstPoint, c.lastPoint, precision));
+    commonSegments = commonSegments.filter((c) => !helpers.samePoint(c.firstPoint, c.lastPoint, precision));
   }
   const commonSegmentsPoints = commonSegments.flatMap((c) => [c.firstPoint, c.lastPoint]);
   return errors.ok({ intersections, commonSegments, commonSegmentsPoints });
@@ -73,12 +73,12 @@ const selfIntersections = (curve, precision = 1e-9) => {
   return errors.ok(intersections);
 };
 const offsetEndPoints = (firstPoint, lastPoint, offset) => {
-  const tangent = query.normalize2d(query.subtract2d(lastPoint, firstPoint));
+  const tangent = helpers.normalize2d(helpers.subtract2d(lastPoint, firstPoint));
   const normal = [tangent[1], -tangent[0]];
   const offsetVec = [normal[0] * offset, normal[1] * offset];
   return {
-    firstPoint: query.add2d(firstPoint, offsetVec),
-    lastPoint: query.add2d(lastPoint, offsetVec)
+    firstPoint: helpers.add2d(firstPoint, offsetVec),
+    lastPoint: helpers.add2d(lastPoint, offsetVec)
   };
 };
 const make2dOffset = (curve, offset) => {
@@ -94,8 +94,8 @@ const make2dOffset = (curve, offset) => {
       const centerPos = r(circle.Location());
       const center = [centerPos.X(), centerPos.Y()];
       const offsetViaCenter = (point) => {
-        const [x, y] = query.normalize2d(query.subtract2d(point, center));
-        return query.add2d(point, [orientedOffset * x, orientedOffset * y]);
+        const [x, y] = helpers.normalize2d(helpers.subtract2d(point, center));
+        return helpers.add2d(point, [orientedOffset * x, orientedOffset * y]);
       };
       return {
         collapsed: true,
@@ -136,7 +136,7 @@ const make2dOffset = (curve, offset) => {
   return approximation;
 };
 function removeCorner(firstCurve, secondCurve, radius) {
-  const sinAngle = query.crossProduct2d(firstCurve.tangentAt(1), secondCurve.tangentAt(0));
+  const sinAngle = helpers.crossProduct2d(firstCurve.tangentAt(1), secondCurve.tangentAt(0));
   if (Math.abs(sinAngle) < 1e-10) return null;
   const orientationCorrection = sinAngle > 0 ? -1 : 1;
   const offset = Math.abs(radius) * orientationCorrection;
@@ -156,8 +156,8 @@ function removeCorner(firstCurve, secondCurve, radius) {
   const center = potentialCenter;
   const splitForFillet = (curve, offsetCurve) => {
     const [x, y] = offsetCurve.tangentAt(center);
-    const normal = query.normalize2d([-y, x]);
-    const splitPoint = query.add2d(center, query.scalarMultiply2d(normal, offset));
+    const normal = helpers.normalize2d([-y, x]);
+    const splitPoint = helpers.add2d(center, helpers.scalarMultiply2d(normal, offset));
     const splitParam = errors.unwrap(curve.parameter(splitPoint, 1e-6));
     return curve.splitAt([splitParam]);
   };
@@ -182,9 +182,9 @@ function chamferCurves(firstCurve, secondCurve, radius) {
   return [first, Blueprint.make2dSegmentCurve(first.lastPoint, second.firstPoint), second];
 }
 function dogboneFilletCurves(firstCurve, secondCurve, radius) {
-  const tgt1 = query.normalize2d(firstCurve.tangentAt(1));
-  const tgt2 = query.normalize2d(secondCurve.tangentAt(0));
-  const sinAngle = query.crossProduct2d(tgt1, tgt2);
+  const tgt1 = helpers.normalize2d(firstCurve.tangentAt(1));
+  const tgt2 = helpers.normalize2d(secondCurve.tangentAt(0));
+  const sinAngle = helpers.crossProduct2d(tgt1, tgt2);
   const a = Math.asin(sinAngle);
   if (Math.abs(sinAngle) < 1e-10) return [firstCurve, secondCurve];
   const orientationCorrection = sinAngle > 0 ? -1 : 1;
@@ -997,9 +997,9 @@ class Sketch {
   face() {
     let face;
     if (!this.baseFace) {
-      face = errors.unwrap(shapeHelpers.makeFace(this.wire));
+      face = errors.unwrap(Blueprint.makeFace(this.wire));
     } else {
-      face = shapeHelpers.makeNewFaceWithinFace(this.baseFace, this.wire);
+      face = Blueprint.makeNewFaceWithinFace(this.baseFace, this.wire);
     }
     return face;
   }
@@ -1016,7 +1016,7 @@ class Sketch {
    * (defaults to the sketch origin)
    */
   revolve(revolutionAxis, { origin } = {}) {
-    const face = errors.unwrap(shapeHelpers.makeFace(this.wire));
+    const face = errors.unwrap(Blueprint.makeFace(this.wire));
     const solid = errors.unwrap(loft.revolution(face, origin || this.defaultOrigin, revolutionAxis));
     face.delete();
     this.delete();
@@ -1058,7 +1058,7 @@ class Sketch {
       this.delete();
       return solid2;
     }
-    const face = errors.unwrap(shapeHelpers.makeFace(this.wire));
+    const face = errors.unwrap(Blueprint.makeFace(this.wire));
     const solid = loft.basicFaceExtrusion(face, [...extrusionVec]);
     gc();
     this.delete();
@@ -1124,13 +1124,13 @@ const defaultsSplineOptions = (config) => {
   const { endTangent: endTgt, startFactor = 1, endFactor = 1, startTangent: startTgt } = conf;
   let endTangent;
   if (typeof endTgt === "number") {
-    endTangent = query.polarToCartesian(1, endTgt * vecOps.DEG2RAD);
+    endTangent = helpers.polarToCartesian(1, endTgt * vecOps.DEG2RAD);
   } else {
     endTangent = endTgt;
   }
   let startTangent;
   if (typeof startTgt === "number") {
-    startTangent = query.polarToCartesian(1, startTgt * vecOps.DEG2RAD);
+    startTangent = helpers.polarToCartesian(1, startTgt * vecOps.DEG2RAD);
   } else {
     startTangent = startTgt;
   }
@@ -1221,9 +1221,57 @@ function convertSvgEllipseParams([x1, y1], [x2, y2], rx, ry, phi, fA, fS) {
   };
   return outputObj;
 }
+function normalizeEllipseRadii(horizontalRadius, verticalRadius, rotation) {
+  if (horizontalRadius < verticalRadius) {
+    return {
+      majorRadius: verticalRadius,
+      minorRadius: horizontalRadius,
+      rotationAngle: rotation + 90
+    };
+  }
+  return {
+    majorRadius: horizontalRadius,
+    minorRadius: verticalRadius,
+    rotationAngle: rotation
+  };
+}
+function makeEllipseArcFromSvgParams(startUV, endUV, majorRadius, minorRadius, rotationAngleDeg, longAxis, sweep, convertToUV) {
+  const radRotationAngle = rotationAngleDeg * vecOps.DEG2RAD;
+  const convertAxis = (ax) => helpers.distance2d(convertToUV(ax));
+  const r1 = convertAxis(helpers.polarToCartesian(majorRadius, radRotationAngle));
+  const r2 = convertAxis(helpers.polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
+  const xDir = helpers.normalize2d(convertToUV(helpers.rotate2d([1, 0], radRotationAngle)));
+  const [, newRotationAngle] = helpers.cartesianToPolar(xDir);
+  const { cx, cy, startAngle, endAngle, clockwise, rx, ry } = convertSvgEllipseParams(
+    startUV,
+    endUV,
+    r1,
+    r2,
+    newRotationAngle,
+    longAxis,
+    sweep
+  );
+  const arc = Blueprint.make2dEllipseArc(
+    rx,
+    ry,
+    clockwise ? startAngle : endAngle,
+    clockwise ? endAngle : startAngle,
+    [cx, cy],
+    xDir
+  );
+  if (!clockwise) {
+    arc.reverse();
+  }
+  return arc;
+}
+const cornerModeFns = {
+  chamfer: chamferCurves,
+  dogbone: dogboneFilletCurves,
+  fillet: filletCurves
+};
 function buildCornerFunction(radius, mode) {
   if (typeof radius === "function") return radius;
-  const makeFn = mode === "chamfer" ? chamferCurves : mode === "dogbone" ? dogboneFilletCurves : filletCurves;
+  const makeFn = cornerModeFns[mode];
   return (first, second) => makeFn(first, second, radius);
 }
 class BaseSketcher2d {
@@ -1237,12 +1285,37 @@ class BaseSketcher2d {
     this._nextCorner = null;
     this.pendingCurves = [];
   }
+  // ── Coordinate conversion (overridden by FaceSketcher for UV mapping) ──
   _convertToUV([x, y]) {
     return [x, y];
   }
   _convertFromUV([u, v]) {
     return [u, v];
   }
+  // ── Internal helpers ──
+  /** Return the last curve in the pending list, or null if empty. */
+  _lastCurve() {
+    const len = this.pendingCurves.length;
+    if (len === 0) return null;
+    return this.pendingCurves[len - 1];
+  }
+  /** Require that a previous curve exists, returning it or throwing. */
+  _requireLastCurve(caller, action) {
+    const curve = this._lastCurve();
+    if (!curve) result.bug(caller, `You need a previous curve to ${action}`);
+    return curve;
+  }
+  /** Resolve a relative offset from the current pointer position. */
+  _resolveRelative(xDist, yDist) {
+    return [this.pointer[0] + xDist, this.pointer[1] + yDist];
+  }
+  /** Save a curve, advance the pointer to the given end point, and return `this`. */
+  _saveCurveAndAdvance(curve, end) {
+    this.saveCurve(curve);
+    this.pointer = end;
+    return this;
+  }
+  // ── Drawing state ──
   /**
    * Returns the current pen position as [x, y] coordinates
    *
@@ -1261,11 +1334,10 @@ class BaseSketcher2d {
    * @category Drawing State
    */
   get penAngle() {
-    if (this.pendingCurves.length === 0) return 0;
-    const lastCurve = this.pendingCurves[this.pendingCurves.length - 1];
+    const lastCurve = this._lastCurve();
+    if (!lastCurve) return 0;
     const [dx, dy] = lastCurve.tangentAt(1);
-    const angleInRadians = Math.atan2(dy, dx);
-    return angleInRadians * vecOps.RAD2DEG;
+    return Math.atan2(dy, dx) * vecOps.RAD2DEG;
   }
   /** Move the pen to an absolute 2D position before drawing any curves. */
   movePointerTo(point) {
@@ -1286,16 +1358,15 @@ class BaseSketcher2d {
     this.pendingCurves.push(...this._nextCorner(previousCurve, curve));
     this._nextCorner = null;
   }
+  // ── Line segments ──
   /** Draw a straight line to an absolute 2D point. */
   lineTo(point) {
     const curve = Blueprint.make2dSegmentCurve(this._convertToUV(this.pointer), this._convertToUV(point));
-    this.pointer = point;
-    this.saveCurve(curve);
-    return this;
+    return this._saveCurveAndAdvance(curve, point);
   }
   /** Draw a straight line by relative horizontal and vertical distances. */
   line(xDist, yDist) {
-    return this.lineTo([this.pointer[0] + xDist, this.pointer[1] + yDist]);
+    return this.lineTo(this._resolveRelative(xDist, yDist));
   }
   /** Draw a vertical line of the given signed distance. */
   vLine(distance) {
@@ -1315,41 +1386,35 @@ class BaseSketcher2d {
   }
   /** 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);
-    return this.lineTo(point);
+    return this.lineTo(helpers.polarToCartesian(r, theta * vecOps.DEG2RAD));
   }
   /** 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, angle * vecOps.DEG2RAD);
     return this.line(x, y);
   }
   /** Draw a line tangent to the previous curve, extending by the given distance. */
   tangentLine(distance) {
-    const previousCurve = this.pendingCurves.length ? this.pendingCurves[this.pendingCurves.length - 1] : null;
-    if (!previousCurve)
-      result.bug("Sketcher2d.tangentLine", "You need a previous curve to sketch a tangent line");
-    const direction = query.normalize2d(this._convertFromUV(previousCurve.tangentAt(1)));
+    const previousCurve = this._requireLastCurve("Sketcher2d.tangentLine", "sketch a tangent line");
+    const direction = helpers.normalize2d(this._convertFromUV(previousCurve.tangentAt(1)));
     return this.line(direction[0] * distance, direction[1] * distance);
   }
+  // ── Three-point arcs ──
   /** Draw a circular arc passing through a mid-point to an absolute end point. */
   threePointsArcTo(end, midPoint) {
-    this.saveCurve(
-      Blueprint.make2dThreePointArc(
-        this._convertToUV(this.pointer),
-        this._convertToUV(midPoint),
-        this._convertToUV(end)
-      )
+    const curve = Blueprint.make2dThreePointArc(
+      this._convertToUV(this.pointer),
+      this._convertToUV(midPoint),
+      this._convertToUV(end)
     );
-    this.pointer = end;
-    return this;
+    return this._saveCurveAndAdvance(curve, end);
   }
   /** Draw a circular arc through a via-point to an end point, both as relative distances. */
   threePointsArc(xDist, yDist, viaXDist, viaYDist) {
     const [x0, y0] = this.pointer;
     return this.threePointsArcTo([x0 + xDist, y0 + yDist], [x0 + viaXDist, y0 + viaYDist]);
   }
+  // ── Sagitta arcs ──
   /** Draw a circular arc to an absolute end point, bulging by the given sagitta. */
   sagittaArcTo(end, sagitta) {
     const [x0, y0] = this.pointer;
@@ -1366,19 +1431,16 @@ class BaseSketcher2d {
       midX + sagDirX / sagDirLen * sagitta,
       midY + sagDirY / sagDirLen * sagitta
     ];
-    this.saveCurve(
-      Blueprint.make2dThreePointArc(
-        this._convertToUV(this.pointer),
-        this._convertToUV(sagPoint),
-        this._convertToUV(end)
-      )
+    const curve = Blueprint.make2dThreePointArc(
+      this._convertToUV(this.pointer),
+      this._convertToUV(sagPoint),
+      this._convertToUV(end)
     );
-    this.pointer = end;
-    return this;
+    return this._saveCurveAndAdvance(curve, end);
   }
   /** Draw a circular arc to a relative end point, bulging by the given sagitta. */
   sagittaArc(xDist, yDist, sagitta) {
-    return this.sagittaArcTo([xDist + this.pointer[0], yDist + this.pointer[1]], sagitta);
+    return this.sagittaArcTo(this._resolveRelative(xDist, yDist), sagitta);
   }
   /** Draw a vertical sagitta arc of the given distance and bulge. */
   vSagittaArc(distance, sagitta) {
@@ -1388,16 +1450,16 @@ class BaseSketcher2d {
   hSagittaArc(distance, sagitta) {
     return this.sagittaArc(distance, 0, sagitta);
   }
+  // ── Bulge arcs ──
   /** Draw an arc to an absolute end point using a bulge factor (sagitta as fraction of half-chord). */
   bulgeArcTo(end, bulge) {
     if (!bulge) return this.lineTo(end);
-    const halfChord = query.distance2d(this.pointer, end) / 2;
-    const bulgeAsSagitta = -bulge * halfChord;
-    return this.sagittaArcTo(end, bulgeAsSagitta);
+    const halfChord = helpers.distance2d(this.pointer, end) / 2;
+    return this.sagittaArcTo(end, -bulge * halfChord);
   }
   /** Draw an arc to a relative end point using a bulge factor. */
   bulgeArc(xDist, yDist, bulge) {
-    return this.bulgeArcTo([xDist + this.pointer[0], yDist + this.pointer[1]], bulge);
+    return this.bulgeArcTo(this._resolveRelative(xDist, yDist), bulge);
   }
   /** Draw a vertical bulge arc of the given distance and bulge factor. */
   vBulgeArc(distance, bulge) {
@@ -1407,71 +1469,45 @@ class BaseSketcher2d {
   hBulgeArc(distance, bulge) {
     return this.bulgeArc(distance, 0, bulge);
   }
+  // ── Tangent arcs ──
   /** Draw a circular arc tangent to the previous curve, ending at an absolute point. */
   tangentArcTo(end) {
-    const previousCurve = this.pendingCurves.length ? this.pendingCurves[this.pendingCurves.length - 1] : null;
-    if (!previousCurve)
-      result.bug("Sketcher2d.tangentArc", "You need a previous curve to sketch a tangent arc");
-    this.saveCurve(
-      Blueprint.make2dTangentArc(
-        this._convertToUV(this.pointer),
-        previousCurve.tangentAt(1),
-        this._convertToUV(end)
-      )
+    const previousCurve = this._requireLastCurve("Sketcher2d.tangentArc", "sketch a tangent arc");
+    const curve = Blueprint.make2dTangentArc(
+      this._convertToUV(this.pointer),
+      previousCurve.tangentAt(1),
+      this._convertToUV(end)
     );
-    this.pointer = end;
-    return this;
+    return this._saveCurveAndAdvance(curve, end);
   }
   /** Draw a circular arc tangent to the previous curve, ending at a relative offset. */
   tangentArc(xDist, yDist) {
-    const [x0, y0] = this.pointer;
-    return this.tangentArcTo([xDist + x0, yDist + y0]);
+    return this.tangentArcTo(this._resolveRelative(xDist, yDist));
   }
+  // ── Ellipse arcs ──
   /** Draw an elliptical arc to an absolute end point (SVG-style parameters). */
   ellipseTo(end, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep = false) {
-    let rotationAngle = rotation;
-    let majorRadius = horizontalRadius;
-    let minorRadius = verticalRadius;
-    if (horizontalRadius < verticalRadius) {
-      rotationAngle = rotation + 90;
-      majorRadius = verticalRadius;
-      minorRadius = horizontalRadius;
-    }
-    const radRotationAngle = rotationAngle * vecOps.DEG2RAD;
-    const convertAxis = (ax) => query.distance2d(this._convertToUV(ax));
-    const r1 = convertAxis(query.polarToCartesian(majorRadius, radRotationAngle));
-    const r2 = convertAxis(query.polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
-    const xDir = query.normalize2d(this._convertToUV(query.rotate2d([1, 0], radRotationAngle)));
-    const [, newRotationAngle] = query.cartesianToPolar(xDir);
-    const { cx, cy, startAngle, endAngle, clockwise, rx, ry } = convertSvgEllipseParams(
+    const { majorRadius, minorRadius, rotationAngle } = normalizeEllipseRadii(
+      horizontalRadius,
+      verticalRadius,
+      rotation
+    );
+    const arc = makeEllipseArcFromSvgParams(
       this._convertToUV(this.pointer),
       this._convertToUV(end),
-      r1,
-      r2,
-      newRotationAngle,
+      majorRadius,
+      minorRadius,
+      rotationAngle,
       longAxis,
-      sweep
-    );
-    const arc = Blueprint.make2dEllipseArc(
-      rx,
-      ry,
-      clockwise ? startAngle : endAngle,
-      clockwise ? endAngle : startAngle,
-      [cx, cy],
-      xDir
+      sweep,
+      (p) => this._convertToUV(p)
     );
-    if (!clockwise) {
-      arc.reverse();
-    }
-    this.saveCurve(arc);
-    this.pointer = end;
-    return this;
+    return this._saveCurveAndAdvance(arc, end);
   }
   /** Draw an elliptical arc to a relative end point (SVG-style parameters). */
   ellipse(xDist, yDist, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep = false) {
-    const [x0, y0] = this.pointer;
     return this.ellipseTo(
-      [xDist + x0, yDist + y0],
+      this._resolveRelative(xDist, yDist),
       horizontalRadius,
       verticalRadius,
       rotation,
@@ -1481,32 +1517,24 @@ class BaseSketcher2d {
   }
   /** Draw a half-ellipse arc to an absolute end point with a given minor radius. */
   halfEllipseTo(end, minorRadius, sweep = false) {
-    const angle = query.polarAngle2d(end, this.pointer);
-    const dist = query.distance2d(end, this.pointer);
+    const angle = helpers.polarAngle2d(end, this.pointer);
+    const dist = helpers.distance2d(end, this.pointer);
     return this.ellipseTo(end, dist / 2, minorRadius, angle * vecOps.RAD2DEG, true, sweep);
   }
   /** Draw a half-ellipse arc to a relative end point with a given minor radius. */
   halfEllipse(xDist, yDist, minorRadius, sweep = false) {
-    const [x0, y0] = this.pointer;
-    return this.halfEllipseTo([x0 + xDist, y0 + yDist], minorRadius, sweep);
+    return this.halfEllipseTo(this._resolveRelative(xDist, yDist), minorRadius, sweep);
   }
+  // ── Bezier curves ──
   /** Draw a Bezier curve to an absolute end point through one or more control points. */
   bezierCurveTo(end, controlPoints) {
-    let cp;
-    if (controlPoints.length === 2 && !Array.isArray(controlPoints[0])) {
-      cp = [controlPoints];
-    } else {
-      cp = controlPoints;
-    }
-    this.saveCurve(
-      Blueprint.make2dBezierCurve(
-        this._convertToUV(this.pointer),
-        cp.map((point) => this._convertToUV(point)),
-        this._convertToUV(end)
-      )
+    const cp = controlPoints.length === 2 && !Array.isArray(controlPoints[0]) ? [controlPoints] : controlPoints;
+    const curve = Blueprint.make2dBezierCurve(
+      this._convertToUV(this.pointer),
+      cp.map((point) => this._convertToUV(point)),
+      this._convertToUV(end)
     );
-    this.pointer = end;
-    return this;
+    return this._saveCurveAndAdvance(curve, end);
   }
   /** Draw a quadratic Bezier curve to an absolute end point with a single control point. */
   quadraticBezierCurveTo(end, controlPoint) {
@@ -1516,11 +1544,12 @@ class BaseSketcher2d {
   cubicBezierCurveTo(end, startControlPoint, endControlPoint) {
     return this.bezierCurveTo(end, [startControlPoint, endControlPoint]);
   }
+  // ── Smooth splines ──
   /** Draw a smooth cubic Bezier spline to an absolute end point, blending tangent with the previous curve. */
   smoothSplineTo(end, config) {
     const { endTangent, startTangent, startFactor, endFactor } = defaultsSplineOptions(config);
-    const previousCurve = this.pendingCurves.length ? this.pendingCurves[this.pendingCurves.length - 1] : null;
-    const defaultDistance = query.distance2d(this.pointer, end) * 0.25;
+    const previousCurve = this._lastCurve();
+    const defaultDistance = helpers.distance2d(this.pointer, end) * 0.25;
     let startPoleDirection;
     if (startTangent) {
       startPoleDirection = startTangent;
@@ -1529,7 +1558,7 @@ class BaseSketcher2d {
     } else {
       startPoleDirection = this._convertFromUV(previousCurve.tangentAt(1));
     }
-    startPoleDirection = query.normalize2d(startPoleDirection);
+    startPoleDirection = helpers.normalize2d(startPoleDirection);
     const startControl = [
       this.pointer[0] + startPoleDirection[0] * startFactor * defaultDistance,
       this.pointer[1] + startPoleDirection[1] * startFactor * defaultDistance
@@ -1540,7 +1569,7 @@ class BaseSketcher2d {
     } else {
       endPoleDirection = endTangent;
     }
-    endPoleDirection = query.normalize2d(endPoleDirection);
+    endPoleDirection = helpers.normalize2d(endPoleDirection);
     const endControl = [
       end[0] - endPoleDirection[0] * endFactor * defaultDistance,
       end[1] - endPoleDirection[1] * endFactor * defaultDistance
@@ -1549,8 +1578,9 @@ class BaseSketcher2d {
   }
   /** Draw a smooth cubic Bezier spline to a relative end point, blending tangent with the previous curve. */
   smoothSpline(xDist, yDist, splineConfig) {
-    return this.smoothSplineTo([xDist + this.pointer[0], yDist + this.pointer[1]], splineConfig);
+    return this.smoothSplineTo(this._resolveRelative(xDist, yDist), splineConfig);
   }
+  // ── Corner treatments ──
   /**
    * Changes the corner between the previous and next segments.
    */
@@ -1568,13 +1598,14 @@ class BaseSketcher2d {
       result.bug("Sketcher2d._customCornerLastWithFirst", "Not enough curves to close and fillet");
     this.pendingCurves.push(...buildCornerFunction(radius, mode)(previousCurve, curve));
   }
+  // ── Close / mirror helpers ──
   _closeSketch() {
-    if (!query.samePoint(this.pointer, this.firstPoint)) {
+    if (!helpers.samePoint(this.pointer, this.firstPoint)) {
       this.lineTo(this.firstPoint);
     }
   }
   _closeWithMirror() {
-    if (query.samePoint(this.pointer, this.firstPoint))
+    if (helpers.samePoint(this.pointer, this.firstPoint))
       result.bug(
         "Sketcher2d._closeWithMirror",
         "Cannot close with a mirror when the sketch is already closed"
@@ -1588,9 +1619,9 @@ class BaseSketcher2d {
       (c) => new Blueprint.Curve2D(c.innerCurve.Mirrored_2(mirrorAxis))
     );
     mirroredCurves.reverse();
-    mirroredCurves.forEach((c) => {
+    for (const c of mirroredCurves) {
       c.reverse();
-    });
+    }
     this.pendingCurves.push(...mirroredCurves);
     this.pointer = this.firstPoint;
   }
@@ -1625,7 +1656,7 @@ class FaceSketcher extends BaseSketcher2d {
     const edges = this.pendingCurves.map((curve) => {
       return r(shapeTypes.createEdge(r(new oc.BRepBuilderAPI_MakeEdge_30(curve.wrapped, geomSurf)).Edge()));
     });
-    const wire = errors.unwrap(shapeHelpers.assembleWire(edges));
+    const wire = errors.unwrap(curveBuilders.assembleWire(edges));
     oc.BRepLib.BuildCurves3d_2(wire.wrapped);
     gc();
     return wire;
@@ -1758,78 +1789,101 @@ const roundedRectangleBlueprint = (width, height, r = 0) => {
   addFillet(rx, -ry);
   return sk.close();
 };
-const samePoint = (x, y) => query.samePoint(x, y, query.PRECISION_INTERSECTION);
-const curveMidPoint = (curve) => {
+const samePoint = (x, y) => helpers.samePoint(x, y, helpers.PRECISION_INTERSECTION);
+function hashPoint(p) {
+  return `${p[0].toFixed(9)},${p[1].toFixed(9)}`;
+}
+function hashSegment(first, last) {
+  const h1 = hashPoint(first);
+  const h2 = hashPoint(last);
+  return h1 < h2 ? `${h1}|${h2}` : `${h2}|${h1}`;
+}
+function startOfSegment(s) {
+  const first = s[0];
+  if (first === void 0) {
+    result.bug("startOfSegment", "empty segment");
+  }
+  return first.firstPoint;
+}
+function endOfSegment(s) {
+  const last = s[s.length - 1];
+  if (last === void 0) {
+    result.bug("endOfSegment", "empty segment");
+  }
+  return last.lastPoint;
+}
+function reverseSegment(segment) {
+  return [...segment].reverse().map((curve) => {
+    const newCurve = curve.clone();
+    newCurve.reverse();
+    return newCurve;
+  });
+}
+function reverseSegments(segments) {
+  return [...segments].reverse().map(reverseSegment);
+}
+function curveMidPoint(curve) {
   const midParameter = (curve.lastParameter + curve.firstParameter) / 2;
   return curve.value(midParameter);
-};
-const rotateToStartAt = (curves, point) => {
-  const pointHash = hashPoint(point);
-  let startIndex = -1;
+}
+function findCurveIndexByStartPoint(curves, point) {
+  const targetHash = hashPoint(point);
   for (let i = 0; i < curves.length; i++) {
     const curve = curves[i];
-    if (hashPoint(curve.firstPoint) === pointHash && samePoint(point, curve.firstPoint)) {
-      startIndex = i;
-      break;
+    if (curve === void 0) continue;
+    if (hashPoint(curve.firstPoint) === targetHash && samePoint(point, curve.firstPoint)) {
+      return i;
     }
   }
-  if (startIndex <= 0) return curves;
-  return curves.slice(startIndex).concat(curves.slice(0, startIndex));
-};
-const rotateToStartAtSegment = (curves, segment) => {
-  const segFirstHash = hashPoint(segment.firstPoint);
-  const segLastHash = hashPoint(segment.lastPoint);
-  const onSegment = (curve) => {
-    return samePoint(segment.firstPoint, curve.firstPoint) && samePoint(segment.lastPoint, curve.lastPoint);
-  };
-  let startIndex = -1;
+  return -1;
+}
+function findCurveIndexBySegment(curves, segFirstHash, segLastHash, matchesFn) {
   for (let i = 0; i < curves.length; i++) {
     const curve = curves[i];
-    if (hashPoint(curve.firstPoint) === segFirstHash && hashPoint(curve.lastPoint) === segLastHash && onSegment(curve)) {
-      startIndex = i;
-      break;
+    if (curve === void 0) continue;
+    if (hashPoint(curve.firstPoint) === segFirstHash && hashPoint(curve.lastPoint) === segLastHash && matchesFn(curve)) {
+      return i;
     }
   }
+  return -1;
+}
+function rotateArray(arr, startIndex) {
+  if (startIndex <= 0) return arr;
+  return arr.slice(startIndex).concat(arr.slice(0, startIndex));
+}
+function rotateToStartAt(curves, point) {
+  const startIndex = findCurveIndexByStartPoint(curves, point);
+  return rotateArray(curves, startIndex);
+}
+function rotateToStartAtSegment(curves, segment) {
+  const segFirstHash = hashPoint(segment.firstPoint);
+  const segLastHash = hashPoint(segment.lastPoint);
+  const onSegment = (curve) => samePoint(segment.firstPoint, curve.firstPoint) && samePoint(segment.lastPoint, curve.lastPoint);
+  let startIndex = findCurveIndexBySegment(curves, segFirstHash, segLastHash, onSegment);
+  if (startIndex !== -1) {
+    return rotateArray(curves, startIndex);
+  }
+  const reversed = reverseSegment(curves);
+  startIndex = findCurveIndexBySegment(reversed, segFirstHash, segLastHash, onSegment);
   if (startIndex === -1) {
-    curves = reverseSegment(curves);
-    for (let i = 0; i < curves.length; i++) {
-      const curve = curves[i];
-      if (hashPoint(curve.firstPoint) === segFirstHash && hashPoint(curve.lastPoint) === segLastHash && onSegment(curve)) {
-        startIndex = i;
-        break;
-      }
-    }
-    if (startIndex === -1) {
-      result.bug("rotateToStartAtSegment", "Failed to rotate to segment start");
-    }
+    result.bug("rotateToStartAtSegment", "failed to rotate to segment start");
   }
-  if (startIndex <= 0) return curves;
-  return curves.slice(startIndex).concat(curves.slice(0, startIndex));
-};
-const hashPoint = (p) => `${p[0].toFixed(9)},${p[1].toFixed(9)}`;
-const hashSegment = (first, last) => {
-  const h1 = hashPoint(first);
-  const h2 = hashPoint(last);
-  return h1 < h2 ? `${h1}|${h2}` : `${h2}|${h1}`;
-};
+  return rotateArray(reversed, startIndex);
+}
 function* createSegmentOnPoints(curves, allIntersections, allCommonSegments) {
   const intersectionSet = new Set(allIntersections.map(hashPoint));
   const commonSegmentSet = new Set(
     allCommonSegments.map((seg) => hashSegment(seg.firstPoint, seg.lastPoint))
   );
-  const endsAtIntersection = (curve) => {
-    return intersectionSet.has(hashPoint(curve.lastPoint));
-  };
-  const isCommonSegment = (curve) => {
-    return commonSegmentSet.has(hashSegment(curve.firstPoint, curve.lastPoint));
-  };
   let currentCurves = [];
   for (const curve of curves) {
-    if (endsAtIntersection(curve)) {
+    const endsAtIntersection = intersectionSet.has(hashPoint(curve.lastPoint));
+    const isCommon = commonSegmentSet.has(hashSegment(curve.firstPoint, curve.lastPoint));
+    if (endsAtIntersection) {
       currentCurves.push(curve);
       yield currentCurves;
       currentCurves = [];
-    } else if (isCommonSegment(curve)) {
+    } else if (isCommon) {
       if (currentCurves.length) {
         yield currentCurves;
         currentCurves = [];
@@ -1843,73 +1897,85 @@ function* createSegmentOnPoints(curves, allIntersections, allCommonSegments) {
     yield currentCurves;
   }
 }
-const startOfSegment = (s) => {
-  return s[0].firstPoint;
-};
-const endOfSegment = (s) => {
-  return s[s.length - 1].lastPoint;
-};
-const reverseSegment = (segment) => {
-  return [...segment].reverse().map((curve) => {
-    const newCurve = curve.clone();
-    newCurve.reverse();
-    return newCurve;
-  });
-};
-const reverseSegments = (s) => {
-  return [...s].reverse().map(reverseSegment);
-};
-function removeNonCrossingPoint(allIntersections, segmentedCurve, blueprintToCheck) {
+function removeNonCrossingPoints(allIntersections, segmentedCurve, blueprintToCheck) {
   return allIntersections.filter((intersection) => {
-    const segmentsOfIntersection = segmentedCurve.filter((s) => {
-      return samePoint(s.firstPoint, intersection) || samePoint(s.lastPoint, intersection);
-    });
-    if (segmentsOfIntersection.length % 2) {
-      result.bug("removeNonCrossingPoint", "Odd number of segments at intersection point (expected even)");
+    const touching = segmentedCurve.filter(
+      (s) => samePoint(s.firstPoint, intersection) || samePoint(s.lastPoint, intersection)
+    );
+    if (touching.length % 2) {
+      result.bug(
+        "removeNonCrossingPoints",
+        "Odd number of segments at intersection point (expected even)"
+      );
     }
-    const isInside = segmentsOfIntersection.map((segment) => {
-      return blueprintToCheck.isInside(curveMidPoint(segment));
-    });
-    const segmentsOnTheSameSide = isInside.every((i) => i) || !isInside.some((i) => i);
-    return !segmentsOnTheSameSide;
+    const insideFlags = touching.map(
+      (segment) => blueprintToCheck.isInside(curveMidPoint(segment))
+    );
+    const allSameSide = insideFlags.every(Boolean) || insideFlags.every((f) => !f);
+    return !allSameSide;
   });
 }
-function blueprintsIntersectionSegments(first, second) {
-  let allIntersections = [];
+function findAllIntersections(first, second) {
+  const allIntersections = [];
   const allCommonSegments = [];
-  const firstCurvePoints = new Array(first.curves.length).fill(0).map(() => []);
-  const secondCurvePoints = new Array(second.curves.length).fill(0).map(() => []);
+  const firstCurvePoints = first.curves.map(() => []);
+  const secondCurvePoints = second.curves.map(() => []);
   first.curves.forEach((thisCurve, firstIndex) => {
     second.curves.forEach((otherCurve, secondIndex) => {
-      const { intersections, commonSegments, commonSegmentsPoints: commonSegmentsPoints2 } = errors.unwrap(
-        intersectCurves(thisCurve, otherCurve, query.PRECISION_INTERSECTION / 100)
+      const { intersections, commonSegments, commonSegmentsPoints } = errors.unwrap(
+        intersectCurves(thisCurve, otherCurve, helpers.PRECISION_INTERSECTION / 100)
       );
       allIntersections.push(...intersections);
-      firstCurvePoints[firstIndex].push(...intersections);
-      secondCurvePoints[secondIndex].push(...intersections);
+      firstCurvePoints[firstIndex]?.push(...intersections);
+      secondCurvePoints[secondIndex]?.push(...intersections);
       allCommonSegments.push(...commonSegments);
-      allIntersections.push(...commonSegmentsPoints2);
-      firstCurvePoints[firstIndex].push(...commonSegmentsPoints2);
-      secondCurvePoints[secondIndex].push(...commonSegmentsPoints2);
+      allIntersections.push(...commonSegmentsPoints);
+      firstCurvePoints[firstIndex]?.push(...commonSegmentsPoints);
+      secondCurvePoints[secondIndex]?.push(...commonSegmentsPoints);
     });
   });
-  allIntersections = Blueprint.removeDuplicatePoints(allIntersections, query.PRECISION_INTERSECTION);
-  if (!allIntersections.length || allIntersections.length === 1) return null;
-  const cutCurve = ([curve, intersections]) => {
-    if (!intersections.length) return [curve];
-    return curve.splitAt(intersections, query.PRECISION_INTERSECTION / 100);
+  return {
+    allIntersections: Blueprint.removeDuplicatePoints(allIntersections, helpers.PRECISION_INTERSECTION),
+    allCommonSegments,
+    firstCurvePoints,
+    secondCurvePoints
   };
-  let firstCurveSegments = shapeHelpers.zip([first.curves, firstCurvePoints]).flatMap(cutCurve);
-  let secondCurveSegments = shapeHelpers.zip([second.curves, secondCurvePoints]).flatMap(cutCurve);
+}
+function splitCurvesAtIntersections(curves, curvePoints) {
+  return Blueprint.zip([curves, curvePoints]).flatMap(
+    ([curve, intersections]) => {
+      if (intersections.length === 0) return [curve];
+      return curve.splitAt(intersections, helpers.PRECISION_INTERSECTION / 100);
+    }
+  );
+}
+function isCommonSegmentMatch(commonSegmentsPoints, segmentStart, segmentEnd) {
+  return commonSegmentsPoints.some(([startPoint, endPoint]) => {
+    if (startPoint === void 0 || endPoint === void 0) return false;
+    return samePoint(startPoint, segmentStart) && samePoint(endPoint, segmentEnd) || samePoint(startPoint, segmentEnd) && samePoint(startPoint, segmentStart);
+  });
+}
+function blueprintsIntersectionSegments(first, second) {
+  const {
+    allIntersections: rawIntersections,
+    allCommonSegments,
+    firstCurvePoints,
+    secondCurvePoints
+  } = findAllIntersections(first, second);
+  if (rawIntersections.length <= 1) return null;
+  let firstCurveSegments = splitCurvesAtIntersections(first.curves, firstCurvePoints);
+  let secondCurveSegments = splitCurvesAtIntersections(second.curves, secondCurvePoints);
   const commonSegmentsPoints = allCommonSegments.map((c) => [c.firstPoint, c.lastPoint]);
-  allIntersections = removeNonCrossingPoint(allIntersections, firstCurveSegments, second);
-  if (!allIntersections.length && !allCommonSegments.length) return null;
-  if (!allCommonSegments.length) {
+  const allIntersections = removeNonCrossingPoints(rawIntersections, firstCurveSegments, second);
+  if (allIntersections.length === 0 && allCommonSegments.length === 0) return null;
+  if (allCommonSegments.length === 0) {
     const startAt = allIntersections[0];
+    if (startAt === void 0) return null;
     firstCurveSegments = rotateToStartAt(firstCurveSegments, startAt);
     secondCurveSegments = rotateToStartAt(secondCurveSegments, startAt);
   } else {
     const startSegment = allCommonSegments[0];
+    if (startSegment === void 0) return null;
     firstCurveSegments = rotateToStartAtSegment(firstCurveSegments, startSegment);
     secondCurveSegments = rotateToStartAtSegment(secondCurveSegments, startSegment);
   }
@@ -1919,130 +1985,145 @@ function blueprintsIntersectionSegments(first, second) {
   let secondIntersectedSegments = Array.from(
     createSegmentOnPoints(secondCurveSegments, allIntersections, allCommonSegments)
   );
-  if (!samePoint(
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    endOfSegment(secondIntersectedSegments[0]),
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    endOfSegment(firstIntersectedSegments[0])
-  ) || // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  allCommonSegments.length > 0 && secondIntersectedSegments[0].length !== 1) {
-    secondIntersectedSegments = reverseSegments(secondIntersectedSegments);
-  }
-  return shapeHelpers.zip([firstIntersectedSegments, secondIntersectedSegments]).map(
+  const firstSeg = firstIntersectedSegments[0];
+  const secondSeg = secondIntersectedSegments[0];
+  if (firstSeg !== void 0 && secondSeg !== void 0) {
+    const endpointsMismatch = !samePoint(endOfSegment(secondSeg), endOfSegment(firstSeg));
+    const commonSegmentLengthMismatch = allCommonSegments.length > 0 && secondSeg.length !== 1;
+    if (endpointsMismatch || commonSegmentLengthMismatch) {
+      secondIntersectedSegments = reverseSegments(secondIntersectedSegments);
+    }
+  }
+  return Blueprint.zip([firstIntersectedSegments, secondIntersectedSegments]).map(
     ([first2, second2]) => {
-      const firstSegment = first2;
-      const secondSegment = second2;
-      const currentStart = startOfSegment(firstSegment);
-      const currentEnd = endOfSegment(firstSegment);
-      if (commonSegmentsPoints.find(([startPoint, endPoint]) => {
-        return (
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          samePoint(startPoint, currentStart) && // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          samePoint(endPoint, currentEnd) || // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          samePoint(startPoint, currentEnd) && // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          samePoint(startPoint, currentStart)
-        );
-      })) {
-        return [firstSegment, "same"];
+      if (first2 === void 0 || second2 === void 0) {
+        result.bug("blueprintsIntersectionSegments", "Mismatched segment counts between blueprints");
+      }
+      const currentStart = startOfSegment(first2);
+      const currentEnd = endOfSegment(first2);
+      if (isCommonSegmentMatch(commonSegmentsPoints, currentStart, currentEnd)) {
+        return [first2, "same"];
       }
-      return [firstSegment, secondSegment];
+      return [first2, second2];
     }
   );
 }
-const splitPaths = (curves) => {
+function splitPaths(curves) {
   const startPoints = curves.map((c) => c.firstPoint);
-  let endPoints = curves.map((c) => c.lastPoint);
-  endPoints = endPoints.slice(-1).concat(endPoints.slice(0, -1));
-  const discontinuities = shapeHelpers.zip([startPoints, endPoints]).map(([startPoint, endPoint], index) => {
-    if (!samePoint(startPoint, endPoint)) {
-      return index;
-    }
-    return null;
+  const shiftedEndPoints = curves.map((c) => c.lastPoint);
+  const endPoints = shiftedEndPoints.slice(-1).concat(shiftedEndPoints.slice(0, -1));
+  const discontinuities = Blueprint.zip([startPoints, endPoints]).map(([startPoint, endPoint], index) => {
+    if (startPoint === void 0 || endPoint === void 0) return null;
+    return samePoint(startPoint, endPoint) ? null : index;
   }).filter((f) => f !== null);
-  if (!discontinuities.length) return [curves];
-  const paths = shapeHelpers.zip([discontinuities.slice(0, -1), discontinuities.slice(1)]).map(
-    ([start, end]) => {
-      return curves.slice(start, end);
-    }
+  if (discontinuities.length === 0) return [curves];
+  const paths = Blueprint.zip([discontinuities.slice(0, -1), discontinuities.slice(1)]).map(
+    ([start, end]) => curves.slice(start, end)
   );
   let lastPath = curves.slice(discontinuities[discontinuities.length - 1]);
-  if (discontinuities[0] !== 0) {
-    lastPath = lastPath.concat(curves.slice(0, discontinuities[0]));
+  const firstDiscontinuity = discontinuities[0];
+  if (firstDiscontinuity !== void 0 && firstDiscontinuity !== 0) {
+    lastPath = lastPath.concat(curves.slice(0, firstDiscontinuity));
   }
   paths.push(lastPath);
   return paths;
-};
-function booleanOperation(first, second, {
-  firstInside,
-  secondInside
-}) {
-  const segments = blueprintsIntersectionSegments(first, second);
-  if (!segments) {
-    const firstBlueprintPoint = curveMidPoint(first.curves[0]);
-    const firstCurveInSecond = second.isInside(firstBlueprintPoint);
-    const secondBlueprintPoint = curveMidPoint(second.curves[0]);
-    const secondCurveInFirst = first.isInside(secondBlueprintPoint);
-    return {
-      identical: false,
-      firstCurveInSecond,
-      secondCurveInFirst
-    };
+}
+function handleSameSegment(firstSegment, segmentsIn, lastWasSame) {
+  if (segmentsIn === 1) {
+    return { curves: [...firstSegment], segmentsIn: 1, lastWasSame: null };
   }
-  if (segments.every(([, secondSegment]) => secondSegment === "same")) {
-    return { identical: true };
+  if (segmentsIn === 2 || segmentsIn === 0) {
+    return { curves: [], segmentsIn: null, lastWasSame: null };
   }
-  let lastWasSame = null;
-  let segmentsIn = null;
-  const s = segments.flatMap(([firstSegment, secondSegment]) => {
-    let segments2 = [];
-    let segmentsOut = 0;
-    if (secondSegment === "same") {
-      if (segmentsIn === 1) {
-        segmentsIn = 1;
-        return [...firstSegment];
-      }
-      if (segmentsIn === 2 || segmentsIn === 0) {
-        segmentsIn = null;
-        return [];
-      }
-      if (segmentsIn === null) {
-        if (!lastWasSame) lastWasSame = firstSegment;
-        else lastWasSame = [...lastWasSame, ...firstSegment];
-        return [];
-      }
-      return [];
-    }
-    const firstSegmentPoint = curveMidPoint(firstSegment[0]);
-    const firstSegmentInSecondShape = second.isInside(firstSegmentPoint);
-    if (firstInside === "keep" && firstSegmentInSecondShape || firstInside === "remove" && !firstSegmentInSecondShape) {
+  if (segmentsIn === null) {
+    const accumulated = lastWasSame ? [...lastWasSame, ...firstSegment] : firstSegment;
+    return { curves: [], segmentsIn: null, lastWasSame: accumulated };
+  }
+  return { curves: [], segmentsIn, lastWasSame };
+}
+function selectSegments(firstSegment, secondSegment, first, second, config, segmentsIn, lastWasSame) {
+  let segments = [];
+  let segmentsOut = 0;
+  const firstCurve = firstSegment[0];
+  if (firstCurve !== void 0) {
+    const firstSegmentPoint = curveMidPoint(firstCurve);
+    const firstInSecond = second.isInside(firstSegmentPoint);
+    if (config.firstInside === "keep" && firstInSecond || config.firstInside === "remove" && !firstInSecond) {
       segmentsOut += 1;
-      segments2.push(...firstSegment);
+      segments.push(...firstSegment);
     }
-    const secondSegmentPoint = curveMidPoint(secondSegment[0]);
-    const secondSegmentInFirstShape = first.isInside(secondSegmentPoint);
-    if (secondInside === "keep" && secondSegmentInFirstShape || secondInside === "remove" && !secondSegmentInFirstShape) {
+  }
+  const secondCurve = secondSegment[0];
+  if (secondCurve !== void 0) {
+    const secondSegmentPoint = curveMidPoint(secondCurve);
+    const secondInFirst = first.isInside(secondSegmentPoint);
+    if (config.secondInside === "keep" && secondInFirst || config.secondInside === "remove" && !secondInFirst) {
       let segmentsToAdd = secondSegment;
       if (segmentsOut === 1) {
         segmentsToAdd = reverseSegment(secondSegment);
       }
       segmentsOut += 1;
-      segments2.push(...segmentsToAdd);
-    }
-    if (segmentsIn === null && segmentsOut === 1 && lastWasSame) {
-      segments2 = [...lastWasSame, ...segments2];
-    }
-    if (segmentsOut === 1) {
-      segmentsIn = segmentsOut;
-      lastWasSame = null;
+      segments.push(...segmentsToAdd);
     }
-    return segments2;
+  }
+  if (segmentsIn === null && segmentsOut === 1 && lastWasSame !== null) {
+    segments = [...lastWasSame, ...segments];
+  }
+  const newSegmentsIn = segmentsOut === 1 ? segmentsOut : segmentsIn;
+  const newLastWasSame = segmentsOut === 1 ? null : lastWasSame;
+  return { curves: segments, segmentsIn: newSegmentsIn, lastWasSame: newLastWasSame };
+}
+function booleanOperation(first, second, config) {
+  const segments = blueprintsIntersectionSegments(first, second);
+  if (segments === null) {
+    return buildNoIntersectionResult(first, second);
+  }
+  if (segments.every(([, secondSegment]) => secondSegment === "same")) {
+    return { identical: true };
+  }
+  let segmentsIn = null;
+  let lastWasSame = null;
+  const assembledCurves = segments.flatMap(([firstSegment, secondSegment]) => {
+    if (secondSegment === "same") {
+      const result22 = handleSameSegment(firstSegment, segmentsIn, lastWasSame);
+      segmentsIn = result22.segmentsIn;
+      lastWasSame = result22.lastWasSame;
+      return result22.curves;
+    }
+    const result2 = selectSegments(
+      firstSegment,
+      secondSegment,
+      first,
+      second,
+      config,
+      segmentsIn,
+      lastWasSame
+    );
+    segmentsIn = result2.segmentsIn;
+    lastWasSame = result2.lastWasSame;
+    return result2.curves;
   });
-  const paths = splitPaths(s).filter((b) => b.length).map((b) => new Blueprint.Blueprint(b));
+  const paths = splitPaths(assembledCurves).filter((b) => b.length > 0).map((b) => new Blueprint.Blueprint(b));
   if (paths.length === 0) return null;
-  if (paths.length === 1) return paths[0];
+  if (paths.length === 1) {
+    const single = paths[0];
+    if (single === void 0) return null;
+    return single;
+  }
   return organiseBlueprints(paths);
 }
-const fuseBlueprints = (first, second) => {
+function buildNoIntersectionResult(first, second) {
+  const firstCurve = first.curves[0];
+  const secondCurve = second.curves[0];
+  const firstCurveInSecond = firstCurve !== void 0 && second.isInside(curveMidPoint(firstCurve));
+  const secondCurveInFirst = secondCurve !== void 0 && first.isInside(curveMidPoint(secondCurve));
+  return {
+    identical: false,
+    firstCurveInSecond,
+    secondCurveInFirst
+  };
+}
+function fuseBlueprints(first, second) {
   const result2 = booleanOperation(first, second, {
     firstInside: "remove",
     secondInside: "remove"
@@ -2058,8 +2139,8 @@ const fuseBlueprints = (first, second) => {
     return first.clone();
   }
   return new Blueprints([first, second]);
-};
-const cutBlueprints = (first, second) => {
+}
+function cutBlueprints(first, second) {
   const result2 = booleanOperation(first, second, {
     firstInside: "remove",
     secondInside: "keep"
@@ -2075,8 +2156,8 @@ const cutBlueprints = (first, second) => {
     return new Blueprints([new CompoundBlueprint([first, second])]);
   }
   return first.clone();
-};
-const intersectBlueprints = (first, second) => {
+}
+function intersectBlueprints(first, second) {
   const result2 = booleanOperation(first, second, {
     firstInside: "keep",
     secondInside: "keep"
@@ -2092,7 +2173,7 @@ const intersectBlueprints = (first, second) => {
     return second.clone();
   }
   return null;
-};
+}
 const genericIntersects = (first, second) => {
   if (first instanceof Blueprint.Blueprint && second instanceof Blueprint.Blueprint) {
     let allIntersections = [];