@weasel-js/geom 1.7.0 → 1.7.1

package/dist/booleans/index.js

@@ -1,8 +1,10 @@
-import { PATH_Z, PATH_Q, elevateQuadraticToCubic, flattenCubic, PATH_C, PATH_L, PATH_M } from '../chunk-36DHVSOV.js';
+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 polygonClipping from 'polygon-clipping';
 
 // src/booleans/adapter.ts
-var DEFAULT_FLATTEN_TOLERANCE = 0.5;
 function pathToMultiPolygon(path, opts = {}) {
   if (path.kind === "rect") {
     const { x, y, width, height } = path;
@@ -83,7 +85,7 @@ function pathToMultiPolygon(path, opts = {}) {
   }
   finalizeCurrent();
   if (rings.length === 0) return [];
-  return groupRings(rings, path.fillRule ?? "nonzero");
+  return groupRings(rings, path.fillRule);
 }
 function ringSignedArea(ring) {
   let a = 0;
@@ -202,7 +204,7 @@ function multiPolygonToPath(mp) {
   return { kind: "polygon", commands, coords, fillRule: "nonzero" };
 }
 
-// src/booleans/index.ts
+// src/booleans/ops.ts
 function pathUnion(...paths) {
   if (paths.length === 0) return multiPolygonToPath([]);
   const mps = paths.map((p) => pathToMultiPolygon(p));
@@ -274,6 +276,644 @@ function pathCrop(...paths) {
   return out;
 }
 
-export { multiPolygonToPath, pathCrop, pathDivide, pathExclude, pathIntersect, pathSubtract, pathToMultiPolygon, pathUnion };
+// 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 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;
+}
+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;
+}
+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 };
+}
+
+export { multiPolygonToPath, pathCrop, pathDivide, pathExclude, pathIntersect, pathSubtract, pathToMultiPolygon, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map