pattapatta 0.2.0

package/dist/index.js

@@ -0,0 +1,3933 @@
+import { FillRule, JoinType, inflatePathsD, EndType, simplifyPathD, minkowskiSumD, minkowskiDiffD, triangulateD, unionD, isPositiveD, intersectD, differenceD, xorD, areaD, pointInPolygonD, PointInPolygonResult } 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/circle.ts
+function circle(x, y, r) {
+  return { x, y, r };
+}
+function circleCenter(c) {
+  return { x: c.x, y: c.y };
+}
+
+// src/types/segment.ts
+function segment(a, b) {
+  return { a, b };
+}
+
+// src/types/path.ts
+function path(rings, closed = true) {
+  return {
+    rings: rings.map((ring2) => ring2.map(cloneVec2)),
+    closed
+  };
+}
+function polyline(points) {
+  return path([points], false);
+}
+function polygon(exterior, holes = []) {
+  return path([exterior, ...holes], true);
+}
+function normalizeRing(ring2, eps = 1e-9) {
+  if (ring2.length < 2) return ring2.map(cloneVec2);
+  const first = ring2[0];
+  const last = ring2[ring2.length - 1];
+  if (first && last && equalsVec2(first, last, eps)) {
+    return ring2.slice(0, -1).map(cloneVec2);
+  }
+  return ring2.map(cloneVec2);
+}
+function clonePath(p) {
+  return {
+    closed: p.closed,
+    rings: p.rings.map((ring2) => ring2.map(cloneVec2))
+  };
+}
+
+// src/types/group.ts
+function group(paths = []) {
+  return { paths: paths.map(clonePath) };
+}
+function groupFromPaths(...paths) {
+  return group(paths);
+}
+function cloneGroup(g) {
+  return group(g.paths);
+}
+
+// src/svg/pathData.ts
+function parsePathData(d) {
+  const tokens = tokenize(d);
+  const rings = [];
+  let current = [];
+  let cx = 0;
+  let cy = 0;
+  let startX = 0;
+  let startY = 0;
+  let sawClose = false;
+  let i = 0;
+  const pushPoint = (x, y) => {
+    current.push(vec2(x, y));
+    cx = x;
+    cy = y;
+  };
+  const finishSubpath = () => {
+    if (current.length === 0) return;
+    const ring2 = normalizeRing(current);
+    if (ring2.length > 0) rings.push(ring2);
+    current = [];
+  };
+  while (i < tokens.length) {
+    const raw = tokens[i];
+    if (raw === void 0) break;
+    i += 1;
+    if (!/^[MmLlHhVvZz]$/.test(raw)) {
+      throw new Error(
+        `Unsupported SVG path command or token "${raw}". Phase 1 supports M/L/H/V/Z only.`
+      );
+    }
+    const relative = raw === raw.toLowerCase();
+    const kind = raw.toUpperCase();
+    if (kind === "Z") {
+      sawClose = true;
+      finishSubpath();
+      cx = startX;
+      cy = startY;
+      continue;
+    }
+    if (kind === "M") {
+      finishSubpath();
+      const pair = readPair(tokens, i);
+      i = pair.next;
+      const x = relative ? cx + pair.x : pair.x;
+      const y = relative ? cy + pair.y : pair.y;
+      pushPoint(x, y);
+      startX = x;
+      startY = y;
+      while (i < tokens.length && isNumberToken(tokens[i])) {
+        const next = readPair(tokens, i);
+        i = next.next;
+        const nx = relative ? cx + next.x : next.x;
+        const ny = relative ? cy + next.y : next.y;
+        pushPoint(nx, ny);
+      }
+      continue;
+    }
+    if (kind === "L") {
+      while (i < tokens.length && isNumberToken(tokens[i])) {
+        const pair = readPair(tokens, i);
+        i = pair.next;
+        const x = relative ? cx + pair.x : pair.x;
+        const y = relative ? cy + pair.y : pair.y;
+        pushPoint(x, y);
+      }
+      continue;
+    }
+    if (kind === "H") {
+      while (i < tokens.length && isNumberToken(tokens[i])) {
+        const v = readNumber(tokens, i);
+        i = v.next;
+        const x = relative ? cx + v.value : v.value;
+        pushPoint(x, cy);
+      }
+      continue;
+    }
+    if (kind === "V") {
+      while (i < tokens.length && isNumberToken(tokens[i])) {
+        const v = readNumber(tokens, i);
+        i = v.next;
+        const y = relative ? cy + v.value : v.value;
+        pushPoint(cx, y);
+      }
+    }
+  }
+  finishSubpath();
+  return { rings, closed: sawClose };
+}
+function serializePathData(rings, closed) {
+  const parts = [];
+  for (const ring2 of rings) {
+    if (ring2.length === 0) continue;
+    const first = ring2[0];
+    if (!first) continue;
+    parts.push(`M ${fmt(first.x)} ${fmt(first.y)}`);
+    for (let i = 1; i < ring2.length; i += 1) {
+      const p = ring2[i];
+      if (!p) continue;
+      parts.push(`L ${fmt(p.x)} ${fmt(p.y)}`);
+    }
+    if (closed) parts.push("Z");
+  }
+  return parts.join(" ");
+}
+function tokenize(d) {
+  const out = [];
+  const re = /([MmLlHhVvZz])|([+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)/g;
+  let m;
+  while ((m = re.exec(d)) !== null) {
+    const token = m[1] ?? m[2];
+    if (token) out.push(token);
+  }
+  return out;
+}
+function isNumberToken(token) {
+  return token !== void 0 && /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(token);
+}
+function readNumber(tokens, i) {
+  const t = tokens[i];
+  if (!isNumberToken(t) || t === void 0) {
+    throw new Error(`Expected number in path data at token index ${i}`);
+  }
+  return { value: Number(t), next: i + 1 };
+}
+function readPair(tokens, i) {
+  const x = readNumber(tokens, i);
+  const y = readNumber(tokens, x.next);
+  return { x: x.value, y: y.value, next: y.next };
+}
+function fmt(n) {
+  if (Number.isInteger(n)) return String(n);
+  return String(Number(n.toPrecision(12)));
+}
+
+// src/svg/parse.ts
+var SHAPE_RE = /<(path|rect|circle|line|polyline|polygon)\b[^>]*\/?>/gi;
+function parseSvg(svg) {
+  const paths = [];
+  for (const match of svg.matchAll(SHAPE_RE)) {
+    const el = match[0];
+    const tag = match[1]?.toLowerCase();
+    if (!tag) continue;
+    if (tag === "path") {
+      const d = getAttr(el, "d");
+      if (!d) continue;
+      const parsed = parsePathData(d);
+      if (parsed.rings.length === 0) continue;
+      paths.push(path(parsed.rings, parsed.closed));
+      continue;
+    }
+    if (tag === "rect") {
+      const x = num(getAttr(el, "x"), 0);
+      const y = num(getAttr(el, "y"), 0);
+      const w = num(getAttr(el, "width"), 0);
+      const h = num(getAttr(el, "height"), 0);
+      if (w === 0 || h === 0) continue;
+      paths.push(
+        polygon([
+          vec2(x, y),
+          vec2(x + w, y),
+          vec2(x + w, y + h),
+          vec2(x, y + h)
+        ])
+      );
+      continue;
+    }
+    if (tag === "circle") {
+      const cx = num(getAttr(el, "cx"), 0);
+      const cy = num(getAttr(el, "cy"), 0);
+      const r = num(getAttr(el, "r"), 0);
+      if (r <= 0) continue;
+      paths.push(polygon(circleRing(cx, cy, r, 64)));
+      continue;
+    }
+    if (tag === "line") {
+      const x1 = num(getAttr(el, "x1"), 0);
+      const y1 = num(getAttr(el, "y1"), 0);
+      const x2 = num(getAttr(el, "x2"), 0);
+      const y2 = num(getAttr(el, "y2"), 0);
+      paths.push(polyline([vec2(x1, y1), vec2(x2, y2)]));
+      continue;
+    }
+    if (tag === "polyline") {
+      const pts = parsePoints(getAttr(el, "points") ?? "");
+      if (pts.length >= 2) paths.push(polyline(pts));
+      continue;
+    }
+    if (tag === "polygon") {
+      const pts = parsePoints(getAttr(el, "points") ?? "");
+      if (pts.length >= 3) paths.push(polygon(pts));
+    }
+  }
+  return group(paths);
+}
+function getAttr(el, name) {
+  const re = new RegExp(`\\b${name}\\s*=\\s*["']([^"']*)["']`, "i");
+  const m = re.exec(el);
+  return m?.[1];
+}
+function num(value, fallback) {
+  if (value === void 0 || value === "") return fallback;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+function parsePoints(points) {
+  const nums = points.trim().split(/[\s,]+/).filter(Boolean).map(Number);
+  const out = [];
+  for (let i = 0; i + 1 < nums.length; i += 2) {
+    const x = nums[i];
+    const y = nums[i + 1];
+    if (x === void 0 || y === void 0) continue;
+    if (!Number.isFinite(x) || !Number.isFinite(y)) continue;
+    out.push(vec2(x, y));
+  }
+  return out;
+}
+function circleRing(cx, cy, r, segments) {
+  const ring2 = [];
+  for (let i = 0; i < segments; i += 1) {
+    const t = i / segments * Math.PI * 2;
+    ring2.push(vec2(cx + r * Math.cos(t), cy + r * Math.sin(t)));
+  }
+  return ring2;
+}
+
+// src/svg/serialize.ts
+function toSvg(g, options = {}) {
+  const stroke = options.stroke ?? "#000";
+  const strokeWidth = options.strokeWidth ?? 1;
+  const viewBox = options.viewBox ?? inferViewBox(g);
+  const widthAttr = options.width !== void 0 ? ` width="${options.width}"` : "";
+  const heightAttr = options.height !== void 0 ? ` height="${options.height}"` : "";
+  const body = g.paths.map((p) => pathElement(p, stroke, strokeWidth)).filter(Boolean).join("\n  ");
+  return [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox}"${widthAttr}${heightAttr} fill="none">`,
+    body ? `  ${body}` : "",
+    `</svg>`
+  ].filter((line) => line !== "").join("\n");
+}
+function pathElement(p, stroke, strokeWidth) {
+  if (p.rings.length === 0) return "";
+  const d = serializePathData(p.rings, p.closed);
+  if (!d) return "";
+  return `<path d="${d}" stroke="${stroke}" stroke-width="${strokeWidth}" fill="none" />`;
+}
+function inferViewBox(g) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of g.paths) {
+    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);
+      }
+    }
+  }
+  if (!Number.isFinite(minX)) return "0 0 100 100";
+  const pad = 1;
+  const w = Math.max(maxX - minX, 0) + pad * 2;
+  const h = Math.max(maxY - minY, 0) + pad * 2;
+  return `${minX - pad} ${minY - pad} ${w} ${h}`;
+}
+var DEFAULT_FILL_RULE = FillRule.NonZero;
+function ringToPathD(ring2) {
+  const pts = [];
+  for (const v of normalizeRing(ring2)) {
+    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((ring2) => ringToPathD(ring2));
+}
+function pathsDToGroup(paths) {
+  if (paths.length === 0) return group([]);
+  const outers = [];
+  const holes = [];
+  for (const pd of paths) {
+    const ring2 = pathDToRing(pd);
+    if (ring2.length < 3) continue;
+    if (isPositiveD(pd)) {
+      outers.push({ ring: ring2, holes: [] });
+    } else {
+      holes.push(ring2);
+    }
+  }
+  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, ring2) {
+  const result = pointInPolygonD(
+    { x: point.x, y: point.y, z: 0 },
+    ringToPathD(ring2)
+  );
+  return result === PointInPolygonResult.IsInside || result === PointInPolygonResult.IsOn;
+}
+function clipUnion(a, b) {
+  return unionD(a, b, DEFAULT_FILL_RULE);
+}
+function clipIntersect(a, b) {
+  return intersectD(a, b, DEFAULT_FILL_RULE);
+}
+function clipDifference(a, b) {
+  return differenceD(a, b, DEFAULT_FILL_RULE);
+}
+function clipXor(a, b) {
+  return xorD(a, b, DEFAULT_FILL_RULE);
+}
+function pathsArea(paths) {
+  let sum = 0;
+  for (const p of paths) {
+    sum += Math.abs(areaD(p));
+  }
+  return sum;
+}
+
+// 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 unionAll(paths) {
+  if (paths.length === 0) return group([]);
+  let acc = pathToPathsD(ensureClosed(paths[0]));
+  for (let i = 1; i < paths.length; i++) {
+    acc = clipUnion(acc, pathToPathsD(ensureClosed(paths[i])));
+  }
+  return pathsDToGroup(acc);
+}
+function intersect(a, b) {
+  const result = clipIntersect(
+    pathToPathsD(ensureClosed(a)),
+    pathToPathsD(ensureClosed(b))
+  );
+  return pathsDToGroup(result);
+}
+function subtract(a, b) {
+  const result = clipDifference(
+    pathToPathsD(ensureClosed(a)),
+    pathToPathsD(ensureClosed(b))
+  );
+  return pathsDToGroup(result);
+}
+function subtractAll(base, shapes) {
+  let acc = pathToPathsD(ensureClosed(base));
+  for (const s of shapes) {
+    acc = clipDifference(acc, pathToPathsD(ensureClosed(s)));
+  }
+  return pathsDToGroup(acc);
+}
+function symDifference(a, b) {
+  const result = clipXor(pathToPathsD(ensureClosed(a)), pathToPathsD(ensureClosed(b)));
+  return pathsDToGroup(result);
+}
+function complement(shape, width2, height2) {
+  const frame = polygon([
+    vec2(0, 0),
+    vec2(width2, 0),
+    vec2(width2, height2),
+    vec2(0, height2)
+  ]);
+  return subtract(frame, shape);
+}
+function occlusionSubtract(g) {
+  const paths = g.paths;
+  const visible = [];
+  for (let i = 0; i < paths.length; i++) {
+    const subject = paths[i];
+    if (!subject) continue;
+    const occluders = paths.slice(i + 1);
+    const piece = occluders.length === 0 ? groupFromPaths(ensureClosed(subject)) : subtractAll(subject, occluders);
+    for (const p of piece.paths) {
+      visible.push(p);
+    }
+  }
+  return group(visible);
+}
+function overlapRegions(shapes, merged) {
+  if (shapes.length < 2) return group([]);
+  const pairs = [];
+  for (let i = 0; i < shapes.length; i++) {
+    for (let j = i + 1; j < shapes.length; j++) {
+      const a = shapes[i];
+      const b = shapes[j];
+      if (!a || !b) continue;
+      for (const p of intersect(a, b).paths) {
+        pairs.push(p);
+      }
+    }
+  }
+  if (!merged) return group(pairs);
+  return unionAll(pairs);
+}
+var shapeBoolean = {
+  union,
+  unionAll,
+  intersect,
+  subtract,
+  subtractAll,
+  symDifference,
+  complement,
+  occlusionSubtract,
+  overlapRegions
+};
+
+// src/predicates/index.ts
+function ringArea(ring2) {
+  if (ring2.length < 3) return 0;
+  let sum = 0;
+  for (let i = 0; i < ring2.length; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % ring2.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function 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 areaGroup(g) {
+  return g.paths.reduce((sum, p) => sum + area(p), 0);
+}
+function centroid(p) {
+  const ring2 = p.rings[0];
+  if (!ring2 || ring2.length === 0) return vec2(0, 0);
+  const a = ringArea(ring2);
+  if (Math.abs(a) < 1e-12) {
+    let sx = 0;
+    let sy = 0;
+    for (const v of ring2) {
+      sx += v.x;
+      sy += v.y;
+    }
+    return vec2(sx / ring2.length, sy / ring2.length);
+  }
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < ring2.length; i++) {
+    const p0 = ring2[i];
+    const p1 = ring2[(i + 1) % ring2.length];
+    const cross4 = p0.x * p1.y - p1.x * p0.y;
+    cx += (p0.x + p1.x) * cross4;
+    cy += (p0.y + p1.y) * cross4;
+  }
+  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 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);
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+  }
+  return { minX, minY, maxX, maxY };
+}
+function width(p) {
+  const b = bounds(p);
+  return b.maxX - b.minX;
+}
+function height(p) {
+  const b = bounds(p);
+  return b.maxY - b.minY;
+}
+function areaSimilarity(a, b) {
+  const aa = area(a);
+  const bb = area(b);
+  const denom = Math.max(aa, bb, 1e-12);
+  return 1 - Math.abs(aa - bb) / denom;
+}
+var predicates = {
+  area,
+  areaGroup,
+  ringArea,
+  centroid,
+  containsPoint,
+  bounds,
+  width,
+  height,
+  areaSimilarity
+};
+
+// src/compare/index.ts
+function ringsToPath(rings) {
+  const converted = rings.map(
+    (ring2) => ring2.map((pt) => vec2(pt[0], pt[1]))
+  );
+  return polygon(converted[0] ?? [], converted.slice(1));
+}
+function oraclePathsToGroup(paths) {
+  return {
+    paths: paths.map((p) => ringsToPath(p.rings))
+  };
+}
+function relativeAreaError(a, b) {
+  const aa = areaGroup(a);
+  const bb = areaGroup(b);
+  const denom = Math.max(Math.abs(aa), Math.abs(bb), 1e-12);
+  return Math.abs(aa - bb) / denom;
+}
+function assertAreaClose(actual, expectedArea, tol = 1e-3) {
+  const got = areaGroup(actual);
+  const denom = Math.max(Math.abs(expectedArea), 1e-12);
+  const err = Math.abs(got - expectedArea) / denom;
+  if (err > tol) {
+    throw new Error(
+      `Area mismatch: got ${got}, expected ${expectedArea}, relErr=${err}`
+    );
+  }
+}
+function containmentAgreement(a, b, samples = 20) {
+  const bounds2 = unionBounds(a, b);
+  if (bounds2.maxX === bounds2.minX || bounds2.maxY === bounds2.minY) return 1;
+  let agree = 0;
+  let total = 0;
+  for (let i = 0; i < samples; i++) {
+    for (let j = 0; j < samples; j++) {
+      const x = bounds2.minX + (i + 0.5) / samples * (bounds2.maxX - bounds2.minX);
+      const y = bounds2.minY + (j + 0.5) / samples * (bounds2.maxY - bounds2.minY);
+      const p = vec2(x, y);
+      const inA = pointInGroup(a, p);
+      const inB = pointInGroup(b, p);
+      if (inA === inB) agree += 1;
+      total += 1;
+    }
+  }
+  return agree / total;
+}
+function pointInGroup(g, p) {
+  for (const path3 of g.paths) {
+    if (!path3.closed || !path3.rings[0]) continue;
+    if (!pointInPoly(p, path3.rings[0])) continue;
+    let inHole = false;
+    for (let i = 1; i < path3.rings.length; i++) {
+      const hole = path3.rings[i];
+      if (hole && pointInPoly(p, hole)) {
+        inHole = true;
+        break;
+      }
+    }
+    if (!inHole) return true;
+  }
+  return false;
+}
+function pointInPoly(point, ring2) {
+  let inside = false;
+  for (let i = 0, j = ring2.length - 1; i < ring2.length; j = i++) {
+    const xi = ring2[i].x;
+    const yi = ring2[i].y;
+    const xj = ring2[j].x;
+    const yj = ring2[j].y;
+    const intersect2 = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi + 0) + xi;
+    if (intersect2) inside = !inside;
+  }
+  return inside;
+}
+function unionBounds(a, b) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const g of [a, b]) {
+    for (const p of g.paths) {
+      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 { minX, minY, maxX, maxY };
+}
+
+// src/segmentSet/index.ts
+function f32(n) {
+  return Math.fround(n);
+}
+function parallelSegments(centerX, centerY, length, spacing, angle, n) {
+  const edges = [];
+  if (n < 1) return edges;
+  const center = vec2(f32(centerX), f32(centerY));
+  let dx = f32(Math.cos(angle + Math.PI / 2) * spacing);
+  let dy = f32(Math.sin(angle + Math.PI / 2) * spacing);
+  const cos = f32(Math.cos(angle));
+  const sin = f32(Math.sin(angle));
+  const l = f32(length);
+  let i;
+  let offX = 0;
+  let offY = 0;
+  if (n % 2 === 1) {
+    const a = vec2(f32(center.x + cos * l), f32(center.y + sin * l));
+    const b = vec2(f32(center.x + cos * -l), f32(center.y + sin * -l));
+    edges.push(segment(a, b));
+    i = 1;
+  } else {
+    dx = f32(dx / 2);
+    dy = f32(dy / 2);
+    i = 1;
+    {
+      let a = vec2(f32(center.x + dx * i), f32(center.y + dy * i));
+      const b = vec2(f32(a.x + cos * l), f32(a.y + sin * l));
+      a = vec2(f32(a.x + cos * -l), f32(a.y + sin * -l));
+      edges.push(segment(a, b));
+    }
+    {
+      let a = vec2(f32(center.x + dx * -i), f32(center.y + dy * -i));
+      const b = vec2(f32(a.x + cos * l), f32(a.y + sin * l));
+      a = vec2(f32(a.x + cos * -l), f32(a.y + sin * -l));
+      edges.push(segment(a, b));
+    }
+    i = 2;
+    dx = f32(dx * 2);
+    dy = f32(dy * 2);
+    offX = f32(dx / 2);
+    offY = f32(dy / 2);
+  }
+  for (; i < 1 + Math.floor(n / 2); i++) {
+    {
+      let a = vec2(
+        f32(center.x + dx * i - offX),
+        f32(center.y + dy * i - offY)
+      );
+      const b = vec2(f32(a.x + cos * l), f32(a.y + sin * l));
+      a = vec2(f32(a.x + cos * -l), f32(a.y + sin * -l));
+      edges.push(segment(a, b));
+    }
+    {
+      let a = vec2(
+        f32(center.x + dx * -i + offX),
+        f32(center.y + dy * -i + offY)
+      );
+      const b = vec2(f32(a.x + cos * l), f32(a.y + sin * l));
+      a = vec2(f32(a.x + cos * -l), f32(a.y + sin * -l));
+      edges.push(segment(a, b));
+    }
+  }
+  return edges;
+}
+function filterByMinLength(segments, minLength) {
+  return segments.filter((s) => segmentLength(s) >= minLength);
+}
+function filterAxisAligned(segments, angleDelta) {
+  return segments.filter((s) => {
+    const ang = Math.abs(Math.atan2(s.b.y - s.a.y, s.b.x - s.a.x));
+    const norm = Math.min(ang % Math.PI, Math.PI - ang % Math.PI);
+    const nearH = norm <= angleDelta || Math.abs(norm - Math.PI) <= angleDelta;
+    const nearV = Math.abs(norm - Math.PI / 2) <= angleDelta;
+    return !(nearH || nearV);
+  });
+}
+function segmentLength(s) {
+  const dx = s.b.x - s.a.x;
+  const dy = s.b.y - s.a.y;
+  return Math.hypot(dx, dy);
+}
+function segmentsToOpenPaths(segments) {
+  return segments.map((s) => ({
+    rings: [[s.a, s.b]],
+    closed: false
+  }));
+}
+var segmentSet = {
+  parallelSegments,
+  filterByMinLength,
+  filterAxisAligned,
+  segmentLength,
+  segmentsToOpenPaths
+};
+
+// src/segmentSet/clip.ts
+function clipSegmentToPath(seg, clip) {
+  if (!clip.closed || !clip.rings[0]) return [];
+  const hits = [];
+  const pushHit = (t, p) => {
+    if (t < -1e-9 || t > 1 + 1e-9) return;
+    const tt = Math.min(1, Math.max(0, t));
+    for (const h of hits) {
+      if (Math.abs(h.t - tt) < 1e-9) return;
+    }
+    hits.push({ t: tt, p });
+  };
+  if (containsPoint(clip, seg.a)) pushHit(0, seg.a);
+  if (containsPoint(clip, seg.b)) pushHit(1, seg.b);
+  for (const ring2 of clip.rings) {
+    for (let i = 0; i < ring2.length; i++) {
+      const e0 = ring2[i];
+      const e1 = ring2[(i + 1) % ring2.length];
+      const hit = segmentIntersection(seg.a, seg.b, e0, e1);
+      if (hit) pushHit(hit.t, hit.p);
+    }
+  }
+  hits.sort((a, b) => a.t - b.t);
+  if (hits.length < 2) return [];
+  const out = [];
+  for (let i = 0; i + 1 < hits.length; i++) {
+    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)) {
+      out.push(segment(h0.p, h1.p));
+    }
+  }
+  return out;
+}
+function clipSegmentsToPath(segments, clip) {
+  const out = [];
+  for (const s of segments) {
+    out.push(...clipSegmentToPath(s, clip));
+  }
+  return out;
+}
+function segmentIntersection(a, b, c, d) {
+  const rX = b.x - a.x;
+  const rY = b.y - a.y;
+  const sX = d.x - c.x;
+  const sY = d.y - c.y;
+  const denom = rX * sY - rY * sX;
+  if (Math.abs(denom) < 1e-12) return null;
+  const t = ((c.x - a.x) * sY - (c.y - a.y) * sX) / denom;
+  const u = ((c.x - a.x) * rY - (c.y - a.y) * rX) / denom;
+  if (t < -1e-9 || t > 1 + 1e-9 || u < -1e-9 || u > 1 + 1e-9) return null;
+  return {
+    t,
+    p: vec2(a.x + t * rX, a.y + t * rY)
+  };
+}
+
+// src/hatch/index.ts
+function parallel(path3, options = {}) {
+  if (!path3.closed || !path3.rings[0]) {
+    throw new Error("hatch.parallel requires a closed path");
+  }
+  const bounds2 = pathBounds(path3);
+  const center = options.center ?? {
+    x: (bounds2.minX + bounds2.maxX) / 2,
+    y: (bounds2.minY + bounds2.maxY) / 2
+  };
+  const diag = Math.hypot(bounds2.maxX - bounds2.minX, bounds2.maxY - bounds2.minY);
+  const length = options.length ?? Math.max(diag, 1e-6);
+  const spacing = Math.max(options.spacing ?? 0.15, 1e-9);
+  const angle = options.angle ?? Math.PI / 4;
+  const count = options.count ?? hatchLineCount(bounds2, spacing, angle);
+  const raw = parallelSegments(
+    center.x,
+    center.y,
+    length,
+    spacing,
+    angle,
+    count
+  );
+  return clipSegmentsToPath(raw, path3);
+}
+function cross(path3, options = {}) {
+  const angle = options.angle ?? Math.PI / 4;
+  const a = parallel(path3, options);
+  const b = parallel(path3, { ...options, angle: angle + Math.PI / 2 });
+  return [...a, ...b];
+}
+function hatchLineCount(bounds2, spacing, angle) {
+  const nx = Math.cos(angle + Math.PI / 2);
+  const ny = Math.sin(angle + Math.PI / 2);
+  const corners = [
+    [bounds2.minX, bounds2.minY],
+    [bounds2.maxX, bounds2.minY],
+    [bounds2.maxX, bounds2.maxY],
+    [bounds2.minX, bounds2.maxY]
+  ];
+  let minP = Infinity;
+  let maxP = -Infinity;
+  for (const [x, y] of corners) {
+    const p = x * nx + y * ny;
+    minP = Math.min(minP, p);
+    maxP = Math.max(maxP, p);
+  }
+  const extent = maxP - minP;
+  return Math.max(1, Math.ceil(extent / spacing) + 1);
+}
+function pathBounds(path3) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const ring2 of path3.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 { minX, minY, maxX, maxY };
+}
+var hatch = {
+  parallel,
+  cross
+};
+
+// src/circlePacking/index.ts
+function squareLatticePack(path3, diameter, mode = "overlap") {
+  const d = Math.max(diameter, 0.1);
+  const r = d / 2;
+  const b = bounds(path3);
+  const out = [];
+  const accept = mode === "contained" ? circleContainedInPath : circleOverlapsPath;
+  const inset = mode === "contained" ? r : 0;
+  const { ox, oy, nX, nY } = centeredLatticeGrid(b, d, d, inset, d);
+  if (nX < 1 || nY < 1) return out;
+  for (let i = 0; i < nX; i++) {
+    for (let j = 0; j < nY; j++) {
+      const c = circle(ox + i * d, oy + j * d, r);
+      if (accept(c, path3)) out.push(c);
+    }
+  }
+  return out;
+}
+function hexLatticePack(path3, diameter, mode = "overlap") {
+  const d = Math.max(diameter, 0.1);
+  const r = d / 2;
+  const b = bounds(path3);
+  const z = r * Math.sqrt(3);
+  const out = [];
+  const accept = mode === "contained" ? circleContainedInPath : circleOverlapsPath;
+  const inset = mode === "contained" ? r : 0;
+  const { ox, nX, nY } = centeredLatticeGrid(b, z, d, inset, d);
+  if (nX < 1 || nY < 1) return out;
+  const innerH = b.maxY - b.minY - 2 * inset;
+  const extentY = (nY - 1) * d + r;
+  const oy = b.minY + inset + (innerH - extentY) / 2 + r;
+  let offset = 0;
+  for (let i = 0; i < nX; i++) {
+    offset = offset === r ? 0 : r;
+    for (let j = 0; j < nY; j++) {
+      const c = circle(ox + i * z, oy + j * d - offset, r);
+      if (accept(c, path3)) out.push(c);
+    }
+  }
+  return out;
+}
+function centeredLatticeGrid(b, stepX, stepY, inset, endPad) {
+  const innerW = b.maxX - b.minX - 2 * inset;
+  const innerH = b.maxY - b.minY - 2 * inset;
+  if (innerW < -1e-9 || innerH < -1e-9) {
+    return { ox: 0, oy: 0, nX: 0, nY: 0 };
+  }
+  let nX;
+  let nY;
+  if (inset > 0) {
+    nX = Math.floor(innerW / stepX + 1e-9) + 1;
+    nY = Math.floor(innerH / stepY + 1e-9) + 1;
+  } else {
+    nX = Math.floor((innerW + endPad) / stepX - 1e-12) + 1;
+    nY = Math.floor((innerH + endPad) / stepY - 1e-12) + 1;
+  }
+  const spanX = (nX - 1) * stepX;
+  const spanY = (nY - 1) * stepY;
+  const ox = b.minX + inset + (innerW - spanX) / 2;
+  const oy = b.minY + inset + (innerH - spanY) / 2;
+  return { ox, oy, nX, nY };
+}
+function stochasticPack(path3, points, minRadius, seed = 1) {
+  const rng = mulberry32(seed >>> 0);
+  const b = bounds(path3);
+  const packing = [];
+  for (let attempt = 0; attempt < points; attempt++) {
+    const p = vecInBounds(b, rng);
+    if (!containsPoint(path3, p)) continue;
+    const maxR = clearanceRadius(p, path3, packing);
+    if (maxR < minRadius) continue;
+    packing.push(circle(p.x, p.y, maxR));
+  }
+  return packing;
+}
+function maximumInscribedPack(path3, n, tolerance = 1) {
+  return obstaclePack(path3, [], n, tolerance);
+}
+function maximumInscribedPackUntil(path3, minRadius, tolerance = 1) {
+  const packing = [];
+  const tol = Math.max(0.01, tolerance);
+  const minR = Math.max(0.01, minRadius);
+  for (; ; ) {
+    const next = findLargestEmptyCircle(path3, packing, tol);
+    if (!next || next.r < minR) break;
+    packing.push(next);
+  }
+  return packing;
+}
+function obstaclePack(path3, 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(path3, packing, tol);
+    if (!next || next.r <= 1e-9) break;
+    packing.push(next);
+    placed.push(next);
+  }
+  return placed;
+}
+function frontChainPack(path3, radiusMin, radiusMax, seed = 1) {
+  let rMin = Math.max(1e-6, Math.min(radiusMin, radiusMax));
+  let rMax = Math.max(rMin, Math.max(radiusMin, radiusMax));
+  const rng = mulberry32(seed >>> 0);
+  const b = bounds(path3);
+  const packing = [];
+  const area2 = Math.max(1e-6, (b.maxX - b.minX) * (b.maxY - b.minY));
+  const capacity = Math.max(
+    4,
+    Math.ceil(area2 / (Math.PI * rMin * rMin) * 2)
+  );
+  const trySeed = () => {
+    const p = vecInBounds(b, rng);
+    const r = rMin + rng() * (rMax - rMin);
+    const c = circle(p.x, p.y, r);
+    if (!overlapsAny(c, packing) && circleOverlapsPath(c, path3)) {
+      packing.push(c);
+      return true;
+    }
+    return false;
+  };
+  for (let i = 0; i < 8; i++) trySeed();
+  let fails = 0;
+  while (packing.length < capacity) {
+    const stallLimit = Math.max(500, packing.length * 12);
+    if (fails >= stallLimit) break;
+    if (packing.length === 0) {
+      if (trySeed()) fails = 0;
+      else fails++;
+      continue;
+    }
+    if (fails > 0 && fails % 50 === 0) {
+      if (trySeed()) {
+        fails = 0;
+        continue;
+      }
+    }
+    const base = packing[Math.floor(rng() * packing.length)];
+    const ang = rng() * Math.PI * 2;
+    const r = rMin + rng() * (rMax - rMin);
+    const dist2 = base.r + r;
+    const c = circle(
+      base.x + Math.cos(ang) * dist2,
+      base.y + Math.sin(ang) * dist2,
+      r
+    );
+    if (c.x < b.minX - rMax || c.x > b.maxX + rMax || c.y < b.minY - rMax || c.y > b.maxY + rMax) {
+      fails++;
+      continue;
+    }
+    if (!overlapsAny(c, packing) && circleOverlapsPath(c, path3)) {
+      packing.push(c);
+      fails = 0;
+    } else {
+      fails++;
+    }
+  }
+  return packing.filter((c) => circleOverlapsPath(c, path3));
+}
+function repulsionPack(path3, radiusMin, radiusMax, seed = 1, iterations = 80) {
+  const rMin = Math.max(1e-6, Math.min(radiusMin, radiusMax));
+  const rMax = Math.max(rMin, Math.max(radiusMin, radiusMax));
+  const rng = mulberry32(seed >>> 0);
+  const b = bounds(path3);
+  const area2 = Math.max(1e-6, (b.maxX - b.minX) * (b.maxY - b.minY));
+  const avgR = (rMin + rMax) / 2;
+  const target = Math.max(
+    4,
+    Math.floor(area2 / (Math.PI * avgR * avgR) * 0.6)
+  );
+  const circles = [];
+  for (let i = 0; i < target; i++) {
+    const p = vecInBounds(b, rng);
+    circles.push(circle(p.x, p.y, rMin + rng() * (rMax - rMin)));
+  }
+  for (let iter = 0; iter < iterations; iter++) {
+    for (let i = 0; i < circles.length; i++) {
+      for (let j = i + 1; j < circles.length; j++) {
+        const a = circles[i];
+        const bC = circles[j];
+        const dx = bC.x - a.x;
+        const dy = bC.y - a.y;
+        const dist2 = Math.hypot(dx, dy) || 1e-9;
+        const minDist = a.r + bC.r;
+        if (dist2 >= minDist) continue;
+        const push = (minDist - dist2) / 2 * 0.5;
+        const ux = dx / dist2;
+        const uy = dy / dist2;
+        a.x -= ux * push;
+        a.y -= uy * push;
+        bC.x += ux * push;
+        bC.y += uy * push;
+      }
+    }
+    for (const c of circles) {
+      c.x = Math.min(b.maxX + c.r, Math.max(b.minX - c.r, c.x));
+      c.y = Math.min(b.maxY + c.r, Math.max(b.minY - c.r, c.y));
+    }
+  }
+  return circles.filter((c) => circleOverlapsPath(c, path3));
+}
+function circleOverlapsPath(c, path3) {
+  const center = { x: c.x, y: c.y };
+  const dist2 = distanceToPolygon(center, path3);
+  return dist2 <= c.r * 0.95;
+}
+function circleContainedInPath(c, path3) {
+  const center = { x: c.x, y: c.y };
+  if (!containsPoint(path3, center)) return false;
+  return distanceToBoundary(center, path3) + 1e-9 >= c.r;
+}
+function distanceToPolygon(p, path3) {
+  if (containsPoint(path3, p)) return 0;
+  return distanceToBoundary(p, path3);
+}
+function findLargestEmptyCircle(path3, obstacles, tolerance) {
+  const b = bounds(path3);
+  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(path3, p)) continue;
+      const r = clearanceRadius(p, path3, 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(path3, p)) continue;
+        const r = clearanceRadius(p, path3, obstacles);
+        if (r > improved.r) improved = circle(p.x, p.y, r);
+      }
+    }
+    cur = improved;
+    span *= 0.5;
+  }
+  return cur;
+}
+function clearanceRadius(p, path3, obstacles) {
+  let r = distanceToBoundary(p, path3);
+  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 overlapsAny(c, packing) {
+  for (const o of packing) {
+    if (Math.hypot(c.x - o.x, c.y - o.y) < c.r + o.r - 1e-9) return true;
+  }
+  return false;
+}
+function distanceToBoundary(p, path3) {
+  let min = Infinity;
+  for (const ring2 of path3.rings) {
+    for (let i = 0; i < ring2.length; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % ring2.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));
+}
+function vecInBounds(b, rng) {
+  return {
+    x: b.minX + rng() * (b.maxX - b.minX),
+    y: b.minY + rng() * (b.maxY - b.minY)
+  };
+}
+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;
+  };
+}
+var circlePacking = {
+  squareLatticePack,
+  hexLatticePack,
+  stochasticPack,
+  maximumInscribedPack,
+  maximumInscribedPackUntil,
+  obstaclePack,
+  frontChainPack,
+  repulsionPack,
+  circleOverlapsPath,
+  circleContainedInPath
+};
+function buffer(path3, delta, options = {}) {
+  const subject = pathToPathsD(path3);
+  const join = options.join === "miter" ? JoinType.Miter : options.join === "square" ? JoinType.Square : JoinType.Round;
+  const inflated = inflatePathsD(subject, delta, join, EndType.Polygon);
+  return pathsDToGroup(inflated);
+}
+function erosionDilation(p, amount) {
+  const a = Math.abs(amount);
+  if (a < 1e-12) return group([p]);
+  const eroded = buffer(p, -a);
+  if (eroded.paths.length === 0) return eroded;
+  const dilated = [];
+  for (const q of eroded.paths) {
+    dilated.push(...buffer(q, a).paths);
+  }
+  return group(dilated);
+}
+function dilationErosion(p, amount) {
+  const a = Math.abs(amount);
+  if (a < 1e-12) return group([p]);
+  const dilated = buffer(p, a);
+  if (dilated.paths.length === 0) return dilated;
+  const eroded = [];
+  for (const q of dilated.paths) {
+    eroded.push(...buffer(q, -a).paths);
+  }
+  return group(eroded);
+}
+
+// src/morphology/index.ts
+function simplify(p, epsilon) {
+  if (epsilon <= 0 || p.rings.length === 0) return p;
+  const rings = [];
+  for (const ring2 of p.rings) {
+    const simplified = simplifyPathD(ringToPathD(ring2), 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);
+}
+function reducePrecision(p, decimals) {
+  const f = 10 ** Math.max(0, Math.floor(decimals));
+  const round = (n) => Math.round(n * f) / f;
+  return path(
+    p.rings.map(
+      (ring2) => normalizeRing(ring2.map((v) => ({ x: round(v.x), y: round(v.y) })))
+    ),
+    p.closed
+  );
+}
+function chaikinCut(p, iterations = 1, ratio = 0.25) {
+  const r = Math.min(0.49, Math.max(0.01, ratio));
+  let rings = p.rings;
+  for (let i = 0; i < Math.max(1, Math.floor(iterations)); i++) {
+    rings = rings.map((ring2) => chaikinRing(ring2, r, p.closed));
+  }
+  return path(rings, p.closed);
+}
+function smooth(p, iterations = 2) {
+  return chaikinCut(p, iterations);
+}
+function radialWarp(p, amplitude, frequency = 3, phase = 0) {
+  const c = centroid(p);
+  return mapVerts(p, (v) => {
+    const dx = v.x - c.x;
+    const dy = v.y - c.y;
+    const dist2 = Math.hypot(dx, dy);
+    if (dist2 < 1e-12) return v;
+    const theta = Math.atan2(dy, dx);
+    const s = 1 + amplitude * Math.cos(frequency * theta + phase);
+    return { x: c.x + dx * s, y: c.y + dy * s };
+  });
+}
+function sineWarp(p, amplitude, frequency = 1, phase = 0) {
+  return mapVerts(p, (v) => ({
+    x: v.x,
+    y: v.y + amplitude * Math.sin(2 * Math.PI * frequency * v.x + phase)
+  }));
+}
+function minkSum(a, b) {
+  const pattern = ringToPathD(b.rings[0] ?? []);
+  const subject = ringToPathD(a.rings[0] ?? []);
+  return pathsDToGroup(minkowskiSumD(pattern, subject, true));
+}
+function minkDifference(a, b) {
+  const pattern = ringToPathD(b.rings[0] ?? []);
+  const subject = ringToPathD(a.rings[0] ?? []);
+  return pathsDToGroup(minkowskiDiffD(pattern, subject, true));
+}
+function chaikinRing(ring2, ratio, closed) {
+  if (ring2.length < 2) return ring2.map((v) => ({ ...v }));
+  const out = [];
+  const n = ring2.length;
+  const edges = closed ? n : n - 1;
+  for (let i = 0; i < edges; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % n];
+    out.push({
+      x: a.x * (1 - ratio) + b.x * ratio,
+      y: a.y * (1 - ratio) + b.y * ratio
+    });
+    out.push({
+      x: a.x * ratio + b.x * (1 - ratio),
+      y: a.y * ratio + b.y * (1 - ratio)
+    });
+  }
+  if (!closed) {
+    out.unshift({ ...ring2[0] });
+    out.push({ ...ring2[n - 1] });
+  }
+  return closed ? normalizeRing(out) : out;
+}
+function mapVerts(p, fn) {
+  return path(
+    p.rings.map((ring2) => normalizeRing(ring2.map(fn))),
+    p.closed
+  );
+}
+var morphology = {
+  buffer,
+  erosionDilation,
+  dilationErosion,
+  simplify,
+  reducePrecision,
+  chaikinCut,
+  smooth,
+  radialWarp,
+  sineWarp,
+  minkSum,
+  minkDifference
+};
+
+// src/transformation/index.ts
+function mapPath(p, fn) {
+  return path(
+    p.rings.map((ring2) => normalizeRing(ring2.map(fn))),
+    p.closed
+  );
+}
+function translate(p, dx, dy) {
+  return mapPath(p, (v) => ({ x: v.x + dx, y: v.y + dy }));
+}
+function translateToOrigin(p) {
+  const c = centroid(p);
+  return translate(p, -c.x, -c.y);
+}
+function translateCentroidTo(p, target) {
+  const c = centroid(p);
+  return translate(p, target.x - c.x, target.y - c.y);
+}
+function rotate(p, angleRad, pivot) {
+  const o = pivot ?? { x: 0, y: 0 };
+  const cos = Math.cos(angleRad);
+  const sin = Math.sin(angleRad);
+  return mapPath(p, (v) => {
+    const x = v.x - o.x;
+    const y = v.y - o.y;
+    return {
+      x: o.x + x * cos - y * sin,
+      y: o.y + x * sin + y * cos
+    };
+  });
+}
+function rotateAroundCenter(p, angleRad) {
+  return rotate(p, angleRad, centroid(p));
+}
+function scale(p, sx, sy = sx, pivot) {
+  const o = pivot ?? { x: 0, y: 0 };
+  return mapPath(p, (v) => ({
+    x: o.x + (v.x - o.x) * sx,
+    y: o.y + (v.y - o.y) * sy
+  }));
+}
+function originScale(p, s) {
+  return scale(p, s, s, { x: 0, y: 0 });
+}
+function flipHorizontal(p, x = 0) {
+  return mapPath(p, (v) => ({ x: 2 * x - v.x, y: v.y }));
+}
+function flipVertical(p, y = 0) {
+  return mapPath(p, (v) => ({ x: v.x, y: 2 * y - v.y }));
+}
+function resizeByWidth(p, width2) {
+  const b = bounds(p);
+  const w = b.maxX - b.minX;
+  if (w < 1e-12) return clonePath(p);
+  return scale(p, width2 / w, width2 / w, { x: b.minX, y: b.minY });
+}
+function resizeByHeight(p, height2) {
+  const b = bounds(p);
+  const h = b.maxY - b.minY;
+  if (h < 1e-12) return clonePath(p);
+  return scale(p, height2 / h, height2 / h, { x: b.minX, y: b.minY });
+}
+function translateCornerTo(p, target) {
+  const b = bounds(p);
+  return translate(p, target.x - b.minX, target.y - b.minY);
+}
+function shear(p, shx, shy = 0, pivot) {
+  const o = pivot ?? { x: 0, y: 0 };
+  return mapPath(p, (v) => {
+    const x = v.x - o.x;
+    const y = v.y - o.y;
+    return {
+      x: o.x + x + shx * y,
+      y: o.y + y + shy * x
+    };
+  });
+}
+var transformation = {
+  translate,
+  translateToOrigin,
+  translateCentroidTo,
+  translateCornerTo,
+  rotate,
+  rotateAroundCenter,
+  scale,
+  originScale,
+  flipHorizontal,
+  flipVertical,
+  resizeByWidth,
+  resizeByHeight,
+  shear
+};
+
+// src/processing/index.ts
+function extractPerimeter(p) {
+  const exterior = p.rings[0];
+  if (!exterior) return path([], true);
+  return polygon(exterior);
+}
+function extractBoundary(p) {
+  return extractPerimeter(p);
+}
+function extractHoles(p) {
+  const holes = [];
+  for (let i = 1; i < p.rings.length; i++) {
+    const hole = p.rings[i];
+    if (hole && hole.length >= 3) holes.push(polygon(hole));
+  }
+  return holes;
+}
+function densify(p, maxSegLen) {
+  if (maxSegLen <= 0) return p;
+  return path(
+    p.rings.map((ring2) => densifyRing(ring2, maxSegLen, p.closed)),
+    p.closed
+  );
+}
+function densifyRing(ring2, maxSegLen, closed) {
+  if (ring2.length < 2) return [...ring2];
+  const out = [];
+  const n = ring2.length;
+  const edges = closed ? n : n - 1;
+  for (let i = 0; i < edges; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % n];
+    out.push(a);
+    const dist2 = Math.hypot(b.x - a.x, b.y - a.y);
+    const steps = Math.floor(dist2 / 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(ring2[n - 1]);
+  return closed ? normalizeRing(out) : out;
+}
+function removeSmallHoles(p, minArea2) {
+  if (p.rings.length <= 1) return p;
+  const exterior = p.rings[0];
+  const kept = p.rings.slice(1).filter((hole) => {
+    const a = Math.abs(shoelace(hole));
+    return a >= minArea2;
+  });
+  return path([exterior, ...kept], p.closed);
+}
+function generateRandomPoints(p, count, seed = 1) {
+  const rng = mulberry322(seed >>> 0);
+  const b = bounds(p);
+  const out = [];
+  let attempts = 0;
+  const maxAttempts = Math.max(count * 50, 100);
+  while (out.length < count && attempts < maxAttempts) {
+    attempts++;
+    const pt = {
+      x: b.minX + rng() * (b.maxX - b.minX),
+      y: b.minY + rng() * (b.maxY - b.minY)
+    };
+    if (containsPoint(p, pt)) out.push(pt);
+  }
+  return out;
+}
+function generateRandomGridPoints(p, spacing) {
+  const step = Math.max(spacing, 1e-9);
+  const b = bounds(p);
+  const out = [];
+  for (let x = b.minX; x <= b.maxX + 1e-12; x += step) {
+    for (let y = b.minY; y <= b.maxY + 1e-12; y += step) {
+      const pt = { x, y };
+      if (containsPoint(p, pt)) out.push(pt);
+    }
+  }
+  return out;
+}
+function pointsOnExterior(p, count) {
+  const ring2 = p.rings[0];
+  if (!ring2 || ring2.length < 2 || count <= 0) return [];
+  const lengths = edgeLengths(ring2);
+  const total = lengths.reduce((s, L) => s + L, 0);
+  if (total < 1e-12) return [];
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const target = i / count * total;
+    out.push(pointAtArcLength(ring2, lengths, target));
+  }
+  return out;
+}
+function segmentsOnExterior(p) {
+  const ring2 = p.rings[0];
+  if (!ring2 || ring2.length < 2) return [];
+  const n = ring2.length;
+  const closed = p.closed;
+  const edges = closed ? n : n - 1;
+  const out = [];
+  for (let i = 0; i < edges; i++) {
+    out.push(segment(ring2[i], ring2[(i + 1) % n]));
+  }
+  return out;
+}
+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 bb = bounds(p);
+  const span = Math.hypot(bb.maxX - bb.minX, bb.maxY - bb.minY) * 4 + 10;
+  const left = halfPlanePoly(a, nx, ny, span);
+  const right = halfPlanePoly(a, -nx, -ny, span);
+  const parts = [];
+  for (const half of [left, right]) {
+    parts.push(...intersect(p, half).paths);
+  }
+  return group(parts);
+}
+function centroidSplit(p) {
+  const c = centroid(p);
+  const bb = bounds(p);
+  const pad = Math.max(bb.maxY - bb.minY, 1) + 1;
+  return slice(p, { x: c.x, y: c.y - pad }, { x: c.x, y: c.y + pad });
+}
+function dissolve(paths) {
+  return unionAll(paths);
+}
+function intersectionPoints(a, b) {
+  const segsA = allSegments(a);
+  const segsB = allSegments(b);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const sa of segsA) {
+    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);
+      out.push(hit);
+    }
+  }
+  return out;
+}
+function halfPlanePoly(origin, nx, ny, span) {
+  const tx = -ny;
+  const ty = nx;
+  const o = origin;
+  return polygon([
+    {
+      x: o.x - tx * span + nx * 1e-9,
+      y: o.y - ty * span + ny * 1e-9
+    },
+    {
+      x: o.x + tx * span + nx * 1e-9,
+      y: o.y + ty * span + ny * 1e-9
+    },
+    {
+      x: o.x + tx * span + nx * span,
+      y: o.y + ty * span + ny * span
+    },
+    {
+      x: o.x - tx * span + nx * span,
+      y: o.y - ty * span + ny * span
+    }
+  ]);
+}
+function allSegments(p) {
+  const out = [];
+  for (const ring2 of p.rings) {
+    const n = ring2.length;
+    const edges = p.closed ? n : Math.max(0, n - 1);
+    for (let i = 0; i < edges; i++) {
+      out.push(segment(ring2[i], ring2[(i + 1) % n]));
+    }
+  }
+  return out;
+}
+function segmentIntersection2(a, b, c, d) {
+  const rX = b.x - a.x;
+  const rY = b.y - a.y;
+  const sX = d.x - c.x;
+  const sY = d.y - c.y;
+  const den = rX * sY - rY * sX;
+  if (Math.abs(den) < 1e-14) return null;
+  const t = ((c.x - a.x) * sY - (c.y - a.y) * sX) / den;
+  const u = ((c.x - a.x) * rY - (c.y - a.y) * rX) / den;
+  if (t < -1e-9 || t > 1 + 1e-9 || u < -1e-9 || u > 1 + 1e-9) return null;
+  return { x: a.x + t * rX, y: a.y + t * rY };
+}
+function edgeLengths(ring2, closed) {
+  const n = ring2.length;
+  const edges = n ;
+  const lengths = [];
+  for (let i = 0; i < edges; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % n];
+    lengths.push(Math.hypot(b.x - a.x, b.y - a.y));
+  }
+  return lengths;
+}
+function pointAtArcLength(ring2, lengths, target) {
+  let remain = target;
+  const n = ring2.length;
+  for (let i = 0; i < lengths.length; i++) {
+    const L = lengths[i];
+    if (remain <= L || i === lengths.length - 1) {
+      const t = L < 1e-12 ? 0 : remain / L;
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      return {
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t
+      };
+    }
+    remain -= L;
+  }
+  return { ...ring2[0] };
+}
+function shoelace(ring2) {
+  let sum = 0;
+  for (let i = 0; i < ring2.length; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % ring2.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function mulberry322(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;
+  };
+}
+var processing = {
+  extractPerimeter,
+  extractBoundary,
+  extractHoles,
+  densify,
+  removeSmallHoles,
+  generateRandomPoints,
+  generateRandomGridPoints,
+  pointsOnExterior,
+  segmentsOnExterior,
+  slice,
+  centroidSplit,
+  dissolve,
+  intersectionPoints
+};
+
+// src/conversion/index.ts
+function copy(p) {
+  return clonePath(p);
+}
+function flatten(g) {
+  return g.paths.map(clonePath);
+}
+function roundVertexCoords(p, decimals) {
+  return reducePrecision(p, decimals);
+}
+function toArray(p) {
+  const ring2 = p.rings[0] ?? [];
+  const out = [];
+  for (const v of ring2) {
+    out.push(v.x, v.y);
+  }
+  return out;
+}
+function fromArray(coords, closed = true) {
+  const ring2 = [];
+  for (let i = 0; i + 1 < coords.length; i += 2) {
+    ring2.push({ x: coords[i], y: coords[i + 1] });
+  }
+  return path([normalizeRing(ring2)], closed);
+}
+function toContours(p) {
+  return p.rings.filter((r) => r.length >= 3).map((r) => path([normalizeRing(r)], true));
+}
+function fromContours(contours) {
+  if (contours.length === 0) return path([], true);
+  const rings = contours.map((c) => normalizeRing(c.rings[0] ?? []));
+  return path(rings, true);
+}
+var conversion = {
+  copy,
+  flatten,
+  roundVertexCoords,
+  toArray,
+  fromArray,
+  toContours,
+  fromContours,
+  cloneGroup,
+  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);
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    out.push({
+      x: minX + rng() * (maxX - minX),
+      y: minY + rng() * (maxY - minY)
+    });
+  }
+  return out;
+}
+function squareGrid(spacing, minX, minY, maxX, maxY) {
+  const s = Math.max(spacing, 1e-9);
+  const out = [];
+  for (let x = minX; x <= maxX + 1e-12; x += s) {
+    for (let y = minY; y <= maxY + 1e-12; y += s) {
+      out.push({ x, y });
+    }
+  }
+  return out;
+}
+function hexGrid(spacing, minX, minY, maxX, maxY) {
+  const s = Math.max(spacing, 1e-9);
+  const dx = s;
+  const dy = s * Math.sqrt(3) * 0.5;
+  const out = [];
+  let row = 0;
+  for (let y = minY; y <= maxY + 1e-12; y += dy, row++) {
+    const x0 = minX + (row % 2 === 0 ? 0 : s * 0.5);
+    for (let x = x0; x <= maxX + 1e-12; x += dx) {
+      out.push({ x, y });
+    }
+  }
+  return out;
+}
+function ring(count, center, radius) {
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const t = i / count * Math.PI * 2;
+    out.push({
+      x: center.x + Math.cos(t) * radius,
+      y: center.y + Math.sin(t) * radius
+    });
+  }
+  return out;
+}
+function mulberry323(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 = mulberry323(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;
+}
+function prunePointsWithinDistance(points, minDistance) {
+  const r = Math.max(minDistance, 0);
+  const out = [];
+  for (const p of points) {
+    if (out.every((q) => Math.hypot(p.x - q.x, p.y - q.y) >= r)) {
+      out.push(p);
+    }
+  }
+  return out;
+}
+var pointSet = {
+  random,
+  squareGrid,
+  hexGrid,
+  ring,
+  poisson,
+  prunePointsWithinDistance
+};
+
+// 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 ring2 = pathDToRing(pd);
+    if (ring2.length >= 3) tris.push(polygon(ring2.slice(0, 3)));
+  }
+  return tris;
+}
+function delaunayTriangulation(p) {
+  return earCutTriangulation(p, { useDelaunay: 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;
+}
+function poissonTriangulationPoints(path3, minDistance, seed = 1) {
+  if (!path3.closed || path3.rings.length === 0) return [];
+  const b = bounds(path3);
+  const samples = poisson(
+    minDistance,
+    b.minX,
+    b.minY,
+    b.maxX,
+    b.maxY,
+    seed
+  ).filter((pt) => containsPoint(path3, pt));
+  return dedupePoints([...pathVertices(path3), ...samples]);
+}
+function poissonTriangulation(path3, minDistance, seed = 1) {
+  const pts = poissonTriangulationPoints(path3, minDistance, seed);
+  return trianglesInsidePath(delaunayTriangulationPoints(pts), path3);
+}
+function refine(path3, options = {}) {
+  if (!path3.closed || path3.rings.length === 0) return [];
+  const minAngle = options.minAngle ?? 20 * Math.PI / 180;
+  const maxIterations = Math.max(1, options.maxIterations ?? 200);
+  const points = dedupePoints(pathVertices(path3));
+  if (points.length < 3) return [];
+  for (let iter = 0; iter < maxIterations; iter++) {
+    const tris = trianglesInsidePath(
+      delaunayTriangulationPoints(points),
+      path3
+    );
+    if (tris.length === 0) break;
+    let skinny = null;
+    let worst = minAngle;
+    for (const t of tris) {
+      const a = minTriangleAngle(t);
+      if (a < worst) {
+        worst = a;
+        skinny = t;
+      }
+    }
+    if (!skinny) break;
+    const ring2 = skinny.rings[0];
+    const cc = circumcenter(ring2[0], ring2[1], ring2[2]);
+    if (!cc) break;
+    const insert = containsPoint(path3, cc) ? cc : longestEdgeMidpoint(ring2[0], ring2[1], ring2[2]);
+    if (points.some((p) => Math.hypot(p.x - insert.x, p.y - insert.y) < 1e-9)) {
+      break;
+    }
+    points.push(insert);
+  }
+  return trianglesInsidePath(delaunayTriangulationPoints(points), path3);
+}
+function pathVertices(path3) {
+  const out = [];
+  for (const ring2 of path3.rings) {
+    for (const v of ring2) out.push({ x: v.x, y: v.y });
+  }
+  return out;
+}
+function dedupePoints(points, eps = 1e-9) {
+  const out = [];
+  for (const p of points) {
+    if (out.some((q) => Math.hypot(q.x - p.x, q.y - p.y) < eps)) continue;
+    out.push(p);
+  }
+  return out;
+}
+function triangleCentroid(t) {
+  const r = t.rings[0];
+  if (!r || r.length < 3) return null;
+  return {
+    x: (r[0].x + r[1].x + r[2].x) / 3,
+    y: (r[0].y + r[1].y + r[2].y) / 3
+  };
+}
+function trianglesInsidePath(tris, path3) {
+  return tris.filter((t) => {
+    const c = triangleCentroid(t);
+    return c != null && containsPoint(path3, c);
+  });
+}
+function minTriangleAngle(t) {
+  const r = t.rings[0];
+  if (!r || r.length < 3) return 0;
+  const a = r[0];
+  const b = r[1];
+  const c = r[2];
+  return Math.min(angleAt(a, b, c), angleAt(b, c, a), angleAt(c, a, b));
+}
+function angleAt(vertex, p, q) {
+  const ux = p.x - vertex.x;
+  const uy = p.y - vertex.y;
+  const vx = q.x - vertex.x;
+  const vy = q.y - vertex.y;
+  const lu = Math.hypot(ux, uy);
+  const lv = Math.hypot(vx, vy);
+  if (lu < 1e-18 || lv < 1e-18) return 0;
+  const cos = Math.max(-1, Math.min(1, (ux * vx + uy * vy) / (lu * lv)));
+  return Math.acos(cos);
+}
+function circumcenter(a, b, c) {
+  const d = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
+  if (Math.abs(d) < 1e-18) return null;
+  const a2 = a.x * a.x + a.y * a.y;
+  const b2 = b.x * b.x + b.y * b.y;
+  const c2 = c.x * c.x + c.y * c.y;
+  return {
+    x: (a2 * (b.y - c.y) + b2 * (c.y - a.y) + c2 * (a.y - b.y)) / d,
+    y: (a2 * (c.x - b.x) + b2 * (a.x - c.x) + c2 * (b.x - a.x)) / d
+  };
+}
+function longestEdgeMidpoint(a, b, c) {
+  const edges = [
+    [a, b],
+    [b, c],
+    [c, a]
+  ];
+  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;
+      best = e;
+    }
+  }
+  return { x: (best[0].x + best[1].x) / 2, y: (best[0].y + best[1].y) / 2 };
+}
+var triangulation = {
+  earCutTriangulation,
+  delaunayTriangulation,
+  delaunayTriangulationPoints,
+  poissonTriangulation,
+  poissonTriangulationPoints,
+  refine
+};
+
+// src/optimisation/index.ts
+function envelope(p) {
+  return boundingBox(p);
+}
+function maximumInscribedCircle(p, tolerance = 1) {
+  return maximumInscribedPack(p, 1, tolerance)[0] ?? null;
+}
+function largestEmptyCircles(p, minRadius, tolerance = 1) {
+  return maximumInscribedPackUntil(p, minRadius, tolerance);
+}
+function largestEmptyCircle(p, tolerance = 1) {
+  return maximumInscribedCircle(p, tolerance);
+}
+function maximumInscribedAARectangle(p) {
+  const b = bounds(p);
+  const w = b.maxX - b.minX;
+  const h = b.maxY - b.minY;
+  if (w < 1e-12 || h < 1e-12) return envelope(p);
+  const fits = (m2) => {
+    const rect = [
+      { x: b.minX + m2, y: b.minY + m2 },
+      { x: b.maxX - m2, y: b.minY + m2 },
+      { x: b.maxX - m2, y: b.maxY - m2 },
+      { x: b.minX + m2, y: b.maxY - m2 }
+    ];
+    return rect.every((pt) => containsPoint(p, pt));
+  };
+  if (fits(0)) return envelope(p);
+  let lo = 0;
+  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;
+    } else {
+      lo = mid3;
+    }
+  }
+  const m = best;
+  return polygon([
+    { x: b.minX + m, y: b.minY + m },
+    { x: b.maxX - m, y: b.minY + m },
+    { x: b.maxX - m, y: b.maxY - m },
+    { x: b.minX + m, y: b.maxY - m }
+  ]);
+}
+function closestPoint(p, point) {
+  let best = point;
+  let bestD = Infinity;
+  for (const ring2 of p.rings) {
+    const n = ring2.length;
+    const edges = p.closed ? n : Math.max(0, n - 1);
+    for (let i = 0; i < edges; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      const q = projectPointToSegment(point, a, b);
+      const d = Math.hypot(q.x - point.x, q.y - point.y);
+      if (d < bestD) {
+        bestD = d;
+        best = q;
+      }
+    }
+  }
+  return best;
+}
+function closestVertex(p, point) {
+  let best = p.rings[0]?.[0] ?? point;
+  let bestD = Infinity;
+  for (const ring2 of p.rings) {
+    for (const v of ring2) {
+      const d = Math.hypot(v.x - point.x, v.y - point.y);
+      if (d < bestD) {
+        bestD = d;
+        best = v;
+      }
+    }
+  }
+  return { ...best };
+}
+function closestPointPair(points) {
+  if (points.length < 2) return null;
+  let best = [points[0], points[1]];
+  let bestD = Infinity;
+  for (let i = 0; i < points.length; i++) {
+    for (let j = i + 1; j < points.length; j++) {
+      const d = Math.hypot(
+        points[i].x - points[j].x,
+        points[i].y - points[j].y
+      );
+      if (d < bestD) {
+        bestD = d;
+        best = [points[i], points[j]];
+      }
+    }
+  }
+  return best;
+}
+function farthestPointPair(points) {
+  if (points.length < 2) return null;
+  let best = [points[0], points[1]];
+  let bestD = -1;
+  for (let i = 0; i < points.length; i++) {
+    for (let j = i + 1; j < points.length; j++) {
+      const d = Math.hypot(
+        points[i].x - points[j].x,
+        points[i].y - points[j].y
+      );
+      if (d > bestD) {
+        bestD = d;
+        best = [points[i], points[j]];
+      }
+    }
+  }
+  return best;
+}
+function minimumBoundingCircle(p) {
+  const pts = [];
+  for (const ring2 of p.rings) pts.push(...ring2);
+  const hull2 = convexHull(pts).rings[0] ?? pts;
+  return minDisk(hull2);
+}
+function minDisk(points) {
+  return welzl(points.map((p) => ({ ...p })), [], 0);
+}
+function welzl(P, R, i) {
+  if (i === P.length || R.length === 3) return diskFromBoundary(R);
+  const d = welzl(P, R, i + 1);
+  const p = P[i];
+  if (Math.hypot(p.x - d.x, p.y - d.y) <= d.r + 1e-9) return d;
+  return welzl(P, [...R, p], i + 1);
+}
+function diskFromBoundary(R) {
+  if (R.length === 0) return circle(0, 0, 0);
+  if (R.length === 1) return circle(R[0].x, R[0].y, 0);
+  if (R.length === 2) {
+    const a = R[0];
+    const b = R[1];
+    return circle(
+      (a.x + b.x) / 2,
+      (a.y + b.y) / 2,
+      Math.hypot(a.x - b.x, a.y - b.y) / 2
+    );
+  }
+  return circumcircle(R[0], R[1], R[2]);
+}
+function circumcircle(a, b, c) {
+  const d = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));
+  if (Math.abs(d) < 1e-14) {
+    const pair = farthestPointPair([a, b, c]);
+    return circle(
+      (pair[0].x + pair[1].x) / 2,
+      (pair[0].y + pair[1].y) / 2,
+      Math.hypot(pair[0].x - pair[1].x, pair[0].y - pair[1].y) / 2
+    );
+  }
+  const ux = ((a.x * a.x + a.y * a.y) * (b.y - c.y) + (b.x * b.x + b.y * b.y) * (c.y - a.y) + (c.x * c.x + c.y * c.y) * (a.y - b.y)) / d;
+  const uy = ((a.x * a.x + a.y * a.y) * (c.x - b.x) + (b.x * b.x + b.y * b.y) * (a.x - c.x) + (c.x * c.x + c.y * c.y) * (b.x - a.x)) / d;
+  return circle(ux, uy, Math.hypot(ux - a.x, uy - a.y));
+}
+function projectPointToSegment(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 { ...a };
+  let t = ((p.x - a.x) * abx + (p.y - a.y) * aby) / len2;
+  t = Math.max(0, Math.min(1, t));
+  return { x: a.x + t * abx, y: a.y + t * aby };
+}
+var optimisation = {
+  envelope,
+  maximumInscribedCircle,
+  largestEmptyCircle,
+  largestEmptyCircles,
+  maximumInscribedAARectangle,
+  closestPoint,
+  closestVertex,
+  closestPointPair,
+  farthestPointPair,
+  minimumBoundingCircle
+};
+function compoundVoronoi(sites, options = {}) {
+  if (sites.length === 0) return group([]);
+  if (sites.length === 1) {
+    const b2 = options.bounds ?? padBounds(sites, 1);
+    return group([
+      polygon([
+        { x: b2.minX, y: b2.minY },
+        { x: b2.maxX, y: b2.minY },
+        { x: b2.maxX, y: b2.maxY },
+        { x: b2.minX, y: b2.maxY }
+      ])
+    ]);
+  }
+  const b = options.bounds ?? padBounds(sites, 0.1);
+  const delaunay = Delaunay.from(
+    sites,
+    (d) => d.x,
+    (d) => d.y
+  );
+  const voronoi2 = delaunay.voronoi([b.minX, b.minY, b.maxX, b.maxY]);
+  const paths = [];
+  for (let i = 0; i < sites.length; i++) {
+    const poly = voronoi2.cellPolygon(i);
+    if (!poly || poly.length < 3) continue;
+    const ring2 = poly.slice(0, -1).map(([x, y]) => ({ x, y }));
+    if (ring2.length >= 3) paths.push(polygon(ring2));
+  }
+  return group(paths);
+}
+function innerVoronoi(sites, container, options = {}) {
+  const b = options.bounds ?? {
+    ...bounds(container)
+  };
+  const cells = compoundVoronoi(sites, { bounds: b });
+  const clipped = [];
+  for (const cell of cells.paths) {
+    clipped.push(...intersect(cell, container).paths);
+  }
+  return group(clipped);
+}
+function innerVoronoiRaw(sites, options = {}) {
+  return compoundVoronoi(sites, options);
+}
+function padBounds(sites, padRatio) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const s of sites) {
+    minX = Math.min(minX, s.x);
+    minY = Math.min(minY, s.y);
+    maxX = Math.max(maxX, s.x);
+    maxY = Math.max(maxY, s.y);
+  }
+  const pad = Math.max(maxX - minX, maxY - minY, 1) * padRatio + 1e-6;
+  return {
+    minX: minX - pad,
+    minY: minY - pad,
+    maxX: maxX + pad,
+    maxY: maxY + pad
+  };
+}
+var voronoi = {
+  compoundVoronoi,
+  innerVoronoi,
+  innerVoronoiRaw
+};
+
+// src/construction/index.ts
+function createCircle(cx, cy, radius, segments = 64) {
+  return createRegularPolygon(cx, cy, radius, Math.max(3, Math.floor(segments)));
+}
+function createRect(x, y, width2, height2) {
+  return polygon([
+    { x, y },
+    { x: x + width2, y },
+    { x: x + width2, y: y + height2 },
+    { x, y: y + height2 }
+  ]);
+}
+function createRegularPolygon(cx, cy, radius, sides, rotation = -Math.PI / 2) {
+  const n = Math.max(3, Math.floor(sides));
+  const ring2 = [];
+  for (let i = 0; i < n; i++) {
+    const t = rotation + i / n * Math.PI * 2;
+    ring2.push({ x: cx + Math.cos(t) * radius, y: cy + Math.sin(t) * radius });
+  }
+  return polygon(ring2);
+}
+function createRing(cx, cy, outerRadius, innerRadius, segments = 64) {
+  const outer = createCircle(cx, cy, outerRadius, segments).rings[0];
+  const inner = createCircle(cx, cy, Math.min(innerRadius, outerRadius), segments).rings[0];
+  return path([outer, [...inner].reverse()], true);
+}
+function createArc(cx, cy, radius, startAngle, endAngle, segments = 32) {
+  const n = Math.max(2, Math.floor(segments));
+  const pts = [];
+  for (let i = 0; i <= n; i++) {
+    const t = startAngle + (endAngle - startAngle) * i / n;
+    pts.push({ x: cx + Math.cos(t) * radius, y: cy + Math.sin(t) * radius });
+  }
+  return polyline(pts);
+}
+function createStar(cx, cy, outerRadius, innerRadius, points = 5, rotation = -Math.PI / 2) {
+  const n = Math.max(3, Math.floor(points));
+  const ring2 = [];
+  for (let i = 0; i < n * 2; i++) {
+    const r = i % 2 === 0 ? outerRadius : innerRadius;
+    const t = rotation + i / (n * 2) * Math.PI * 2;
+    ring2.push({ x: cx + Math.cos(t) * r, y: cy + Math.sin(t) * r });
+  }
+  return polygon(ring2);
+}
+function createKochSnowflake(cx, cy, radius, iterations = 3) {
+  const tri = createRegularPolygon(cx, cy, radius, 3);
+  let ring2 = tri.rings[0];
+  const iters = Math.max(0, Math.min(6, Math.floor(iterations)));
+  for (let i = 0; i < iters; i++) {
+    ring2 = kochRefine(ring2);
+  }
+  return polygon(ring2);
+}
+function kochRefine(ring2) {
+  const out = [];
+  const n = ring2.length;
+  for (let i = 0; i < n; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % n];
+    const dx = b.x - a.x;
+    const dy = b.y - a.y;
+    const p1 = { x: a.x + dx / 3, y: a.y + dy / 3 };
+    const p2 = { x: a.x + 2 * dx / 3, y: a.y + 2 * dy / 3 };
+    const px = a.x + dx / 2 - dy * (Math.sqrt(3) / 6);
+    const py = a.y + dy / 2 + dx * (Math.sqrt(3) / 6);
+    out.push(a, p1, { x: px, y: py }, p2);
+  }
+  return out;
+}
+var construction = {
+  createCircle,
+  createRect,
+  createRegularPolygon,
+  createRing,
+  createArc,
+  createStar,
+  createKochSnowflake
+};
+
+// src/tiling/index.ts
+function squareGrid2(spacing, minX, minY, maxX, maxY) {
+  const s = Math.max(spacing, 1e-9);
+  const paths = [];
+  for (let x = minX; x < maxX - 1e-12; x += s) {
+    for (let y = minY; y < maxY - 1e-12; y += s) {
+      const w = Math.min(s, maxX - x);
+      const h = Math.min(s, maxY - y);
+      if (w > 1e-12 && h > 1e-12) paths.push(createRect(x, y, w, h));
+    }
+  }
+  return group(paths);
+}
+function hexTiling(spacing, minX, minY, maxX, maxY) {
+  const s = Math.max(spacing, 1e-9);
+  const r = s / 2;
+  const dx = s * 0.75;
+  const dy = s * Math.sqrt(3) * 0.5;
+  const paths = [];
+  let row = 0;
+  for (let y = minY + r; y <= maxY + r; y += dy, row++) {
+    const x0 = minX + r + (row % 2 === 0 ? 0 : dx * 0.5);
+    for (let x = x0; x <= maxX + r; x += dx) {
+      paths.push(hexagon(x, y, r));
+    }
+  }
+  return group(paths);
+}
+function hexagon(cx, cy, r) {
+  const ring2 = [];
+  for (let i = 0; i < 6; i++) {
+    const t = Math.PI / 180 * (60 * i - 30);
+    ring2.push({ x: cx + Math.cos(t) * r, y: cy + Math.sin(t) * r });
+  }
+  return polygon(ring2);
+}
+function rectSubdivision(p, nx, ny) {
+  const b = bounds(p);
+  const cols = Math.max(1, Math.floor(nx));
+  const rows = Math.max(1, Math.floor(ny));
+  const dw = (b.maxX - b.minX) / cols;
+  const dh = (b.maxY - b.minY) / rows;
+  const paths = [];
+  for (let i = 0; i < cols; i++) {
+    for (let j = 0; j < rows; j++) {
+      const cell = createRect(
+        b.minX + i * dw,
+        b.minY + j * dh,
+        dw,
+        dh
+      );
+      paths.push(...intersect(p, cell).paths);
+    }
+  }
+  return group(paths);
+}
+function quadSubdivision(faces, depth = 1) {
+  let cur = faces;
+  const d = Math.max(0, Math.floor(depth));
+  for (let i = 0; i < d; i++) {
+    const next = [];
+    for (const f of cur) {
+      next.push(...subdivideQuad(f));
+    }
+    cur = next;
+  }
+  return group(cur);
+}
+function subdivideQuad(p) {
+  const ring2 = p.rings[0];
+  if (!ring2 || ring2.length < 4) return [p];
+  const [a, b, c, d] = ring2;
+  if (!a || !b || !c || !d) return [p];
+  const mab = mid(a, b);
+  const mbc = mid(b, c);
+  const mcd = mid(c, d);
+  const mda = mid(d, a);
+  const cen = mid(mid(a, c), mid(b, d));
+  return [
+    polygon([a, mab, cen, mda]),
+    polygon([mab, b, mbc, cen]),
+    polygon([cen, mbc, c, mcd]),
+    polygon([mda, cen, mcd, d])
+  ];
+}
+function triangleSubdivision(faces, depth = 1) {
+  let cur = faces;
+  const d = Math.max(0, Math.floor(depth));
+  for (let i = 0; i < d; i++) {
+    const next = [];
+    for (const f of cur) {
+      next.push(...subdivideTriangle(f));
+    }
+    cur = next;
+  }
+  return group(cur);
+}
+function subdivideTriangle(p) {
+  const ring2 = p.rings[0];
+  if (!ring2 || ring2.length < 3) return [p];
+  const a = ring2[0];
+  const b = ring2[1];
+  const c = ring2[2];
+  const mab = mid(a, b);
+  const mbc = mid(b, c);
+  const mca = mid(c, a);
+  return [
+    polygon([a, mab, mca]),
+    polygon([mab, b, mbc]),
+    polygon([mca, mbc, c]),
+    polygon([mab, mbc, mca])
+  ];
+}
+function sliceDivision(p, spacing, angle = 0) {
+  const s = Math.max(spacing, 1e-9);
+  const b = bounds(p);
+  const cx = (b.minX + b.maxX) / 2;
+  const cy = (b.minY + b.maxY) / 2;
+  const diag = Math.hypot(b.maxX - b.minX, b.maxY - b.minY) + s;
+  const ux = Math.cos(angle);
+  const uy = Math.sin(angle);
+  const nx = -uy;
+  const ny = ux;
+  const parts = [p];
+  for (let t = -diag; t <= diag; t += s) {
+    const a = { x: cx + nx * t - ux * diag, y: cy + ny * t - uy * diag };
+    const bb = { x: cx + nx * t + ux * diag, y: cy + ny * t + uy * diag };
+    const next = [];
+    for (const piece of parts) {
+      const g = slice(piece, a, bb);
+      next.push(...g.paths.length ? g.paths : [piece]);
+    }
+    parts.length = 0;
+    parts.push(...next);
+  }
+  return group(parts);
+}
+function hatchSubdivision(p, spacing, angle = 0) {
+  return sliceDivision(p, spacing, angle);
+}
+function mid(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+var tiling = {
+  squareGrid: squareGrid2,
+  hexTiling,
+  rectSubdivision,
+  quadSubdivision,
+  triangleSubdivision,
+  sliceDivision,
+  hatchSubdivision
+};
+
+// src/polygonisation/index.ts
+function maxArea(points) {
+  return convexHull(points);
+}
+function minArea(points) {
+  const hull2 = convexHull(points).rings[0] ?? [];
+  if (hull2.length < 3) return convexHull(points);
+  if (hull2.length === 3) return polygon(hull2);
+  let best = null;
+  let bestA = Infinity;
+  const h = hull2;
+  const n = h.length;
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      for (let k = j + 1; k < n; k++) {
+        const tri = polygon([h[i], h[j], h[k]]);
+        if (!coversPoints(tri, points)) continue;
+        const a = area(tri);
+        if (a < bestA) {
+          bestA = a;
+          best = tri;
+        }
+      }
+    }
+  }
+  return best ?? convexHull(points);
+}
+function minPerimeter(points) {
+  if (points.length === 0) return polygon([]);
+  if (points.length < 3) return polygon(points);
+  const remaining = points.map((p) => ({ ...p }));
+  const ordered = [remaining.shift()];
+  while (remaining.length) {
+    const last = ordered[ordered.length - 1];
+    let bestI = 0;
+    let bestD = Infinity;
+    for (let i = 0; i < remaining.length; i++) {
+      const d = Math.hypot(
+        remaining[i].x - last.x,
+        remaining[i].y - last.y
+      );
+      if (d < bestD) {
+        bestD = d;
+        bestI = i;
+      }
+    }
+    ordered.push(remaining.splice(bestI, 1)[0]);
+  }
+  return polygon(ordered);
+}
+function horizontal(points) {
+  const pts = [...points].sort(
+    (a, b) => a.y === b.y ? a.x - b.x : a.y - b.y
+  );
+  return polygon(pts);
+}
+function vertical(points) {
+  const pts = [...points].sort(
+    (a, b) => a.x === b.x ? a.y - b.y : a.x - b.x
+  );
+  return polygon(pts);
+}
+function angular(points) {
+  if (points.length === 0) return polygon([]);
+  const c = centroidOf(points);
+  const pts = [...points].sort(
+    (a, b) => Math.atan2(a.y - c.y, a.x - c.x) - Math.atan2(b.y - c.y, b.x - c.x)
+  );
+  return polygon(pts);
+}
+function circular(points) {
+  return angular(points);
+}
+function onion(points) {
+  const layers = onionLayers(points);
+  return layers[0] ?? polygon([]);
+}
+function onionLayers(points) {
+  let remaining = points.map((p) => ({ ...p }));
+  const layers = [];
+  while (remaining.length >= 3) {
+    const hull2 = convexHull(remaining);
+    const ring2 = hull2.rings[0] ?? [];
+    if (ring2.length < 3) break;
+    layers.push(hull2);
+    const onHull = new Set(ring2.map((v) => `${v.x},${v.y}`));
+    remaining = remaining.filter((p) => !onHull.has(`${p.x},${p.y}`));
+  }
+  return layers;
+}
+function hilbert(points) {
+  if (points.length === 0) return polygon([]);
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of points) {
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x);
+    maxY = Math.max(maxY, p.y);
+  }
+  const span = Math.max(maxX - minX, maxY - minY, 1e-9);
+  const order = 10;
+  const n = 1 << order;
+  const scored = points.map((p) => {
+    const x = Math.min(
+      n - 1,
+      Math.max(0, Math.floor((p.x - minX) / span * (n - 1)))
+    );
+    const y = Math.min(
+      n - 1,
+      Math.max(0, Math.floor((p.y - minY) / span * (n - 1)))
+    );
+    return { p, h: xy2d(order, x, y) };
+  });
+  scored.sort((a, b) => a.h - b.h);
+  return polygon(scored.map((s) => s.p));
+}
+function coversPoints(poly, points) {
+  const r = poly.rings[0];
+  if (!r || r.length < 3) return false;
+  const a = r[0];
+  const b = r[1];
+  const c = r[2];
+  for (const p of points) {
+    if (!pointInTriangle(p, a, b, c)) return false;
+  }
+  return true;
+}
+function pointInTriangle(p, a, b, c) {
+  const v0x = c.x - a.x;
+  const v0y = c.y - a.y;
+  const v1x = b.x - a.x;
+  const v1y = b.y - a.y;
+  const v2x = p.x - a.x;
+  const v2y = p.y - a.y;
+  const dot00 = v0x * v0x + v0y * v0y;
+  const dot01 = v0x * v1x + v0y * v1y;
+  const dot02 = v0x * v2x + v0y * v2y;
+  const dot11 = v1x * v1x + v1y * v1y;
+  const dot12 = v1x * v2x + v1y * v2y;
+  const inv = 1 / (dot00 * dot11 - dot01 * dot01 || 1e-18);
+  const u = (dot11 * dot02 - dot01 * dot12) * inv;
+  const v = (dot00 * dot12 - dot01 * dot02) * inv;
+  return u >= -1e-9 && v >= -1e-9 && u + v <= 1 + 1e-9;
+}
+function centroidOf(points) {
+  let sx = 0;
+  let sy = 0;
+  for (const p of points) {
+    sx += p.x;
+    sy += p.y;
+  }
+  return { x: sx / points.length, y: sy / points.length };
+}
+function xy2d(order, x, y) {
+  let rx;
+  let ry;
+  let s;
+  let d = 0;
+  for (s = 1 << order - 1; s > 0; s >>= 1) {
+    rx = (x & s) > 0 ? 1 : 0;
+    ry = (y & s) > 0 ? 1 : 0;
+    d += s * s * (3 * rx ^ ry);
+    ({ x, y } = rot(s, x, y, rx, ry));
+  }
+  return d;
+}
+function rot(n, x, y, rx, ry) {
+  if (ry === 0) {
+    if (rx === 1) {
+      x = n - 1 - x;
+      y = n - 1 - y;
+    }
+    return { x: y, y: x };
+  }
+  return { x, y };
+}
+var polygonisation = {
+  maxArea,
+  minArea,
+  minPerimeter,
+  horizontal,
+  vertical,
+  angular,
+  circular,
+  onion,
+  onionLayers,
+  hilbert
+};
+
+// src/meshing/index.ts
+function edgeKey(a, b) {
+  const aKey = `${a.x},${a.y}`;
+  const bKey = `${b.x},${b.y}`;
+  return aKey < bKey ? `${aKey}|${bKey}` : `${bKey}|${aKey}`;
+}
+function vertKey(v) {
+  return `${v.x},${v.y}`;
+}
+function same(a, b, eps = 1e-12) {
+  return Math.abs(a.x - b.x) < eps && Math.abs(a.y - b.y) < eps;
+}
+function dist(a, b) {
+  return Math.hypot(a.x - b.x, a.y - b.y);
+}
+function mid2(a, b) {
+  return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
+}
+function lerp(a, b, t) {
+  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };
+}
+function unique(points) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of points) {
+    const k = vertKey(p);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push({ ...p });
+  }
+  return out;
+}
+function cross3(o, a, b) {
+  return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+}
+function ringOf(face) {
+  return face.rings[0] ?? [];
+}
+function buildEdgeMap(faces) {
+  const edges = /* @__PURE__ */ new Map();
+  faces.forEach((f, fi) => {
+    const ring2 = ringOf(f);
+    if (ring2.length < 2) return;
+    const n = ring2.length;
+    const closed = f.closed !== false && n >= 3;
+    const lim = closed ? n : n - 1;
+    for (let i = 0; i < lim; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      const 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 ring2 = boundaryRingOfComponent(tris, members);
+    if (ring2 && ring2.length >= 3) out.push(polygon(ring2));
+  }
+  return out;
+}
+function boundaryRingOfComponent(tris, members) {
+  const edgeCount = /* @__PURE__ */ new Map();
+  for (const fi of members) {
+    const ring2 = ringOf(tris[fi]);
+    if (ring2.length < 3) continue;
+    for (let i = 0; i < ring2.length; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % ring2.length];
+      const 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 ring2 = [{ ...start }];
+  let prev = start;
+  let curr = edges[0].b;
+  const maxSteps = edges.length + 2;
+  for (let step = 0; step < maxSteps; step++) {
+    ring2.push({ ...curr });
+    if (same(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)) {
+        next = n;
+        break;
+      }
+    }
+    if (!next) break;
+    prev = curr;
+    curr = next;
+  }
+  return ring2.length >= 3 ? ring2 : null;
+}
+function applyEdgeFilter(tris, shouldKeep, preservePerimeter) {
+  const edgeMap = buildEdgeMap(tris);
+  const peri = perimeterKeys(edgeMap);
+  const kept = /* @__PURE__ */ new Set();
+  for (const [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(
+        densifyRing2(ringOf(f), lim),
+        f.rings.slice(1).map((r) => densifyRing2(r, lim))
+      )
+    );
+  }
+  return group(out);
+}
+function densifyRing2(ring2, maxLen) {
+  if (ring2.length < 2) return ring2.map((v) => ({ ...v }));
+  const out = [];
+  const n = ring2.length;
+  for (let i = 0; i < n; i++) {
+    const a = ring2[i];
+    const b = ring2[(i + 1) % n];
+    out.push({ ...a });
+    const d = dist(a, b);
+    const steps = Math.floor(d / maxLen);
+    for (let s = 1; s < steps; s++) out.push(lerp(a, b, s / steps));
+  }
+  return out;
+}
+function isGabriel(a, b, points) {
+  const m = mid2(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 ring2 = uniqueList.map((item) => centroid(faces[item.fi]));
+    out.push(polygon(ring2));
+  }
+  return group(out);
+}
+function triVerts(t) {
+  const r = ringOf(t);
+  if (r.length < 3) return null;
+  return [r[0], r[1], r[2]];
+}
+function midpointMap(faces) {
+  const mids = /* @__PURE__ */ new Map();
+  const edgeMap = buildEdgeMap(faces);
+  for (const [key, e] of edgeMap) {
+    mids.set(key, mid2(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)) ?? mid2(a, b);
+    const mbc = mids.get(edgeKey(b, c)) ?? mid2(b, c);
+    const mca = mids.get(edgeKey(c, a)) ?? mid2(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 ring2 of rings) {
+    ring2.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 ring2 = ringOf(f);
+    if (ring2.length < 3) continue;
+    const c = centroid(f);
+    const n = ring2.length;
+    const splits = [];
+    for (let i = 0; i < n; i++) {
+      const a = ring2[i];
+      const b = ring2[(i + 1) % n];
+      splits.push(lerp(a, b, t));
+    }
+    for (let i = 0; i < n; i++) {
+      const v = ring2[i];
+      const sPrev = splits[(i - 1 + n) % n];
+      const sNext = splits[i];
+      out.push(polygon([v, sNext, c, sPrev]));
+    }
+  }
+  return group(out);
+}
+function simplifyMesh(faces, tolerance, preservePerimeter = true) {
+  if (tolerance <= 0 || faces.length === 0) return group(faces.map((f) => polygon(ringOf(f), f.rings.slice(1))));
+  const edgeMap = buildEdgeMap(faces);
+  const peri = perimeterKeys(edgeMap);
+  const simplified = faces.map((f) => {
+    const ring2 = ringOf(f);
+    if (ring2.length <= 3) return polygon(ring2);
+    if (preservePerimeter) {
+      const s = simplify(f, tolerance);
+      const sr = ringOf(s);
+      if (sr.length < 3) return polygon(ring2);
+      return polygon(sr, s.rings.slice(1));
+    }
+    return simplify(f, tolerance);
+  });
+  const all = unique(simplified.flatMap((f) => ringOf(f)));
+  const snapped = clusterSnap(all, Math.max(tolerance * 0.5, 1e-9));
+  const remap = (v) => {
+    let best = v;
+    let bestD = Infinity;
+    for (const s of snapped) {
+      const d = dist(v, s);
+      if (d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    return { ...best };
+  };
+  const periVerts = /* @__PURE__ */ new Set();
+  if (preservePerimeter) {
+    for (const 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 ring2 = ringOf(f).map((v, vi) => {
+        if (preservePerimeter && original[vi] && periVerts.has(vertKey(original[vi]))) {
+          return { ...original[vi] };
+        }
+        for (const ov of original) {
+          if (periVerts.has(vertKey(ov)) && dist(v, ov) < tolerance * 2) {
+            return { ...ov };
+          }
+        }
+        return remap(v);
+      });
+      return polygon(unique(ring2).length >= 3 ? ring2 : original);
+    })
+  );
+}
+function clusterSnap(points, tol) {
+  const clusters = [];
+  for (const p of points) {
+    let found = false;
+    for (const c of clusters) {
+      if (dist(p, c[0]) <= tol) {
+        c.push(p);
+        found = true;
+        break;
+      }
+    }
+    if (!found) clusters.push([p]);
+  }
+  return clusters.map((c) => ({
+    x: c.reduce((s, p) => s + p.x, 0) / c.length,
+    y: c.reduce((s, p) => s + p.y, 0) / c.length
+  }));
+}
+function stochasticMerge(faces, nClasses, seed = 1) {
+  if (faces.length === 0) return group([]);
+  const classes = Math.max(1, Math.floor(nClasses));
+  const rng = mulberry324(seed >>> 0);
+  const label = faces.map(() => Math.floor(rng() * classes));
+  const adj = faceAdjacency(faces);
+  const parent = faces.map((_, i) => i);
+  const find = (i) => {
+    let x = i;
+    while (parent[x] !== x) {
+      parent[x] = parent[parent[x]];
+      x = parent[x];
+    }
+    return x;
+  };
+  const unite = (a, b) => {
+    const ra = find(a);
+    const rb = find(b);
+    if (ra !== rb) parent[rb] = ra;
+  };
+  for (let i = 0; i < faces.length; i++) {
+    for (const j of adj[i]) {
+      if (j > i && label[i] === label[j]) unite(i, j);
+    }
+  }
+  const comps = /* @__PURE__ */ new Map();
+  for (let i = 0; i < faces.length; i++) {
+    const r = find(i);
+    const list = comps.get(r) ?? [];
+    list.push(i);
+    comps.set(r, list);
+  }
+  const out = [];
+  for (const members of comps.values()) {
+    if (members.length === 1) {
+      out.push(faces[members[0]]);
+      continue;
+    }
+    const merged = dissolveFaces(members.map((i) => faces[i]));
+    out.push(...merged);
+  }
+  return group(out);
+}
+function dissolveFaces(faces) {
+  if (faces.length === 0) return [];
+  if (faces.length === 1) return [faces[0]];
+  try {
+    let acc = faces[0];
+    for (let i = 1; i < faces.length; i++) {
+      const u = union(acc, faces[i]);
+      if (u.paths.length === 0) continue;
+      acc = u.paths.reduce(
+        (best, p) => area(p) > area(best) ? p : best
+      );
+    }
+    return [acc];
+  } catch {
+    return [convexHullOf(faces.flatMap((f) => ringOf(f)))];
+  }
+}
+function areaMerge(faces, minAreaOrOptions) {
+  let working = [...faces];
+  if (working.length === 0) return group([]);
+  if (typeof minAreaOrOptions === "object" && minAreaOrOptions.remainingFaces != null) {
+    const target = Math.max(1, Math.floor(minAreaOrOptions.remainingFaces));
+    while (working.length > target) {
+      const next = mergeSmallestAdjacent(working);
+      if (next.length >= working.length) break;
+      working = next;
+    }
+    return group(working);
+  }
+  const minArea2 = typeof minAreaOrOptions === "number" ? minAreaOrOptions : minAreaOrOptions.minArea ?? 0;
+  let guard = 0;
+  while (guard++ < working.length + 10) {
+    const smallIdx = working.findIndex((f) => area(f) < minArea2);
+    if (smallIdx < 0) break;
+    const next = mergeFaceIntoNeighbor(working, smallIdx);
+    if (!next) break;
+    working = next;
+  }
+  return group(working);
+}
+function mergeSmallestAdjacent(faces) {
+  let best = -1;
+  let bestA = Infinity;
+  for (let i = 0; i < faces.length; i++) {
+    const a = area(faces[i]);
+    if (a < bestA) {
+      bestA = a;
+      best = i;
+    }
+  }
+  if (best < 0) return faces;
+  return mergeFaceIntoNeighbor(faces, best) ?? faces;
+}
+function mergeFaceIntoNeighbor(faces, idx) {
+  const adj = faceAdjacency(faces);
+  const nbrs = adj[idx] ?? [];
+  if (nbrs.length === 0) {
+    return faces.filter((_, i) => i !== idx);
+  }
+  let bestN = nbrs[0];
+  let bestA = -1;
+  for (const n of nbrs) {
+    const a = area(faces[n]);
+    if (a > bestA) {
+      bestA = a;
+      bestN = n;
+    }
+  }
+  const merged = dissolveFaces([faces[idx], faces[bestN]]);
+  const out = [];
+  for (let i = 0; i < faces.length; i++) {
+    if (i === idx || i === bestN) continue;
+    out.push(faces[i]);
+  }
+  out.push(...merged);
+  return out;
+}
+function convexHullOf(points) {
+  const pts = unique(points);
+  if (pts.length < 3) return polygon(pts);
+  pts.sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+  const lower = [];
+  for (const p of pts) {
+    while (lower.length >= 2 && cross3(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+      lower.pop();
+    }
+    lower.push(p);
+  }
+  const upper = [];
+  for (let i = pts.length - 1; i >= 0; i--) {
+    const p = pts[i];
+    while (upper.length >= 2 && cross3(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+      upper.pop();
+    }
+    upper.push(p);
+  }
+  lower.pop();
+  upper.pop();
+  return polygon([...lower, ...upper]);
+}
+function mulberry324(a) {
+  return () => {
+    a |= 0;
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function 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 ring2 = unique(ringOf(f).map(remap));
+    return ring2.length >= 3 ? polygon(ring2) : f;
+  });
+  try {
+    return group(dissolveOverlaps(fixed));
+  } catch {
+    return group(fixed);
+  }
+}
+function dissolveOverlaps(faces) {
+  let working = [...faces];
+  let changed = true;
+  let guard = 0;
+  while (changed && guard++ < working.length) {
+    changed = false;
+    outer: for (let i = 0; i < working.length; i++) {
+      for (let j = i + 1; j < working.length; j++) {
+        const a = working[i];
+        const b = working[j];
+        const u = union(a, b);
+        const ua = u.paths.reduce((s, p) => s + area(p), 0);
+        if (ua < area(a) + area(b) - 1e-6) {
+          const next = working.filter((_, k) => k !== i && k !== j);
+          next.push(...u.paths);
+          working = next;
+          changed = true;
+          break outer;
+        }
+      }
+    }
+  }
+  return working;
+}
+function fixBrokenFaces(coverage, tolerance, polygonise = true) {
+  const tol = Math.max(tolerance, 1e-9);
+  const anchors = [];
+  const endpoints = [];
+  coverage.forEach((p, pi) => {
+    const ring2 = ringOf(p);
+    if (ring2.length === 0) return;
+    if (p.closed) {
+      for (const v of ring2) anchors.push(v);
+    } else {
+      endpoints.push({ pathIdx: pi, end: 0, v: ring2[0] });
+      endpoints.push({
+        pathIdx: pi,
+        end: 1,
+        v: ring2[ring2.length - 1]
+      });
+    }
+  });
+  const snapTargets = clusterSnap(
+    [...anchors, ...endpoints.map((e) => e.v)],
+    tol
+  );
+  const snapTo = (v, preferAnchor) => {
+    let best = v;
+    let bestD = Infinity;
+    for (const s of snapTargets) {
+      const d = dist(v, s);
+      if (d <= tol && d < bestD) {
+        bestD = d;
+        best = s;
+      }
+    }
+    {
+      for (const a of anchors) {
+        if (dist(v, a) <= tol) return { ...a };
+      }
+    }
+    return { ...best };
+  };
+  const snappedPaths = coverage.map((p) => {
+    const ring2 = ringOf(p);
+    if (ring2.length === 0) return p;
+    if (p.closed) return p;
+    const next = ring2.map((v) => ({ ...v }));
+    next[0] = snapTo(ring2[0]);
+    next[next.length - 1] = snapTo(ring2[ring2.length - 1]);
+    return polyline(next);
+  });
+  if (!polygonise) return group(snappedPaths);
+  const out = [];
+  for (const p of snappedPaths) {
+    const ring2 = ringOf(p);
+    if (p.closed) {
+      out.push(p);
+      continue;
+    }
+    if (ring2.length >= 3 && same(ring2[0], ring2[ring2.length - 1], tol * 2)) {
+      out.push(polygon(ring2.slice(0, -1)));
+    } else if (ring2.length >= 3 && dist(ring2[0], ring2[ring2.length - 1]) <= tol * 2) {
+      out.push(polygon(ring2));
+    } else {
+      out.push(p);
+    }
+  }
+  return group(out);
+}
+function findIslands(faces) {
+  if (faces.length === 0) return [];
+  const adj = faceAdjacency(faces);
+  const seen = /* @__PURE__ */ new Set();
+  const islands = [];
+  for (let i = 0; i < faces.length; i++) {
+    if (seen.has(i)) continue;
+    const stack = [i];
+    const members = [];
+    seen.add(i);
+    while (stack.length) {
+      const cur = stack.pop();
+      members.push(cur);
+      for (const n of adj[cur]) {
+        if (!seen.has(n)) {
+          seen.add(n);
+          stack.push(n);
+        }
+      }
+    }
+    islands.push(members);
+  }
+  islands.sort((a, b) => b.length - a.length);
+  return islands.map((m) => group(m.map((i) => faces[i])));
+}
+function radialSortFaces(faces) {
+  if (faces.length === 0) return [];
+  const cs = faces.map((f) => centroid(f));
+  const cx = cs.reduce((s, p) => s + p.x, 0) / cs.length;
+  const cy = cs.reduce((s, p) => s + p.y, 0) / cs.length;
+  return faces.map((f, i) => ({ f, a: Math.atan2(cs[i].y - cy, cs[i].x - cx) })).sort((a, b) => a.a - b.a).map((x) => x.f);
+}
+function centroidSortFaces(faces) {
+  return [...faces].sort((a, b) => {
+    const ca = centroid(a);
+    const cb = centroid(b);
+    return ca.x === cb.x ? ca.y - cb.y : ca.x - cb.x;
+  });
+}
+var meshing = {
+  extractInnerEdges,
+  extractInnerVertices,
+  findContainingFace,
+  splitEdges,
+  urquhartFaces,
+  gabrielFaces,
+  relativeNeighborFaces,
+  spannerFaces,
+  dualFaces,
+  centroidQuadrangulation,
+  edgeCollapseQuadrangulation,
+  splitQuadrangulation,
+  spiralQuadrangulation,
+  matchingQuadrangulation,
+  smoothMesh,
+  subdivideMesh,
+  simplifyMesh,
+  stochasticMerge,
+  areaMerge,
+  radialSortFaces,
+  centroidSortFaces,
+  findBreaks,
+  fixBreaks,
+  fixBrokenFaces,
+  findIslands
+};
+
+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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map