pattapatta 0.3.0 → 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) {
@@ -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;
@@ -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,9 +2112,62 @@ var conversion = {
   group
 };
 
+// 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));
+  }
+  return d;
+}
+function rot(n, x, y, rx, ry) {
+  if (ry === 0) {
+    if (rx === 1) {
+      x = n - 1 - x;
+      y = n - 1 - y;
+    }
+    return { x: y, y: x };
+  }
+  return { x, y };
+}
+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) {
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x);
+    maxY = Math.max(maxY, p.y);
+  }
+  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({
@@ -1809,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);
@@ -1818,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;
@@ -1889,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
@@ -3428,640 +3905,398 @@ var voronoi = {
   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 }
-  ]);
+// 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 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 vertKey(v) {
+  return `${v.x},${v.y}`;
 }
-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 same2(a, b, eps = 1e-12) {
+  return Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps;
 }
-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 dist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
 }
-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 mid3(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
 }
-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 lerp(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
 }
-function kochRefine(ring2) {
+function unique(points) {
+  const seen = /* @__PURE__ */ new Set();
   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 (const p of points) {
+    const k = vertKey(p);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push({ ...p });
   }
   return out;
 }
-var construction = {
-  createCircle,
-  createRect,
-  createRegularPolygon,
-  createRing,
-  createArc,
-  createStar,
-  createKochSnowflake
-};
-
-// 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 cross3(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
 }
-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));
+function ringOf(face) {
+  return face.rings[0] ?? [];
+}
+function buildEdgeMap(faces) {
+  const edges = /* @__PURE__ */ new Map();
+  faces.forEach((f, fi) => {
+    const ring2 = ringOf(f);
+    if (ring2.length < 2) return;
+    const n = ring2.length;
+    const closed = f.closed !== false && n >= 3;
+    const lim = closed ? n : n - 1;
+    for (let i = 0; i < lim; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      const key4 = edgeKey3(a, b);
+      const rec = edges.get(key4);
+      if (rec) rec.faceIds.push(fi);
+      else edges.set(key4, { a: { ...a }, b: { ...b }, faceIds: [fi] });
     }
-  }
-  return group(paths);
+  });
+  return edges;
 }
-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 });
+function perimeterKeys(edgeMap) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [k, e] of edgeMap) {
+    if (e.faceIds.length === 1) out.add(k);
   }
-  return polygon(ring2);
+  return out;
 }
-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 faceAdjacency(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const adj = faces.map(() => []);
+  for (const e of edgeMap.values()) {
+    if (e.faceIds.length === 2) {
+      const [i, j] = e.faceIds;
+      adj[i].push(j);
+      adj[j].push(i);
     }
   }
-  return group(paths);
+  return adj;
 }
-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 sitesFromFaces(faces) {
+  return unique(faces.flatMap((f) => ringOf(f)));
+}
+function facesFromKeptEdges(tris, kept) {
+  if (tris.length === 0) return [];
+  const parent = tris.map((_, i) => i);
+  const find = (i) => {
+    let x = i;
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  const unite = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[rb] = ra;
+  };
+  const edgeMap = buildEdgeMap(tris);
+  for (const [key4, e] of edgeMap) {
+    if (e.faceIds.length === 2 && !kept.has(key4)) {
+      unite(e.faceIds[0], e.faceIds[1]);
     }
-    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 = mid3(a, b);
-  const mbc = mid3(b, c);
-  const mcd = mid3(c, d);
-  const mda = mid3(d, a);
-  const cen = mid3(mid3(a, c), mid3(b, d));
-  return [
-    polygon([a, mab, cen, mda]),
-    polygon([mab, b, mbc, cen]),
-    polygon([cen, mbc, c, mcd]),
-    polygon([mda, cen, mcd, d])
-  ];
+  const components = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tris.length; i++) {
+    const r = find(i);
+    const list = components.get(r) ?? [];
+    list.push(i);
+    components.set(r, list);
+  }
+  const out = [];
+  for (const members of components.values()) {
+    const ring2 = boundaryRingOfComponent(tris, members);
+    if (ring2 && ring2.length >= 3) out.push(polygon(ring2));
+  }
+  return out;
 }
-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));
+function boundaryRingOfComponent(tris, members) {
+  const edgeCount = /* @__PURE__ */ new Map();
+  for (const fi of members) {
+    const ring2 = ringOf(tris[fi]);
+    if (ring2.length < 3) continue;
+    for (let i = 0; i < ring2.length; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % ring2.length];
+      const key4 = edgeKey3(a, b);
+      const rec = edgeCount.get(key4);
+      if (rec) rec.n++;
+      else edgeCount.set(key4, { a: { ...a }, b: { ...b }, n: 1 });
     }
-    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 = mid3(a, b);
-  const mbc = mid3(b, c);
-  const mca = mid3(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);
+  const boundary = [];
+  for (const e of edgeCount.values()) {
+    if (e.n === 1) boundary.push({ a: e.a, b: e.b });
   }
-  return group(parts);
-}
-function hatchSubdivision(p, spacing, angle = 0) {
-  return sliceDivision(p, spacing, angle);
-}
-function mid3(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
-};
-
-// src/polygonisation/index.ts
-function maxArea(points) {
-  return convexHull(points);
+  if (boundary.length < 3) return null;
+  return orderEdgesIntoRing(boundary);
 }
-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;
-        }
+function orderEdgesIntoRing(edges) {
+  if (edges.length === 0) return null;
+  const adj = /* @__PURE__ */ new Map();
+  const add = (from, to) => {
+    const k = vertKey(from);
+    const list = adj.get(k) ?? [];
+    list.push(to);
+    adj.set(k, list);
+  };
+  for (const e of edges) {
+    add(e.a, e.b);
+    add(e.b, e.a);
+  }
+  const start = edges[0].a;
+  const ring2 = [{ ...start }];
+  let prev = start;
+  let curr = edges[0].b;
+  const maxSteps = edges.length + 2;
+  for (let step = 0; step < maxSteps; step++) {
+    ring2.push({ ...curr });
+    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 (!same2(n, prev)) {
+        next = n;
+        break;
       }
     }
+    if (!next) break;
+    prev = curr;
+    curr = next;
   }
-  return best ?? convexHull(points);
+  return ring2.length >= 3 ? ring2 : null;
 }
-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;
-      }
+function applyEdgeFilter(tris, shouldKeep, preservePerimeter) {
+  const edgeMap = buildEdgeMap(tris);
+  const peri = perimeterKeys(edgeMap);
+  const kept = /* @__PURE__ */ new Set();
+  for (const [key4, e] of edgeMap) {
+    const isPeri = peri.has(key4);
+    if (isPeri && preservePerimeter) {
+      kept.add(key4);
+      continue;
     }
-    ordered.push(remaining.splice(bestI, 1)[0]);
+    if (shouldKeep(e.a, e.b, isPeri)) kept.add(key4);
   }
-  return polygon(ordered);
+  return facesFromKeptEdges(tris, kept);
 }
-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 asTriFaces(input) {
+  if (input.length === 0) return [];
+  const first = input[0];
+  if ("rings" in first) return input;
+  return delaunayTriangulationPoints(input);
 }
-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 pointsOf(input) {
+  if (input.length === 0) return [];
+  const first = input[0];
+  if ("rings" in first) return sitesFromFaces(input);
+  return input;
 }
-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 extractInnerEdges(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const out = [];
+  for (const e of edgeMap.values()) {
+    if (e.faceIds.length >= 2) out.push(segment(e.a, e.b));
+  }
+  return out;
 }
-function circular(points) {
-  return angular(points);
+function extractInnerVertices(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const peri = perimeterKeys(edgeMap);
+  const periVerts = /* @__PURE__ */ new Set();
+  for (const key4 of peri) {
+    const e = edgeMap.get(key4);
+    periVerts.add(vertKey(e.a));
+    periVerts.add(vertKey(e.b));
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of faces) {
+    for (const v of ringOf(f)) {
+      const k = vertKey(v);
+      if (periVerts.has(k) || seen.has(k)) continue;
+      seen.add(k);
+      out.push({ ...v });
+    }
+  }
+  return out;
 }
-function onion(points) {
-  const layers = onionLayers(points);
-  return layers[0] ?? polygon([]);
+function findContainingFace(faces, point) {
+  for (const f of faces) {
+    if (containsPoint(f, point)) return f;
+  }
+  return null;
 }
-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 splitEdges(faces, maxLen) {
+  const lim = Math.max(maxLen, 1e-9);
+  const out = [];
+  for (const f of faces) {
+    out.push(
+      polygon(
+        densifyRing2(ringOf(f), lim),
+        f.rings.slice(1).map((r) => densifyRing2(r, lim))
+      )
+    );
   }
-  return layers;
+  return group(out);
 }
-function hilbert(points) {
-  if (points.length === 0) return polygon([]);
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
+function densifyRing2(ring2, maxLen) {
+  if (ring2.length < 2) return ring2.map((v) => ({ ...v }));
+  const out = [];
+  const n = ring2.length;
+  for (let i = 0; i < n; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % n];
+    out.push({ ...a });
+    const d = dist(a, b);
+    const steps = Math.floor(d / maxLen);
+    for (let s = 1; s < steps; s++) out.push(lerp(a, b, s / steps));
+  }
+  return out;
+}
+function isGabriel(a, b, points) {
+  const m = mid3(a, b);
+  const r = dist(a, b) / 2;
   for (const p of points) {
-    minX = Math.min(minX, p.x);
-    minY = Math.min(minY, p.y);
-    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));
-}
-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;
+    if (same2(p, a) || same2(p, b)) continue;
+    if (dist(p, m) < r - 1e-9) 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;
+function isRelativeNeighbor(a, b, points) {
+  const dab = dist(a, b);
   for (const p of points) {
-    sx += p.x;
-    sy += p.y;
-  }
-  return { x: sx / points.length, y: sy / points.length };
-}
-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));
+    if (same2(p, a) || same2(p, b)) continue;
+    if (Math.max(dist(p, a), dist(p, b)) < dab - 1e-9) return false;
   }
-  return d;
+  return true;
 }
-function rot(n, x, y, rx, ry) {
-  if (ry === 0) {
-    if (rx === 1) {
-      x = n - 1 - x;
-      y = n - 1 - y;
+function urquhartFaces(input, preservePerimeter = false) {
+  const tris = asTriFaces(input);
+  const edgeMap = buildEdgeMap(tris);
+  const peri = perimeterKeys(edgeMap);
+  const removed = /* @__PURE__ */ new Set();
+  for (const t of tris) {
+    const r = ringOf(t);
+    if (r.length < 3) continue;
+    let longestKey = "";
+    let longestLen = -1;
+    for (let i = 0; i < 3; i++) {
+      const a = r[i];
+      const b = r[(i + 1) % 3];
+      const d = dist(a, b);
+      if (d > longestLen) {
+        longestLen = d;
+        longestKey = edgeKey3(a, b);
+      }
+    }
+    if (longestKey && !(preservePerimeter && peri.has(longestKey))) {
+      removed.add(longestKey);
     }
-    return { x: y, y: x };
   }
-  return { x, y };
-}
-var polygonisation = {
-  maxArea,
-  minArea,
-  minPerimeter,
-  horizontal,
-  vertical,
-  angular,
-  circular,
-  onion,
-  onionLayers,
-  hilbert
-};
-
-// 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 mid4(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 });
+  const kept = /* @__PURE__ */ new Set();
+  for (const key4 of edgeMap.keys()) {
+    if (!removed.has(key4)) kept.add(key4);
   }
-  return out;
+  return group(facesFromKeptEdges(tris, kept));
 }
-function cross3(o, a, b) {
-  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+function gabrielFaces(input, preservePerimeter = false) {
+  const tris = asTriFaces(input);
+  const pts = pointsOf(input);
+  return group(
+    applyEdgeFilter(
+      tris,
+      (a, b) => isGabriel(a, b, pts),
+      preservePerimeter
+    )
+  );
 }
-function ringOf(face) {
-  return face.rings[0] ?? [];
+function relativeNeighborFaces(input, preservePerimeter = false) {
+  const tris = asTriFaces(input);
+  const pts = pointsOf(input);
+  return group(
+    applyEdgeFilter(
+      tris,
+      (a, b) => isRelativeNeighbor(a, b, pts),
+      preservePerimeter
+    )
+  );
 }
-function buildEdgeMap(faces) {
-  const edges = /* @__PURE__ */ new Map();
-  faces.forEach((f, fi) => {
-    const ring2 = ringOf(f);
-    if (ring2.length < 2) return;
-    const n = ring2.length;
-    const closed = f.closed !== false && n >= 3;
-    const lim = closed ? n : n - 1;
-    for (let i = 0; i < lim; i++) {
-      const a = ring2[i];
-      const b = ring2[(i + 1) % n];
-      const key4 = edgeKey3(a, b);
-      const rec = edges.get(key4);
-      if (rec) rec.faceIds.push(fi);
-      else edges.set(key4, { a: { ...a }, b: { ...b }, faceIds: [fi] });
+function spannerFaces(input, k = 1, preservePerimeter = false) {
+  const tris = asTriFaces(input);
+  const edgeMap = buildEdgeMap(tris);
+  const peri = perimeterKeys(edgeMap);
+  const stretch = Math.max(1, k);
+  const edges = [...edgeMap.entries()].map(([key4, e]) => ({
+    key: key4,
+    a: e.a,
+    b: e.b,
+    len: dist(e.a, e.b),
+    peri: peri.has(key4)
+  }));
+  edges.sort((a, b) => a.len - b.len);
+  const adj = /* @__PURE__ */ new Map();
+  const link = (a, b, w) => {
+    const ka = vertKey(a);
+    const kb = vertKey(b);
+    if (!adj.has(ka)) adj.set(ka, []);
+    if (!adj.has(kb)) adj.set(kb, []);
+    adj.get(ka).push({ to: kb, w });
+    adj.get(kb).push({ to: ka, w });
+  };
+  const shortest = (from, to) => {
+    const start = vertKey(from);
+    const goal = vertKey(to);
+    const distMap = /* @__PURE__ */ new Map([[start, 0]]);
+    const pq = [{ k: start, d: 0 }];
+    while (pq.length) {
+      pq.sort((x, y) => x.d - y.d);
+      const cur = pq.shift();
+      if (cur.k === goal) return cur.d;
+      if (cur.d > (distMap.get(cur.k) ?? Infinity)) continue;
+      for (const e of adj.get(cur.k) ?? []) {
+        const nd = cur.d + e.w;
+        if (nd < (distMap.get(e.to) ?? Infinity)) {
+          distMap.set(e.to, nd);
+          pq.push({ k: e.to, d: nd });
+        }
+      }
     }
-  });
-  return edges;
-}
-function perimeterKeys(edgeMap) {
-  const out = /* @__PURE__ */ new Set();
-  for (const [k, e] of edgeMap) {
-    if (e.faceIds.length === 1) out.add(k);
-  }
-  return out;
-}
-function faceAdjacency(faces) {
-  const edgeMap = buildEdgeMap(faces);
-  const adj = faces.map(() => []);
-  for (const e of edgeMap.values()) {
-    if (e.faceIds.length === 2) {
-      const [i, j] = e.faceIds;
-      adj[i].push(j);
-      adj[j].push(i);
+    return Infinity;
+  };
+  const kept = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (e.peri && preservePerimeter) {
+      kept.add(e.key);
+      link(e.a, e.b, e.len);
+      continue;
+    }
+    const pathLen = shortest(e.a, e.b);
+    if (pathLen > stretch * e.len + 1e-9) {
+      kept.add(e.key);
+      link(e.a, e.b, e.len);
+    } else if (e.peri) {
+      kept.add(e.key);
+      link(e.a, e.b, e.len);
     }
   }
-  return adj;
-}
-function sitesFromFaces(faces) {
-  return unique(faces.flatMap((f) => ringOf(f)));
+  return group(facesFromKeptEdges(tris, kept));
 }
-function facesFromKeptEdges(tris, kept) {
-  if (tris.length === 0) return [];
-  const parent = tris.map((_, i) => i);
-  const find = (i) => {
-    let x = i;
-    while (parent[x] !== x) {
-      parent[x] = parent[parent[x]];
-      x = parent[x];
-    }
-    return x;
-  };
-  const unite = (a, b) => {
-    const ra = find(a);
-    const rb = find(b);
-    if (ra !== rb) parent[rb] = ra;
-  };
-  const edgeMap = buildEdgeMap(tris);
-  for (const [key4, e] of edgeMap) {
-    if (e.faceIds.length === 2 && !kept.has(key4)) {
-      unite(e.faceIds[0], e.faceIds[1]);
-    }
-  }
-  const components = /* @__PURE__ */ new Map();
-  for (let i = 0; i < tris.length; i++) {
-    const r = find(i);
-    const list = components.get(r) ?? [];
-    list.push(i);
-    components.set(r, list);
-  }
-  const out = [];
-  for (const members of components.values()) {
-    const ring2 = boundaryRingOfComponent(tris, members);
-    if (ring2 && ring2.length >= 3) out.push(polygon(ring2));
-  }
-  return out;
-}
-function boundaryRingOfComponent(tris, members) {
-  const edgeCount = /* @__PURE__ */ new Map();
-  for (const fi of members) {
-    const ring2 = ringOf(tris[fi]);
-    if (ring2.length < 3) continue;
-    for (let i = 0; i < ring2.length; i++) {
-      const a = ring2[i];
-      const b = ring2[(i + 1) % ring2.length];
-      const key4 = edgeKey3(a, b);
-      const rec = edgeCount.get(key4);
-      if (rec) rec.n++;
-      else edgeCount.set(key4, { a: { ...a }, b: { ...b }, n: 1 });
-    }
-  }
-  const boundary = [];
-  for (const e of edgeCount.values()) {
-    if (e.n === 1) boundary.push({ a: e.a, b: e.b });
-  }
-  if (boundary.length < 3) return null;
-  return orderEdgesIntoRing(boundary);
-}
-function orderEdgesIntoRing(edges) {
-  if (edges.length === 0) return null;
-  const adj = /* @__PURE__ */ new Map();
-  const add = (from, to) => {
-    const k = vertKey(from);
-    const list = adj.get(k) ?? [];
-    list.push(to);
-    adj.set(k, list);
-  };
-  for (const e of edges) {
-    add(e.a, e.b);
-    add(e.b, e.a);
-  }
-  const start = edges[0].a;
-  const ring2 = [{ ...start }];
-  let prev = start;
-  let curr = edges[0].b;
-  const maxSteps = edges.length + 2;
-  for (let step = 0; step < maxSteps; step++) {
-    ring2.push({ ...curr });
-    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 (!same2(n, prev)) {
-        next = n;
-        break;
-      }
-    }
-    if (!next) break;
-    prev = curr;
-    curr = next;
-  }
-  return ring2.length >= 3 ? ring2 : null;
-}
-function applyEdgeFilter(tris, shouldKeep, preservePerimeter) {
-  const edgeMap = buildEdgeMap(tris);
-  const peri = perimeterKeys(edgeMap);
-  const kept = /* @__PURE__ */ new Set();
-  for (const [key4, e] of edgeMap) {
-    const isPeri = peri.has(key4);
-    if (isPeri && preservePerimeter) {
-      kept.add(key4);
-      continue;
-    }
-    if (shouldKeep(e.a, e.b, isPeri)) kept.add(key4);
-  }
-  return facesFromKeptEdges(tris, kept);
-}
-function asTriFaces(input) {
-  if (input.length === 0) return [];
-  const first = input[0];
-  if ("rings" in first) return input;
-  return delaunayTriangulationPoints(input);
-}
-function pointsOf(input) {
-  if (input.length === 0) return [];
-  const first = input[0];
-  if ("rings" in first) return sitesFromFaces(input);
-  return input;
-}
-function extractInnerEdges(faces) {
-  const edgeMap = buildEdgeMap(faces);
-  const out = [];
-  for (const e of edgeMap.values()) {
-    if (e.faceIds.length >= 2) out.push(segment(e.a, e.b));
-  }
-  return out;
-}
-function extractInnerVertices(faces) {
+function dualFaces(faces) {
+  if (faces.length === 0) return group([]);
   const edgeMap = buildEdgeMap(faces);
   const peri = perimeterKeys(edgeMap);
   const periVerts = /* @__PURE__ */ new Set();
@@ -4070,246 +4305,63 @@ function extractInnerVertices(faces) {
     periVerts.add(vertKey(e.a));
     periVerts.add(vertKey(e.b));
   }
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const f of faces) {
+  const incident = /* @__PURE__ */ new Map();
+  faces.forEach((f, fi) => {
+    const c = centroid(f);
     for (const v of ringOf(f)) {
       const k = vertKey(v);
-      if (periVerts.has(k) || seen.has(k)) continue;
-      seen.add(k);
-      out.push({ ...v });
+      if (periVerts.has(k)) continue;
+      const list = incident.get(k) ?? [];
+      list.push({ fi, ang: Math.atan2(c.y - v.y, c.x - v.x), v });
+      incident.set(k, list);
     }
-  }
-  return out;
-}
-function findContainingFace(faces, point) {
-  for (const f of faces) {
-    if (containsPoint(f, point)) return f;
-  }
-  return null;
-}
-function splitEdges(faces, maxLen) {
-  const lim = Math.max(maxLen, 1e-9);
+  });
   const out = [];
-  for (const f of faces) {
-    out.push(
-      polygon(
-        densifyRing2(ringOf(f), lim),
-        f.rings.slice(1).map((r) => densifyRing2(r, lim))
-      )
-    );
+  for (const list of incident.values()) {
+    if (list.length < 3) continue;
+    const byFace = /* @__PURE__ */ new Map();
+    for (const item of list) byFace.set(item.fi, item);
+    const uniqueList = [...byFace.values()];
+    if (uniqueList.length < 3) continue;
+    uniqueList.sort((a, b) => a.ang - b.ang);
+    const ring2 = uniqueList.map((item) => centroid(faces[item.fi]));
+    out.push(polygon(ring2));
   }
   return group(out);
 }
-function densifyRing2(ring2, maxLen) {
-  if (ring2.length < 2) return ring2.map((v) => ({ ...v }));
-  const out = [];
-  const n = ring2.length;
-  for (let i = 0; i < n; i++) {
-    const a = ring2[i];
-    const b = ring2[(i + 1) % n];
-    out.push({ ...a });
-    const d = dist(a, b);
-    const steps = Math.floor(d / maxLen);
-    for (let s = 1; s < steps; s++) out.push(lerp(a, b, s / steps));
-  }
-  return out;
-}
-function isGabriel(a, b, points) {
-  const m = mid4(a, b);
-  const r = dist(a, b) / 2;
-  for (const p of points) {
-    if (same2(p, a) || same2(p, b)) continue;
-    if (dist(p, m) < r - 1e-9) return false;
-  }
-  return true;
+function triVerts(t) {
+  const r = ringOf(t);
+  if (r.length < 3) return null;
+  return [r[0], r[1], r[2]];
 }
-function isRelativeNeighbor(a, b, points) {
-  const dab = dist(a, b);
-  for (const p of points) {
-    if (same2(p, a) || same2(p, b)) continue;
-    if (Math.max(dist(p, a), dist(p, b)) < dab - 1e-9) return false;
+function midpointMap(faces) {
+  const mids = /* @__PURE__ */ new Map();
+  const edgeMap = buildEdgeMap(faces);
+  for (const [key4, e] of edgeMap) {
+    mids.set(key4, mid3(e.a, e.b));
   }
-  return true;
+  return mids;
 }
-function urquhartFaces(input, preservePerimeter = false) {
+function centroidQuadrangulation(input, preservePerimeter = true) {
   const tris = asTriFaces(input);
   const edgeMap = buildEdgeMap(tris);
+  const centers = tris.map((t) => centroid(t));
+  const out = [];
   const peri = perimeterKeys(edgeMap);
-  const removed = /* @__PURE__ */ new Set();
-  for (const t of tris) {
-    const r = ringOf(t);
-    if (r.length < 3) continue;
-    let longestKey = "";
-    let longestLen = -1;
-    for (let i = 0; i < 3; i++) {
-      const a = r[i];
-      const b = r[(i + 1) % 3];
-      const d = dist(a, b);
-      if (d > longestLen) {
-        longestLen = d;
-        longestKey = edgeKey3(a, b);
-      }
-    }
-    if (longestKey && !(preservePerimeter && peri.has(longestKey))) {
-      removed.add(longestKey);
-    }
-  }
-  const kept = /* @__PURE__ */ new Set();
-  for (const key4 of edgeMap.keys()) {
-    if (!removed.has(key4)) kept.add(key4);
+  for (const [key4, e] of edgeMap) {
+    const ids = e.faceIds;
+    if (ids.length === 2) {
+      const c0 = centers[ids[0]];
+      const c1 = centers[ids[1]];
+      out.push(polygon([e.a, c0, e.b, c1]));
+    } 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(key4)) ;
   }
-  return group(facesFromKeptEdges(tris, kept));
+  return group(out);
 }
-function gabrielFaces(input, preservePerimeter = false) {
-  const tris = asTriFaces(input);
-  const pts = pointsOf(input);
-  return group(
-    applyEdgeFilter(
-      tris,
-      (a, b) => isGabriel(a, b, pts),
-      preservePerimeter
-    )
-  );
-}
-function relativeNeighborFaces(input, preservePerimeter = false) {
-  const tris = asTriFaces(input);
-  const pts = pointsOf(input);
-  return group(
-    applyEdgeFilter(
-      tris,
-      (a, b) => isRelativeNeighbor(a, b, pts),
-      preservePerimeter
-    )
-  );
-}
-function spannerFaces(input, k = 1, preservePerimeter = false) {
-  const tris = asTriFaces(input);
-  const edgeMap = buildEdgeMap(tris);
-  const peri = perimeterKeys(edgeMap);
-  const stretch = Math.max(1, k);
-  const edges = [...edgeMap.entries()].map(([key4, e]) => ({
-    key: key4,
-    a: e.a,
-    b: e.b,
-    len: dist(e.a, e.b),
-    peri: peri.has(key4)
-  }));
-  edges.sort((a, b) => a.len - b.len);
-  const adj = /* @__PURE__ */ new Map();
-  const link = (a, b, w) => {
-    const ka = vertKey(a);
-    const kb = vertKey(b);
-    if (!adj.has(ka)) adj.set(ka, []);
-    if (!adj.has(kb)) adj.set(kb, []);
-    adj.get(ka).push({ to: kb, w });
-    adj.get(kb).push({ to: ka, w });
-  };
-  const shortest = (from, to) => {
-    const start = vertKey(from);
-    const goal = vertKey(to);
-    const distMap = /* @__PURE__ */ new Map([[start, 0]]);
-    const pq = [{ k: start, d: 0 }];
-    while (pq.length) {
-      pq.sort((x, y) => x.d - y.d);
-      const cur = pq.shift();
-      if (cur.k === goal) return cur.d;
-      if (cur.d > (distMap.get(cur.k) ?? Infinity)) continue;
-      for (const e of adj.get(cur.k) ?? []) {
-        const nd = cur.d + e.w;
-        if (nd < (distMap.get(e.to) ?? Infinity)) {
-          distMap.set(e.to, nd);
-          pq.push({ k: e.to, d: nd });
-        }
-      }
-    }
-    return Infinity;
-  };
-  const kept = /* @__PURE__ */ new Set();
-  for (const e of edges) {
-    if (e.peri && preservePerimeter) {
-      kept.add(e.key);
-      link(e.a, e.b, e.len);
-      continue;
-    }
-    const pathLen = shortest(e.a, e.b);
-    if (pathLen > stretch * e.len + 1e-9) {
-      kept.add(e.key);
-      link(e.a, e.b, e.len);
-    } else if (e.peri) {
-      kept.add(e.key);
-      link(e.a, e.b, e.len);
-    }
-  }
-  return group(facesFromKeptEdges(tris, kept));
-}
-function dualFaces(faces) {
-  if (faces.length === 0) return group([]);
-  const edgeMap = buildEdgeMap(faces);
-  const peri = perimeterKeys(edgeMap);
-  const periVerts = /* @__PURE__ */ new Set();
-  for (const key4 of peri) {
-    const e = edgeMap.get(key4);
-    periVerts.add(vertKey(e.a));
-    periVerts.add(vertKey(e.b));
-  }
-  const incident = /* @__PURE__ */ new Map();
-  faces.forEach((f, fi) => {
-    const c = centroid(f);
-    for (const v of ringOf(f)) {
-      const k = vertKey(v);
-      if (periVerts.has(k)) continue;
-      const list = incident.get(k) ?? [];
-      list.push({ fi, ang: Math.atan2(c.y - v.y, c.x - v.x), v });
-      incident.set(k, list);
-    }
-  });
-  const out = [];
-  for (const list of incident.values()) {
-    if (list.length < 3) continue;
-    const byFace = /* @__PURE__ */ new Map();
-    for (const item of list) byFace.set(item.fi, item);
-    const uniqueList = [...byFace.values()];
-    if (uniqueList.length < 3) continue;
-    uniqueList.sort((a, b) => a.ang - b.ang);
-    const ring2 = uniqueList.map((item) => centroid(faces[item.fi]));
-    out.push(polygon(ring2));
-  }
-  return group(out);
-}
-function triVerts(t) {
-  const r = ringOf(t);
-  if (r.length < 3) return null;
-  return [r[0], r[1], r[2]];
-}
-function midpointMap(faces) {
-  const mids = /* @__PURE__ */ new Map();
-  const edgeMap = buildEdgeMap(faces);
-  for (const [key4, e] of edgeMap) {
-    mids.set(key4, mid4(e.a, e.b));
-  }
-  return mids;
-}
-function centroidQuadrangulation(input, preservePerimeter = true) {
-  const tris = asTriFaces(input);
-  const edgeMap = buildEdgeMap(tris);
-  const centers = tris.map((t) => centroid(t));
-  const out = [];
-  const peri = perimeterKeys(edgeMap);
-  for (const [key4, e] of edgeMap) {
-    const ids = e.faceIds;
-    if (ids.length === 2) {
-      const c0 = centers[ids[0]];
-      const c1 = centers[ids[1]];
-      out.push(polygon([e.a, c0, e.b, c1]));
-    } 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(key4)) ;
-  }
-  return group(out);
-}
-function splitQuadrangulation(input) {
+function splitQuadrangulation(input) {
   const tris = asTriFaces(input);
   const mids = midpointMap(tris);
   const out = [];
@@ -4318,9 +4370,9 @@ function splitQuadrangulation(input) {
     if (!v) continue;
     const [a, b, c] = v;
     const g = centroid(t);
-    const mab = mids.get(edgeKey3(a, b)) ?? mid4(a, b);
-    const mbc = mids.get(edgeKey3(b, c)) ?? mid4(b, c);
-    const mca = mids.get(edgeKey3(c, a)) ?? mid4(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]));
@@ -4503,471 +4555,975 @@ function smoothMesh(faces, iterationsOrCutoff, preservePerimeter = true) {
     positions = next;
     if (cutoff > 0 && maxDisp < cutoff) break;
   }
-  return group(remapFaces(faces, positions));
+  return group(remapFaces(faces, positions));
+}
+function subdivideMesh(faces, edgeSplitRatio = 0.5) {
+  const t = Math.min(1, Math.max(0, edgeSplitRatio));
+  const out = [];
+  for (const f of faces) {
+    const ring2 = ringOf(f);
+    if (ring2.length < 3) continue;
+    const c = centroid(f);
+    const n = ring2.length;
+    const splits = [];
+    for (let i = 0; i < n; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      splits.push(lerp(a, b, t));
+    }
+    for (let i = 0; i < n; i++) {
+      const v = ring2[i];
+      const sPrev = splits[(i - 1 + n) % n];
+      const sNext = splits[i];
+      out.push(polygon([v, sNext, c, sPrev]));
+    }
+  }
+  return group(out);
+}
+function simplifyMesh(faces, tolerance, preservePerimeter = true) {
+  if (tolerance <= 0 || faces.length === 0) return group(faces.map((f) => polygon(ringOf(f), f.rings.slice(1))));
+  const edgeMap = buildEdgeMap(faces);
+  const peri = perimeterKeys(edgeMap);
+  const simplified = faces.map((f) => {
+    const ring2 = ringOf(f);
+    if (ring2.length <= 3) return polygon(ring2);
+    if (preservePerimeter) {
+      const s = simplify(f, tolerance);
+      const sr = ringOf(s);
+      if (sr.length < 3) return polygon(ring2);
+      return polygon(sr, s.rings.slice(1));
+    }
+    return simplify(f, tolerance);
+  });
+  const all = unique(simplified.flatMap((f) => ringOf(f)));
+  const snapped = clusterSnap(all, Math.max(tolerance * 0.5, 1e-9));
+  const remap = (v) => {
+    let best = v;
+    let bestD = Infinity;
+    for (const s of snapped) {
+      const d = dist(v, s);
+      if (d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    return { ...best };
+  };
+  const periVerts = /* @__PURE__ */ new Set();
+  if (preservePerimeter) {
+    for (const key4 of peri) {
+      const e = edgeMap.get(key4);
+      periVerts.add(vertKey(e.a));
+      periVerts.add(vertKey(e.b));
+    }
+  }
+  return group(
+    simplified.map((f, i) => {
+      const original = ringOf(faces[i]);
+      const ring2 = ringOf(f).map((v, vi) => {
+        if (preservePerimeter && original[vi] && periVerts.has(vertKey(original[vi]))) {
+          return { ...original[vi] };
+        }
+        for (const ov of original) {
+          if (periVerts.has(vertKey(ov)) && dist(v, ov) < tolerance * 2) {
+            return { ...ov };
+          }
+        }
+        return remap(v);
+      });
+      return polygon(unique(ring2).length >= 3 ? ring2 : original);
+    })
+  );
+}
+function clusterSnap(points, tol) {
+  const clusters = [];
+  for (const p of points) {
+    let found = false;
+    for (const c of clusters) {
+      if (dist(p, c[0]) <= tol) {
+        c.push(p);
+        found = true;
+        break;
+      }
+    }
+    if (!found) clusters.push([p]);
+  }
+  return clusters.map((c) => ({
+    x: c.reduce((s, p) => s + p.x, 0) / c.length,
+    y: c.reduce((s, p) => s + p.y, 0) / c.length
+  }));
+}
+function stochasticMerge(faces, nClasses, seed = 1) {
+  if (faces.length === 0) return group([]);
+  const classes = Math.max(1, Math.floor(nClasses));
+  const rng = mulberry325(seed >>> 0);
+  const label = faces.map(() => Math.floor(rng() * classes));
+  const adj = faceAdjacency(faces);
+  const parent = faces.map((_, i) => i);
+  const find = (i) => {
+    let x = i;
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  const unite = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[rb] = ra;
+  };
+  for (let i = 0; i < faces.length; i++) {
+    for (const j of adj[i]) {
+      if (j > i && label[i] === label[j]) unite(i, j);
+    }
+  }
+  const comps = /* @__PURE__ */ new Map();
+  for (let i = 0; i < faces.length; i++) {
+    const r = find(i);
+    const list = comps.get(r) ?? [];
+    list.push(i);
+    comps.set(r, list);
+  }
+  const out = [];
+  for (const members of comps.values()) {
+    if (members.length === 1) {
+      out.push(faces[members[0]]);
+      continue;
+    }
+    const merged = dissolveFaces(members.map((i) => faces[i]));
+    out.push(...merged);
+  }
+  return group(out);
+}
+function dissolveFaces(faces) {
+  if (faces.length === 0) return [];
+  if (faces.length === 1) return [faces[0]];
+  try {
+    let acc = faces[0];
+    for (let i = 1; i < faces.length; i++) {
+      const u = union(acc, faces[i]);
+      if (u.paths.length === 0) continue;
+      acc = u.paths.reduce(
+        (best, p) => area(p) > area(best) ? p : best
+      );
+    }
+    return [acc];
+  } catch {
+    return [convexHullOf(faces.flatMap((f) => ringOf(f)))];
+  }
+}
+function areaMerge(faces, minAreaOrOptions) {
+  let working = [...faces];
+  if (working.length === 0) return group([]);
+  if (typeof minAreaOrOptions === "object" && minAreaOrOptions.remainingFaces != null) {
+    const target = Math.max(1, Math.floor(minAreaOrOptions.remainingFaces));
+    while (working.length > target) {
+      const next = mergeSmallestAdjacent(working);
+      if (next.length >= working.length) break;
+      working = next;
+    }
+    return group(working);
+  }
+  const minArea2 = typeof minAreaOrOptions === "number" ? minAreaOrOptions : minAreaOrOptions.minArea ?? 0;
+  let guard = 0;
+  while (guard++ < working.length + 10) {
+    const smallIdx = working.findIndex((f) => area(f) < minArea2);
+    if (smallIdx < 0) break;
+    const next = mergeFaceIntoNeighbor(working, smallIdx);
+    if (!next) break;
+    working = next;
+  }
+  return group(working);
+}
+function mergeSmallestAdjacent(faces) {
+  let best = -1;
+  let bestA = Infinity;
+  for (let i = 0; i < faces.length; i++) {
+    const a = area(faces[i]);
+    if (a < bestA) {
+      bestA = a;
+      best = i;
+    }
+  }
+  if (best < 0) return faces;
+  return mergeFaceIntoNeighbor(faces, best) ?? faces;
+}
+function mergeFaceIntoNeighbor(faces, idx) {
+  const adj = faceAdjacency(faces);
+  const nbrs = adj[idx] ?? [];
+  if (nbrs.length === 0) {
+    return faces.filter((_, i) => i !== idx);
+  }
+  let bestN = nbrs[0];
+  let bestA = -1;
+  for (const n of nbrs) {
+    const a = area(faces[n]);
+    if (a > bestA) {
+      bestA = a;
+      bestN = n;
+    }
+  }
+  const merged = dissolveFaces([faces[idx], faces[bestN]]);
+  const out = [];
+  for (let i = 0; i < faces.length; i++) {
+    if (i === idx || i === bestN) continue;
+    out.push(faces[i]);
+  }
+  out.push(...merged);
+  return out;
+}
+function convexHullOf(points) {
+  const pts = unique(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 && cross3(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 && cross3(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+      upper.pop();
+    }
+    upper.push(p);
+  }
+  lower.pop();
+  upper.pop();
+  return polygon([...lower, ...upper]);
+}
+function mulberry325(a) {
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function findBreaks(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const segs = [];
+  const peri = [];
+  for (const e of edgeMap.values()) {
+    if (e.faceIds.length === 1) peri.push(e);
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < peri.length; i++) {
+    if (used.has(i)) continue;
+    const a = peri[i];
+    for (let j = i + 1; j < peri.length; j++) {
+      if (used.has(j)) continue;
+      const b = peri[j];
+      if (nearDuplicateEdge(a, b, 1e-3)) {
+        segs.push(polyline([a.a, a.b]));
+        segs.push(polyline([b.a, b.b]));
+        used.add(i);
+        used.add(j);
+        break;
+      }
+    }
+  }
+  return group(segs);
+}
+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 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([]);
+  const tol = Math.max(maxGapWidth, 1e-9);
+  const verts = unique(faces.flatMap((f) => ringOf(f)));
+  const snapped = clusterSnap(verts, tol);
+  const remap = (v) => {
+    let best = snapped[0];
+    let bestD = Infinity;
+    for (const s of snapped) {
+      const d = dist(v, s);
+      if (d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    return { ...best };
+  };
+  const fixed = faces.map((f) => {
+    const ring2 = unique(ringOf(f).map(remap));
+    return ring2.length >= 3 ? polygon(ring2) : f;
+  });
+  try {
+    return group(dissolveOverlaps(fixed));
+  } catch {
+    return group(fixed);
+  }
+}
+function dissolveOverlaps(faces) {
+  let working = [...faces];
+  let changed = true;
+  let guard = 0;
+  while (changed && guard++ < working.length) {
+    changed = false;
+    outer: for (let i = 0; i < working.length; i++) {
+      for (let j = i + 1; j < working.length; j++) {
+        const a = working[i];
+        const b = working[j];
+        const u = union(a, b);
+        const ua = u.paths.reduce((s, p) => s + area(p), 0);
+        if (ua < area(a) + area(b) - 1e-6) {
+          const next = working.filter((_, k) => k !== i && k !== j);
+          next.push(...u.paths);
+          working = next;
+          changed = true;
+          break outer;
+        }
+      }
+    }
+  }
+  return working;
+}
+function fixBrokenFaces(coverage, tolerance, polygonise = true) {
+  const tol = Math.max(tolerance, 1e-9);
+  const anchors = [];
+  const endpoints = [];
+  coverage.forEach((p, pi) => {
+    const ring2 = ringOf(p);
+    if (ring2.length === 0) return;
+    if (p.closed) {
+      for (const v of ring2) anchors.push(v);
+    } else {
+      endpoints.push({ pathIdx: pi, end: 0, v: ring2[0] });
+      endpoints.push({
+        pathIdx: pi,
+        end: 1,
+        v: ring2[ring2.length - 1]
+      });
+    }
+  });
+  const snapTargets = clusterSnap(
+    [...anchors, ...endpoints.map((e) => e.v)],
+    tol
+  );
+  const snapTo = (v, preferAnchor) => {
+    let best = v;
+    let bestD = Infinity;
+    for (const s of snapTargets) {
+      const d = dist(v, s);
+      if (d <= tol && d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    {
+      for (const a of anchors) {
+        if (dist(v, a) <= tol) return { ...a };
+      }
+    }
+    return { ...best };
+  };
+  const snappedPaths = coverage.map((p) => {
+    const ring2 = ringOf(p);
+    if (ring2.length === 0) return p;
+    if (p.closed) return p;
+    const next = ring2.map((v) => ({ ...v }));
+    next[0] = snapTo(ring2[0]);
+    next[next.length - 1] = snapTo(ring2[ring2.length - 1]);
+    return polyline(next);
+  });
+  if (!polygonise) return group(snappedPaths);
+  const out = [];
+  for (const p of snappedPaths) {
+    const ring2 = ringOf(p);
+    if (p.closed) {
+      out.push(p);
+      continue;
+    }
+    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));
+    } else {
+      out.push(p);
+    }
+  }
+  return group(out);
+}
+function findIslands(faces) {
+  if (faces.length === 0) return [];
+  const adj = faceAdjacency(faces);
+  const seen = /* @__PURE__ */ new Set();
+  const islands = [];
+  for (let i = 0; i < faces.length; i++) {
+    if (seen.has(i)) continue;
+    const stack = [i];
+    const members = [];
+    seen.add(i);
+    while (stack.length) {
+      const cur = stack.pop();
+      members.push(cur);
+      for (const n of adj[cur]) {
+        if (!seen.has(n)) {
+          seen.add(n);
+          stack.push(n);
+        }
+      }
+    }
+    islands.push(members);
+  }
+  islands.sort((a, b) => b.length - a.length);
+  return islands.map((m) => group(m.map((i) => faces[i])));
+}
+function radialSortFaces(faces) {
+  if (faces.length === 0) return [];
+  const cs = faces.map((f) => centroid(f));
+  const cx = cs.reduce((s, p) => s + p.x, 0) / cs.length;
+  const cy = cs.reduce((s, p) => s + p.y, 0) / cs.length;
+  return faces.map((f, i) => ({ f, a: Math.atan2(cs[i].y - cy, cs[i].x - cx) })).sort((a, b) => a.a - b.a).map((x) => x.f);
+}
+function centroidSortFaces(faces) {
+  return [...faces].sort((a, b) => {
+    const ca = centroid(a);
+    const cb = centroid(b);
+    return ca.x === cb.x ? ca.y - cb.y : ca.x - cb.x;
+  });
+}
+var meshing = {
+  extractInnerEdges,
+  extractInnerVertices,
+  findContainingFace,
+  splitEdges,
+  urquhartFaces,
+  gabrielFaces,
+  relativeNeighborFaces,
+  spannerFaces,
+  dualFaces,
+  centroidQuadrangulation,
+  edgeCollapseQuadrangulation,
+  splitQuadrangulation,
+  spiralQuadrangulation,
+  matchingQuadrangulation,
+  smoothMesh,
+  subdivideMesh,
+  simplifyMesh,
+  stochasticMerge,
+  areaMerge,
+  radialSortFaces,
+  centroidSortFaces,
+  findBreaks,
+  fixBreaks,
+  fixBrokenFaces,
+  findIslands
+};
+
+// 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 subdivideMesh(faces, edgeSplitRatio = 0.5) {
-  const t = Math.min(1, Math.max(0, edgeSplitRatio));
-  const out = [];
-  for (const f of faces) {
-    const ring2 = ringOf(f);
-    if (ring2.length < 3) continue;
-    const c = centroid(f);
-    const n = ring2.length;
-    const splits = [];
-    for (let i = 0; i < n; i++) {
-      const a = ring2[i];
-      const b = ring2[(i + 1) % n];
-      splits.push(lerp(a, b, t));
-    }
-    for (let i = 0; i < n; i++) {
-      const v = ring2[i];
-      const sPrev = splits[(i - 1 + n) % n];
-      const sNext = splits[i];
-      out.push(polygon([v, sNext, c, sPrev]));
-    }
+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 group(out);
+  return polyline(pts);
 }
-function simplifyMesh(faces, tolerance, preservePerimeter = true) {
-  if (tolerance <= 0 || faces.length === 0) return group(faces.map((f) => polygon(ringOf(f), f.rings.slice(1))));
-  const edgeMap = buildEdgeMap(faces);
-  const peri = perimeterKeys(edgeMap);
-  const simplified = faces.map((f) => {
-    const ring2 = ringOf(f);
-    if (ring2.length <= 3) return polygon(ring2);
-    if (preservePerimeter) {
-      const s = simplify(f, tolerance);
-      const sr = ringOf(s);
-      if (sr.length < 3) return polygon(ring2);
-      return polygon(sr, s.rings.slice(1));
-    }
-    return simplify(f, tolerance);
-  });
-  const all = unique(simplified.flatMap((f) => ringOf(f)));
-  const snapped = clusterSnap(all, Math.max(tolerance * 0.5, 1e-9));
-  const remap = (v) => {
-    let best = v;
-    let bestD = Infinity;
-    for (const s of snapped) {
-      const d = dist(v, s);
-      if (d < bestD) {
-        bestD = d;
-        best = s;
-      }
-    }
-    return { ...best };
-  };
-  const periVerts = /* @__PURE__ */ new Set();
-  if (preservePerimeter) {
-    for (const key4 of peri) {
-      const e = edgeMap.get(key4);
-      periVerts.add(vertKey(e.a));
-      periVerts.add(vertKey(e.b));
-    }
+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 group(
-    simplified.map((f, i) => {
-      const original = ringOf(faces[i]);
-      const ring2 = ringOf(f).map((v, vi) => {
-        if (preservePerimeter && original[vi] && periVerts.has(vertKey(original[vi]))) {
-          return { ...original[vi] };
-        }
-        for (const ov of original) {
-          if (periVerts.has(vertKey(ov)) && dist(v, ov) < tolerance * 2) {
-            return { ...ov };
-          }
-        }
-        return remap(v);
-      });
-      return polygon(unique(ring2).length >= 3 ? ring2 : original);
-    })
-  );
+  return polygon(ring2);
 }
-function clusterSnap(points, tol) {
-  const clusters = [];
-  for (const p of points) {
-    let found = false;
-    for (const c of clusters) {
-      if (dist(p, c[0]) <= tol) {
-        c.push(p);
-        found = true;
-        break;
-      }
-    }
-    if (!found) clusters.push([p]);
+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 clusters.map((c) => ({
-    x: c.reduce((s, p) => s + p.x, 0) / c.length,
-    y: c.reduce((s, p) => s + p.y, 0) / c.length
-  }));
+  return polygon(ring2);
 }
-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 label = faces.map(() => Math.floor(rng() * classes));
-  const adj = faceAdjacency(faces);
-  const parent = faces.map((_, i) => i);
-  const find = (i) => {
-    let x = i;
-    while (parent[x] !== x) {
-      parent[x] = parent[parent[x]];
-      x = parent[x];
-    }
-    return x;
-  };
-  const unite = (a, b) => {
-    const ra = find(a);
-    const rb = find(b);
-    if (ra !== rb) parent[rb] = ra;
-  };
-  for (let i = 0; i < faces.length; i++) {
-    for (const j of adj[i]) {
-      if (j > i && label[i] === label[j]) unite(i, j);
+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 comps = /* @__PURE__ */ new Map();
-  for (let i = 0; i < faces.length; i++) {
-    const r = find(i);
-    const list = comps.get(r) ?? [];
-    list.push(i);
-    comps.set(r, list);
-  }
+  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 (const members of comps.values()) {
-    if (members.length === 1) {
-      out.push(faces[members[0]]);
-      continue;
-    }
-    const merged = dissolveFaces(members.map((i) => faces[i]));
-    out.push(...merged);
+  for (let i = 0; i < count; i++) {
+    out.push({
+      x: minX + rng() * (maxX - minX),
+      y: minY + rng() * (maxY - minY)
+    });
   }
-  return group(out);
+  return out;
 }
-function dissolveFaces(faces) {
-  if (faces.length === 0) return [];
-  if (faces.length === 1) return [faces[0]];
-  try {
-    let acc = faces[0];
-    for (let i = 1; i < faces.length; i++) {
-      const u = union(acc, faces[i]);
-      if (u.paths.length === 0) continue;
-      acc = u.paths.reduce(
-        (best, p) => area(p) > area(best) ? p : best
-      );
-    }
-    return [acc];
-  } catch {
-    return [convexHullOf(faces.flatMap((f) => ringOf(f)))];
-  }
+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 areaMerge(faces, minAreaOrOptions) {
-  let working = [...faces];
-  if (working.length === 0) return group([]);
-  if (typeof minAreaOrOptions === "object" && minAreaOrOptions.remainingFaces != null) {
-    const target = Math.max(1, Math.floor(minAreaOrOptions.remainingFaces));
-    while (working.length > target) {
-      const next = mergeSmallestAdjacent(working);
-      if (next.length >= working.length) break;
-      working = next;
-    }
-    return group(working);
+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);
   }
-  const minArea2 = typeof minAreaOrOptions === "number" ? minAreaOrOptions : minAreaOrOptions.minArea ?? 0;
-  let guard = 0;
-  while (guard++ < working.length + 10) {
-    const smallIdx = working.findIndex((f) => area(f) < minArea2);
-    if (smallIdx < 0) break;
-    const next = mergeFaceIntoNeighbor(working, smallIdx);
-    if (!next) break;
-    working = next;
+  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(working);
+  return group(paths);
 }
-function mergeSmallestAdjacent(faces) {
-  let best = -1;
-  let bestA = Infinity;
-  for (let i = 0; i < faces.length; i++) {
-    const a = area(faces[i]);
-    if (a < bestA) {
-      bestA = a;
-      best = i;
+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));
     }
   }
-  if (best < 0) return faces;
-  return mergeFaceIntoNeighbor(faces, best) ?? faces;
+  return group(paths);
 }
-function mergeFaceIntoNeighbor(faces, idx) {
-  const adj = faceAdjacency(faces);
-  const nbrs = adj[idx] ?? [];
-  if (nbrs.length === 0) {
-    return faces.filter((_, i) => i !== idx);
+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 });
   }
-  let bestN = nbrs[0];
-  let bestA = -1;
-  for (const n of nbrs) {
-    const a = area(faces[n]);
-    if (a > bestA) {
-      bestA = a;
-      bestN = n;
+  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);
     }
   }
-  const merged = dissolveFaces([faces[idx], faces[bestN]]);
-  const out = [];
-  for (let i = 0; i < faces.length; i++) {
-    if (i === idx || i === bestN) continue;
-    out.push(faces[i]);
-  }
-  out.push(...merged);
-  return out;
+  return group(paths);
 }
-function convexHullOf(points) {
-  const pts = unique(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 && cross3(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
-      lower.pop();
+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));
     }
-    lower.push(p);
+    cur = next;
   }
-  const upper = [];
-  for (let i = pts.length - 1; i >= 0; i--) {
-    const p = pts[i];
-    while (upper.length >= 2 && cross3(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
-      upper.pop();
+  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));
     }
-    upper.push(p);
+    cur = next;
   }
-  lower.pop();
-  upper.pop();
-  return polygon([...lower, ...upper]);
+  return group(cur);
 }
-function mulberry324(a) {
-  return () => {
-    a |= 0;
-    a = a + 1831565813 | 0;
-    let t = Math.imul(a ^ a >>> 15, 1 | a);
-    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
-    return ((t ^ t >>> 14) >>> 0) / 4294967296;
-  };
+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 findBreaks(faces) {
-  const edgeMap = buildEdgeMap(faces);
-  const segs = [];
-  const peri = [];
-  for (const e of edgeMap.values()) {
-    if (e.faceIds.length === 1) peri.push(e);
+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);
   }
-  const used = /* @__PURE__ */ new Set();
-  for (let i = 0; i < peri.length; i++) {
-    if (used.has(i)) continue;
-    const a = peri[i];
-    for (let j = i + 1; j < peri.length; j++) {
-      if (used.has(j)) continue;
-      const b = peri[j];
-      if (nearDuplicateEdge(a, b, 1e-3)) {
-        segs.push(polyline([a.a, a.b]));
-        segs.push(polyline([b.a, b.b]));
-        used.add(i);
-        used.add(j);
-        break;
+  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(segs);
-}
-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 len2 = dist(a.a, a.b);
-  return Math.min(d1, d2) < tol * 2 + len2 * 0.05 && Math.min(d1, d2) > 1e-9;
+  return group(faces);
 }
-function fixBreaks(faces, maxGapWidth) {
-  if (faces.length === 0) return group([]);
-  const tol = Math.max(maxGapWidth, 1e-9);
-  const verts = unique(faces.flatMap((f) => ringOf(f)));
-  const snapped = clusterSnap(verts, tol);
-  const remap = (v) => {
-    let best = snapped[0];
-    let bestD = Infinity;
-    for (const s of snapped) {
-      const d = dist(v, s);
-      if (d < bestD) {
-        bestD = d;
-        best = s;
+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);
       }
     }
-    return { ...best };
-  };
-  const fixed = faces.map((f) => {
-    const ring2 = unique(ringOf(f).map(remap));
-    return ring2.length >= 3 ? polygon(ring2) : f;
-  });
-  try {
-    return group(dissolveOverlaps(fixed));
-  } catch {
-    return group(fixed);
   }
+  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 dissolveOverlaps(faces) {
-  let working = [...faces];
-  let changed = true;
-  let guard = 0;
-  while (changed && guard++ < working.length) {
-    changed = false;
-    outer: for (let i = 0; i < working.length; i++) {
-      for (let j = i + 1; j < working.length; j++) {
-        const a = working[i];
-        const b = working[j];
-        const u = union(a, b);
-        const ua = u.paths.reduce((s, p) => s + area(p), 0);
-        if (ua < area(a) + area(b) - 1e-6) {
-          const next = working.filter((_, k) => k !== i && k !== j);
-          next.push(...u.paths);
-          working = next;
-          changed = true;
-          break outer;
+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 working;
+  return best ?? convexHull(points);
 }
-function fixBrokenFaces(coverage, tolerance, polygonise = true) {
-  const tol = Math.max(tolerance, 1e-9);
-  const anchors = [];
-  const endpoints = [];
-  coverage.forEach((p, pi) => {
-    const ring2 = ringOf(p);
-    if (ring2.length === 0) return;
-    if (p.closed) {
-      for (const v of ring2) anchors.push(v);
-    } else {
-      endpoints.push({ pathIdx: pi, end: 0, v: ring2[0] });
-      endpoints.push({
-        pathIdx: pi,
-        end: 1,
-        v: ring2[ring2.length - 1]
-      });
-    }
-  });
-  const snapTargets = clusterSnap(
-    [...anchors, ...endpoints.map((e) => e.v)],
-    tol
-  );
-  const snapTo = (v, preferAnchor) => {
-    let best = v;
+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 (const s of snapTargets) {
-      const d = dist(v, s);
-      if (d <= tol && d < bestD) {
+    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;
-        best = s;
-      }
-    }
-    {
-      for (const a of anchors) {
-        if (dist(v, a) <= tol) return { ...a };
+        bestI = i;
       }
     }
-    return { ...best };
-  };
-  const snappedPaths = coverage.map((p) => {
-    const ring2 = ringOf(p);
-    if (ring2.length === 0) return p;
-    if (p.closed) return p;
-    const next = ring2.map((v) => ({ ...v }));
-    next[0] = snapTo(ring2[0]);
-    next[next.length - 1] = snapTo(ring2[ring2.length - 1]);
-    return polyline(next);
-  });
-  if (!polygonise) return group(snappedPaths);
-  const out = [];
-  for (const p of snappedPaths) {
-    const ring2 = ringOf(p);
-    if (p.closed) {
-      out.push(p);
-      continue;
-    }
-    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));
-    } else {
-      out.push(p);
-    }
+    ordered.push(remaining.splice(bestI, 1)[0]);
   }
-  return group(out);
+  return polygon(ordered);
 }
-function findIslands(faces) {
-  if (faces.length === 0) return [];
-  const adj = faceAdjacency(faces);
-  const seen = /* @__PURE__ */ new Set();
-  const islands = [];
-  for (let i = 0; i < faces.length; i++) {
-    if (seen.has(i)) continue;
-    const stack = [i];
-    const members = [];
-    seen.add(i);
-    while (stack.length) {
-      const cur = stack.pop();
-      members.push(cur);
-      for (const n of adj[cur]) {
-        if (!seen.has(n)) {
-          seen.add(n);
-          stack.push(n);
-        }
-      }
-    }
-    islands.push(members);
+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}`));
   }
-  islands.sort((a, b) => b.length - a.length);
-  return islands.map((m) => group(m.map((i) => faces[i])));
+  return layers;
 }
-function radialSortFaces(faces) {
-  if (faces.length === 0) return [];
-  const cs = faces.map((f) => centroid(f));
-  const cx = cs.reduce((s, p) => s + p.x, 0) / cs.length;
-  const cy = cs.reduce((s, p) => s + p.y, 0) / cs.length;
-  return faces.map((f, i) => ({ f, a: Math.atan2(cs[i].y - cy, cs[i].x - cx) })).sort((a, b) => a.a - b.a).map((x) => x.f);
+function hilbert(points) {
+  return polygon(hilbertSort(points));
 }
-function centroidSortFaces(faces) {
-  return [...faces].sort((a, b) => {
-    const ca = centroid(a);
-    const cb = centroid(b);
-    return ca.x === cb.x ? ca.y - cb.y : ca.x - cb.x;
-  });
+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;
 }
-var meshing = {
-  extractInnerEdges,
-  extractInnerVertices,
-  findContainingFace,
-  splitEdges,
-  urquhartFaces,
-  gabrielFaces,
-  relativeNeighborFaces,
-  spannerFaces,
-  dualFaces,
-  centroidQuadrangulation,
-  edgeCollapseQuadrangulation,
-  splitQuadrangulation,
-  spiralQuadrangulation,
-  matchingQuadrangulation,
-  smoothMesh,
-  subdivideMesh,
-  simplifyMesh,
-  stochasticMerge,
-  areaMerge,
-  radialSortFaces,
-  centroidSortFaces,
-  findBreaks,
-  fixBreaks,
-  fixBrokenFaces,
-  findIslands
+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, 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, 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, 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, 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, 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, straightSkeleton, straightSkeletonParts, subdivideMesh, subtract, subtractAll, symDifference, tiling, toArray, toContours, toSvg, transformation, translate, translateCentroidTo, translateCornerTo, translateToOrigin, triangleSubdivision, triangulation, union, unionAll, urquhartFaces, vec2, voronoi, width };
+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