brepjs 12.8.2 → 12.10.0

package/dist/{Blueprint-CQ28WJhz.cjs → Blueprint-BoC0DsDm.cjs}

@@ -1,41 +1,13 @@
 "use strict";
-const vectors = require("./vectors-D_IiZx0q.cjs");
+const vectors = require("./vectors-I_0zdD3O.cjs");
+const shapeTypes = require("./shapeTypes-T0n6mRmt.cjs");
+const faceFns = require("./faceFns-CmIrjdt1.cjs");
+const curveFns = require("./curveFns-CWZRuXQ3.cjs");
+const result = require("./result-DULetAht.cjs");
+const helpers = require("./helpers-mipaxDTy.cjs");
 const types = require("./types-CA_xrgDq.cjs");
-const shapeTypes = require("./shapeTypes-7xEam9Ri.cjs");
-const faceFns = require("./faceFns-DB1Fc5gy.cjs");
-const curveFns = require("./curveFns-BZngcnQ1.cjs");
-const result = require("./result-fAX0OZzI.cjs");
-const helpers = require("./helpers-C8NoT0Wu.cjs");
 const vecOps = require("./vecOps-CjRL1jau.cjs");
-const surfaceBuilders = require("./surfaceBuilders-5VA34a3_.cjs");
-function makePlane(plane, origin) {
-  if (plane && typeof plane !== "string") {
-    return { ...plane };
-  } else {
-    return vectors.resolvePlane(plane ?? "XY", origin);
-  }
-}
-function mirror(shape, inputPlane, origin) {
-  let originVec;
-  let directionVec;
-  if (typeof inputPlane === "string") {
-    const plane = vectors.resolvePlane(inputPlane, origin);
-    originVec = plane.origin;
-    directionVec = plane.zDir;
-  } else if (inputPlane && typeof inputPlane === "object" && "origin" in inputPlane && "zDir" in inputPlane) {
-    originVec = origin ? types.toVec3(origin) : inputPlane.origin;
-    directionVec = inputPlane.zDir;
-  } else if (inputPlane) {
-    originVec = origin ? types.toVec3(origin) : [0, 0, 0];
-    directionVec = types.toVec3(inputPlane);
-  } else {
-    const plane = vectors.resolvePlane("YZ", origin);
-    originVec = plane.origin;
-    directionVec = plane.zDir;
-  }
-  const newShape = shapeTypes.getKernel().mirror(shape, originVec, directionVec);
-  return newShape;
-}
+const surfaceBuilders = require("./surfaceBuilders-DYS8AMSS.cjs");
 function isPoint2D(point) {
   return Array.isArray(point) && point.length === 2 && typeof point[0] === "number" && typeof point[1] === "number";
 }
@@ -47,6 +19,9 @@ function precisionRound(number, precision) {
 function round2(v) {
   return Math.round(v * 100) / 100;
 }
+function round5(v) {
+  return Math.round(v * 1e5) / 1e5;
+}
 const reprPnt = ([x, y]) => {
   return `(${round2(x)},${round2(y)})`;
 };
@@ -138,12 +113,12 @@ class BoundingBox2d {
     return !shapeTypes.getKernel2D().isBBox2dOutPoint(this.wrapped, other[0], other[1]);
   }
 }
-const normalize2d = ([x0, y0]) => {
-  const l = helpers.distance2d([x0, y0]);
-  if (l < 1e-12) {
+const normalize2d = ([x, y]) => {
+  const result$1 = helpers.normalize2d([x, y]);
+  if (result$1[0] === 0 && result$1[1] === 0) {
     result.bug("normalize2d", "Cannot normalize zero-length vector");
   }
-  return [x0 / l, y0 / l];
+  return result$1;
 };
 function deserializeCurve2D(data) {
   return new Curve2D(shapeTypes.getKernel().deserializeCurve2d(data));
@@ -517,9 +492,6 @@ const make2dArcFromCenter = (startPoint, endPoint, center, longArc = false) => {
     endPoint
   );
 };
-function round5(v) {
-  return Math.round(v * 1e5) / 1e5;
-}
 const adaptedCurveToPathElem = (curve, lastPoint) => {
   const k2d = shapeTypes.getKernel2D();
   const curveType = curve.geomType;
@@ -825,7 +797,7 @@ class Blueprint {
    * @returns Sketch data containing the projected wire and default orientation.
    */
   sketchOnPlane(inputPlane, origin) {
-    const plane = inputPlane && typeof inputPlane !== "string" ? { ...inputPlane } : makePlane(inputPlane, origin);
+    const plane = inputPlane && typeof inputPlane !== "string" ? { ...inputPlane } : vectors.makePlane(inputPlane, origin);
     const edges = curvesAsEdgesOnPlane(this.curves, plane);
     const wire = assembleWire(edges);
     return {
@@ -996,8 +968,6 @@ exports.make2dInerpolatedBSplineCurve = make2dInerpolatedBSplineCurve;
 exports.make2dSegmentCurve = make2dSegmentCurve;
 exports.make2dTangentArc = make2dTangentArc;
 exports.make2dThreePointArc = make2dThreePointArc;
-exports.makePlane = makePlane;
-exports.mirror = mirror;
 exports.normalize2d = normalize2d;
 exports.removeDuplicatePoints = removeDuplicatePoints;
 exports.viewbox = viewbox;

package/dist/{Blueprint-DbVaf6k7.js → Blueprint-CQNRtmYG.js}

@@ -1,40 +1,12 @@
-import { r as resolvePlane } from "./vectors-Bx8wkNui.js";
-import { a as toVec3 } from "./types-CWDdqcrq.js";
-import { B as getKernel, J as getKernel2D, K as registerForCleanup, L as unregisterFromCleanup, H as createEdge, G as createWire } from "./shapeTypes-CpSaBLDv.js";
-import { u as uvBounds, f as faceGeomType, e as faceCenter, h as uvCoordinates, c as cast } from "./faceFns-B8GnxjdY.js";
-import { g as getOrientation } from "./curveFns-mROFhiuG.js";
-import { b as bug, o as ok, e as err, d as computationError, v as unwrap, z as validationError } from "./result-BaSD1fqR.js";
-import { d as distance2d, s as samePoint, b as scalarMultiply2d, c as add2d, e as subtract2d, g as getSingleFace } from "./helpers-X0juxnwj.js";
-import { R as RAD2DEG, D as DEG2RAD } from "./vecOps-ZDdZWbwT.js";
-import { m as makeFace } from "./surfaceBuilders-nQdJ56fe.js";
-function makePlane(plane, origin) {
-  if (plane && typeof plane !== "string") {
-    return { ...plane };
-  } else {
-    return resolvePlane(plane ?? "XY", origin);
-  }
-}
-function mirror(shape, inputPlane, origin) {
-  let originVec;
-  let directionVec;
-  if (typeof inputPlane === "string") {
-    const plane = resolvePlane(inputPlane, origin);
-    originVec = plane.origin;
-    directionVec = plane.zDir;
-  } else if (inputPlane && typeof inputPlane === "object" && "origin" in inputPlane && "zDir" in inputPlane) {
-    originVec = origin ? toVec3(origin) : inputPlane.origin;
-    directionVec = inputPlane.zDir;
-  } else if (inputPlane) {
-    originVec = origin ? toVec3(origin) : [0, 0, 0];
-    directionVec = toVec3(inputPlane);
-  } else {
-    const plane = resolvePlane("YZ", origin);
-    originVec = plane.origin;
-    directionVec = plane.zDir;
-  }
-  const newShape = getKernel().mirror(shape, originVec, directionVec);
-  return newShape;
-}
+import { m as makePlane } from "./vectors-B8juLsQB.js";
+import { p as getKernel2D, r as registerForCleanup, u as unregisterFromCleanup, g as getKernel, m as createEdge, l as createWire } from "./shapeTypes-dhhm-T5A.js";
+import { u as uvBounds, f as faceGeomType, a as faceCenter, b as uvCoordinates, c as cast } from "./faceFns-Bn2seBfp.js";
+import { b as getOrientation } from "./curveFns-OmbtFSG8.js";
+import { d as bug, o as ok, e as err, f as computationError, u as unwrap, v as validationError } from "./result-CoDaWsvc.js";
+import { n as normalize2d$1, d as distance2d, s as samePoint, a as scalarMultiply2d, b as add2d, c as subtract2d, g as getSingleFace } from "./helpers-CEn618MW.js";
+import { t as toVec3 } from "./types-CcKqsmd0.js";
+import { R as RAD2DEG, D as DEG2RAD } from "./vecOps-LTN--A58.js";
+import { m as makeFace } from "./surfaceBuilders-Dl0ATFbO.js";
 function isPoint2D(point) {
   return Array.isArray(point) && point.length === 2 && typeof point[0] === "number" && typeof point[1] === "number";
 }
@@ -46,6 +18,9 @@ function precisionRound(number, precision) {
 function round2(v) {
   return Math.round(v * 100) / 100;
 }
+function round5(v) {
+  return Math.round(v * 1e5) / 1e5;
+}
 const reprPnt = ([x, y]) => {
   return `(${round2(x)},${round2(y)})`;
 };
@@ -137,12 +112,12 @@ class BoundingBox2d {
     return !getKernel2D().isBBox2dOutPoint(this.wrapped, other[0], other[1]);
   }
 }
-const normalize2d = ([x0, y0]) => {
-  const l = distance2d([x0, y0]);
-  if (l < 1e-12) {
+const normalize2d = ([x, y]) => {
+  const result = normalize2d$1([x, y]);
+  if (result[0] === 0 && result[1] === 0) {
     bug("normalize2d", "Cannot normalize zero-length vector");
   }
-  return [x0 / l, y0 / l];
+  return result;
 };
 function deserializeCurve2D(data) {
   return new Curve2D(getKernel().deserializeCurve2d(data));
@@ -516,9 +491,6 @@ const make2dArcFromCenter = (startPoint, endPoint, center, longArc = false) => {
     endPoint
   );
 };
-function round5(v) {
-  return Math.round(v * 1e5) / 1e5;
-}
 const adaptedCurveToPathElem = (curve, lastPoint) => {
   const k2d = getKernel2D();
   const curveType = curve.geomType;
@@ -979,26 +951,24 @@ class Blueprint {
 export {
   Blueprint as B,
   Curve2D as C,
-  make2dSegmentCurve as a,
-  make2dArcFromCenter as b,
+  make2dArcFromCenter as a,
+  approximateAsSvgCompatibleCurve as b,
   curvesAsEdgesOnPlane as c,
-  approximateAsSvgCompatibleCurve as d,
-  BoundingBox2d as e,
-  edgeToCurve as f,
-  make2dInerpolatedBSplineCurve as g,
-  make2dCircle as h,
-  make2dEllipse as i,
-  deserializeCurve2D as j,
-  approximateAsBSpline as k,
-  isPoint2D as l,
-  mirror as m,
+  BoundingBox2d as d,
+  make2dInerpolatedBSplineCurve as e,
+  make2dCircle as f,
+  make2dEllipse as g,
+  deserializeCurve2D as h,
+  edgeToCurve as i,
+  approximateAsBSpline as j,
+  isPoint2D as k,
+  make2dThreePointArc as l,
+  make2dSegmentCurve as m,
   normalize2d as n,
-  make2dThreePointArc as o,
-  asSVG as p,
-  make2dEllipseArc as q,
-  make2dTangentArc as r,
-  make2dBezierCurve as s,
-  removeDuplicatePoints as t,
-  makePlane as u,
+  asSVG as o,
+  make2dEllipseArc as p,
+  make2dTangentArc as q,
+  make2dBezierCurve as r,
+  removeDuplicatePoints as s,
   viewbox as v
 };

package/dist/{boolean2D-y3E92F0u.js → boolean2D-DXAt4GAK.js}

@@ -43,17 +43,17 @@ var __callDispose = (stack, error, hasError) => {
   };
   return next();
 };
-import { a as createPlane } from "./vectors-Bx8wkNui.js";
-import { o as ok, e as err, d as computationError, v as unwrap, h as isOk, C as safeIndex, b as bug } from "./result-BaSD1fqR.js";
-import { d as downcast, u as uvBounds, p as pointOnSurface, n as normalAt } from "./faceFns-B8GnxjdY.js";
-import { a as toVec3 } from "./types-CWDdqcrq.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-Bhw-FMoL.js";
-import { J as getKernel2D, I as createFace, G as createWire, B as getKernel, H as createEdge, D as DisposalScope } from "./shapeTypes-CpSaBLDv.js";
-import { c as curveStartPoint, a as curveTangentAt, b as curveIsClosed } from "./curveFns-mROFhiuG.js";
-import { m as makeFace, h as makeNewFaceWithinFace, b as assembleWire, z as zip } from "./surfaceBuilders-nQdJ56fe.js";
-import { s as samePoint$1, e as subtract2d, c as add2d, h as crossProduct2d, b as scalarMultiply2d, p as polarToCartesian, r as rotate2d, i as cartesianToPolar, d as distance2d, j as polarAngle2d, k as PRECISION_INTERSECTION } from "./helpers-X0juxnwj.js";
-import { C as Curve2D, a as make2dSegmentCurve, k as approximateAsBSpline, n as normalize2d, b as make2dArcFromCenter, l as isPoint2D, h as make2dCircle, o as make2dThreePointArc, e as BoundingBox2d, v as viewbox, p as asSVG, B as Blueprint, q as make2dEllipseArc, r as make2dTangentArc, s as make2dBezierCurve, t as removeDuplicatePoints } from "./Blueprint-DbVaf6k7.js";
+import { c as createPlane } from "./vectors-B8juLsQB.js";
+import { o as ok, e as err, f as computationError, u as unwrap, c as isOk, s as safeIndex, v as validationError, B as BrepErrorCode, k as kernelError, t as typeCastError, d as bug } from "./result-CoDaWsvc.js";
+import { d as downcast, u as uvBounds, p as pointOnSurface, n as normalAt } from "./faceFns-Bn2seBfp.js";
+import { t as toVec3 } from "./types-CcKqsmd0.js";
+import { v as vecLength, c as vecNormalize, b as vecScale, e as vecCross, D as DEG2RAD, R as RAD2DEG } from "./vecOps-LTN--A58.js";
+import { p as getKernel2D, g as getKernel, f as createSolid, c as castShape, h as isShape3D, n as createFace, l as createWire, m as createEdge, D as DisposalScope } from "./shapeTypes-dhhm-T5A.js";
+import { c as complexExtrude, t as twistExtrude, s as sweep } from "./sweepFns-BKnQs59A.js";
+import { d as curveStartPoint, e as curveTangentAt, a as curveIsClosed } from "./curveFns-OmbtFSG8.js";
+import { m as makeFace, g as makeNewFaceWithinFace, a as assembleWire, z as zip } from "./surfaceBuilders-Dl0ATFbO.js";
+import { s as samePoint$1, c as subtract2d, b as add2d, f as crossProduct2d, a as scalarMultiply2d, p as polarToCartesian, r as rotate2d, h as cartesianToPolar, d as distance2d, i as polarAngle2d, j as PRECISION_INTERSECTION } from "./helpers-CEn618MW.js";
+import { C as Curve2D, m as make2dSegmentCurve, j as approximateAsBSpline, n as normalize2d, a as make2dArcFromCenter, k as isPoint2D, f as make2dCircle, l as make2dThreePointArc, d as BoundingBox2d, v as viewbox, o as asSVG, B as Blueprint, p as make2dEllipseArc, q as make2dTangentArc, r as make2dBezierCurve, s as removeDuplicatePoints } from "./Blueprint-CQNRtmYG.js";
 const intersectCurves = (first, second, precision = 1e-9) => {
   if (first.boundingBox.isOut(second.boundingBox))
     return ok({ intersections: [], commonSegments: [], commonSegmentsPoints: [] });
@@ -566,33 +566,29 @@ function upperBound(value, arr) {
   return arr[i];
 }
 function sort(values, boxes, indices, left, right, nodeSize) {
-  if (Math.floor(left / nodeSize) >= Math.floor(right / nodeSize)) return;
-  const start = values[left];
-  const mid = values[left + right >> 1];
-  const end = values[right];
-  let pivot = end;
-  const x = Math.max(start, mid);
-  if (end > x) {
-    pivot = x;
-  } else if (x === start) {
-    pivot = Math.max(mid, end);
-  } else if (x === mid) {
-    pivot = Math.max(start, end);
-  }
-  let i = left - 1;
-  let j = right + 1;
-  while (true) {
-    do
-      i++;
-    while (values[i] < pivot);
-    do
-      j--;
-    while (values[j] > pivot);
-    if (i >= j) break;
-    swap(values, boxes, indices, i, j);
-  }
-  sort(values, boxes, indices, left, j, nodeSize);
-  sort(values, boxes, indices, j + 1, right, nodeSize);
+  const stack = [left, right];
+  while (stack.length) {
+    const r = stack.pop() || 0;
+    const l = stack.pop() || 0;
+    if (r - l <= nodeSize && Math.floor(l / nodeSize) >= Math.floor(r / nodeSize)) continue;
+    const a = values[l];
+    const b = values[l + r >> 1];
+    const c = values[r];
+    const pivot = a > b !== a > c ? a : b < a !== b < c ? b : c;
+    let i = l - 1;
+    let j = r + 1;
+    while (true) {
+      do
+        i++;
+      while (values[i] < pivot);
+      do
+        j--;
+      while (values[j] > pivot);
+      if (i >= j) break;
+      swap(values, boxes, indices, i, j);
+    }
+    stack.push(l, j, j + 1, r);
+  }
 }
 function swap(values, boxes, indices, i, j) {
   const temp = values[i];
@@ -947,6 +943,69 @@ const organiseBlueprints = (blueprints) => {
     })
   );
 };
+function extrude(face, extrusionVec) {
+  if (getKernel().isNull(face.wrapped)) {
+    return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "extrude: face is a null shape"));
+  }
+  if (vecLength(extrusionVec) === 0) {
+    return err(validationError("EXTRUDE_ZERO_VECTOR", "extrude: extrusion vector has zero length"));
+  }
+  try {
+    const kernel = getKernel();
+    const len = vecLength(extrusionVec);
+    const dir = vecNormalize(extrusionVec);
+    const shape = kernel.extrude(face.wrapped, [...dir], len);
+    const downcastShape = kernel.downcast(shape, "solid");
+    const solid = createSolid(downcastShape);
+    return ok(solid);
+  } catch (e) {
+    return err(
+      kernelError("EXTRUDE_FAILED", "Extrusion operation failed", e, {
+        operation: "extrude",
+        vectorLength: vecLength(extrusionVec)
+      })
+    );
+  }
+}
+function revolve(face, center = [0, 0, 0], direction = [0, 0, 1], angle = 360) {
+  if (getKernel().isNull(face.wrapped)) {
+    return err(validationError(BrepErrorCode.NULL_SHAPE_INPUT, "revolve: face is a null shape"));
+  }
+  const kernel = getKernel();
+  const shape = kernel.revolveVec(face.wrapped, [...center], [...direction], angle);
+  const result = castShape(shape);
+  if (!isShape3D(result)) {
+    return err(typeCastError("REVOLUTION_NOT_3D", "Revolution did not produce a 3D shape"));
+  }
+  return ok(result);
+}
+function loft(wires, { ruled = true, startPoint, endPoint, tolerance = 1e-6 } = {}, returnShell = false) {
+  if (wires.length === 0 && !startPoint && !endPoint) {
+    return err(validationError("LOFT_EMPTY", "Loft requires at least one wire or start/end point"));
+  }
+  const kernel = getKernel();
+  const startVertex = startPoint ? kernel.makeVertex(...toVec3(startPoint)) : void 0;
+  const endVertex = endPoint ? kernel.makeVertex(...toVec3(endPoint)) : void 0;
+  try {
+    const shape = kernel.loftAdvanced(
+      wires.map((w) => w.wrapped),
+      {
+        solid: !returnShell,
+        ruled,
+        tolerance,
+        ...startVertex ? { startVertex } : {},
+        ...endVertex ? { endVertex } : {}
+      }
+    );
+    const result = castShape(shape);
+    if (!isShape3D(result)) {
+      return err(typeCastError("LOFT_NOT_3D", "Loft did not produce a 3D shape"));
+    }
+    return ok(result);
+  } catch {
+    return err(kernelError("LOFT_FAILED", "Loft operation failed"));
+  }
+}
 class Sketch {
   wire;
   /**
@@ -1031,7 +1090,9 @@ class Sketch {
    */
   revolve(revolutionAxis, { origin } = {}) {
     const face = unwrap(makeFace(this.wire));
-    const solid = unwrap(revolution(face, origin || this.defaultOrigin, revolutionAxis));
+    const center = origin ? toVec3(origin) : this.defaultOrigin;
+    const dir = revolutionAxis ? toVec3(revolutionAxis) : [0, 0, 1];
+    const solid = unwrap(revolve(face, center, dir));
     face.delete();
     this.delete();
     return solid;
@@ -1064,13 +1125,19 @@ class Sketch {
     }
     if (twistAngle) {
       const solid2 = unwrap(
-        twistExtrude(this.wire, twistAngle, [...originVec], [...extrusionVec], extrusionProfile)
+        twistExtrude(
+          this.wire,
+          twistAngle,
+          [...originVec],
+          [...extrusionVec],
+          extrusionProfile
+        )
       );
       this.delete();
       return solid2;
     }
     const face = unwrap(makeFace(this.wire));
-    const solid = basicFaceExtrusion(face, [...extrusionVec]);
+    const solid = unwrap(extrude(face, [...extrusionVec]));
     this.delete();
     return solid;
   }
@@ -1094,7 +1161,7 @@ class Sketch {
     if (this.baseFace) {
       config.support = this.baseFace.wrapped;
     }
-    const shape = unwrap(genericSweep(sketch.wire, this.wire, config));
+    const shape = unwrap(sweep(sketch.wire, this.wire, config));
     this.delete();
     return shape;
   }
@@ -1245,7 +1312,7 @@ function normalizeEllipseRadii(horizontalRadius, verticalRadius, rotation) {
     rotationAngle: rotation
   };
 }
-function makeEllipseArcFromSvgParams(startUV, endUV, majorRadius, minorRadius, rotationAngleDeg, longAxis, sweep, convertToUV) {
+function makeEllipseArcFromSvgParams(startUV, endUV, majorRadius, minorRadius, rotationAngleDeg, longAxis, sweep2, convertToUV) {
   const radRotationAngle = rotationAngleDeg * DEG2RAD;
   const convertAxis = (ax) => distance2d(convertToUV(ax));
   const r1 = convertAxis(polarToCartesian(majorRadius, radRotationAngle));
@@ -1259,7 +1326,7 @@ function makeEllipseArcFromSvgParams(startUV, endUV, majorRadius, minorRadius, r
     r2,
     newRotationAngle,
     longAxis,
-    sweep
+    sweep2
   );
   const arc = make2dEllipseArc(
     rx,
@@ -1496,7 +1563,7 @@ class BaseSketcher2d {
   }
   // ── Ellipse arcs ──
   /** Draw an elliptical arc to an absolute end point (SVG-style parameters). */
-  ellipseTo(end, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep = false) {
+  ellipseTo(end, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep2 = false) {
     const { majorRadius, minorRadius, rotationAngle } = normalizeEllipseRadii(
       horizontalRadius,
       verticalRadius,
@@ -1509,31 +1576,31 @@ class BaseSketcher2d {
       minorRadius,
       rotationAngle,
       longAxis,
-      sweep,
+      sweep2,
       (p) => this._convertToUV(p)
     );
     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) {
+  ellipse(xDist, yDist, horizontalRadius, verticalRadius, rotation = 0, longAxis = false, sweep2 = false) {
     return this.ellipseTo(
       this._resolveRelative(xDist, yDist),
       horizontalRadius,
       verticalRadius,
       rotation,
       longAxis,
-      sweep
+      sweep2
     );
   }
   /** Draw a half-ellipse arc to an absolute end point with a given minor radius. */
-  halfEllipseTo(end, minorRadius, sweep = false) {
+  halfEllipseTo(end, minorRadius, sweep2 = false) {
     const angle = polarAngle2d(end, this.pointer);
     const dist = distance2d(end, this.pointer);
-    return this.ellipseTo(end, dist / 2, minorRadius, angle * RAD2DEG, true, sweep);
+    return this.ellipseTo(end, dist / 2, minorRadius, angle * RAD2DEG, true, sweep2);
   }
   /** Draw a half-ellipse arc to a relative end point with a given minor radius. */
-  halfEllipse(xDist, yDist, minorRadius, sweep = false) {
-    return this.halfEllipseTo(this._resolveRelative(xDist, yDist), minorRadius, sweep);
+  halfEllipse(xDist, yDist, minorRadius, sweep2 = false) {
+    return this.halfEllipseTo(this._resolveRelative(xDist, yDist), minorRadius, sweep2);
   }
   // ── Bezier curves ──
   /** Draw a Bezier curve to an absolute end point through one or more control points. */
@@ -2474,18 +2541,21 @@ export {
   Sketch as S,
   BlueprintSketcher as a,
   Flatbush as b,
-  Blueprints as c,
-  cut2D as d,
-  filletCurves as e,
-  fuse2D as f,
-  chamferCurves as g,
-  intersect2D as h,
+  roundedRectangleBlueprint as c,
+  Blueprints as d,
+  extrude as e,
+  cut2D as f,
+  fuse2D as g,
+  filletCurves as h,
   intersectCurves as i,
-  cutBlueprints as j,
-  fuseBlueprints as k,
-  intersectBlueprints as l,
+  chamferCurves as j,
+  intersect2D as k,
+  loft as l,
   make2dOffset as m,
+  cutBlueprints as n,
   organiseBlueprints as o,
   polysidesBlueprint as p,
-  roundedRectangleBlueprint as r
+  fuseBlueprints as q,
+  revolve as r,
+  intersectBlueprints as s
 };