brepjs 8.0.0 → 8.0.2

package/dist/{boolean2D-hOw5Qay5.js → boolean2D-_WiqPxWZ.js}

@@ -1,16 +1,16 @@
-import { a as createPlane } from "./vectors-CBuaMeZv.js";
-import { o as makeFace, u as makeNewFaceWithinFace, a as assembleWire, z as zip } from "./shapeHelpers-BcoZf2N9.js";
+import { a as createPlane } from "./vectors-BVgXsYWl.js";
 import { l as ok, e as err, b as computationError, u as unwrap, g as isOk } from "./errors-wGhcJMpB.js";
-import { d as downcast } from "./cast-DQaUibmm.js";
-import { g as getKernel, a as toVec3 } from "./occtBoundary-CwegMzqc.js";
+import { d as downcast } from "./cast-C4Ff_1Qe.js";
+import { g as getKernel, a as toVec3 } from "./occtBoundary-CqXvDhZY.js";
 import { n as vecScale, j as vecNormalize, b as vecCross, D as DEG2RAD, R as RAD2DEG } from "./vecOps-ZDdZWbwT.js";
-import { r as revolution, c as complexExtrude, t as twistExtrude, b as basicFaceExtrusion, g as genericSweep, l as loft } from "./loft-CtG5nMq5.js";
-import { n as gcWithScope, q as createFace, s as createWire, o as localGC, t as createEdge } from "./shapeTypes-BlSElW8z.js";
-import { e as curveStartPoint, a as curveTangentAt, c as curveIsClosed } from "./curveFns-CdVE4da7.js";
-import { u as uvBounds, p as pointOnSurface, n as normalAt } from "./faceFns-DHu-2JpA.js";
+import { r as revolution, k as complexExtrude, t as twistExtrude, i as basicFaceExtrusion, j as genericSweep, l as loft } from "./loft-Bk9EM0gZ.js";
+import { p as gcWithScope, u as createFace, n as createWire, t as localGC, o as createEdge } from "./shapeTypes-C9sUsmEW.js";
+import { e as curveStartPoint, a as curveTangentAt, c as curveIsClosed } from "./curveFns-BshHA9Ys.js";
+import { C as Curve2D, i as make2dSegmentCurve, r as approximateAsBSpline, j as make2dArcFromCenter, s as isPoint2D, o as make2dCircle, t as make2dThreePointArc, e as BoundingBox2d, v as viewbox, u as asSVG, B as Blueprint, m as makeFace, d as makeNewFaceWithinFace, w as make2dEllipseArc, x as make2dTangentArc, y as make2dBezierCurve, f as axis2d, z as zip, A as removeDuplicatePoints } from "./Blueprint-B9fhnpFp.js";
+import { u as uvBounds, p as pointOnSurface, n as normalAt } from "./faceFns-DDzCECn3.js";
 import { bug } from "./result.js";
-import { s as samePoint$1, n as normalize2d, a as subtract2d, b as add2d, d as crossProduct2d, h as scalarMultiply2d, p as polarToCartesian, i as distance2d, r as rotate2d, j as cartesianToPolar, k as polarAngle2d, P as PRECISION_INTERSECTION } from "./query-V6nV-VfL.js";
-import { C as Curve2D, c as make2dSegmentCurve, d as approximateAsBSpline, i as isPoint2D, e as make2dCircle, f as make2dThreePointArc, g as make2dArcFromCenter, a as BoundingBox2d, v as viewbox, h as asSVG, B as Blueprint, j as make2dTangentArc, k as make2dEllipseArc, l as make2dBezierCurve, b as axis2d, r as removeDuplicatePoints } from "./Blueprint-D3JfGJTz.js";
+import { s as samePoint$1, n as normalize2d, h as subtract2d, i as add2d, j as crossProduct2d, k as scalarMultiply2d, b as polarToCartesian, r as rotate2d, l as cartesianToPolar, d as distance2d, p as polarAngle2d, m as PRECISION_INTERSECTION } from "./helpers-jku2V1DY.js";
+import { a as assembleWire } from "./curveBuilders-CBlIWlbU.js";
 function* pointsIteration(intersector) {
   const nPoints = intersector.NbPoints();
   if (!nPoints) return;
@@ -1220,9 +1220,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 * DEG2RAD;
+  const convertAxis = (ax) => distance2d(convertToUV(ax));
+  const r1 = convertAxis(polarToCartesian(majorRadius, radRotationAngle));
+  const r2 = convertAxis(polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
+  const xDir = normalize2d(convertToUV(rotate2d([1, 0], radRotationAngle)));
+  const [, newRotationAngle] = cartesianToPolar(xDir);
+  const { cx, cy, startAngle, endAngle, clockwise, rx, ry } = convertSvgEllipseParams(
+    startUV,
+    endUV,
+    r1,
+    r2,
+    newRotationAngle,
+    longAxis,
+    sweep
+  );
+  const arc = 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 {
@@ -1236,12 +1284,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) 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
    *
@@ -1260,11 +1333,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 * RAD2DEG;
+    return Math.atan2(dy, dx) * RAD2DEG;
   }
   /** Move the pen to an absolute 2D position before drawing any curves. */
   movePointerTo(point) {
@@ -1285,16 +1357,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 = 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) {
@@ -1314,41 +1385,35 @@ class BaseSketcher2d {
   }
   /** Draw a line to a point given in polar coordinates [r, theta] from the origin. */
   polarLineTo([r, theta]) {
-    const angleInRads = theta * DEG2RAD;
-    const point = polarToCartesian(r, angleInRads);
-    return this.lineTo(point);
+    return this.lineTo(polarToCartesian(r, theta * DEG2RAD));
   }
   /** Draw a line in polar coordinates (distance and angle in degrees) from the current point. */
   polarLine(distance, angle) {
-    const angleInRads = angle * DEG2RAD;
-    const [x, y] = polarToCartesian(distance, angleInRads);
+    const [x, y] = polarToCartesian(distance, angle * 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)
-      bug("Sketcher2d.tangentLine", "You need a previous curve to sketch a tangent line");
+    const previousCurve = this._requireLastCurve("Sketcher2d.tangentLine", "sketch a tangent line");
     const direction = 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(
-      make2dThreePointArc(
-        this._convertToUV(this.pointer),
-        this._convertToUV(midPoint),
-        this._convertToUV(end)
-      )
+    const curve = 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;
@@ -1365,19 +1430,16 @@ class BaseSketcher2d {
       midX + sagDirX / sagDirLen * sagitta,
       midY + sagDirY / sagDirLen * sagitta
     ];
-    this.saveCurve(
-      make2dThreePointArc(
-        this._convertToUV(this.pointer),
-        this._convertToUV(sagPoint),
-        this._convertToUV(end)
-      )
+    const curve = 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) {
@@ -1387,16 +1449,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 = distance2d(this.pointer, end) / 2;
-    const bulgeAsSagitta = -bulge * halfChord;
-    return this.sagittaArcTo(end, bulgeAsSagitta);
+    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) {
@@ -1406,71 +1468,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)
-      bug("Sketcher2d.tangentArc", "You need a previous curve to sketch a tangent arc");
-    this.saveCurve(
-      make2dTangentArc(
-        this._convertToUV(this.pointer),
-        previousCurve.tangentAt(1),
-        this._convertToUV(end)
-      )
+    const previousCurve = this._requireLastCurve("Sketcher2d.tangentArc", "sketch a tangent arc");
+    const curve = 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 * DEG2RAD;
-    const convertAxis = (ax) => distance2d(this._convertToUV(ax));
-    const r1 = convertAxis(polarToCartesian(majorRadius, radRotationAngle));
-    const r2 = convertAxis(polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
-    const xDir = normalize2d(this._convertToUV(rotate2d([1, 0], radRotationAngle)));
-    const [, newRotationAngle] = 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 = 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,
@@ -1486,26 +1522,18 @@ class BaseSketcher2d {
   }
   /** 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(
-      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 = 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) {
@@ -1515,10 +1543,11 @@ 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 previousCurve = this._lastCurve();
     const defaultDistance = distance2d(this.pointer, end) * 0.25;
     let startPoleDirection;
     if (startTangent) {
@@ -1548,8 +1577,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.
    */
@@ -1567,6 +1597,7 @@ class BaseSketcher2d {
       bug("Sketcher2d._customCornerLastWithFirst", "Not enough curves to close and fillet");
     this.pendingCurves.push(...buildCornerFunction(radius, mode)(previousCurve, curve));
   }
+  // ── Close / mirror helpers ──
   _closeSketch() {
     if (!samePoint$1(this.pointer, this.firstPoint)) {
       this.lineTo(this.firstPoint);
@@ -1587,9 +1618,9 @@ class BaseSketcher2d {
       (c) => new 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;
   }
@@ -1758,77 +1789,100 @@ const roundedRectangleBlueprint = (width, height, r = 0) => {
   return sk.close();
 };
 const samePoint = (x, y) => samePoint$1(x, y, PRECISION_INTERSECTION);
-const curveMidPoint = (curve) => {
+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) {
+    bug("startOfSegment", "empty segment");
+  }
+  return first.firstPoint;
+}
+function endOfSegment(s) {
+  const last = s[s.length - 1];
+  if (last === void 0) {
+    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) {
-      bug("rotateToStartAtSegment", "Failed to rotate to segment start");
-    }
+    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 = [];
@@ -1842,73 +1896,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) {
-      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) {
+      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 } = unwrap(
+      const { intersections, commonSegments, commonSegmentsPoints } = unwrap(
         intersectCurves(thisCurve, otherCurve, 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 = removeDuplicatePoints(allIntersections, PRECISION_INTERSECTION);
-  if (!allIntersections.length || allIntersections.length === 1) return null;
-  const cutCurve = ([curve, intersections]) => {
-    if (!intersections.length) return [curve];
-    return curve.splitAt(intersections, PRECISION_INTERSECTION / 100);
+  return {
+    allIntersections: removeDuplicatePoints(allIntersections, PRECISION_INTERSECTION),
+    allCommonSegments,
+    firstCurvePoints,
+    secondCurvePoints
   };
-  let firstCurveSegments = zip([first.curves, firstCurvePoints]).flatMap(cutCurve);
-  let secondCurveSegments = zip([second.curves, secondCurvePoints]).flatMap(cutCurve);
+}
+function splitCurvesAtIntersections(curves, curvePoints) {
+  return zip([curves, curvePoints]).flatMap(
+    ([curve, intersections]) => {
+      if (intersections.length === 0) return [curve];
+      return curve.splitAt(intersections, 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);
   }
@@ -1918,130 +1984,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);
+  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 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) {
+        bug("blueprintsIntersectionSegments", "Mismatched segment counts between blueprints");
       }
-      return [firstSegment, secondSegment];
+      const currentStart = startOfSegment(first2);
+      const currentEnd = endOfSegment(first2);
+      if (isCommonSegmentMatch(commonSegmentsPoints, currentStart, currentEnd)) {
+        return [first2, "same"];
+      }
+      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 shiftedEndPoints = curves.map((c) => c.lastPoint);
+  const endPoints = shiftedEndPoints.slice(-1).concat(shiftedEndPoints.slice(0, -1));
   const discontinuities = zip([startPoints, endPoints]).map(([startPoint, endPoint], index) => {
-    if (!samePoint(startPoint, endPoint)) {
-      return index;
-    }
-    return null;
+    if (startPoint === void 0 || endPoint === void 0) return null;
+    return samePoint(startPoint, endPoint) ? null : index;
   }).filter((f) => f !== null);
-  if (!discontinuities.length) return [curves];
+  if (discontinuities.length === 0) return [curves];
   const paths = zip([discontinuities.slice(0, -1), discontinuities.slice(1)]).map(
-    ([start, end]) => {
-      return curves.slice(start, end);
-    }
+    ([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 result2 = handleSameSegment(firstSegment, segmentsIn, lastWasSame);
+      segmentsIn = result2.segmentsIn;
+      lastWasSame = result2.lastWasSame;
+      return result2.curves;
+    }
+    const result = selectSegments(
+      firstSegment,
+      secondSegment,
+      first,
+      second,
+      config,
+      segmentsIn,
+      lastWasSame
+    );
+    segmentsIn = result.segmentsIn;
+    lastWasSame = result.lastWasSame;
+    return result.curves;
   });
-  const paths = splitPaths(s).filter((b) => b.length).map((b) => new Blueprint(b));
+  const paths = splitPaths(assembledCurves).filter((b) => b.length > 0).map((b) => new 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 result = booleanOperation(first, second, {
     firstInside: "remove",
     secondInside: "remove"
@@ -2057,8 +2138,8 @@ const fuseBlueprints = (first, second) => {
     return first.clone();
   }
   return new Blueprints([first, second]);
-};
-const cutBlueprints = (first, second) => {
+}
+function cutBlueprints(first, second) {
   const result = booleanOperation(first, second, {
     firstInside: "remove",
     secondInside: "keep"
@@ -2074,8 +2155,8 @@ const cutBlueprints = (first, second) => {
     return new Blueprints([new CompoundBlueprint([first, second])]);
   }
   return first.clone();
-};
-const intersectBlueprints = (first, second) => {
+}
+function intersectBlueprints(first, second) {
   const result = booleanOperation(first, second, {
     firstInside: "keep",
     secondInside: "keep"
@@ -2091,7 +2172,7 @@ const intersectBlueprints = (first, second) => {
     return second.clone();
   }
   return null;
-};
+}
 const genericIntersects = (first, second) => {
   if (first instanceof Blueprint && second instanceof Blueprint) {
     let allIntersections = [];