@weasel-js/geom 1.10.1 → 1.11.1

package/dist/booleans/index.js

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