pattapatta 0.2.0 → 0.3.0

package/dist/index.js

@@ -825,8 +825,8 @@ function clipSegmentToPath(seg, clip) {
     const h0 = hits[i];
     const h1 = hits[i + 1];
     if (h1.t - h0.t < 1e-9) continue;
-    const mid3 = vec2((h0.p.x + h1.p.x) / 2, (h0.p.y + h1.p.y) / 2);
-    if (containsPoint(clip, mid3)) {
+    const mid5 = vec2((h0.p.x + h1.p.x) / 2, (h0.p.y + h1.p.y) / 2);
+    if (containsPoint(clip, mid5)) {
       out.push(segment(h0.p, h1.p));
     }
   }
@@ -1569,10 +1569,10 @@ function segmentsOnExterior(p) {
 function slice(p, a, b) {
   const dx = b.x - a.x;
   const dy = b.y - a.y;
-  const len = Math.hypot(dx, dy);
-  if (len < 1e-12) return group([p]);
-  const nx = -dy / len;
-  const ny = dx / len;
+  const len2 = Math.hypot(dx, dy);
+  if (len2 < 1e-12) return group([p]);
+  const nx = -dy / len2;
+  const ny = dx / len2;
   const bb = bounds(p);
   const span = Math.hypot(bb.maxX - bb.minX, bb.maxY - bb.minY) * 4 + 10;
   const left = halfPlanePoly(a, nx, ny, span);
@@ -1601,9 +1601,9 @@ function intersectionPoints(a, b) {
     for (const sb of segsB) {
       const hit = segmentIntersection2(sa.a, sa.b, sb.a, sb.b);
       if (!hit) continue;
-      const key = `${hit.x.toFixed(9)},${hit.y.toFixed(9)}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
+      const key4 = `${hit.x.toFixed(9)},${hit.y.toFixed(9)}`;
+      if (seen.has(key4)) continue;
+      seen.add(key4);
       out.push(hit);
     }
   }
@@ -1762,76 +1762,6 @@ var conversion = {
   group
 };
 
-// src/contour/index.ts
-function offsetCurvesOutward(p, distance) {
-  return buffer(p, Math.abs(distance));
-}
-function offsetCurvesInward(p, distance) {
-  return buffer(p, -Math.abs(distance));
-}
-var contour = {
-  offsetCurvesOutward,
-  offsetCurvesInward
-};
-
-// src/hull/index.ts
-function convexHull(points) {
-  const pts = uniquePoints(points);
-  if (pts.length < 3) return polygon(pts);
-  pts.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
-  const lower = [];
-  for (const p of pts) {
-    while (lower.length >= 2 && cross2(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
-      lower.pop();
-    }
-    lower.push(p);
-  }
-  const upper = [];
-  for (let i = pts.length - 1; i >= 0; i--) {
-    const p = pts[i];
-    while (upper.length >= 2 && cross2(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
-      upper.pop();
-    }
-    upper.push(p);
-  }
-  lower.pop();
-  upper.pop();
-  return polygon([...lower, ...upper]);
-}
-function convexHullPath(p) {
-  const pts = [];
-  for (const ring2 of p.rings) pts.push(...ring2);
-  return convexHull(pts);
-}
-function boundingBox(p) {
-  const b = bounds(p);
-  return polygon([
-    { x: b.minX, y: b.minY },
-    { x: b.maxX, y: b.minY },
-    { x: b.maxX, y: b.maxY },
-    { x: b.minX, y: b.maxY }
-  ]);
-}
-function cross2(o, a, b) {
-  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
-}
-function uniquePoints(points) {
-  const seen = /* @__PURE__ */ new Set();
-  const out = [];
-  for (const p of points) {
-    const key = `${p.x},${p.y}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push({ x: p.x, y: p.y });
-  }
-  return out;
-}
-var hull = {
-  convexHull,
-  convexHullPath,
-  boundingBox
-};
-
 // src/pointSet/index.ts
 function random(count, minX, minY, maxX, maxY, seed = 1) {
   const rng = mulberry323(seed >>> 0);
@@ -2121,9 +2051,9 @@ function longestEdgeMidpoint(a, b, c) {
   let best = edges[0];
   let bestLen = -1;
   for (const e of edges) {
-    const len = Math.hypot(e[0].x - e[1].x, e[0].y - e[1].y);
-    if (len > bestLen) {
-      bestLen = len;
+    const len2 = Math.hypot(e[0].x - e[1].x, e[0].y - e[1].y);
+    if (len2 > bestLen) {
+      bestLen = len2;
       best = e;
     }
   }
@@ -2138,6 +2068,205 @@ var triangulation = {
   refine
 };
 
+// src/contour/dissolve.ts
+function key(v, digits = 9) {
+  return `${v.x.toFixed(digits)},${v.y.toFixed(digits)}`;
+}
+function same(a, b, eps = 1e-9) {
+  return Math.abs(a.x - b.x) <= eps && Math.abs(a.y - b.y) <= eps;
+}
+function dissolveSegments(segments) {
+  const segs = segments.filter((s) => !same(s.a, s.b));
+  if (segs.length === 0) return group([]);
+  const adj = /* @__PURE__ */ new Map();
+  const pts = /* @__PURE__ */ new Map();
+  const add = (a, b, segIdx) => {
+    const ka = key(a);
+    const kb = key(b);
+    pts.set(ka, a);
+    pts.set(kb, b);
+    if (!adj.has(ka)) adj.set(ka, []);
+    if (!adj.has(kb)) adj.set(kb, []);
+    adj.get(ka).push({ segIdx, other: kb });
+    adj.get(kb).push({ segIdx, other: ka });
+  };
+  for (let i = 0; i < segs.length; i++) {
+    add(segs[i].a, segs[i].b, i);
+  }
+  const used = /* @__PURE__ */ new Set();
+  const paths = [];
+  const unusedDegree = (k) => (adj.get(k) ?? []).filter((e) => !used.has(e.segIdx)).length;
+  const nextUnused = (k) => (adj.get(k) ?? []).find((e) => !used.has(e.segIdx));
+  const starts = [...adj.keys()].sort(
+    (a, b) => unusedDegree(a) - unusedDegree(b)
+  );
+  for (const start of starts) {
+    let link = nextUnused(start);
+    while (link) {
+      const chain = [pts.get(start)];
+      used.add(link.segIdx);
+      let next = link.other;
+      chain.push(pts.get(next));
+      while (unusedDegree(next) === 1) {
+        const e = nextUnused(next);
+        if (!e) break;
+        used.add(e.segIdx);
+        next = e.other;
+        chain.push(pts.get(next));
+        if (next === start) break;
+      }
+      if (chain.length >= 2) paths.push(polyline(chain));
+      link = nextUnused(start);
+    }
+  }
+  for (let i = 0; i < segs.length; i++) {
+    if (used.has(i)) continue;
+    const s = segs[i];
+    paths.push(polyline([s.a, s.b]));
+  }
+  return group(paths);
+}
+
+// src/contour/chordalAxis.ts
+function mid(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+function len(a, b) {
+  return Math.hypot(b.x - a.x, b.y - a.y);
+}
+function edgeKey(a, b) {
+  const ka = `${a.x.toFixed(8)},${a.y.toFixed(8)}`;
+  const kb = `${b.x.toFixed(8)},${b.y.toFixed(8)}`;
+  return ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+}
+function chordalAxis(shape) {
+  if (!shape.closed || shape.rings.length === 0) return dissolveSegments([]);
+  const b = boundsSpan(shape);
+  const densified = densify(shape, Math.max(b / 40, 1e-3));
+  const tris = delaunayTriangulation(densified);
+  if (tris.length === 0) return dissolveSegments([]);
+  const edgeCount = /* @__PURE__ */ new Map();
+  const triEdges = [];
+  for (const t of tris) {
+    const r = t.rings[0];
+    if (!r || r.length < 3) continue;
+    const a = r[0];
+    const b0 = r[1];
+    const c = r[2];
+    triEdges.push([a, b0, c]);
+    for (const [u, v] of [
+      [a, b0],
+      [b0, c],
+      [c, a]
+    ]) {
+      const k = edgeKey(u, v);
+      edgeCount.set(k, (edgeCount.get(k) ?? 0) + 1);
+    }
+  }
+  const isBoundary = (u, v) => (edgeCount.get(edgeKey(u, v)) ?? 0) <= 1;
+  const segs = [];
+  for (const [a, b0, c] of triEdges) {
+    const edges = [
+      [a, b0],
+      [b0, c],
+      [c, a]
+    ];
+    const interior = edges.filter(([u, v]) => !isBoundary(u, v));
+    const degree = interior.length;
+    if (degree === 1) {
+      const [u, v] = interior[0];
+      const cen = centroid({ rings: [[a, b0, c]]});
+      segs.push(segment(cen, mid(u, v)));
+    } else if (degree === 2) {
+      const m0 = mid(interior[0][0], interior[0][1]);
+      const m1 = mid(interior[1][0], interior[1][1]);
+      segs.push(segment(m0, m1));
+    } else if (degree === 3) {
+      const ranked = edges.map(([u, v]) => ({ u, v, l: len(u, v) })).sort((x, y) => y.l - x.l);
+      const longest = ranked[0];
+      const shortA = ranked[1];
+      const shortB = ranked[2];
+      const mL = mid(longest.u, longest.v);
+      segs.push(segment(mid(shortA.u, shortA.v), mL));
+      segs.push(segment(mid(shortB.u, shortB.v), mL));
+    }
+  }
+  return dissolveSegments(segs);
+}
+function boundsSpan(p) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const ring2 of p.rings) {
+    for (const v of ring2) {
+      minX = Math.min(minX, v.x);
+      minY = Math.min(minY, v.y);
+      maxX = Math.max(maxX, v.x);
+      maxY = Math.max(maxY, v.y);
+    }
+  }
+  return Math.max(maxX - minX, maxY - minY, 1);
+}
+
+// src/hull/index.ts
+function convexHull(points) {
+  const pts = uniquePoints(points);
+  if (pts.length < 3) return polygon(pts);
+  pts.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+  const lower = [];
+  for (const p of pts) {
+    while (lower.length >= 2 && cross2(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+      lower.pop();
+    }
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = pts.length - 1; i >= 0; i--) {
+    const p = pts[i];
+    while (upper.length >= 2 && cross2(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+      upper.pop();
+    }
+    upper.push(p);
+  }
+  lower.pop();
+  upper.pop();
+  return polygon([...lower, ...upper]);
+}
+function convexHullPath(p) {
+  const pts = [];
+  for (const ring2 of p.rings) pts.push(...ring2);
+  return convexHull(pts);
+}
+function boundingBox(p) {
+  const b = bounds(p);
+  return polygon([
+    { x: b.minX, y: b.minY },
+    { x: b.maxX, y: b.minY },
+    { x: b.maxX, y: b.maxY },
+    { x: b.minX, y: b.maxY }
+  ]);
+}
+function cross2(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+function uniquePoints(points) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of points) {
+    const key4 = `${p.x},${p.y}`;
+    if (seen.has(key4)) continue;
+    seen.add(key4);
+    out.push({ x: p.x, y: p.y });
+  }
+  return out;
+}
+var hull = {
+  convexHull,
+  convexHullPath,
+  boundingBox
+};
+
 // src/optimisation/index.ts
 function envelope(p) {
   return boundingBox(p);
@@ -2170,12 +2299,12 @@ function maximumInscribedAARectangle(p) {
   let hi = Math.min(w, h) / 2;
   let best = hi;
   for (let i = 0; i < 40; i++) {
-    const mid3 = (lo + hi) / 2;
-    if (fits(mid3)) {
-      best = mid3;
-      hi = mid3;
+    const mid5 = (lo + hi) / 2;
+    if (fits(mid5)) {
+      best = mid5;
+      hi = mid5;
     } else {
-      lo = mid3;
+      lo = mid5;
     }
   }
   const m = best;
@@ -2320,6 +2449,917 @@ var optimisation = {
   farthestPointPair,
   minimumBoundingCircle
 };
+
+// src/contour/boundaryDistance.ts
+function distanceToBoundary2(path3, p) {
+  let best = Infinity;
+  for (const ring2 of path3.rings) {
+    if (ring2.length < 2) continue;
+    const n = ring2.length;
+    const closed = path3.closed;
+    const limit = closed ? n : n - 1;
+    for (let i = 0; i < limit; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      best = Math.min(best, distPointSeg(p, a, b));
+    }
+  }
+  return best;
+}
+function sampleBoundary(path3, maxSegLen) {
+  const pts = [];
+  const lim = Math.max(maxSegLen, 1e-9);
+  for (const ring2 of path3.rings) {
+    if (ring2.length < 2) continue;
+    const n = ring2.length;
+    const limit = path3.closed ? n : n - 1;
+    for (let i = 0; i < limit; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      const len2 = Math.hypot(b.x - a.x, b.y - a.y);
+      const steps = Math.max(1, Math.ceil(len2 / lim));
+      for (let s = 0; s < steps; s++) {
+        const t = s / steps;
+        pts.push({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+      }
+    }
+  }
+  return pts;
+}
+function distPointSeg(p, a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 1e-18) return Math.hypot(p.x - a.x, p.y - a.y);
+  let t = ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(p.x - (a.x + t * dx), p.y - (a.y + t * dy));
+}
+
+// src/contour/medialAxis.ts
+function medialAxis(shape, axialThreshold = 0, distanceThreshold = 0, areaThreshold = 0) {
+  const g = buildMedialAxisGraph(shape);
+  if (!g) return dissolveSegments([]);
+  const kept = pruneEdges(g, axialThreshold, distanceThreshold, areaThreshold);
+  const segs = kept.map((e) => {
+    const a = g.nodes[e.head].position;
+    const b = g.nodes[e.tail].position;
+    return segment(a, b);
+  });
+  return dissolveSegments(segs);
+}
+function buildMedialAxisGraph(shape) {
+  if (!shape.closed || shape.rings.length === 0) return null;
+  const b = bounds(shape);
+  const span = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1);
+  const densified = densify(shape, Math.max(span / 60, 1e-3));
+  const samples = sampleBoundary(densified, Math.max(span / 80, 1e-3));
+  if (samples.length < 3) return null;
+  const uniq = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of samples) {
+    const k = `${p.x.toFixed(6)},${p.y.toFixed(6)}`;
+    if (seen.has(k)) continue;
+    seen.add(k);
+    uniq.push(p);
+  }
+  if (uniq.length < 3) return null;
+  const delaunay = Delaunay.from(
+    uniq,
+    (d) => d.x,
+    (d) => d.y
+  );
+  const pad = span * 0.5;
+  const voronoi2 = delaunay.voronoi([
+    b.minX - pad,
+    b.minY - pad,
+    b.maxX + pad,
+    b.maxY + pad
+  ]);
+  const raw = [];
+  const edgeSeen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < uniq.length; i++) {
+    const poly = voronoi2.cellPolygon(i);
+    if (!poly || poly.length < 2) continue;
+    for (let j = 0; j < poly.length - 1; j++) {
+      const p0 = poly[j];
+      const p1 = poly[j + 1];
+      const a = { x: p0[0], y: p0[1] };
+      const bb = { x: p1[0], y: p1[1] };
+      if (!containsPoint(shape, a) || !containsPoint(shape, bb)) continue;
+      const ek = edgeKey2(a, bb);
+      if (edgeSeen.has(ek)) continue;
+      edgeSeen.add(ek);
+      const mid5 = { x: (a.x + bb.x) / 2, y: (a.y + bb.y) / 2 };
+      const site = uniq[i];
+      const radius = Math.hypot(mid5.x - site.x, mid5.y - site.y);
+      raw.push({ a, b: bb, radius });
+    }
+  }
+  if (raw.length === 0) return null;
+  const nodeIndex = /* @__PURE__ */ new Map();
+  const nodes = [];
+  const ensure = (p, radius) => {
+    const k = key2(p);
+    let id = nodeIndex.get(k);
+    if (id !== void 0) {
+      nodes[id].radius = Math.max(nodes[id].radius, radius);
+      return id;
+    }
+    id = nodes.length;
+    nodeIndex.set(k, id);
+    nodes.push({
+      id,
+      position: p,
+      radius,
+      parent: null,
+      children: [],
+      rootDist: 0,
+      featureArea: Math.PI * radius * radius
+    });
+    return id;
+  };
+  const undirected = [];
+  for (const e of raw) {
+    const midR = e.radius;
+    const u = ensure(e.a, midR);
+    const v = ensure(e.b, midR);
+    if (u === v) continue;
+    const length = Math.hypot(
+      nodes[u].position.x - nodes[v].position.x,
+      nodes[u].position.y - nodes[v].position.y
+    );
+    const axial = length > 1e-12 ? Math.abs(nodes[u].radius - nodes[v].radius) / length : 0;
+    undirected.push({ u, v, axial, length });
+  }
+  const mic = maximumInscribedCircle(shape, Math.max(span * 0.01, 0.1));
+  const rootPos = mic ? { x: mic.x, y: mic.y } : {
+    x: (b.minX + b.maxX) / 2,
+    y: (b.minY + b.maxY) / 2
+  };
+  let root = 0;
+  let bestD = Infinity;
+  for (const n of nodes) {
+    const d = Math.hypot(n.position.x - rootPos.x, n.position.y - rootPos.y);
+    if (d < bestD) {
+      bestD = d;
+      root = n.id;
+    }
+  }
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of undirected) {
+    if (!adj.has(e.u)) adj.set(e.u, []);
+    if (!adj.has(e.v)) adj.set(e.v, []);
+    adj.get(e.u).push({ to: e.v, axial: e.axial, length: e.length });
+    adj.get(e.v).push({ to: e.u, axial: e.axial, length: e.length });
+  }
+  const edges = [];
+  const visited = /* @__PURE__ */ new Set([root]);
+  const queue = [root];
+  nodes[root].rootDist = 0;
+  while (queue.length) {
+    const u = queue.shift();
+    for (const link of adj.get(u) ?? []) {
+      if (visited.has(link.to)) continue;
+      visited.add(link.to);
+      nodes[link.to].parent = u;
+      nodes[u].children.push(link.to);
+      nodes[link.to].rootDist = nodes[u].rootDist + link.length;
+      edges.push({
+        head: u,
+        tail: link.to,
+        axial: link.axial,
+        length: link.length
+      });
+      queue.push(link.to);
+    }
+  }
+  const post = [];
+  const stack = [root];
+  const seenN = /* @__PURE__ */ new Set();
+  while (stack.length) {
+    const u = stack.pop();
+    if (seenN.has(u)) {
+      post.push(u);
+      continue;
+    }
+    seenN.add(u);
+    stack.push(u);
+    for (const c of nodes[u].children) stack.push(c);
+  }
+  for (const u of post) {
+    let area2 = nodes[u].featureArea;
+    for (const c of nodes[u].children) area2 += nodes[c].featureArea;
+    nodes[u].featureArea = area2;
+  }
+  return { nodes, edges, root };
+}
+function pruneEdges(g, axialT, distT, areaT) {
+  const maxDist = Math.max(...g.nodes.map((n) => n.rootDist), 1e-9);
+  const maxArea2 = Math.max(...g.nodes.map((n) => n.featureArea), 1e-9);
+  const maxAxial = Math.max(...g.edges.map((e) => e.axial), 1e-9);
+  const aT = clamp01(axialT);
+  const dT = clamp01(distT);
+  const arT = clamp01(areaT);
+  return g.edges.filter((e) => {
+    const tail = g.nodes[e.tail];
+    if (aT > 0 && e.axial / maxAxial < aT * 0.15 && aT > 0.05) {
+      if (tail.children.length === 0 && e.axial / maxAxial < aT) return false;
+    }
+    if (dT > 0) {
+      const nd = tail.rootDist / maxDist;
+      if (tail.children.length === 0 && nd > 1 - dT && dT > 0) ;
+      if (tail.children.length === 0 && 1 - nd < dT * 0.5 && dT >= 0.5) {
+        return false;
+      }
+      if (tail.children.length === 0 && nd * dT > 0.85) return false;
+    }
+    if (arT > 0) {
+      const na = tail.featureArea / maxArea2;
+      if (na < arT) return false;
+    }
+    if (aT > 0 && e.axial / maxAxial > 1 - aT * 0.5 && tail.children.length === 0) {
+      return false;
+    }
+    return true;
+  });
+}
+function centerLine(shape, straightnessWeighting = 0.7, smoothing = 50) {
+  const g = buildMedialAxisGraph(shape);
+  if (!g || g.nodes.length < 2) {
+    return polyline([]);
+  }
+  const root = g.nodes[g.root];
+  const childRoots = root.children;
+  const leavesOf = (start) => {
+    const out = [];
+    const stack = [start];
+    while (stack.length) {
+      const u = stack.pop();
+      const n = g.nodes[u];
+      if (n.children.length === 0) out.push(n);
+      else stack.push(...n.children);
+    }
+    return out;
+  };
+  let bestPath = [];
+  if (childRoots.length <= 1) {
+    bestPath = longestPathNodes(g);
+  } else if (childRoots.length === 2) {
+    bestPath = pathBetweenLeaves(
+      g,
+      leavesOf(childRoots[0]),
+      leavesOf(childRoots[1]),
+      root,
+      straightnessWeighting
+    );
+  } else {
+    const groups = childRoots.map(leavesOf);
+    let bestW = -Infinity;
+    for (let i = 0; i < groups.length; i++) {
+      for (let j = i + 1; j < groups.length; j++) {
+        const { path: p, weight } = bestLeafPair(
+          g,
+          groups[i],
+          groups[j],
+          root,
+          straightnessWeighting
+        );
+        if (weight > bestW) {
+          bestW = weight;
+          bestPath = p;
+        }
+      }
+    }
+  }
+  if (bestPath.length < 2) bestPath = longestPathNodes(g);
+  const pts = bestPath.map((id) => g.nodes[id].position);
+  return polyline(gaussianSmooth(pts, smoothing));
+}
+function bestLeafPair(g, a, b, root, straightness) {
+  let bestW = -Infinity;
+  let best = [];
+  for (const d1 of a) {
+    for (const d2 of b) {
+      const angle = angleBetween(d1.position, root.position, d2.position);
+      const aw = Math.pow(1 + angle, straightness);
+      const weight = (d1.rootDist + d2.rootDist) * Math.max(aw - 1, 1);
+      if (weight > bestW) {
+        bestW = weight;
+        best = [...pathToRoot(g, d1.id), ...pathToRoot(g, d2.id).reverse().slice(1)];
+      }
+    }
+  }
+  return { path: best, weight: bestW };
+}
+function pathBetweenLeaves(g, a, b, root, straightness) {
+  return bestLeafPair(g, a, b, root, straightness).path;
+}
+function pathToRoot(g, id) {
+  const path3 = [id];
+  let cur = id;
+  while (g.nodes[cur].parent !== null) {
+    cur = g.nodes[cur].parent;
+    path3.push(cur);
+  }
+  return path3;
+}
+function longestPathNodes(g) {
+  const leaves = g.nodes.filter((n) => n.children.length === 0 && n.id !== g.root);
+  if (leaves.length === 0) return g.nodes.map((n) => n.id);
+  let farthest = leaves[0];
+  let best = -1;
+  for (const L of leaves) {
+    if (L.rootDist > best) {
+      best = L.rootDist;
+      farthest = L;
+    }
+  }
+  let bestPath = pathToRoot(g, farthest.id);
+  let bestLen = farthest.rootDist;
+  for (const L of leaves) {
+    if (L.id === farthest.id) continue;
+    const p = [
+      ...pathToRoot(g, farthest.id),
+      ...pathToRoot(g, L.id).reverse().slice(1)
+    ];
+    const len2 = farthest.rootDist + L.rootDist;
+    if (len2 > bestLen) {
+      bestLen = len2;
+      bestPath = p;
+    }
+  }
+  return bestPath;
+}
+function angleBetween(a, apex, b) {
+  const ax = a.x - apex.x;
+  const ay = a.y - apex.y;
+  const bx = b.x - apex.x;
+  const by = b.y - apex.y;
+  const la = Math.hypot(ax, ay) || 1;
+  const lb = Math.hypot(bx, by) || 1;
+  const cos = Math.max(-1, Math.min(1, (ax * bx + ay * by) / (la * lb)));
+  return Math.acos(cos);
+}
+function gaussianSmooth(pts, sigma) {
+  if (pts.length < 3 || sigma <= 0) return pts;
+  const radius = Math.max(1, Math.round(Math.min(pts.length / 4, sigma / 10)));
+  const out = [];
+  for (let i = 0; i < pts.length; i++) {
+    let sx = 0;
+    let sy = 0;
+    let w = 0;
+    for (let k = -radius; k <= radius; k++) {
+      const j = Math.max(0, Math.min(pts.length - 1, i + k));
+      const wk = Math.exp(-(k * k) / (2 * (radius * 0.5) ** 2 + 1e-9));
+      sx += pts[j].x * wk;
+      sy += pts[j].y * wk;
+      w += wk;
+    }
+    out.push({ x: sx / w, y: sy / w });
+  }
+  out[0] = pts[0];
+  out[out.length - 1] = pts[pts.length - 1];
+  return out;
+}
+function key2(p) {
+  return `${p.x.toFixed(7)},${p.y.toFixed(7)}`;
+}
+function edgeKey2(a, b) {
+  const ka = key2(a);
+  const kb = key2(b);
+  return ka < kb ? `${ka}|${kb}` : `${kb}|${ka}`;
+}
+function clamp01(v) {
+  return Math.max(0, Math.min(1, v));
+}
+
+// src/contour/straightSkeleton.ts
+function straightSkeleton(shape) {
+  const parts = straightSkeletonParts(shape);
+  return group([
+    ...parts.faces.paths,
+    ...parts.branches.paths,
+    ...parts.bones.paths
+  ]);
+}
+function straightSkeletonParts(shape) {
+  const empty = {
+    faces: group([]),
+    branches: group([]),
+    bones: group([])
+  };
+  if (!shape.closed || !shape.rings[0] || shape.rings[0].length < 3) {
+    return empty;
+  }
+  const b = bounds(shape);
+  const span = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1);
+  const delta = Math.max(span / 40, 0.5);
+  const densified = densify(shape, Math.max(span / 40, 1e-3));
+  const levels = [densified];
+  let current = densified;
+  for (let i = 0; i < 40; i++) {
+    const next = buffer(current, -delta);
+    if (next.paths.length === 0) break;
+    let best = next.paths[0];
+    let bestA = -1;
+    for (const p of next.paths) {
+      const bb = bounds(p);
+      const a = (bb.maxX - bb.minX) * (bb.maxY - bb.minY);
+      if (a > bestA) {
+        bestA = a;
+        best = p;
+      }
+    }
+    if (!best.rings[0] || best.rings[0].length < 3) break;
+    levels.push(best);
+    current = best;
+  }
+  const boneSegs = [];
+  for (let i = 0; i < levels.length - 1; i++) {
+    const a = levels[i];
+    const bb = levels[i + 1];
+    const ca = centroid(a);
+    const cb = centroid(bb);
+    if (containsPoint(shape, mid2(ca, cb))) {
+      boneSegs.push(segment(ca, cb));
+    }
+    for (const ring2 of a.rings) {
+      for (const p of ring2) {
+        const q = nearestOnPath(bb, p);
+        if (q && containsPoint(shape, mid2(p, q))) {
+          boneSegs.push(segment(p, q));
+        }
+      }
+    }
+  }
+  const branchSegs = [];
+  const outer = densified.rings[0];
+  const target = levels[1] ?? levels[0];
+  for (let i = 0; i < outer.length; i++) {
+    const a = outer[i];
+    const bb = outer[(i + 1) % outer.length];
+    const m = mid2(a, bb);
+    const q = nearestOnPath(target, m);
+    if (q) branchSegs.push(segment(m, q));
+  }
+  const faces = [];
+  if (levels.length >= 2) {
+    const inner = levels[1].rings[0] ?? [];
+    for (let i = 0; i < outer.length; i++) {
+      const a = outer[i];
+      const bb = outer[(i + 1) % outer.length];
+      const ia = nearestOnRing(inner, a);
+      const ib = nearestOnRing(inner, bb);
+      if (ia && ib) {
+        const face = [a, bb, ib, ia];
+        const c = {
+          x: (a.x + bb.x + ib.x + ia.x) / 4,
+          y: (a.y + bb.y + ib.y + ia.y) / 4
+        };
+        if (containsPoint(shape, c)) faces.push(polygon(face));
+      }
+    }
+  }
+  return {
+    faces: group(faces),
+    branches: dissolveSegments(branchSegs),
+    bones: dissolveSegments(boneSegs)
+  };
+}
+function mid2(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+function nearestOnPath(p, q) {
+  let best = null;
+  let bestD = Infinity;
+  for (const ring2 of p.rings) {
+    for (const v of ring2) {
+      const d = Math.hypot(v.x - q.x, v.y - q.y);
+      if (d < bestD) {
+        bestD = d;
+        best = v;
+      }
+    }
+  }
+  return best;
+}
+function nearestOnRing(ring2, q) {
+  if (ring2.length === 0) return null;
+  let best = ring2[0];
+  let bestD = Infinity;
+  for (const v of ring2) {
+    const d = Math.hypot(v.x - q.x, v.y - q.y);
+    if (d < bestD) {
+      bestD = d;
+      best = v;
+    }
+  }
+  return best;
+}
+
+// src/contour/marchingSquares.ts
+function isolinesFromFunction(bounds2, sampleSpacing, contourInterval, fn, isolineMin = Number.NaN, isolineMax = Number.NaN) {
+  const [xmin, ymin, xmax, ymax] = bounds2;
+  const dx = Math.max(sampleSpacing, 1e-9);
+  const dy = dx;
+  const nx = Math.max(2, Math.ceil((xmax - xmin) / dx) + 1);
+  const ny = Math.max(2, Math.ceil((ymax - ymin) / dy) + 1);
+  const grid = [];
+  let gmin = Infinity;
+  let gmax = -Infinity;
+  for (let j = 0; j < ny; j++) {
+    const row = [];
+    const y = ymin + j * ((ymax - ymin) / (ny - 1));
+    for (let i = 0; i < nx; i++) {
+      const x = xmin + i * ((xmax - xmin) / (nx - 1));
+      let v = fn(x, y);
+      if (!Number.isFinite(v)) v = Number.NEGATIVE_INFINITY;
+      row.push(v);
+      if (Number.isFinite(v)) {
+        gmin = Math.min(gmin, v);
+        gmax = Math.max(gmax, v);
+      }
+    }
+    grid.push(row);
+  }
+  const z0 = Number.isFinite(isolineMin) ? isolineMin : gmin;
+  const z1 = Number.isFinite(isolineMax) ? isolineMax : gmax;
+  if (!Number.isFinite(z0) || !Number.isFinite(z1) || contourInterval <= 0) {
+    return group([]);
+  }
+  const levels = [];
+  const start = Math.ceil(z0 / contourInterval) * contourInterval;
+  for (let z = start; z <= z1 + 1e-12; z += contourInterval) {
+    levels.push(z);
+  }
+  const segs = [];
+  for (const level of levels) {
+    segs.push(...marchLevel(grid, xmin, ymin, xmax, ymax, nx, ny, level));
+  }
+  return dissolveSegments(segs);
+}
+function isolineZeroFromFunction(bounds2, sampleSpacing, fn) {
+  return isolinesFromFunction(bounds2, sampleSpacing, 1, fn, 0, 0);
+}
+function marchLevel(grid, xmin, ymin, xmax, ymax, nx, ny, level) {
+  const segs = [];
+  const xAt = (i) => xmin + i / (nx - 1) * (xmax - xmin);
+  const yAt = (j) => ymin + j / (ny - 1) * (ymax - ymin);
+  const lerp2 = (x0, y0, v0, x1, y1, v1) => {
+    const t = (level - v0) / (v1 - v0 || 1e-15);
+    return { x: x0 + t * (x1 - x0), y: y0 + t * (y1 - y0) };
+  };
+  for (let j = 0; j < ny - 1; j++) {
+    for (let i = 0; i < nx - 1; i++) {
+      const v00 = grid[j][i];
+      const v10 = grid[j][i + 1];
+      const v11 = grid[j + 1][i + 1];
+      const v01 = grid[j + 1][i];
+      const x0 = xAt(i);
+      const x1 = xAt(i + 1);
+      const y0 = yAt(j);
+      const y1 = yAt(j + 1);
+      let code = 0;
+      if (v00 >= level) code |= 1;
+      if (v10 >= level) code |= 2;
+      if (v11 >= level) code |= 4;
+      if (v01 >= level) code |= 8;
+      if (code === 0 || code === 15) continue;
+      const bottom = () => lerp2(x0, y0, v00, x1, y0, v10);
+      const right = () => lerp2(x1, y0, v10, x1, y1, v11);
+      const top = () => lerp2(x0, y1, v01, x1, y1, v11);
+      const left = () => lerp2(x0, y0, v00, x0, y1, v01);
+      const add = (a, b) => segs.push(segment(a, b));
+      switch (code) {
+        case 1:
+        case 14:
+          add(left(), bottom());
+          break;
+        case 2:
+        case 13:
+          add(bottom(), right());
+          break;
+        case 3:
+        case 12:
+          add(left(), right());
+          break;
+        case 4:
+        case 11:
+          add(right(), top());
+          break;
+        case 6:
+        case 9:
+          add(bottom(), top());
+          break;
+        case 7:
+        case 8:
+          add(left(), top());
+          break;
+        case 5: {
+          const avg = (v00 + v10 + v11 + v01) / 4;
+          if (avg >= level) {
+            add(left(), top());
+            add(bottom(), right());
+          } else {
+            add(left(), bottom());
+            add(right(), top());
+          }
+          break;
+        }
+        case 10: {
+          const avg = (v00 + v10 + v11 + v01) / 4;
+          if (avg >= level) {
+            add(left(), bottom());
+            add(right(), top());
+          } else {
+            add(left(), top());
+            add(bottom(), right());
+          }
+          break;
+        }
+      }
+    }
+  }
+  return segs;
+}
+function isolinesFromPoints(points, values, intervals, _smoothing = 0) {
+  if (points.length < 3 || intervals < 1) return group([]);
+  let minZ = Infinity;
+  let maxZ = -Infinity;
+  for (const v of values) {
+    minZ = Math.min(minZ, v);
+    maxZ = Math.max(maxZ, v);
+  }
+  if (!Number.isFinite(minZ) || maxZ - minZ < 1e-15) return group([]);
+  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, 1);
+  const sampleSpacing = span / Math.max(20, Math.sqrt(points.length));
+  const interval = (maxZ - minZ) / intervals;
+  const fn = (x, y) => {
+    let num2 = 0;
+    let den = 0;
+    for (let i = 0; i < points.length; i++) {
+      const p = points[i];
+      const d2 = (x - p.x) ** 2 + (y - p.y) ** 2;
+      const w = 1 / Math.max(d2, 1e-12);
+      num2 += w * values[i];
+      den += w;
+    }
+    return num2 / den;
+  };
+  return isolinesFromFunction(
+    [minX, minY, maxX, maxY],
+    sampleSpacing,
+    interval,
+    fn,
+    minZ,
+    maxZ
+  );
+}
+
+// src/contour/fields.ts
+function distanceField(shape, spacing, pole) {
+  if (!shape.closed || shape.rings.length === 0 || spacing <= 0) return group([]);
+  const b = bounds(shape);
+  const span = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1);
+  let polePt = pole;
+  if (!polePt) {
+    const mic = maximumInscribedCircle(shape, Math.max(span * 0.01, 0.1));
+    polePt = mic ? { x: mic.x, y: mic.y } : { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 };
+  }
+  const pad = Math.max(spacing, 1);
+  const box = [
+    b.minX - pad,
+    b.minY - pad,
+    b.maxX + pad,
+    b.maxY + pad
+  ];
+  const sampleSpacing = Math.max(spacing / 10, span / 80);
+  const fn = (x, y) => {
+    const p = { x, y };
+    if (!insideSafe(shape, p)) return Number.NEGATIVE_INFINITY;
+    const dGeo = distanceToBoundary2(shape, p);
+    const dPoint = Math.hypot(x - polePt.x, y - polePt.y);
+    return dGeo - dPoint;
+  };
+  const raw = isolinesFromFunction(box, sampleSpacing, spacing, fn);
+  return clipPolylinesToPath(raw, shape);
+}
+function contrastField(shape, intervals, reference) {
+  if (!shape.closed || shape.rings.length === 0 || intervals < 1) {
+    return group([]);
+  }
+  const b = bounds(shape);
+  const areaApprox = (b.maxX - b.minX) * (b.maxY - b.minY);
+  const count = Math.max(100, Math.floor(areaApprox / 100));
+  const minDist = Math.sqrt(areaApprox / (count * 1.5));
+  const samples = poisson(
+    Math.max(minDist, 1e-3),
+    b.minX,
+    b.minY,
+    b.maxX,
+    b.maxY,
+    1337
+  ).filter((p) => containsPoint(shape, p));
+  if (samples.length < 3) return group([]);
+  const values = samples.map((p) => {
+    const dB = distanceToBoundary2(shape, p);
+    const dR = Math.hypot(p.x - reference.x, p.y - reference.y);
+    return Math.abs(dB - dR);
+  });
+  const lines = isolinesFromPoints(samples, values, Math.max(1, intervals), 0);
+  return clipPolylinesToPath(lines, shape);
+}
+function isolines(shape, highPoint, intervalSpacing) {
+  if (!shape.closed || intervalSpacing <= 0) return group([]);
+  const b = bounds(shape);
+  const span = Math.max(b.maxX - b.minX, b.maxY - b.minY, 1);
+  const pad = intervalSpacing;
+  const box = [
+    b.minX - pad,
+    b.minY - pad,
+    b.maxX + pad,
+    b.maxY + pad
+  ];
+  const fn = (x, y) => {
+    if (!containsPoint(shape, { x, y })) return -1;
+    return Math.hypot(x - highPoint.x, y - highPoint.y);
+  };
+  const raw = isolinesFromFunction(
+    box,
+    Math.max(intervalSpacing / 8, span / 100),
+    intervalSpacing,
+    fn,
+    0,
+    span
+  );
+  return clipPolylinesToPath(raw, shape);
+}
+function clipPolylinesToPath(g, shape) {
+  const paths = [];
+  for (const p of g.paths) {
+    const ring2 = p.rings[0];
+    if (!ring2 || ring2.length < 2) continue;
+    let current = [];
+    const flush = () => {
+      if (current.length >= 2) {
+        paths.push({ rings: [current], closed: false });
+      }
+      current = [];
+    };
+    for (let i = 0; i < ring2.length - 1; i++) {
+      const a = ring2[i];
+      const b = ring2[i + 1];
+      if (!finitePt(a) || !finitePt(b)) {
+        flush();
+        continue;
+      }
+      const mid5 = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+      if (insideSafe(shape, mid5)) {
+        if (current.length === 0) current.push(a);
+        current.push(b);
+      } else {
+        flush();
+      }
+    }
+    flush();
+  }
+  return group(paths);
+}
+function finitePt(p) {
+  return Number.isFinite(p.x) && Number.isFinite(p.y);
+}
+function insideSafe(shape, point) {
+  if (!finitePt(point)) return false;
+  try {
+    return containsPoint(shape, point);
+  } catch {
+    return pointInPoly2(point, shape.rings[0]) && shape.rings.slice(1).every((h) => !pointInPoly2(point, h));
+  }
+}
+function pointInPoly2(point, ring2) {
+  let inside = false;
+  for (let i = 0, j = ring2.length - 1; i < ring2.length; j = i++) {
+    const pi = ring2[i];
+    const pj = ring2[j];
+    if (pi.y > point.y !== pj.y > point.y && point.x < (pj.x - pi.x) * (point.y - pi.y) / (pj.y - pi.y + 1e-15) + pi.x) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+
+// src/contour/distanceTree.ts
+function key3(v) {
+  return `${v.x.toFixed(8)},${v.y.toFixed(8)}`;
+}
+function distanceTree(mesh, source, flatten2) {
+  const adj = /* @__PURE__ */ new Map();
+  const pts = /* @__PURE__ */ new Map();
+  const addEdge = (a, b) => {
+    const ka = key3(a);
+    const kb = key3(b);
+    if (ka === kb) return;
+    pts.set(ka, a);
+    pts.set(kb, b);
+    if (!adj.has(ka)) adj.set(ka, []);
+    if (!adj.has(kb)) adj.set(kb, []);
+    adj.get(ka).push({ to: kb, pt: b });
+    adj.get(kb).push({ to: ka, pt: a });
+  };
+  for (const face of mesh.paths) {
+    for (const ring2 of face.rings) {
+      if (ring2.length < 2) continue;
+      const n = ring2.length;
+      const closed = face.closed;
+      const limit = closed ? n : n - 1;
+      for (let i = 0; i < limit; i++) {
+        addEdge(ring2[i], ring2[(i + 1) % n]);
+      }
+    }
+  }
+  if (pts.size === 0) return group([]);
+  let sourceKey = "";
+  let best = Infinity;
+  for (const [k, p] of pts) {
+    const d = Math.hypot(p.x - source.x, p.y - source.y);
+    if (d < best) {
+      best = d;
+      sourceKey = k;
+    }
+  }
+  const parent = /* @__PURE__ */ new Map();
+  parent.set(sourceKey, null);
+  const q = [sourceKey];
+  while (q.length) {
+    const u = q.shift();
+    for (const { to } of adj.get(u) ?? []) {
+      if (parent.has(to)) continue;
+      parent.set(to, u);
+      q.push(to);
+    }
+  }
+  if (flatten2) {
+    const segs = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const [v, p] of parent) {
+      if (p === null) continue;
+      const ek = v < p ? `${v}|${p}` : `${p}|${v}`;
+      if (seen.has(ek)) continue;
+      seen.add(ek);
+      segs.push(segment(pts.get(p), pts.get(v)));
+    }
+    return dissolveSegments(segs);
+  }
+  const paths = [];
+  for (const [v] of parent) {
+    if (v === sourceKey) continue;
+    const chain = [];
+    let cur = v;
+    while (cur !== null) {
+      chain.push(pts.get(cur));
+      cur = parent.get(cur) ?? null;
+    }
+    chain.reverse();
+    if (chain.length >= 2) paths.push(polyline(chain));
+  }
+  return group(paths);
+}
+
+// src/contour/index.ts
+function offsetCurvesOutward(p, distance) {
+  return buffer(p, Math.abs(distance));
+}
+function offsetCurvesInward(p, distance) {
+  return buffer(p, -Math.abs(distance));
+}
+var contour = {
+  offsetCurvesOutward,
+  offsetCurvesInward,
+  medialAxis,
+  chordalAxis,
+  straightSkeleton,
+  straightSkeletonParts,
+  centerLine,
+  distanceField,
+  contrastField,
+  distanceTree,
+  isolines,
+  isolinesFromFunction,
+  isolineZeroFromFunction,
+  isolinesFromPoints,
+  dissolveSegments
+};
 function compoundVoronoi(sites, options = {}) {
   if (sites.length === 0) return group([]);
   if (sites.length === 1) {
@@ -2541,11 +3581,11 @@ function subdivideQuad(p) {
   if (!ring2 || ring2.length < 4) return [p];
   const [a, b, c, d] = ring2;
   if (!a || !b || !c || !d) return [p];
-  const mab = mid(a, b);
-  const mbc = mid(b, c);
-  const mcd = mid(c, d);
-  const mda = mid(d, a);
-  const cen = mid(mid(a, c), mid(b, d));
+  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]),
@@ -2571,9 +3611,9 @@ function subdivideTriangle(p) {
   const a = ring2[0];
   const b = ring2[1];
   const c = ring2[2];
-  const mab = mid(a, b);
-  const mbc = mid(b, c);
-  const mca = mid(c, a);
+  const mab = mid3(a, b);
+  const mbc = mid3(b, c);
+  const mca = mid3(c, a);
   return [
     polygon([a, mab, mca]),
     polygon([mab, b, mbc]),
@@ -2608,7 +3648,7 @@ function sliceDivision(p, spacing, angle = 0) {
 function hatchSubdivision(p, spacing, angle = 0) {
   return sliceDivision(p, spacing, angle);
 }
-function mid(a, b) {
+function mid3(a, b) {
   return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
 }
 var tiling = {
@@ -2814,7 +3854,7 @@ var polygonisation = {
 };
 
 // src/meshing/index.ts
-function edgeKey(a, b) {
+function edgeKey3(a, b) {
   const aKey = `${a.x},${a.y}`;
   const bKey = `${b.x},${b.y}`;
   return aKey < bKey ? `${aKey}|${bKey}` : `${bKey}|${aKey}`;
@@ -2822,13 +3862,13 @@ function edgeKey(a, b) {
 function vertKey(v) {
   return `${v.x},${v.y}`;
 }
-function same(a, b, eps = 1e-12) {
+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 mid2(a, b) {
+function mid4(a, b) {
   return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
 }
 function lerp(a, b, t) {
@@ -2862,10 +3902,10 @@ function buildEdgeMap(faces) {
     for (let i = 0; i < lim; i++) {
       const a = ring2[i];
       const b = ring2[(i + 1) % n];
-      const key = edgeKey(a, b);
-      const rec = edges.get(key);
+      const key4 = edgeKey3(a, b);
+      const rec = edges.get(key4);
       if (rec) rec.faceIds.push(fi);
-      else edges.set(key, { a: { ...a }, b: { ...b }, faceIds: [fi] });
+      else edges.set(key4, { a: { ...a }, b: { ...b }, faceIds: [fi] });
     }
   });
   return edges;
@@ -2909,8 +3949,8 @@ function facesFromKeptEdges(tris, kept) {
     if (ra !== rb) parent[rb] = ra;
   };
   const edgeMap = buildEdgeMap(tris);
-  for (const [key, e] of edgeMap) {
-    if (e.faceIds.length === 2 && !kept.has(key)) {
+  for (const [key4, e] of edgeMap) {
+    if (e.faceIds.length === 2 && !kept.has(key4)) {
       unite(e.faceIds[0], e.faceIds[1]);
     }
   }
@@ -2936,10 +3976,10 @@ function boundaryRingOfComponent(tris, members) {
     for (let i = 0; i < ring2.length; i++) {
       const a = ring2[i];
       const b = ring2[(i + 1) % ring2.length];
-      const key = edgeKey(a, b);
-      const rec = edgeCount.get(key);
+      const key4 = edgeKey3(a, b);
+      const rec = edgeCount.get(key4);
       if (rec) rec.n++;
-      else edgeCount.set(key, { a: { ...a }, b: { ...b }, n: 1 });
+      else edgeCount.set(key4, { a: { ...a }, b: { ...b }, n: 1 });
     }
   }
   const boundary = [];
@@ -2969,14 +4009,14 @@ function orderEdgesIntoRing(edges) {
   const maxSteps = edges.length + 2;
   for (let step = 0; step < maxSteps; step++) {
     ring2.push({ ...curr });
-    if (same(curr, start) && ring2.length > 2) {
+    if (same2(curr, start) && ring2.length > 2) {
       ring2.pop();
       return ring2;
     }
     const nbrs = adj.get(vertKey(curr)) ?? [];
     let next = null;
     for (const n of nbrs) {
-      if (!same(n, prev)) {
+      if (!same2(n, prev)) {
         next = n;
         break;
       }
@@ -2991,13 +4031,13 @@ function applyEdgeFilter(tris, shouldKeep, preservePerimeter) {
   const edgeMap = buildEdgeMap(tris);
   const peri = perimeterKeys(edgeMap);
   const kept = /* @__PURE__ */ new Set();
-  for (const [key, e] of edgeMap) {
-    const isPeri = peri.has(key);
+  for (const [key4, e] of edgeMap) {
+    const isPeri = peri.has(key4);
     if (isPeri && preservePerimeter) {
-      kept.add(key);
+      kept.add(key4);
       continue;
     }
-    if (shouldKeep(e.a, e.b, isPeri)) kept.add(key);
+    if (shouldKeep(e.a, e.b, isPeri)) kept.add(key4);
   }
   return facesFromKeptEdges(tris, kept);
 }
@@ -3025,8 +4065,8 @@ function extractInnerVertices(faces) {
   const edgeMap = buildEdgeMap(faces);
   const peri = perimeterKeys(edgeMap);
   const periVerts = /* @__PURE__ */ new Set();
-  for (const key of peri) {
-    const e = edgeMap.get(key);
+  for (const key4 of peri) {
+    const e = edgeMap.get(key4);
     periVerts.add(vertKey(e.a));
     periVerts.add(vertKey(e.b));
   }
@@ -3076,10 +4116,10 @@ function densifyRing2(ring2, maxLen) {
   return out;
 }
 function isGabriel(a, b, points) {
-  const m = mid2(a, b);
+  const m = mid4(a, b);
   const r = dist(a, b) / 2;
   for (const p of points) {
-    if (same(p, a) || same(p, b)) continue;
+    if (same2(p, a) || same2(p, b)) continue;
     if (dist(p, m) < r - 1e-9) return false;
   }
   return true;
@@ -3087,7 +4127,7 @@ function isGabriel(a, b, points) {
 function isRelativeNeighbor(a, b, points) {
   const dab = dist(a, b);
   for (const p of points) {
-    if (same(p, a) || same(p, b)) continue;
+    if (same2(p, a) || same2(p, b)) continue;
     if (Math.max(dist(p, a), dist(p, b)) < dab - 1e-9) return false;
   }
   return true;
@@ -3108,7 +4148,7 @@ function urquhartFaces(input, preservePerimeter = false) {
       const d = dist(a, b);
       if (d > longestLen) {
         longestLen = d;
-        longestKey = edgeKey(a, b);
+        longestKey = edgeKey3(a, b);
       }
     }
     if (longestKey && !(preservePerimeter && peri.has(longestKey))) {
@@ -3116,8 +4156,8 @@ function urquhartFaces(input, preservePerimeter = false) {
     }
   }
   const kept = /* @__PURE__ */ new Set();
-  for (const key of edgeMap.keys()) {
-    if (!removed.has(key)) kept.add(key);
+  for (const key4 of edgeMap.keys()) {
+    if (!removed.has(key4)) kept.add(key4);
   }
   return group(facesFromKeptEdges(tris, kept));
 }
@@ -3148,12 +4188,12 @@ function spannerFaces(input, k = 1, preservePerimeter = false) {
   const edgeMap = buildEdgeMap(tris);
   const peri = perimeterKeys(edgeMap);
   const stretch = Math.max(1, k);
-  const edges = [...edgeMap.entries()].map(([key, e]) => ({
-    key,
+  const edges = [...edgeMap.entries()].map(([key4, e]) => ({
+    key: key4,
     a: e.a,
     b: e.b,
     len: dist(e.a, e.b),
-    peri: peri.has(key)
+    peri: peri.has(key4)
   }));
   edges.sort((a, b) => a.len - b.len);
   const adj = /* @__PURE__ */ new Map();
@@ -3208,8 +4248,8 @@ function dualFaces(faces) {
   const edgeMap = buildEdgeMap(faces);
   const peri = perimeterKeys(edgeMap);
   const periVerts = /* @__PURE__ */ new Set();
-  for (const key of peri) {
-    const e = edgeMap.get(key);
+  for (const key4 of peri) {
+    const e = edgeMap.get(key4);
     periVerts.add(vertKey(e.a));
     periVerts.add(vertKey(e.b));
   }
@@ -3245,8 +4285,8 @@ function triVerts(t) {
 function midpointMap(faces) {
   const mids = /* @__PURE__ */ new Map();
   const edgeMap = buildEdgeMap(faces);
-  for (const [key, e] of edgeMap) {
-    mids.set(key, mid2(e.a, e.b));
+  for (const [key4, e] of edgeMap) {
+    mids.set(key4, mid4(e.a, e.b));
   }
   return mids;
 }
@@ -3256,7 +4296,7 @@ function centroidQuadrangulation(input, preservePerimeter = true) {
   const centers = tris.map((t) => centroid(t));
   const out = [];
   const peri = perimeterKeys(edgeMap);
-  for (const [key, e] of edgeMap) {
+  for (const [key4, e] of edgeMap) {
     const ids = e.faceIds;
     if (ids.length === 2) {
       const c0 = centers[ids[0]];
@@ -3265,7 +4305,7 @@ function centroidQuadrangulation(input, preservePerimeter = true) {
     } else if (ids.length === 1 && preservePerimeter) {
       const c0 = centers[ids[0]];
       out.push(polygon([e.a, e.b, c0]));
-    } else if (ids.length === 1 && !preservePerimeter && peri.has(key)) ;
+    } else if (ids.length === 1 && !preservePerimeter && peri.has(key4)) ;
   }
   return group(out);
 }
@@ -3278,9 +4318,9 @@ function splitQuadrangulation(input) {
     if (!v) continue;
     const [a, b, c] = v;
     const g = centroid(t);
-    const mab = mids.get(edgeKey(a, b)) ?? mid2(a, b);
-    const mbc = mids.get(edgeKey(b, c)) ?? mid2(b, c);
-    const mca = mids.get(edgeKey(c, a)) ?? mid2(c, a);
+    const mab = mids.get(edgeKey3(a, b)) ?? mid4(a, b);
+    const mbc = mids.get(edgeKey3(b, c)) ?? mid4(b, c);
+    const mca = mids.get(edgeKey3(c, a)) ?? mid4(c, a);
     out.push(polygon([a, mab, g, mca]));
     out.push(polygon([b, mbc, g, mab]));
     out.push(polygon([c, mca, g, mbc]));
@@ -3291,13 +4331,13 @@ function edgeCollapseQuadrangulation(input, preservePerimeter = true) {
   const tris = asTriFaces(input);
   const edgeMap = buildEdgeMap(tris);
   const candidates = [];
-  for (const [key, e] of edgeMap) {
+  for (const [key4, e] of edgeMap) {
     if (e.faceIds.length !== 2) continue;
     const [i, j] = e.faceIds;
     const quad = mergeTriPair(tris[i], tris[j], e.a, e.b);
     if (!quad) continue;
     candidates.push({
-      key,
+      key: key4,
       a: e.a,
       b: e.b,
       i,
@@ -3333,7 +4373,7 @@ function mergeTriPair(t0, t1, ea, eb) {
 }
 function oppositeVertex(t, ea, eb) {
   for (const v of ringOf(t)) {
-    if (!same(v, ea) && !same(v, eb)) return v;
+    if (!same2(v, ea) && !same2(v, eb)) return v;
   }
   return null;
 }
@@ -3395,8 +4435,8 @@ function vertexNeighborhood(faces) {
   const edgeMap = buildEdgeMap(faces);
   const peri = perimeterKeys(edgeMap);
   const perimeter = /* @__PURE__ */ new Set();
-  for (const key of peri) {
-    const e = edgeMap.get(key);
+  for (const key4 of peri) {
+    const e = edgeMap.get(key4);
     perimeter.add(vertKey(e.a));
     perimeter.add(vertKey(e.b));
   }
@@ -3519,8 +4559,8 @@ function simplifyMesh(faces, tolerance, preservePerimeter = true) {
   };
   const periVerts = /* @__PURE__ */ new Set();
   if (preservePerimeter) {
-    for (const key of peri) {
-      const e = edgeMap.get(key);
+    for (const key4 of peri) {
+      const e = edgeMap.get(key4);
       periVerts.add(vertKey(e.a));
       periVerts.add(vertKey(e.b));
     }
@@ -3741,8 +4781,8 @@ function findBreaks(faces) {
 function nearDuplicateEdge(a, b, tol) {
   const d1 = dist(a.a, b.a) + dist(a.b, b.b);
   const d2 = dist(a.a, b.b) + dist(a.b, b.a);
-  const len = dist(a.a, a.b);
-  return Math.min(d1, d2) < tol * 2 + len * 0.05 && Math.min(d1, d2) > 1e-9;
+  const len2 = dist(a.a, a.b);
+  return Math.min(d1, d2) < tol * 2 + len2 * 0.05 && Math.min(d1, d2) > 1e-9;
 }
 function fixBreaks(faces, maxGapWidth) {
   if (faces.length === 0) return group([]);
@@ -3851,7 +4891,7 @@ function fixBrokenFaces(coverage, tolerance, polygonise = true) {
       out.push(p);
       continue;
     }
-    if (ring2.length >= 3 && same(ring2[0], ring2[ring2.length - 1], tol * 2)) {
+    if (ring2.length >= 3 && same2(ring2[0], ring2[ring2.length - 1], tol * 2)) {
       out.push(polygon(ring2.slice(0, -1)));
     } else if (ring2.length >= 3 && dist(ring2[0], ring2[ring2.length - 1]) <= tol * 2) {
       out.push(polygon(ring2));
@@ -3928,6 +4968,6 @@ var meshing = {
   findIslands
 };
 
-export { angular, area, areaGroup, areaMerge, areaSimilarity, assertAreaClose, boundingBox, bounds, buffer, centroid, centroidQuadrangulation, centroidSortFaces, centroidSplit, chaikinCut, circle, circleCenter, circleContainedInPath, circleOverlapsPath, circlePacking, circular, clipSegmentToPath, clipSegmentsToPath, cloneGroup, clonePath, cloneVec2, closestPoint, closestPointPair, closestVertex, complement, compoundVoronoi, construction, containmentAgreement, containsPoint, contour, conversion, convexHull, convexHullPath, copy, createArc, createCircle, createKochSnowflake, createRect, createRegularPolygon, createRing, createStar, delaunayTriangulation, delaunayTriangulationPoints, densify, dilationErosion, dissolve, dualFaces, earCutTriangulation, edgeCollapseQuadrangulation, envelope, equalsVec2, erosionDilation, extractBoundary, extractHoles, extractInnerEdges, extractInnerVertices, extractPerimeter, farthestPointPair, filterAxisAligned, filterByMinLength, findBreaks, findContainingFace, findIslands, fixBreaks, fixBrokenFaces, flatten, flipHorizontal, flipVertical, fromArray, fromContours, frontChainPack, gabrielFaces, generateRandomGridPoints, generateRandomPoints, group, groupFromPaths, hatch, cross as hatchCross, parallel as hatchParallel, hatchSubdivision, height, hexGrid, hexLatticePack, hexTiling, hilbert as hilbertPolygonise, hull, innerVoronoi, innerVoronoiRaw, intersect, intersectionPoints, largestEmptyCircle, largestEmptyCircles, matchingQuadrangulation, maxArea, maximumInscribedAARectangle, maximumInscribedCircle, maximumInscribedPack, maximumInscribedPackUntil, meshing, minArea, minPerimeter, minimumBoundingCircle, minkDifference, minkSum, morphology, normalizeRing, obstaclePack, occlusionSubtract, offsetCurvesInward, offsetCurvesOutward, onion, onionLayers, optimisation, oraclePathsToGroup, originScale, overlapRegions, parallelSegments, parsePathData, parseSvg, path, ring as pointRing, pointSet, pointsOnExterior, poisson, poissonTriangulation, poissonTriangulationPoints, polygon, polygonisation, horizontal as polygoniseHorizontal, vertical as polygoniseVertical, polyline, predicates, processing, prunePointsWithinDistance, quadSubdivision, radialSortFaces, radialWarp, random as randomPoints, rectSubdivision, reducePrecision, refine, relativeAreaError, relativeNeighborFaces, removeSmallHoles, repulsionPack, resizeByHeight, resizeByWidth, ringArea, ringsToPath, rotate, rotateAroundCenter, roundVertexCoords, scale, segment, segmentLength, segmentSet, segmentsOnExterior, segmentsToOpenPaths, serializePathData, shapeBoolean, shear, simplify, simplifyMesh, sineWarp, slice, sliceDivision, smooth, smoothMesh, spannerFaces, spiralQuadrangulation, splitEdges, splitQuadrangulation, squareGrid, squareLatticePack, squareGrid2 as squareTiling, stochasticMerge, stochasticPack, subdivideMesh, subtract, subtractAll, symDifference, tiling, toArray, toContours, toSvg, transformation, translate, translateCentroidTo, translateCornerTo, translateToOrigin, triangleSubdivision, triangulation, union, unionAll, urquhartFaces, vec2, voronoi, width };
+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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map