@weasel-js/geom 1.9.3 → 1.10.0

package/dist/booleans/index.js

@@ -1,7 +1,7 @@
 import { elevateQuadraticToCubic, splitQuadraticAt, splitCubicAt } from '../chunk-URQMDR6Q.js';
-import { DEFAULT_FLATTEN_TOLERANCE, flattenCubic, segmentsCross, pointInPolygon } from '../chunk-RQYCDPU5.js';
-import '../chunk-7ROQRYOA.js';
-import { PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M } from '../chunk-HEZTRG2M.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 polygonClipping from 'polygon-clipping';
 
 // src/booleans/adapter.ts
@@ -21,9 +21,12 @@ function pathToMultiPolygon(path, opts = {}) {
   const rings = [];
   let current = null;
   let cx = 0, cy = 0;
+  let startX = 0, startY = 0;
   let ci = 0;
   const { commands, coords } = path;
-  const finalizeCurrent = () => {
+  const fillsOpen = fillsOpenSubpaths(path);
+  const finalizeCurrent = (closed = fillsOpen) => {
+    if (!closed) current = null;
     if (!current || current.length === 0) return;
     const first = current[0];
     const last = current[current.length - 1];
@@ -40,14 +43,17 @@ function pathToMultiPolygon(path, opts = {}) {
         finalizeCurrent();
         cx = coords[ci];
         cy = coords[ci + 1];
+        startX = cx;
+        startY = cy;
         current = [[cx, cy]];
         ci += 2;
         break;
       }
       case PATH_L: {
+        current ??= [[cx, cy]];
         cx = coords[ci];
         cy = coords[ci + 1];
-        if (current) current.push([cx, cy]);
+        current.push([cx, cy]);
         ci += 2;
         break;
       }
@@ -57,7 +63,8 @@ function pathToMultiPolygon(path, opts = {}) {
         const x3 = coords[ci + 4], y3 = coords[ci + 5];
         const out = [];
         flattenCubic(cx, cy, x1, y1, x2, y2, x3, y3, tolerance, out);
-        if (current) for (let k = 0; k < out.length; k += 2) current.push([out[k], out[k + 1]]);
+        current ??= [[cx, cy]];
+        for (let k = 0; k < out.length; k += 2) current.push([out[k], out[k + 1]]);
         cx = x3;
         cy = y3;
         ci += 6;
@@ -69,14 +76,17 @@ function pathToMultiPolygon(path, opts = {}) {
         const [c1x, c1y, c2x, c2y] = elevateQuadraticToCubic(cx, cy, x1, y1, x2, y2);
         const out = [];
         flattenCubic(cx, cy, c1x, c1y, c2x, c2y, x2, y2, tolerance, out);
-        if (current) for (let k = 0; k < out.length; k += 2) current.push([out[k], out[k + 1]]);
+        current ??= [[cx, cy]];
+        for (let k = 0; k < out.length; k += 2) current.push([out[k], out[k + 1]]);
         cx = x2;
         cy = y2;
         ci += 4;
         break;
       }
       case PATH_Z: {
-        finalizeCurrent();
+        finalizeCurrent(true);
+        cx = startX;
+        cy = startY;
         break;
       }
       default:
@@ -227,9 +237,15 @@ function pathExclude(...paths) {
   return multiPolygonToPath(polygonClipping.xor(head, ...rest));
 }
 function pathDivide(...paths) {
+  return pathDividePieces(...paths).map((p) => p.path);
+}
+function pathCrop(...paths) {
+  return pathCropPieces(...paths).map((p) => p.path);
+}
+function pathDividePieces(...paths) {
   if (paths.length === 0) return [];
   if (paths.length === 1) {
-    return [multiPolygonToPath(pathToMultiPolygon(paths[0]))];
+    return [{ path: multiPolygonToPath(pathToMultiPolygon(paths[0])), sources: [0] }];
   }
   const mps = paths.map((p) => pathToMultiPolygon(p));
   const n = mps.length;
@@ -240,7 +256,9 @@ function pathDivide(...paths) {
   for (const mask of subsets) {
     const inside = [];
     const outside = [];
+    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;
@@ -252,10 +270,35 @@ function pathDivide(...paths) {
       region = polygonClipping.difference(region, outsideUnion);
       if (region.length === 0) continue;
     }
-    out.push(multiPolygonToPath(region));
+    out.push({ path: multiPolygonToPath(region), sources });
+  }
+  return out;
+}
+function pathTrim(...paths) {
+  const mps = paths.map((p) => pathToMultiPolygon(p));
+  const out = [];
+  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] });
+    cover = cover ? polygonClipping.union(cover, mps[i]) : mps[i];
   }
   return out;
 }
+function pathMerge(paths, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const piece of pathTrim(...paths)) {
+    const key = keyOf(piece.sources[0]);
+    const group = groups.get(key);
+    if (group) group.push(piece);
+    else groups.set(key, [piece]);
+  }
+  const top = (p) => p.sources[p.sources.length - 1];
+  return [...groups.values()].map((g) => g.length === 1 ? g[0] : {
+    path: pathUnion(...g.map((p) => p.path)),
+    sources: g.map((p) => p.sources[0])
+  }).sort((a, b) => top(a) - top(b));
+}
 function popcount(n) {
   let c = 0;
   while (n) {
@@ -264,153 +307,359 @@ function popcount(n) {
   }
   return c;
 }
-function pathCrop(...paths) {
+function pathCropPieces(...paths) {
   if (paths.length < 2) return [];
   const mps = paths.map((p) => pathToMultiPolygon(p));
   const mask = mps[mps.length - 1];
   const out = [];
   for (let i = 0; i < mps.length - 1; i++) {
     const clipped = polygonClipping.intersection(mps[i], mask);
-    if (clipped.length > 0) out.push(multiPolygonToPath(clipped));
+    if (clipped.length > 0) out.push({ path: multiPolygonToPath(clipped), sources: [i] });
   }
   return out;
 }
+function trianglesToPath(vertices, indices) {
+  const triangles = [];
+  for (let i = 0; i + 2 < indices.length; i += 3) {
+    const a = indices[i] * 2, b = indices[i + 1] * 2, c = indices[i + 2] * 2;
+    const ax = vertices[a], ay = vertices[a + 1];
+    const bx = vertices[b], by = vertices[b + 1];
+    const cx = vertices[c], cy = vertices[c + 1];
+    if ((bx - ax) * (cy - ay) - (cx - ax) * (by - ay) === 0) continue;
+    triangles.push([[[[ax, ay], [bx, by], [cx, cy], [ax, ay]]]]);
+  }
+  if (triangles.length === 0) return multiPolygonToPath([]);
+  const [head, ...rest] = triangles;
+  return multiPolygonToPath(polygonClipping.union(head, ...rest));
+}
 
-// src/booleans/splitBySegment.ts
-function splitPathBySegment(path, a, b, opts = {}) {
-  return splitPathByPolyline(path, [a, b], opts);
+// 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 splitPathByPolyline(path, cut, opts = {}) {
-  let pts = distinctPoints(cut);
-  if (pts.length < 2) return null;
-  const outRule = fillRuleOf(path);
-  const boundaries = resolveBoundaries(path, opts);
-  if (boundaries.length === 0) return null;
-  pts = openClosedCut(pts, boundaries);
-  const loops = interiorLoops(pts, boundaries);
-  const pieces = knife(path, pts, opts, pts.length);
-  if (loops.length === 0) return pieces;
-  const regions = pieces ? pieces.map((p) => orientBoundaries(parseContours(p), outRule)) : [boundaries];
-  if (!cutOutLoops(regions, loops)) return pieces;
-  return regions.map((r) => toPath(r, outRule));
+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);
 }
-var fillRuleOf = (path) => path.kind === "polygon" ? path.fillRule : "nonzero";
-function resolveBoundaries(path, opts) {
-  const contours = parseContours(path);
-  if (contoursIntersect(contours, opts.flattenTolerance ?? 0.5)) {
-    return orientBoundaries(parseContours(pathUnion(path)), "nonzero");
+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]]];
   }
-  return orientBoundaries(contours, fillRuleOf(path));
+  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 knife(path, cut, opts, budget) {
-  const outRule = fillRuleOf(path);
-  const boundaries = resolveBoundaries(path, opts);
-  if (boundaries.length === 0) return null;
-  const crossings = findCrossings(boundaries, cut);
-  const partner = /* @__PURE__ */ new Map();
-  const chord = /* @__PURE__ */ new Map();
-  const accepted = [];
-  let deferred = false;
-  for (let k = 0; k + 1 < crossings.length; k++) {
-    const c0 = crossings[k], c1 = crossings[k + 1];
-    if (!c0.enters || c1.enters || c1.s - c0.s <= 1e-9) continue;
-    const run = splitLoops(cutBetween(cut, c0, c1)).spine;
-    if (accepted.some((other) => polylinesCross(run, other))) {
-      deferred = true;
-      continue;
+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);
     }
-    accepted.push(run);
-    partner.set(c0, c1);
-    partner.set(c1, c0);
-    chord.set(c0, run);
-    chord.set(c1, run.slice().reverse());
   }
-  if (partner.size === 0) return null;
-  const { loops, untouched } = traceLoops(boundaries, partner, chord);
-  const traced = assembleRegions(loops, untouched.filter((c) => signedArea(c) < 0));
-  const islands = untouched.filter((c) => signedArea(c) > 0);
-  const regions = traced.filter((r) => Math.abs(regionArea(r)) > 1e-6);
-  if (islands.length > 0) {
-    const leftover = untouched.filter((c) => !traced.some((r) => r.includes(c)));
-    regions.push(leftover);
+  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];
   }
-  const pieces = regions.map((r) => toPath(r, outRule));
-  if (!deferred || budget <= 1) return pieces;
-  return pieces.flatMap((p) => knife(p, cut, opts, budget - 1) ?? [p]);
+  return a / 2;
 }
-function snipPathByPolyline(path, cut) {
-  const pts = distinctPoints(cut);
-  if (pts.length < 2) return null;
-  const rule = path.kind === "polygon" ? path.fillRule : "nonzero";
-  const runs = [];
-  const missed = [];
-  for (const sub of parseSubpaths(path, false)) {
-    const stops = snipStations(sub, pts);
-    if (stops.length === 0) {
-      missed.push(sub);
-      continue;
+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 });
     }
-    const segs = sub.segs;
-    if (sub.closed) {
-      for (let i = 0; i < stops.length; i++) {
-        runs.push(arcBetween(segs, stops[i], stops[(i + 1) % stops.length], stops.length === 1));
-      }
-    } else {
-      const last = segs[segs.length - 1];
-      const all = [
-        { seg: 0, t: 0, pt: segs[0][0] },
-        ...stops,
-        { seg: segs.length - 1, t: 1, pt: last[last.length - 1] }
-      ];
-      for (let i = 0; i + 1 < all.length; i++) runs.push(arcBetween(segs, all[i], all[i + 1], false));
+    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 });
   }
-  if (runs.length === 0) return null;
-  const pieces = runs.filter((r) => r.length > 0).map((r) => writePath([{ segs: r, closed: false }], rule));
-  if (missed.length > 0) pieces.push(writePath(missed, rule));
-  return pieces;
+  return out;
 }
-function snipStations(sub, cut) {
-  const raw = [];
-  sub.segs.forEach((seg, si) => {
-    for (let k = 0; k + 1 < cut.length; k++) {
-      const a = cut[k];
-      const d = { x: cut[k + 1].x - a.x, y: cut[k + 1].y - a.y };
-      for (const c of signChanges(sideCoeffs(seg, a, d), true)) {
-        const pt = evalSeg(seg, c.t);
-        if (cutPosition(cut, k, pt) !== null) raw.push({ seg: si, t: c.t, pt });
-      }
-    }
-  });
-  raw.sort((x, y) => x.seg - y.seg || x.t - y.t);
-  const same = (p, q) => Math.abs(p.x - q.x) <= 1e-7 && Math.abs(p.y - q.y) <= 1e-7;
-  const groups = [];
-  for (const st of raw) {
-    const g = groups[groups.length - 1];
-    if (g && same(g[0].pt, st.pt)) g.push(st);
-    else groups.push([st]);
+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];
   }
-  if (sub.closed && groups.length > 1 && same(groups[0][0].pt, groups[groups.length - 1][0].pt)) {
-    groups[0].push(...groups.pop());
+  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);
+    }
   }
-  const first = sub.segs[0][0];
-  const lastSeg = sub.segs[sub.segs.length - 1];
-  const end = lastSeg[lastSeg.length - 1];
-  return groups.filter((g) => g.length % 2 === 1).map((g) => g[0]).filter((st) => sub.closed || !same(st.pt, first) && !same(st.pt, end));
+  return out.filter((t) => t > 0 && t < 1).sort((x, y) => x - y);
 }
-function distinctPoints(cut) {
-  const out = [];
-  for (const p of cut) {
-    const q = out[out.length - 1];
-    if (!q || q.x !== p.x || q.y !== p.y) out.push({ x: p.x, y: p.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 out;
+  return 0;
 }
-function cutBetween(cut, from, to) {
-  const out = [from.pt];
-  for (let v = Math.floor(from.s) + 1; v < to.s; v++) out.push(cut[v]);
-  out.push(to.pt);
-  return out;
+
+// src/booleans/cutCrossings.ts
+function cutPosition(cut, k, pt) {
+  const a = cut[k], b = cut[k + 1];
+  const d = { x: b.x - a.x, y: b.y - a.y };
+  const s = ((pt.x - a.x) * d.x + (pt.y - a.y) * d.y) / (d.x * d.x + d.y * d.y);
+  const eps = 1e-9;
+  const last = k + 2 === cut.length;
+  if (s < (k === 0 ? 0 : -eps)) return null;
+  if (last ? s > 1 : s >= 1 - eps) return null;
+  return k + Math.min(1, Math.max(0, s));
+}
+function findCrossings(boundaries, cut) {
+  const out = [];
+  for (let k = 0; k + 1 < cut.length; k++) crossingsOnSegment(boundaries, cut, k, out);
+  return out.sort((x, y) => x.s - y.s);
+}
+function crossingsOnSegment(boundaries, cut, k, out) {
+  const a = cut[k];
+  const d = { x: cut[k + 1].x - a.x, y: cut[k + 1].y - a.y };
+  const push = (contour, seg, t, before, after) => {
+    const pt = evalSeg(boundaries[contour][seg], t);
+    const s = cutPosition(cut, k, pt);
+    if (s === null) return;
+    out.push({ contour, seg, t, pt, s, enters: before > 0 && after < 0 });
+  };
+  boundaries.forEach((contour, ci) => {
+    const fs = contour.map((s) => sideCoeffs(s, a, d));
+    const n = contour.length;
+    fs.forEach((f, si) => {
+      for (const c of signChanges(f, false)) push(ci, si, c.t, c.before, c.after);
+      if (f[0] !== 0) return;
+      const after = endSide(f, true);
+      if (after === 0) return;
+      let before = 0;
+      for (let k2 = 1; k2 <= n && before === 0; k2++) before = endSide(fs[(si - k2 + n) % n], false);
+      if (before !== 0 && before !== after) push(ci, si, 0, before, after);
+    });
+  });
+}
+
+// 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 = [];
+  for (const p of cut) {
+    const q = out[out.length - 1];
+    if (!q || q.x !== p.x || q.y !== p.y) out.push({ x: p.x, y: p.y });
+  }
+  return out;
+}
+function cutBetween(cut, from, to) {
+  const out = [from.pt];
+  for (let v = Math.floor(from.s) + 1; v < to.s; v++) out.push(cut[v]);
+  out.push(to.pt);
+  return out;
 }
 function properCrossing(p0, p1, q0, q1) {
   const r = { x: p1.x - p0.x, y: p1.y - p0.y };
@@ -502,10 +751,11 @@ function interiorLoops(cut, boundaries) {
 }
 function cutOutLoops(regions, loops) {
   let cut = false;
+  const minArea = negligibleArea(regions.flat());
   for (const loop of loops) {
     let ring = loop.map((p, i) => [p, loop[(i + 1) % loop.length]]);
     const a = signedArea(ring);
-    if (Math.abs(a) <= 1e-6) continue;
+    if (Math.abs(a) <= minArea) continue;
     if (a < 0) ring = reverseContour(ring);
     const probe = evalSeg(ring[0], 0.5);
     const at = regions.findIndex((r) => windingAt(probe, r) !== 0);
@@ -530,361 +780,66 @@ function polylinesCross(a, b) {
   }
   return false;
 }
-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 };
+
+// src/booleans/cutLoops.ts
+function traceLoops(boundaries, partner, chord) {
+  const byContour = /* @__PURE__ */ new Map();
+  for (const c of partner.keys()) {
+    const list = byContour.get(c.contour) ?? [];
+    list.push(c);
+    byContour.set(c.contour, list);
   }
-  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);
+  const arcFrom = /* @__PURE__ */ new Map();
+  const untouched = [];
+  boundaries.forEach((contour, ci) => {
+    const cuts = byContour.get(ci);
+    if (!cuts) {
+      untouched.push(contour);
+      return;
+    }
+    cuts.sort((x, y) => x.seg - y.seg || x.t - y.t);
+    for (let k = 0; k < cuts.length; k++) {
+      const from = cuts[k], to = cuts[(k + 1) % cuts.length];
+      arcFrom.set(from, { segs: arcBetween(contour, from, to, cuts.length === 1), end: to });
+    }
+  });
+  const loops = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const start of arcFrom.keys()) {
+    if (seen.has(start)) continue;
+    const loop = [];
+    let at = start;
+    while (!seen.has(at)) {
+      seen.add(at);
+      const arc = arcFrom.get(at);
+      loop.push(...arc.segs);
+      const run = chord.get(arc.end);
+      for (let i = 0; i + 1 < run.length; i++) loop.push([run[i], run[i + 1]]);
+      at = partner.get(arc.end);
+    }
+    loops.push(loop);
+  }
+  return { loops, untouched };
 }
-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;
+function arcBetween(contour, from, to, whole) {
+  const out = [];
+  const add = (s) => {
+    if (s) out.push(s);
   };
-  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)];
+  if (!whole && to.seg === from.seg && to.t > from.t) {
+    add(subSeg(contour[from.seg], from.t, to.t, from.pt, to.pt));
+    return out;
   }
-  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;
-}
-function parseContours(path) {
-  return parseSubpaths(path).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 orientBoundaries(contours, fillRule) {
-  const filled = (q) => {
-    const w = windingAt(q, contours);
-    return fillRule === "evenodd" ? (w & 1) !== 0 : w !== 0;
-  };
-  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);
-  }
-  const eps = Math.max(Math.hypot(maxX - minX, maxY - minY) * 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;
-}
-function cutPosition(cut, k, pt) {
-  const a = cut[k], b = cut[k + 1];
-  const d = { x: b.x - a.x, y: b.y - a.y };
-  const s = ((pt.x - a.x) * d.x + (pt.y - a.y) * d.y) / (d.x * d.x + d.y * d.y);
-  const eps = 1e-9;
-  const last = k + 2 === cut.length;
-  if (s < (k === 0 ? 0 : -eps)) return null;
-  if (last ? s > 1 : s >= 1 - eps) return null;
-  return k + Math.min(1, Math.max(0, s));
-}
-function findCrossings(boundaries, cut) {
-  const out = [];
-  for (let k = 0; k + 1 < cut.length; k++) crossingsOnSegment(boundaries, cut, k, out);
-  return out.sort((x, y) => x.s - y.s);
-}
-function crossingsOnSegment(boundaries, cut, k, out) {
-  const a = cut[k];
-  const d = { x: cut[k + 1].x - a.x, y: cut[k + 1].y - a.y };
-  const push = (contour, seg, t, before, after) => {
-    const pt = evalSeg(boundaries[contour][seg], t);
-    const s = cutPosition(cut, k, pt);
-    if (s === null) return;
-    out.push({ contour, seg, t, pt, s, enters: before > 0 && after < 0 });
-  };
-  boundaries.forEach((contour, ci) => {
-    const fs = contour.map((s) => sideCoeffs(s, a, d));
-    const n = contour.length;
-    fs.forEach((f, si) => {
-      for (const c of signChanges(f, false)) push(ci, si, c.t, c.before, c.after);
-      if (f[0] !== 0) return;
-      const after = endSide(f, true);
-      if (after === 0) return;
-      let before = 0;
-      for (let k2 = 1; k2 <= n && before === 0; k2++) before = endSide(fs[(si - k2 + n) % n], false);
-      if (before !== 0 && before !== after) push(ci, si, 0, before, after);
-    });
-  });
-}
-function traceLoops(boundaries, partner, chord) {
-  const byContour = /* @__PURE__ */ new Map();
-  for (const c of partner.keys()) {
-    const list = byContour.get(c.contour) ?? [];
-    list.push(c);
-    byContour.set(c.contour, list);
-  }
-  const arcFrom = /* @__PURE__ */ new Map();
-  const untouched = [];
-  boundaries.forEach((contour, ci) => {
-    const cuts = byContour.get(ci);
-    if (!cuts) {
-      untouched.push(contour);
-      return;
-    }
-    cuts.sort((x, y) => x.seg - y.seg || x.t - y.t);
-    for (let k = 0; k < cuts.length; k++) {
-      const from = cuts[k], to = cuts[(k + 1) % cuts.length];
-      arcFrom.set(from, { segs: arcBetween(contour, from, to, cuts.length === 1), end: to });
-    }
-  });
-  const loops = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const start of arcFrom.keys()) {
-    if (seen.has(start)) continue;
-    const loop = [];
-    let at = start;
-    while (!seen.has(at)) {
-      seen.add(at);
-      const arc = arcFrom.get(at);
-      loop.push(...arc.segs);
-      const run = chord.get(arc.end);
-      for (let i = 0; i + 1 < run.length; i++) loop.push([run[i], run[i + 1]]);
-      at = partner.get(arc.end);
-    }
-    loops.push(loop);
-  }
-  return { loops, untouched };
-}
-function arcBetween(contour, from, to, whole) {
-  const out = [];
-  const add = (s) => {
-    if (s) out.push(s);
-  };
-  if (!whole && to.seg === from.seg && to.t > from.t) {
-    add(subSeg(contour[from.seg], from.t, to.t, from.pt, to.pt));
-    return out;
-  }
-  const n = contour.length;
-  const first = contour[from.seg];
-  add(subSeg(first, from.t, 1, from.pt, first[first.length - 1]));
-  for (let i = (from.seg + 1) % n; i !== to.seg; i = (i + 1) % n) out.push(contour[i]);
-  const last = contour[to.seg];
-  add(subSeg(last, 0, to.t, last[0], to.pt));
-  return out;
+  const n = contour.length;
+  const first = contour[from.seg];
+  add(subSeg(first, from.t, 1, from.pt, first[first.length - 1]));
+  for (let i = (from.seg + 1) % n; i !== to.seg; i = (i + 1) % n) out.push(contour[i]);
+  const last = contour[to.seg];
+  add(subSeg(last, 0, to.t, last[0], to.pt));
+  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) {
@@ -914,6 +869,131 @@ function writePath(subpaths, fillRule) {
   return { kind: "polygon", commands: new Uint8Array(cmds), coords: new Float32Array(xs), fillRule };
 }
 
-export { multiPolygonToPath, pathCrop, pathDivide, pathExclude, pathIntersect, pathSubtract, pathToMultiPolygon, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment };
+// src/booleans/splitBySegment.ts
+function splitPathBySegment(path, a, b, opts = {}) {
+  return splitPathByPolyline(path, [a, b], opts);
+}
+function splitPathByPolyline(path, cut, opts = {}) {
+  let pts = distinctPoints(cut);
+  if (pts.length < 2) return null;
+  const outRule = fillRuleOf(path);
+  const boundaries = resolveBoundaries(path, opts);
+  if (boundaries.length === 0) return null;
+  pts = openClosedCut(pts, boundaries);
+  const loops = interiorLoops(pts, boundaries);
+  const pieces = knife(path, pts, opts, pts.length);
+  if (loops.length === 0) return pieces;
+  const regions = pieces ? pieces.map((p) => orientBoundaries(parseContours(p), outRule)) : [boundaries];
+  if (!cutOutLoops(regions, loops)) return pieces;
+  return regions.map((r) => toPath(r, outRule));
+}
+var fillRuleOf = (path) => path.kind === "polygon" ? path.fillRule : "nonzero";
+function resolveBoundaries(path, opts) {
+  const contours = parseContours(path);
+  if (contoursIntersect(contours, opts.flattenTolerance ?? 0.5)) {
+    return orientBoundaries(parseContours(pathUnion(path)), "nonzero");
+  }
+  return orientBoundaries(contours, fillRuleOf(path));
+}
+function knife(path, cut, opts, budget) {
+  const outRule = fillRuleOf(path);
+  const boundaries = resolveBoundaries(path, opts);
+  if (boundaries.length === 0) return null;
+  const crossings = findCrossings(boundaries, cut);
+  const partner = /* @__PURE__ */ new Map();
+  const chord = /* @__PURE__ */ new Map();
+  const accepted = [];
+  let deferred = false;
+  for (let k = 0; k + 1 < crossings.length; k++) {
+    const c0 = crossings[k], c1 = crossings[k + 1];
+    if (!c0.enters || c1.enters || c1.s - c0.s <= 1e-9) continue;
+    const run = splitLoops(cutBetween(cut, c0, c1)).spine;
+    if (accepted.some((other) => polylinesCross(run, other))) {
+      deferred = true;
+      continue;
+    }
+    accepted.push(run);
+    partner.set(c0, c1);
+    partner.set(c1, c0);
+    chord.set(c0, run);
+    chord.set(c1, run.slice().reverse());
+  }
+  if (partner.size === 0) return null;
+  const { loops, untouched } = traceLoops(boundaries, partner, chord);
+  const traced = assembleRegions(loops, untouched.filter((c) => signedArea(c) < 0));
+  const islands = untouched.filter((c) => signedArea(c) > 0);
+  const minArea = negligibleArea(boundaries);
+  const regions = traced.filter((r) => Math.abs(regionArea(r)) > minArea);
+  if (islands.length > 0) {
+    const leftover = untouched.filter((c) => !traced.some((r) => r.includes(c)));
+    regions.push(leftover);
+  }
+  const pieces = regions.map((r) => toPath(r, outRule));
+  if (!deferred || budget <= 1) return pieces;
+  return pieces.flatMap((p) => knife(p, cut, opts, budget - 1) ?? [p]);
+}
+function snipPathByPolyline(path, cut) {
+  const pts = distinctPoints(cut);
+  if (pts.length < 2) return null;
+  const rule = path.kind === "polygon" ? path.fillRule : "nonzero";
+  const runs = [];
+  const missed = [];
+  for (const sub of parseSubpaths(path, false)) {
+    const stops = snipStations(sub, pts);
+    if (stops.length === 0) {
+      missed.push(sub);
+      continue;
+    }
+    const segs = sub.segs;
+    if (sub.closed) {
+      for (let i = 0; i < stops.length; i++) {
+        runs.push(arcBetween(segs, stops[i], stops[(i + 1) % stops.length], stops.length === 1));
+      }
+    } else {
+      const last = segs[segs.length - 1];
+      const all = [
+        { seg: 0, t: 0, pt: segs[0][0] },
+        ...stops,
+        { seg: segs.length - 1, t: 1, pt: last[last.length - 1] }
+      ];
+      for (let i = 0; i + 1 < all.length; i++) runs.push(arcBetween(segs, all[i], all[i + 1], false));
+    }
+  }
+  if (runs.length === 0) return null;
+  const pieces = runs.filter((r) => r.length > 0).map((r) => writePath([{ segs: r, closed: false }], rule));
+  if (missed.length > 0) pieces.push(writePath(missed, rule));
+  return pieces;
+}
+function snipStations(sub, cut) {
+  const raw = [];
+  sub.segs.forEach((seg, si) => {
+    for (let k = 0; k + 1 < cut.length; k++) {
+      const a = cut[k];
+      const d = { x: cut[k + 1].x - a.x, y: cut[k + 1].y - a.y };
+      for (const c of signChanges(sideCoeffs(seg, a, d), true)) {
+        const pt = evalSeg(seg, c.t);
+        if (cutPosition(cut, k, pt) !== null) raw.push({ seg: si, t: c.t, pt });
+      }
+    }
+  });
+  raw.sort((x, y) => x.seg - y.seg || x.t - y.t);
+  const tol = extentOf([sub.segs]) * 1e-9;
+  const same = (p, q) => Math.abs(p.x - q.x) <= tol && Math.abs(p.y - q.y) <= tol;
+  const groups = [];
+  for (const st of raw) {
+    const g = groups[groups.length - 1];
+    if (g && same(g[0].pt, st.pt)) g.push(st);
+    else groups.push([st]);
+  }
+  if (sub.closed && groups.length > 1 && same(groups[0][0].pt, groups[groups.length - 1][0].pt)) {
+    groups[0].push(...groups.pop());
+  }
+  const first = sub.segs[0][0];
+  const lastSeg = sub.segs[sub.segs.length - 1];
+  const end = lastSeg[lastSeg.length - 1];
+  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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map