@weasel-js/geom 1.10.0 → 1.11.0

package/dist/booleans/index.js

@@ -1,11 +1,13 @@
-import { elevateQuadraticToCubic, splitQuadraticAt, splitCubicAt } from '../chunk-URQMDR6Q.js';
-import { DEFAULT_FLATTEN_TOLERANCE, fillsOpenSubpaths, flattenCubic, segmentsCross, pointInPolygon } from '../chunk-WQMYOCFB.js';
-import { EPS } from '../chunk-755Y4YZS.js';
-import { PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M } from '../chunk-OXH3NOXC.js';
+import { orientBoundaries, parseContours, contoursIntersect, assembleRegions, signedArea, negligibleArea, regionArea, toPath, parseSubpaths, writePath, signChanges, sideCoeffs, evalSeg, extentOf, keepCorners, windingAt, reverseContour, sampleContour, subSeg, endSide } from '../chunk-7KLJZFBY.js';
+import '../chunk-CE7IY7TB.js';
+import { resolveCorners, DEFAULT_FLATTEN_TOLERANCE, fillsOpenSubpaths, flattenCubic, flattenQuadratic, pointInPolygon } from '../chunk-J2O2B54M.js';
+import '../chunk-755Y4YZS.js';
+import { PATH_Z, PATH_Q, elevateQuadraticToCubic, PATH_C, PATH_L, PATH_M } from '../chunk-B53BERKG.js';
 import polygonClipping from 'polygon-clipping';
 
 // src/booleans/adapter.ts
-function pathToMultiPolygon(path, opts = {}) {
+function pathToMultiPolygon(given, opts = {}) {
+  const path = resolveCorners(given);
   if (path.kind === "rect") {
     const { x, y, width, height } = path;
     const ring = [
@@ -214,27 +216,297 @@ function multiPolygonToPath(mp) {
   return { kind: "polygon", commands, coords, fillRule: "nonzero" };
 }
 
+// src/booleans/arrangement.ts
+var VertexPool = class {
+  constructor(eps) {
+    this.eps = eps;
+    this.cell = eps * 2;
+  }
+  eps;
+  xs = [];
+  ys = [];
+  cells = /* @__PURE__ */ new Map();
+  cell;
+  id(x, y) {
+    const cx = Math.floor(x / this.cell), cy = Math.floor(y / this.cell);
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        for (const v2 of this.cells.get(`${cx + dx},${cy + dy}`) ?? []) {
+          if (Math.abs(this.xs[v2] - x) <= this.eps && Math.abs(this.ys[v2] - y) <= this.eps) return v2;
+        }
+      }
+    }
+    const v = this.xs.length;
+    this.xs.push(x);
+    this.ys.push(y);
+    const key = `${cx},${cy}`;
+    const bucket = this.cells.get(key);
+    if (bucket) bucket.push(v);
+    else this.cells.set(key, [v]);
+    return v;
+  }
+};
+function segmentsOf(inputs) {
+  const segs = [];
+  let extent = 0;
+  inputs.forEach((mp, input) => {
+    for (const polygon of mp) {
+      for (const ring of polygon) {
+        for (let k = 0; k + 1 < ring.length; k++) {
+          const [ax, ay] = ring[k];
+          const [bx, by] = ring[k + 1];
+          if (ax === bx && ay === by) continue;
+          extent = Math.max(extent, Math.abs(ax), Math.abs(ay), Math.abs(bx), Math.abs(by));
+          segs.push({
+            ax,
+            ay,
+            bx,
+            by,
+            input,
+            minX: Math.min(ax, bx),
+            maxX: Math.max(ax, bx),
+            minY: Math.min(ay, by),
+            maxY: Math.max(ay, by),
+            cuts: []
+          });
+        }
+      }
+    }
+  });
+  return { segs, extent };
+}
+function cutAtPoint(seg, px, py, eps) {
+  const rx = seg.bx - seg.ax, ry = seg.by - seg.ay;
+  const len2 = rx * rx + ry * ry;
+  const t = ((px - seg.ax) * rx + (py - seg.ay) * ry) / len2;
+  if (t <= 0 || t >= 1) return;
+  const ex = seg.ax + t * rx - px, ey = seg.ay + t * ry - py;
+  if (ex * ex + ey * ey <= eps * eps) seg.cuts.push({ t, x: px, y: py });
+}
+function cutPair(s, o, eps) {
+  const rx = s.bx - s.ax, ry = s.by - s.ay;
+  const sx = o.bx - o.ax, sy = o.by - o.ay;
+  const d = rx * sy - ry * sx;
+  const lenR = Math.hypot(rx, ry), lenS = Math.hypot(sx, sy);
+  if (Math.abs(d) > 1e-12 * lenR * lenS) {
+    const qx = o.ax - s.ax, qy = o.ay - s.ay;
+    const t = (qx * sy - qy * sx) / d;
+    const u = (qx * ry - qy * rx) / d;
+    const tolT = eps / lenR, tolU = eps / lenS;
+    if (t > -tolT && t < 1 + tolT && u > -tolU && u < 1 + tolU) {
+      const tc = Math.min(1, Math.max(0, t));
+      const x = s.ax + tc * rx, y = s.ay + tc * ry;
+      s.cuts.push({ t: tc, x, y });
+      o.cuts.push({ t: Math.min(1, Math.max(0, u)), x, y });
+    }
+  }
+  cutAtPoint(s, o.ax, o.ay, eps);
+  cutAtPoint(s, o.bx, o.by, eps);
+  cutAtPoint(o, s.ax, s.ay, eps);
+  cutAtPoint(o, s.bx, s.by, eps);
+}
+function cutAll(segs, eps) {
+  const order = segs.map((_, i) => i).sort((i, j) => segs[i].minX - segs[j].minX);
+  for (let a = 0; a < order.length; a++) {
+    const s = segs[order[a]];
+    for (let b = a + 1; b < order.length; b++) {
+      const o = segs[order[b]];
+      if (o.minX > s.maxX + eps) break;
+      if (o.minY > s.maxY + eps || o.maxY < s.minY - eps) continue;
+      cutPair(s, o, eps);
+    }
+  }
+}
+function linkFaces(xs, ys, origin) {
+  const out = xs.map(() => []);
+  const angle = [];
+  for (let h = 0; h < origin.length; h++) {
+    const u = origin[h], v = origin[h ^ 1];
+    out[u].push(h);
+    angle[h] = Math.atan2(ys[v] - ys[u], xs[v] - xs[u]);
+  }
+  const slot = [];
+  for (const list of out) {
+    list.sort((a, b) => angle[a] - angle[b]);
+    list.forEach((h, k) => {
+      slot[h] = k;
+    });
+  }
+  return origin.map((_, h) => {
+    const list = out[origin[h ^ 1]];
+    return list[(slot[h ^ 1] - 1 + list.length) % list.length];
+  });
+}
+function buildArrangement(inputs) {
+  const { segs, extent } = segmentsOf(inputs);
+  const eps = 1e-9 * Math.max(1, extent);
+  cutAll(segs, eps);
+  const pool = new VertexPool(eps);
+  const edges = /* @__PURE__ */ new Map();
+  for (const seg of segs) {
+    const points = [{ t: 0, x: seg.ax, y: seg.ay }, ...seg.cuts, { t: 1, x: seg.bx, y: seg.by }].sort((a, b) => a.t - b.t);
+    const bit = 1n << BigInt(seg.input);
+    let prev = pool.id(points[0].x, points[0].y);
+    for (let k = 1; k < points.length; k++) {
+      const id = pool.id(points[k].x, points[k].y);
+      if (id === prev) continue;
+      const u = Math.min(prev, id), v = Math.max(prev, id);
+      const key = `${u},${v}`;
+      const edge = edges.get(key);
+      if (edge) edge.owners ^= bit;
+      else edges.set(key, { u, v, owners: bit });
+      prev = id;
+    }
+  }
+  const origin = [];
+  const owners = [];
+  for (const { u, v, owners: o } of edges.values()) {
+    if (o === 0n) continue;
+    origin.push(u, v);
+    owners.push(o);
+  }
+  return { xs: pool.xs, ys: pool.ys, origin, next: linkFaces(pool.xs, pool.ys, origin), owners };
+}
+
+// src/booleans/arrangementFaces.ts
+function components(arr) {
+  const parent = arr.xs.map((_, i) => i);
+  const find = (v) => {
+    while (parent[v] !== v) {
+      parent[v] = parent[parent[v]];
+      v = parent[v];
+    }
+    return v;
+  };
+  for (let h = 0; h < arr.origin.length; h += 2) parent[find(arr.origin[h])] = find(arr.origin[h + 1]);
+  return arr.xs.map((_, v) => find(v));
+}
+function traceCycles(arr, compOf) {
+  const cycleOf = new Array(arr.origin.length).fill(-1);
+  const cycles = [];
+  for (let start = 0; start < arr.origin.length; start++) {
+    if (cycleOf[start] !== -1) continue;
+    const c = { edges: [], area: 0, component: compOf[arr.origin[start]], minX: Infinity, maxX: -Infinity, minY: Infinity, maxY: -Infinity };
+    let h = start;
+    do {
+      cycleOf[h] = cycles.length;
+      c.edges.push(h);
+      const x0 = arr.xs[arr.origin[h]], y0 = arr.ys[arr.origin[h]];
+      const x1 = arr.xs[arr.origin[h ^ 1]], y1 = arr.ys[arr.origin[h ^ 1]];
+      c.area += (x0 * y1 - x1 * y0) / 2;
+      c.minX = Math.min(c.minX, x0);
+      c.maxX = Math.max(c.maxX, x0);
+      c.minY = Math.min(c.minY, y0);
+      c.maxY = Math.max(c.maxY, y0);
+      h = arr.next[h];
+    } while (h !== start);
+    cycles.push(c);
+  }
+  return { cycles, cycleOf };
+}
+function coverAt(arr, compOf, component, px, py) {
+  let mask = 0n;
+  for (let h = 0; h < arr.origin.length; h += 2) {
+    const u = arr.origin[h], v = arr.origin[h + 1];
+    if (compOf[u] === component) continue;
+    const y0 = arr.ys[u], y1 = arr.ys[v];
+    if (y0 > py === y1 > py) continue;
+    const x = arr.xs[u] + (py - y0) / (y1 - y0) * (arr.xs[v] - arr.xs[u]);
+    if (x < px) mask ^= arr.owners[h >> 1];
+  }
+  return mask;
+}
+function ringOf(arr, cycle) {
+  const ring = cycle.edges.map((h) => [arr.xs[arr.origin[h]], arr.ys[arr.origin[h]]]);
+  ring.push([ring[0][0], ring[0][1]]);
+  return ring;
+}
+function ringHolds(ring, px, py) {
+  let inside = false;
+  for (let k = 0; k + 1 < ring.length; k++) {
+    const [x0, y0] = ring[k];
+    const [x1, y1] = ring[k + 1];
+    if (y0 > py !== y1 > py && px < x0 + (py - y0) / (y1 - y0) * (x1 - x0)) inside = !inside;
+  }
+  return inside;
+}
+function popcount(mask) {
+  let c = 0;
+  for (let m = mask; m; m &= m - 1n) c++;
+  return c;
+}
+function arrangementFaces(inputs) {
+  const arr = buildArrangement(inputs);
+  const compOf = components(arr);
+  const { cycles, cycleOf } = traceCycles(arr, compOf);
+  const outerOf = /* @__PURE__ */ new Map();
+  cycles.forEach((c, i) => {
+    const best = outerOf.get(c.component);
+    if (best === void 0 || c.area < cycles[best].area) outerOf.set(c.component, i);
+  });
+  const label = new Array(cycles.length);
+  for (const [component, outer] of outerOf) {
+    const v = arr.origin[cycles[outer].edges[0]];
+    label[outer] = coverAt(arr, compOf, component, arr.xs[v], arr.ys[v]);
+    const queue = [outer];
+    while (queue.length > 0) {
+      const f = queue.pop();
+      for (const h of cycles[f].edges) {
+        const g = cycleOf[h ^ 1];
+        if (label[g] !== void 0) continue;
+        label[g] = label[f] ^ arr.owners[h >> 1];
+        queue.push(g);
+      }
+    }
+  }
+  let extent = 1;
+  for (let v = 0; v < arr.xs.length; v++) extent = Math.max(extent, Math.abs(arr.xs[v]), Math.abs(arr.ys[v]));
+  const minArea = 1e-12 * extent * extent;
+  const faces2 = /* @__PURE__ */ new Map();
+  cycles.forEach((c, i) => {
+    if (c.area > minArea && label[i]) faces2.set(i, { mask: label[i], polygon: [ringOf(arr, c)] });
+  });
+  for (const [component, outer] of outerOf) {
+    const v = arr.origin[cycles[outer].edges[0]];
+    const px = arr.xs[v], py = arr.ys[v];
+    let host = -1;
+    cycles.forEach((c, i) => {
+      if (c.component === component || c.area <= minArea) return;
+      if (px < c.minX || px > c.maxX || py < c.minY || py > c.maxY) return;
+      if (host !== -1 && cycles[host].area <= c.area) return;
+      if (ringHolds(ringOf(arr, c), px, py)) host = i;
+    });
+    faces2.get(host)?.polygon.push(ringOf(arr, cycles[outer]));
+  }
+  const left = (f) => Math.min(...f.polygon[0].map((p) => p[0]));
+  const low = (f) => Math.min(...f.polygon[0].map((p) => p[1]));
+  return [...faces2.values()].sort((a, b) => popcount(a.mask) - popcount(b.mask) || (a.mask < b.mask ? -1 : a.mask > b.mask ? 1 : 0) || left(a) - left(b) || low(a) - low(b));
+}
+
 // src/booleans/ops.ts
+function toPath2(mp, sources) {
+  return keepCorners(sources, multiPolygonToPath(mp));
+}
 function pathUnion(...paths) {
   if (paths.length === 0) return multiPolygonToPath([]);
   const mps = paths.map((p) => pathToMultiPolygon(p));
   const [head, ...rest] = mps;
-  return multiPolygonToPath(polygonClipping.union(head, ...rest));
+  return toPath2(polygonClipping.union(head, ...rest), paths);
 }
 function pathIntersect(...paths) {
   if (paths.length === 0) return multiPolygonToPath([]);
   const mps = paths.map((p) => pathToMultiPolygon(p));
   const [head, ...rest] = mps;
-  return multiPolygonToPath(polygonClipping.intersection(head, ...rest));
+  return toPath2(polygonClipping.intersection(head, ...rest), paths);
 }
 function pathSubtract(a, b) {
-  return multiPolygonToPath(polygonClipping.difference(pathToMultiPolygon(a), pathToMultiPolygon(b)));
+  return toPath2(polygonClipping.difference(pathToMultiPolygon(a), pathToMultiPolygon(b)), [a, b]);
 }
 function pathExclude(...paths) {
   if (paths.length === 0) return multiPolygonToPath([]);
   const mps = paths.map((p) => pathToMultiPolygon(p));
   const [head, ...rest] = mps;
-  return multiPolygonToPath(polygonClipping.xor(head, ...rest));
+  return toPath2(polygonClipping.xor(head, ...rest), paths);
 }
 function pathDivide(...paths) {
   return pathDividePieces(...paths).map((p) => p.path);
@@ -242,37 +514,29 @@ function pathDivide(...paths) {
 function pathCrop(...paths) {
   return pathCropPieces(...paths).map((p) => p.path);
 }
-function pathDividePieces(...paths) {
-  if (paths.length === 0) return [];
-  if (paths.length === 1) {
-    return [{ path: multiPolygonToPath(pathToMultiPolygon(paths[0])), sources: [0] }];
-  }
-  const mps = paths.map((p) => pathToMultiPolygon(p));
-  const n = mps.length;
-  const out = [];
-  const subsets = [];
-  for (let mask = 1; mask < 1 << n; mask++) subsets.push(mask);
-  subsets.sort((a, b) => popcount(a) - popcount(b) || a - b);
-  for (const mask of subsets) {
-    const inside = [];
-    const outside = [];
+function faces(paths) {
+  const clean = paths.map((p) => {
+    const mp = pathToMultiPolygon(p);
+    return mp.length === 0 ? mp : polygonClipping.union(mp);
+  });
+  return arrangementFaces(clean).map(({ mask, polygon }) => {
     const sources = [];
-    for (let i = 0; i < n; i++) {
-      if (mask & 1 << i) sources.push(i);
-      (mask & 1 << i ? inside : outside).push(mps[i]);
-    }
-    const [insideHead, ...insideRest] = inside;
-    let region = insideRest.length === 0 ? insideHead : polygonClipping.intersection(insideHead, ...insideRest);
-    if (region.length === 0) continue;
-    if (outside.length > 0) {
-      const [outHead, ...outRest] = outside;
-      const outsideUnion = polygonClipping.union(outHead, ...outRest);
-      region = polygonClipping.difference(region, outsideUnion);
-      if (region.length === 0) continue;
-    }
-    out.push({ path: multiPolygonToPath(region), sources });
+    for (let i = 0; i < paths.length; i++) if (mask & 1n << BigInt(i)) sources.push(i);
+    return { polygon, sources };
+  });
+}
+function pathDividePieces(...paths) {
+  const regions = /* @__PURE__ */ new Map();
+  for (const { polygon, sources } of faces(paths)) {
+    const key = sources.join(",");
+    const region = regions.get(key);
+    if (region) region.polygons.push(polygon);
+    else regions.set(key, { polygons: [polygon], sources });
   }
-  return out;
+  return [...regions.values()].map(({ polygons, sources }) => ({ path: toPath2(polygons, paths), sources }));
+}
+function pathFacePieces(...paths) {
+  return faces(paths).map(({ polygon, sources }) => ({ path: toPath2([polygon], paths), sources }));
 }
 function pathTrim(...paths) {
   const mps = paths.map((p) => pathToMultiPolygon(p));
@@ -280,7 +544,7 @@ function pathTrim(...paths) {
   let cover = null;
   for (let i = mps.length - 1; i >= 0; i--) {
     const shown = cover ? polygonClipping.difference(mps[i], cover) : mps[i];
-    if (shown.length > 0) out.unshift({ path: multiPolygonToPath(shown), sources: [i] });
+    if (shown.length > 0) out.unshift({ path: toPath2(shown, paths), sources: [i] });
     cover = cover ? polygonClipping.union(cover, mps[i]) : mps[i];
   }
   return out;
@@ -299,14 +563,6 @@ function pathMerge(paths, keyOf) {
     sources: g.map((p) => p.sources[0])
   }).sort((a, b) => top(a) - top(b));
 }
-function popcount(n) {
-  let c = 0;
-  while (n) {
-    n &= n - 1;
-    c++;
-  }
-  return c;
-}
 function pathCropPieces(...paths) {
   if (paths.length < 2) return [];
   const mps = paths.map((p) => pathToMultiPolygon(p));
@@ -314,7 +570,7 @@ function pathCropPieces(...paths) {
   const out = [];
   for (let i = 0; i < mps.length - 1; i++) {
     const clipped = polygonClipping.intersection(mps[i], mask);
-    if (clipped.length > 0) out.push({ path: multiPolygonToPath(clipped), sources: [i] });
+    if (clipped.length > 0) out.push({ path: toPath2(clipped, paths), sources: [i] });
   }
   return out;
 }
@@ -333,141 +589,6 @@ function trianglesToPath(vertices, indices) {
   return multiPolygonToPath(polygonClipping.union(head, ...rest));
 }
 
-// src/booleans/contourSegments.ts
-function evalSeg(s, t) {
-  const u = 1 - t;
-  if (s.length === 2) return { x: u * s[0].x + t * s[1].x, y: u * s[0].y + t * s[1].y };
-  if (s.length === 3) {
-    const a2 = u * u, b2 = 2 * u * t, c2 = t * t;
-    return { x: a2 * s[0].x + b2 * s[1].x + c2 * s[2].x, y: a2 * s[0].y + b2 * s[1].y + c2 * s[2].y };
-  }
-  const a = u * u * u, b = 3 * u * u * t, c = 3 * u * t * t, d = t * t * t;
-  return {
-    x: a * s[0].x + b * s[1].x + c * s[2].x + d * s[3].x,
-    y: a * s[0].y + b * s[1].y + c * s[2].y + d * s[3].y
-  };
-}
-function derivSeg(s, t) {
-  const n = s.length - 1;
-  const d = [];
-  for (let i = 0; i < n; i++) d.push({ x: n * (s[i + 1].x - s[i].x), y: n * (s[i + 1].y - s[i].y) });
-  return d.length === 1 ? d[0] : evalSeg(d, t);
-}
-function splitSeg(s, t) {
-  const pts = (c) => {
-    const out = [];
-    for (let i = 0; i < c.length; i += 2) out.push({ x: c[i], y: c[i + 1] });
-    return out;
-  };
-  if (s.length === 2) {
-    const m = evalSeg(s, t);
-    return [[s[0], m], [m, s[1]]];
-  }
-  if (s.length === 3) {
-    const [l2, r2] = splitQuadraticAt(s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, t);
-    return [pts(l2), pts(r2)];
-  }
-  const [l, r] = splitCubicAt(s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, s[3].x, s[3].y, t);
-  return [pts(l), pts(r)];
-}
-function subSeg(s, t0, t1, p0, p1) {
-  if (t1 - t0 <= 0) return null;
-  let out = s;
-  if (t0 > 0) out = splitSeg(out, t0)[1];
-  const u = (t1 - t0) / (1 - t0);
-  if (u < 1) out = splitSeg(out, u)[0];
-  out = out.slice();
-  out[0] = p0;
-  out[out.length - 1] = p1;
-  return out;
-}
-var reverseContour = (c) => c.map((s) => s.slice().reverse()).reverse();
-function sampleContour(c) {
-  const out = [];
-  for (const s of c) {
-    const n = s.length === 2 ? 1 : 16;
-    for (let i = 0; i < n; i++) {
-      const p = evalSeg(s, i / n);
-      out.push(p.x, p.y);
-    }
-  }
-  return out;
-}
-function signedArea(c) {
-  const pts = sampleContour(c);
-  let a = 0;
-  for (let i = 0; i < pts.length; i += 2) {
-    const j = (i + 2) % pts.length;
-    a += pts[i] * pts[j + 1] - pts[j] * pts[i + 1];
-  }
-  return a / 2;
-}
-function sideCoeffs(s, o, d) {
-  return s.map((p) => d.x * (p.y - o.y) - d.y * (p.x - o.x));
-}
-function bernstein(f, t) {
-  const u = 1 - t;
-  if (f.length === 2) return u * f[0] + t * f[1];
-  if (f.length === 3) return u * u * f[0] + 2 * u * t * f[1] + t * t * f[2];
-  return u * u * u * f[0] + 3 * u * u * t * f[1] + 3 * u * t * t * f[2] + t * t * t * f[3];
-}
-function signChanges(f, zeroIsPositive) {
-  const sgn = (v) => v > 0 ? 1 : v < 0 ? -1 : zeroIsPositive ? 1 : 0;
-  const cuts = [0, ...criticalPoints(f), 1];
-  const out = [];
-  for (let i = 0; i + 1 < cuts.length; i++) {
-    let lo = cuts[i], hi = cuts[i + 1];
-    const slo = sgn(bernstein(f, lo)), shi = sgn(bernstein(f, hi));
-    if (slo === 0 && i > 0) {
-      const before = sgn(bernstein(f, lo - 1e-7)), after = sgn(bernstein(f, lo + 1e-7));
-      if (before * after < 0) out.push({ t: lo, before, after });
-    }
-    if (slo * shi >= 0) continue;
-    for (let it = 0; it < 64; it++) {
-      const mid = (lo + hi) / 2;
-      if (sgn(bernstein(f, mid)) === slo) lo = mid;
-      else hi = mid;
-    }
-    out.push({ t: (lo + hi) / 2, before: slo, after: shi });
-  }
-  return out;
-}
-function criticalPoints(f) {
-  if (f.length < 3) return [];
-  const n = f.length - 1;
-  const d = f.slice(1).map((v, i) => n * (v - f[i]));
-  let A = 0, B, C;
-  if (d.length === 2) {
-    B = d[1] - d[0];
-    C = d[0];
-  } else {
-    A = d[0] - 2 * d[1] + d[2];
-    B = 2 * (d[1] - d[0]);
-    C = d[0];
-  }
-  const out = [];
-  const scale = Math.max(Math.abs(A), Math.abs(B), Math.abs(C)) || 1;
-  if (Math.abs(A) / scale < 1e-12) {
-    if (Math.abs(B) / scale > 1e-12) out.push(-C / B);
-  } else {
-    const disc = B * B - 4 * A * C;
-    if (disc >= 0) {
-      const q = -0.5 * (B + Math.sign(B || 1) * Math.sqrt(disc));
-      out.push(q / A);
-      if (q !== 0) out.push(C / q);
-    }
-  }
-  return out.filter((t) => t > 0 && t < 1).sort((x, y) => x - y);
-}
-function endSide(f, fromStart) {
-  const n = f.length;
-  for (let i = 1; i < n; i++) {
-    const v = fromStart ? f[i] : f[n - 1 - i];
-    if (v !== 0) return Math.sign(v);
-  }
-  return 0;
-}
-
 // src/booleans/cutCrossings.ts
 function cutPosition(cut, k, pt) {
   const a = cut[k], b = cut[k + 1];
@@ -508,144 +629,6 @@ function crossingsOnSegment(boundaries, cut, k, out) {
   });
 }
 
-// src/booleans/contours.ts
-function parseContours(path) {
-  const fillsOpen = path.kind === "rect" || fillsOpenSubpaths(path);
-  return parseSubpaths(path).filter((s) => s.closed || fillsOpen).map((s) => s.segs);
-}
-function parseSubpaths(path, implicitClose = true) {
-  if (path.kind === "rect") {
-    const { x, y, width: w, height: h } = path;
-    const p = [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }];
-    return [{ segs: p.map((q, i) => [q, p[(i + 1) % 4]]), closed: true }];
-  }
-  const out = [];
-  let cur = [];
-  let start = { x: 0, y: 0 };
-  let pen = start;
-  const finish = (closed) => {
-    if (cur.length > 0 && (closed || implicitClose) && (pen.x !== start.x || pen.y !== start.y)) {
-      cur.push([pen, start]);
-    }
-    if (cur.length > 0) out.push({ segs: cur, closed });
-    cur = [];
-    pen = start;
-  };
-  const c = path.coords;
-  let k = 0;
-  for (const cmd of path.commands) {
-    if (cmd === PATH_M) {
-      finish(false);
-      start = pen = { x: c[k], y: c[k + 1] };
-      k += 2;
-    } else if (cmd === PATH_L) {
-      const e = { x: c[k], y: c[k + 1] };
-      if (e.x !== pen.x || e.y !== pen.y) cur.push([pen, e]);
-      pen = e;
-      k += 2;
-    } else if (cmd === PATH_Q) {
-      const e = { x: c[k + 2], y: c[k + 3] };
-      cur.push([pen, { x: c[k], y: c[k + 1] }, e]);
-      pen = e;
-      k += 4;
-    } else if (cmd === PATH_C) {
-      const e = { x: c[k + 4], y: c[k + 5] };
-      cur.push([pen, { x: c[k], y: c[k + 1] }, { x: c[k + 2], y: c[k + 3] }, e]);
-      pen = e;
-      k += 6;
-    } else if (cmd === PATH_Z) {
-      finish(true);
-    }
-  }
-  finish(false);
-  return out;
-}
-function contoursIntersect(contours, tol) {
-  const edges = [];
-  contours.forEach((contour, ci) => {
-    const pts = [];
-    for (const s of contour) {
-      let n = 1;
-      if (s.length > 2) {
-        let len = 0;
-        for (let i = 0; i + 1 < s.length; i++) len += Math.hypot(s[i + 1].x - s[i].x, s[i + 1].y - s[i].y);
-        n = Math.min(64, Math.max(2, Math.ceil(Math.sqrt(len / Math.max(tol, 1e-3)))));
-      }
-      for (let i = 0; i < n; i++) pts.push(evalSeg(s, i / n));
-    }
-    for (let i = 0; i < pts.length; i++) {
-      const p = pts[i], q = pts[(i + 1) % pts.length];
-      edges.push({ x0: p.x, y0: p.y, x1: q.x, y1: q.y, c: ci, i, n: pts.length });
-    }
-  });
-  for (let i = 0; i < edges.length; i++) {
-    const e = edges[i];
-    for (let j = i + 1; j < edges.length; j++) {
-      const f = edges[j];
-      if (e.c === f.c && (j - i === 1 || i === 0 && f.i === f.n - 1)) continue;
-      if (Math.max(e.x0, e.x1) < Math.min(f.x0, f.x1) || Math.max(f.x0, f.x1) < Math.min(e.x0, e.x1)) continue;
-      if (Math.max(e.y0, e.y1) < Math.min(f.y0, f.y1) || Math.max(f.y0, f.y1) < Math.min(e.y0, e.y1)) continue;
-      if (segmentsCross(e.x0, e.y0, e.x1, e.y1, f.x0, f.y0, f.x1, f.y1)) return true;
-    }
-  }
-  return false;
-}
-function windingAt(q, contours) {
-  const dir = { x: 1, y: 0 };
-  let w = 0;
-  for (const contour of contours) {
-    for (const s of contour) {
-      for (const c of signChanges(sideCoeffs(s, q, dir), true)) {
-        if (evalSeg(s, c.t).x > q.x) w += c.after > 0 ? 1 : -1;
-      }
-    }
-  }
-  return w;
-}
-function extentOf(contours) {
-  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-  for (const c of contours) for (const s of c) for (const p of s) {
-    minX = Math.min(minX, p.x);
-    maxX = Math.max(maxX, p.x);
-    minY = Math.min(minY, p.y);
-    maxY = Math.max(maxY, p.y);
-  }
-  return Math.hypot(maxX - minX, maxY - minY);
-}
-function negligibleArea(contours) {
-  const extent = extentOf(contours);
-  return extent * extent * EPS * EPS;
-}
-function orientBoundaries(contours, fillRule) {
-  const filled = (q) => {
-    const w = windingAt(q, contours);
-    return fillRule === "evenodd" ? (w & 1) !== 0 : w !== 0;
-  };
-  const eps = Math.max(extentOf(contours) * 1e-6, 1e-9);
-  const out = [];
-  for (const contour of contours) {
-    let probe = contour[0];
-    let best = -1;
-    for (const s of contour) {
-      const len = Math.hypot(s[s.length - 1].x - s[0].x, s[s.length - 1].y - s[0].y);
-      if (len > best) {
-        best = len;
-        probe = s;
-      }
-    }
-    const p = evalSeg(probe, 0.5);
-    let tan = derivSeg(probe, 0.5);
-    const tl = Math.hypot(tan.x, tan.y);
-    if (tl === 0) continue;
-    tan = { x: tan.x / tl, y: tan.y / tl };
-    const left = filled({ x: p.x - tan.y * eps, y: p.y + tan.x * eps });
-    const right = filled({ x: p.x + tan.y * eps, y: p.y - tan.x * eps });
-    if (left && !right) out.push(contour);
-    else if (right && !left) out.push(reverseContour(contour));
-  }
-  return out;
-}
-
 // src/booleans/cutPolyline.ts
 function distinctPoints(cut) {
   const out = [];
@@ -839,36 +822,6 @@ function arcBetween(contour, from, to, whole) {
   return out;
 }
 
-// src/booleans/cutRegions.ts
-function assembleRegions(outers, holes) {
-  const regions = outers.map((o) => ({ loops: [o], ring: sampleContour(o), area: signedArea(o) }));
-  for (const h of holes) {
-    const hp = evalSeg(h[0], 0.5);
-    let best = null;
-    for (const r of regions) {
-      if (pointInPolygon(r.ring, hp.x, hp.y) && (!best || r.area < best.area)) best = r;
-    }
-    best?.loops.push(h);
-  }
-  return regions.map((r) => r.loops);
-}
-var regionArea = (r) => r.reduce((s, c) => s + signedArea(c), 0);
-var toPath = (loops, fillRule) => writePath(loops.map((segs) => ({ segs, closed: true })), fillRule);
-function writePath(subpaths, fillRule) {
-  const cmds = [];
-  const xs = [];
-  for (const { segs, closed } of subpaths) {
-    cmds.push(PATH_M);
-    xs.push(segs[0][0].x, segs[0][0].y);
-    for (const s of segs) {
-      cmds.push(s.length === 2 ? PATH_L : s.length === 3 ? PATH_Q : PATH_C);
-      for (let i = 1; i < s.length; i++) xs.push(s[i].x, s[i].y);
-    }
-    if (closed) cmds.push(PATH_Z);
-  }
-  return { kind: "polygon", commands: new Uint8Array(cmds), coords: new Float32Array(xs), fillRule };
-}
-
 // src/booleans/splitBySegment.ts
 function splitPathBySegment(path, a, b, opts = {}) {
   return splitPathByPolyline(path, [a, b], opts);
@@ -994,6 +947,45 @@ function snipStations(sub, cut) {
   return groups.filter((g) => g.length % 2 === 1).map((g) => g[0]).filter((st) => sub.closed || !same(st.pt, first) && !same(st.pt, end));
 }
 
-export { multiPolygonToPath, pathCrop, pathCropPieces, pathDivide, pathDividePieces, pathExclude, pathIntersect, pathMerge, pathSubtract, pathToMultiPolygon, pathTrim, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment, trianglesToPath };
+// src/booleans/snipAtCrossings.ts
+function snipPathsAtCrossings(paths, opts = {}) {
+  const tol = opts.flattenTolerance ?? 0.05;
+  const cuts = paths.map((p) => cutLinesOf(p, tol));
+  return paths.map((path, i) => {
+    let pieces = [path];
+    let cut = false;
+    cuts.forEach((lines, j) => {
+      if (j === i) return;
+      for (const line of lines) {
+        pieces = pieces.flatMap((piece) => {
+          const snipped = snipPathByPolyline(piece, line);
+          if (!snipped) return [piece];
+          cut = true;
+          return snipped;
+        });
+      }
+    });
+    return cut ? pieces.map((piece) => piece.kind === "polygon" ? keepCorners([path], piece) : piece) : null;
+  });
+}
+function cutLinesOf(path, tol) {
+  return parseSubpaths(path, false).map(({ segs, closed }) => {
+    const flat = [segs[0][0].x, segs[0][0].y];
+    for (const s of segs) {
+      if (s.length === 2) flat.push(s[1].x, s[1].y);
+      else if (s.length === 3) flattenQuadratic(s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, tol, flat);
+      else flattenCubic(s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, s[3].x, s[3].y, tol, flat);
+    }
+    const pts = [];
+    for (let k = 0; k < flat.length; k += 2) pts.push({ x: flat[k], y: flat[k + 1] });
+    if (closed) {
+      const end = pts[pts.length - 1];
+      if (end.x !== pts[0].x || end.y !== pts[0].y) pts.push({ ...pts[0] });
+    }
+    return pts;
+  });
+}
+
+export { multiPolygonToPath, pathCrop, pathCropPieces, pathDivide, pathDividePieces, pathExclude, pathFacePieces, pathIntersect, pathMerge, pathSubtract, pathToMultiPolygon, pathTrim, pathUnion, snipPathByPolyline, snipPathsAtCrossings, splitPathByPolyline, splitPathBySegment, trianglesToPath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map