@faicad/faijs 0.13.0

package/dist/vendored/brepjs/2d/blueprints/boolean2D.js

@@ -0,0 +1,362 @@
+import { bug, safeIndex } from '../../core/errors.js';
+import { unwrap } from '../../core/result.js';
+import Blueprint from './blueprint.js';
+import Blueprints from './blueprints.js';
+import CompoundBlueprint from './compoundBlueprint.js';
+import { organiseBlueprints } from './lib.js';
+import { fuseBlueprints, cutBlueprints, intersectBlueprints } from './booleanOperations.js';
+import { intersectCurves, removeDuplicatePoints } from '../../2d/lib/index.js';
+const 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');
+};
+const 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');
+};
+const fuseIntersectingBlueprints = (blueprints) => {
+    const fused = 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) {
+                    // The generic intersects was wrong here - the intersection
+                    // points were only touching and not crossing
+                    return;
+                }
+                else if (newFused instanceof Blueprints && newFused.blueprints.length === 1) {
+                    // The generic intersects was wrong here - the intersection
+                    // points were only touching and not crossing
+                    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)));
+};
+const 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 [];
+};
+const 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;
+}
+const 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.
+ */
+export const 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;
+};
+// We assume that the shapes are not intersecting here - we do not check for it
+const 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.
+ */
+export const 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)) {
+            // Tool is entirely outside the compound shape — nothing to cut
+            if (!wrapper.isInside(second.firstPoint))
+                return first.clone();
+            const cuts = fuse2D(second, new Blueprints(first.blueprints.slice(1)));
+            return organiseBlueprints([wrapper, ...allBlueprints(cuts)]);
+        }
+        else {
+            let out = cut2D(wrapper, second);
+            first.blueprints.slice(1).forEach((bp) => {
+                out = cut2D(out, bp);
+            });
+            return out;
+        }
+    }
+    // From here the first is a simple blueprint
+    if (second instanceof Blueprints) {
+        // Apply cuts sequentially: first - a - b - c
+        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;
+    }
+    // Both are blueprints
+    const singleCut = cutBlueprints(first, second);
+    return singleCut;
+};
+/**
+ * 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.
+ */
+export 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) {
+        // blueprints[0] is the outer boundary (wrapper), remaining are holes (cuts)
+        const wrapper = safeIndex(first.blueprints, 0, 'intersect2D');
+        const cuts = first.blueprints.slice(1);
+        // If no holes, just intersect with the wrapper
+        if (cuts.length === 0) {
+            return intersect2D(wrapper, second);
+        }
+        // With holes, cut each from the intersection result
+        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) {
+        // blueprints[0] is the outer boundary (wrapper), remaining are holes (cuts)
+        const wrapper = safeIndex(second.blueprints, 0, 'intersect2D');
+        const cuts = second.blueprints.slice(1);
+        // If no holes, just intersect with the wrapper
+        if (cuts.length === 0) {
+            return intersect2D(wrapper, first);
+        }
+        // With holes, cut each from the intersection result
+        let result = intersect2D(wrapper, first);
+        for (const cut of cuts) {
+            result = cut2D(result, cut);
+        }
+        return result;
+    }
+    bug('intersect2D', 'Unhandled Shape2D combination');
+}
+//# sourceMappingURL=boolean2D.js.map

package/dist/vendored/brepjs/2d/blueprints/boolean2D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean2D.js","sourceRoot":"","sources":["../../../../../src/vendored/brepjs/2d/blueprints/boolean2D.ts"],"names":[],"mappings":"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","sourcesContent":["import { bug, safeIndex } from '../../core/errors.js';\nimport { unwrap } from '../../core/result.js';\nimport Blueprint from './blueprint.js';\nimport Blueprints from './blueprints.js';\nimport CompoundBlueprint from './compoundBlueprint.js';\nimport { organiseBlueprints } from './lib.js';\nimport { fuseBlueprints, cutBlueprints, intersectBlueprints } from './booleanOperations.js';\nimport type { Point2D } from '../../2d/lib/index.js';\nimport { intersectCurves, removeDuplicatePoints } from '../../2d/lib/index.js';\n\n/**\n * Union type for all 2D shape representations, including `null` for empty results.\n *\n * Used throughout the 2D boolean API as both input and output of operations.\n */\nexport type Shape2D = Blueprint | Blueprints | CompoundBlueprint | null;\n\nconst genericIntersects = (\n  first: Blueprint | CompoundBlueprint | Blueprints,\n  second: Blueprint | CompoundBlueprint | Blueprints\n): boolean => {\n  if (first instanceof Blueprint && second instanceof Blueprint) {\n    let allIntersections: Point2D[] = [];\n\n    first.curves.forEach((thisCurve) => {\n      second.curves.forEach((otherCurve) => {\n        const { intersections, commonSegmentsPoints } = unwrap(\n          intersectCurves(thisCurve, otherCurve)\n        );\n        allIntersections.push(...intersections);\n        allIntersections.push(...commonSegmentsPoints);\n      });\n    });\n\n    allIntersections = removeDuplicatePoints(allIntersections);\n    return allIntersections.length > 1;\n  }\n  if (first instanceof CompoundBlueprint || first instanceof Blueprints) {\n    return first.blueprints.some((bp) => genericIntersects(bp, second));\n  }\n  if (second instanceof CompoundBlueprint || second instanceof Blueprints) {\n    return second.blueprints.some((bp) => genericIntersects(first, bp));\n  }\n\n  bug('genericIntersects', 'Unhandled shape combination in genericIntersects');\n};\n\nconst genericFuse = (\n  first: Blueprint | CompoundBlueprint,\n  second: Blueprint | CompoundBlueprint\n): Blueprint | CompoundBlueprint | Blueprints | null => {\n  if (first instanceof CompoundBlueprint) {\n    if (second instanceof Blueprint) {\n      return fuseBlueprintWithCompound(second, first);\n    }\n    if (second instanceof CompoundBlueprint) {\n      return fuseCompoundWithCompound(first, second);\n    }\n  }\n\n  if (second instanceof CompoundBlueprint) {\n    if (first instanceof Blueprint) {\n      return fuseBlueprintWithCompound(first, second);\n    }\n    if (first instanceof CompoundBlueprint) {\n      return fuseCompoundWithCompound(first, second);\n    }\n  }\n\n  if (first instanceof Blueprint && second instanceof Blueprint) {\n    return fuseBlueprints(first, second);\n  }\n\n  bug('genericFuse', 'Unhandled shape combination in genericFuse');\n};\n\nconst fuseIntersectingBlueprints = (blueprints: (Blueprint | CompoundBlueprint)[]) => {\n  const fused = new Map();\n\n  const output: { current: Blueprint | CompoundBlueprint | Blueprints }[] = [];\n\n  blueprints.forEach((inputBlueprint, i) => {\n    let savedBlueprint: {\n      current: Blueprint | CompoundBlueprint | Blueprints;\n      fusedWith: Set<number>;\n    };\n\n    if (fused.has(i)) {\n      savedBlueprint = fused.get(i);\n    } else {\n      savedBlueprint = { current: inputBlueprint, fusedWith: new Set([i]) };\n      output.push(savedBlueprint);\n    }\n\n    blueprints.slice(i + 1).forEach((inputOtherBlueprint, j) => {\n      const blueprint = savedBlueprint.current;\n\n      const currentIndex = i + j + 1;\n\n      if (savedBlueprint.fusedWith.has(currentIndex)) return;\n\n      let otherBlueprint = inputOtherBlueprint;\n      let otherIsFused = false;\n\n      if (fused.has(currentIndex)) {\n        otherBlueprint = fused.get(currentIndex).current;\n        otherIsFused = true;\n      }\n\n      if (blueprint.boundingBox.isOut(otherBlueprint.boundingBox)) return;\n      if (!genericIntersects(blueprint, otherBlueprint)) return;\n\n      let newFused;\n      if (blueprint instanceof Blueprints || otherBlueprint instanceof Blueprints) {\n        const fused = fuse2D(blueprint, otherBlueprint);\n        if (fused === null) {\n          bug('fuseIntersectingBlueprints', 'fuse2D returned null for non-null inputs');\n        }\n        newFused = fused;\n      } else {\n        newFused = genericFuse(blueprint, otherBlueprint);\n      }\n      if (!(newFused instanceof Blueprint || newFused instanceof CompoundBlueprint)) {\n        if (newFused instanceof Blueprints && newFused.blueprints.length === 2) {\n          // The generic intersects was wrong here - the intersection\n          // points were only touching and not crossing\n          return;\n        } else if (newFused instanceof Blueprints && newFused.blueprints.length === 1) {\n          // The generic intersects was wrong here - the intersection\n          // points were only touching and not crossing\n          newFused = safeIndex(newFused.blueprints, 0, 'fuseIntersectingBlueprints');\n        } else if (!(newFused instanceof Blueprints)) {\n          bug('fuseIntersectingBlueprints', 'Fuse produced unexpected non-blueprint result');\n        }\n      }\n      savedBlueprint.fusedWith.add(currentIndex);\n      savedBlueprint.current = newFused;\n      if (!otherIsFused) fused.set(currentIndex, savedBlueprint);\n    });\n  });\n\n  return organiseBlueprints(output.map(({ current }) => current).flatMap((b) => allBlueprints(b)));\n};\n\nconst allBlueprints = (shape: Shape2D): Blueprint[] => {\n  if (shape instanceof Blueprint) return [shape];\n  if (shape instanceof CompoundBlueprint) return shape.blueprints;\n  if (shape instanceof Blueprints) return shape.blueprints.flatMap((b) => allBlueprints(b));\n  return [];\n};\n\nconst fuseBlueprintWithCompound = (blueprint: Blueprint, compound: CompoundBlueprint) => {\n  const outerFused = fuseBlueprints(\n    blueprint,\n    safeIndex(compound.blueprints, 0, 'fuseBlueprintWithCompound')\n  );\n  const innerFused = compound.blueprints.slice(1).map((c) => cutBlueprints(c, blueprint));\n\n  return organiseBlueprints([\n    ...allBlueprints(outerFused),\n    ...innerFused.flatMap((fused) => allBlueprints(fused)),\n  ]);\n};\n\nfunction allPairs<S, T>(list1: T[], list2: S[]): [T, S][] {\n  const result: [T, S][] = [];\n\n  for (const l1 of list1) {\n    for (const l2 of list2) {\n      result.push([l1, l2]);\n    }\n  }\n\n  return result;\n}\n\nconst fuseCompoundWithCompound = (first: CompoundBlueprint, second: CompoundBlueprint) => {\n  const firstOuter = safeIndex(first.blueprints, 0, 'fuseCompoundWithCompound');\n  const secondOuter = safeIndex(second.blueprints, 0, 'fuseCompoundWithCompound');\n  const outerFused = fuseBlueprints(firstOuter, secondOuter);\n\n  const inner1Fused = second.blueprints.slice(1).map((c) => cutBlueprints(c, firstOuter));\n\n  const inner2Fused = first.blueprints.slice(1).map((c) => cutBlueprints(c, secondOuter));\n\n  const innerIntersections = allPairs(\n    first.blueprints.slice(1),\n    second.blueprints.slice(1)\n  ).flatMap(([first, second]) => {\n    return allBlueprints(intersectBlueprints(first, second));\n  });\n\n  return organiseBlueprints([\n    ...allBlueprints(outerFused),\n    ...inner1Fused.flatMap((fused) => allBlueprints(fused)),\n    ...inner2Fused.flatMap((fused) => allBlueprints(fused)),\n    ...innerIntersections,\n  ]);\n};\n\n/**\n * Compute the boolean union of two 2D shapes.\n *\n * Handles all combinations of {@link Blueprint}, {@link CompoundBlueprint},\n * {@link Blueprints}, and `null`. When both inputs are simple blueprints the\n * operation delegates to {@link fuseBlueprints}; compound and multi-blueprint\n * cases are decomposed recursively.\n *\n * @param first - First operand (or `null` for empty).\n * @param second - Second operand (or `null` for empty).\n * @returns The fused shape, or `null` if both operands are empty.\n *\n * @example\n * ```ts\n * const union = fuse2D(circleBlueprint, squareBlueprint);\n * ```\n *\n * @see {@link fuse2D} for the functional API.\n */\nexport const fuse2D = (\n  first: Shape2D,\n  second: Shape2D\n): Blueprint | Blueprints | CompoundBlueprint | null => {\n  if (first === null) {\n    return second?.clone() ?? null;\n  }\n  if (second === null) {\n    return first.clone();\n  }\n\n  if (!(first instanceof Blueprints) && second instanceof Blueprints) {\n    return fuseIntersectingBlueprints([first, ...second.blueprints]);\n  }\n  if (!(second instanceof Blueprints) && first instanceof Blueprints) {\n    return fuseIntersectingBlueprints([second, ...first.blueprints]);\n  }\n  if (first instanceof Blueprints && second instanceof Blueprints) {\n    let out = fuse2D(safeIndex(first.blueprints, 0, 'fuse2D'), second);\n\n    first.blueprints.slice(1).forEach((bp) => {\n      out = fuse2D(bp, out);\n    });\n    return out;\n  }\n\n  if (first instanceof CompoundBlueprint) {\n    if (second instanceof Blueprints) {\n      return fuse2D(second, first);\n    }\n    if (second instanceof Blueprint) {\n      return fuseBlueprintWithCompound(second, first);\n    }\n    if (second instanceof CompoundBlueprint) {\n      return fuseCompoundWithCompound(first, second);\n    }\n  }\n\n  if (second instanceof CompoundBlueprint) {\n    if (first instanceof Blueprints) {\n      return fuse2D(first, second);\n    }\n    if (first instanceof Blueprint) {\n      return fuseBlueprintWithCompound(first, second);\n    }\n    if (first instanceof CompoundBlueprint) {\n      return fuseCompoundWithCompound(first, second);\n    }\n  }\n\n  if (first instanceof Blueprint && second instanceof Blueprint) {\n    return fuseBlueprints(first, second);\n  }\n  return null;\n};\n\n// We assume that the shapes are not intersecting here - we do not check for it\nconst mergeNonIntersecting = (shapes: Shape2D[]) => {\n  const exploded: (CompoundBlueprint | Blueprint)[] = shapes.flatMap((s) => {\n    if (s === null) return [];\n    if (s instanceof Blueprints) return s.blueprints;\n    return s;\n  });\n  if (exploded.length === 1) return safeIndex(exploded, 0, 'mergeNonIntersecting');\n  return new Blueprints(exploded);\n};\n\n/**\n * Compute the boolean difference of two 2D shapes (first minus second).\n *\n * Removes the region covered by `second` from `first`. When the tool is fully\n * inside the base, the result is a {@link CompoundBlueprint} (base with a\n * hole).\n *\n * @param first - Base shape to cut from.\n * @param second - Tool shape to subtract.\n * @returns The remaining shape, or `null` if nothing remains.\n *\n * @example\n * ```ts\n * const withHole = cut2D(outerRect, innerCircle);\n * ```\n *\n * @see {@link cut2D} for the functional API.\n */\nexport const cut2D = (\n  first: Shape2D,\n  second: Shape2D\n): Blueprint | Blueprints | CompoundBlueprint | null => {\n  if (first === null) {\n    return null;\n  }\n  if (second === null) {\n    return first.clone();\n  }\n\n  if (first instanceof Blueprints) {\n    return mergeNonIntersecting(first.blueprints.map((bp) => cut2D(bp, second)));\n  }\n\n  if (first instanceof CompoundBlueprint) {\n    const wrapper = safeIndex(first.blueprints, 0, 'cut2D');\n    if (second instanceof Blueprint && !second.intersects(wrapper)) {\n      // Tool is entirely outside the compound shape — nothing to cut\n      if (!wrapper.isInside(second.firstPoint)) return first.clone();\n      const cuts = fuse2D(second, new Blueprints(first.blueprints.slice(1)));\n      return organiseBlueprints([wrapper, ...allBlueprints(cuts)]);\n    } else {\n      let out = cut2D(wrapper, second);\n      first.blueprints.slice(1).forEach((bp) => {\n        out = cut2D(out, bp);\n      });\n      return out;\n    }\n  }\n\n  // From here the first is a simple blueprint\n  if (second instanceof Blueprints) {\n    // Apply cuts sequentially: first - a - b - c\n    let out: Shape2D = first;\n    for (const bp of second.blueprints) {\n      out = cut2D(out, bp);\n    }\n    return out;\n  }\n\n  if (second instanceof CompoundBlueprint) {\n    let out: Shape2D = cutBlueprints(first, safeIndex(second.blueprints, 0, 'cut2D'));\n    second.blueprints.slice(1).forEach((bp) => {\n      out = fuse2D(out, intersectBlueprints(bp, first));\n    });\n    return out;\n  }\n\n  // Both are blueprints\n  const singleCut = cutBlueprints(first, second);\n  return singleCut;\n};\n\n/**\n * Compute the boolean intersection of two 2D shapes.\n *\n * Returns only the region common to both shapes. Compound and multi-blueprint\n * operands are decomposed recursively, with holes handled via complementary\n * cut operations.\n *\n * @param first - First operand.\n * @param second - Second operand.\n * @returns The intersection shape, or `null` if the shapes do not overlap.\n *\n * @example\n * ```ts\n * const overlap = intersect2D(circle, rectangle);\n * ```\n *\n * @see {@link intersect2D} for the functional API.\n */\nexport function intersect2D(\n  first: Shape2D,\n  second: Shape2D\n): Blueprint | Blueprints | CompoundBlueprint | null {\n  if (first === null || second === null) {\n    return null;\n  }\n\n  if (first instanceof Blueprint && second instanceof Blueprint) {\n    return intersectBlueprints(first, second);\n  }\n\n  if (first instanceof Blueprints) {\n    return mergeNonIntersecting(first.blueprints.map((bp) => intersect2D(bp, second)));\n  }\n\n  if (first instanceof CompoundBlueprint) {\n    // blueprints[0] is the outer boundary (wrapper), remaining are holes (cuts)\n    const wrapper = safeIndex(first.blueprints, 0, 'intersect2D');\n    const cuts = first.blueprints.slice(1);\n\n    // If no holes, just intersect with the wrapper\n    if (cuts.length === 0) {\n      return intersect2D(wrapper, second);\n    }\n    // With holes, cut each from the intersection result\n    let result = intersect2D(wrapper, second);\n    for (const cut of cuts) {\n      result = cut2D(result, cut);\n    }\n    return result;\n  }\n\n  if (second instanceof Blueprints) {\n    return mergeNonIntersecting(second.blueprints.map((bp) => intersect2D(first, bp)));\n  }\n\n  if (second instanceof CompoundBlueprint) {\n    // blueprints[0] is the outer boundary (wrapper), remaining are holes (cuts)\n    const wrapper = safeIndex(second.blueprints, 0, 'intersect2D');\n    const cuts = second.blueprints.slice(1);\n\n    // If no holes, just intersect with the wrapper\n    if (cuts.length === 0) {\n      return intersect2D(wrapper, first);\n    }\n    // With holes, cut each from the intersection result\n    let result = intersect2D(wrapper, first);\n    for (const cut of cuts) {\n      result = cut2D(result, cut);\n    }\n    return result;\n  }\n\n  bug('intersect2D', 'Unhandled Shape2D combination');\n}\n"]}

package/dist/vendored/brepjs/2d/blueprints/booleanHelpers.d.ts

@@ -0,0 +1,34 @@
+import type { Point2D, Curve2D } from '../../2d/lib/index.js';
+export declare const samePoint: (x: Point2D, y: Point2D) => boolean;
+/**
+ * Hash a point for Set/Map lookup using precision rounding.
+ * Must match PRECISION_INTERSECTION (1e-9) to avoid hash collisions for
+ * nearly-equal points.
+ */
+export declare function hashPoint(p: Point2D): string;
+/**
+ * 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.
+ */
+export declare function hashSegment(first: Point2D, last: Point2D): string;
+export type Segment = Curve2D[];
+export type IntersectionSegment = [Segment, Segment | 'same'];
+export declare function startOfSegment(s: Segment): Point2D;
+export declare function endOfSegment(s: Segment): Point2D;
+export declare function reverseSegment(segment: Segment): Segment;
+export declare function reverseSegments(segments: Segment[]): Segment[];
+export declare function curveMidPoint(curve: Curve2D): Point2D;
+/**
+ * Rotate the curves array so that it starts at the curve whose firstPoint
+ * matches the given point.
+ */
+export declare function rotateToStartAt(curves: Curve2D[], point: Point2D): Curve2D[];
+/**
+ * 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.
+ */
+export declare function rotateToStartAtSegment(curves: Curve2D[], segment: Curve2D): Curve2D[];
+//# sourceMappingURL=booleanHelpers.d.ts.map

package/dist/vendored/brepjs/2d/blueprints/booleanHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"booleanHelpers.d.ts","sourceRoot":"","sources":["../../../../../src/vendored/brepjs/2d/blueprints/booleanHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAQ9D,eAAO,MAAM,SAAS,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,KAAG,OACH,CAAC;AAMjD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAE5C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,CAIjE;AAMD,MAAM,MAAM,OAAO,GAAG,OAAO,EAAE,CAAC;AAChC,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;AAE9D,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAMlD;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAMhD;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAMxD;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,CAE9D;AAMD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAGrD;AA0ED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,EAAE,CAG5E;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,EAAE,CAgDrF"}

package/dist/vendored/brepjs/2d/blueprints/booleanHelpers.js

@@ -0,0 +1,176 @@
+import { samePoint as defaultSamePoint, PRECISION_INTERSECTION } from '../../2d/lib/index.js';
+import { bug } from '../../core/errors.js';
+// ---------------------------------------------------------------------------
+// Precision-aware point comparison
+// ---------------------------------------------------------------------------
+export const samePoint = (x, y) => defaultSamePoint(x, y, PRECISION_INTERSECTION);
+// ---------------------------------------------------------------------------
+// Hashing utilities for O(1) lookup of points and segments
+// ---------------------------------------------------------------------------
+/**
+ * Hash a point for Set/Map lookup using precision rounding.
+ * Must match PRECISION_INTERSECTION (1e-9) to avoid hash collisions for
+ * nearly-equal points.
+ */
+export 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.
+ */
+export function hashSegment(first, last) {
+    const h1 = hashPoint(first);
+    const h2 = hashPoint(last);
+    return h1 < h2 ? `${h1}|${h2}` : `${h2}|${h1}`;
+}
+export function startOfSegment(s) {
+    const first = s[0];
+    if (first === undefined) {
+        bug('startOfSegment', 'empty segment');
+    }
+    return first.firstPoint;
+}
+export function endOfSegment(s) {
+    const last = s[s.length - 1];
+    if (last === undefined) {
+        bug('endOfSegment', 'empty segment');
+    }
+    return last.lastPoint;
+}
+export function reverseSegment(segment) {
+    return [...segment].reverse().map((curve) => {
+        const newCurve = curve.clone();
+        newCurve.reverse();
+        return newCurve;
+    });
+}
+export function reverseSegments(segments) {
+    return [...segments].reverse().map(reverseSegment);
+}
+// ---------------------------------------------------------------------------
+// Curve midpoint evaluation
+// ---------------------------------------------------------------------------
+export function curveMidPoint(curve) {
+    const midParameter = (curve.lastParameter + curve.firstParameter) / 2;
+    return curve.value(midParameter);
+}
+// ---------------------------------------------------------------------------
+// Array rotation helpers
+// ---------------------------------------------------------------------------
+/**
+ * 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);
+    // Fast path: hash + tolerance
+    for (let i = 0; i < curves.length; i++) {
+        const curve = curves[i];
+        if (curve === undefined)
+            continue;
+        if (hashPoint(curve.firstPoint) === targetHash && samePoint(point, curve.firstPoint)) {
+            return i;
+        }
+    }
+    // Fallback: tolerance-only (handles hash mismatches at rounding boundaries)
+    for (let i = 0; i < curves.length; i++) {
+        const curve = curves[i];
+        if (curve === undefined)
+            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) {
+    // Fast path: hash + tolerance
+    for (let i = 0; i < curves.length; i++) {
+        const curve = curves[i];
+        if (curve === undefined)
+            continue;
+        if (hashPoint(curve.firstPoint) === segFirstHash &&
+            hashPoint(curve.lastPoint) === segLastHash &&
+            matchesFn(curve)) {
+            return i;
+        }
+    }
+    // Fallback: tolerance-only (handles hash mismatches at rounding boundaries)
+    for (let i = 0; i < curves.length; i++) {
+        const curve = curves[i];
+        if (curve === undefined)
+            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.
+ */
+export function rotateToStartAt(curves, point) {
+    const startIndex = findCurveIndexByStartPoint(curves, point);
+    return rotateArray(curves, startIndex);
+}
+/**
+ * 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.
+ */
+export function rotateToStartAtSegment(curves, segment) {
+    const segFirstHash = hashPoint(segment.firstPoint);
+    const segLastHash = hashPoint(segment.lastPoint);
+    // matchesForward: curve runs in the same direction as segment (first→last)
+    const matchesForward = (curve) => samePoint(segment.firstPoint, curve.firstPoint) &&
+        samePoint(segment.lastPoint, curve.lastPoint);
+    // matchesFlipped: curve runs opposite to segment (last→first)
+    const matchesFlipped = (curve) => samePoint(segment.lastPoint, curve.firstPoint) &&
+        samePoint(segment.firstPoint, curve.lastPoint);
+    // Attempt to locate the segment in `chain` and return a rotated result.
+    // Returns null when the segment is not found in the chain.
+    function tryRotate(chain, firstHash, lastHash, matchFn) {
+        const idx = findCurveIndexBySegment(chain, firstHash, lastHash, matchFn);
+        return idx !== -1 ? rotateArray(chain, idx) : null;
+    }
+    // Try forward segment on forward curves
+    const fwdFwd = tryRotate(curves, segFirstHash, segLastHash, matchesForward);
+    if (fwdFwd !== null)
+        return fwdFwd;
+    // Try flipped segment on forward curves (common segment oriented opposite).
+    // Expected to trigger only for secondCurveSegments — allCommonSegments[0]
+    // is oriented with the first blueprint's curve direction, so firstCurveSegments
+    // should always match via fwdFwd. The downstream reversal in
+    // blueprintsIntersectionSegments always flips secondIntersectedSegments.
+    const flipFwd = tryRotate(curves, segLastHash, segFirstHash, matchesFlipped);
+    if (flipFwd !== null)
+        return flipFwd;
+    // Reverse the chain once; try both segment orientations against it
+    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');
+}
+//# sourceMappingURL=booleanHelpers.js.map