@weasel-js/geom 1.13.0-rc.0 → 1.14.0

package/dist/booleans/index.js

@@ -1,8 +1,8 @@
-import { orientBoundaries, parseContours, contoursIntersect, assembleRegions, signedArea, negligibleArea, regionArea, toPath, parseSubpaths, writePath, signChanges, sideCoeffs, evalSeg, extentOf, keepCorners, windingAt, reverseContour, sampleContour, subSeg, endSide } from '../chunk-YPWFGFQX.js';
-import '../chunk-CE7IY7TB.js';
-import { resolveCorners, DEFAULT_FLATTEN_TOLERANCE, fillsOpenSubpaths, flattenCubic, flattenQuadratic, pointInPolygon } from '../chunk-2PKPKU4P.js';
+import { orientBoundaries, parseContours, contoursIntersect, assembleRegions, signedArea, negligibleArea, regionArea, toPath, parseSubpaths, writePath, signChanges, sideCoeffs, evalSeg, extentOf, keepCorners, windingAt, reverseContour, sampleContour, subSeg, endSide, intersectSegments, derivSeg } from '../chunk-3YH5XU3H.js';
+import { nearestOnLine, nearestOnQuadratic, nearestOnCubic } from '../chunk-2N6OWA7E.js';
+import { resolveCorners, DEFAULT_FLATTEN_TOLERANCE, fillsOpenSubpaths, flattenCubic, flattenQuadratic, pointInPolygon } from '../chunk-EURWZUNY.js';
 import '../chunk-755Y4YZS.js';
-import { PATH_Z, PATH_Q, elevateQuadraticToCubic, PATH_C, PATH_L, PATH_M } from '../chunk-B53BERKG.js';
+import { worldCoords, PATH_Z, PATH_Q, elevateQuadraticToCubic, PATH_C, PATH_L, PATH_M, originFor, coordsFrom } from '../chunk-B3D6KWW3.js';
 import polygonClipping from 'polygon-clipping';
 
 // src/booleans/adapter.ts
@@ -25,7 +25,8 @@ function pathToMultiPolygon(given, opts = {}) {
   let cx = 0, cy = 0;
   let startX = 0, startY = 0;
   let ci = 0;
-  const { commands, coords } = path;
+  const { commands } = path;
+  const coords = worldCoords(path);
   const fillsOpen = fillsOpenSubpaths(path);
   const finalizeCurrent = (closed = fillsOpen) => {
     if (!closed) current = null;
@@ -158,25 +159,25 @@ function groupRings(rings, fillRule) {
     parent[i] = best;
   }
   for (let i = 0; i < n; i++) if (parent[i] >= 0) children[parent[i]].push(i);
-  const filled = new Array(n);
+  const filled2 = new Array(n);
   for (let i = 0; i < n; i++) {
     let depth = 0;
-    let winding = 0;
+    let winding2 = 0;
     for (let a = i; a >= 0; a = parent[a]) {
-      winding += orient[a];
+      winding2 += orient[a];
       if (a !== i) depth++;
     }
-    filled[i] = fillRule === "evenodd" ? depth % 2 === 0 : winding !== 0;
+    filled2[i] = fillRule === "evenodd" ? depth % 2 === 0 : winding2 !== 0;
   }
   const out = [];
   for (let i = 0; i < n; i++) {
-    if (!filled[i]) continue;
-    if (parent[i] >= 0 && filled[parent[i]]) continue;
+    if (!filled2[i]) continue;
+    if (parent[i] >= 0 && filled2[parent[i]]) continue;
     const polygon = [rings[i]];
     const queue = [...children[i]];
     while (queue.length > 0) {
       const c = queue.pop();
-      if (filled[c]) queue.push(...children[c]);
+      if (filled2[c]) queue.push(...children[c]);
       else polygon.push(rings[c]);
     }
     out.push(polygon);
@@ -195,7 +196,7 @@ function multiPolygonToPath(mp) {
     }
   }
   const commands = new Uint8Array(nCmds);
-  const coords = new Float32Array(nCoords);
+  const world = new Float64Array(nCoords);
   let ci = 0;
   let pi = 0;
   for (const poly of mp) {
@@ -203,17 +204,18 @@ function multiPolygonToPath(mp) {
       if (ring.length < 4) continue;
       const unique = ring.length - 1;
       commands[ci++] = PATH_M;
-      coords[pi++] = ring[0][0];
-      coords[pi++] = ring[0][1];
+      world[pi++] = ring[0][0];
+      world[pi++] = ring[0][1];
       for (let k = 1; k < unique; k++) {
         commands[ci++] = PATH_L;
-        coords[pi++] = ring[k][0];
-        coords[pi++] = ring[k][1];
+        world[pi++] = ring[k][0];
+        world[pi++] = ring[k][1];
       }
       commands[ci++] = PATH_Z;
     }
   }
-  return { kind: "polygon", commands, coords, fillRule: "nonzero" };
+  const origin = originFor(world);
+  return { kind: "polygon", commands, coords: coordsFrom(origin, world), fillRule: "nonzero", ...origin ? { origin } : {} };
 }
 
 // src/booleans/arrangement.ts
@@ -319,15 +321,15 @@ function cutAll(segs, eps) {
 }
 function linkFaces(xs, ys, origin) {
   const out = xs.map(() => []);
-  const angle = [];
+  const angle2 = [];
   for (let h = 0; h < origin.length; h++) {
     const u = origin[h], v = origin[h ^ 1];
     out[u].push(h);
-    angle[h] = Math.atan2(ys[v] - ys[u], xs[v] - xs[u]);
+    angle2[h] = Math.atan2(ys[v] - ys[u], xs[v] - xs[u]);
   }
   const slot = [];
   for (const list of out) {
-    list.sort((a, b) => angle[a] - angle[b]);
+    list.sort((a, b) => angle2[a] - angle2[b]);
     list.forEach((h, k) => {
       slot[h] = k;
     });
@@ -483,30 +485,530 @@ function arrangementFaces(inputs) {
   return [...faces2.values()].sort((a, b) => popcount(a.mask) - popcount(b.mask) || (a.mask < b.mask ? -1 : a.mask > b.mask ? 1 : 0) || left(a) - left(b) || low(a) - low(b));
 }
 
+// src/booleans/curveOverlap.ts
+function nearestOnSeg(s, p) {
+  if (s.length === 2) return nearestOnLine(p.x, p.y, s[0].x, s[0].y, s[1].x, s[1].y);
+  if (s.length === 3) return nearestOnQuadratic(p.x, p.y, s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y);
+  return nearestOnCubic(p.x, p.y, s[0].x, s[0].y, s[1].x, s[1].y, s[2].x, s[2].y, s[3].x, s[3].y);
+}
+var SAMPLES = [0.25, 0.5, 0.75];
+function sharedStretch(a, b, snap) {
+  const ends = [];
+  const add = (e) => {
+    if (!ends.some((f) => Math.hypot(f.p.x - e.p.x, f.p.y - e.p.y) <= snap)) ends.push(e);
+  };
+  for (const [tb, p] of [[0, b[0]], [1, b[b.length - 1]]]) {
+    const n = nearestOnSeg(a, p);
+    if (n.dist <= snap) add({ ta: n.t, tb, p });
+  }
+  for (const [ta, p] of [[0, a[0]], [1, a[a.length - 1]]]) {
+    const n = nearestOnSeg(b, p);
+    if (n.dist <= snap) add({ ta, tb: n.t, p });
+  }
+  let best = null;
+  for (let i = 0; i < ends.length; i++) {
+    for (let j = i + 1; j < ends.length; j++) {
+      const [e, f] = ends[i].ta <= ends[j].ta ? [ends[i], ends[j]] : [ends[j], ends[i]];
+      if (best && f.ta - e.ta <= best[1].ta - best[0].ta) continue;
+      const on = SAMPLES.every((s) => nearestOnSeg(b, evalSeg(a, e.ta + (f.ta - e.ta) * s)).dist <= snap);
+      if (on) best = [e, f];
+    }
+  }
+  return best;
+}
+function coincide(e, f, snap) {
+  const same = e.from === f.from && e.to === f.to;
+  if (!same && !(e.from === f.to && e.to === f.from)) return false;
+  return SAMPLES.every((s) => nearestOnSeg(f.seg, evalSeg(e.seg, s)).dist <= snap);
+}
+function mergeCoincident(edges, snap) {
+  const byEnds = /* @__PURE__ */ new Map();
+  const out = [];
+  for (const e of edges) {
+    const key = e.from < e.to ? `${e.from},${e.to}` : `${e.to},${e.from}`;
+    const list = byEnds.get(key) ?? [];
+    const twin = list.find((f) => coincide(f, e, snap));
+    if (twin) {
+      (twin.also ??= []).push({ operand: e.operand, sign: twin.from === e.from ? 1 : -1 });
+      continue;
+    }
+    list.push(e);
+    byEnds.set(key, list);
+    out.push(e);
+  }
+  return out;
+}
+
+// src/booleans/curveEdges.ts
+var OVERLAP_HITS = 16;
+var END_T = 1e-9;
+var Vertices = class {
+  constructor(snap) {
+    this.snap = snap;
+  }
+  snap;
+  points = [];
+  grid = /* @__PURE__ */ new Map();
+  id(p) {
+    const gx = Math.floor(p.x / this.snap), gy = Math.floor(p.y / this.snap);
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        for (const i2 of this.grid.get(`${gx + dx},${gy + dy}`) ?? []) {
+          const q = this.points[i2];
+          if (Math.hypot(q.x - p.x, q.y - p.y) <= this.snap) return i2;
+        }
+      }
+    }
+    const i = this.points.length;
+    this.points.push({ x: p.x, y: p.y });
+    const key = `${gx},${gy}`;
+    const cell = this.grid.get(key);
+    if (cell) cell.push(i);
+    else this.grid.set(key, [i]);
+    return i;
+  }
+};
+function refsOf(operands) {
+  const out = [];
+  operands.forEach((contours, operand) => contours.forEach((c, contour) => c.forEach((seg, index) => {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of seg) {
+      x0 = Math.min(x0, p.x);
+      x1 = Math.max(x1, p.x);
+      y0 = Math.min(y0, p.y);
+      y1 = Math.max(y1, p.y);
+    }
+    out.push({ seg, operand, contour, index, count: c.length, box: [x0, y0, x1, y1] });
+  })));
+  return out;
+}
+var adjacent = (a, b) => {
+  if (a.operand !== b.operand || a.contour !== b.contour) return false;
+  const d = Math.abs(a.index - b.index);
+  return d === 1 || d === a.count - 1;
+};
+function loops(seg) {
+  if (seg.length < 4) return false;
+  const mid = evalSeg(seg, 0.5);
+  const l = subSeg(seg, 0, 0.5, seg[0], mid);
+  const r = subSeg(seg, 0.5, 1, mid, seg[3]);
+  if (!l || !r) return false;
+  return intersectSegments(l, r).some((h) => h.ta < 1 - 1e-6 || h.tb > 1e-6);
+}
+function cutEdges(operands, snap) {
+  const refs = refsOf(operands);
+  if (refs.some((r) => loops(r.seg))) return null;
+  const verts = new Vertices(snap);
+  const ends = refs.map(({ seg }) => [verts.id(seg[0]), verts.id(seg[seg.length - 1])]);
+  const stops = refs.map(() => []);
+  for (let i = 0; i < refs.length; i++) {
+    const a = refs[i];
+    for (let j = i + 1; j < refs.length; j++) {
+      const b = refs[j];
+      if (a.box[0] > b.box[2] + snap || b.box[0] > a.box[2] + snap || a.box[1] > b.box[3] + snap || b.box[1] > a.box[3] + snap) continue;
+      const shared = sharedStretch(a.seg, b.seg, snap);
+      if (shared) {
+        for (const end of shared) {
+          const v = verts.id(end.p);
+          stops[i].push({ t: end.ta, v });
+          stops[j].push({ t: end.tb, v });
+        }
+        continue;
+      }
+      const hits = intersectSegments(a.seg, b.seg);
+      if (hits.length >= OVERLAP_HITS) return null;
+      const near = adjacent(a, b);
+      for (const h of hits) {
+        if (near && (h.ta > 1 - END_T && h.tb < END_T || h.ta < END_T && h.tb > 1 - END_T)) continue;
+        const v = verts.id(h);
+        stops[i].push({ t: h.ta, v });
+        stops[j].push({ t: h.tb, v });
+      }
+    }
+  }
+  const edges = [];
+  refs.forEach((ref, i) => {
+    const { seg } = ref;
+    const list = [{ t: 0, v: ends[i][0] }, ...stops[i].sort((p, q) => p.t - q.t), { t: 1, v: ends[i][1] }];
+    const kept = [list[0]];
+    for (let k = 1; k < list.length; k++) {
+      const s = list[k];
+      if (s.v !== kept[kept.length - 1].v) kept.push(s);
+      else if (k === list.length - 1 && kept.length > 1) kept[kept.length - 1] = s;
+    }
+    const size = Math.hypot(ref.box[2] - ref.box[0], ref.box[3] - ref.box[1]);
+    if (kept.length === 1 && seg.length > 2 && size > 100 * snap) kept.push(list[list.length - 1]);
+    for (let k = 0; k + 1 < kept.length; k++) {
+      const a = kept[k], b = kept[k + 1];
+      const piece = a.t === 0 && b.t === 1 ? seg.slice() : subSeg(seg, a.t, b.t, verts.points[a.v], verts.points[b.v]);
+      if (!piece) continue;
+      piece[0] = verts.points[a.v];
+      piece[piece.length - 1] = verts.points[b.v];
+      edges.push({ seg: piece, from: a.v, to: b.v, operand: ref.operand, source: seg, t0: a.t, t1: b.t, key: i + a.t * 0.5, reversed: false });
+    }
+  });
+  return { edges: mergeCoincident(edges, snap), points: verts.points };
+}
+
+// src/booleans/curveClassify.ts
+function windingSet(contours, fillRule) {
+  const segs = contours.flat();
+  const boxes = new Float64Array(segs.length * 4);
+  segs.forEach((s, i) => {
+    let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+    for (const p of s) {
+      x0 = Math.min(x0, p.x);
+      x1 = Math.max(x1, p.x);
+      y0 = Math.min(y0, p.y);
+      y1 = Math.max(y1, p.y);
+    }
+    boxes.set([x0, y0, x1, y1], i * 4);
+  });
+  return { segs, boxes, fillRule };
+}
+var RAY = { x: 1, y: 0 };
+function winding(q, set) {
+  let w = 0;
+  const { segs, boxes } = set;
+  for (let i = 0; i < segs.length; i++) {
+    if (q.y < boxes[i * 4 + 1] || q.y > boxes[i * 4 + 3] || boxes[i * 4 + 2] < q.x) continue;
+    const s = segs[i];
+    for (const c of signChanges(sideCoeffs(s, q, RAY), true)) {
+      if (evalSeg(s, c.t).x > q.x) w += c.after > 0 ? 1 : -1;
+    }
+  }
+  return w;
+}
+var filled = (w, rule) => rule === "evenodd" ? (w & 1) !== 0 : w !== 0;
+var reversed = (e) => ({ ...e, seg: e.seg.slice().reverse(), from: e.to, to: e.from, reversed: true });
+function runs(e, operands) {
+  const n = new Array(operands).fill(0);
+  n[e.operand] = 1;
+  for (const { operand, sign } of e.also ?? []) n[operand] += sign;
+  return n;
+}
+function coverEdges(edges, sets, probe) {
+  const out = [];
+  for (const e of edges) {
+    const tm = (e.t0 + e.t1) / 2;
+    const m = evalSeg(e.source, tm);
+    let tan = derivSeg(e.source, tm);
+    let len = Math.hypot(tan.x, tan.y);
+    if (len === 0) {
+      const a = e.seg[0], b = e.seg[e.seg.length - 1];
+      tan = { x: b.x - a.x, y: b.y - a.y };
+      len = Math.hypot(tan.x, tan.y);
+      if (len === 0) continue;
+    }
+    const nx = -tan.y / len * probe, ny = tan.x / len * probe;
+    const L = { x: m.x + nx, y: m.y + ny }, R = { x: m.x - nx, y: m.y - ny };
+    const along2 = runs(e, sets.length);
+    const inL = new Array(sets.length);
+    const inR = new Array(sets.length);
+    for (let k = 0; k < sets.length; k++) {
+      const wl = winding(L, sets[k]), wr = winding(R, sets[k]);
+      if (Math.abs(wl - wr) !== Math.abs(along2[k])) return null;
+      inL[k] = filled(wl, sets[k].fillRule);
+      inR[k] = filled(wr, sets[k].fillRule);
+    }
+    out.push({ edge: e, inL, inR });
+  }
+  return out;
+}
+
+// src/booleans/curveTrace.ts
+var TAU = Math.PI * 2;
+var TIE = 1e-7;
+function leaving(s) {
+  const a = s[0];
+  for (let i = 1; i < s.length; i++) if (s[i].x !== a.x || s[i].y !== a.y) return { x: s[i].x - a.x, y: s[i].y - a.y };
+  return { x: 0, y: 0 };
+}
+var backward = (s) => s.slice().reverse();
+function along(s, dist) {
+  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);
+  const p = evalSeg(s, len === 0 ? 0 : Math.min(1, dist / len));
+  return { x: p.x - s[0].x, y: p.y - s[0].y };
+}
+var angle = (d) => Math.atan2(d.y, d.x);
+function clockwise(from, to) {
+  const d = (from - to) % TAU;
+  return d <= 0 ? d + TAU : d;
+}
+function chordLength(s) {
+  const a = s[0], b = s[s.length - 1];
+  return Math.hypot(b.x - a.x, b.y - a.y) || Math.hypot(s[1].x - a.x, s[1].y - a.y);
+}
+function nextEdge(e, out) {
+  const cands = out[e.to];
+  if (!cands || cands.length === 0) return -1;
+  if (cands.length === 1) return cands[0].key;
+  const back = backward(e.seg);
+  const turns = (dir) => {
+    const from = angle(dir(back));
+    return cands.map((c) => clockwise(from, angle(dir(c.seg))));
+  };
+  const tied = (t2) => {
+    const sorted = t2.slice().sort((x, y) => x - y);
+    return sorted[0] < TIE || sorted[sorted.length - 1] > TAU - TIE || sorted[1] - sorted[0] < TIE;
+  };
+  let t = turns(leaving);
+  if (tied(t)) {
+    const dist = 1e-3 * Math.min(chordLength(e.seg), ...cands.map((c) => chordLength(c.seg)));
+    t = turns((s) => along(s, dist));
+    if (tied(t)) return -1;
+  }
+  let best = 0;
+  for (let i = 1; i < t.length; i++) if (t[i] < t[best]) best = i;
+  return cands[best].key;
+}
+function joined(e, f) {
+  if (e.source !== f.source || e.reversed !== f.reversed) return null;
+  const [lo, hi] = e.reversed ? [f, e] : [e, f];
+  if (lo.t1 !== hi.t0) return null;
+  const t0 = lo.t0, t1 = hi.t1;
+  const a = lo.seg[e.reversed ? lo.seg.length - 1 : 0], b = hi.seg[e.reversed ? 0 : hi.seg.length - 1];
+  const seg = t0 === 0 && t1 === 1 ? lo.source.slice() : subSeg(lo.source, t0, t1, a, b);
+  if (!seg) return null;
+  seg[0] = a;
+  seg[seg.length - 1] = b;
+  if (e.reversed) seg.reverse();
+  return { ...e, seg, from: e.from, to: f.to, t0, t1 };
+}
+function rejoin(loop) {
+  const out = [];
+  for (const e of loop) {
+    const j = out.length > 0 ? joined(out[out.length - 1], e) : null;
+    if (j) out[out.length - 1] = j;
+    else out.push(e);
+  }
+  while (out.length > 1) {
+    const j = joined(out[out.length - 1], out[0]);
+    if (!j) break;
+    out.pop();
+    out[0] = j;
+  }
+  return out.map((e) => e.seg);
+}
+function traceLoops(edges, vertexCount) {
+  const byKey = /* @__PURE__ */ new Map();
+  const out = Array.from({ length: vertexCount }, () => []);
+  edges.forEach((e, i) => {
+    byKey.set(e.key, i);
+    out[e.from].push(e);
+  });
+  if (byKey.size !== edges.length) return null;
+  const next = edges.map((e) => {
+    const k = nextEdge(e, out);
+    return k < 0 ? -1 : byKey.get(k);
+  });
+  if (next.includes(-1)) return null;
+  const loopOf = new Int32Array(edges.length).fill(-1);
+  const loops2 = [];
+  for (let s = 0; s < edges.length; s++) {
+    if (loopOf[s] >= 0) continue;
+    const loop = [];
+    let e = s;
+    do {
+      if (loopOf[e] >= 0) return null;
+      loopOf[e] = loops2.length;
+      loop.push(e);
+      e = next[e];
+    } while (e !== s);
+    let first = 0;
+    for (let i = 1; i < loop.length; i++) if (edges[loop[i]].key < edges[loop[first]].key) first = i;
+    loops2.push(rejoin([...loop.slice(first), ...loop.slice(0, first)].map((i) => edges[i])));
+  }
+  return loops2;
+}
+
+// src/booleans/curveBoolean.ts
+var MAX_SEGMENTS = 4096;
+function hasCurve(path) {
+  const p = resolveCorners(path);
+  return p.kind === "polygon" && p.commands.some((c) => c === PATH_C || c === PATH_Q);
+}
+function closingTrimmed(loop) {
+  if (loop.length < 2) return loop;
+  const last = loop[loop.length - 1];
+  return last.length === 2 ? loop.slice(0, -1) : loop;
+}
+function cutPaths(paths) {
+  if (!paths.some(hasCurve)) return null;
+  const operands = paths.map((p) => parseContours(p));
+  const count = operands.reduce((n, cs) => n + cs.reduce((m, c) => m + c.length, 0), 0);
+  if (count === 0 || count > MAX_SEGMENTS) return null;
+  const extent = extentOf(operands.flat()) || 1;
+  const arrangement = cutEdges(operands, extent * 1e-6);
+  if (!arrangement) return null;
+  const sets = operands.map((cs, i) => {
+    const p = paths[i];
+    return windingSet(cs, p.kind === "polygon" ? p.fillRule : "nonzero");
+  });
+  const edges = coverEdges(arrangement.edges, sets, extent * 1e-7);
+  if (!edges) return null;
+  return { edges, vertexCount: arrangement.points.length, clockwise: operands.map(clockwiseFirst) };
+}
+function curveRegions(cut, label) {
+  const sides = /* @__PURE__ */ new Map();
+  const add = (k, e) => {
+    const list = sides.get(k);
+    if (list) list.push(e);
+    else sides.set(k, [e]);
+  };
+  for (const { edge, inL, inR } of cut.edges) {
+    const l = label(inL), r = label(inR);
+    if (l === r) continue;
+    if (l !== -1) add(l, edge);
+    if (r !== -1) add(r, reversed(edge));
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [k, edges] of sides) {
+    const loops2 = traceLoops(edges, cut.vertexCount);
+    if (!loops2) return null;
+    out.set(k, loops2);
+  }
+  return out;
+}
+function writeLoops(loops2, clockwise2) {
+  const turned = clockwise2 ? loops2.map(reversedFromFirst) : loops2;
+  return writePath(turned.map((l) => ({ segs: closingTrimmed(l), closed: true })), "nonzero");
+}
+function curveBoolean(paths, keep) {
+  const cut = cutPaths(paths);
+  if (!cut) return null;
+  const regions = curveRegions(cut, (inside) => keep(inside) ? 0 : -1);
+  if (!regions) return null;
+  return writeLoops(regions.get(0) ?? [], cut.clockwise[0]);
+}
+function clockwiseFirst(contours) {
+  let best = 0;
+  for (const c of contours) {
+    const a = signedArea(c);
+    if (Math.abs(a) > Math.abs(best)) best = a;
+  }
+  return best < 0;
+}
+function reversedFromFirst(loop) {
+  const rev = reverseContour(loop);
+  return [rev[rev.length - 1], ...rev.slice(0, -1)];
+}
+
+// src/booleans/curvePieces.ts
+var covering = (inside) => {
+  const s = [];
+  inside.forEach((v, i) => {
+    if (v) s.push(i);
+  });
+  return s;
+};
+var maskOf = (sources) => sources.reduce((m, i) => m | 1n << BigInt(i), 0n);
+function corner(loops2) {
+  const pts = sampleContour(loops2[0]);
+  let x = Infinity, y = Infinity;
+  for (let i = 0; i < pts.length; i += 2) {
+    x = Math.min(x, pts[i]);
+    y = Math.min(y, pts[i + 1]);
+  }
+  return [x, y];
+}
+function connected(loops2) {
+  const outers = [], holes = [];
+  for (const l of loops2) (signedArea(l) > 0 ? outers : holes).push(l);
+  return assembleRegions(outers, holes);
+}
+function curveDivide(paths, split) {
+  const cut = cutPaths(paths);
+  if (!cut) return null;
+  const ids = /* @__PURE__ */ new Map();
+  const sets = [];
+  const regions = curveRegions(cut, (inside) => {
+    const s = covering(inside);
+    if (s.length === 0) return -1;
+    const key = s.join(",");
+    let id = ids.get(key);
+    if (id === void 0) {
+      id = sets.length;
+      ids.set(key, id);
+      sets.push(s);
+    }
+    return id;
+  });
+  if (!regions) return null;
+  const out = [];
+  for (const [id, loops2] of regions) {
+    const sources = sets[id];
+    const mask = maskOf(sources);
+    for (const face of split ? connected(loops2) : [loops2]) {
+      out.push({ piece: { path: writeLoops(face, cut.clockwise[sources[0]]), sources }, mask, at: corner(face) });
+    }
+  }
+  return out.sort((a, b) => a.piece.sources.length - b.piece.sources.length || (a.mask < b.mask ? -1 : a.mask > b.mask ? 1 : 0) || a.at[0] - b.at[0] || a.at[1] - b.at[1]).map((o) => o.piece);
+}
+var topmost = (inside) => inside.lastIndexOf(true);
+function shown(cut) {
+  return curveRegions(cut, topmost);
+}
+function curveTrim(paths) {
+  const cut = cutPaths(paths);
+  const regions = cut && shown(cut);
+  if (!cut || !regions) return null;
+  return [...regions.keys()].sort((a, b) => a - b).map((i) => ({ path: writeLoops(regions.get(i), cut.clockwise[i]), sources: [i] }));
+}
+function curveMerge(paths, keyOf) {
+  const cut = cutPaths(paths);
+  const visible = cut && shown(cut);
+  if (!cut || !visible) return null;
+  const groupIds = /* @__PURE__ */ new Map();
+  const groupOf = paths.map((_, i) => {
+    const key = keyOf(i);
+    let g = groupIds.get(key);
+    if (g === void 0) {
+      g = groupIds.size;
+      groupIds.set(key, g);
+    }
+    return g;
+  });
+  const regions = curveRegions(cut, (inside) => {
+    const top = topmost(inside);
+    return top < 0 ? -1 : groupOf[top];
+  });
+  if (!regions) return null;
+  const pieces = [];
+  for (const [g, loops2] of regions) {
+    const sources = [...visible.keys()].filter((i) => groupOf[i] === g).sort((a, b) => a - b);
+    pieces.push({ path: writeLoops(loops2, cut.clockwise[sources[0]]), sources });
+  }
+  return pieces.sort((a, b) => a.sources[a.sources.length - 1] - b.sources[b.sources.length - 1]);
+}
+
 // src/booleans/ops.ts
 function toPath2(mp, sources) {
   return keepCorners(sources, multiPolygonToPath(mp));
 }
-function pathUnion(...paths) {
+function boolean(paths, keep, clip) {
   if (paths.length === 0) return multiPolygonToPath([]);
-  const mps = paths.map((p) => pathToMultiPolygon(p));
-  const [head, ...rest] = mps;
-  return toPath2(polygonClipping.union(head, ...rest), paths);
+  const curved = curveBoolean(paths, keep);
+  if (curved) return keepCorners(paths, curved);
+  const [head, ...rest] = paths.map((p) => pathToMultiPolygon(p));
+  return toPath2(clip(head, ...rest), paths);
+}
+var any = (inside) => inside.includes(true);
+var all = (inside) => !inside.includes(false);
+var aNotB = (inside) => inside[0] && !inside[1];
+var odd = (inside) => inside.filter(Boolean).length % 2 === 1;
+function pathUnion(...paths) {
+  return boolean(paths, any, polygonClipping.union);
 }
 function pathIntersect(...paths) {
-  if (paths.length === 0) return multiPolygonToPath([]);
-  const mps = paths.map((p) => pathToMultiPolygon(p));
-  const [head, ...rest] = mps;
-  return toPath2(polygonClipping.intersection(head, ...rest), paths);
+  return boolean(paths, all, polygonClipping.intersection);
 }
 function pathSubtract(a, b) {
-  return toPath2(polygonClipping.difference(pathToMultiPolygon(a), pathToMultiPolygon(b)), [a, b]);
+  return boolean([a, b], aNotB, polygonClipping.difference);
 }
 function pathExclude(...paths) {
-  if (paths.length === 0) return multiPolygonToPath([]);
-  const mps = paths.map((p) => pathToMultiPolygon(p));
-  const [head, ...rest] = mps;
-  return toPath2(polygonClipping.xor(head, ...rest), paths);
+  return boolean(paths, odd, polygonClipping.xor);
 }
 function pathDivide(...paths) {
   return pathDividePieces(...paths).map((p) => p.path);
@@ -514,6 +1016,7 @@ function pathDivide(...paths) {
 function pathCrop(...paths) {
   return pathCropPieces(...paths).map((p) => p.path);
 }
+var cornered = (pieces, sources) => pieces.map(({ path, sources: s }) => ({ path: keepCorners(sources, path), sources: s }));
 function faces(paths) {
   const clean = paths.map((p) => {
     const mp = pathToMultiPolygon(p);
@@ -526,6 +1029,8 @@ function faces(paths) {
   });
 }
 function pathDividePieces(...paths) {
+  const curved = curveDivide(paths, false);
+  if (curved) return cornered(curved, paths);
   const regions = /* @__PURE__ */ new Map();
   for (const { polygon, sources } of faces(paths)) {
     const key = sources.join(",");
@@ -536,20 +1041,26 @@ function pathDividePieces(...paths) {
   return [...regions.values()].map(({ polygons, sources }) => ({ path: toPath2(polygons, paths), sources }));
 }
 function pathFacePieces(...paths) {
+  const curved = curveDivide(paths, true);
+  if (curved) return cornered(curved, paths);
   return faces(paths).map(({ polygon, sources }) => ({ path: toPath2([polygon], paths), sources }));
 }
 function pathTrim(...paths) {
+  const curved = curveTrim(paths);
+  if (curved) return cornered(curved, 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: toPath2(shown, paths), sources: [i] });
+    const shown2 = cover ? polygonClipping.difference(mps[i], cover) : mps[i];
+    if (shown2.length > 0) out.unshift({ path: toPath2(shown2, paths), sources: [i] });
     cover = cover ? polygonClipping.union(cover, mps[i]) : mps[i];
   }
   return out;
 }
 function pathMerge(paths, keyOf) {
+  const curved = curveMerge(paths, keyOf);
+  if (curved) return cornered(curved, paths);
   const groups = /* @__PURE__ */ new Map();
   for (const piece of pathTrim(...paths)) {
     const key = keyOf(piece.sources[0]);
@@ -565,12 +1076,11 @@ function pathMerge(paths, keyOf) {
 }
 function pathCropPieces(...paths) {
   if (paths.length < 2) return [];
-  const mps = paths.map((p) => pathToMultiPolygon(p));
-  const mask = mps[mps.length - 1];
+  const mask = paths[paths.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({ path: toPath2(clipped, paths), sources: [i] });
+  for (let i = 0; i < paths.length - 1; i++) {
+    const clipped = pathIntersect(paths[i], mask);
+    if (clipped.commands.length > 0) out.push({ path: clipped, sources: [i] });
   }
   return out;
 }
@@ -658,8 +1168,8 @@ function meshOutline(rings) {
       }
     }
   }
-  const loops = walkLoops(edges).map((loop) => loop.map((k) => points.get(k)));
-  return loops.length === 0 ? null : bridge(loops);
+  const loops2 = walkLoops(edges).map((loop) => loop.map((k) => points.get(k)));
+  return loops2.length === 0 ? null : bridge(loops2);
 }
 function walkLoops(edges) {
   const out = /* @__PURE__ */ new Map();
@@ -669,7 +1179,7 @@ function walkLoops(edges) {
     if (!list) out.set(a, list = []);
     for (let i = 0; i < n; i++) list.push(b);
   }
-  const loops = [];
+  const loops2 = [];
   for (const start of out.keys()) {
     while ((out.get(start)?.length ?? 0) > 0) {
       const loop = [start];
@@ -679,13 +1189,13 @@ function walkLoops(edges) {
         const next = out.get(at);
         at = next.pop();
       }
-      loops.push(loop);
+      loops2.push(loop);
     }
   }
-  return loops;
+  return loops2;
 }
-function bridge(loops) {
-  const entered = loops.map((loop) => {
+function bridge(loops2) {
+  const entered = loops2.map((loop) => {
     let k = 0;
     for (let i = 1; i < loop.length; i++) if (loop[i][0] < loop[k][0] || loop[i][0] === loop[k][0] && loop[i][1] < loop[k][1]) k = i;
     return [...loop.slice(k), ...loop.slice(0, k)];
@@ -785,7 +1295,7 @@ function properCrossing(p0, p1, q0, q1) {
 }
 function splitLoops(run) {
   const spine = [run[0]];
-  const loops = [];
+  const loops2 = [];
   for (let i = 1; i < run.length; i++) {
     const to = run[i];
     for (; ; ) {
@@ -801,17 +1311,17 @@ function splitLoops(run) {
         spine.push(to);
         break;
       }
-      loops.push([hit.x, ...spine.slice(hit.j + 1)]);
+      loops2.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 };
+    loops2.push(spine.slice(0, -1));
+    return { spine: [], loops: loops2 };
   }
-  return { spine, loops };
+  return { spine, loops: loops2 };
 }
 function pointAt(cut, s) {
   const k = Math.min(Math.floor(s), cut.length - 2);
@@ -842,7 +1352,7 @@ function interiorLoops(cut, boundaries) {
   const last = cut.length - 1;
   const stops = [{ s: 0, pt: cut[0] }, ...crossings, { s: last, pt: cut[last] }];
   const rings = [];
-  const loops = [];
+  const loops2 = [];
   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;
@@ -854,15 +1364,15 @@ function interiorLoops(cut, boundaries) {
       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);
+      loops2.push(loop);
     }
   }
-  return loops;
+  return loops2;
 }
-function cutOutLoops(regions, loops) {
+function cutOutLoops(regions, loops2) {
   let cut = false;
   const minArea = negligibleArea(regions.flat());
-  for (const loop of loops) {
+  for (const loop of loops2) {
     let ring = loop.map((p, i) => [p, loop[(i + 1) % loop.length]]);
     const a = signedArea(ring);
     if (Math.abs(a) <= minArea) continue;
@@ -892,7 +1402,7 @@ function polylinesCross(a, b) {
 }
 
 // src/booleans/cutLoops.ts
-function traceLoops(boundaries, partner, chord) {
+function traceLoops2(boundaries, partner, chord) {
   const byContour = /* @__PURE__ */ new Map();
   for (const c of partner.keys()) {
     const list = byContour.get(c.contour) ?? [];
@@ -913,7 +1423,7 @@ function traceLoops(boundaries, partner, chord) {
       arcFrom.set(from, { segs: arcBetween(contour, from, to, cuts.length === 1), end: to });
     }
   });
-  const loops = [];
+  const loops2 = [];
   const seen = /* @__PURE__ */ new Set();
   for (const start of arcFrom.keys()) {
     if (seen.has(start)) continue;
@@ -927,9 +1437,9 @@ function traceLoops(boundaries, partner, chord) {
       for (let i = 0; i + 1 < run.length; i++) loop.push([run[i], run[i + 1]]);
       at = partner.get(arc.end);
     }
-    loops.push(loop);
+    loops2.push(loop);
   }
-  return { loops, untouched };
+  return { loops: loops2, untouched };
 }
 function arcBetween(contour, from, to, whole) {
   const out = [];
@@ -960,11 +1470,11 @@ function splitPathByPolyline(path, cut, opts = {}) {
   const boundaries = resolveBoundaries(path, opts);
   if (boundaries.length === 0) return null;
   pts = openClosedCut(pts, boundaries);
-  const loops = interiorLoops(pts, boundaries);
+  const loops2 = interiorLoops(pts, boundaries);
   const pieces = knife(path, pts, opts, pts.length);
-  if (loops.length === 0) return pieces;
+  if (loops2.length === 0) return pieces;
   const regions = pieces ? pieces.map((p) => orientBoundaries(parseContours(p), outRule)) : [boundaries];
-  if (!cutOutLoops(regions, loops)) return pieces;
+  if (!cutOutLoops(regions, loops2)) return pieces;
   return regions.map((r) => toPath(r, outRule));
 }
 var fillRuleOf = (path) => path.kind === "polygon" ? path.fillRule : "nonzero";
@@ -999,8 +1509,8 @@ function knife(path, cut, opts, budget) {
     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 { loops: loops2, untouched } = traceLoops2(boundaries, partner, chord);
+  const traced = assembleRegions(loops2, 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);
@@ -1016,7 +1526,7 @@ 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 runs2 = [];
   const missed = [];
   for (const sub of parseSubpaths(path, false)) {
     const stops = snipStations(sub, pts);
@@ -1027,20 +1537,20 @@ function snipPathByPolyline(path, cut) {
     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));
+        runs2.push(arcBetween(segs, stops[i], stops[(i + 1) % stops.length], stops.length === 1));
       }
     } else {
       const last = segs[segs.length - 1];
-      const all = [
+      const all2 = [
         { 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));
+      for (let i = 0; i + 1 < all2.length; i++) runs2.push(arcBetween(segs, all2[i], all2[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 (runs2.length === 0) return null;
+  const pieces = runs2.filter((r) => r.length > 0).map((r) => writePath([{ segs: r, closed: false }], rule));
   if (missed.length > 0) pieces.push(writePath(missed, rule));
   return pieces;
 }