@weasel-js/geom 1.9.3 → 1.9.4

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, flattenCubic, segmentsCross, pointInPolygon } from '../chunk-X6GJRIQD.js';
+import { EPS } from '../chunk-N5SYTHMR.js';
+import { PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M } from '../chunk-E4TJRGJD.js';
 import polygonClipping from 'polygon-clipping';
 
 // src/booleans/adapter.ts
@@ -21,6 +21,7 @@ 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 = () => {
@@ -40,14 +41,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 +61,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,7 +74,8 @@ 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;
@@ -77,6 +83,8 @@ function pathToMultiPolygon(path, opts = {}) {
       }
       case PATH_Z: {
         finalizeCurrent();
+        cx = startX;
+        cy = startY;
         break;
       }
       default:
@@ -275,261 +283,22 @@ function pathCrop(...paths) {
   }
   return out;
 }
-
-// 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 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);
-  }
-  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 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]);
-  }
-  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));
-}
-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 };
-  const s = { x: q1.x - q0.x, y: q1.y - q0.y };
-  const den = r.x * s.y - r.y * s.x;
-  if (den === 0) return null;
-  const qp = { x: q0.x - p0.x, y: q0.y - p0.y };
-  const t = (qp.x * s.y - qp.y * s.x) / den;
-  const u = (qp.x * r.y - qp.y * r.x) / den;
-  const eps = 1e-9;
-  if (t <= eps || t >= 1 - eps || u <= eps || u >= 1 - eps) return null;
-  return { x: p0.x + t * r.x, y: p0.y + t * r.y };
-}
-function splitLoops(run) {
-  const spine = [run[0]];
-  const loops = [];
-  for (let i = 1; i < run.length; i++) {
-    const to = run[i];
-    for (; ; ) {
-      const from = spine[spine.length - 1];
-      let hit = null;
-      for (let j = 0; j + 2 < spine.length; j++) {
-        const x = properCrossing(from, to, spine[j], spine[j + 1]);
-        if (!x) continue;
-        const d = Math.hypot(x.x - from.x, x.y - from.y);
-        if (!hit || d < hit.d) hit = { j, x, d };
-      }
-      if (!hit) {
-        spine.push(to);
-        break;
-      }
-      loops.push([hit.x, ...spine.slice(hit.j + 1)]);
-      spine.length = hit.j + 1;
-      spine.push(hit.x);
-    }
-  }
-  const last = spine[spine.length - 1];
-  if (spine.length >= 4 && last.x === spine[0].x && last.y === spine[0].y) {
-    loops.push(spine.slice(0, -1));
-    return { spine: [], loops };
-  }
-  return { spine, loops };
-}
-function pointAt(cut, s) {
-  const k = Math.min(Math.floor(s), cut.length - 2);
-  const f = s - k;
-  const a = cut[k], b = cut[k + 1];
-  return { x: a.x + f * (b.x - a.x), y: a.y + f * (b.y - a.y) };
-}
-function openClosedCut(cut, boundaries) {
-  const n = cut.length - 1;
-  if (n < 3 || cut[0].x !== cut[n].x || cut[0].y !== cut[n].y) return cut;
-  const crossings = findCrossings(boundaries, cut);
-  const k = crossings.findIndex((c) => !c.enters);
-  if (k < 0) return cut;
-  const next = k + 1 < crossings.length ? crossings[k + 1].s : crossings[0].s + n;
-  const s = (crossings[k].s + next) / 2 % n;
-  const seg = Math.min(Math.floor(s), n - 1);
-  const start = pointAt(cut, s);
-  const ring = cut.slice(0, n);
-  return distinctPoints([start, ...ring.slice(seg + 1), ...ring.slice(0, seg + 1), start]);
-}
-function interiorLoops(cut, boundaries) {
-  const crossings = findCrossings(boundaries, cut);
-  const chords = [];
-  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) chords.push(splitLoops(cutBetween(cut, c0, c1)).spine);
-  }
-  const last = cut.length - 1;
-  const stops = [{ s: 0, pt: cut[0] }, ...crossings, { s: last, pt: cut[last] }];
-  const rings = [];
-  const loops = [];
-  for (let i = 0; i + 1 < stops.length; i++) {
-    const a = stops[i], b = stops[i + 1];
-    if (b.s - a.s <= 1e-9) continue;
-    if (windingAt(pointAt(cut, (a.s + b.s) / 2), boundaries) === 0) continue;
-    const run = [a.pt];
-    for (let v = Math.floor(a.s) + 1; v < b.s; v++) run.push(cut[v]);
-    run.push(b.pt);
-    for (const loop of splitLoops(distinctPoints(run)).loops) {
-      const ring = [...loop, loop[0]];
-      if (chords.some((c) => polylinesCross(ring, c)) || rings.some((r) => polylinesCross(ring, r))) continue;
-      rings.push(ring);
-      loops.push(loop);
-    }
-  }
-  return loops;
-}
-function cutOutLoops(regions, loops) {
-  let cut = false;
-  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 (a < 0) ring = reverseContour(ring);
-    const probe = evalSeg(ring[0], 0.5);
-    const at = regions.findIndex((r) => windingAt(probe, r) !== 0);
-    if (at < 0) continue;
-    const samples = sampleContour(ring);
-    const within = (c) => {
-      const p = evalSeg(c[0], 0.5);
-      return pointInPolygon(samples, p.x, p.y);
-    };
-    const region = regions[at];
-    regions[at] = [...region.filter((c) => !within(c)), reverseContour(ring)];
-    regions.push([ring, ...region.filter(within)]);
-    cut = true;
-  }
-  return cut;
-}
-function polylinesCross(a, b) {
-  for (let i = 0; i + 1 < a.length; i++) {
-    for (let j = 0; j + 1 < b.length; j++) {
-      if (properCrossing(a[i], a[i + 1], b[j], b[j + 1])) return true;
-    }
-  }
-  return false;
+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/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 };
@@ -663,9 +432,51 @@ function endSide(f, fromStart) {
   }
   return 0;
 }
-function parseContours(path) {
-  return parseSubpaths(path).map((s) => s.segs);
-}
+
+// 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) {
+  return parseSubpaths(path).map((s) => s.segs);
+}
 function parseSubpaths(path, implicitClose = true) {
   if (path.kind === "rect") {
     const { x, y, width: w, height: h } = path;
@@ -755,11 +566,7 @@ function windingAt(q, contours) {
   }
   return w;
 }
-function orientBoundaries(contours, fillRule) {
-  const filled = (q) => {
-    const w = windingAt(q, contours);
-    return fillRule === "evenodd" ? (w & 1) !== 0 : w !== 0;
-  };
+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);
@@ -767,7 +574,18 @@ function orientBoundaries(contours, fillRule) {
     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);
+  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];
@@ -791,44 +609,143 @@ function orientBoundaries(contours, fillRule) {
   }
   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);
+
+// 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 };
+  const s = { x: q1.x - q0.x, y: q1.y - q0.y };
+  const den = r.x * s.y - r.y * s.x;
+  if (den === 0) return null;
+  const qp = { x: q0.x - p0.x, y: q0.y - p0.y };
+  const t = (qp.x * s.y - qp.y * s.x) / den;
+  const u = (qp.x * r.y - qp.y * r.x) / den;
   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));
+  if (t <= eps || t >= 1 - eps || u <= eps || u >= 1 - eps) return null;
+  return { x: p0.x + t * r.x, y: p0.y + t * r.y };
 }
-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 splitLoops(run) {
+  const spine = [run[0]];
+  const loops = [];
+  for (let i = 1; i < run.length; i++) {
+    const to = run[i];
+    for (; ; ) {
+      const from = spine[spine.length - 1];
+      let hit = null;
+      for (let j = 0; j + 2 < spine.length; j++) {
+        const x = properCrossing(from, to, spine[j], spine[j + 1]);
+        if (!x) continue;
+        const d = Math.hypot(x.x - from.x, x.y - from.y);
+        if (!hit || d < hit.d) hit = { j, x, d };
+      }
+      if (!hit) {
+        spine.push(to);
+        break;
+      }
+      loops.push([hit.x, ...spine.slice(hit.j + 1)]);
+      spine.length = hit.j + 1;
+      spine.push(hit.x);
+    }
+  }
+  const last = spine[spine.length - 1];
+  if (spine.length >= 4 && last.x === spine[0].x && last.y === spine[0].y) {
+    loops.push(spine.slice(0, -1));
+    return { spine: [], loops };
+  }
+  return { spine, loops };
 }
-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 pointAt(cut, s) {
+  const k = Math.min(Math.floor(s), cut.length - 2);
+  const f = s - k;
+  const a = cut[k], b = cut[k + 1];
+  return { x: a.x + f * (b.x - a.x), y: a.y + f * (b.y - a.y) };
+}
+function openClosedCut(cut, boundaries) {
+  const n = cut.length - 1;
+  if (n < 3 || cut[0].x !== cut[n].x || cut[0].y !== cut[n].y) return cut;
+  const crossings = findCrossings(boundaries, cut);
+  const k = crossings.findIndex((c) => !c.enters);
+  if (k < 0) return cut;
+  const next = k + 1 < crossings.length ? crossings[k + 1].s : crossings[0].s + n;
+  const s = (crossings[k].s + next) / 2 % n;
+  const seg = Math.min(Math.floor(s), n - 1);
+  const start = pointAt(cut, s);
+  const ring = cut.slice(0, n);
+  return distinctPoints([start, ...ring.slice(seg + 1), ...ring.slice(0, seg + 1), start]);
+}
+function interiorLoops(cut, boundaries) {
+  const crossings = findCrossings(boundaries, cut);
+  const chords = [];
+  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) chords.push(splitLoops(cutBetween(cut, c0, c1)).spine);
+  }
+  const last = cut.length - 1;
+  const stops = [{ s: 0, pt: cut[0] }, ...crossings, { s: last, pt: cut[last] }];
+  const rings = [];
+  const loops = [];
+  for (let i = 0; i + 1 < stops.length; i++) {
+    const a = stops[i], b = stops[i + 1];
+    if (b.s - a.s <= 1e-9) continue;
+    if (windingAt(pointAt(cut, (a.s + b.s) / 2), boundaries) === 0) continue;
+    const run = [a.pt];
+    for (let v = Math.floor(a.s) + 1; v < b.s; v++) run.push(cut[v]);
+    run.push(b.pt);
+    for (const loop of splitLoops(distinctPoints(run)).loops) {
+      const ring = [...loop, loop[0]];
+      if (chords.some((c) => polylinesCross(ring, c)) || rings.some((r) => polylinesCross(ring, r))) continue;
+      rings.push(ring);
+      loops.push(loop);
+    }
+  }
+  return loops;
 }
+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) <= minArea) continue;
+    if (a < 0) ring = reverseContour(ring);
+    const probe = evalSeg(ring[0], 0.5);
+    const at = regions.findIndex((r) => windingAt(probe, r) !== 0);
+    if (at < 0) continue;
+    const samples = sampleContour(ring);
+    const within = (c) => {
+      const p = evalSeg(c[0], 0.5);
+      return pointInPolygon(samples, p.x, p.y);
+    };
+    const region = regions[at];
+    regions[at] = [...region.filter((c) => !within(c)), reverseContour(ring)];
+    regions.push([ring, ...region.filter(within)]);
+    cut = true;
+  }
+  return cut;
+}
+function polylinesCross(a, b) {
+  for (let i = 0; i + 1 < a.length; i++) {
+    for (let j = 0; j + 1 < b.length; j++) {
+      if (properCrossing(a[i], a[i + 1], b[j], b[j + 1])) return true;
+    }
+  }
+  return false;
+}
+
+// src/booleans/cutLoops.ts
 function traceLoops(boundaries, partner, chord) {
   const byContour = /* @__PURE__ */ new Map();
   for (const c of partner.keys()) {
@@ -885,6 +802,8 @@ function arcBetween(contour, from, to, whole) {
   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 +833,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, pathDivide, pathExclude, pathIntersect, pathSubtract, pathToMultiPolygon, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment, trianglesToPath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map