@weasel-js/geom 1.9.3 → 1.10.0

package/dist/3d/index.js

@@ -1,6 +1,6 @@
 import { PORT_REACH, portControls, portCurvePoints, cubicAt } from '../chunk-YQADYJJ7.js';
 export { PORT_REACH } from '../chunk-YQADYJJ7.js';
-import { SINGULAR_RATIO } from '../chunk-7ROQRYOA.js';
+import { SINGULAR_RATIO } from '../chunk-755Y4YZS.js';
 
 // src/3d/vec3.ts
 function add(a, b) {

package/dist/booleans/index.d.ts

@@ -1,5 +1,5 @@
-import { P as Path, a as PolygonPath } from '../path-D0CoudGM.js';
-import { P as Point } from '../cubicMath-CpCvuEl8.js';
+import { P as PolygonPath, a as Path } from '../path-Bf9KeVxC.js';
+import { P as Point } from '../cubicMath-CFXbq6vp.js';
 
 /** Union of N paths. Commutative. Returns an empty path if all inputs are empty. */
 declare function pathUnion(...paths: Path[]): PolygonPath;
@@ -9,30 +9,55 @@ declare function pathIntersect(...paths: Path[]): PolygonPath;
 declare function pathSubtract(a: Path, b: Path): PolygonPath;
 /** Symmetric difference (XOR) of N paths. Commutative. */
 declare function pathExclude(...paths: Path[]): PolygonPath;
+/** One path of a result that keeps its pieces apart, and the inputs it came
+ *  from: their indices in the call, ascending, so the last is the topmost of
+ *  inputs given back to front. */
+interface BooleanPiece {
+    path: PolygonPath;
+    sources: number[];
+}
+/** {@link pathDividePieces} as bare paths. */
+declare function pathDivide(...paths: Path[]): PolygonPath[];
+/** {@link pathCropPieces} as bare paths. */
+declare function pathCrop(...paths: Path[]): PolygonPath[];
 /**
  * Fracture N paths along every intersection into the maximal set of
- * non-overlapping regions. Returns one polygon path per region.
- *
- * Algorithm: for every non-empty subset S ⊆ {A1..AN}, emit the region
- * `(∩ S) − (∪ complement)` — points covered by exactly the members of S
- * and no others. By construction the emitted regions are pairwise disjoint
- * and their union equals `pathUnion(A1..AN)`.
+ * non-overlapping regions. Returns one piece per region, naming every input
+ * that covers it. For N=2 these are the three Illustrator "Divide" outputs
+ * (A−B, B−A, A∩B).
  *
- * For N=2 this collapses to the three Illustrator "Divide" outputs
- * (A−B, B−A, A∩B). For N=3 up to 7 regions are emitted. The 2^N − 1
- * subset count limits this to small N in practice; passing more than ~8
- * inputs is a misuse — the polygon-clipping kernel dominates anyway.
+ * One region per non-empty subset of the inputs, so the 2^N − 1 subset count
+ * limits this to small N; passing more than ~8 inputs is a misuse.
  */
-declare function pathDivide(...paths: Path[]): PolygonPath[];
+declare function pathDividePieces(...paths: Path[]): BooleanPiece[];
 /**
- * Clip each non-topmost path to the topmost path (Illustrator "Crop").
- * Returns `N - 1` results, one per source-below-top, in input order.
- * Discards the topmost path itself — it acts purely as the clipping mask.
- *
- * Empty results (a source that lies entirely outside the mask) are
- * filtered. With `<2` inputs the result is empty.
+ * Remove from each path what the paths after it cover (Illustrator "Trim"):
+ * given back to front, every piece is the part of its input left showing.
+ * One piece per input in input order, less the inputs wholly hidden.
  */
-declare function pathCrop(...paths: Path[]): PolygonPath[];
+declare function pathTrim(...paths: Path[]): BooleanPiece[];
+/**
+ * {@link pathTrim}, then unite the pieces of the inputs `keyOf` gives the same
+ * key (Illustrator "Merge", keyed by paint). Keys compare with `===`. A piece
+ * names every input left showing in it, and the pieces are ordered by their
+ * topmost one. Pieces that share a key and do not touch come back as one path
+ * of several contours.
+ */
+declare function pathMerge(paths: readonly Path[], keyOf: (index: number) => unknown): BooleanPiece[];
+/**
+ * Clip each non-topmost path to the topmost path (Illustrator "Crop"), which
+ * acts purely as the mask and is discarded. Returns up to `N - 1` pieces in
+ * input order, each naming the one input it was clipped from; a source
+ * entirely outside the mask is dropped.
+ */
+declare function pathCropPieces(...paths: Path[]): BooleanPiece[];
+
+/**
+ * Union the triangles of an indexed mesh (`vertices` as x, y pairs; `indices`
+ * three per triangle) into canonical, non-overlapping rings. Overlaps count
+ * once, and triangles with no area are skipped. The result holds only M/L/Z.
+ */
+declare function trianglesToPath(vertices: ArrayLike<number>, indices: ArrayLike<number>): PolygonPath;
 
 /** A `[x, y]` 2-tuple. */
 type Pair = [number, number];
@@ -67,16 +92,13 @@ interface SplitBySegmentOptions {
  */
 declare function splitPathBySegment(path: Path, a: Point, b: Point, opts?: SplitBySegmentOptions): Path[] | null;
 /**
- * Split `path` along the open polyline `cut` into closed pieces (Knife). A
- * freehand cut is a polyline through its samples.
+ * Split `path` along the open polyline `cut` into closed pieces (Knife).
  *
  * Only chords the cut crosses end to end are cut: a stretch of the cut that
  * starts or stops inside the fill cuts nothing, and nothing beyond the cut's
- * ends is touched, so a concave shape splits exactly where the stroke crosses
- * it. Curves are split at the crossing parameters by de Casteljau
- * subdivision, so every piece traces the original boundary exactly and keeps
- * its quadratic and cubic segments; the new edges follow the cut as straight
- * lines, bends included.
+ * ends is touched. Curves are split at the crossing parameters by de Casteljau
+ * subdivision, so every piece keeps its quadratic and cubic segments; the new
+ * edges follow the cut as straight lines, bends included.
  *
  * A loop the cut draws inside the fill, where it crosses its own track, cuts
  * out the region it encloses: that region is returned as its own piece, with
@@ -84,7 +106,7 @@ declare function splitPathBySegment(path: Path, a: Point, b: Point, opts?: Split
  * running through a loop leaves the loop uncut. A closed cut (its last point
  * equal to its first) is one such loop or, where it crosses the boundary, is
  * cut as the chords it makes. Chords that cross each other are cut one after
- * another, so a cross-hatch yields every piece.
+ * another.
  *
  * Each connected piece the cut produces is returned as its own path, holes
  * included. Contours the cut misses entirely are returned together as one
@@ -115,4 +137,4 @@ declare function splitPathByPolyline(path: Path, cut: readonly Point[], opts?: S
  */
 declare function snipPathByPolyline(path: Path, cut: readonly Point[]): Path[] | null;
 
-export { type MultiPolygon, type Pair, type PathToMultiPolygonOptions, type Polygon, type Ring, type SplitBySegmentOptions, multiPolygonToPath, pathCrop, pathDivide, pathExclude, pathIntersect, pathSubtract, pathToMultiPolygon, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment };
+export { type BooleanPiece, type MultiPolygon, type Pair, type PathToMultiPolygonOptions, type Polygon, type Ring, type SplitBySegmentOptions, multiPolygonToPath, pathCrop, pathCropPieces, pathDivide, pathDividePieces, pathExclude, pathIntersect, pathMerge, pathSubtract, pathToMultiPolygon, pathTrim, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment, trianglesToPath };