brepjs 18.6.1 → 18.14.3

package/dist/boolean2D-Z7P0c012.js

@@ -0,0 +1,855 @@
+import { n as wasmIndex } from "./vec3-BRj3eI54.js";
+import { R as unwrap, h as bug, s as safeIndex } from "./errors-0fYW_YnO.js";
+import { r as lastOrThrow } from "./arrayAccess-C5IWcxs9.js";
+import { v as zip } from "./surfaceBuilders-CinmHCbZ.js";
+import { a as Blueprints, i as CompoundBlueprint, l as intersectCurves, r as organiseBlueprints, t as BlueprintSketcher, u as Flatbush } from "./blueprintSketcher-xDsl9GXO.js";
+import { _ as samePoint$1, b as subtract2d, f as crossProduct2d, s as PRECISION_INTERSECTION } from "./helpers-vV2ONZwD.js";
+import { b as removeDuplicatePoints, f as make2dSegmentCurve, t as Blueprint } from "./blueprint-Dv45Evnu.js";
+//#region src/2d/blueprints/cannedBlueprints.ts
+/**
+* Create a regular polygon blueprint inscribed in a circle of the given radius.
+*
+* @param radius - Circumscribed circle radius.
+* @param sidesCount - Number of sides (3 = triangle, 6 = hexagon, etc.).
+* @param sagitta - When non-zero, sides are replaced by sagitta arcs (bulge height).
+* @returns A closed Blueprint representing the polygon.
+*
+* @example
+* ```ts
+* const hexagon = polysidesBlueprint(10, 6);
+* const roundedTriangle = polysidesBlueprint(10, 3, 2);
+* ```
+*/
+var polysidesBlueprint = (radius, sidesCount, sagitta = 0) => {
+	const points = [...Array(sidesCount).keys()].map((i) => {
+		const theta = -(Math.PI * 2 / sidesCount) * i;
+		return [radius * Math.sin(theta), radius * Math.cos(theta)];
+	});
+	const lastPoint = lastOrThrow(points);
+	const blueprint = new BlueprintSketcher().movePointerTo([lastPoint[0], lastPoint[1]]);
+	if (sagitta) points.forEach(([x, y]) => blueprint.sagittaArcTo([x, y], sagitta));
+	else points.forEach(([x, y]) => blueprint.lineTo([x, y]));
+	return blueprint.done();
+};
+/**
+* Create an axis-aligned rectangle blueprint with optional rounded corners.
+*
+* The rectangle is centered at the origin. When `r` is zero the corners
+* are sharp; otherwise they are filleted with circular or elliptical arcs.
+*
+* @param width - Total width of the rectangle.
+* @param height - Total height of the rectangle.
+* @param r - Corner radius. Pass a number for uniform rounding, or
+*   `{ rx, ry }` for elliptical corners. Clamped to half the respective
+*   dimension.
+* @returns A closed Blueprint representing the rectangle.
+*
+* @example
+* ```ts
+* const sharp = roundedRectangleBlueprint(20, 10);
+* const rounded = roundedRectangleBlueprint(20, 10, 3);
+* const elliptical = roundedRectangleBlueprint(20, 10, { rx: 4, ry: 2 });
+* ```
+*/
+var roundedRectangleBlueprint = (width, height, r = 0) => {
+	const { rx: inputRx = 0, ry: inputRy = 0 } = typeof r === "number" ? {
+		ry: r,
+		rx: r
+	} : r;
+	let rx = Math.min(inputRx, width / 2);
+	let ry = Math.min(inputRy, height / 2);
+	const withRadius = rx && ry;
+	if (!withRadius) {
+		rx = 0;
+		ry = 0;
+	}
+	const symmetricRadius = rx === ry;
+	const sk = new BlueprintSketcher([Math.min(0, -(width / 2 - rx)), -height / 2]);
+	const addFillet = (xDist, yDist) => {
+		if (withRadius) if (symmetricRadius) sk.tangentArc(xDist, yDist);
+		else sk.ellipse(xDist, yDist, rx, ry, 0, false, true);
+	};
+	if (rx < width / 2) sk.hLine(width - 2 * rx);
+	addFillet(rx, ry);
+	if (ry < height / 2) sk.vLine(height - 2 * ry);
+	addFillet(-rx, ry);
+	if (rx < width / 2) sk.hLine(-(width - 2 * rx));
+	addFillet(-rx, -ry);
+	if (ry < height / 2) sk.vLine(-(height - 2 * ry));
+	addFillet(rx, -ry);
+	return sk.close();
+};
+//#endregion
+//#region src/2d/blueprints/booleanHelpers.ts
+var samePoint = (x, y) => samePoint$1(x, y, PRECISION_INTERSECTION);
+/**
+* Hash a point for Set/Map lookup using precision rounding.
+* Must match PRECISION_INTERSECTION (1e-9) to avoid hash collisions for
+* nearly-equal points.
+*/
+function hashPoint(p) {
+	return `${p[0].toFixed(9)},${p[1].toFixed(9)}`;
+}
+/**
+* Hash a segment by both orientations for bidirectional lookup.
+* The smaller hash comes first so that (A,B) and (B,A) produce the same key.
+*/
+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);
+}
+/**
+* Find the index of the first curve in `curves` whose firstPoint matches
+* `point`. Uses hash for a fast first pass, then falls back to tolerance-only
+* comparison to handle floating-point rounding at `toFixed(9)` boundaries.
+* Returns -1 if no match is found.
+*/
+function findCurveIndexByStartPoint(curves, point) {
+	const targetHash = hashPoint(point);
+	for (let i = 0; i < curves.length; i++) {
+		const curve = curves[i];
+		if (curve === void 0) continue;
+		if (hashPoint(curve.firstPoint) === targetHash && samePoint(point, curve.firstPoint)) return i;
+	}
+	for (let i = 0; i < curves.length; i++) {
+		const curve = curves[i];
+		if (curve === void 0) continue;
+		if (samePoint(point, curve.firstPoint)) return i;
+	}
+	return -1;
+}
+/**
+* Find the index of the first curve in `curves` that matches the given
+* segment's start and end points. Uses hash for a fast first pass, then
+* falls back to tolerance-only comparison.
+* Returns -1 if no match is found.
+*/
+function findCurveIndexBySegment(curves, segFirstHash, segLastHash, matchesFn) {
+	for (let i = 0; i < curves.length; i++) {
+		const curve = curves[i];
+		if (curve === void 0) continue;
+		if (hashPoint(curve.firstPoint) === segFirstHash && hashPoint(curve.lastPoint) === segLastHash && matchesFn(curve)) return i;
+	}
+	for (let i = 0; i < curves.length; i++) {
+		const curve = curves[i];
+		if (curve === void 0) continue;
+		if (matchesFn(curve)) return i;
+	}
+	return -1;
+}
+/** Rotate an array so that element at `startIndex` becomes the first element. */
+function rotateArray(arr, startIndex) {
+	if (startIndex <= 0) return arr;
+	return arr.slice(startIndex).concat(arr.slice(0, startIndex));
+}
+/**
+* Rotate the curves array so that it starts at the curve whose firstPoint
+* matches the given point.
+*/
+function rotateToStartAt(curves, point) {
+	return rotateArray(curves, findCurveIndexByStartPoint(curves, point));
+}
+/**
+* Rotate the curves array so that it starts at the curve matching the given
+* segment. Tries both segment orientations (forward and flipped) against both
+* curve orientations (original and reversed chain) to handle cases where
+* `intersectCurves` returns a common segment oriented opposite to the
+* matching curve in the split result.
+*/
+function rotateToStartAtSegment(curves, segment) {
+	const segFirstHash = hashPoint(segment.firstPoint);
+	const segLastHash = hashPoint(segment.lastPoint);
+	const matchesForward = (curve) => samePoint(segment.firstPoint, curve.firstPoint) && samePoint(segment.lastPoint, curve.lastPoint);
+	const matchesFlipped = (curve) => samePoint(segment.lastPoint, curve.firstPoint) && samePoint(segment.firstPoint, curve.lastPoint);
+	function tryRotate(chain, firstHash, lastHash, matchFn) {
+		const idx = findCurveIndexBySegment(chain, firstHash, lastHash, matchFn);
+		return idx !== -1 ? rotateArray(chain, idx) : null;
+	}
+	const fwdFwd = tryRotate(curves, segFirstHash, segLastHash, matchesForward);
+	if (fwdFwd !== null) return fwdFwd;
+	const flipFwd = tryRotate(curves, segLastHash, segFirstHash, matchesFlipped);
+	if (flipFwd !== null) return flipFwd;
+	const reversed = reverseSegment(curves);
+	const fwdRev = tryRotate(reversed, segFirstHash, segLastHash, matchesForward);
+	if (fwdRev !== null) return fwdRev;
+	const flipRev = tryRotate(reversed, segLastHash, segFirstHash, matchesFlipped);
+	if (flipRev !== null) return flipRev;
+	bug("rotateToStartAtSegment", "failed to rotate to segment start");
+}
+//#endregion
+//#region src/2d/blueprints/intersectionSegments.ts
+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 matchesIntersection = (point) => {
+		if (intersectionSet.has(hashPoint(point))) return true;
+		return allIntersections.some((p) => samePoint(p, point));
+	};
+	const matchesCommonSegment = (first, last) => {
+		if (commonSegmentSet.has(hashSegment(first, last))) return true;
+		return allCommonSegments.some((seg) => samePoint(seg.firstPoint, first) && samePoint(seg.lastPoint, last) || samePoint(seg.firstPoint, last) && samePoint(seg.lastPoint, first));
+	};
+	let currentCurves = [];
+	for (const curve of curves) {
+		if (samePoint(curve.firstPoint, curve.lastPoint)) {
+			currentCurves.push(curve);
+			continue;
+		}
+		const endsAtIntersection = matchesIntersection(curve.lastPoint);
+		const isCommon = matchesCommonSegment(curve.firstPoint, curve.lastPoint);
+		if (endsAtIntersection) {
+			currentCurves.push(curve);
+			yield currentCurves;
+			currentCurves = [];
+		} else if (isCommon) {
+			if (currentCurves.length) {
+				yield currentCurves;
+				currentCurves = [];
+			}
+			yield [curve];
+		} else currentCurves.push(curve);
+	}
+	if (currentCurves.length) yield currentCurves;
+}
+/**
+* Filter out intersection points where the curves only touch but do not
+* actually cross from one side to the other.
+*/
+function removeNonCrossingPoints(allIntersections, segmentedCurve, blueprintToCheck) {
+	return allIntersections.filter((intersection) => {
+		const touching = segmentedCurve.filter((s) => samePoint(s.firstPoint, intersection) || samePoint(s.lastPoint, intersection));
+		const effectiveTouching = touching.length % 2 ? touching.filter((s) => !(samePoint(s.firstPoint, intersection) && samePoint(s.lastPoint, intersection))) : touching;
+		if (effectiveTouching.length === 0 || effectiveTouching.length % 2) return false;
+		const insideFlags = effectiveTouching.map((segment) => blueprintToCheck.isInside(curveMidPoint(segment)));
+		return !(insideFlags.every(Boolean) || insideFlags.every((f) => !f));
+	});
+}
+/**
+* Find all intersection points and common segments between two blueprints'
+* curves. Returns per-curve intersection points for subsequent splitting.
+*/
+function findAllIntersections(first, second) {
+	const allIntersections = [];
+	const allCommonSegments = [];
+	const firstCurvePoints = first.curves.map(() => []);
+	const secondCurvePoints = second.curves.map(() => []);
+	const secondIndex = new Flatbush(second.curves.length);
+	for (const curve of second.curves) {
+		const [[xMin, yMin], [xMax, yMax]] = curve.boundingBox.bounds;
+		secondIndex.add(xMin, yMin, xMax, yMax);
+	}
+	secondIndex.finish();
+	first.curves.forEach((thisCurve, firstIdx) => {
+		const [[xMin, yMin], [xMax, yMax]] = thisCurve.boundingBox.bounds;
+		const candidates = secondIndex.search(xMin, yMin, xMax, yMax);
+		for (const secondIdx of candidates) {
+			const { intersections, commonSegments, commonSegmentsPoints } = unwrap(intersectCurves(thisCurve, wasmIndex(second.curves, secondIdx), PRECISION_INTERSECTION / 100));
+			allIntersections.push(...intersections);
+			firstCurvePoints[firstIdx]?.push(...intersections);
+			secondCurvePoints[secondIdx]?.push(...intersections);
+			allCommonSegments.push(...commonSegments);
+			allIntersections.push(...commonSegmentsPoints);
+			firstCurvePoints[firstIdx]?.push(...commonSegmentsPoints);
+			secondCurvePoints[secondIdx]?.push(...commonSegmentsPoints);
+		}
+	});
+	return {
+		allIntersections: removeDuplicatePoints(allIntersections, PRECISION_INTERSECTION),
+		allCommonSegments,
+		firstCurvePoints,
+		secondCurvePoints
+	};
+}
+/**
+* Split each curve at its intersection points and return the resulting
+* sub-curves.
+*/
+function splitCurvesAtIntersections(curves, curvePoints) {
+	return zip([curves, curvePoints]).flatMap(([curve, intersections]) => {
+		if (intersections.length === 0) return [curve];
+		return curve.splitAt(intersections, PRECISION_INTERSECTION / 100);
+	});
+}
+/**
+* Check whether a segment's start/end points match one of the common segment
+* point pairs.
+*/
+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(endPoint, segmentStart);
+	});
+}
+/**
+* Given two closed blueprints, find their intersection points, split each
+* blueprint's curves at those points, and pair up the resulting segments.
+*
+* Returns an array of paired segments (one from each blueprint) that share
+* the same start/end intersection points, or `null` if the blueprints do not
+* intersect.
+*/
+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]);
+	const allIntersections = removeNonCrossingPoints(removeNonCrossingPoints(rawIntersections, firstCurveSegments, second), secondCurveSegments, first);
+	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);
+	}
+	const firstIntersectedSegments = Array.from(createSegmentOnPoints(firstCurveSegments, allIntersections, allCommonSegments));
+	let secondIntersectedSegments = Array.from(createSegmentOnPoints(secondCurveSegments, allIntersections, allCommonSegments));
+	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);
+	}
+	const maxLen = Math.max(firstIntersectedSegments.length, secondIntersectedSegments.length);
+	const result = [];
+	for (let i = 0; i < maxLen; i++) {
+		const firstSeg2 = firstIntersectedSegments[i];
+		const secondSeg2 = secondIntersectedSegments[i];
+		if (firstSeg2 === void 0 || secondSeg2 === void 0) {
+			const available = firstSeg2 ?? secondSeg2;
+			if (available === void 0) continue;
+			result.push([available, available]);
+			continue;
+		}
+		if (isCommonSegmentMatch(commonSegmentsPoints, startOfSegment(firstSeg2), endOfSegment(firstSeg2))) result.push([firstSeg2, "same"]);
+		else result.push([firstSeg2, secondSeg2]);
+	}
+	return result;
+}
+//#endregion
+//#region src/2d/blueprints/segmentAssembly.ts
+/**
+* Merge adjacent collinear line segments into single segments.
+*
+* Boolean operations can split a line at intersection points that lie on the
+* line itself (e.g. when a cut rectangle's edge is collinear with the
+* profile's edge). The extra split creates a C0 discontinuity in swept
+* surfaces. Merging eliminates unnecessary vertices.
+*/
+function mergeCollinearSegments(curves) {
+	if (curves.length < 2) return curves;
+	const result = [];
+	let i = 0;
+	while (i < curves.length) {
+		const current = wasmIndex(curves, i);
+		if (current.geomType !== "LINE") {
+			result.push(current);
+			i++;
+			continue;
+		}
+		let endPoint = current.lastPoint;
+		let j = i + 1;
+		while (j < curves.length) {
+			const next = wasmIndex(curves, j);
+			if (next.geomType !== "LINE") break;
+			if (!samePoint(endPoint, next.firstPoint)) break;
+			const dir1 = subtract2d(endPoint, current.firstPoint);
+			const dir2 = subtract2d(next.lastPoint, next.firstPoint);
+			if (Math.abs(crossProduct2d(dir1, dir2)) > 1e-9) break;
+			endPoint = next.lastPoint;
+			j++;
+		}
+		if (j > i + 1) result.push(make2dSegmentCurve(current.firstPoint, endPoint));
+		else result.push(current);
+		i = j;
+	}
+	return result;
+}
+/**
+* Split an array of curves into separate continuous paths. A discontinuity
+* occurs where one curve's lastPoint does not match the next curve's
+* firstPoint.
+*/
+function splitPaths(curves) {
+	const startPoints = curves.map((c) => c.firstPoint);
+	const shiftedEndPoints = curves.map((c) => c.lastPoint);
+	const discontinuities = zip([startPoints, shiftedEndPoints.slice(-1).concat(shiftedEndPoints.slice(0, -1))]).map(([startPoint, endPoint], index) => {
+		if (startPoint === void 0 || endPoint === void 0) return null;
+		return samePoint(startPoint, endPoint) ? null : index;
+	}).filter((f) => f !== null);
+	if (discontinuities.length === 0) return [curves];
+	const paths = zip([discontinuities.slice(0, -1), discontinuities.slice(1)]).map(([start, end]) => curves.slice(start, end));
+	let lastPath = curves.slice(discontinuities[discontinuities.length - 1]);
+	const firstDiscontinuity = discontinuities[0];
+	if (firstDiscontinuity !== void 0 && firstDiscontinuity !== 0) lastPath = lastPath.concat(curves.slice(0, firstDiscontinuity));
+	paths.push(lastPath);
+	return paths;
+}
+/**
+* Handle the case where two segments overlap ("same"). The decision depends
+* on how many segments are entering the current intersection node.
+*/
+function handleSameSegment(firstSegment, segmentsIn, lastWasSame) {
+	if (segmentsIn === 1) return {
+		curves: [...firstSegment],
+		segmentsIn: 1,
+		lastWasSame: null
+	};
+	if (segmentsIn === 2 || segmentsIn === 0) return {
+		curves: [],
+		segmentsIn: null,
+		lastWasSame: null
+	};
+	if (segmentsIn === null) return {
+		curves: [],
+		segmentsIn: null,
+		lastWasSame: lastWasSame ? [...lastWasSame, ...firstSegment] : firstSegment
+	};
+	return {
+		curves: [],
+		segmentsIn,
+		lastWasSame
+	};
+}
+/**
+* Determine which non-overlapping segments to keep based on
+* inside/outside status relative to the other blueprint.
+*/
+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;
+			segments.push(...firstSegment);
+		}
+	}
+	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;
+			segments.push(...segmentsToAdd);
+		}
+	}
+	if (segmentsIn === null && segmentsOut === 1 && lastWasSame !== null) segments = [...lastWasSame, ...segments];
+	return {
+		curves: segments,
+		segmentsIn: segmentsOut === 1 ? segmentsOut : segmentsIn,
+		lastWasSame: segmentsOut === 1 ? null : lastWasSame
+	};
+}
+/**
+* Core boolean operation between two simple (non-compound) blueprints.
+*
+* Segments both blueprints at their intersection points, then selects which
+* segments to keep based on the `firstInside`/`secondInside` configuration.
+*/
+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;
+	let assembledCurves = segments.flatMap(([firstSegment, secondSegment]) => {
+		if (secondSegment === "same") {
+			const result = handleSameSegment(firstSegment, segmentsIn, lastWasSame);
+			segmentsIn = result.segmentsIn;
+			lastWasSame = result.lastWasSame;
+			return result.curves;
+		}
+		const result = selectSegments(firstSegment, secondSegment, first, second, config, segmentsIn, lastWasSame);
+		segmentsIn = result.segmentsIn;
+		lastWasSame = result.lastWasSame;
+		return result.curves;
+	});
+	const finalLastWasSame = lastWasSame;
+	if (finalLastWasSame !== null && segmentsIn === 1) assembledCurves = [...finalLastWasSame, ...assembledCurves];
+	const paths = splitPaths(mergeCollinearSegments(assembledCurves)).filter((b) => b.length > 0).map((b) => new Blueprint(b));
+	if (paths.length === 0) return null;
+	if (paths.length === 1) {
+		const single = paths[0];
+		if (single === void 0) return null;
+		return single;
+	}
+	return organiseBlueprints(paths);
+}
+function buildNoIntersectionResult(first, second) {
+	const firstCurve = first.curves[0];
+	const secondCurve = second.curves[0];
+	return {
+		identical: false,
+		firstCurveInSecond: firstCurve !== void 0 && second.isInside(curveMidPoint(firstCurve)),
+		secondCurveInFirst: secondCurve !== void 0 && first.isInside(curveMidPoint(secondCurve))
+	};
+}
+//#endregion
+//#region src/2d/blueprints/booleanOperations.ts
+/**
+* Boolean operations on 2D blueprints: fuse, cut, and intersect.
+*
+* This module is the public API. Internal logic is split across:
+* - `booleanHelpers.ts` — hashing, segment types, rotation utilities
+* - `intersectionSegments.ts` — curve intersection and segment pairing
+* - `segmentAssembly.ts` — segment selection and path assembly
+*/
+/**
+* Compute the boolean union of two simple blueprints.
+*
+* Segments each blueprint at their intersection points, discards segments
+* inside the other shape, and reassembles the remaining curves.
+*
+* @param first - First blueprint operand.
+* @param second - Second blueprint operand.
+* @returns The fused outline, a {@link Blueprints} if the result is
+*   disjoint, or `null` if the operation produces no geometry.
+*
+* @remarks Both blueprints must be closed. For compound or multi-blueprint
+* inputs, use {@link fuse2D} instead.
+*/
+function fuseBlueprints(first, second) {
+	const result = booleanOperation(first, second, {
+		firstInside: "remove",
+		secondInside: "remove"
+	});
+	if (result === null || result instanceof Blueprint || result instanceof Blueprints) return result;
+	if (result.identical) return first.clone();
+	if (result.firstCurveInSecond) return second.clone();
+	if (result.secondCurveInFirst) return first.clone();
+	return new Blueprints([first, second]);
+}
+/**
+* Compute the boolean difference of two simple blueprints (first minus second).
+*
+* Segments the blueprints at their intersections, keeps segments of the first
+* that are outside the second, and segments of the second that are inside the
+* first (reversed to form the boundary of the cut).
+*
+* @param first - Base blueprint to cut from.
+* @param second - Tool blueprint to subtract.
+* @returns The remaining outline, or `null` if nothing remains.
+*
+* @remarks Both blueprints must be closed. For compound inputs use {@link cut2D}.
+*/
+function cutBlueprints(first, second) {
+	const result = booleanOperation(first, second, {
+		firstInside: "remove",
+		secondInside: "keep"
+	});
+	if (result === null || result instanceof Blueprint || result instanceof Blueprints) return result;
+	if (result.identical) return null;
+	if (result.firstCurveInSecond) return null;
+	if (result.secondCurveInFirst) return new Blueprints([new CompoundBlueprint([first, second])]);
+	return first.clone();
+}
+/**
+* Compute the boolean intersection of two simple blueprints.
+*
+* Keeps only the segments of each blueprint that lie inside the other,
+* producing the overlapping region.
+*
+* @param first - First blueprint operand.
+* @param second - Second blueprint operand.
+* @returns The intersection outline, or `null` if the blueprints do not overlap.
+*
+* @remarks Both blueprints must be closed. For compound inputs use {@link intersect2D}.
+*/
+function intersectBlueprints(first, second) {
+	const result = booleanOperation(first, second, {
+		firstInside: "keep",
+		secondInside: "keep"
+	});
+	if (result === null || result instanceof Blueprint || result instanceof Blueprints) return result;
+	if (result.identical) return first.clone();
+	if (result.firstCurveInSecond) return first.clone();
+	if (result.secondCurveInFirst) return second.clone();
+	return null;
+}
+//#endregion
+//#region src/2d/blueprints/boolean2D.ts
+var genericIntersects = (first, second) => {
+	if (first instanceof Blueprint && second instanceof Blueprint) {
+		let allIntersections = [];
+		first.curves.forEach((thisCurve) => {
+			second.curves.forEach((otherCurve) => {
+				const { intersections, commonSegmentsPoints } = unwrap(intersectCurves(thisCurve, otherCurve));
+				allIntersections.push(...intersections);
+				allIntersections.push(...commonSegmentsPoints);
+			});
+		});
+		allIntersections = removeDuplicatePoints(allIntersections);
+		return allIntersections.length > 1;
+	}
+	if (first instanceof CompoundBlueprint || first instanceof Blueprints) return first.blueprints.some((bp) => genericIntersects(bp, second));
+	if (second instanceof CompoundBlueprint || second instanceof Blueprints) return second.blueprints.some((bp) => genericIntersects(first, bp));
+	bug("genericIntersects", "Unhandled shape combination in genericIntersects");
+};
+var genericFuse = (first, second) => {
+	if (first instanceof CompoundBlueprint) {
+		if (second instanceof Blueprint) return fuseBlueprintWithCompound(second, first);
+		if (second instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
+	}
+	if (second instanceof CompoundBlueprint) {
+		if (first instanceof Blueprint) return fuseBlueprintWithCompound(first, second);
+		if (first instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
+	}
+	if (first instanceof Blueprint && second instanceof Blueprint) return fuseBlueprints(first, second);
+	bug("genericFuse", "Unhandled shape combination in genericFuse");
+};
+var fuseIntersectingBlueprints = (blueprints) => {
+	const fused = /* @__PURE__ */ new Map();
+	const output = [];
+	blueprints.forEach((inputBlueprint, i) => {
+		let savedBlueprint;
+		if (fused.has(i)) savedBlueprint = fused.get(i);
+		else {
+			savedBlueprint = {
+				current: inputBlueprint,
+				fusedWith: new Set([i])
+			};
+			output.push(savedBlueprint);
+		}
+		blueprints.slice(i + 1).forEach((inputOtherBlueprint, j) => {
+			const blueprint = savedBlueprint.current;
+			const currentIndex = i + j + 1;
+			if (savedBlueprint.fusedWith.has(currentIndex)) return;
+			let otherBlueprint = inputOtherBlueprint;
+			let otherIsFused = false;
+			if (fused.has(currentIndex)) {
+				otherBlueprint = fused.get(currentIndex).current;
+				otherIsFused = true;
+			}
+			if (blueprint.boundingBox.isOut(otherBlueprint.boundingBox)) return;
+			if (!genericIntersects(blueprint, otherBlueprint)) return;
+			let newFused;
+			if (blueprint instanceof Blueprints || otherBlueprint instanceof Blueprints) {
+				const fused = fuse2D(blueprint, otherBlueprint);
+				if (fused === null) bug("fuseIntersectingBlueprints", "fuse2D returned null for non-null inputs");
+				newFused = fused;
+			} else newFused = genericFuse(blueprint, otherBlueprint);
+			if (!(newFused instanceof Blueprint || newFused instanceof CompoundBlueprint)) {
+				if (newFused instanceof Blueprints && newFused.blueprints.length === 2) return;
+				else if (newFused instanceof Blueprints && newFused.blueprints.length === 1) newFused = safeIndex(newFused.blueprints, 0, "fuseIntersectingBlueprints");
+				else if (!(newFused instanceof Blueprints)) bug("fuseIntersectingBlueprints", "Fuse produced unexpected non-blueprint result");
+			}
+			savedBlueprint.fusedWith.add(currentIndex);
+			savedBlueprint.current = newFused;
+			if (!otherIsFused) fused.set(currentIndex, savedBlueprint);
+		});
+	});
+	return organiseBlueprints(output.map(({ current }) => current).flatMap((b) => allBlueprints(b)));
+};
+var allBlueprints = (shape) => {
+	if (shape instanceof Blueprint) return [shape];
+	if (shape instanceof CompoundBlueprint) return shape.blueprints;
+	if (shape instanceof Blueprints) return shape.blueprints.flatMap((b) => allBlueprints(b));
+	return [];
+};
+var fuseBlueprintWithCompound = (blueprint, compound) => {
+	const outerFused = fuseBlueprints(blueprint, safeIndex(compound.blueprints, 0, "fuseBlueprintWithCompound"));
+	const innerFused = compound.blueprints.slice(1).map((c) => cutBlueprints(c, blueprint));
+	return organiseBlueprints([...allBlueprints(outerFused), ...innerFused.flatMap((fused) => allBlueprints(fused))]);
+};
+function allPairs(list1, list2) {
+	const result = [];
+	for (const l1 of list1) for (const l2 of list2) result.push([l1, l2]);
+	return result;
+}
+var fuseCompoundWithCompound = (first, second) => {
+	const firstOuter = safeIndex(first.blueprints, 0, "fuseCompoundWithCompound");
+	const secondOuter = safeIndex(second.blueprints, 0, "fuseCompoundWithCompound");
+	const outerFused = fuseBlueprints(firstOuter, secondOuter);
+	const inner1Fused = second.blueprints.slice(1).map((c) => cutBlueprints(c, firstOuter));
+	const inner2Fused = first.blueprints.slice(1).map((c) => cutBlueprints(c, secondOuter));
+	const innerIntersections = allPairs(first.blueprints.slice(1), second.blueprints.slice(1)).flatMap(([first, second]) => {
+		return allBlueprints(intersectBlueprints(first, second));
+	});
+	return organiseBlueprints([
+		...allBlueprints(outerFused),
+		...inner1Fused.flatMap((fused) => allBlueprints(fused)),
+		...inner2Fused.flatMap((fused) => allBlueprints(fused)),
+		...innerIntersections
+	]);
+};
+/**
+* Compute the boolean union of two 2D shapes.
+*
+* Handles all combinations of {@link Blueprint}, {@link CompoundBlueprint},
+* {@link Blueprints}, and `null`. When both inputs are simple blueprints the
+* operation delegates to {@link fuseBlueprints}; compound and multi-blueprint
+* cases are decomposed recursively.
+*
+* @param first - First operand (or `null` for empty).
+* @param second - Second operand (or `null` for empty).
+* @returns The fused shape, or `null` if both operands are empty.
+*
+* @example
+* ```ts
+* const union = fuse2D(circleBlueprint, squareBlueprint);
+* ```
+*
+* @see {@link fuse2D} for the functional API.
+*/
+var fuse2D = (first, second) => {
+	if (first === null) return second?.clone() ?? null;
+	if (second === null) return first.clone();
+	if (!(first instanceof Blueprints) && second instanceof Blueprints) return fuseIntersectingBlueprints([first, ...second.blueprints]);
+	if (!(second instanceof Blueprints) && first instanceof Blueprints) return fuseIntersectingBlueprints([second, ...first.blueprints]);
+	if (first instanceof Blueprints && second instanceof Blueprints) {
+		let out = fuse2D(safeIndex(first.blueprints, 0, "fuse2D"), second);
+		first.blueprints.slice(1).forEach((bp) => {
+			out = fuse2D(bp, out);
+		});
+		return out;
+	}
+	if (first instanceof CompoundBlueprint) {
+		if (second instanceof Blueprints) return fuse2D(second, first);
+		if (second instanceof Blueprint) return fuseBlueprintWithCompound(second, first);
+		if (second instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
+	}
+	if (second instanceof CompoundBlueprint) {
+		if (first instanceof Blueprints) return fuse2D(first, second);
+		if (first instanceof Blueprint) return fuseBlueprintWithCompound(first, second);
+		if (first instanceof CompoundBlueprint) return fuseCompoundWithCompound(first, second);
+	}
+	if (first instanceof Blueprint && second instanceof Blueprint) return fuseBlueprints(first, second);
+	return null;
+};
+var mergeNonIntersecting = (shapes) => {
+	const exploded = shapes.flatMap((s) => {
+		if (s === null) return [];
+		if (s instanceof Blueprints) return s.blueprints;
+		return s;
+	});
+	if (exploded.length === 1) return safeIndex(exploded, 0, "mergeNonIntersecting");
+	return new Blueprints(exploded);
+};
+/**
+* Compute the boolean difference of two 2D shapes (first minus second).
+*
+* Removes the region covered by `second` from `first`. When the tool is fully
+* inside the base, the result is a {@link CompoundBlueprint} (base with a
+* hole).
+*
+* @param first - Base shape to cut from.
+* @param second - Tool shape to subtract.
+* @returns The remaining shape, or `null` if nothing remains.
+*
+* @example
+* ```ts
+* const withHole = cut2D(outerRect, innerCircle);
+* ```
+*
+* @see {@link cut2D} for the functional API.
+*/
+var cut2D = (first, second) => {
+	if (first === null) return null;
+	if (second === null) return first.clone();
+	if (first instanceof Blueprints) return mergeNonIntersecting(first.blueprints.map((bp) => cut2D(bp, second)));
+	if (first instanceof CompoundBlueprint) {
+		const wrapper = safeIndex(first.blueprints, 0, "cut2D");
+		if (second instanceof Blueprint && !second.intersects(wrapper)) {
+			if (!wrapper.isInside(second.firstPoint)) return first.clone();
+			return organiseBlueprints([wrapper, ...allBlueprints(fuse2D(second, new Blueprints(first.blueprints.slice(1))))]);
+		} else {
+			let out = cut2D(wrapper, second);
+			first.blueprints.slice(1).forEach((bp) => {
+				out = cut2D(out, bp);
+			});
+			return out;
+		}
+	}
+	if (second instanceof Blueprints) {
+		let out = first;
+		for (const bp of second.blueprints) out = cut2D(out, bp);
+		return out;
+	}
+	if (second instanceof CompoundBlueprint) {
+		let out = cutBlueprints(first, safeIndex(second.blueprints, 0, "cut2D"));
+		second.blueprints.slice(1).forEach((bp) => {
+			out = fuse2D(out, intersectBlueprints(bp, first));
+		});
+		return out;
+	}
+	return cutBlueprints(first, second);
+};
+/**
+* Compute the boolean intersection of two 2D shapes.
+*
+* Returns only the region common to both shapes. Compound and multi-blueprint
+* operands are decomposed recursively, with holes handled via complementary
+* cut operations.
+*
+* @param first - First operand.
+* @param second - Second operand.
+* @returns The intersection shape, or `null` if the shapes do not overlap.
+*
+* @example
+* ```ts
+* const overlap = intersect2D(circle, rectangle);
+* ```
+*
+* @see {@link intersect2D} for the functional API.
+*/
+function intersect2D(first, second) {
+	if (first === null || second === null) return null;
+	if (first instanceof Blueprint && second instanceof Blueprint) return intersectBlueprints(first, second);
+	if (first instanceof Blueprints) return mergeNonIntersecting(first.blueprints.map((bp) => intersect2D(bp, second)));
+	if (first instanceof CompoundBlueprint) {
+		const wrapper = safeIndex(first.blueprints, 0, "intersect2D");
+		const cuts = first.blueprints.slice(1);
+		if (cuts.length === 0) return intersect2D(wrapper, second);
+		let result = intersect2D(wrapper, second);
+		for (const cut of cuts) result = cut2D(result, cut);
+		return result;
+	}
+	if (second instanceof Blueprints) return mergeNonIntersecting(second.blueprints.map((bp) => intersect2D(first, bp)));
+	if (second instanceof CompoundBlueprint) {
+		const wrapper = safeIndex(second.blueprints, 0, "intersect2D");
+		const cuts = second.blueprints.slice(1);
+		if (cuts.length === 0) return intersect2D(wrapper, first);
+		let result = intersect2D(wrapper, first);
+		for (const cut of cuts) result = cut2D(result, cut);
+		return result;
+	}
+	bug("intersect2D", "Unhandled Shape2D combination");
+}
+//#endregion
+export { fuseBlueprints as a, roundedRectangleBlueprint as c, cutBlueprints as i, fuse2D as n, intersectBlueprints as o, intersect2D as r, polysidesBlueprint as s, cut2D as t };