brepjs 18.119.2 → 18.119.4

package/dist/{blueprintSketcher-C0EXFVb2.cjs → blueprintSketcher-gXVPrPlj.cjs}

@@ -1,10 +1,10 @@
-const require_shapeTypes = require("./shapeTypes-Bpsu5KJO.cjs");
+const require_shapeTypes = require("./shapeTypes-CkcIL7zv.cjs");
 const require_bug = require("./bug-O02CsAmt.cjs");
-const require_errors = require("./errors-CJU8CHng.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
 const require_constants = require("./constants-BOVyEYGH.cjs");
 const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
-const require_helpers = require("./helpers-Cu4ag5bh.cjs");
-const require_blueprint = require("./blueprint-DTNT4qYJ.cjs");
+const require_helpers = require("./helpers-BfkBvokP.cjs");
+const require_blueprint = require("./blueprint-DUnNPwQL.cjs");
 //#region node_modules/flatqueue/index.js
 /**
 * @typedef {Float64ArrayConstructor | Float32ArrayConstructor |
@@ -587,7 +587,7 @@ var selfIntersections = (curve, precision = 1e-9) => {
 //#endregion
 //#region src/2d/lib/offset.ts
 var offsetEndPoints = (firstPoint, lastPoint, offset) => {
-	const tangent = require_helpers.normalize2d(require_helpers.subtract2d(lastPoint, firstPoint));
+	const tangent = require_blueprint.normalize2d(require_helpers.subtract2d(lastPoint, firstPoint));
 	const normal = [tangent[1], -tangent[0]];
 	const offsetVec = [require_bug.wasmIndex(normal, 0) * offset, require_bug.wasmIndex(normal, 1) * offset];
 	return {
@@ -629,7 +629,7 @@ var make2dOffset = (curve, offset) => {
 		if (newRadius < 1e-10) {
 			const center = [cx, cy];
 			const offsetViaCenter = (point) => {
-				const [x, y] = require_helpers.normalize2d(require_helpers.subtract2d(point, center));
+				const [x, y] = require_blueprint.normalize2d(require_helpers.subtract2d(point, center));
 				return require_helpers.add2d(point, [orientedOffset * x, orientedOffset * y]);
 			};
 			return {
@@ -668,32 +668,99 @@ var make2dOffset = (curve, offset) => {
 };
 //#endregion
 //#region src/2d/lib/customCorners.ts
+/** Unwrap an intersection, discarding the common-segment curves the caller does not use. */
+function intersectionPoints(first, second) {
+	const result = require_errors.unwrap(intersectCurves(first, second));
+	result.commonSegments.forEach((c) => {
+		c.delete();
+	});
+	return result.intersections;
+}
+/**
+* Delete the split pieces the caller is discarding. `splitAt` returns the curve
+* itself when there is nothing to split, so the source is never deleted here.
+*/
+function disposeSplitPieces(pieces, source, kept) {
+	pieces.forEach((piece) => {
+		if (piece !== source && piece !== kept) piece.delete();
+	});
+}
+/**
+* Run `split` and, if it throws, dispose the pieces an earlier split already
+* produced. Splitting the second curve of a corner can fail (its parameter may
+* not project onto the offset), stranding the first curve's pieces.
+*/
+function splitOrDiscard(split, earlier) {
+	try {
+		return split();
+	} catch (e) {
+		disposeSplitPieces(earlier.pieces, earlier.source);
+		throw e;
+	}
+}
+/**
+* Build the corner result, disposing the trimmed halves if the connecting curve
+* cannot be built. They are unreachable once the error propagates.
+*/
+function discardTrimsOnError(firstCurve, secondCurve, first, second, build) {
+	try {
+		return build();
+	} catch (e) {
+		if (first !== firstCurve) first.delete();
+		if (second !== secondCurve) second.delete();
+		throw e;
+	}
+}
 function removeCorner(firstCurve, secondCurve, radius) {
 	const sinAngle = require_helpers.crossProduct2d(firstCurve.tangentAt(1), secondCurve.tangentAt(0));
 	if (Math.abs(sinAngle) < 1e-10) return null;
 	const offset = Math.abs(radius) * (sinAngle > 0 ? -1 : 1);
-	const firstOffset = make2dOffset(firstCurve, offset);
-	const secondOffset = make2dOffset(secondCurve, offset);
-	if (!(firstOffset instanceof require_blueprint.Curve2D) || !(secondOffset instanceof require_blueprint.Curve2D)) return null;
-	const intersectionResult = intersectCurves(firstOffset, secondOffset, 1e-9);
-	if (!require_errors.isOk(intersectionResult)) return null;
-	const potentialCenter = intersectionResult.value.intersections.at(-1);
-	if (!require_blueprint.isPoint2D(potentialCenter)) return null;
-	const center = potentialCenter;
-	const splitForFillet = (curve, offsetCurve) => {
-		const [x, y] = offsetCurve.tangentAt(center);
-		const normal = require_helpers.normalize2d([-y, x]);
-		const splitPoint = require_helpers.add2d(center, require_helpers.scalarMultiply2d(normal, offset));
-		const splitParam = require_errors.unwrap(curve.parameter(splitPoint, 1e-6));
-		return curve.splitAt([splitParam]);
-	};
-	const firstSplit = splitForFillet(firstCurve, firstOffset);
-	const secondSplit = splitForFillet(secondCurve, secondOffset);
-	return {
-		first: require_bug.wasmIndex(firstSplit, 0),
-		second: require_bug.wasmIndex(secondSplit, 1),
-		center
-	};
+	let firstOffset = null;
+	let secondOffset = null;
+	try {
+		firstOffset = make2dOffset(firstCurve, offset);
+		secondOffset = make2dOffset(secondCurve, offset);
+		if (!(firstOffset instanceof require_blueprint.Curve2D) || !(secondOffset instanceof require_blueprint.Curve2D)) return null;
+		const firstOffsetCurve = firstOffset;
+		const secondOffsetCurve = secondOffset;
+		const intersectionResult = intersectCurves(firstOffsetCurve, secondOffsetCurve, 1e-9);
+		if (!require_errors.isOk(intersectionResult)) return null;
+		intersectionResult.value.commonSegments.forEach((c) => {
+			c.delete();
+		});
+		const potentialCenter = intersectionResult.value.intersections.at(-1);
+		if (!require_blueprint.isPoint2D(potentialCenter)) return null;
+		const center = potentialCenter;
+		const splitForFillet = (curve, offsetCurve) => {
+			const [x, y] = offsetCurve.tangentAt(center);
+			const normal = require_blueprint.normalize2d([-y, x]);
+			const splitPoint = require_helpers.add2d(center, require_helpers.scalarMultiply2d(normal, offset));
+			const splitParam = require_errors.unwrap(curve.parameter(splitPoint, 1e-6));
+			return curve.splitAt([splitParam]);
+		};
+		const firstSplit = splitForFillet(firstCurve, firstOffsetCurve);
+		const secondSplit = splitOrDiscard(() => splitForFillet(secondCurve, secondOffsetCurve), {
+			pieces: firstSplit,
+			source: firstCurve
+		});
+		const first = firstSplit[0];
+		const second = secondSplit[1];
+		if (!first || !second) {
+			disposeSplitPieces(firstSplit, firstCurve);
+			disposeSplitPieces(secondSplit, secondCurve);
+			return null;
+		}
+		disposeSplitPieces(firstSplit, firstCurve, first);
+		disposeSplitPieces(secondSplit, secondCurve, second);
+		return {
+			first,
+			second,
+			center
+		};
+	} finally {
+		if (firstOffset instanceof require_blueprint.Curve2D) firstOffset.delete();
+		if (secondOffset instanceof require_blueprint.Curve2D) secondOffset.delete();
+	}
 }
 /**
 * Insert a circular fillet arc at the corner between two curves.
@@ -711,11 +778,11 @@ function filletCurves(firstCurve, secondCurve, radius) {
 	const cornerRemoved = removeCorner(firstCurve, secondCurve, radius);
 	if (!cornerRemoved) return [firstCurve, secondCurve];
 	const { first, second, center } = cornerRemoved;
-	return [
+	return discardTrimsOnError(firstCurve, secondCurve, first, second, () => [
 		first,
 		require_blueprint.make2dArcFromCenter(first.lastPoint, second.firstPoint, center),
 		second
-	];
+	]);
 }
 /**
 * Insert a straight chamfer segment at the corner between two curves.
@@ -727,11 +794,11 @@ function chamferCurves(firstCurve, secondCurve, radius) {
 	const cornerRemoved = removeCorner(firstCurve, secondCurve, radius);
 	if (!cornerRemoved) return [firstCurve, secondCurve];
 	const { first, second } = cornerRemoved;
-	return [
+	return discardTrimsOnError(firstCurve, secondCurve, first, second, () => [
 		first,
 		require_blueprint.make2dSegmentCurve(first.lastPoint, second.firstPoint),
 		second
-	];
+	]);
 }
 /**
 * Insert a dogbone fillet at an inner corner for CNC milling clearance.
@@ -740,34 +807,58 @@ function chamferCurves(firstCurve, secondCurve, radius) {
 * round end-mill of the given radius can fully reach the corner.
 */
 function dogboneFilletCurves(firstCurve, secondCurve, radius) {
-	const sinAngle = require_helpers.crossProduct2d(require_helpers.normalize2d(firstCurve.tangentAt(1)), require_helpers.normalize2d(secondCurve.tangentAt(0)));
+	const sinAngle = require_helpers.crossProduct2d(require_blueprint.normalize2d(firstCurve.tangentAt(1)), require_blueprint.normalize2d(secondCurve.tangentAt(0)));
 	const a = Math.asin(sinAngle);
 	if (Math.abs(sinAngle) < 1e-10) return [firstCurve, secondCurve];
 	const orientationCorrection = sinAngle > 0 ? -1 : 1;
 	const offset = Math.abs(radius) * Math.sin(a / 2) * orientationCorrection;
-	const firstOffset = make2dOffset(firstCurve, offset);
-	const secondOffset = make2dOffset(secondCurve, offset);
-	if (!(firstOffset instanceof require_blueprint.Curve2D) || !(secondOffset instanceof require_blueprint.Curve2D)) return [firstCurve, secondCurve];
-	const intersectionResult2 = intersectCurves(firstOffset, secondOffset, 1e-9);
-	if (!require_errors.isOk(intersectionResult2)) return [firstCurve, secondCurve];
-	const potentialCenter = intersectionResult2.value.intersections.at(-1);
-	if (!require_blueprint.isPoint2D(potentialCenter)) return [firstCurve, secondCurve];
-	const circle = require_blueprint.make2dCircle(radius, potentialCenter);
-	const firstInt = require_errors.unwrap(intersectCurves(firstCurve, circle)).intersections[0];
-	const secondInt = require_errors.unwrap(intersectCurves(secondCurve, circle)).intersections.at(-1);
-	if (!firstInt || !secondInt) return [firstCurve, secondCurve];
-	const firstSplit = firstCurve.splitAt([firstInt]);
-	const secondSplit = secondCurve.splitAt([secondInt]);
-	const firstPart = require_bug.wasmIndex(firstSplit, 0);
-	const secondPart = require_bug.wasmIndex(secondSplit, secondSplit.length - 1);
+	let firstOffset = null;
+	let secondOffset = null;
+	let circle = null;
 	try {
-		return [
-			firstPart,
-			require_blueprint.make2dThreePointArc(firstPart.lastPoint, firstCurve.lastPoint, secondPart.firstPoint),
-			secondPart
-		];
-	} catch {
-		return [firstCurve, secondCurve];
+		firstOffset = make2dOffset(firstCurve, offset);
+		secondOffset = make2dOffset(secondCurve, offset);
+		if (!(firstOffset instanceof require_blueprint.Curve2D) || !(secondOffset instanceof require_blueprint.Curve2D)) return [firstCurve, secondCurve];
+		const intersectionResult2 = intersectCurves(firstOffset, secondOffset, 1e-9);
+		if (!require_errors.isOk(intersectionResult2)) return [firstCurve, secondCurve];
+		intersectionResult2.value.commonSegments.forEach((c) => {
+			c.delete();
+		});
+		const potentialCenter = intersectionResult2.value.intersections.at(-1);
+		if (!require_blueprint.isPoint2D(potentialCenter)) return [firstCurve, secondCurve];
+		circle = require_blueprint.make2dCircle(radius, potentialCenter);
+		const firstInt = intersectionPoints(firstCurve, circle)[0];
+		const secondInt = intersectionPoints(secondCurve, circle).at(-1);
+		if (!firstInt || !secondInt) return [firstCurve, secondCurve];
+		const firstSplit = firstCurve.splitAt([firstInt]);
+		const secondSplit = splitOrDiscard(() => secondCurve.splitAt([secondInt]), {
+			pieces: firstSplit,
+			source: firstCurve
+		});
+		const firstPart = firstSplit[0];
+		const secondPart = secondSplit[secondSplit.length - 1];
+		if (!firstPart || !secondPart) {
+			disposeSplitPieces(firstSplit, firstCurve);
+			disposeSplitPieces(secondSplit, secondCurve);
+			return [firstCurve, secondCurve];
+		}
+		disposeSplitPieces(firstSplit, firstCurve, firstPart);
+		disposeSplitPieces(secondSplit, secondCurve, secondPart);
+		try {
+			return [
+				firstPart,
+				require_blueprint.make2dThreePointArc(firstPart.lastPoint, firstCurve.lastPoint, secondPart.firstPoint),
+				secondPart
+			];
+		} catch {
+			if (firstPart !== firstCurve) firstPart.delete();
+			if (secondPart !== secondCurve) secondPart.delete();
+			return [firstCurve, secondCurve];
+		}
+	} finally {
+		if (firstOffset instanceof require_blueprint.Curve2D) firstOffset.delete();
+		if (secondOffset instanceof require_blueprint.Curve2D) secondOffset.delete();
+		circle?.delete();
 	}
 }
 //#endregion
@@ -791,6 +882,19 @@ var Blueprints = class Blueprints {
 		this.blueprints = blueprints;
 		this._boundingBox = null;
 	}
+	/** Release the resources held by every child blueprint and the cached bounding box. */
+	delete() {
+		this.blueprints.forEach((bp) => {
+			bp.delete();
+		});
+		if (this._boundingBox) {
+			this._boundingBox.delete();
+			this._boundingBox = null;
+		}
+	}
+	[Symbol.dispose]() {
+		this.delete();
+	}
 	/** Return a multi-line debug representation of every child blueprint. */
 	get repr() {
 		return ["Blueprints", ...this.blueprints.map((b) => b.repr)].join("\n");
@@ -898,6 +1002,19 @@ var CompoundBlueprint = class CompoundBlueprint {
 		this.blueprints = blueprints;
 		this._boundingBox = null;
 	}
+	/** Release the resources held by every child blueprint and the cached bounding box. */
+	delete() {
+		this.blueprints.forEach((bp) => {
+			bp.delete();
+		});
+		if (this._boundingBox) {
+			this._boundingBox.delete();
+			this._boundingBox = null;
+		}
+	}
+	[Symbol.dispose]() {
+		this.delete();
+	}
 	/** Return a deep copy of this compound blueprint and all its children. */
 	clone() {
 		return new CompoundBlueprint(this.blueprints.map((bp) => bp.clone()));
@@ -1121,7 +1238,7 @@ function makeEllipseArcFromSvgParams(startUV, endUV, majorRadius, minorRadius, r
 	const convertAxis = (ax) => require_helpers.distance2d(convertToUV(ax));
 	const r1 = convertAxis(require_helpers.polarToCartesian(majorRadius, radRotationAngle));
 	const r2 = convertAxis(require_helpers.polarToCartesian(minorRadius, radRotationAngle + Math.PI / 2));
-	const xDir = require_helpers.normalize2d(convertToUV(require_helpers.rotate2d([1, 0], radRotationAngle)));
+	const xDir = require_blueprint.normalize2d(convertToUV(require_helpers.rotate2d([1, 0], radRotationAngle)));
 	const [, newRotationAngle] = require_helpers.cartesianToPolar(xDir);
 	const { cx, cy, startAngle, endAngle, clockwise, rx, ry } = convertSvgEllipseParams(startUV, endUV, r1, r2, newRotationAngle, longAxis, sweep);
 	const arc = require_blueprint.make2dEllipseArc(rx, ry, clockwise ? startAngle : endAngle, clockwise ? endAngle : startAngle, [cx, cy], xDir);
@@ -1213,6 +1330,16 @@ var cornerModeFns = {
 	dogbone: dogboneFilletCurves,
 	fillet: filletCurves
 };
+/**
+* Delete the curves a corner function consumed. Corner functions return their
+* inputs untouched when they bail (collinear curves, failed offset), so only
+* the ones absent from the result are ours to free.
+*/
+function disposeConsumedCurves(consumed, produced) {
+	consumed.forEach((curve) => {
+		if (!produced.includes(curve)) curve.delete();
+	});
+}
 function buildCornerFunction(radius, mode) {
 	if (typeof radius === "function") return radius;
 	const makeFn = cornerModeFns[mode];
@@ -1295,7 +1422,9 @@ var BaseSketcher2d = class {
 		}
 		const previousCurve = this.pendingCurves.pop();
 		if (!previousCurve) require_bug.bug("Sketcher2d.saveCurve", "No previous curve available for custom corner");
-		this.pendingCurves.push(...this._nextCorner(previousCurve, curve));
+		const cornered = this._nextCorner(previousCurve, curve);
+		disposeConsumedCurves([previousCurve, curve], cornered);
+		this.pendingCurves.push(...cornered);
 		this._nextCorner = null;
 	}
 	/** Draw a straight line to an absolute 2D point. */
@@ -1335,7 +1464,7 @@ var BaseSketcher2d = class {
 	/** Draw a line tangent to the previous curve, extending by the given distance. */
 	tangentLine(distance) {
 		const previousCurve = this._requireLastCurve("Sketcher2d.tangentLine", "sketch a tangent line");
-		const direction = require_helpers.normalize2d(this._convertFromUV(previousCurve.tangentAt(1)));
+		const direction = require_blueprint.normalize2d(this._convertFromUV(previousCurve.tangentAt(1)));
 		return this.line(direction[0] * distance, direction[1] * distance);
 	}
 	/** Draw a circular arc passing through a mid-point to an absolute end point. */
@@ -1445,12 +1574,12 @@ var BaseSketcher2d = class {
 		if (startTangent) startPoleDirection = startTangent;
 		else if (!previousCurve) startPoleDirection = [1, 0];
 		else startPoleDirection = this._convertFromUV(previousCurve.tangentAt(1));
-		startPoleDirection = require_helpers.normalize2d(startPoleDirection);
+		startPoleDirection = require_blueprint.normalize2d(startPoleDirection);
 		const startControl = [this.pointer[0] + startPoleDirection[0] * startFactor * defaultDistance, this.pointer[1] + startPoleDirection[1] * startFactor * defaultDistance];
 		let endPoleDirection;
 		if (endTangent === "symmetric") endPoleDirection = [-startPoleDirection[0], -startPoleDirection[1]];
 		else endPoleDirection = endTangent;
-		endPoleDirection = require_helpers.normalize2d(endPoleDirection);
+		endPoleDirection = require_blueprint.normalize2d(endPoleDirection);
 		const endControl = [end[0] - endPoleDirection[0] * endFactor * defaultDistance, end[1] - endPoleDirection[1] * endFactor * defaultDistance];
 		return this.cubicBezierCurveTo(end, startControl, endControl);
 	}
@@ -1469,7 +1598,9 @@ var BaseSketcher2d = class {
 		const previousCurve = this.pendingCurves.pop();
 		const curve = this.pendingCurves.shift();
 		if (!previousCurve || !curve) require_bug.bug("Sketcher2d._customCornerLastWithFirst", "Not enough curves to close and fillet");
-		this.pendingCurves.push(...buildCornerFunction(radius, mode)(previousCurve, curve));
+		const cornered = buildCornerFunction(radius, mode)(previousCurve, curve);
+		disposeConsumedCurves([previousCurve, curve], cornered);
+		this.pendingCurves.push(...cornered);
 	}
 	_closeSketch() {
 		if (!require_helpers.samePoint(this.pointer, this.firstPoint)) this.lineTo(this.firstPoint);

package/dist/{boolean2D-Ddfo_dd0.cjs → boolean2D-BpmxQ1AH.cjs}

@@ -1,10 +1,10 @@
 const require_bug = require("./bug-O02CsAmt.cjs");
-const require_errors = require("./errors-CJU8CHng.cjs");
+const require_errors = require("./errors-RHkKO5bZ.cjs");
 const require_arrayAccess = require("./arrayAccess-e4H9cBfh.cjs");
-const require_surfaceBuilders = require("./surfaceBuilders-D8_08oOR.cjs");
-const require_blueprintSketcher = require("./blueprintSketcher-C0EXFVb2.cjs");
-const require_helpers = require("./helpers-Cu4ag5bh.cjs");
-const require_blueprint = require("./blueprint-DTNT4qYJ.cjs");
+const require_surfaceBuilders = require("./surfaceBuilders-Biqx51el.cjs");
+const require_blueprintSketcher = require("./blueprintSketcher-gXVPrPlj.cjs");
+const require_helpers = require("./helpers-BfkBvokP.cjs");
+const require_blueprint = require("./blueprint-DUnNPwQL.cjs");
 //#region src/2d/blueprints/cannedBlueprints.ts
 /**
 * Create a regular polygon blueprint inscribed in a circle of the given radius.

package/dist/{boolean2D-C_PVz8xT.js → boolean2D-DKT0BgZs.js}

@@ -1,10 +1,10 @@
 import { i as wasmIndex, n as bug } from "./bug-BdOHwn_e.js";
-import { I as unwrap, s as safeIndex } from "./errors-B3CDG537.js";
+import { P as unwrap, s as safeIndex } from "./errors-MHLiNE-C.js";
 import { r as lastOrThrow } from "./arrayAccess-DrUGPADn.js";
-import { v as zip } from "./surfaceBuilders-BNR7yMQO.js";
-import { a as Blueprints, i as CompoundBlueprint, l as intersectCurves, r as organiseBlueprints, t as BlueprintSketcher, u as Flatbush } from "./blueprintSketcher-DDPyypmC.js";
-import { _ as samePoint$1, b as subtract2d, f as crossProduct2d, s as PRECISION_INTERSECTION } from "./helpers-BiN4qQZP.js";
-import { b as removeDuplicatePoints, f as make2dSegmentCurve, t as Blueprint } from "./blueprint-DJJo8WkI.js";
+import { v as zip } from "./surfaceBuilders-BryY-i0F.js";
+import { a as Blueprints, i as CompoundBlueprint, l as intersectCurves, r as organiseBlueprints, t as BlueprintSketcher, u as Flatbush } from "./blueprintSketcher-gMuUUPb-.js";
+import { _ as samePoint$1, b as subtract2d, d as crossProduct2d, o as PRECISION_INTERSECTION } from "./helpers-Du_OdHuy.js";
+import { f as make2dSegmentCurve, t as Blueprint, x as removeDuplicatePoints } from "./blueprint-DEMSX-hc.js";
 //#region src/2d/blueprints/cannedBlueprints.ts
 /**
 * Create a regular polygon blueprint inscribed in a circle of the given radius.