pattapatta 0.2.1 → 0.3.0

package/dist/contour/index.js

@@ -1,4 +1,5 @@
-import { FillRule, JoinType, inflatePathsD, EndType, isPositiveD, pointInPolygonD, PointInPolygonResult } from 'clipper2-ts';
+import { FillRule, JoinType, inflatePathsD, EndType, triangulateD, pointInPolygonD, PointInPolygonResult, isPositiveD } from 'clipper2-ts';
+import { Delaunay } from 'd3-delaunay';
 
 // src/types/vec2.ts
 function vec2(x, y) {
@@ -11,6 +12,16 @@ function equalsVec2(a, b, eps = 1e-9) {
   return Math.abs(a.x - b.x) <= eps && Math.abs(a.y - b.y) <= eps;
 }
 
+// src/types/circle.ts
+function circle(x, y, r) {
+  return { x, y, r };
+}
+
+// src/types/segment.ts
+function segment(a, b) {
+  return { a, b };
+}
+
 // src/types/path.ts
 function path(rings, closed = true) {
   return {
@@ -18,6 +29,12 @@ function path(rings, closed = true) {
     closed
   };
 }
+function polyline(points) {
+  return path([points], false);
+}
+function polygon(exterior, holes = []) {
+  return path([exterior, ...holes], true);
+}
 function normalizeRing(ring, eps = 1e-9) {
   if (ring.length < 2) return ring.map(cloneVec2);
   const first = ring[0];
@@ -101,6 +118,1299 @@ function buffer(path2, delta, options = {}) {
   return pathsDToGroup(inflated);
 }
 
+// src/predicates/index.ts
+function ringArea(ring) {
+  if (ring.length < 3) return 0;
+  let sum = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % ring.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function centroid(p) {
+  const ring = p.rings[0];
+  if (!ring || ring.length === 0) return vec2(0, 0);
+  const a = ringArea(ring);
+  if (Math.abs(a) < 1e-12) {
+    let sx = 0;
+    let sy = 0;
+    for (const v of ring) {
+      sx += v.x;
+      sy += v.y;
+    }
+    return vec2(sx / ring.length, sy / ring.length);
+  }
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const p0 = ring[i];
+    const p1 = ring[(i + 1) % ring.length];
+    const cross = p0.x * p1.y - p1.x * p0.y;
+    cx += (p0.x + p1.x) * cross;
+    cy += (p0.y + p1.y) * cross;
+  }
+  return vec2(cx / (6 * a), cy / (6 * a));
+}
+function containsPoint(p, point) {
+  if (!p.closed || !p.rings[0]) return false;
+  if (!pointInRing(point, p.rings[0])) return false;
+  for (let i = 1; i < p.rings.length; i++) {
+    const hole = p.rings[i];
+    if (hole && pointInRing(point, hole)) return false;
+  }
+  return true;
+}
+function bounds(p) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const ring of p.rings) {
+    for (const v of ring) {
+      minX = Math.min(minX, v.x);
+      minY = Math.min(minY, v.y);
+      maxX = Math.max(maxX, v.x);
+      maxY = Math.max(maxY, v.y);
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+  }
+  return { minX, minY, maxX, maxY };
+}
+
+// src/processing/index.ts
+function densify(p, maxSegLen) {
+  if (maxSegLen <= 0) return p;
+  return path(
+    p.rings.map((ring) => densifyRing(ring, maxSegLen, p.closed)),
+    p.closed
+  );
+}
+function densifyRing(ring, maxSegLen, closed) {
+  if (ring.length < 2) return [...ring];
+  const out = [];
+  const n = ring.length;
+  const edges = closed ? n : n - 1;
+  for (let i = 0; i < edges; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    out.push(a);
+    const dist = Math.hypot(b.x - a.x, b.y - a.y);
+    const steps = Math.floor(dist / maxSegLen);
+    for (let s = 1; s < steps; s++) {
+      const t = s / steps;
+      out.push({
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t
+      });
+    }
+  }
+  if (!closed) out.push(ring[n - 1]);
+  return closed ? normalizeRing(out) : out;
+}
+
+// src/pointSet/index.ts
+function mulberry32(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 poisson(minDistance, minX, minY, maxX, maxY, seed = 1, maxAttempts = 30) {
+  const rng = mulberry32(seed >>> 0);
+  const r = Math.max(minDistance, 1e-9);
+  const cell = r / Math.SQRT2;
+  const w = maxX - minX;
+  const h = maxY - minY;
+  const gw = Math.max(1, Math.ceil(w / cell));
+  const gh = Math.max(1, Math.ceil(h / cell));
+  const grid = Array(gw * gh).fill(null);
+  const points = [];
+  const active = [];
+  const gx = (p) => Math.min(gw - 1, Math.floor((p.x - minX) / cell));
+  const gy = (p) => Math.min(gh - 1, Math.floor((p.y - minY) / cell));
+  const emit = (p) => {
+    const i = points.length;
+    points.push(p);
+    active.push(i);
+    grid[gy(p) * gw + gx(p)] = i;
+  };
+  emit({
+    x: minX + rng() * w,
+    y: minY + rng() * h
+  });
+  while (active.length > 0) {
+    const ai = Math.floor(rng() * active.length);
+    const i = active[ai];
+    const src = points[i];
+    let found = false;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const ang = rng() * Math.PI * 2;
+      const rad = r * (1 + rng());
+      const cand = {
+        x: src.x + Math.cos(ang) * rad,
+        y: src.y + Math.sin(ang) * rad
+      };
+      if (cand.x < minX || cand.x > maxX || cand.y < minY || cand.y > maxY) {
+        continue;
+      }
+      const cx = gx(cand);
+      const cy = gy(cand);
+      let ok = true;
+      for (let yy = Math.max(0, cy - 2); yy <= Math.min(gh - 1, cy + 2) && ok; yy++) {
+        for (let xx = Math.max(0, cx - 2); xx <= Math.min(gw - 1, cx + 2); xx++) {
+          const j = grid[yy * gw + xx];
+          if (j == null) continue;
+          const q = points[j];
+          if (Math.hypot(cand.x - q.x, cand.y - q.y) < r) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (ok) {
+        emit(cand);
+        found = true;
+        break;
+      }
+    }
+    if (!found) active.splice(ai, 1);
+  }
+  return points;
+}
+
+// src/triangulation/index.ts
+function earCutTriangulation(p, options = {}) {
+  if (!p.closed || p.rings.length === 0) return [];
+  const { solution } = triangulateD(
+    pathToPathsD(p),
+    options.precision ?? 8,
+    options.useDelaunay ?? false
+  );
+  const tris = [];
+  for (const pd of solution) {
+    const ring = pathDToRing(pd);
+    if (ring.length >= 3) tris.push(polygon(ring.slice(0, 3)));
+  }
+  return tris;
+}
+function delaunayTriangulation(p) {
+  return earCutTriangulation(p, { useDelaunay: true });
+}
+
+// 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 ring of p.rings) {
+    for (const v of ring) {
+      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/circlePacking/index.ts
+function maximumInscribedPack(path2, n, tolerance = 1) {
+  return obstaclePack(path2, [], n, tolerance);
+}
+function obstaclePack(path2, obstacles, n, tolerance = 1) {
+  const packing = obstacles.map((c) => ({ ...c }));
+  const placed = [];
+  const tol = Math.max(0.01, tolerance);
+  for (let i = 0; i < n; i++) {
+    const next = findLargestEmptyCircle(path2, packing, tol);
+    if (!next || next.r <= 1e-9) break;
+    packing.push(next);
+    placed.push(next);
+  }
+  return placed;
+}
+function findLargestEmptyCircle(path2, obstacles, tolerance) {
+  const b = bounds(path2);
+  const diag = Math.hypot(b.maxX - b.minX, b.maxY - b.minY) || 1;
+  const step = Math.max(diag * 0.02 * Math.sqrt(tolerance), diag * 0.01);
+  let best = null;
+  for (let x = b.minX; x <= b.maxX; x += step) {
+    for (let y = b.minY; y <= b.maxY; y += step) {
+      const p = { x, y };
+      if (!containsPoint(path2, p)) continue;
+      const r = clearanceRadius(p, path2, obstacles);
+      if (!best || r > best.r) best = circle(p.x, p.y, r);
+    }
+  }
+  if (!best) return null;
+  let cur = best;
+  let span = step;
+  for (let iter = 0; iter < 8; iter++) {
+    let improved = cur;
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        if (dx === 0 && dy === 0) continue;
+        const p = { x: cur.x + dx * span, y: cur.y + dy * span };
+        if (!containsPoint(path2, p)) continue;
+        const r = clearanceRadius(p, path2, obstacles);
+        if (r > improved.r) improved = circle(p.x, p.y, r);
+      }
+    }
+    cur = improved;
+    span *= 0.5;
+  }
+  return cur;
+}
+function clearanceRadius(p, path2, obstacles) {
+  let r = distanceToBoundary(p, path2);
+  for (const c of obstacles) {
+    r = Math.min(r, Math.hypot(p.x - c.x, p.y - c.y) - c.r);
+  }
+  return Math.max(0, r);
+}
+function distanceToBoundary(p, path2) {
+  let min = Infinity;
+  for (const ring of path2.rings) {
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % ring.length];
+      min = Math.min(min, pointSegmentDistance(p, a, b));
+    }
+  }
+  return min;
+}
+function pointSegmentDistance(p, a, b) {
+  const abx = b.x - a.x;
+  const aby = b.y - a.y;
+  const len2 = abx * abx + aby * aby;
+  if (len2 < 1e-18) return Math.hypot(p.x - a.x, p.y - a.y);
+  let t = ((p.x - a.x) * abx + (p.y - a.y) * aby) / len2;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(p.x - (a.x + t * abx), p.y - (a.y + t * aby));
+}
+
+// src/optimisation/index.ts
+function maximumInscribedCircle(p, tolerance = 1) {
+  return maximumInscribedPack(p, 1, tolerance)[0] ?? null;
+}
+
+// src/contour/boundaryDistance.ts
+function distanceToBoundary2(path2, p) {
+  let best = Infinity;
+  for (const ring of path2.rings) {
+    if (ring.length < 2) continue;
+    const n = ring.length;
+    const closed = path2.closed;
+    const limit = closed ? n : n - 1;
+    for (let i = 0; i < limit; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % n];
+      best = Math.min(best, distPointSeg(p, a, b));
+    }
+  }
+  return best;
+}
+function sampleBoundary(path2, maxSegLen) {
+  const pts = [];
+  const lim = Math.max(maxSegLen, 1e-9);
+  for (const ring of path2.rings) {
+    if (ring.length < 2) continue;
+    const n = ring.length;
+    const limit = path2.closed ? n : n - 1;
+    for (let i = 0; i < limit; i++) {
+      const a = ring[i];
+      const b = ring[(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 voronoi = 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 = voronoi.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 mid3 = { x: (a.x + bb.x) / 2, y: (a.y + bb.y) / 2 };
+      const site = uniq[i];
+      const radius = Math.hypot(mid3.x - site.x, mid3.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 area = nodes[u].featureArea;
+    for (const c of nodes[u].children) area += nodes[c].featureArea;
+    nodes[u].featureArea = area;
+  }
+  return { nodes, edges, root };
+}
+function pruneEdges(g, axialT, distT, areaT) {
+  const maxDist = Math.max(...g.nodes.map((n) => n.rootDist), 1e-9);
+  const maxArea = 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 / maxArea;
+      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 path2 = [id];
+  let cur = id;
+  while (g.nodes[cur].parent !== null) {
+    cur = g.nodes[cur].parent;
+    path2.push(cur);
+  }
+  return path2;
+}
+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 ring of a.rings) {
+      for (const p of ring) {
+        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 ring of p.rings) {
+    for (const v of ring) {
+      const d = Math.hypot(v.x - q.x, v.y - q.y);
+      if (d < bestD) {
+        bestD = d;
+        best = v;
+      }
+    }
+  }
+  return best;
+}
+function nearestOnRing(ring, q) {
+  if (ring.length === 0) return null;
+  let best = ring[0];
+  let bestD = Infinity;
+  for (const v of ring) {
+    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 lerp = (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 = () => lerp(x0, y0, v00, x1, y0, v10);
+      const right = () => lerp(x1, y0, v10, x1, y1, v11);
+      const top = () => lerp(x0, y1, v01, x1, y1, v11);
+      const left = () => lerp(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 num = 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);
+      num += w * values[i];
+      den += w;
+    }
+    return num / 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 ring = p.rings[0];
+    if (!ring || ring.length < 2) continue;
+    let current = [];
+    const flush = () => {
+      if (current.length >= 2) {
+        paths.push({ rings: [current], closed: false });
+      }
+      current = [];
+    };
+    for (let i = 0; i < ring.length - 1; i++) {
+      const a = ring[i];
+      const b = ring[i + 1];
+      if (!finitePt(a) || !finitePt(b)) {
+        flush();
+        continue;
+      }
+      const mid3 = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+      if (insideSafe(shape, mid3)) {
+        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 pointInPoly(point, shape.rings[0]) && shape.rings.slice(1).every((h) => !pointInPoly(point, h));
+  }
+}
+function pointInPoly(point, ring) {
+  let inside = false;
+  for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+    const pi = ring[i];
+    const pj = ring[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, flatten) {
+  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 ring of face.rings) {
+      if (ring.length < 2) continue;
+      const n = ring.length;
+      const closed = face.closed;
+      const limit = closed ? n : n - 1;
+      for (let i = 0; i < limit; i++) {
+        addEdge(ring[i], ring[(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 (flatten) {
+    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));
@@ -110,9 +1420,22 @@ function offsetCurvesInward(p, distance) {
 }
 var contour = {
   offsetCurvesOutward,
-  offsetCurvesInward
+  offsetCurvesInward,
+  medialAxis,
+  chordalAxis,
+  straightSkeleton,
+  straightSkeletonParts,
+  centerLine,
+  distanceField,
+  contrastField,
+  distanceTree,
+  isolines,
+  isolinesFromFunction,
+  isolineZeroFromFunction,
+  isolinesFromPoints,
+  dissolveSegments
 };
 
-export { contour, offsetCurvesInward, offsetCurvesOutward };
+export { centerLine, chordalAxis, contour, contrastField, dissolveSegments, distanceField, distanceTree, isolineZeroFromFunction, isolines, isolinesFromFunction, isolinesFromPoints, medialAxis, offsetCurvesInward, offsetCurvesOutward, straightSkeleton, straightSkeletonParts };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map