pattapatta 0.2.1 → 0.4.0

package/dist/index.js

@@ -765,6 +765,193 @@ function parallelSegments(centerX, centerY, length, spacing, angle, n) {
   }
   return edges;
 }
+function stochasticSegments(width2, height2, n, minLength, maxLength, seed = 1, originX = 0, originY = 0) {
+  const minL = minLength ?? 1;
+  const maxL = maxLength ?? Math.min(width2, height2);
+  if (n < 1 || width2 <= 0 || height2 <= 0) return [];
+  const monoLength = minL === maxL;
+  const rng = mulberry32(seed >>> 0);
+  const edges = [];
+  const maxAttempts = Math.max(1e4, n * 500);
+  let attempts = 0;
+  while (edges.length < n && attempts < maxAttempts) {
+    attempts++;
+    const length = monoLength ? minL : minL + rng() * (maxL - minL);
+    if (!(length > 0) || length * 2 >= width2 || length * 2 >= height2) {
+      continue;
+    }
+    const ax = originX + rng() * (width2 - length * 2) + length;
+    const ay = originY + rng() * (height2 - length * 2) + length;
+    const theta = rng() * Math.PI * 2;
+    const bx = ax + Math.cos(theta) * length;
+    const by = ay + Math.sin(theta) * length;
+    const a = vec2(ax, ay);
+    const b = vec2(bx, by);
+    let hits = false;
+    for (const s of edges) {
+      if (segmentsIntersect(a, b, s.a, s.b)) {
+        hits = true;
+        break;
+      }
+    }
+    if (!hits) edges.push(segment(a, b));
+  }
+  return edges;
+}
+function weaveSegments(width2, height2, cellSize, A = 1, B = 1, C = 1, options = {}) {
+  if (!(cellSize > 0)) {
+    throw new Error("weaveSegments: cellSize must be > 0");
+  }
+  if (A <= 0 || B <= 0) {
+    throw new Error("weaveSegments: A and B must be > 0");
+  }
+  const {
+    originX = 0,
+    originY = 0,
+    swapColors = false,
+    cellFraction = 1,
+    extendSingletonsToEdge = true
+  } = options;
+  if (!(cellFraction > 0)) {
+    throw new Error("weaveSegments: cellFraction must be > 0");
+  }
+  const P = A + B;
+  const f = Math.max(0, Math.min(1, cellFraction));
+  const cols = Math.max(1, Math.floor(width2 / cellSize));
+  const rows = Math.max(1, Math.floor(height2 / cellSize));
+  const gridW = cols * cellSize;
+  const gridH = rows * cellSize;
+  const dx = originX + (width2 - gridW) * 0.5;
+  const dy = originY + (height2 - gridH) * 0.5;
+  const gridLeft = dx;
+  const gridRight = dx + gridW;
+  const gridBottom = dy;
+  const gridTop = dy + gridH;
+  const weft = Array.from(
+    { length: rows },
+    () => Array.from({ length: cols }, () => false)
+  );
+  for (let r = 0; r < rows; r++) {
+    const shift = floorMod(r * C, P);
+    for (let c = 0; c < cols; c++) {
+      const idx = floorMod(c + shift, P);
+      let isWeft = idx < A;
+      if (swapColors) isWeft = !isWeft;
+      weft[r][c] = isWeft;
+    }
+  }
+  const segs = [];
+  for (let r = 0; r < rows; r++) {
+    let c = 0;
+    while (c < cols) {
+      if (!weft[r][c]) {
+        c++;
+        continue;
+      }
+      const start = c;
+      while (c + 1 < cols && weft[r][c + 1]) c++;
+      const end = c;
+      const runLen = end - start + 1;
+      const y = dy + (r + 0.5) * cellSize;
+      let x0 = dx + (start + (1 - f)) * cellSize;
+      let x1 = dx + (end + f) * cellSize;
+      if (extendSingletonsToEdge && runLen === 1) {
+        const cx = dx + (start + 0.5) * cellSize;
+        if (start === 0) {
+          x0 = gridLeft;
+          x1 = cx;
+        } else if (end === cols - 1) {
+          x0 = cx;
+          x1 = gridRight;
+        }
+      }
+      x0 = clamp(x0, gridLeft, gridRight);
+      x1 = clamp(x1, gridLeft, gridRight);
+      segs.push(segment(vec2(x0, y), vec2(x1, y)));
+      c++;
+    }
+  }
+  for (let c = 0; c < cols; c++) {
+    let r = 0;
+    while (r < rows) {
+      if (weft[r][c]) {
+        r++;
+        continue;
+      }
+      const start = r;
+      while (r + 1 < rows && !weft[r + 1][c]) r++;
+      const end = r;
+      const runLen = end - start + 1;
+      const x = dx + (c + 0.5) * cellSize;
+      let y0 = dy + (start + (1 - f)) * cellSize;
+      let y1 = dy + (end + f) * cellSize;
+      if (extendSingletonsToEdge && runLen === 1) {
+        const cy = dy + (start + 0.5) * cellSize;
+        if (start === 0) {
+          y0 = gridBottom;
+          y1 = cy;
+        } else if (end === rows - 1) {
+          y0 = cy;
+          y1 = gridTop;
+        }
+      }
+      y0 = clamp(y0, gridBottom, gridTop);
+      y1 = clamp(y1, gridBottom, gridTop);
+      segs.push(segment(vec2(x, y0), vec2(x, y1)));
+      r++;
+    }
+  }
+  return segs;
+}
+function perpendicularPathSegments(path3, interSegmentDistance, length, startOffset = 0) {
+  if (!(interSegmentDistance > 0)) return [];
+  const lengthFn = typeof length === "function" ? length : () => length;
+  const startNorm = (startOffset % 1 + 1) % 1;
+  const edges = [];
+  for (const ring2 of path3.rings) {
+    if (ring2.length < 2) continue;
+    const closed = path3.closed;
+    let pts = ring2.map((v) => vec2(v.x, v.y));
+    if (closed && shoelace(pts) > 0) {
+      pts = pts.slice().reverse();
+    }
+    const indexed = lengthIndex(pts, closed);
+    const end = indexed.total;
+    if (!(end > 0)) continue;
+    const count = Math.max(1, Math.round(end / interSegmentDistance));
+    const increment = 1 / count;
+    const eps = Math.max(
+      end * 1e-4,
+      Math.min(interSegmentDistance * 0.35, end * 0.01)
+    );
+    for (let i = 0; i < count; i++) {
+      const posFrac = (startNorm + i * increment) % 1;
+      const idx = posFrac * end;
+      const idxM = closed ? wrapIndex(idx - eps, end) : clamp(idx - eps, 0, end);
+      const idxP = closed ? wrapIndex(idx + eps, end) : clamp(idx + eps, 0, end);
+      const pm = indexed.pointAt(idxM);
+      const pp = indexed.pointAt(idxP);
+      const pc = indexed.pointAt(idx);
+      const tx = pp.x - pm.x;
+      const ty = pp.y - pm.y;
+      const tlen = Math.hypot(tx, ty);
+      if (tlen === 0) continue;
+      const nx = -ty / tlen;
+      const ny = tx / tlen;
+      const normalAngle = Math.atan2(ny, nx);
+      const L = lengthFn(pc.x, pc.y, posFrac, normalAngle);
+      if (!(L > 0)) continue;
+      const half = L * 0.5;
+      edges.push(
+        segment(
+          vec2(pc.x - nx * half, pc.y - ny * half),
+          vec2(pc.x + nx * half, pc.y + ny * half)
+        )
+      );
+    }
+  }
+  return edges;
+}
 function filterByMinLength(segments, minLength) {
   return segments.filter((s) => segmentLength(s) >= minLength);
 }
@@ -790,11 +977,84 @@ function segmentsToOpenPaths(segments) {
 }
 var segmentSet = {
   parallelSegments,
+  stochasticSegments,
+  weaveSegments,
+  perpendicularPathSegments,
   filterByMinLength,
   filterAxisAligned,
   segmentLength,
   segmentsToOpenPaths
 };
+function floorMod(n, m) {
+  return (n % m + m) % m;
+}
+function clamp(v, lo, hi) {
+  return Math.max(lo, Math.min(hi, v));
+}
+function wrapIndex(idx, end) {
+  if (end <= 0) return 0;
+  let x = idx % end;
+  if (x < 0) x += end;
+  return x;
+}
+function shoelace(ring2) {
+  let sum = 0;
+  for (let i = 0; i < ring2.length; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % ring2.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function segmentsIntersect(a, b, c, d) {
+  return ccw(a, c, d) !== ccw(b, c, d) && ccw(a, b, c) !== ccw(a, b, d);
+}
+function ccw(a, b, c) {
+  return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
+}
+function mulberry32(seed) {
+  return function() {
+    let t = seed += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function lengthIndex(ring2, closed) {
+  const n = ring2.length;
+  const edgeCount = closed ? n : n - 1;
+  const lengths = [];
+  let total = 0;
+  for (let i = 0; i < edgeCount; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % n];
+    const L = Math.hypot(b.x - a.x, b.y - a.y);
+    lengths.push(L);
+    total += L;
+  }
+  return {
+    total,
+    pointAt(dist2) {
+      let remain = dist2;
+      if (remain <= 0) return { ...ring2[0] };
+      if (remain >= total) return { ...ring2[closed ? 0 : n - 1] };
+      for (let i = 0; i < lengths.length; i++) {
+        const L = lengths[i];
+        if (remain <= L || i === lengths.length - 1) {
+          const t = L < 1e-12 ? 0 : remain / L;
+          const a = ring2[i];
+          const b = ring2[(i + 1) % n];
+          return {
+            x: a.x + (b.x - a.x) * t,
+            y: a.y + (b.y - a.y) * t
+          };
+        }
+        remain -= L;
+      }
+      return { ...ring2[0] };
+    }
+  };
+}
 
 // src/segmentSet/clip.ts
 function clipSegmentToPath(seg, clip) {
@@ -825,8 +1085,8 @@ function clipSegmentToPath(seg, clip) {
     const h0 = hits[i];
     const h1 = hits[i + 1];
     if (h1.t - h0.t < 1e-9) continue;
-    const mid3 = vec2((h0.p.x + h1.p.x) / 2, (h0.p.y + h1.p.y) / 2);
-    if (containsPoint(clip, mid3)) {
+    const mid5 = vec2((h0.p.x + h1.p.x) / 2, (h0.p.y + h1.p.y) / 2);
+    if (containsPoint(clip, mid5)) {
       out.push(segment(h0.p, h1.p));
     }
   }
@@ -854,6 +1114,34 @@ function segmentIntersection(a, b, c, d) {
     p: vec2(a.x + t * rX, a.y + t * rY)
   };
 }
+function buffer(path3, delta, options = {}) {
+  const subject = pathToPathsD(path3);
+  const join = options.join === "miter" ? JoinType.Miter : options.join === "square" ? JoinType.Square : JoinType.Round;
+  const inflated = inflatePathsD(subject, delta, join, EndType.Polygon);
+  return pathsDToGroup(inflated);
+}
+function erosionDilation(p, amount) {
+  const a = Math.abs(amount);
+  if (a < 1e-12) return group([p]);
+  const eroded = buffer(p, -a);
+  if (eroded.paths.length === 0) return eroded;
+  const dilated = [];
+  for (const q of eroded.paths) {
+    dilated.push(...buffer(q, a).paths);
+  }
+  return group(dilated);
+}
+function dilationErosion(p, amount) {
+  const a = Math.abs(amount);
+  if (a < 1e-12) return group([p]);
+  const dilated = buffer(p, a);
+  if (dilated.paths.length === 0) return dilated;
+  const eroded = [];
+  for (const q of dilated.paths) {
+    eroded.push(...buffer(q, -a).paths);
+  }
+  return group(eroded);
+}
 
 // src/hatch/index.ts
 function parallel(path3, options = {}) {
@@ -886,6 +1174,94 @@ function cross(path3, options = {}) {
   const b = parallel(path3, { ...options, angle: angle + Math.PI / 2 });
   return [...a, ...b];
 }
+function weave(path3, options = {}) {
+  if (!path3.closed || !path3.rings[0]) {
+    throw new Error("hatch.weave requires a closed path");
+  }
+  const bounds2 = pathBounds(path3);
+  const width2 = Math.max(bounds2.maxX - bounds2.minX, 1e-9);
+  const height2 = Math.max(bounds2.maxY - bounds2.minY, 1e-9);
+  const cellSize = options.cellSize ?? Math.max(Math.min(width2, height2) / 12, 1e-6);
+  const weaveOpts = {
+    originX: bounds2.minX,
+    originY: bounds2.minY
+  };
+  if (options.swapColors !== void 0) weaveOpts.swapColors = options.swapColors;
+  if (options.cellFraction !== void 0) {
+    weaveOpts.cellFraction = options.cellFraction;
+  }
+  if (options.extendSingletonsToEdge !== void 0) {
+    weaveOpts.extendSingletonsToEdge = options.extendSingletonsToEdge;
+  }
+  const raw = weaveSegments(
+    width2,
+    height2,
+    cellSize,
+    options.A ?? 1,
+    options.B ?? 1,
+    options.C ?? 1,
+    weaveOpts
+  );
+  return clipSegmentsToPath(raw, path3);
+}
+function stochastic(path3, options = {}) {
+  if (!path3.closed || !path3.rings[0]) {
+    throw new Error("hatch.stochastic requires a closed path");
+  }
+  const bounds2 = pathBounds(path3);
+  const width2 = Math.max(bounds2.maxX - bounds2.minX, 1e-9);
+  const height2 = Math.max(bounds2.maxY - bounds2.minY, 1e-9);
+  const count = options.count ?? 40;
+  const minLength = options.length ?? options.minLength ?? 1;
+  const maxLength = options.length ?? options.maxLength ?? Math.min(width2, height2);
+  const raw = stochasticSegments(
+    width2,
+    height2,
+    count,
+    minLength,
+    maxLength,
+    options.seed ?? 1,
+    bounds2.minX,
+    bounds2.minY
+  );
+  return clipSegmentsToPath(raw, path3);
+}
+function perpendicular(path3, options = {}) {
+  if (!path3.rings[0]) {
+    throw new Error("hatch.perpendicular requires a path with at least one ring");
+  }
+  const spacing = Math.max(options.spacing ?? 0.15, 1e-9);
+  const length = options.length ?? 0.2;
+  return perpendicularPathSegments(
+    path3,
+    spacing,
+    length,
+    options.startOffset ?? 0
+  );
+}
+function concentric(path3, options = {}) {
+  if (!path3.closed || !path3.rings[0]) {
+    throw new Error("hatch.concentric requires a closed path");
+  }
+  const spacing = Math.max(options.spacing ?? 0.15, 1e-9);
+  const bounds2 = pathBounds(path3);
+  const diag = Math.hypot(bounds2.maxX - bounds2.minX, bounds2.maxY - bounds2.minY);
+  const maxCount = options.count ?? Math.max(1, Math.floor(diag / (2 * spacing)));
+  const out = [];
+  for (let i = 1; i <= maxCount; i++) {
+    const shell = buffer(path3, -spacing * i);
+    if (shell.paths.length === 0) break;
+    for (const p of shell.paths) {
+      out.push(
+        path(
+          p.rings.map((r) => r.map((v) => ({ x: v.x, y: v.y }))),
+          true
+        )
+      );
+    }
+  }
+  return out;
+}
 function hatchLineCount(bounds2, spacing, angle) {
   const nx = Math.cos(angle + Math.PI / 2);
   const ny = Math.sin(angle + Math.PI / 2);
@@ -922,7 +1298,11 @@ function pathBounds(path3) {
 }
 var hatch = {
   parallel,
-  cross
+  cross,
+  weave,
+  stochastic,
+  perpendicular,
+  concentric
 };
 
 // src/circlePacking/index.ts
@@ -988,7 +1368,7 @@ function centeredLatticeGrid(b, stepX, stepY, inset, endPad) {
   return { ox, oy, nX, nY };
 }
 function stochasticPack(path3, points, minRadius, seed = 1) {
-  const rng = mulberry32(seed >>> 0);
+  const rng = mulberry322(seed >>> 0);
   const b = bounds(path3);
   const packing = [];
   for (let attempt = 0; attempt < points; attempt++) {
@@ -1029,7 +1409,7 @@ function obstaclePack(path3, obstacles, n, tolerance = 1) {
 function frontChainPack(path3, radiusMin, radiusMax, seed = 1) {
   let rMin = Math.max(1e-6, Math.min(radiusMin, radiusMax));
   let rMax = Math.max(rMin, Math.max(radiusMin, radiusMax));
-  const rng = mulberry32(seed >>> 0);
+  const rng = mulberry322(seed >>> 0);
   const b = bounds(path3);
   const packing = [];
   const area2 = Math.max(1e-6, (b.maxX - b.minX) * (b.maxY - b.minY));
@@ -1088,7 +1468,7 @@ function frontChainPack(path3, radiusMin, radiusMax, seed = 1) {
 function repulsionPack(path3, radiusMin, radiusMax, seed = 1, iterations = 80) {
   const rMin = Math.max(1e-6, Math.min(radiusMin, radiusMax));
   const rMax = Math.max(rMin, Math.max(radiusMin, radiusMax));
-  const rng = mulberry32(seed >>> 0);
+  const rng = mulberry322(seed >>> 0);
   const b = bounds(path3);
   const area2 = Math.max(1e-6, (b.maxX - b.minX) * (b.maxY - b.minY));
   const avgR = (rMin + rMax) / 2;
@@ -1212,7 +1592,7 @@ function vecInBounds(b, rng) {
     y: b.minY + rng() * (b.maxY - b.minY)
   };
 }
-function mulberry32(a) {
+function mulberry322(a) {
   return function() {
     let t = a += 1831565813;
     t = Math.imul(t ^ t >>> 15, t | 1);
@@ -1232,36 +1612,6 @@ var circlePacking = {
   circleOverlapsPath,
   circleContainedInPath
 };
-function buffer(path3, delta, options = {}) {
-  const subject = pathToPathsD(path3);
-  const join = options.join === "miter" ? JoinType.Miter : options.join === "square" ? JoinType.Square : JoinType.Round;
-  const inflated = inflatePathsD(subject, delta, join, EndType.Polygon);
-  return pathsDToGroup(inflated);
-}
-function erosionDilation(p, amount) {
-  const a = Math.abs(amount);
-  if (a < 1e-12) return group([p]);
-  const eroded = buffer(p, -a);
-  if (eroded.paths.length === 0) return eroded;
-  const dilated = [];
-  for (const q of eroded.paths) {
-    dilated.push(...buffer(q, a).paths);
-  }
-  return group(dilated);
-}
-function dilationErosion(p, amount) {
-  const a = Math.abs(amount);
-  if (a < 1e-12) return group([p]);
-  const dilated = buffer(p, a);
-  if (dilated.paths.length === 0) return dilated;
-  const eroded = [];
-  for (const q of dilated.paths) {
-    eroded.push(...buffer(q, -a).paths);
-  }
-  return group(eroded);
-}
-
-// src/morphology/index.ts
 function simplify(p, epsilon) {
   if (epsilon <= 0 || p.rings.length === 0) return p;
   const rings = [];
@@ -1508,13 +1858,13 @@ function removeSmallHoles(p, minArea2) {
   if (p.rings.length <= 1) return p;
   const exterior = p.rings[0];
   const kept = p.rings.slice(1).filter((hole) => {
-    const a = Math.abs(shoelace(hole));
+    const a = Math.abs(shoelace2(hole));
     return a >= minArea2;
   });
   return path([exterior, ...kept], p.closed);
 }
 function generateRandomPoints(p, count, seed = 1) {
-  const rng = mulberry322(seed >>> 0);
+  const rng = mulberry323(seed >>> 0);
   const b = bounds(p);
   const out = [];
   let attempts = 0;
@@ -1569,10 +1919,10 @@ function segmentsOnExterior(p) {
 function slice(p, a, b) {
   const dx = b.x - a.x;
   const dy = b.y - a.y;
-  const len = Math.hypot(dx, dy);
-  if (len < 1e-12) return group([p]);
-  const nx = -dy / len;
-  const ny = dx / len;
+  const len2 = Math.hypot(dx, dy);
+  if (len2 < 1e-12) return group([p]);
+  const nx = -dy / len2;
+  const ny = dx / len2;
   const bb = bounds(p);
   const span = Math.hypot(bb.maxX - bb.minX, bb.maxY - bb.minY) * 4 + 10;
   const left = halfPlanePoly(a, nx, ny, span);
@@ -1601,9 +1951,9 @@ function intersectionPoints(a, b) {
     for (const sb of segsB) {
       const hit = segmentIntersection2(sa.a, sa.b, sb.a, sb.b);
       if (!hit) continue;
-      const key = `${hit.x.toFixed(9)},${hit.y.toFixed(9)}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
+      const key4 = `${hit.x.toFixed(9)},${hit.y.toFixed(9)}`;
+      if (seen.has(key4)) continue;
+      seen.add(key4);
       out.push(hit);
     }
   }
@@ -1684,7 +2034,7 @@ function pointAtArcLength(ring2, lengths, target) {
   }
   return { ...ring2[0] };
 }
-function shoelace(ring2) {
+function shoelace2(ring2) {
   let sum = 0;
   for (let i = 0; i < ring2.length; i++) {
     const a = ring2[i];
@@ -1693,7 +2043,7 @@ function shoelace(ring2) {
   }
   return sum / 2;
 }
-function mulberry322(a) {
+function mulberry323(a) {
   return function() {
     let t = a += 1831565813;
     t = Math.imul(t ^ t >>> 15, t | 1);
@@ -1762,79 +2112,62 @@ var conversion = {
   group
 };
 
-// src/contour/index.ts
-function offsetCurvesOutward(p, distance) {
-  return buffer(p, Math.abs(distance));
-}
-function offsetCurvesInward(p, distance) {
-  return buffer(p, -Math.abs(distance));
-}
-var contour = {
-  offsetCurvesOutward,
-  offsetCurvesInward
-};
-
-// src/hull/index.ts
-function convexHull(points) {
-  const pts = uniquePoints(points);
-  if (pts.length < 3) return polygon(pts);
-  pts.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
-  const lower = [];
-  for (const p of pts) {
-    while (lower.length >= 2 && cross2(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
-      lower.pop();
-    }
-    lower.push(p);
+// src/pointSet/hilbert.ts
+function xy2d(order, x, y) {
+  let rx;
+  let ry;
+  let s;
+  let d = 0;
+  for (s = 1 << order - 1; s > 0; s >>= 1) {
+    rx = (x & s) > 0 ? 1 : 0;
+    ry = (y & s) > 0 ? 1 : 0;
+    d += s * s * (3 * rx ^ ry);
+    ({ x, y } = rot(s, x, y, rx, ry));
   }
-  const upper = [];
-  for (let i = pts.length - 1; i >= 0; i--) {
-    const p = pts[i];
-    while (upper.length >= 2 && cross2(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
-      upper.pop();
+  return d;
+}
+function rot(n, x, y, rx, ry) {
+  if (ry === 0) {
+    if (rx === 1) {
+      x = n - 1 - x;
+      y = n - 1 - y;
     }
-    upper.push(p);
+    return { x: y, y: x };
   }
-  lower.pop();
-  upper.pop();
-  return polygon([...lower, ...upper]);
-}
-function convexHullPath(p) {
-  const pts = [];
-  for (const ring2 of p.rings) pts.push(...ring2);
-  return convexHull(pts);
-}
-function boundingBox(p) {
-  const b = bounds(p);
-  return polygon([
-    { x: b.minX, y: b.minY },
-    { x: b.maxX, y: b.minY },
-    { x: b.maxX, y: b.maxY },
-    { x: b.minX, y: b.maxY }
-  ]);
-}
-function cross2(o, a, b) {
-  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+  return { x, y };
 }
-function uniquePoints(points) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
+function hilbertSort(points, order = 10) {
+  if (points.length === 0) return [];
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
   for (const p of points) {
-    const key = `${p.x},${p.y}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push({ x: p.x, y: p.y });
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x);
+    maxY = Math.max(maxY, p.y);
   }
-  return out;
-}
-var hull = {
-  convexHull,
-  convexHullPath,
-  boundingBox
-};
-
+  const span = Math.max(maxX - minX, maxY - minY, 1e-9);
+  const n = 1 << order;
+  const scored = points.map((p) => {
+    const x = Math.min(
+      n - 1,
+      Math.max(0, Math.floor((p.x - minX) / span * (n - 1)))
+    );
+    const y = Math.min(
+      n - 1,
+      Math.max(0, Math.floor((p.y - minY) / span * (n - 1)))
+    );
+    return { p, h: xy2d(order, x, y) };
+  });
+  scored.sort((a, b) => a.h - b.h);
+  return scored.map((s) => s.p);
+}
+
 // src/pointSet/index.ts
 function random(count, minX, minY, maxX, maxY, seed = 1) {
-  const rng = mulberry323(seed >>> 0);
+  const rng = mulberry324(seed >>> 0);
   const out = [];
   for (let i = 0; i < count; i++) {
     out.push({
@@ -1879,7 +2212,7 @@ function ring(count, center, radius) {
   }
   return out;
 }
-function mulberry323(a) {
+function mulberry324(a) {
   return function() {
     let t = a += 1831565813;
     t = Math.imul(t ^ t >>> 15, t | 1);
@@ -1888,7 +2221,7 @@ function mulberry323(a) {
   };
 }
 function poisson(minDistance, minX, minY, maxX, maxY, seed = 1, maxAttempts = 30) {
-  const rng = mulberry323(seed >>> 0);
+  const rng = mulberry324(seed >>> 0);
   const r = Math.max(minDistance, 1e-9);
   const cell = r / Math.SQRT2;
   const w = maxX - minX;
@@ -1959,13 +2292,87 @@ function prunePointsWithinDistance(points, minDistance) {
   }
   return out;
 }
+function findShortestTour(points) {
+  if (points.length === 0) return polygon([]);
+  if (points.length === 1) return polygon([{ ...points[0] }]);
+  if (points.length === 2) {
+    return polyline([
+      { ...points[0] },
+      { ...points[1] },
+      { ...points[0] }
+    ]);
+  }
+  const tour = nearestNeighborTour(points);
+  twoOpt(tour);
+  return polygon(tour);
+}
+function nearestNeighborTour(points) {
+  const remaining = points.map((p) => ({ ...p }));
+  let startI = 0;
+  for (let i = 1; i < remaining.length; i++) {
+    const a = remaining[i];
+    const b = remaining[startI];
+    if (a.x < b.x || a.x === b.x && a.y < b.y) startI = i;
+  }
+  const ordered = [remaining.splice(startI, 1)[0]];
+  while (remaining.length) {
+    const last = ordered[ordered.length - 1];
+    let bestI = 0;
+    let bestD = Infinity;
+    for (let i = 0; i < remaining.length; i++) {
+      const d = Math.hypot(
+        remaining[i].x - last.x,
+        remaining[i].y - last.y
+      );
+      if (d < bestD) {
+        bestD = d;
+        bestI = i;
+      }
+    }
+    ordered.push(remaining.splice(bestI, 1)[0]);
+  }
+  return ordered;
+}
+function twoOpt(tour) {
+  const n = tour.length;
+  if (n < 4) return;
+  let improved = true;
+  while (improved) {
+    improved = false;
+    for (let i = 0; i < n - 1; i++) {
+      for (let j = i + 2; j < n; j++) {
+        if (i === 0 && j === n - 1) continue;
+        const a = tour[i];
+        const b = tour[(i + 1) % n];
+        const c = tour[j];
+        const d = tour[(j + 1) % n];
+        const before = Math.hypot(a.x - b.x, a.y - b.y) + Math.hypot(c.x - d.x, c.y - d.y);
+        const after = Math.hypot(a.x - c.x, a.y - c.y) + Math.hypot(b.x - d.x, b.y - d.y);
+        if (after + 1e-12 < before) {
+          let lo = i + 1;
+          let hi = j;
+          while (lo < hi) {
+            const tmp = tour[lo];
+            tour[lo] = tour[hi];
+            tour[hi] = tmp;
+            lo++;
+            hi--;
+          }
+          improved = true;
+        }
+      }
+    }
+  }
+}
 var pointSet = {
   random,
   squareGrid,
   hexGrid,
   ring,
   poisson,
-  prunePointsWithinDistance
+  prunePointsWithinDistance,
+  hilbertSort,
+  findShortestTour
 };
 
 // src/triangulation/index.ts
@@ -2121,9 +2528,9 @@ function longestEdgeMidpoint(a, b, c) {
   let best = edges[0];
   let bestLen = -1;
   for (const e of edges) {
-    const len = Math.hypot(e[0].x - e[1].x, e[0].y - e[1].y);
-    if (len > bestLen) {
-      bestLen = len;
+    const len2 = Math.hypot(e[0].x - e[1].x, e[0].y - e[1].y);
+    if (len2 > bestLen) {
+      bestLen = len2;
       best = e;
     }
   }
@@ -2138,6 +2545,205 @@ var triangulation = {
   refine
 };
 
+// src/contour/dissolve.ts
+function key(v, digits = 9) {
+  return `${v.x.toFixed(digits)},${v.y.toFixed(digits)}`;
+}
+function same(a, b, eps = 1e-9) {
+  return Math.abs(a.x - b.x) <= eps && Math.abs(a.y - b.y) <= eps;
+}
+function dissolveSegments(segments) {
+  const segs = segments.filter((s) => !same(s.a, s.b));
+  if (segs.length === 0) return group([]);
+  const adj = /* @__PURE__ */ new Map();
+  const pts = /* @__PURE__ */ new Map();
+  const add = (a, b, segIdx) => {
+    const ka = key(a);
+    const kb = key(b);
+    pts.set(ka, a);
+    pts.set(kb, b);
+    if (!adj.has(ka)) adj.set(ka, []);
+    if (!adj.has(kb)) adj.set(kb, []);
+    adj.get(ka).push({ segIdx, other: kb });
+    adj.get(kb).push({ segIdx, other: ka });
+  };
+  for (let i = 0; i < segs.length; i++) {
+    add(segs[i].a, segs[i].b, i);
+  }
+  const used = /* @__PURE__ */ new Set();
+  const paths = [];
+  const unusedDegree = (k) => (adj.get(k) ?? []).filter((e) => !used.has(e.segIdx)).length;
+  const nextUnused = (k) => (adj.get(k) ?? []).find((e) => !used.has(e.segIdx));
+  const starts = [...adj.keys()].sort(
+    (a, b) => unusedDegree(a) - unusedDegree(b)
+  );
+  for (const start of starts) {
+    let link = nextUnused(start);
+    while (link) {
+      const chain = [pts.get(start)];
+      used.add(link.segIdx);
+      let next = link.other;
+      chain.push(pts.get(next));
+      while (unusedDegree(next) === 1) {
+        const e = nextUnused(next);
+        if (!e) break;
+        used.add(e.segIdx);
+        next = e.other;
+        chain.push(pts.get(next));
+        if (next === start) break;
+      }
+      if (chain.length >= 2) paths.push(polyline(chain));
+      link = nextUnused(start);
+    }
+  }
+  for (let i = 0; i < segs.length; i++) {
+    if (used.has(i)) continue;
+    const s = segs[i];
+    paths.push(polyline([s.a, s.b]));
+  }
+  return group(paths);
+}
+
+// src/contour/chordalAxis.ts
+function mid(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+function len(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function edgeKey(a, b) {
+  const ka = `${a.x.toFixed(8)},${a.y.toFixed(8)}`;
+  const kb = `${b.x.toFixed(8)},${b.y.toFixed(8)}`;
+  return ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+}
+function chordalAxis(shape) {
+  if (!shape.closed || shape.rings.length === 0) return dissolveSegments([]);
+  const b = boundsSpan(shape);
+  const densified = densify(shape, Math.max(b / 40, 1e-3));
+  const tris = delaunayTriangulation(densified);
+  if (tris.length === 0) return dissolveSegments([]);
+  const edgeCount = /* @__PURE__ */ new Map();
+  const triEdges = [];
+  for (const t of tris) {
+    const r = t.rings[0];
+    if (!r || r.length < 3) continue;
+    const a = r[0];
+    const b0 = r[1];
+    const c = r[2];
+    triEdges.push([a, b0, c]);
+    for (const [u, v] of [
+      [a, b0],
+      [b0, c],
+      [c, a]
+    ]) {
+      const k = edgeKey(u, v);
+      edgeCount.set(k, (edgeCount.get(k) ?? 0) + 1);
+    }
+  }
+  const isBoundary = (u, v) => (edgeCount.get(edgeKey(u, v)) ?? 0) <= 1;
+  const segs = [];
+  for (const [a, b0, c] of triEdges) {
+    const edges = [
+      [a, b0],
+      [b0, c],
+      [c, a]
+    ];
+    const interior = edges.filter(([u, v]) => !isBoundary(u, v));
+    const degree = interior.length;
+    if (degree === 1) {
+      const [u, v] = interior[0];
+      const cen = centroid({ rings: [[a, b0, c]]});
+      segs.push(segment(cen, mid(u, v)));
+    } else if (degree === 2) {
+      const m0 = mid(interior[0][0], interior[0][1]);
+      const m1 = mid(interior[1][0], interior[1][1]);
+      segs.push(segment(m0, m1));
+    } else if (degree === 3) {
+      const ranked = edges.map(([u, v]) => ({ u, v, l: len(u, v) })).sort((x, y) => y.l - x.l);
+      const longest = ranked[0];
+      const shortA = ranked[1];
+      const shortB = ranked[2];
+      const mL = mid(longest.u, longest.v);
+      segs.push(segment(mid(shortA.u, shortA.v), mL));
+      segs.push(segment(mid(shortB.u, shortB.v), mL));
+    }
+  }
+  return dissolveSegments(segs);
+}
+function boundsSpan(p) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const ring2 of p.rings) {
+    for (const v of ring2) {
+      minX = Math.min(minX, v.x);
+      minY = Math.min(minY, v.y);
+      maxX = Math.max(maxX, v.x);
+      maxY = Math.max(maxY, v.y);
+    }
+  }
+  return Math.max(maxX - minX, maxY - minY, 1);
+}
+
+// src/hull/index.ts
+function convexHull(points) {
+  const pts = uniquePoints(points);
+  if (pts.length < 3) return polygon(pts);
+  pts.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+  const lower = [];
+  for (const p of pts) {
+    while (lower.length >= 2 && cross2(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+      lower.pop();
+    }
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = pts.length - 1; i >= 0; i--) {
+    const p = pts[i];
+    while (upper.length >= 2 && cross2(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+      upper.pop();
+    }
+    upper.push(p);
+  }
+  lower.pop();
+  upper.pop();
+  return polygon([...lower, ...upper]);
+}
+function convexHullPath(p) {
+  const pts = [];
+  for (const ring2 of p.rings) pts.push(...ring2);
+  return convexHull(pts);
+}
+function boundingBox(p) {
+  const b = bounds(p);
+  return polygon([
+    { x: b.minX, y: b.minY },
+    { x: b.maxX, y: b.minY },
+    { x: b.maxX, y: b.maxY },
+    { x: b.minX, y: b.maxY }
+  ]);
+}
+function cross2(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+function uniquePoints(points) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of points) {
+    const key4 = `${p.x},${p.y}`;
+    if (seen.has(key4)) continue;
+    seen.add(key4);
+    out.push({ x: p.x, y: p.y });
+  }
+  return out;
+}
+var hull = {
+  convexHull,
+  convexHullPath,
+  boundingBox
+};
+
 // src/optimisation/index.ts
 function envelope(p) {
   return boundingBox(p);
@@ -2170,12 +2776,12 @@ function maximumInscribedAARectangle(p) {
   let hi = Math.min(w, h) / 2;
   let best = hi;
   for (let i = 0; i < 40; i++) {
-    const mid3 = (lo + hi) / 2;
-    if (fits(mid3)) {
-      best = mid3;
-      hi = mid3;
+    const mid5 = (lo + hi) / 2;
+    if (fits(mid5)) {
+      best = mid5;
+      hi = mid5;
     } else {
-      lo = mid3;
+      lo = mid5;
     }
   }
   const m = best;
@@ -2320,399 +2926,649 @@ var optimisation = {
   farthestPointPair,
   minimumBoundingCircle
 };
-function compoundVoronoi(sites, options = {}) {
-  if (sites.length === 0) return group([]);
-  if (sites.length === 1) {
-    const b2 = options.bounds ?? padBounds(sites, 1);
-    return group([
-      polygon([
-        { x: b2.minX, y: b2.minY },
-        { x: b2.maxX, y: b2.minY },
-        { x: b2.maxX, y: b2.maxY },
-        { x: b2.minX, y: b2.maxY }
-      ])
-    ]);
+
+// src/contour/boundaryDistance.ts
+function distanceToBoundary2(path3, p) {
+  let best = Infinity;
+  for (const ring2 of path3.rings) {
+    if (ring2.length < 2) continue;
+    const n = ring2.length;
+    const closed = path3.closed;
+    const limit = closed ? n : n - 1;
+    for (let i = 0; i < limit; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      best = Math.min(best, distPointSeg(p, a, b));
+    }
   }
-  const b = options.bounds ?? padBounds(sites, 0.1);
+  return best;
+}
+function sampleBoundary(path3, maxSegLen) {
+  const pts = [];
+  const lim = Math.max(maxSegLen, 1e-9);
+  for (const ring2 of path3.rings) {
+    if (ring2.length < 2) continue;
+    const n = ring2.length;
+    const limit = path3.closed ? n : n - 1;
+    for (let i = 0; i < limit; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      const len2 = Math.hypot(b.x - a.x, b.y - a.y);
+      const steps = Math.max(1, Math.ceil(len2 / lim));
+      for (let s = 0; s < steps; s++) {
+        const t = s / steps;
+        pts.push({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+      }
+    }
+  }
+  return pts;
+}
+function distPointSeg(p, a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 1e-18) return Math.hypot(p.x - a.x, p.y - a.y);
+  let t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+
+// src/contour/medialAxis.ts
+function medialAxis(shape, axialThreshold = 0, distanceThreshold = 0, areaThreshold = 0) {
+  const g = buildMedialAxisGraph(shape);
+  if (!g) return dissolveSegments([]);
+  const kept = pruneEdges(g, axialThreshold, distanceThreshold, areaThreshold);
+  const segs = kept.map((e) => {
+    const a = g.nodes[e.head].position;
+    const b = g.nodes[e.tail].position;
+    return segment(a, b);
+  });
+  return dissolveSegments(segs);
+}
+function buildMedialAxisGraph(shape) {
+  if (!shape.closed || shape.rings.length === 0) return null;
+  const b = bounds(shape);
+  const span = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1);
+  const densified = densify(shape, Math.max(span / 60, 1e-3));
+  const samples = sampleBoundary(densified, Math.max(span / 80, 1e-3));
+  if (samples.length < 3) return null;
+  const uniq = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of samples) {
+    const k = `${p.x.toFixed(6)},${p.y.toFixed(6)}`;
+    if (seen.has(k)) continue;
+    seen.add(k);
+    uniq.push(p);
+  }
+  if (uniq.length < 3) return null;
   const delaunay = Delaunay.from(
-    sites,
+    uniq,
     (d) => d.x,
     (d) => d.y
   );
-  const voronoi2 = delaunay.voronoi([b.minX, b.minY, b.maxX, b.maxY]);
-  const paths = [];
-  for (let i = 0; i < sites.length; i++) {
+  const pad = span * 0.5;
+  const voronoi2 = delaunay.voronoi([
+    b.minX - pad,
+    b.minY - pad,
+    b.maxX + pad,
+    b.maxY + pad
+  ]);
+  const raw = [];
+  const edgeSeen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < uniq.length; i++) {
     const poly = voronoi2.cellPolygon(i);
-    if (!poly || poly.length < 3) continue;
-    const ring2 = poly.slice(0, -1).map(([x, y]) => ({ x, y }));
-    if (ring2.length >= 3) paths.push(polygon(ring2));
+    if (!poly || poly.length < 2) continue;
+    for (let j = 0; j < poly.length - 1; j++) {
+      const p0 = poly[j];
+      const p1 = poly[j + 1];
+      const a = { x: p0[0], y: p0[1] };
+      const bb = { x: p1[0], y: p1[1] };
+      if (!containsPoint(shape, a) || !containsPoint(shape, bb)) continue;
+      const ek = edgeKey2(a, bb);
+      if (edgeSeen.has(ek)) continue;
+      edgeSeen.add(ek);
+      const mid5 = { x: (a.x + bb.x) / 2, y: (a.y + bb.y) / 2 };
+      const site = uniq[i];
+      const radius = Math.hypot(mid5.x - site.x, mid5.y - site.y);
+      raw.push({ a, b: bb, radius });
+    }
   }
-  return group(paths);
-}
-function innerVoronoi(sites, container, options = {}) {
-  const b = options.bounds ?? {
-    ...bounds(container)
+  if (raw.length === 0) return null;
+  const nodeIndex = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const ensure = (p, radius) => {
+    const k = key2(p);
+    let id = nodeIndex.get(k);
+    if (id !== void 0) {
+      nodes[id].radius = Math.max(nodes[id].radius, radius);
+      return id;
+    }
+    id = nodes.length;
+    nodeIndex.set(k, id);
+    nodes.push({
+      id,
+      position: p,
+      radius,
+      parent: null,
+      children: [],
+      rootDist: 0,
+      featureArea: Math.PI * radius * radius
+    });
+    return id;
   };
-  const cells = compoundVoronoi(sites, { bounds: b });
-  const clipped = [];
-  for (const cell of cells.paths) {
-    clipped.push(...intersect(cell, container).paths);
+  const undirected = [];
+  for (const e of raw) {
+    const midR = e.radius;
+    const u = ensure(e.a, midR);
+    const v = ensure(e.b, midR);
+    if (u === v) continue;
+    const length = Math.hypot(
+      nodes[u].position.x - nodes[v].position.x,
+      nodes[u].position.y - nodes[v].position.y
+    );
+    const axial = length > 1e-12 ? Math.abs(nodes[u].radius - nodes[v].radius) / length : 0;
+    undirected.push({ u, v, axial, length });
   }
-  return group(clipped);
-}
-function innerVoronoiRaw(sites, options = {}) {
-  return compoundVoronoi(sites, options);
+  const mic = maximumInscribedCircle(shape, Math.max(span * 0.01, 0.1));
+  const rootPos = mic ? { x: mic.x, y: mic.y } : {
+    x: (b.minX + b.maxX) / 2,
+    y: (b.minY + b.maxY) / 2
+  };
+  let root = 0;
+  let bestD = Infinity;
+  for (const n of nodes) {
+    const d = Math.hypot(n.position.x - rootPos.x, n.position.y - rootPos.y);
+    if (d < bestD) {
+      bestD = d;
+      root = n.id;
+    }
+  }
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of undirected) {
+    if (!adj.has(e.u)) adj.set(e.u, []);
+    if (!adj.has(e.v)) adj.set(e.v, []);
+    adj.get(e.u).push({ to: e.v, axial: e.axial, length: e.length });
+    adj.get(e.v).push({ to: e.u, axial: e.axial, length: e.length });
+  }
+  const edges = [];
+  const visited = /* @__PURE__ */ new Set([root]);
+  const queue = [root];
+  nodes[root].rootDist = 0;
+  while (queue.length) {
+    const u = queue.shift();
+    for (const link of adj.get(u) ?? []) {
+      if (visited.has(link.to)) continue;
+      visited.add(link.to);
+      nodes[link.to].parent = u;
+      nodes[u].children.push(link.to);
+      nodes[link.to].rootDist = nodes[u].rootDist + link.length;
+      edges.push({
+        head: u,
+        tail: link.to,
+        axial: link.axial,
+        length: link.length
+      });
+      queue.push(link.to);
+    }
+  }
+  const post = [];
+  const stack = [root];
+  const seenN = /* @__PURE__ */ new Set();
+  while (stack.length) {
+    const u = stack.pop();
+    if (seenN.has(u)) {
+      post.push(u);
+      continue;
+    }
+    seenN.add(u);
+    stack.push(u);
+    for (const c of nodes[u].children) stack.push(c);
+  }
+  for (const u of post) {
+    let area2 = nodes[u].featureArea;
+    for (const c of nodes[u].children) area2 += nodes[c].featureArea;
+    nodes[u].featureArea = area2;
+  }
+  return { nodes, edges, root };
+}
+function pruneEdges(g, axialT, distT, areaT) {
+  const maxDist = Math.max(...g.nodes.map((n) => n.rootDist), 1e-9);
+  const maxArea2 = Math.max(...g.nodes.map((n) => n.featureArea), 1e-9);
+  const maxAxial = Math.max(...g.edges.map((e) => e.axial), 1e-9);
+  const aT = clamp01(axialT);
+  const dT = clamp01(distT);
+  const arT = clamp01(areaT);
+  return g.edges.filter((e) => {
+    const tail = g.nodes[e.tail];
+    if (aT > 0 && e.axial / maxAxial < aT * 0.15 && aT > 0.05) {
+      if (tail.children.length === 0 && e.axial / maxAxial < aT) return false;
+    }
+    if (dT > 0) {
+      const nd = tail.rootDist / maxDist;
+      if (tail.children.length === 0 && nd > 1 - dT && dT > 0) ;
+      if (tail.children.length === 0 && 1 - nd < dT * 0.5 && dT >= 0.5) {
+        return false;
+      }
+      if (tail.children.length === 0 && nd * dT > 0.85) return false;
+    }
+    if (arT > 0) {
+      const na = tail.featureArea / maxArea2;
+      if (na < arT) return false;
+    }
+    if (aT > 0 && e.axial / maxAxial > 1 - aT * 0.5 && tail.children.length === 0) {
+      return false;
+    }
+    return true;
+  });
 }
-function padBounds(sites, padRatio) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const s of sites) {
-    minX = Math.min(minX, s.x);
-    minY = Math.min(minY, s.y);
-    maxX = Math.max(maxX, s.x);
-    maxY = Math.max(maxY, s.y);
+function centerLine(shape, straightnessWeighting = 0.7, smoothing = 50) {
+  const g = buildMedialAxisGraph(shape);
+  if (!g || g.nodes.length < 2) {
+    return polyline([]);
   }
-  const pad = Math.max(maxX - minX, maxY - minY, 1) * padRatio + 1e-6;
-  return {
-    minX: minX - pad,
-    minY: minY - pad,
-    maxX: maxX + pad,
-    maxY: maxY + pad
+  const root = g.nodes[g.root];
+  const childRoots = root.children;
+  const leavesOf = (start) => {
+    const out = [];
+    const stack = [start];
+    while (stack.length) {
+      const u = stack.pop();
+      const n = g.nodes[u];
+      if (n.children.length === 0) out.push(n);
+      else stack.push(...n.children);
+    }
+    return out;
   };
-}
-var voronoi = {
-  compoundVoronoi,
-  innerVoronoi,
-  innerVoronoiRaw
-};
-
-// src/construction/index.ts
-function createCircle(cx, cy, radius, segments = 64) {
-  return createRegularPolygon(cx, cy, radius, Math.max(3, Math.floor(segments)));
-}
-function createRect(x, y, width2, height2) {
-  return polygon([
-    { x, y },
-    { x: x + width2, y },
-    { x: x + width2, y: y + height2 },
-    { x, y: y + height2 }
-  ]);
-}
-function createRegularPolygon(cx, cy, radius, sides, rotation = -Math.PI / 2) {
-  const n = Math.max(3, Math.floor(sides));
-  const ring2 = [];
-  for (let i = 0; i < n; i++) {
-    const t = rotation + i / n * Math.PI * 2;
-    ring2.push({ x: cx + Math.cos(t) * radius, y: cy + Math.sin(t) * radius });
+  let bestPath = [];
+  if (childRoots.length <= 1) {
+    bestPath = longestPathNodes(g);
+  } else if (childRoots.length === 2) {
+    bestPath = pathBetweenLeaves(
+      g,
+      leavesOf(childRoots[0]),
+      leavesOf(childRoots[1]),
+      root,
+      straightnessWeighting
+    );
+  } else {
+    const groups = childRoots.map(leavesOf);
+    let bestW = -Infinity;
+    for (let i = 0; i < groups.length; i++) {
+      for (let j = i + 1; j < groups.length; j++) {
+        const { path: p, weight } = bestLeafPair(
+          g,
+          groups[i],
+          groups[j],
+          root,
+          straightnessWeighting
+        );
+        if (weight > bestW) {
+          bestW = weight;
+          bestPath = p;
+        }
+      }
+    }
   }
-  return polygon(ring2);
+  if (bestPath.length < 2) bestPath = longestPathNodes(g);
+  const pts = bestPath.map((id) => g.nodes[id].position);
+  return polyline(gaussianSmooth(pts, smoothing));
+}
+function bestLeafPair(g, a, b, root, straightness) {
+  let bestW = -Infinity;
+  let best = [];
+  for (const d1 of a) {
+    for (const d2 of b) {
+      const angle = angleBetween(d1.position, root.position, d2.position);
+      const aw = Math.pow(1 + angle, straightness);
+      const weight = (d1.rootDist + d2.rootDist) * Math.max(aw - 1, 1);
+      if (weight > bestW) {
+        bestW = weight;
+        best = [...pathToRoot(g, d1.id), ...pathToRoot(g, d2.id).reverse().slice(1)];
+      }
+    }
+  }
+  return { path: best, weight: bestW };
 }
-function createRing(cx, cy, outerRadius, innerRadius, segments = 64) {
-  const outer = createCircle(cx, cy, outerRadius, segments).rings[0];
-  const inner = createCircle(cx, cy, Math.min(innerRadius, outerRadius), segments).rings[0];
-  return path([outer, [...inner].reverse()], true);
+function pathBetweenLeaves(g, a, b, root, straightness) {
+  return bestLeafPair(g, a, b, root, straightness).path;
 }
-function createArc(cx, cy, radius, startAngle, endAngle, segments = 32) {
-  const n = Math.max(2, Math.floor(segments));
-  const pts = [];
-  for (let i = 0; i <= n; i++) {
-    const t = startAngle + (endAngle - startAngle) * i / n;
-    pts.push({ x: cx + Math.cos(t) * radius, y: cy + Math.sin(t) * radius });
+function pathToRoot(g, id) {
+  const path3 = [id];
+  let cur = id;
+  while (g.nodes[cur].parent !== null) {
+    cur = g.nodes[cur].parent;
+    path3.push(cur);
   }
-  return polyline(pts);
+  return path3;
 }
-function createStar(cx, cy, outerRadius, innerRadius, points = 5, rotation = -Math.PI / 2) {
-  const n = Math.max(3, Math.floor(points));
-  const ring2 = [];
-  for (let i = 0; i < n * 2; i++) {
-    const r = i % 2 === 0 ? outerRadius : innerRadius;
-    const t = rotation + i / (n * 2) * Math.PI * 2;
-    ring2.push({ x: cx + Math.cos(t) * r, y: cy + Math.sin(t) * r });
+function longestPathNodes(g) {
+  const leaves = g.nodes.filter((n) => n.children.length === 0 && n.id !== g.root);
+  if (leaves.length === 0) return g.nodes.map((n) => n.id);
+  let farthest = leaves[0];
+  let best = -1;
+  for (const L of leaves) {
+    if (L.rootDist > best) {
+      best = L.rootDist;
+      farthest = L;
+    }
   }
-  return polygon(ring2);
-}
-function createKochSnowflake(cx, cy, radius, iterations = 3) {
-  const tri = createRegularPolygon(cx, cy, radius, 3);
-  let ring2 = tri.rings[0];
-  const iters = Math.max(0, Math.min(6, Math.floor(iterations)));
-  for (let i = 0; i < iters; i++) {
-    ring2 = kochRefine(ring2);
+  let bestPath = pathToRoot(g, farthest.id);
+  let bestLen = farthest.rootDist;
+  for (const L of leaves) {
+    if (L.id === farthest.id) continue;
+    const p = [
+      ...pathToRoot(g, farthest.id),
+      ...pathToRoot(g, L.id).reverse().slice(1)
+    ];
+    const len2 = farthest.rootDist + L.rootDist;
+    if (len2 > bestLen) {
+      bestLen = len2;
+      bestPath = p;
+    }
   }
-  return polygon(ring2);
+  return bestPath;
 }
-function kochRefine(ring2) {
+function angleBetween(a, apex, b) {
+  const ax = a.x - apex.x;
+  const ay = a.y - apex.y;
+  const bx = b.x - apex.x;
+  const by = b.y - apex.y;
+  const la = Math.hypot(ax, ay) || 1;
+  const lb = Math.hypot(bx, by) || 1;
+  const cos = Math.max(-1, Math.min(1, (ax * bx + ay * by) / (la * lb)));
+  return Math.acos(cos);
+}
+function gaussianSmooth(pts, sigma) {
+  if (pts.length < 3 || sigma <= 0) return pts;
+  const radius = Math.max(1, Math.round(Math.min(pts.length / 4, sigma / 10)));
   const out = [];
-  const n = ring2.length;
-  for (let i = 0; i < n; i++) {
-    const a = ring2[i];
-    const b = ring2[(i + 1) % n];
-    const dx = b.x - a.x;
-    const dy = b.y - a.y;
-    const p1 = { x: a.x + dx / 3, y: a.y + dy / 3 };
-    const p2 = { x: a.x + 2 * dx / 3, y: a.y + 2 * dy / 3 };
-    const px = a.x + dx / 2 - dy * (Math.sqrt(3) / 6);
-    const py = a.y + dy / 2 + dx * (Math.sqrt(3) / 6);
-    out.push(a, p1, { x: px, y: py }, p2);
+  for (let i = 0; i < pts.length; i++) {
+    let sx = 0;
+    let sy = 0;
+    let w = 0;
+    for (let k = -radius; k <= radius; k++) {
+      const j = Math.max(0, Math.min(pts.length - 1, i + k));
+      const wk = Math.exp(-(k * k) / (2 * (radius * 0.5) ** 2 + 1e-9));
+      sx += pts[j].x * wk;
+      sy += pts[j].y * wk;
+      w += wk;
+    }
+    out.push({ x: sx / w, y: sy / w });
   }
+  out[0] = pts[0];
+  out[out.length - 1] = pts[pts.length - 1];
   return out;
 }
-var construction = {
-  createCircle,
-  createRect,
-  createRegularPolygon,
-  createRing,
-  createArc,
-  createStar,
-  createKochSnowflake
-};
+function key2(p) {
+  return `${p.x.toFixed(7)},${p.y.toFixed(7)}`;
+}
+function edgeKey2(a, b) {
+  const ka = key2(a);
+  const kb = key2(b);
+  return ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+}
+function clamp01(v) {
+  return Math.max(0, Math.min(1, v));
+}
 
-// src/tiling/index.ts
-function squareGrid2(spacing, minX, minY, maxX, maxY) {
-  const s = Math.max(spacing, 1e-9);
-  const paths = [];
-  for (let x = minX; x < maxX - 1e-12; x += s) {
-    for (let y = minY; y < maxY - 1e-12; y += s) {
-      const w = Math.min(s, maxX - x);
-      const h = Math.min(s, maxY - y);
-      if (w > 1e-12 && h > 1e-12) paths.push(createRect(x, y, w, h));
+// src/contour/straightSkeleton.ts
+function straightSkeleton(shape) {
+  const parts = straightSkeletonParts(shape);
+  return group([
+    ...parts.faces.paths,
+    ...parts.branches.paths,
+    ...parts.bones.paths
+  ]);
+}
+function straightSkeletonParts(shape) {
+  const empty = {
+    faces: group([]),
+    branches: group([]),
+    bones: group([])
+  };
+  if (!shape.closed || !shape.rings[0] || shape.rings[0].length < 3) {
+    return empty;
+  }
+  const b = bounds(shape);
+  const span = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1);
+  const delta = Math.max(span / 40, 0.5);
+  const densified = densify(shape, Math.max(span / 40, 1e-3));
+  const levels = [densified];
+  let current = densified;
+  for (let i = 0; i < 40; i++) {
+    const next = buffer(current, -delta);
+    if (next.paths.length === 0) break;
+    let best = next.paths[0];
+    let bestA = -1;
+    for (const p of next.paths) {
+      const bb = bounds(p);
+      const a = (bb.maxX - bb.minX) * (bb.maxY - bb.minY);
+      if (a > bestA) {
+        bestA = a;
+        best = p;
+      }
+    }
+    if (!best.rings[0] || best.rings[0].length < 3) break;
+    levels.push(best);
+    current = best;
+  }
+  const boneSegs = [];
+  for (let i = 0; i < levels.length - 1; i++) {
+    const a = levels[i];
+    const bb = levels[i + 1];
+    const ca = centroid(a);
+    const cb = centroid(bb);
+    if (containsPoint(shape, mid2(ca, cb))) {
+      boneSegs.push(segment(ca, cb));
+    }
+    for (const ring2 of a.rings) {
+      for (const p of ring2) {
+        const q = nearestOnPath(bb, p);
+        if (q && containsPoint(shape, mid2(p, q))) {
+          boneSegs.push(segment(p, q));
+        }
+      }
     }
   }
-  return group(paths);
-}
-function hexTiling(spacing, minX, minY, maxX, maxY) {
-  const s = Math.max(spacing, 1e-9);
-  const r = s / 2;
-  const dx = s * 0.75;
-  const dy = s * Math.sqrt(3) * 0.5;
-  const paths = [];
-  let row = 0;
-  for (let y = minY + r; y <= maxY + r; y += dy, row++) {
-    const x0 = minX + r + (row % 2 === 0 ? 0 : dx * 0.5);
-    for (let x = x0; x <= maxX + r; x += dx) {
-      paths.push(hexagon(x, y, r));
+  const branchSegs = [];
+  const outer = densified.rings[0];
+  const target = levels[1] ?? levels[0];
+  for (let i = 0; i < outer.length; i++) {
+    const a = outer[i];
+    const bb = outer[(i + 1) % outer.length];
+    const m = mid2(a, bb);
+    const q = nearestOnPath(target, m);
+    if (q) branchSegs.push(segment(m, q));
+  }
+  const faces = [];
+  if (levels.length >= 2) {
+    const inner = levels[1].rings[0] ?? [];
+    for (let i = 0; i < outer.length; i++) {
+      const a = outer[i];
+      const bb = outer[(i + 1) % outer.length];
+      const ia = nearestOnRing(inner, a);
+      const ib = nearestOnRing(inner, bb);
+      if (ia && ib) {
+        const face = [a, bb, ib, ia];
+        const c = {
+          x: (a.x + bb.x + ib.x + ia.x) / 4,
+          y: (a.y + bb.y + ib.y + ia.y) / 4
+        };
+        if (containsPoint(shape, c)) faces.push(polygon(face));
+      }
     }
   }
-  return group(paths);
+  return {
+    faces: group(faces),
+    branches: dissolveSegments(branchSegs),
+    bones: dissolveSegments(boneSegs)
+  };
 }
-function hexagon(cx, cy, r) {
-  const ring2 = [];
-  for (let i = 0; i < 6; i++) {
-    const t = Math.PI / 180 * (60 * i - 30);
-    ring2.push({ x: cx + Math.cos(t) * r, y: cy + Math.sin(t) * r });
-  }
-  return polygon(ring2);
+function mid2(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
 }
-function rectSubdivision(p, nx, ny) {
-  const b = bounds(p);
-  const cols = Math.max(1, Math.floor(nx));
-  const rows = Math.max(1, Math.floor(ny));
-  const dw = (b.maxX - b.minX) / cols;
-  const dh = (b.maxY - b.minY) / rows;
-  const paths = [];
-  for (let i = 0; i < cols; i++) {
-    for (let j = 0; j < rows; j++) {
-      const cell = createRect(
-        b.minX + i * dw,
-        b.minY + j * dh,
-        dw,
-        dh
-      );
-      paths.push(...intersect(p, cell).paths);
+function nearestOnPath(p, q) {
+  let best = null;
+  let bestD = Infinity;
+  for (const ring2 of p.rings) {
+    for (const v of ring2) {
+      const d = Math.hypot(v.x - q.x, v.y - q.y);
+      if (d < bestD) {
+        bestD = d;
+        best = v;
+      }
     }
   }
-  return group(paths);
+  return best;
 }
-function quadSubdivision(faces, depth = 1) {
-  let cur = faces;
-  const d = Math.max(0, Math.floor(depth));
-  for (let i = 0; i < d; i++) {
-    const next = [];
-    for (const f of cur) {
-      next.push(...subdivideQuad(f));
+function nearestOnRing(ring2, q) {
+  if (ring2.length === 0) return null;
+  let best = ring2[0];
+  let bestD = Infinity;
+  for (const v of ring2) {
+    const d = Math.hypot(v.x - q.x, v.y - q.y);
+    if (d < bestD) {
+      bestD = d;
+      best = v;
     }
-    cur = next;
   }
-  return group(cur);
-}
-function subdivideQuad(p) {
-  const ring2 = p.rings[0];
-  if (!ring2 || ring2.length < 4) return [p];
-  const [a, b, c, d] = ring2;
-  if (!a || !b || !c || !d) return [p];
-  const mab = mid(a, b);
-  const mbc = mid(b, c);
-  const mcd = mid(c, d);
-  const mda = mid(d, a);
-  const cen = mid(mid(a, c), mid(b, d));
-  return [
-    polygon([a, mab, cen, mda]),
-    polygon([mab, b, mbc, cen]),
-    polygon([cen, mbc, c, mcd]),
-    polygon([mda, cen, mcd, d])
-  ];
+  return best;
 }
-function triangleSubdivision(faces, depth = 1) {
-  let cur = faces;
-  const d = Math.max(0, Math.floor(depth));
-  for (let i = 0; i < d; i++) {
-    const next = [];
-    for (const f of cur) {
-      next.push(...subdivideTriangle(f));
+
+// src/contour/marchingSquares.ts
+function isolinesFromFunction(bounds2, sampleSpacing, contourInterval, fn, isolineMin = Number.NaN, isolineMax = Number.NaN) {
+  const [xmin, ymin, xmax, ymax] = bounds2;
+  const dx = Math.max(sampleSpacing, 1e-9);
+  const dy = dx;
+  const nx = Math.max(2, Math.ceil((xmax - xmin) / dx) + 1);
+  const ny = Math.max(2, Math.ceil((ymax - ymin) / dy) + 1);
+  const grid = [];
+  let gmin = Infinity;
+  let gmax = -Infinity;
+  for (let j = 0; j < ny; j++) {
+    const row = [];
+    const y = ymin + j * ((ymax - ymin) / (ny - 1));
+    for (let i = 0; i < nx; i++) {
+      const x = xmin + i * ((xmax - xmin) / (nx - 1));
+      let v = fn(x, y);
+      if (!Number.isFinite(v)) v = Number.NEGATIVE_INFINITY;
+      row.push(v);
+      if (Number.isFinite(v)) {
+        gmin = Math.min(gmin, v);
+        gmax = Math.max(gmax, v);
+      }
     }
-    cur = next;
+    grid.push(row);
   }
-  return group(cur);
+  const z0 = Number.isFinite(isolineMin) ? isolineMin : gmin;
+  const z1 = Number.isFinite(isolineMax) ? isolineMax : gmax;
+  if (!Number.isFinite(z0) || !Number.isFinite(z1) || contourInterval <= 0) {
+    return group([]);
+  }
+  const levels = [];
+  const start = Math.ceil(z0 / contourInterval) * contourInterval;
+  for (let z = start; z <= z1 + 1e-12; z += contourInterval) {
+    levels.push(z);
+  }
+  const segs = [];
+  for (const level of levels) {
+    segs.push(...marchLevel(grid, xmin, ymin, xmax, ymax, nx, ny, level));
+  }
+  return dissolveSegments(segs);
 }
-function subdivideTriangle(p) {
-  const ring2 = p.rings[0];
-  if (!ring2 || ring2.length < 3) return [p];
-  const a = ring2[0];
-  const b = ring2[1];
-  const c = ring2[2];
-  const mab = mid(a, b);
-  const mbc = mid(b, c);
-  const mca = mid(c, a);
-  return [
-    polygon([a, mab, mca]),
-    polygon([mab, b, mbc]),
-    polygon([mca, mbc, c]),
-    polygon([mab, mbc, mca])
-  ];
+function isolineZeroFromFunction(bounds2, sampleSpacing, fn) {
+  return isolinesFromFunction(bounds2, sampleSpacing, 1, fn, 0, 0);
 }
-function sliceDivision(p, spacing, angle = 0) {
-  const s = Math.max(spacing, 1e-9);
-  const b = bounds(p);
-  const cx = (b.minX + b.maxX) / 2;
-  const cy = (b.minY + b.maxY) / 2;
-  const diag = Math.hypot(b.maxX - b.minX, b.maxY - b.minY) + s;
-  const ux = Math.cos(angle);
-  const uy = Math.sin(angle);
-  const nx = -uy;
-  const ny = ux;
-  const parts = [p];
-  for (let t = -diag; t <= diag; t += s) {
-    const a = { x: cx + nx * t - ux * diag, y: cy + ny * t - uy * diag };
-    const bb = { x: cx + nx * t + ux * diag, y: cy + ny * t + uy * diag };
-    const next = [];
-    for (const piece of parts) {
-      const g = slice(piece, a, bb);
-      next.push(...g.paths.length ? g.paths : [piece]);
+function marchLevel(grid, xmin, ymin, xmax, ymax, nx, ny, level) {
+  const segs = [];
+  const xAt = (i) => xmin + i / (nx - 1) * (xmax - xmin);
+  const yAt = (j) => ymin + j / (ny - 1) * (ymax - ymin);
+  const lerp2 = (x0, y0, v0, x1, y1, v1) => {
+    const t = (level - v0) / (v1 - v0 || 1e-15);
+    return { x: x0 + t * (x1 - x0), y: y0 + t * (y1 - y0) };
+  };
+  for (let j = 0; j < ny - 1; j++) {
+    for (let i = 0; i < nx - 1; i++) {
+      const v00 = grid[j][i];
+      const v10 = grid[j][i + 1];
+      const v11 = grid[j + 1][i + 1];
+      const v01 = grid[j + 1][i];
+      const x0 = xAt(i);
+      const x1 = xAt(i + 1);
+      const y0 = yAt(j);
+      const y1 = yAt(j + 1);
+      let code = 0;
+      if (v00 >= level) code |= 1;
+      if (v10 >= level) code |= 2;
+      if (v11 >= level) code |= 4;
+      if (v01 >= level) code |= 8;
+      if (code === 0 || code === 15) continue;
+      const bottom = () => lerp2(x0, y0, v00, x1, y0, v10);
+      const right = () => lerp2(x1, y0, v10, x1, y1, v11);
+      const top = () => lerp2(x0, y1, v01, x1, y1, v11);
+      const left = () => lerp2(x0, y0, v00, x0, y1, v01);
+      const add = (a, b) => segs.push(segment(a, b));
+      switch (code) {
+        case 1:
+        case 14:
+          add(left(), bottom());
+          break;
+        case 2:
+        case 13:
+          add(bottom(), right());
+          break;
+        case 3:
+        case 12:
+          add(left(), right());
+          break;
+        case 4:
+        case 11:
+          add(right(), top());
+          break;
+        case 6:
+        case 9:
+          add(bottom(), top());
+          break;
+        case 7:
+        case 8:
+          add(left(), top());
+          break;
+        case 5: {
+          const avg = (v00 + v10 + v11 + v01) / 4;
+          if (avg >= level) {
+            add(left(), top());
+            add(bottom(), right());
+          } else {
+            add(left(), bottom());
+            add(right(), top());
+          }
+          break;
+        }
+        case 10: {
+          const avg = (v00 + v10 + v11 + v01) / 4;
+          if (avg >= level) {
+            add(left(), bottom());
+            add(right(), top());
+          } else {
+            add(left(), top());
+            add(bottom(), right());
+          }
+          break;
+        }
+      }
     }
-    parts.length = 0;
-    parts.push(...next);
   }
-  return group(parts);
-}
-function hatchSubdivision(p, spacing, angle = 0) {
-  return sliceDivision(p, spacing, angle);
-}
-function mid(a, b) {
-  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+  return segs;
 }
-var tiling = {
-  squareGrid: squareGrid2,
-  hexTiling,
-  rectSubdivision,
-  quadSubdivision,
-  triangleSubdivision,
-  sliceDivision,
-  hatchSubdivision
-};
-
-// src/polygonisation/index.ts
-function maxArea(points) {
-  return convexHull(points);
-}
-function minArea(points) {
-  const hull2 = convexHull(points).rings[0] ?? [];
-  if (hull2.length < 3) return convexHull(points);
-  if (hull2.length === 3) return polygon(hull2);
-  let best = null;
-  let bestA = Infinity;
-  const h = hull2;
-  const n = h.length;
-  for (let i = 0; i < n; i++) {
-    for (let j = i + 1; j < n; j++) {
-      for (let k = j + 1; k < n; k++) {
-        const tri = polygon([h[i], h[j], h[k]]);
-        if (!coversPoints(tri, points)) continue;
-        const a = area(tri);
-        if (a < bestA) {
-          bestA = a;
-          best = tri;
-        }
-      }
-    }
-  }
-  return best ?? convexHull(points);
-}
-function minPerimeter(points) {
-  if (points.length === 0) return polygon([]);
-  if (points.length < 3) return polygon(points);
-  const remaining = points.map((p) => ({ ...p }));
-  const ordered = [remaining.shift()];
-  while (remaining.length) {
-    const last = ordered[ordered.length - 1];
-    let bestI = 0;
-    let bestD = Infinity;
-    for (let i = 0; i < remaining.length; i++) {
-      const d = Math.hypot(
-        remaining[i].x - last.x,
-        remaining[i].y - last.y
-      );
-      if (d < bestD) {
-        bestD = d;
-        bestI = i;
-      }
-    }
-    ordered.push(remaining.splice(bestI, 1)[0]);
-  }
-  return polygon(ordered);
-}
-function horizontal(points) {
-  const pts = [...points].sort(
-    (a, b) => a.y === b.y ? a.x - b.x : a.y - b.y
-  );
-  return polygon(pts);
-}
-function vertical(points) {
-  const pts = [...points].sort(
-    (a, b) => a.x === b.x ? a.y - b.y : a.x - b.x
-  );
-  return polygon(pts);
-}
-function angular(points) {
-  if (points.length === 0) return polygon([]);
-  const c = centroidOf(points);
-  const pts = [...points].sort(
-    (a, b) => Math.atan2(a.y - c.y, a.x - c.x) - Math.atan2(b.y - c.y, b.x - c.x)
-  );
-  return polygon(pts);
-}
-function circular(points) {
-  return angular(points);
-}
-function onion(points) {
-  const layers = onionLayers(points);
-  return layers[0] ?? polygon([]);
-}
-function onionLayers(points) {
-  let remaining = points.map((p) => ({ ...p }));
-  const layers = [];
-  while (remaining.length >= 3) {
-    const hull2 = convexHull(remaining);
-    const ring2 = hull2.rings[0] ?? [];
-    if (ring2.length < 3) break;
-    layers.push(hull2);
-    const onHull = new Set(ring2.map((v) => `${v.x},${v.y}`));
-    remaining = remaining.filter((p) => !onHull.has(`${p.x},${p.y}`));
+function isolinesFromPoints(points, values, intervals, _smoothing = 0) {
+  if (points.length < 3 || intervals < 1) return group([]);
+  let minZ = Infinity;
+  let maxZ = -Infinity;
+  for (const v of values) {
+    minZ = Math.min(minZ, v);
+    maxZ = Math.max(maxZ, v);
   }
-  return layers;
-}
-function hilbert(points) {
-  if (points.length === 0) return polygon([]);
+  if (!Number.isFinite(minZ) || maxZ - minZ < 1e-15) return group([]);
   let minX = Infinity;
   let minY = Infinity;
   let maxX = -Infinity;
@@ -2723,135 +3579,371 @@ function hilbert(points) {
     maxX = Math.max(maxX, p.x);
     maxY = Math.max(maxY, p.y);
   }
-  const span = Math.max(maxX - minX, maxY - minY, 1e-9);
-  const order = 10;
-  const n = 1 << order;
-  const scored = points.map((p) => {
-    const x = Math.min(
-      n - 1,
-      Math.max(0, Math.floor((p.x - minX) / span * (n - 1)))
-    );
-    const y = Math.min(
-      n - 1,
-      Math.max(0, Math.floor((p.y - minY) / span * (n - 1)))
-    );
-    return { p, h: xy2d(order, x, y) };
-  });
-  scored.sort((a, b) => a.h - b.h);
-  return polygon(scored.map((s) => s.p));
+  const span = Math.max(maxX - minX, maxY - minY, 1);
+  const sampleSpacing = span / Math.max(20, Math.sqrt(points.length));
+  const interval = (maxZ - minZ) / intervals;
+  const fn = (x, y) => {
+    let num2 = 0;
+    let den = 0;
+    for (let i = 0; i < points.length; i++) {
+      const p = points[i];
+      const d2 = (x - p.x) ** 2 + (y - p.y) ** 2;
+      const w = 1 / Math.max(d2, 1e-12);
+      num2 += w * values[i];
+      den += w;
+    }
+    return num2 / den;
+  };
+  return isolinesFromFunction(
+    [minX, minY, maxX, maxY],
+    sampleSpacing,
+    interval,
+    fn,
+    minZ,
+    maxZ
+  );
 }
-function coversPoints(poly, points) {
-  const r = poly.rings[0];
-  if (!r || r.length < 3) return false;
-  const a = r[0];
-  const b = r[1];
-  const c = r[2];
-  for (const p of points) {
-    if (!pointInTriangle(p, a, b, c)) return false;
-  }
-  return true;
+
+// src/contour/fields.ts
+function distanceField(shape, spacing, pole) {
+  if (!shape.closed || shape.rings.length === 0 || spacing <= 0) return group([]);
+  const b = bounds(shape);
+  const span = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1);
+  let polePt = pole;
+  if (!polePt) {
+    const mic = maximumInscribedCircle(shape, Math.max(span * 0.01, 0.1));
+    polePt = mic ? { x: mic.x, y: mic.y } : { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 };
+  }
+  const pad = Math.max(spacing, 1);
+  const box = [
+    b.minX - pad,
+    b.minY - pad,
+    b.maxX + pad,
+    b.maxY + pad
+  ];
+  const sampleSpacing = Math.max(spacing / 10, span / 80);
+  const fn = (x, y) => {
+    const p = { x, y };
+    if (!insideSafe(shape, p)) return Number.NEGATIVE_INFINITY;
+    const dGeo = distanceToBoundary2(shape, p);
+    const dPoint = Math.hypot(x - polePt.x, y - polePt.y);
+    return dGeo - dPoint;
+  };
+  const raw = isolinesFromFunction(box, sampleSpacing, spacing, fn);
+  return clipPolylinesToPath(raw, shape);
 }
-function pointInTriangle(p, a, b, c) {
-  const v0x = c.x - a.x;
-  const v0y = c.y - a.y;
-  const v1x = b.x - a.x;
-  const v1y = b.y - a.y;
-  const v2x = p.x - a.x;
-  const v2y = p.y - a.y;
-  const dot00 = v0x * v0x + v0y * v0y;
-  const dot01 = v0x * v1x + v0y * v1y;
-  const dot02 = v0x * v2x + v0y * v2y;
-  const dot11 = v1x * v1x + v1y * v1y;
-  const dot12 = v1x * v2x + v1y * v2y;
-  const inv = 1 / (dot00 * dot11 - dot01 * dot01 || 1e-18);
-  const u = (dot11 * dot02 - dot01 * dot12) * inv;
-  const v = (dot00 * dot12 - dot01 * dot02) * inv;
-  return u >= -1e-9 && v >= -1e-9 && u + v <= 1 + 1e-9;
+function contrastField(shape, intervals, reference) {
+  if (!shape.closed || shape.rings.length === 0 || intervals < 1) {
+    return group([]);
+  }
+  const b = bounds(shape);
+  const areaApprox = (b.maxX - b.minX) * (b.maxY - b.minY);
+  const count = Math.max(100, Math.floor(areaApprox / 100));
+  const minDist = Math.sqrt(areaApprox / (count * 1.5));
+  const samples = poisson(
+    Math.max(minDist, 1e-3),
+    b.minX,
+    b.minY,
+    b.maxX,
+    b.maxY,
+    1337
+  ).filter((p) => containsPoint(shape, p));
+  if (samples.length < 3) return group([]);
+  const values = samples.map((p) => {
+    const dB = distanceToBoundary2(shape, p);
+    const dR = Math.hypot(p.x - reference.x, p.y - reference.y);
+    return Math.abs(dB - dR);
+  });
+  const lines = isolinesFromPoints(samples, values, Math.max(1, intervals), 0);
+  return clipPolylinesToPath(lines, shape);
+}
+function isolines(shape, highPoint, intervalSpacing) {
+  if (!shape.closed || intervalSpacing <= 0) return group([]);
+  const b = bounds(shape);
+  const span = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1);
+  const pad = intervalSpacing;
+  const box = [
+    b.minX - pad,
+    b.minY - pad,
+    b.maxX + pad,
+    b.maxY + pad
+  ];
+  const fn = (x, y) => {
+    if (!containsPoint(shape, { x, y })) return -1;
+    return Math.hypot(x - highPoint.x, y - highPoint.y);
+  };
+  const raw = isolinesFromFunction(
+    box,
+    Math.max(intervalSpacing / 8, span / 100),
+    intervalSpacing,
+    fn,
+    0,
+    span
+  );
+  return clipPolylinesToPath(raw, shape);
 }
-function centroidOf(points) {
-  let sx = 0;
-  let sy = 0;
-  for (const p of points) {
-    sx += p.x;
-    sy += p.y;
+function clipPolylinesToPath(g, shape) {
+  const paths = [];
+  for (const p of g.paths) {
+    const ring2 = p.rings[0];
+    if (!ring2 || ring2.length < 2) continue;
+    let current = [];
+    const flush = () => {
+      if (current.length >= 2) {
+        paths.push({ rings: [current], closed: false });
+      }
+      current = [];
+    };
+    for (let i = 0; i < ring2.length - 1; i++) {
+      const a = ring2[i];
+      const b = ring2[i + 1];
+      if (!finitePt(a) || !finitePt(b)) {
+        flush();
+        continue;
+      }
+      const mid5 = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+      if (insideSafe(shape, mid5)) {
+        if (current.length === 0) current.push(a);
+        current.push(b);
+      } else {
+        flush();
+      }
+    }
+    flush();
   }
-  return { x: sx / points.length, y: sy / points.length };
+  return group(paths);
 }
-function xy2d(order, x, y) {
-  let rx;
-  let ry;
-  let s;
-  let d = 0;
-  for (s = 1 << order - 1; s > 0; s >>= 1) {
-    rx = (x & s) > 0 ? 1 : 0;
-    ry = (y & s) > 0 ? 1 : 0;
-    d += s * s * (3 * rx ^ ry);
-    ({ x, y } = rot(s, x, y, rx, ry));
+function finitePt(p) {
+  return Number.isFinite(p.x) && Number.isFinite(p.y);
+}
+function insideSafe(shape, point) {
+  if (!finitePt(point)) return false;
+  try {
+    return containsPoint(shape, point);
+  } catch {
+    return pointInPoly2(point, shape.rings[0]) && shape.rings.slice(1).every((h) => !pointInPoly2(point, h));
   }
-  return d;
 }
-function rot(n, x, y, rx, ry) {
-  if (ry === 0) {
-    if (rx === 1) {
-      x = n - 1 - x;
-      y = n - 1 - y;
+function pointInPoly2(point, ring2) {
+  let inside = false;
+  for (let i = 0, j = ring2.length - 1; i < ring2.length; j = i++) {
+    const pi = ring2[i];
+    const pj = ring2[j];
+    if (pi.y > point.y !== pj.y > point.y && point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y + 1e-15) + pi.x) {
+      inside = !inside;
     }
-    return { x: y, y: x };
   }
-  return { x, y };
+  return inside;
 }
-var polygonisation = {
-  maxArea,
-  minArea,
-  minPerimeter,
-  horizontal,
-  vertical,
-  angular,
-  circular,
-  onion,
-  onionLayers,
-  hilbert
-};
 
-// src/meshing/index.ts
-function edgeKey(a, b) {
-  const aKey = `${a.x},${a.y}`;
-  const bKey = `${b.x},${b.y}`;
-  return aKey < bKey ? `${aKey}|${bKey}` : `${bKey}|${aKey}`;
-}
-function vertKey(v) {
-  return `${v.x},${v.y}`;
-}
-function same(a, b, eps = 1e-12) {
-  return Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps;
-}
-function dist(a, b) {
-  return Math.hypot(a.x - b.x, a.y - b.y);
-}
-function mid2(a, b) {
-  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
-}
-function lerp(a, b, t) {
-  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+// src/contour/distanceTree.ts
+function key3(v) {
+  return `${v.x.toFixed(8)},${v.y.toFixed(8)}`;
 }
-function unique(points) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const p of points) {
-    const k = vertKey(p);
-    if (seen.has(k)) continue;
-    seen.add(k);
-    out.push({ ...p });
+function distanceTree(mesh, source, flatten2) {
+  const adj = /* @__PURE__ */ new Map();
+  const pts = /* @__PURE__ */ new Map();
+  const addEdge = (a, b) => {
+    const ka = key3(a);
+    const kb = key3(b);
+    if (ka === kb) return;
+    pts.set(ka, a);
+    pts.set(kb, b);
+    if (!adj.has(ka)) adj.set(ka, []);
+    if (!adj.has(kb)) adj.set(kb, []);
+    adj.get(ka).push({ to: kb, pt: b });
+    adj.get(kb).push({ to: ka, pt: a });
+  };
+  for (const face of mesh.paths) {
+    for (const ring2 of face.rings) {
+      if (ring2.length < 2) continue;
+      const n = ring2.length;
+      const closed = face.closed;
+      const limit = closed ? n : n - 1;
+      for (let i = 0; i < limit; i++) {
+        addEdge(ring2[i], ring2[(i + 1) % n]);
+      }
+    }
   }
-  return out;
+  if (pts.size === 0) return group([]);
+  let sourceKey = "";
+  let best = Infinity;
+  for (const [k, p] of pts) {
+    const d = Math.hypot(p.x - source.x, p.y - source.y);
+    if (d < best) {
+      best = d;
+      sourceKey = k;
+    }
+  }
+  const parent = /* @__PURE__ */ new Map();
+  parent.set(sourceKey, null);
+  const q = [sourceKey];
+  while (q.length) {
+    const u = q.shift();
+    for (const { to } of adj.get(u) ?? []) {
+      if (parent.has(to)) continue;
+      parent.set(to, u);
+      q.push(to);
+    }
+  }
+  if (flatten2) {
+    const segs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [v, p] of parent) {
+      if (p === null) continue;
+      const ek = v < p ? `${v}|${p}` : `${p}|${v}`;
+      if (seen.has(ek)) continue;
+      seen.add(ek);
+      segs.push(segment(pts.get(p), pts.get(v)));
+    }
+    return dissolveSegments(segs);
+  }
+  const paths = [];
+  for (const [v] of parent) {
+    if (v === sourceKey) continue;
+    const chain = [];
+    let cur = v;
+    while (cur !== null) {
+      chain.push(pts.get(cur));
+      cur = parent.get(cur) ?? null;
+    }
+    chain.reverse();
+    if (chain.length >= 2) paths.push(polyline(chain));
+  }
+  return group(paths);
 }
-function cross3(o, a, b) {
-  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+
+// src/contour/index.ts
+function offsetCurvesOutward(p, distance) {
+  return buffer(p, Math.abs(distance));
 }
-function ringOf(face) {
-  return face.rings[0] ?? [];
+function offsetCurvesInward(p, distance) {
+  return buffer(p, -Math.abs(distance));
 }
-function buildEdgeMap(faces) {
+var contour = {
+  offsetCurvesOutward,
+  offsetCurvesInward,
+  medialAxis,
+  chordalAxis,
+  straightSkeleton,
+  straightSkeletonParts,
+  centerLine,
+  distanceField,
+  contrastField,
+  distanceTree,
+  isolines,
+  isolinesFromFunction,
+  isolineZeroFromFunction,
+  isolinesFromPoints,
+  dissolveSegments
+};
+function compoundVoronoi(sites, options = {}) {
+  if (sites.length === 0) return group([]);
+  if (sites.length === 1) {
+    const b2 = options.bounds ?? padBounds(sites, 1);
+    return group([
+      polygon([
+        { x: b2.minX, y: b2.minY },
+        { x: b2.maxX, y: b2.minY },
+        { x: b2.maxX, y: b2.maxY },
+        { x: b2.minX, y: b2.maxY }
+      ])
+    ]);
+  }
+  const b = options.bounds ?? padBounds(sites, 0.1);
+  const delaunay = Delaunay.from(
+    sites,
+    (d) => d.x,
+    (d) => d.y
+  );
+  const voronoi2 = delaunay.voronoi([b.minX, b.minY, b.maxX, b.maxY]);
+  const paths = [];
+  for (let i = 0; i < sites.length; i++) {
+    const poly = voronoi2.cellPolygon(i);
+    if (!poly || poly.length < 3) continue;
+    const ring2 = poly.slice(0, -1).map(([x, y]) => ({ x, y }));
+    if (ring2.length >= 3) paths.push(polygon(ring2));
+  }
+  return group(paths);
+}
+function innerVoronoi(sites, container, options = {}) {
+  const b = options.bounds ?? {
+    ...bounds(container)
+  };
+  const cells = compoundVoronoi(sites, { bounds: b });
+  const clipped = [];
+  for (const cell of cells.paths) {
+    clipped.push(...intersect(cell, container).paths);
+  }
+  return group(clipped);
+}
+function innerVoronoiRaw(sites, options = {}) {
+  return compoundVoronoi(sites, options);
+}
+function padBounds(sites, padRatio) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const s of sites) {
+    minX = Math.min(minX, s.x);
+    minY = Math.min(minY, s.y);
+    maxX = Math.max(maxX, s.x);
+    maxY = Math.max(maxY, s.y);
+  }
+  const pad = Math.max(maxX - minX, maxY - minY, 1) * padRatio + 1e-6;
+  return {
+    minX: minX - pad,
+    minY: minY - pad,
+    maxX: maxX + pad,
+    maxY: maxY + pad
+  };
+}
+var voronoi = {
+  compoundVoronoi,
+  innerVoronoi,
+  innerVoronoiRaw
+};
+
+// src/meshing/index.ts
+function edgeKey3(a, b) {
+  const aKey = `${a.x},${a.y}`;
+  const bKey = `${b.x},${b.y}`;
+  return aKey < bKey ? `${aKey}|${bKey}` : `${bKey}|${aKey}`;
+}
+function vertKey(v) {
+  return `${v.x},${v.y}`;
+}
+function same2(a, b, eps = 1e-12) {
+  return Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps;
+}
+function dist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function mid3(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+function lerp(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function unique(points) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of points) {
+    const k = vertKey(p);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push({ ...p });
+  }
+  return out;
+}
+function cross3(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+function ringOf(face) {
+  return face.rings[0] ?? [];
+}
+function buildEdgeMap(faces) {
   const edges = /* @__PURE__ */ new Map();
   faces.forEach((f, fi) => {
     const ring2 = ringOf(f);
@@ -2862,10 +3954,10 @@ function buildEdgeMap(faces) {
     for (let i = 0; i < lim; i++) {
       const a = ring2[i];
       const b = ring2[(i + 1) % n];
-      const key = edgeKey(a, b);
-      const rec = edges.get(key);
+      const key4 = edgeKey3(a, b);
+      const rec = edges.get(key4);
       if (rec) rec.faceIds.push(fi);
-      else edges.set(key, { a: { ...a }, b: { ...b }, faceIds: [fi] });
+      else edges.set(key4, { a: { ...a }, b: { ...b }, faceIds: [fi] });
     }
   });
   return edges;
@@ -2909,8 +4001,8 @@ function facesFromKeptEdges(tris, kept) {
     if (ra !== rb) parent[rb] = ra;
   };
   const edgeMap = buildEdgeMap(tris);
-  for (const [key, e] of edgeMap) {
-    if (e.faceIds.length === 2 && !kept.has(key)) {
+  for (const [key4, e] of edgeMap) {
+    if (e.faceIds.length === 2 && !kept.has(key4)) {
       unite(e.faceIds[0], e.faceIds[1]);
     }
   }
@@ -2936,10 +4028,10 @@ function boundaryRingOfComponent(tris, members) {
     for (let i = 0; i < ring2.length; i++) {
       const a = ring2[i];
       const b = ring2[(i + 1) % ring2.length];
-      const key = edgeKey(a, b);
-      const rec = edgeCount.get(key);
+      const key4 = edgeKey3(a, b);
+      const rec = edgeCount.get(key4);
       if (rec) rec.n++;
-      else edgeCount.set(key, { a: { ...a }, b: { ...b }, n: 1 });
+      else edgeCount.set(key4, { a: { ...a }, b: { ...b }, n: 1 });
     }
   }
   const boundary = [];
@@ -2969,14 +4061,14 @@ function orderEdgesIntoRing(edges) {
   const maxSteps = edges.length + 2;
   for (let step = 0; step < maxSteps; step++) {
     ring2.push({ ...curr });
-    if (same(curr, start) && ring2.length > 2) {
+    if (same2(curr, start) && ring2.length > 2) {
       ring2.pop();
       return ring2;
     }
     const nbrs = adj.get(vertKey(curr)) ?? [];
     let next = null;
     for (const n of nbrs) {
-      if (!same(n, prev)) {
+      if (!same2(n, prev)) {
         next = n;
         break;
       }
@@ -2991,13 +4083,13 @@ function applyEdgeFilter(tris, shouldKeep, preservePerimeter) {
   const edgeMap = buildEdgeMap(tris);
   const peri = perimeterKeys(edgeMap);
   const kept = /* @__PURE__ */ new Set();
-  for (const [key, e] of edgeMap) {
-    const isPeri = peri.has(key);
+  for (const [key4, e] of edgeMap) {
+    const isPeri = peri.has(key4);
     if (isPeri && preservePerimeter) {
-      kept.add(key);
+      kept.add(key4);
       continue;
     }
-    if (shouldKeep(e.a, e.b, isPeri)) kept.add(key);
+    if (shouldKeep(e.a, e.b, isPeri)) kept.add(key4);
   }
   return facesFromKeptEdges(tris, kept);
 }
@@ -3025,8 +4117,8 @@ function extractInnerVertices(faces) {
   const edgeMap = buildEdgeMap(faces);
   const peri = perimeterKeys(edgeMap);
   const periVerts = /* @__PURE__ */ new Set();
-  for (const key of peri) {
-    const e = edgeMap.get(key);
+  for (const key4 of peri) {
+    const e = edgeMap.get(key4);
     periVerts.add(vertKey(e.a));
     periVerts.add(vertKey(e.b));
   }
@@ -3076,10 +4168,10 @@ function densifyRing2(ring2, maxLen) {
   return out;
 }
 function isGabriel(a, b, points) {
-  const m = mid2(a, b);
+  const m = mid3(a, b);
   const r = dist(a, b) / 2;
   for (const p of points) {
-    if (same(p, a) || same(p, b)) continue;
+    if (same2(p, a) || same2(p, b)) continue;
     if (dist(p, m) < r - 1e-9) return false;
   }
   return true;
@@ -3087,7 +4179,7 @@ function isGabriel(a, b, points) {
 function isRelativeNeighbor(a, b, points) {
   const dab = dist(a, b);
   for (const p of points) {
-    if (same(p, a) || same(p, b)) continue;
+    if (same2(p, a) || same2(p, b)) continue;
     if (Math.max(dist(p, a), dist(p, b)) < dab - 1e-9) return false;
   }
   return true;
@@ -3108,7 +4200,7 @@ function urquhartFaces(input, preservePerimeter = false) {
       const d = dist(a, b);
       if (d > longestLen) {
         longestLen = d;
-        longestKey = edgeKey(a, b);
+        longestKey = edgeKey3(a, b);
       }
     }
     if (longestKey && !(preservePerimeter && peri.has(longestKey))) {
@@ -3116,8 +4208,8 @@ function urquhartFaces(input, preservePerimeter = false) {
     }
   }
   const kept = /* @__PURE__ */ new Set();
-  for (const key of edgeMap.keys()) {
-    if (!removed.has(key)) kept.add(key);
+  for (const key4 of edgeMap.keys()) {
+    if (!removed.has(key4)) kept.add(key4);
   }
   return group(facesFromKeptEdges(tris, kept));
 }
@@ -3148,12 +4240,12 @@ function spannerFaces(input, k = 1, preservePerimeter = false) {
   const edgeMap = buildEdgeMap(tris);
   const peri = perimeterKeys(edgeMap);
   const stretch = Math.max(1, k);
-  const edges = [...edgeMap.entries()].map(([key, e]) => ({
-    key,
+  const edges = [...edgeMap.entries()].map(([key4, e]) => ({
+    key: key4,
     a: e.a,
     b: e.b,
     len: dist(e.a, e.b),
-    peri: peri.has(key)
+    peri: peri.has(key4)
   }));
   edges.sort((a, b) => a.len - b.len);
   const adj = /* @__PURE__ */ new Map();
@@ -3208,8 +4300,8 @@ function dualFaces(faces) {
   const edgeMap = buildEdgeMap(faces);
   const peri = perimeterKeys(edgeMap);
   const periVerts = /* @__PURE__ */ new Set();
-  for (const key of peri) {
-    const e = edgeMap.get(key);
+  for (const key4 of peri) {
+    const e = edgeMap.get(key4);
     periVerts.add(vertKey(e.a));
     periVerts.add(vertKey(e.b));
   }
@@ -3245,8 +4337,8 @@ function triVerts(t) {
 function midpointMap(faces) {
   const mids = /* @__PURE__ */ new Map();
   const edgeMap = buildEdgeMap(faces);
-  for (const [key, e] of edgeMap) {
-    mids.set(key, mid2(e.a, e.b));
+  for (const [key4, e] of edgeMap) {
+    mids.set(key4, mid3(e.a, e.b));
   }
   return mids;
 }
@@ -3256,7 +4348,7 @@ function centroidQuadrangulation(input, preservePerimeter = true) {
   const centers = tris.map((t) => centroid(t));
   const out = [];
   const peri = perimeterKeys(edgeMap);
-  for (const [key, e] of edgeMap) {
+  for (const [key4, e] of edgeMap) {
     const ids = e.faceIds;
     if (ids.length === 2) {
       const c0 = centers[ids[0]];
@@ -3265,7 +4357,7 @@ function centroidQuadrangulation(input, preservePerimeter = true) {
     } else if (ids.length === 1 && preservePerimeter) {
       const c0 = centers[ids[0]];
       out.push(polygon([e.a, e.b, c0]));
-    } else if (ids.length === 1 && !preservePerimeter && peri.has(key)) ;
+    } else if (ids.length === 1 && !preservePerimeter && peri.has(key4)) ;
   }
   return group(out);
 }
@@ -3278,9 +4370,9 @@ function splitQuadrangulation(input) {
     if (!v) continue;
     const [a, b, c] = v;
     const g = centroid(t);
-    const mab = mids.get(edgeKey(a, b)) ?? mid2(a, b);
-    const mbc = mids.get(edgeKey(b, c)) ?? mid2(b, c);
-    const mca = mids.get(edgeKey(c, a)) ?? mid2(c, a);
+    const mab = mids.get(edgeKey3(a, b)) ?? mid3(a, b);
+    const mbc = mids.get(edgeKey3(b, c)) ?? mid3(b, c);
+    const mca = mids.get(edgeKey3(c, a)) ?? mid3(c, a);
     out.push(polygon([a, mab, g, mca]));
     out.push(polygon([b, mbc, g, mab]));
     out.push(polygon([c, mca, g, mbc]));
@@ -3291,13 +4383,13 @@ function edgeCollapseQuadrangulation(input, preservePerimeter = true) {
   const tris = asTriFaces(input);
   const edgeMap = buildEdgeMap(tris);
   const candidates = [];
-  for (const [key, e] of edgeMap) {
+  for (const [key4, e] of edgeMap) {
     if (e.faceIds.length !== 2) continue;
     const [i, j] = e.faceIds;
     const quad = mergeTriPair(tris[i], tris[j], e.a, e.b);
     if (!quad) continue;
     candidates.push({
-      key,
+      key: key4,
       a: e.a,
       b: e.b,
       i,
@@ -3333,7 +4425,7 @@ function mergeTriPair(t0, t1, ea, eb) {
 }
 function oppositeVertex(t, ea, eb) {
   for (const v of ringOf(t)) {
-    if (!same(v, ea) && !same(v, eb)) return v;
+    if (!same2(v, ea) && !same2(v, eb)) return v;
   }
   return null;
 }
@@ -3395,8 +4487,8 @@ function vertexNeighborhood(faces) {
   const edgeMap = buildEdgeMap(faces);
   const peri = perimeterKeys(edgeMap);
   const perimeter = /* @__PURE__ */ new Set();
-  for (const key of peri) {
-    const e = edgeMap.get(key);
+  for (const key4 of peri) {
+    const e = edgeMap.get(key4);
     perimeter.add(vertKey(e.a));
     perimeter.add(vertKey(e.b));
   }
@@ -3519,8 +4611,8 @@ function simplifyMesh(faces, tolerance, preservePerimeter = true) {
   };
   const periVerts = /* @__PURE__ */ new Set();
   if (preservePerimeter) {
-    for (const key of peri) {
-      const e = edgeMap.get(key);
+    for (const key4 of peri) {
+      const e = edgeMap.get(key4);
       periVerts.add(vertKey(e.a));
       periVerts.add(vertKey(e.b));
     }
@@ -3564,7 +4656,7 @@ function clusterSnap(points, tol) {
 function stochasticMerge(faces, nClasses, seed = 1) {
   if (faces.length === 0) return group([]);
   const classes = Math.max(1, Math.floor(nClasses));
-  const rng = mulberry324(seed >>> 0);
+  const rng = mulberry325(seed >>> 0);
   const label = faces.map(() => Math.floor(rng() * classes));
   const adj = faceAdjacency(faces);
   const parent = faces.map((_, i) => i);
@@ -3704,7 +4796,7 @@ function convexHullOf(points) {
   upper.pop();
   return polygon([...lower, ...upper]);
 }
-function mulberry324(a) {
+function mulberry325(a) {
   return () => {
     a |= 0;
     a = a + 1831565813 | 0;
@@ -3741,8 +4833,8 @@ function findBreaks(faces) {
 function nearDuplicateEdge(a, b, tol) {
   const d1 = dist(a.a, b.a) + dist(a.b, b.b);
   const d2 = dist(a.a, b.b) + dist(a.b, b.a);
-  const len = dist(a.a, a.b);
-  return Math.min(d1, d2) < tol * 2 + len * 0.05 && Math.min(d1, d2) > 1e-9;
+  const len2 = dist(a.a, a.b);
+  return Math.min(d1, d2) < tol * 2 + len2 * 0.05 && Math.min(d1, d2) > 1e-9;
 }
 function fixBreaks(faces, maxGapWidth) {
   if (faces.length === 0) return group([]);
@@ -3851,7 +4943,7 @@ function fixBrokenFaces(coverage, tolerance, polygonise = true) {
       out.push(p);
       continue;
     }
-    if (ring2.length >= 3 && same(ring2[0], ring2[ring2.length - 1], tol * 2)) {
+    if (ring2.length >= 3 && same2(ring2[0], ring2[ring2.length - 1], tol * 2)) {
       out.push(polygon(ring2.slice(0, -1)));
     } else if (ring2.length >= 3 && dist(ring2[0], ring2[ring2.length - 1]) <= tol * 2) {
       out.push(polygon(ring2));
@@ -3928,6 +5020,510 @@ var meshing = {
   findIslands
 };
 
-export { angular, area, areaGroup, areaMerge, areaSimilarity, assertAreaClose, boundingBox, bounds, buffer, centroid, centroidQuadrangulation, centroidSortFaces, centroidSplit, chaikinCut, circle, circleCenter, circleContainedInPath, circleOverlapsPath, circlePacking, circular, clipSegmentToPath, clipSegmentsToPath, cloneGroup, clonePath, cloneVec2, closestPoint, closestPointPair, closestVertex, complement, compoundVoronoi, construction, containmentAgreement, containsPoint, contour, conversion, convexHull, convexHullPath, copy, createArc, createCircle, createKochSnowflake, createRect, createRegularPolygon, createRing, createStar, delaunayTriangulation, delaunayTriangulationPoints, densify, dilationErosion, dissolve, dualFaces, earCutTriangulation, edgeCollapseQuadrangulation, envelope, equalsVec2, erosionDilation, extractBoundary, extractHoles, extractInnerEdges, extractInnerVertices, extractPerimeter, farthestPointPair, filterAxisAligned, filterByMinLength, findBreaks, findContainingFace, findIslands, fixBreaks, fixBrokenFaces, flatten, flipHorizontal, flipVertical, fromArray, fromContours, frontChainPack, gabrielFaces, generateRandomGridPoints, generateRandomPoints, group, groupFromPaths, hatch, cross as hatchCross, parallel as hatchParallel, hatchSubdivision, height, hexGrid, hexLatticePack, hexTiling, hilbert as hilbertPolygonise, hull, innerVoronoi, innerVoronoiRaw, intersect, intersectionPoints, largestEmptyCircle, largestEmptyCircles, matchingQuadrangulation, maxArea, maximumInscribedAARectangle, maximumInscribedCircle, maximumInscribedPack, maximumInscribedPackUntil, meshing, minArea, minPerimeter, minimumBoundingCircle, minkDifference, minkSum, morphology, normalizeRing, obstaclePack, occlusionSubtract, offsetCurvesInward, offsetCurvesOutward, onion, onionLayers, optimisation, oraclePathsToGroup, originScale, overlapRegions, parallelSegments, parsePathData, parseSvg, path, ring as pointRing, pointSet, pointsOnExterior, poisson, poissonTriangulation, poissonTriangulationPoints, polygon, polygonisation, horizontal as polygoniseHorizontal, vertical as polygoniseVertical, polyline, predicates, processing, prunePointsWithinDistance, quadSubdivision, radialSortFaces, radialWarp, random as randomPoints, rectSubdivision, reducePrecision, refine, relativeAreaError, relativeNeighborFaces, removeSmallHoles, repulsionPack, resizeByHeight, resizeByWidth, ringArea, ringsToPath, rotate, rotateAroundCenter, roundVertexCoords, scale, segment, segmentLength, segmentSet, segmentsOnExterior, segmentsToOpenPaths, serializePathData, shapeBoolean, shear, simplify, simplifyMesh, sineWarp, slice, sliceDivision, smooth, smoothMesh, spannerFaces, spiralQuadrangulation, splitEdges, splitQuadrangulation, squareGrid, squareLatticePack, squareGrid2 as squareTiling, stochasticMerge, stochasticPack, subdivideMesh, subtract, subtractAll, symDifference, tiling, toArray, toContours, toSvg, transformation, translate, translateCentroidTo, translateCornerTo, translateToOrigin, triangleSubdivision, triangulation, union, unionAll, urquhartFaces, vec2, voronoi, width };
+// src/construction/index.ts
+function createCircle(cx, cy, radius, segments = 64) {
+  return createRegularPolygon(cx, cy, radius, Math.max(3, Math.floor(segments)));
+}
+function createRect(x, y, width2, height2) {
+  return polygon([
+    { x, y },
+    { x: x + width2, y },
+    { x: x + width2, y: y + height2 },
+    { x, y: y + height2 }
+  ]);
+}
+function createRegularPolygon(cx, cy, radius, sides, rotation = -Math.PI / 2) {
+  const n = Math.max(3, Math.floor(sides));
+  const ring2 = [];
+  for (let i = 0; i < n; i++) {
+    const t = rotation + i / n * Math.PI * 2;
+    ring2.push({ x: cx + Math.cos(t) * radius, y: cy + Math.sin(t) * radius });
+  }
+  return polygon(ring2);
+}
+function createRing(cx, cy, outerRadius, innerRadius, segments = 64) {
+  const outer = createCircle(cx, cy, outerRadius, segments).rings[0];
+  const inner = createCircle(cx, cy, Math.min(innerRadius, outerRadius), segments).rings[0];
+  return path([outer, [...inner].reverse()], true);
+}
+function createArc(cx, cy, radius, startAngle, endAngle, segments = 32) {
+  const n = Math.max(2, Math.floor(segments));
+  const pts = [];
+  for (let i = 0; i <= n; i++) {
+    const t = startAngle + (endAngle - startAngle) * i / n;
+    pts.push({ x: cx + Math.cos(t) * radius, y: cy + Math.sin(t) * radius });
+  }
+  return polyline(pts);
+}
+function createStar(cx, cy, outerRadius, innerRadius, points = 5, rotation = -Math.PI / 2) {
+  const n = Math.max(3, Math.floor(points));
+  const ring2 = [];
+  for (let i = 0; i < n * 2; i++) {
+    const r = i % 2 === 0 ? outerRadius : innerRadius;
+    const t = rotation + i / (n * 2) * Math.PI * 2;
+    ring2.push({ x: cx + Math.cos(t) * r, y: cy + Math.sin(t) * r });
+  }
+  return polygon(ring2);
+}
+function createKochSnowflake(cx, cy, radius, iterations = 3) {
+  const tri = createRegularPolygon(cx, cy, radius, 3);
+  let ring2 = tri.rings[0];
+  const iters = Math.max(0, Math.min(6, Math.floor(iterations)));
+  for (let i = 0; i < iters; i++) {
+    ring2 = kochRefine(ring2);
+  }
+  return polygon(ring2);
+}
+function createSponge(width2, height2, generators, thickness, smoothing, classes, seed = 1) {
+  const w = Math.max(width2, 1e-9);
+  const h = Math.max(height2, 1e-9);
+  const nGen = Math.max(6, Math.floor(generators));
+  const nClasses = Math.max(1, Math.floor(classes));
+  const smoothIters = Math.max(0, Math.floor(smoothing));
+  const wall = Math.max(0, thickness);
+  const sites = randomInBox(nGen, 0, 0, w, h, seed);
+  const cells = compoundVoronoi(sites, {
+    bounds: { minX: 0, minY: 0, maxX: w, maxY: h }
+  });
+  const merged = stochasticMerge(cells.paths, nClasses, seed + 1);
+  const pores = [];
+  for (let p of merged.paths) {
+    if (smoothIters > 0) p = smooth(p, smoothIters);
+    if (wall > 1e-12) {
+      pores.push(...buffer(p, -wall * 0.5).paths);
+    } else {
+      pores.push(p);
+    }
+  }
+  const frame = createRect(0, 0, w, h);
+  if (pores.length === 0) return group([frame]);
+  return subtractAll(frame, pores);
+}
+function randomInBox(count, minX, minY, maxX, maxY, seed) {
+  const rng = mulberry326(seed >>> 0);
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    out.push({
+      x: minX + rng() * (maxX - minX),
+      y: minY + rng() * (maxY - minY)
+    });
+  }
+  return out;
+}
+function mulberry326(a) {
+  return function() {
+    let t = a += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function kochRefine(ring2) {
+  const out = [];
+  const n = ring2.length;
+  for (let i = 0; i < n; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % n];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const p1 = { x: a.x + dx / 3, y: a.y + dy / 3 };
+    const p2 = { x: a.x + 2 * dx / 3, y: a.y + 2 * dy / 3 };
+    const px = a.x + dx / 2 - dy * (Math.sqrt(3) / 6);
+    const py = a.y + dy / 2 + dx * (Math.sqrt(3) / 6);
+    out.push(a, p1, { x: px, y: py }, p2);
+  }
+  return out;
+}
+var construction = {
+  createCircle,
+  createRect,
+  createRegularPolygon,
+  createRing,
+  createArc,
+  createStar,
+  createKochSnowflake,
+  createSponge
+};
+
+// src/tiling/index.ts
+function squareGrid2(spacing, minX, minY, maxX, maxY) {
+  const s = Math.max(spacing, 1e-9);
+  const paths = [];
+  for (let x = minX; x < maxX - 1e-12; x += s) {
+    for (let y = minY; y < maxY - 1e-12; y += s) {
+      const w = Math.min(s, maxX - x);
+      const h = Math.min(s, maxY - y);
+      if (w > 1e-12 && h > 1e-12) paths.push(createRect(x, y, w, h));
+    }
+  }
+  return group(paths);
+}
+function hexTiling(spacing, minX, minY, maxX, maxY) {
+  const s = Math.max(spacing, 1e-9);
+  const r = s / 2;
+  const dx = s * 0.75;
+  const dy = s * Math.sqrt(3) * 0.5;
+  const paths = [];
+  let row = 0;
+  for (let y = minY + r; y <= maxY + r; y += dy, row++) {
+    const x0 = minX + r + (row % 2 === 0 ? 0 : dx * 0.5);
+    for (let x = x0; x <= maxX + r; x += dx) {
+      paths.push(hexagon(x, y, r));
+    }
+  }
+  return group(paths);
+}
+function hexagon(cx, cy, r) {
+  const ring2 = [];
+  for (let i = 0; i < 6; i++) {
+    const t = Math.PI / 180 * (60 * i - 30);
+    ring2.push({ x: cx + Math.cos(t) * r, y: cy + Math.sin(t) * r });
+  }
+  return polygon(ring2);
+}
+function rectSubdivision(p, nx, ny) {
+  const b = bounds(p);
+  const cols = Math.max(1, Math.floor(nx));
+  const rows = Math.max(1, Math.floor(ny));
+  const dw = (b.maxX - b.minX) / cols;
+  const dh = (b.maxY - b.minY) / rows;
+  const paths = [];
+  for (let i = 0; i < cols; i++) {
+    for (let j = 0; j < rows; j++) {
+      const cell = createRect(
+        b.minX + i * dw,
+        b.minY + j * dh,
+        dw,
+        dh
+      );
+      paths.push(...intersect(p, cell).paths);
+    }
+  }
+  return group(paths);
+}
+function quadSubdivision(faces, depth = 1) {
+  let cur = faces;
+  const d = Math.max(0, Math.floor(depth));
+  for (let i = 0; i < d; i++) {
+    const next = [];
+    for (const f of cur) {
+      next.push(...subdivideQuad(f));
+    }
+    cur = next;
+  }
+  return group(cur);
+}
+function subdivideQuad(p) {
+  const ring2 = p.rings[0];
+  if (!ring2 || ring2.length < 4) return [p];
+  const [a, b, c, d] = ring2;
+  if (!a || !b || !c || !d) return [p];
+  const mab = mid4(a, b);
+  const mbc = mid4(b, c);
+  const mcd = mid4(c, d);
+  const mda = mid4(d, a);
+  const cen = mid4(mid4(a, c), mid4(b, d));
+  return [
+    polygon([a, mab, cen, mda]),
+    polygon([mab, b, mbc, cen]),
+    polygon([cen, mbc, c, mcd]),
+    polygon([mda, cen, mcd, d])
+  ];
+}
+function triangleSubdivision(faces, depth = 1) {
+  let cur = faces;
+  const d = Math.max(0, Math.floor(depth));
+  for (let i = 0; i < d; i++) {
+    const next = [];
+    for (const f of cur) {
+      next.push(...subdivideTriangle(f));
+    }
+    cur = next;
+  }
+  return group(cur);
+}
+function subdivideTriangle(p) {
+  const ring2 = p.rings[0];
+  if (!ring2 || ring2.length < 3) return [p];
+  const a = ring2[0];
+  const b = ring2[1];
+  const c = ring2[2];
+  const mab = mid4(a, b);
+  const mbc = mid4(b, c);
+  const mca = mid4(c, a);
+  return [
+    polygon([a, mab, mca]),
+    polygon([mab, b, mbc]),
+    polygon([mca, mbc, c]),
+    polygon([mab, mbc, mca])
+  ];
+}
+function sliceDivision(p, spacing, angle = 0) {
+  const s = Math.max(spacing, 1e-9);
+  const b = bounds(p);
+  const cx = (b.minX + b.maxX) / 2;
+  const cy = (b.minY + b.maxY) / 2;
+  const diag = Math.hypot(b.maxX - b.minX, b.maxY - b.minY) + s;
+  const ux = Math.cos(angle);
+  const uy = Math.sin(angle);
+  const nx = -uy;
+  const ny = ux;
+  const parts = [p];
+  for (let t = -diag; t <= diag; t += s) {
+    const a = { x: cx + nx * t - ux * diag, y: cy + ny * t - uy * diag };
+    const bb = { x: cx + nx * t + ux * diag, y: cy + ny * t + uy * diag };
+    const next = [];
+    for (const piece of parts) {
+      const g = slice(piece, a, bb);
+      next.push(...g.paths.length ? g.paths : [piece]);
+    }
+    parts.length = 0;
+    parts.push(...next);
+  }
+  return group(parts);
+}
+function hatchSubdivision(p, spacing, angle = 0) {
+  return sliceDivision(p, spacing, angle);
+}
+function arcDivision(width2, height2, arcs, seed = 1, circlePoints = 64) {
+  const w = Math.max(width2, 1e-9);
+  const h = Math.max(height2, 1e-9);
+  const n = Math.max(0, Math.floor(arcs));
+  const segs = Math.max(8, Math.floor(circlePoints));
+  const rect = createRect(0, 0, w, h);
+  if (n === 0) return group([rect]);
+  const rng = mulberry327(seed >>> 0);
+  let faces = [rect];
+  const minArea2 = w * h * 1e-8;
+  for (let i = 0; i < n; i++) {
+    const { cx, cy, r } = sampleBoundaryCircle(w, h, rng);
+    const disk = createCircle(cx, cy, r, segs);
+    const next = [];
+    for (const face of faces) {
+      for (const piece of intersect(face, disk).paths) {
+        if (area(piece) > minArea2) next.push(piece);
+      }
+      for (const piece of subtract(face, disk).paths) {
+        if (area(piece) > minArea2) next.push(piece);
+      }
+    }
+    if (next.length > 0) faces = next;
+  }
+  return group(faces);
+}
+function sampleBoundaryCircle(w, h, rng) {
+  const peri = 2 * (w + h);
+  let t = rng() * peri;
+  let cx;
+  let cy;
+  let side;
+  if (t < w) {
+    side = 0;
+    cx = t;
+    cy = 0;
+  } else {
+    t -= w;
+    if (t < h) {
+      side = 1;
+      cx = w;
+      cy = t;
+    } else {
+      t -= h;
+      if (t < w) {
+        side = 2;
+        cx = w - t;
+        cy = h;
+      } else {
+        side = 3;
+        cx = 0;
+        cy = h - (t - w);
+      }
+    }
+  }
+  const distOther = [
+    cy,
+    // to top
+    w - cx,
+    // to right
+    h - cy,
+    // to bottom
+    cx
+    // to left
+  ];
+  let minSecond = Infinity;
+  for (let s = 0; s < 4; s++) {
+    if (s === side) continue;
+    minSecond = Math.min(minSecond, distOther[s]);
+  }
+  const maxR = Math.hypot(w, h);
+  const r = minSecond + rng() * Math.max(0, maxR - minSecond);
+  return { cx, cy, r: Math.max(r, minSecond + 1e-6) };
+}
+function mulberry327(a) {
+  return function() {
+    let t = a += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function mid4(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+var tiling = {
+  squareGrid: squareGrid2,
+  hexTiling,
+  rectSubdivision,
+  quadSubdivision,
+  triangleSubdivision,
+  sliceDivision,
+  hatchSubdivision,
+  arcDivision
+};
+
+// src/polygonisation/index.ts
+function maxArea(points) {
+  return convexHull(points);
+}
+function minArea(points) {
+  const hull2 = convexHull(points).rings[0] ?? [];
+  if (hull2.length < 3) return convexHull(points);
+  if (hull2.length === 3) return polygon(hull2);
+  let best = null;
+  let bestA = Infinity;
+  const h = hull2;
+  const n = h.length;
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      for (let k = j + 1; k < n; k++) {
+        const tri = polygon([h[i], h[j], h[k]]);
+        if (!coversPoints(tri, points)) continue;
+        const a = area(tri);
+        if (a < bestA) {
+          bestA = a;
+          best = tri;
+        }
+      }
+    }
+  }
+  return best ?? convexHull(points);
+}
+function minPerimeter(points) {
+  if (points.length === 0) return polygon([]);
+  if (points.length < 3) return polygon(points);
+  const remaining = points.map((p) => ({ ...p }));
+  const ordered = [remaining.shift()];
+  while (remaining.length) {
+    const last = ordered[ordered.length - 1];
+    let bestI = 0;
+    let bestD = Infinity;
+    for (let i = 0; i < remaining.length; i++) {
+      const d = Math.hypot(
+        remaining[i].x - last.x,
+        remaining[i].y - last.y
+      );
+      if (d < bestD) {
+        bestD = d;
+        bestI = i;
+      }
+    }
+    ordered.push(remaining.splice(bestI, 1)[0]);
+  }
+  return polygon(ordered);
+}
+function horizontal(points) {
+  const pts = [...points].sort(
+    (a, b) => a.y === b.y ? a.x - b.x : a.y - b.y
+  );
+  return polygon(pts);
+}
+function vertical(points) {
+  const pts = [...points].sort(
+    (a, b) => a.x === b.x ? a.y - b.y : a.x - b.x
+  );
+  return polygon(pts);
+}
+function angular(points) {
+  if (points.length === 0) return polygon([]);
+  const c = centroidOf(points);
+  const pts = [...points].sort(
+    (a, b) => Math.atan2(a.y - c.y, a.x - c.x) - Math.atan2(b.y - c.y, b.x - c.x)
+  );
+  return polygon(pts);
+}
+function circular(points) {
+  return angular(points);
+}
+function onion(points) {
+  const layers = onionLayers(points);
+  return layers[0] ?? polygon([]);
+}
+function onionLayers(points) {
+  let remaining = points.map((p) => ({ ...p }));
+  const layers = [];
+  while (remaining.length >= 3) {
+    const hull2 = convexHull(remaining);
+    const ring2 = hull2.rings[0] ?? [];
+    if (ring2.length < 3) break;
+    layers.push(hull2);
+    const onHull = new Set(ring2.map((v) => `${v.x},${v.y}`));
+    remaining = remaining.filter((p) => !onHull.has(`${p.x},${p.y}`));
+  }
+  return layers;
+}
+function hilbert(points) {
+  return polygon(hilbertSort(points));
+}
+function coversPoints(poly, points) {
+  const r = poly.rings[0];
+  if (!r || r.length < 3) return false;
+  const a = r[0];
+  const b = r[1];
+  const c = r[2];
+  for (const p of points) {
+    if (!pointInTriangle(p, a, b, c)) return false;
+  }
+  return true;
+}
+function pointInTriangle(p, a, b, c) {
+  const v0x = c.x - a.x;
+  const v0y = c.y - a.y;
+  const v1x = b.x - a.x;
+  const v1y = b.y - a.y;
+  const v2x = p.x - a.x;
+  const v2y = p.y - a.y;
+  const dot00 = v0x * v0x + v0y * v0y;
+  const dot01 = v0x * v1x + v0y * v1y;
+  const dot02 = v0x * v2x + v0y * v2y;
+  const dot11 = v1x * v1x + v1y * v1y;
+  const dot12 = v1x * v2x + v1y * v2y;
+  const inv = 1 / (dot00 * dot11 - dot01 * dot01 || 1e-18);
+  const u = (dot11 * dot02 - dot01 * dot12) * inv;
+  const v = (dot00 * dot12 - dot01 * dot02) * inv;
+  return u >= -1e-9 && v >= -1e-9 && u + v <= 1 + 1e-9;
+}
+function centroidOf(points) {
+  let sx = 0;
+  let sy = 0;
+  for (const p of points) {
+    sx += p.x;
+    sy += p.y;
+  }
+  return { x: sx / points.length, y: sy / points.length };
+}
+var polygonisation = {
+  maxArea,
+  minArea,
+  minPerimeter,
+  horizontal,
+  vertical,
+  angular,
+  circular,
+  onion,
+  onionLayers,
+  hilbert
+};
+
+export { angular, arcDivision, area, areaGroup, areaMerge, areaSimilarity, assertAreaClose, boundingBox, bounds, buffer, centerLine, centroid, centroidQuadrangulation, centroidSortFaces, centroidSplit, chaikinCut, chordalAxis, circle, circleCenter, circleContainedInPath, circleOverlapsPath, circlePacking, circular, clipSegmentToPath, clipSegmentsToPath, cloneGroup, clonePath, cloneVec2, closestPoint, closestPointPair, closestVertex, complement, compoundVoronoi, construction, containmentAgreement, containsPoint, contour, contrastField, conversion, convexHull, convexHullPath, copy, createArc, createCircle, createKochSnowflake, createRect, createRegularPolygon, createRing, createSponge, createStar, delaunayTriangulation, delaunayTriangulationPoints, densify, dilationErosion, dissolve, dissolveSegments, distanceField, distanceTree, dualFaces, earCutTriangulation, edgeCollapseQuadrangulation, envelope, equalsVec2, erosionDilation, extractBoundary, extractHoles, extractInnerEdges, extractInnerVertices, extractPerimeter, farthestPointPair, filterAxisAligned, filterByMinLength, findBreaks, findContainingFace, findIslands, findShortestTour, fixBreaks, fixBrokenFaces, flatten, flipHorizontal, flipVertical, fromArray, fromContours, frontChainPack, gabrielFaces, generateRandomGridPoints, generateRandomPoints, group, groupFromPaths, hatch, concentric as hatchConcentric, cross as hatchCross, parallel as hatchParallel, perpendicular as hatchPerpendicular, stochastic as hatchStochastic, hatchSubdivision, weave as hatchWeave, height, hexGrid, hexLatticePack, hexTiling, hilbert as hilbertPolygonise, hilbertSort, hull, innerVoronoi, innerVoronoiRaw, intersect, intersectionPoints, isolineZeroFromFunction, isolines, isolinesFromFunction, isolinesFromPoints, largestEmptyCircle, largestEmptyCircles, matchingQuadrangulation, maxArea, maximumInscribedAARectangle, maximumInscribedCircle, maximumInscribedPack, maximumInscribedPackUntil, medialAxis, meshing, minArea, minPerimeter, minimumBoundingCircle, minkDifference, minkSum, morphology, normalizeRing, obstaclePack, occlusionSubtract, offsetCurvesInward, offsetCurvesOutward, onion, onionLayers, optimisation, oraclePathsToGroup, originScale, overlapRegions, parallelSegments, parsePathData, parseSvg, path, perpendicularPathSegments, ring as pointRing, pointSet, pointsOnExterior, poisson, poissonTriangulation, poissonTriangulationPoints, polygon, polygonisation, horizontal as polygoniseHorizontal, vertical as polygoniseVertical, polyline, predicates, processing, prunePointsWithinDistance, quadSubdivision, radialSortFaces, radialWarp, random as randomPoints, rectSubdivision, reducePrecision, refine, relativeAreaError, relativeNeighborFaces, removeSmallHoles, repulsionPack, resizeByHeight, resizeByWidth, ringArea, ringsToPath, rotate, rotateAroundCenter, roundVertexCoords, scale, segment, segmentLength, segmentSet, segmentsOnExterior, segmentsToOpenPaths, serializePathData, shapeBoolean, shear, simplify, simplifyMesh, sineWarp, slice, sliceDivision, smooth, smoothMesh, spannerFaces, spiralQuadrangulation, splitEdges, splitQuadrangulation, squareGrid, squareLatticePack, squareGrid2 as squareTiling, stochasticMerge, stochasticPack, stochasticSegments, straightSkeleton, straightSkeletonParts, subdivideMesh, subtract, subtractAll, symDifference, tiling, toArray, toContours, toSvg, transformation, translate, translateCentroidTo, translateCornerTo, translateToOrigin, triangleSubdivision, triangulation, union, unionAll, urquhartFaces, vec2, voronoi, weaveSegments, width };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map