pattapatta 0.2.0

package/dist/meshing/index.js

@@ -0,0 +1,1333 @@
+import { FillRule, simplifyPathD, pointInPolygonD, PointInPolygonResult, unionD, isPositiveD, areaD } from 'clipper2-ts';
+import { Delaunay } from 'd3-delaunay';
+
+// src/types/vec2.ts
+function vec2(x, y) {
+  return { x, y };
+}
+function cloneVec2(v) {
+  return { x: v.x, y: v.y };
+}
+function equalsVec2(a, b, eps = 1e-9) {
+  return Math.abs(a.x - b.x) <= eps && Math.abs(a.y - b.y) <= eps;
+}
+
+// src/types/segment.ts
+function segment(a, b) {
+  return { a, b };
+}
+
+// src/types/path.ts
+function path(rings, closed = true) {
+  return {
+    rings: rings.map((ring) => ring.map(cloneVec2)),
+    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];
+  const last = ring[ring.length - 1];
+  if (first && last && equalsVec2(first, last, eps)) {
+    return ring.slice(0, -1).map(cloneVec2);
+  }
+  return ring.map(cloneVec2);
+}
+function clonePath(p) {
+  return {
+    closed: p.closed,
+    rings: p.rings.map((ring) => ring.map(cloneVec2))
+  };
+}
+
+// src/types/group.ts
+function group(paths = []) {
+  return { paths: paths.map(clonePath) };
+}
+var DEFAULT_FILL_RULE = FillRule.NonZero;
+function ringToPathD(ring) {
+  const pts = [];
+  for (const v of normalizeRing(ring)) {
+    pts.push({ x: v.x, y: v.y, z: 0 });
+  }
+  return pts;
+}
+function pathToPathsD(p) {
+  if (!p.closed || p.rings.length === 0) {
+    throw new Error("Boolean ops require a closed path with at least one ring");
+  }
+  return p.rings.map((ring) => ringToPathD(ring));
+}
+function pathsDToGroup(paths) {
+  if (paths.length === 0) return group([]);
+  const outers = [];
+  const holes = [];
+  for (const pd of paths) {
+    const ring = pathDToRing(pd);
+    if (ring.length < 3) continue;
+    if (isPositiveD(pd)) {
+      outers.push({ ring, holes: [] });
+    } else {
+      holes.push(ring);
+    }
+  }
+  for (const hole of holes) {
+    const sample = hole[0];
+    if (!sample) continue;
+    let assigned = false;
+    for (const outer of outers) {
+      if (pointInRing(sample, outer.ring)) {
+        outer.holes.push(hole);
+        assigned = true;
+        break;
+      }
+    }
+    if (!assigned) {
+      outers.push({ ring: [...hole].reverse(), holes: [] });
+    }
+  }
+  return group(outers.map((o) => path([o.ring, ...o.holes], true)));
+}
+function pathDToRing(pd) {
+  return normalizeRing(pd.map((p) => vec2(p.x, p.y)));
+}
+function pointInRing(point, ring) {
+  const result = pointInPolygonD(
+    { x: point.x, y: point.y, z: 0 },
+    ringToPathD(ring)
+  );
+  return result === PointInPolygonResult.IsInside || result === PointInPolygonResult.IsOn;
+}
+function clipUnion(a, b) {
+  return unionD(a, b, DEFAULT_FILL_RULE);
+}
+function pathsArea(paths) {
+  let sum = 0;
+  for (const p of paths) {
+    sum += Math.abs(areaD(p));
+  }
+  return sum;
+}
+
+// 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 area(p) {
+  if (!p.closed || p.rings.length === 0) return 0;
+  try {
+    return pathsArea(pathToPathsD(p));
+  } catch {
+    let total = 0;
+    for (let i = 0; i < p.rings.length; i++) {
+      const a = Math.abs(ringArea(p.rings[i]));
+      total += i === 0 ? a : -a;
+    }
+    return Math.max(0, total);
+  }
+}
+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 cross2 = p0.x * p1.y - p1.x * p0.y;
+    cx += (p0.x + p1.x) * cross2;
+    cy += (p0.y + p1.y) * cross2;
+  }
+  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 delaunayTriangulationPoints(points) {
+  if (points.length < 3) return [];
+  const delaunay = Delaunay.from(
+    points,
+    (d) => d.x,
+    (d) => d.y
+  );
+  const tris = [];
+  const { triangles } = delaunay;
+  for (let i = 0; i < triangles.length; i += 3) {
+    const a = points[triangles[i]];
+    const b = points[triangles[i + 1]];
+    const c = points[triangles[i + 2]];
+    tris.push(polygon([a, b, c]));
+  }
+  return tris;
+}
+
+// src/shapeBoolean/index.ts
+function ensureClosed(p) {
+  if (!p.closed) {
+    throw new Error("shapeBoolean requires closed paths");
+  }
+  return p;
+}
+function union(a, b) {
+  const result = clipUnion(pathToPathsD(ensureClosed(a)), pathToPathsD(ensureClosed(b)));
+  return pathsDToGroup(result);
+}
+function simplify(p, epsilon) {
+  if (epsilon <= 0 || p.rings.length === 0) return p;
+  const rings = [];
+  for (const ring of p.rings) {
+    const simplified = simplifyPathD(ringToPathD(ring), epsilon, p.closed);
+    const out = pathDToRing(simplified);
+    if (out.length >= (p.closed ? 3 : 2)) rings.push(out);
+  }
+  if (rings.length === 0) return path([], p.closed);
+  return path(rings, p.closed);
+}
+
+// src/meshing/index.ts
+function edgeKey(a, b) {
+  const aKey = `${a.x},${a.y}`;
+  const bKey = `${b.x},${b.y}`;
+  return aKey < bKey ? `${aKey}|${bKey}` : `${bKey}|${aKey}`;
+}
+function vertKey(v) {
+  return `${v.x},${v.y}`;
+}
+function same(a, b, eps = 1e-12) {
+  return Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps;
+}
+function dist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function mid(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+function lerp(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function unique(points) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of points) {
+    const k = vertKey(p);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push({ ...p });
+  }
+  return out;
+}
+function cross(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+function ringOf(face) {
+  return face.rings[0] ?? [];
+}
+function buildEdgeMap(faces) {
+  const edges = /* @__PURE__ */ new Map();
+  faces.forEach((f, fi) => {
+    const ring = ringOf(f);
+    if (ring.length < 2) return;
+    const n = ring.length;
+    const closed = f.closed !== false && n >= 3;
+    const lim = closed ? n : n - 1;
+    for (let i = 0; i < lim; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % n];
+      const key = edgeKey(a, b);
+      const rec = edges.get(key);
+      if (rec) rec.faceIds.push(fi);
+      else edges.set(key, { a: { ...a }, b: { ...b }, faceIds: [fi] });
+    }
+  });
+  return edges;
+}
+function perimeterKeys(edgeMap) {
+  const out = /* @__PURE__ */ new Set();
+  for (const [k, e] of edgeMap) {
+    if (e.faceIds.length === 1) out.add(k);
+  }
+  return out;
+}
+function faceAdjacency(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const adj = faces.map(() => []);
+  for (const e of edgeMap.values()) {
+    if (e.faceIds.length === 2) {
+      const [i, j] = e.faceIds;
+      adj[i].push(j);
+      adj[j].push(i);
+    }
+  }
+  return adj;
+}
+function sitesFromFaces(faces) {
+  return unique(faces.flatMap((f) => ringOf(f)));
+}
+function facesFromKeptEdges(tris, kept) {
+  if (tris.length === 0) return [];
+  const parent = tris.map((_, i) => i);
+  const find = (i) => {
+    let x = i;
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  const unite = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[rb] = ra;
+  };
+  const edgeMap = buildEdgeMap(tris);
+  for (const [key, e] of edgeMap) {
+    if (e.faceIds.length === 2 && !kept.has(key)) {
+      unite(e.faceIds[0], e.faceIds[1]);
+    }
+  }
+  const components = /* @__PURE__ */ new Map();
+  for (let i = 0; i < tris.length; i++) {
+    const r = find(i);
+    const list = components.get(r) ?? [];
+    list.push(i);
+    components.set(r, list);
+  }
+  const out = [];
+  for (const members of components.values()) {
+    const ring = boundaryRingOfComponent(tris, members);
+    if (ring && ring.length >= 3) out.push(polygon(ring));
+  }
+  return out;
+}
+function boundaryRingOfComponent(tris, members) {
+  const edgeCount = /* @__PURE__ */ new Map();
+  for (const fi of members) {
+    const ring = ringOf(tris[fi]);
+    if (ring.length < 3) continue;
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % ring.length];
+      const key = edgeKey(a, b);
+      const rec = edgeCount.get(key);
+      if (rec) rec.n++;
+      else edgeCount.set(key, { a: { ...a }, b: { ...b }, n: 1 });
+    }
+  }
+  const boundary = [];
+  for (const e of edgeCount.values()) {
+    if (e.n === 1) boundary.push({ a: e.a, b: e.b });
+  }
+  if (boundary.length < 3) return null;
+  return orderEdgesIntoRing(boundary);
+}
+function orderEdgesIntoRing(edges) {
+  if (edges.length === 0) return null;
+  const adj = /* @__PURE__ */ new Map();
+  const add = (from, to) => {
+    const k = vertKey(from);
+    const list = adj.get(k) ?? [];
+    list.push(to);
+    adj.set(k, list);
+  };
+  for (const e of edges) {
+    add(e.a, e.b);
+    add(e.b, e.a);
+  }
+  const start = edges[0].a;
+  const ring = [{ ...start }];
+  let prev = start;
+  let curr = edges[0].b;
+  const maxSteps = edges.length + 2;
+  for (let step = 0; step < maxSteps; step++) {
+    ring.push({ ...curr });
+    if (same(curr, start) && ring.length > 2) {
+      ring.pop();
+      return ring;
+    }
+    const nbrs = adj.get(vertKey(curr)) ?? [];
+    let next = null;
+    for (const n of nbrs) {
+      if (!same(n, prev)) {
+        next = n;
+        break;
+      }
+    }
+    if (!next) break;
+    prev = curr;
+    curr = next;
+  }
+  return ring.length >= 3 ? ring : null;
+}
+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);
+    if (isPeri && preservePerimeter) {
+      kept.add(key);
+      continue;
+    }
+    if (shouldKeep(e.a, e.b, isPeri)) kept.add(key);
+  }
+  return facesFromKeptEdges(tris, kept);
+}
+function asTriFaces(input) {
+  if (input.length === 0) return [];
+  const first = input[0];
+  if ("rings" in first) return input;
+  return delaunayTriangulationPoints(input);
+}
+function pointsOf(input) {
+  if (input.length === 0) return [];
+  const first = input[0];
+  if ("rings" in first) return sitesFromFaces(input);
+  return input;
+}
+function extractInnerEdges(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const out = [];
+  for (const e of edgeMap.values()) {
+    if (e.faceIds.length >= 2) out.push(segment(e.a, e.b));
+  }
+  return out;
+}
+function extractInnerVertices(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const peri = perimeterKeys(edgeMap);
+  const periVerts = /* @__PURE__ */ new Set();
+  for (const key of peri) {
+    const e = edgeMap.get(key);
+    periVerts.add(vertKey(e.a));
+    periVerts.add(vertKey(e.b));
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of faces) {
+    for (const v of ringOf(f)) {
+      const k = vertKey(v);
+      if (periVerts.has(k) || seen.has(k)) continue;
+      seen.add(k);
+      out.push({ ...v });
+    }
+  }
+  return out;
+}
+function findContainingFace(faces, point) {
+  for (const f of faces) {
+    if (containsPoint(f, point)) return f;
+  }
+  return null;
+}
+function splitEdges(faces, maxLen) {
+  const lim = Math.max(maxLen, 1e-9);
+  const out = [];
+  for (const f of faces) {
+    out.push(
+      polygon(
+        densifyRing(ringOf(f), lim),
+        f.rings.slice(1).map((r) => densifyRing(r, lim))
+      )
+    );
+  }
+  return group(out);
+}
+function densifyRing(ring, maxLen) {
+  if (ring.length < 2) return ring.map((v) => ({ ...v }));
+  const out = [];
+  const n = ring.length;
+  for (let i = 0; i < n; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    out.push({ ...a });
+    const d = dist(a, b);
+    const steps = Math.floor(d / maxLen);
+    for (let s = 1; s < steps; s++) out.push(lerp(a, b, s / steps));
+  }
+  return out;
+}
+function isGabriel(a, b, points) {
+  const m = mid(a, b);
+  const r = dist(a, b) / 2;
+  for (const p of points) {
+    if (same(p, a) || same(p, b)) continue;
+    if (dist(p, m) < r - 1e-9) return false;
+  }
+  return true;
+}
+function isRelativeNeighbor(a, b, points) {
+  const dab = dist(a, b);
+  for (const p of points) {
+    if (same(p, a) || same(p, b)) continue;
+    if (Math.max(dist(p, a), dist(p, b)) < dab - 1e-9) return false;
+  }
+  return true;
+}
+function urquhartFaces(input, preservePerimeter = false) {
+  const tris = asTriFaces(input);
+  const edgeMap = buildEdgeMap(tris);
+  const peri = perimeterKeys(edgeMap);
+  const removed = /* @__PURE__ */ new Set();
+  for (const t of tris) {
+    const r = ringOf(t);
+    if (r.length < 3) continue;
+    let longestKey = "";
+    let longestLen = -1;
+    for (let i = 0; i < 3; i++) {
+      const a = r[i];
+      const b = r[(i + 1) % 3];
+      const d = dist(a, b);
+      if (d > longestLen) {
+        longestLen = d;
+        longestKey = edgeKey(a, b);
+      }
+    }
+    if (longestKey && !(preservePerimeter && peri.has(longestKey))) {
+      removed.add(longestKey);
+    }
+  }
+  const kept = /* @__PURE__ */ new Set();
+  for (const key of edgeMap.keys()) {
+    if (!removed.has(key)) kept.add(key);
+  }
+  return group(facesFromKeptEdges(tris, kept));
+}
+function gabrielFaces(input, preservePerimeter = false) {
+  const tris = asTriFaces(input);
+  const pts = pointsOf(input);
+  return group(
+    applyEdgeFilter(
+      tris,
+      (a, b) => isGabriel(a, b, pts),
+      preservePerimeter
+    )
+  );
+}
+function relativeNeighborFaces(input, preservePerimeter = false) {
+  const tris = asTriFaces(input);
+  const pts = pointsOf(input);
+  return group(
+    applyEdgeFilter(
+      tris,
+      (a, b) => isRelativeNeighbor(a, b, pts),
+      preservePerimeter
+    )
+  );
+}
+function spannerFaces(input, k = 1, preservePerimeter = false) {
+  const tris = asTriFaces(input);
+  const edgeMap = buildEdgeMap(tris);
+  const peri = perimeterKeys(edgeMap);
+  const stretch = Math.max(1, k);
+  const edges = [...edgeMap.entries()].map(([key, e]) => ({
+    key,
+    a: e.a,
+    b: e.b,
+    len: dist(e.a, e.b),
+    peri: peri.has(key)
+  }));
+  edges.sort((a, b) => a.len - b.len);
+  const adj = /* @__PURE__ */ new Map();
+  const link = (a, b, w) => {
+    const ka = vertKey(a);
+    const kb = vertKey(b);
+    if (!adj.has(ka)) adj.set(ka, []);
+    if (!adj.has(kb)) adj.set(kb, []);
+    adj.get(ka).push({ to: kb, w });
+    adj.get(kb).push({ to: ka, w });
+  };
+  const shortest = (from, to) => {
+    const start = vertKey(from);
+    const goal = vertKey(to);
+    const distMap = /* @__PURE__ */ new Map([[start, 0]]);
+    const pq = [{ k: start, d: 0 }];
+    while (pq.length) {
+      pq.sort((x, y) => x.d - y.d);
+      const cur = pq.shift();
+      if (cur.k === goal) return cur.d;
+      if (cur.d > (distMap.get(cur.k) ?? Infinity)) continue;
+      for (const e of adj.get(cur.k) ?? []) {
+        const nd = cur.d + e.w;
+        if (nd < (distMap.get(e.to) ?? Infinity)) {
+          distMap.set(e.to, nd);
+          pq.push({ k: e.to, d: nd });
+        }
+      }
+    }
+    return Infinity;
+  };
+  const kept = /* @__PURE__ */ new Set();
+  for (const e of edges) {
+    if (e.peri && preservePerimeter) {
+      kept.add(e.key);
+      link(e.a, e.b, e.len);
+      continue;
+    }
+    const pathLen = shortest(e.a, e.b);
+    if (pathLen > stretch * e.len + 1e-9) {
+      kept.add(e.key);
+      link(e.a, e.b, e.len);
+    } else if (e.peri) {
+      kept.add(e.key);
+      link(e.a, e.b, e.len);
+    }
+  }
+  return group(facesFromKeptEdges(tris, kept));
+}
+function dualFaces(faces) {
+  if (faces.length === 0) return group([]);
+  const edgeMap = buildEdgeMap(faces);
+  const peri = perimeterKeys(edgeMap);
+  const periVerts = /* @__PURE__ */ new Set();
+  for (const key of peri) {
+    const e = edgeMap.get(key);
+    periVerts.add(vertKey(e.a));
+    periVerts.add(vertKey(e.b));
+  }
+  const incident = /* @__PURE__ */ new Map();
+  faces.forEach((f, fi) => {
+    const c = centroid(f);
+    for (const v of ringOf(f)) {
+      const k = vertKey(v);
+      if (periVerts.has(k)) continue;
+      const list = incident.get(k) ?? [];
+      list.push({ fi, ang: Math.atan2(c.y - v.y, c.x - v.x), v });
+      incident.set(k, list);
+    }
+  });
+  const out = [];
+  for (const list of incident.values()) {
+    if (list.length < 3) continue;
+    const byFace = /* @__PURE__ */ new Map();
+    for (const item of list) byFace.set(item.fi, item);
+    const uniqueList = [...byFace.values()];
+    if (uniqueList.length < 3) continue;
+    uniqueList.sort((a, b) => a.ang - b.ang);
+    const ring = uniqueList.map((item) => centroid(faces[item.fi]));
+    out.push(polygon(ring));
+  }
+  return group(out);
+}
+function triVerts(t) {
+  const r = ringOf(t);
+  if (r.length < 3) return null;
+  return [r[0], r[1], r[2]];
+}
+function midpointMap(faces) {
+  const mids = /* @__PURE__ */ new Map();
+  const edgeMap = buildEdgeMap(faces);
+  for (const [key, e] of edgeMap) {
+    mids.set(key, mid(e.a, e.b));
+  }
+  return mids;
+}
+function centroidQuadrangulation(input, preservePerimeter = true) {
+  const tris = asTriFaces(input);
+  const edgeMap = buildEdgeMap(tris);
+  const centers = tris.map((t) => centroid(t));
+  const out = [];
+  const peri = perimeterKeys(edgeMap);
+  for (const [key, e] of edgeMap) {
+    const ids = e.faceIds;
+    if (ids.length === 2) {
+      const c0 = centers[ids[0]];
+      const c1 = centers[ids[1]];
+      out.push(polygon([e.a, c0, e.b, c1]));
+    } else if (ids.length === 1 && preservePerimeter) {
+      const c0 = centers[ids[0]];
+      out.push(polygon([e.a, e.b, c0]));
+    } else if (ids.length === 1 && !preservePerimeter && peri.has(key)) ;
+  }
+  return group(out);
+}
+function splitQuadrangulation(input) {
+  const tris = asTriFaces(input);
+  const mids = midpointMap(tris);
+  const out = [];
+  for (const t of tris) {
+    const v = triVerts(t);
+    if (!v) continue;
+    const [a, b, c] = v;
+    const g = centroid(t);
+    const mab = mids.get(edgeKey(a, b)) ?? mid(a, b);
+    const mbc = mids.get(edgeKey(b, c)) ?? mid(b, c);
+    const mca = mids.get(edgeKey(c, a)) ?? mid(c, a);
+    out.push(polygon([a, mab, g, mca]));
+    out.push(polygon([b, mbc, g, mab]));
+    out.push(polygon([c, mca, g, mbc]));
+  }
+  return group(out);
+}
+function edgeCollapseQuadrangulation(input, preservePerimeter = true) {
+  const tris = asTriFaces(input);
+  const edgeMap = buildEdgeMap(tris);
+  const candidates = [];
+  for (const [key, 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,
+      a: e.a,
+      b: e.b,
+      i,
+      j,
+      q: quadQuality(quad)
+    });
+  }
+  candidates.sort((x, y) => y.q - x.q);
+  const used = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const c of candidates) {
+    if (used.has(c.i) || used.has(c.j)) continue;
+    const quad = mergeTriPair(tris[c.i], tris[c.j], c.a, c.b);
+    if (!quad) continue;
+    out.push(quad);
+    used.add(c.i);
+    used.add(c.j);
+  }
+  for (let i = 0; i < tris.length; i++) {
+    if (used.has(i)) continue;
+    if (preservePerimeter) out.push(tris[i]);
+  }
+  return group(out);
+}
+function matchingQuadrangulation(input) {
+  return edgeCollapseQuadrangulation(input, true);
+}
+function mergeTriPair(t0, t1, ea, eb) {
+  const opp0 = oppositeVertex(t0, ea, eb);
+  const opp1 = oppositeVertex(t1, ea, eb);
+  if (!opp0 || !opp1) return null;
+  return polygon([opp0, ea, opp1, eb]);
+}
+function oppositeVertex(t, ea, eb) {
+  for (const v of ringOf(t)) {
+    if (!same(v, ea) && !same(v, eb)) return v;
+  }
+  return null;
+}
+function quadQuality(q) {
+  const r = ringOf(q);
+  if (r.length < 4) return 0;
+  const lens = [];
+  for (let i = 0; i < 4; i++) {
+    lens.push(dist(r[i], r[(i + 1) % 4]));
+  }
+  const minL = Math.min(...lens);
+  const maxL = Math.max(...lens);
+  if (maxL < 1e-12) return 0;
+  return minL / maxL;
+}
+function spiralQuadrangulation(points) {
+  if (points.length < 4) return group([]);
+  const pts = unique(points);
+  const cx = pts.reduce((s, p) => s + p.x, 0) / pts.length;
+  const cy = pts.reduce((s, p) => s + p.y, 0) / pts.length;
+  const withMeta = pts.map((p) => ({
+    p,
+    ang: Math.atan2(p.y - cy, p.x - cx),
+    rad: Math.hypot(p.x - cx, p.y - cy)
+  }));
+  withMeta.sort((a, b) => a.rad - b.rad || a.ang - b.ang);
+  const ringCount = Math.max(2, Math.ceil(Math.sqrt(pts.length)));
+  const rings = Array.from({ length: ringCount }, () => []);
+  withMeta.forEach((item, i) => {
+    const ri = Math.min(
+      ringCount - 1,
+      Math.floor(i / withMeta.length * ringCount)
+    );
+    rings[ri].push(item.p);
+  });
+  for (const ring of rings) {
+    ring.sort(
+      (a, b) => Math.atan2(a.y - cy, a.x - cx) - Math.atan2(b.y - cy, b.x - cx)
+    );
+  }
+  const out = [];
+  for (let r = 0; r < rings.length - 1; r++) {
+    const inner = rings[r];
+    const outer = rings[r + 1];
+    if (inner.length === 0 || outer.length === 0) continue;
+    const n = Math.max(inner.length, outer.length);
+    for (let i = 0; i < n; i++) {
+      const a = inner[i % inner.length];
+      const b = inner[(i + 1) % inner.length];
+      const c = outer[(i + 1) % outer.length];
+      const d = outer[i % outer.length];
+      const verts = unique([a, b, c, d]);
+      if (verts.length >= 3) out.push(polygon(verts.length === 3 ? verts : [a, b, c, d]));
+    }
+  }
+  return group(out);
+}
+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);
+    perimeter.add(vertKey(e.a));
+    perimeter.add(vertKey(e.b));
+  }
+  const positions = /* @__PURE__ */ new Map();
+  const neighbors = /* @__PURE__ */ new Map();
+  const link = (a, b) => {
+    const ka = vertKey(a);
+    const kb = vertKey(b);
+    positions.set(ka, { ...a });
+    positions.set(kb, { ...b });
+    if (!neighbors.has(ka)) neighbors.set(ka, /* @__PURE__ */ new Set());
+    if (!neighbors.has(kb)) neighbors.set(kb, /* @__PURE__ */ new Set());
+    neighbors.get(ka).add(kb);
+    neighbors.get(kb).add(ka);
+  };
+  for (const e of edgeMap.values()) link(e.a, e.b);
+  return { positions, neighbors, perimeter };
+}
+function remapFaces(faces, positions) {
+  return faces.map(
+    (f) => polygon(
+      ringOf(f).map((v) => {
+        const p = positions.get(vertKey(v));
+        return p ? { ...p } : { ...v };
+      }),
+      f.rings.slice(1).map(
+        (r) => r.map((v) => {
+          const p = positions.get(vertKey(v));
+          return p ? { ...p } : { ...v };
+        })
+      )
+    )
+  );
+}
+function smoothMesh(faces, iterationsOrCutoff, preservePerimeter = true) {
+  if (faces.length === 0) return group([]);
+  let { positions, neighbors, perimeter } = vertexNeighborhood(faces);
+  const maxIter = iterationsOrCutoff >= 1 && Number.isInteger(iterationsOrCutoff) ? iterationsOrCutoff : 200;
+  const cutoff = iterationsOrCutoff > 0 && iterationsOrCutoff < 1 ? iterationsOrCutoff : 0;
+  for (let iter = 0; iter < maxIter; iter++) {
+    const next = /* @__PURE__ */ new Map();
+    let maxDisp = 0;
+    for (const [k, p] of positions) {
+      if (preservePerimeter && perimeter.has(k)) {
+        next.set(k, p);
+        continue;
+      }
+      const nbrs = neighbors.get(k);
+      if (!nbrs || nbrs.size === 0) {
+        next.set(k, p);
+        continue;
+      }
+      let sx = 0;
+      let sy = 0;
+      for (const nk of nbrs) {
+        const n = positions.get(nk);
+        sx += n.x;
+        sy += n.y;
+      }
+      const np = { x: sx / nbrs.size, y: sy / nbrs.size };
+      maxDisp = Math.max(maxDisp, dist(p, np));
+      next.set(k, np);
+    }
+    positions = next;
+    if (cutoff > 0 && maxDisp < cutoff) break;
+  }
+  return group(remapFaces(faces, positions));
+}
+function subdivideMesh(faces, edgeSplitRatio = 0.5) {
+  const t = Math.min(1, Math.max(0, edgeSplitRatio));
+  const out = [];
+  for (const f of faces) {
+    const ring = ringOf(f);
+    if (ring.length < 3) continue;
+    const c = centroid(f);
+    const n = ring.length;
+    const splits = [];
+    for (let i = 0; i < n; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % n];
+      splits.push(lerp(a, b, t));
+    }
+    for (let i = 0; i < n; i++) {
+      const v = ring[i];
+      const sPrev = splits[(i - 1 + n) % n];
+      const sNext = splits[i];
+      out.push(polygon([v, sNext, c, sPrev]));
+    }
+  }
+  return group(out);
+}
+function simplifyMesh(faces, tolerance, preservePerimeter = true) {
+  if (tolerance <= 0 || faces.length === 0) return group(faces.map((f) => polygon(ringOf(f), f.rings.slice(1))));
+  const edgeMap = buildEdgeMap(faces);
+  const peri = perimeterKeys(edgeMap);
+  const simplified = faces.map((f) => {
+    const ring = ringOf(f);
+    if (ring.length <= 3) return polygon(ring);
+    if (preservePerimeter) {
+      const s = simplify(f, tolerance);
+      const sr = ringOf(s);
+      if (sr.length < 3) return polygon(ring);
+      return polygon(sr, s.rings.slice(1));
+    }
+    return simplify(f, tolerance);
+  });
+  const all = unique(simplified.flatMap((f) => ringOf(f)));
+  const snapped = clusterSnap(all, Math.max(tolerance * 0.5, 1e-9));
+  const remap = (v) => {
+    let best = v;
+    let bestD = Infinity;
+    for (const s of snapped) {
+      const d = dist(v, s);
+      if (d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    return { ...best };
+  };
+  const periVerts = /* @__PURE__ */ new Set();
+  if (preservePerimeter) {
+    for (const key of peri) {
+      const e = edgeMap.get(key);
+      periVerts.add(vertKey(e.a));
+      periVerts.add(vertKey(e.b));
+    }
+  }
+  return group(
+    simplified.map((f, i) => {
+      const original = ringOf(faces[i]);
+      const ring = ringOf(f).map((v, vi) => {
+        if (preservePerimeter && original[vi] && periVerts.has(vertKey(original[vi]))) {
+          return { ...original[vi] };
+        }
+        for (const ov of original) {
+          if (periVerts.has(vertKey(ov)) && dist(v, ov) < tolerance * 2) {
+            return { ...ov };
+          }
+        }
+        return remap(v);
+      });
+      return polygon(unique(ring).length >= 3 ? ring : original);
+    })
+  );
+}
+function clusterSnap(points, tol) {
+  const clusters = [];
+  for (const p of points) {
+    let found = false;
+    for (const c of clusters) {
+      if (dist(p, c[0]) <= tol) {
+        c.push(p);
+        found = true;
+        break;
+      }
+    }
+    if (!found) clusters.push([p]);
+  }
+  return clusters.map((c) => ({
+    x: c.reduce((s, p) => s + p.x, 0) / c.length,
+    y: c.reduce((s, p) => s + p.y, 0) / c.length
+  }));
+}
+function stochasticMerge(faces, nClasses, seed = 1) {
+  if (faces.length === 0) return group([]);
+  const classes = Math.max(1, Math.floor(nClasses));
+  const rng = mulberry32(seed >>> 0);
+  const label = faces.map(() => Math.floor(rng() * classes));
+  const adj = faceAdjacency(faces);
+  const parent = faces.map((_, i) => i);
+  const find = (i) => {
+    let x = i;
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  const unite = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[rb] = ra;
+  };
+  for (let i = 0; i < faces.length; i++) {
+    for (const j of adj[i]) {
+      if (j > i && label[i] === label[j]) unite(i, j);
+    }
+  }
+  const comps = /* @__PURE__ */ new Map();
+  for (let i = 0; i < faces.length; i++) {
+    const r = find(i);
+    const list = comps.get(r) ?? [];
+    list.push(i);
+    comps.set(r, list);
+  }
+  const out = [];
+  for (const members of comps.values()) {
+    if (members.length === 1) {
+      out.push(faces[members[0]]);
+      continue;
+    }
+    const merged = dissolveFaces(members.map((i) => faces[i]));
+    out.push(...merged);
+  }
+  return group(out);
+}
+function dissolveFaces(faces) {
+  if (faces.length === 0) return [];
+  if (faces.length === 1) return [faces[0]];
+  try {
+    let acc = faces[0];
+    for (let i = 1; i < faces.length; i++) {
+      const u = union(acc, faces[i]);
+      if (u.paths.length === 0) continue;
+      acc = u.paths.reduce(
+        (best, p) => area(p) > area(best) ? p : best
+      );
+    }
+    return [acc];
+  } catch {
+    return [convexHullOf(faces.flatMap((f) => ringOf(f)))];
+  }
+}
+function areaMerge(faces, minAreaOrOptions) {
+  let working = [...faces];
+  if (working.length === 0) return group([]);
+  if (typeof minAreaOrOptions === "object" && minAreaOrOptions.remainingFaces != null) {
+    const target = Math.max(1, Math.floor(minAreaOrOptions.remainingFaces));
+    while (working.length > target) {
+      const next = mergeSmallestAdjacent(working);
+      if (next.length >= working.length) break;
+      working = next;
+    }
+    return group(working);
+  }
+  const minArea = typeof minAreaOrOptions === "number" ? minAreaOrOptions : minAreaOrOptions.minArea ?? 0;
+  let guard = 0;
+  while (guard++ < working.length + 10) {
+    const smallIdx = working.findIndex((f) => area(f) < minArea);
+    if (smallIdx < 0) break;
+    const next = mergeFaceIntoNeighbor(working, smallIdx);
+    if (!next) break;
+    working = next;
+  }
+  return group(working);
+}
+function mergeSmallestAdjacent(faces) {
+  let best = -1;
+  let bestA = Infinity;
+  for (let i = 0; i < faces.length; i++) {
+    const a = area(faces[i]);
+    if (a < bestA) {
+      bestA = a;
+      best = i;
+    }
+  }
+  if (best < 0) return faces;
+  return mergeFaceIntoNeighbor(faces, best) ?? faces;
+}
+function mergeFaceIntoNeighbor(faces, idx) {
+  const adj = faceAdjacency(faces);
+  const nbrs = adj[idx] ?? [];
+  if (nbrs.length === 0) {
+    return faces.filter((_, i) => i !== idx);
+  }
+  let bestN = nbrs[0];
+  let bestA = -1;
+  for (const n of nbrs) {
+    const a = area(faces[n]);
+    if (a > bestA) {
+      bestA = a;
+      bestN = n;
+    }
+  }
+  const merged = dissolveFaces([faces[idx], faces[bestN]]);
+  const out = [];
+  for (let i = 0; i < faces.length; i++) {
+    if (i === idx || i === bestN) continue;
+    out.push(faces[i]);
+  }
+  out.push(...merged);
+  return out;
+}
+function convexHullOf(points) {
+  const pts = unique(points);
+  if (pts.length < 3) return polygon(pts);
+  pts.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+  const lower = [];
+  for (const p of pts) {
+    while (lower.length >= 2 && cross(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 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+      upper.pop();
+    }
+    upper.push(p);
+  }
+  lower.pop();
+  upper.pop();
+  return polygon([...lower, ...upper]);
+}
+function mulberry32(a) {
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function findBreaks(faces) {
+  const edgeMap = buildEdgeMap(faces);
+  const segs = [];
+  const peri = [];
+  for (const e of edgeMap.values()) {
+    if (e.faceIds.length === 1) peri.push(e);
+  }
+  const used = /* @__PURE__ */ new Set();
+  for (let i = 0; i < peri.length; i++) {
+    if (used.has(i)) continue;
+    const a = peri[i];
+    for (let j = i + 1; j < peri.length; j++) {
+      if (used.has(j)) continue;
+      const b = peri[j];
+      if (nearDuplicateEdge(a, b, 1e-3)) {
+        segs.push(polyline([a.a, a.b]));
+        segs.push(polyline([b.a, b.b]));
+        used.add(i);
+        used.add(j);
+        break;
+      }
+    }
+  }
+  return group(segs);
+}
+function nearDuplicateEdge(a, b, tol) {
+  const d1 = dist(a.a, b.a) + dist(a.b, b.b);
+  const d2 = dist(a.a, b.b) + dist(a.b, b.a);
+  const len = dist(a.a, a.b);
+  return Math.min(d1, d2) < tol * 2 + len * 0.05 && Math.min(d1, d2) > 1e-9;
+}
+function fixBreaks(faces, maxGapWidth) {
+  if (faces.length === 0) return group([]);
+  const tol = Math.max(maxGapWidth, 1e-9);
+  const verts = unique(faces.flatMap((f) => ringOf(f)));
+  const snapped = clusterSnap(verts, tol);
+  const remap = (v) => {
+    let best = snapped[0];
+    let bestD = Infinity;
+    for (const s of snapped) {
+      const d = dist(v, s);
+      if (d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    return { ...best };
+  };
+  const fixed = faces.map((f) => {
+    const ring = unique(ringOf(f).map(remap));
+    return ring.length >= 3 ? polygon(ring) : f;
+  });
+  try {
+    return group(dissolveOverlaps(fixed));
+  } catch {
+    return group(fixed);
+  }
+}
+function dissolveOverlaps(faces) {
+  let working = [...faces];
+  let changed = true;
+  let guard = 0;
+  while (changed && guard++ < working.length) {
+    changed = false;
+    outer: for (let i = 0; i < working.length; i++) {
+      for (let j = i + 1; j < working.length; j++) {
+        const a = working[i];
+        const b = working[j];
+        const u = union(a, b);
+        const ua = u.paths.reduce((s, p) => s + area(p), 0);
+        if (ua < area(a) + area(b) - 1e-6) {
+          const next = working.filter((_, k) => k !== i && k !== j);
+          next.push(...u.paths);
+          working = next;
+          changed = true;
+          break outer;
+        }
+      }
+    }
+  }
+  return working;
+}
+function fixBrokenFaces(coverage, tolerance, polygonise = true) {
+  const tol = Math.max(tolerance, 1e-9);
+  const anchors = [];
+  const endpoints = [];
+  coverage.forEach((p, pi) => {
+    const ring = ringOf(p);
+    if (ring.length === 0) return;
+    if (p.closed) {
+      for (const v of ring) anchors.push(v);
+    } else {
+      endpoints.push({ pathIdx: pi, end: 0, v: ring[0] });
+      endpoints.push({
+        pathIdx: pi,
+        end: 1,
+        v: ring[ring.length - 1]
+      });
+    }
+  });
+  const snapTargets = clusterSnap(
+    [...anchors, ...endpoints.map((e) => e.v)],
+    tol
+  );
+  const snapTo = (v, preferAnchor) => {
+    let best = v;
+    let bestD = Infinity;
+    for (const s of snapTargets) {
+      const d = dist(v, s);
+      if (d <= tol && d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    {
+      for (const a of anchors) {
+        if (dist(v, a) <= tol) return { ...a };
+      }
+    }
+    return { ...best };
+  };
+  const snappedPaths = coverage.map((p) => {
+    const ring = ringOf(p);
+    if (ring.length === 0) return p;
+    if (p.closed) return p;
+    const next = ring.map((v) => ({ ...v }));
+    next[0] = snapTo(ring[0]);
+    next[next.length - 1] = snapTo(ring[ring.length - 1]);
+    return polyline(next);
+  });
+  if (!polygonise) return group(snappedPaths);
+  const out = [];
+  for (const p of snappedPaths) {
+    const ring = ringOf(p);
+    if (p.closed) {
+      out.push(p);
+      continue;
+    }
+    if (ring.length >= 3 && same(ring[0], ring[ring.length - 1], tol * 2)) {
+      out.push(polygon(ring.slice(0, -1)));
+    } else if (ring.length >= 3 && dist(ring[0], ring[ring.length - 1]) <= tol * 2) {
+      out.push(polygon(ring));
+    } else {
+      out.push(p);
+    }
+  }
+  return group(out);
+}
+function findIslands(faces) {
+  if (faces.length === 0) return [];
+  const adj = faceAdjacency(faces);
+  const seen = /* @__PURE__ */ new Set();
+  const islands = [];
+  for (let i = 0; i < faces.length; i++) {
+    if (seen.has(i)) continue;
+    const stack = [i];
+    const members = [];
+    seen.add(i);
+    while (stack.length) {
+      const cur = stack.pop();
+      members.push(cur);
+      for (const n of adj[cur]) {
+        if (!seen.has(n)) {
+          seen.add(n);
+          stack.push(n);
+        }
+      }
+    }
+    islands.push(members);
+  }
+  islands.sort((a, b) => b.length - a.length);
+  return islands.map((m) => group(m.map((i) => faces[i])));
+}
+function radialSortFaces(faces) {
+  if (faces.length === 0) return [];
+  const cs = faces.map((f) => centroid(f));
+  const cx = cs.reduce((s, p) => s + p.x, 0) / cs.length;
+  const cy = cs.reduce((s, p) => s + p.y, 0) / cs.length;
+  return faces.map((f, i) => ({ f, a: Math.atan2(cs[i].y - cy, cs[i].x - cx) })).sort((a, b) => a.a - b.a).map((x) => x.f);
+}
+function centroidSortFaces(faces) {
+  return [...faces].sort((a, b) => {
+    const ca = centroid(a);
+    const cb = centroid(b);
+    return ca.x === cb.x ? ca.y - cb.y : ca.x - cb.x;
+  });
+}
+var meshing = {
+  extractInnerEdges,
+  extractInnerVertices,
+  findContainingFace,
+  splitEdges,
+  urquhartFaces,
+  gabrielFaces,
+  relativeNeighborFaces,
+  spannerFaces,
+  dualFaces,
+  centroidQuadrangulation,
+  edgeCollapseQuadrangulation,
+  splitQuadrangulation,
+  spiralQuadrangulation,
+  matchingQuadrangulation,
+  smoothMesh,
+  subdivideMesh,
+  simplifyMesh,
+  stochasticMerge,
+  areaMerge,
+  radialSortFaces,
+  centroidSortFaces,
+  findBreaks,
+  fixBreaks,
+  fixBrokenFaces,
+  findIslands
+};
+
+export { areaMerge, centroidQuadrangulation, centroidSortFaces, dualFaces, edgeCollapseQuadrangulation, extractInnerEdges, extractInnerVertices, findBreaks, findContainingFace, findIslands, fixBreaks, fixBrokenFaces, gabrielFaces, matchingQuadrangulation, meshing, radialSortFaces, relativeNeighborFaces, simplifyMesh, smoothMesh, spannerFaces, spiralQuadrangulation, splitEdges, splitQuadrangulation, stochasticMerge, subdivideMesh, urquhartFaces };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map