brepjs 18.119.2 → 18.119.4

package/dist/{blueprintSketcher-DDPyypmC.js → blueprintSketcher-gMuUUPb-.js}

@@ -1,10 +1,10 @@
-import { at as getKernel2D, it as getKernel } from "./shapeTypes-CnKFSfDT.js";
+import { K as getKernel, q as getKernel2D } from "./shapeTypes-t49f64Dx.js";
 import { i as wasmIndex, n as bug } from "./bug-BdOHwn_e.js";
-import { C as isOk, I as unwrap, O as ok, n as computationError, s as safeIndex, v as err } from "./errors-B3CDG537.js";
+import { E as ok, P as unwrap, g as err, n as computationError, s as safeIndex, x as isOk } from "./errors-MHLiNE-C.js";
 import { r as RAD2DEG, t as DEG2RAD } from "./constants-ITRzCnCp.js";
 import { t as firstOrThrow } from "./arrayAccess-DrUGPADn.js";
-import { _ as samePoint, b as subtract2d, d as cartesianToPolar, f as crossProduct2d, g as rotate2d, h as polarToCartesian, l as add2d, m as polarAngle2d, o as normalize2d, p as distance2d, v as scalarMultiply2d } from "./helpers-BiN4qQZP.js";
-import { _ as Curve2D, c as make2dCircle, f as make2dSegmentCurve, h as approximateAsBSpline, m as make2dThreePointArc, n as asSVG, o as make2dArcFromCenter, p as make2dTangentArc, r as viewbox, s as make2dBezierCurve, t as Blueprint, u as make2dEllipseArc, x as isPoint2D, y as BoundingBox2d } from "./blueprint-DJJo8WkI.js";
+import { _ as samePoint, b as subtract2d, c as add2d, d as crossProduct2d, f as distance2d, g as rotate2d, h as polarToCartesian, m as polarAngle2d, u as cartesianToPolar, v as scalarMultiply2d } from "./helpers-Du_OdHuy.js";
+import { S as isPoint2D, _ as Curve2D, b as BoundingBox2d, c as make2dCircle, f as make2dSegmentCurve, h as approximateAsBSpline, m as make2dThreePointArc, n as asSVG, o as make2dArcFromCenter, p as make2dTangentArc, r as viewbox, s as make2dBezierCurve, t as Blueprint, u as make2dEllipseArc, y as normalize2d } from "./blueprint-DEMSX-hc.js";
 //#region node_modules/flatqueue/index.js
 /**
 * @typedef {Float64ArrayConstructor | Float32ArrayConstructor |
@@ -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 = 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 = 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 Curve2D) || !(secondOffset instanceof Curve2D)) return null;
-	const intersectionResult = intersectCurves(firstOffset, secondOffset, 1e-9);
-	if (!isOk(intersectionResult)) return null;
-	const potentialCenter = intersectionResult.value.intersections.at(-1);
-	if (!isPoint2D(potentialCenter)) return null;
-	const center = potentialCenter;
-	const splitForFillet = (curve, offsetCurve) => {
-		const [x, y] = offsetCurve.tangentAt(center);
-		const normal = normalize2d([-y, x]);
-		const splitPoint = add2d(center, scalarMultiply2d(normal, offset));
-		const splitParam = unwrap(curve.parameter(splitPoint, 1e-6));
-		return curve.splitAt([splitParam]);
-	};
-	const firstSplit = splitForFillet(firstCurve, firstOffset);
-	const secondSplit = splitForFillet(secondCurve, secondOffset);
-	return {
-		first: wasmIndex(firstSplit, 0),
-		second: wasmIndex(secondSplit, 1),
-		center
-	};
+	let firstOffset = null;
+	let secondOffset = null;
+	try {
+		firstOffset = make2dOffset(firstCurve, offset);
+		secondOffset = make2dOffset(secondCurve, offset);
+		if (!(firstOffset instanceof Curve2D) || !(secondOffset instanceof Curve2D)) return null;
+		const firstOffsetCurve = firstOffset;
+		const secondOffsetCurve = secondOffset;
+		const intersectionResult = intersectCurves(firstOffsetCurve, secondOffsetCurve, 1e-9);
+		if (!isOk(intersectionResult)) return null;
+		intersectionResult.value.commonSegments.forEach((c) => {
+			c.delete();
+		});
+		const potentialCenter = intersectionResult.value.intersections.at(-1);
+		if (!isPoint2D(potentialCenter)) return null;
+		const center = potentialCenter;
+		const splitForFillet = (curve, offsetCurve) => {
+			const [x, y] = offsetCurve.tangentAt(center);
+			const normal = normalize2d([-y, x]);
+			const splitPoint = add2d(center, scalarMultiply2d(normal, offset));
+			const splitParam = 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 Curve2D) firstOffset.delete();
+		if (secondOffset instanceof 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,
 		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,
 		make2dSegmentCurve(first.lastPoint, second.firstPoint),
 		second
-	];
+	]);
 }
 /**
 * Insert a dogbone fillet at an inner corner for CNC milling clearance.
@@ -745,29 +812,53 @@ function dogboneFilletCurves(firstCurve, secondCurve, radius) {
 	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 Curve2D) || !(secondOffset instanceof Curve2D)) return [firstCurve, secondCurve];
-	const intersectionResult2 = intersectCurves(firstOffset, secondOffset, 1e-9);
-	if (!isOk(intersectionResult2)) return [firstCurve, secondCurve];
-	const potentialCenter = intersectionResult2.value.intersections.at(-1);
-	if (!isPoint2D(potentialCenter)) return [firstCurve, secondCurve];
-	const circle = make2dCircle(radius, potentialCenter);
-	const firstInt = unwrap(intersectCurves(firstCurve, circle)).intersections[0];
-	const secondInt = 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 = wasmIndex(firstSplit, 0);
-	const secondPart = wasmIndex(secondSplit, secondSplit.length - 1);
+	let firstOffset = null;
+	let secondOffset = null;
+	let circle = null;
 	try {
-		return [
-			firstPart,
-			make2dThreePointArc(firstPart.lastPoint, firstCurve.lastPoint, secondPart.firstPoint),
-			secondPart
-		];
-	} catch {
-		return [firstCurve, secondCurve];
+		firstOffset = make2dOffset(firstCurve, offset);
+		secondOffset = make2dOffset(secondCurve, offset);
+		if (!(firstOffset instanceof Curve2D) || !(secondOffset instanceof Curve2D)) return [firstCurve, secondCurve];
+		const intersectionResult2 = intersectCurves(firstOffset, secondOffset, 1e-9);
+		if (!isOk(intersectionResult2)) return [firstCurve, secondCurve];
+		intersectionResult2.value.commonSegments.forEach((c) => {
+			c.delete();
+		});
+		const potentialCenter = intersectionResult2.value.intersections.at(-1);
+		if (!isPoint2D(potentialCenter)) return [firstCurve, secondCurve];
+		circle = 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,
+				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 Curve2D) firstOffset.delete();
+		if (secondOffset instanceof 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()));
@@ -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) 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. */
@@ -1469,7 +1598,9 @@ var BaseSketcher2d = class {
 		const previousCurve = this.pendingCurves.pop();
 		const curve = this.pendingCurves.shift();
 		if (!previousCurve || !curve) 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 (!samePoint(this.pointer, this.firstPoint)) this.lineTo(this.firstPoint);