pattapatta 0.2.0

package/dist/transformation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/vec2.ts","../../src/types/path.ts","../../src/predicates/index.ts","../../src/transformation/index.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/** 2D point / vector. */\nexport type Vec2 = {\n  x: number\n  y: number\n}\n\nexport function vec2(x: number, y: number): Vec2 {\n  return { x, y }\n}\n\nexport function cloneVec2(v: Vec2): Vec2 {\n  return { x: v.x, y: v.y }\n}\n\nexport function equalsVec2(a: Vec2, b: Vec2, eps = 1e-9): boolean {\n  return Math.abs(a.x - b.x) <= eps && Math.abs(a.y - b.y) <= eps\n}\n","import type { Vec2 } from './vec2.js'\nimport { cloneVec2, equalsVec2 } from './vec2.js'\n\n/** Ordered ring of vertices (typically without repeating the closing vertex). */\nexport type Ring = Vec2[]\n\n/**\n * A path: one exterior ring plus optional holes, or an open polyline.\n * `rings[0]` is the exterior (or the open polyline when `closed` is false).\n * Additional rings are holes (only meaningful when `closed` is true).\n */\nexport type Path = {\n  rings: Ring[]\n  closed: boolean\n}\n\nexport function path(rings: Ring[], closed = true): Path {\n  return {\n    rings: rings.map((ring) => ring.map(cloneVec2)),\n    closed,\n  }\n}\n\nexport function polyline(points: Ring): Path {\n  return path([points], false)\n}\n\nexport function polygon(exterior: Ring, holes: Ring[] = []): Path {\n  return path([exterior, ...holes], true)\n}\n\n/** Drop a trailing vertex that duplicates the first (SVG often closes this way). */\nexport function normalizeRing(ring: Ring, eps = 1e-9): Ring {\n  if (ring.length < 2) return ring.map(cloneVec2)\n  const first = ring[0]\n  const last = ring[ring.length - 1]\n  if (first && last && equalsVec2(first, last, eps)) {\n    return ring.slice(0, -1).map(cloneVec2)\n  }\n  return ring.map(cloneVec2)\n}\n\nexport function clonePath(p: Path): Path {\n  return {\n    closed: p.closed,\n    rings: p.rings.map((ring) => ring.map(cloneVec2)),\n  }\n}\n","import type { Group, Path, Vec2 } from '../types/index.js'\nimport { vec2 } from '../types/index.js'\nimport {\n  pathToPathsD,\n  pathsArea,\n  pointInRing,\n} from '../clipper/convert.js'\n\n/** Signed area of a closed ring (shoelace). */\nexport function ringArea(ring: Vec2[]): number {\n  if (ring.length < 3) return 0\n  let sum = 0\n  for (let i = 0; i < ring.length; i++) {\n    const a = ring[i]!\n    const b = ring[(i + 1) % ring.length]!\n    sum += a.x * b.y - b.x * a.y\n  }\n  return sum / 2\n}\n\n/** Absolute area of a closed path (exterior minus holes). */\nexport function area(p: Path): number {\n  if (!p.closed || p.rings.length === 0) return 0\n  try {\n    return pathsArea(pathToPathsD(p))\n  } catch {\n    let total = 0\n    for (let i = 0; i < p.rings.length; i++) {\n      const a = Math.abs(ringArea(p.rings[i]!))\n      total += i === 0 ? a : -a\n    }\n    return Math.max(0, total)\n  }\n}\n\nexport function areaGroup(g: Group): number {\n  return g.paths.reduce((sum, p) => sum + area(p), 0)\n}\n\n/** Centroid of a closed exterior ring (ignores holes for Phase 2). */\nexport function centroid(p: Path): Vec2 {\n  const ring = p.rings[0]\n  if (!ring || ring.length === 0) return vec2(0, 0)\n  const a = ringArea(ring)\n  if (Math.abs(a) < 1e-12) {\n    let sx = 0\n    let sy = 0\n    for (const v of ring) {\n      sx += v.x\n      sy += v.y\n    }\n    return vec2(sx / ring.length, sy / ring.length)\n  }\n  let cx = 0\n  let cy = 0\n  for (let i = 0; i < ring.length; i++) {\n    const p0 = ring[i]!\n    const p1 = ring[(i + 1) % ring.length]!\n    const cross = p0.x * p1.y - p1.x * p0.y\n    cx += (p0.x + p1.x) * cross\n    cy += (p0.y + p1.y) * cross\n  }\n  return vec2(cx / (6 * a), cy / (6 * a))\n}\n\nexport function containsPoint(p: Path, point: Vec2): boolean {\n  if (!p.closed || !p.rings[0]) return false\n  if (!pointInRing(point, p.rings[0])) return false\n  for (let i = 1; i < p.rings.length; i++) {\n    const hole = p.rings[i]\n    if (hole && pointInRing(point, hole)) return false\n  }\n  return true\n}\n\nexport function bounds(p: Path): {\n  minX: number\n  minY: number\n  maxX: number\n  maxY: number\n} {\n  let minX = Infinity\n  let minY = Infinity\n  let maxX = -Infinity\n  let maxY = -Infinity\n  for (const ring of p.rings) {\n    for (const v of ring) {\n      minX = Math.min(minX, v.x)\n      minY = Math.min(minY, v.y)\n      maxX = Math.max(maxX, v.x)\n      maxY = Math.max(maxY, v.y)\n    }\n  }\n  if (!Number.isFinite(minX)) {\n    return { minX: 0, minY: 0, maxX: 0, maxY: 0 }\n  }\n  return { minX, minY, maxX, maxY }\n}\n\nexport function width(p: Path): number {\n  const b = bounds(p)\n  return b.maxX - b.minX\n}\n\nexport function height(p: Path): number {\n  const b = bounds(p)\n  return b.maxY - b.minY\n}\n\n/** Rough polygon similarity via absolute area difference relative to max area. */\nexport function areaSimilarity(a: Path, b: Path): number {\n  const aa = area(a)\n  const bb = area(b)\n  const denom = Math.max(aa, bb, 1e-12)\n  return 1 - Math.abs(aa - bb) / denom\n}\n\nexport const predicates = {\n  area,\n  areaGroup,\n  ringArea,\n  centroid,\n  containsPoint,\n  bounds,\n  width,\n  height,\n  areaSimilarity,\n}\n","import type { Path, Vec2 } from '../types/index.js'\nimport { path, normalizeRing, clonePath } from '../types/index.js'\nimport { bounds, centroid } from '../predicates/index.js'\n\nfunction mapPath(p: Path, fn: (v: Vec2) => Vec2): Path {\n  return path(\n    p.rings.map((ring) => normalizeRing(ring.map(fn))),\n    p.closed,\n  )\n}\n\nexport function translate(p: Path, dx: number, dy: number): Path {\n  return mapPath(p, (v) => ({ x: v.x + dx, y: v.y + dy }))\n}\n\nexport function translateToOrigin(p: Path): Path {\n  const c = centroid(p)\n  return translate(p, -c.x, -c.y)\n}\n\nexport function translateCentroidTo(p: Path, target: Vec2): Path {\n  const c = centroid(p)\n  return translate(p, target.x - c.x, target.y - c.y)\n}\n\nexport function rotate(p: Path, angleRad: number, pivot?: Vec2): Path {\n  const o = pivot ?? { x: 0, y: 0 }\n  const cos = Math.cos(angleRad)\n  const sin = Math.sin(angleRad)\n  return mapPath(p, (v) => {\n    const x = v.x - o.x\n    const y = v.y - o.y\n    return {\n      x: o.x + x * cos - y * sin,\n      y: o.y + x * sin + y * cos,\n    }\n  })\n}\n\nexport function rotateAroundCenter(p: Path, angleRad: number): Path {\n  return rotate(p, angleRad, centroid(p))\n}\n\nexport function scale(p: Path, sx: number, sy = sx, pivot?: Vec2): Path {\n  const o = pivot ?? { x: 0, y: 0 }\n  return mapPath(p, (v) => ({\n    x: o.x + (v.x - o.x) * sx,\n    y: o.y + (v.y - o.y) * sy,\n  }))\n}\n\nexport function originScale(p: Path, s: number): Path {\n  return scale(p, s, s, { x: 0, y: 0 })\n}\n\nexport function flipHorizontal(p: Path, x = 0): Path {\n  return mapPath(p, (v) => ({ x: 2 * x - v.x, y: v.y }))\n}\n\nexport function flipVertical(p: Path, y = 0): Path {\n  return mapPath(p, (v) => ({ x: v.x, y: 2 * y - v.y }))\n}\n\n/** Uniform resize so bounding-box width equals `width`. */\nexport function resizeByWidth(p: Path, width: number): Path {\n  const b = bounds(p)\n  const w = b.maxX - b.minX\n  if (w < 1e-12) return clonePath(p)\n  return scale(p, width / w, width / w, { x: b.minX, y: b.minY })\n}\n\n/** Uniform resize so bounding-box height equals `height`. */\nexport function resizeByHeight(p: Path, height: number): Path {\n  const b = bounds(p)\n  const h = b.maxY - b.minY\n  if (h < 1e-12) return clonePath(p)\n  return scale(p, height / h, height / h, { x: b.minX, y: b.minY })\n}\n\n/** Move the AABB min corner to `target`. */\nexport function translateCornerTo(p: Path, target: Vec2): Path {\n  const b = bounds(p)\n  return translate(p, target.x - b.minX, target.y - b.minY)\n}\n\n/** Shear: x' = x + shx * y, y' = y + shy * x (about origin or pivot). */\nexport function shear(\n  p: Path,\n  shx: number,\n  shy = 0,\n  pivot?: Vec2,\n): Path {\n  const o = pivot ?? { x: 0, y: 0 }\n  return mapPath(p, (v) => {\n    const x = v.x - o.x\n    const y = v.y - o.y\n    return {\n      x: o.x + x + shx * y,\n      y: o.y + y + shy * x,\n    }\n  })\n}\n\nexport const transformation = {\n  translate,\n  translateToOrigin,\n  translateCentroidTo,\n  translateCornerTo,\n  rotate,\n  rotateAroundCenter,\n  scale,\n  originScale,\n  flipHorizontal,\n  flipVertical,\n  resizeByWidth,\n  resizeByHeight,\n  shear,\n}\n"]}

package/dist/triangulation/index.d.ts

@@ -0,0 +1,48 @@
+import { V as Vec2 } from '../vec2-CWyXN1Wj.js';
+import { P as Path } from '../path-0RjhYjJs.js';
+
+/**
+ * Triangulate a closed path into triangle polygons (Clipper2).
+ * Holes are supported when present on the path. `useDelaunay` prefers
+ * better-shaped triangles when Clipper can apply it.
+ */
+declare function earCutTriangulation(p: Path, options?: {
+    useDelaunay?: boolean;
+    precision?: number;
+}): Path[];
+/** Alias matching PGS naming for Clipper/Delaunay triangulation of a polygon. */
+declare function delaunayTriangulation(p: Path): Path[];
+/** Delaunay triangulation of a point set (d3-delaunay). */
+declare function delaunayTriangulationPoints(points: Vec2[]): Path[];
+/**
+ * Boundary vertices plus Poisson-disk Steiner points inside `path`.
+ */
+declare function poissonTriangulationPoints(path: Path, minDistance: number, seed?: number): Vec2[];
+/**
+ * Delaunay triangulation of a path with Poisson Steiner points inserted.
+ * Triangles whose centroid falls outside the path (or in a hole) are dropped.
+ */
+declare function poissonTriangulation(path: Path, minDistance: number, seed?: number): Path[];
+type RefineOptions = {
+    /** Minimum allowed interior angle (radians). Default ≈ 20°. */
+    minAngle?: number;
+    /** Safety cap on Steiner insertions. Default `200`. */
+    maxIterations?: number;
+};
+/**
+ * Ruppert-inspired angle refinement for plotter meshes.
+ * Clean-room approximation (not a full constrained CDT): insert circumcenters
+ * of skinny triangles when they lie inside the path; otherwise split the
+ * longest edge of that triangle (simple encroachment stand-in).
+ */
+declare function refine(path: Path, options?: RefineOptions): Path[];
+declare const triangulation: {
+    earCutTriangulation: typeof earCutTriangulation;
+    delaunayTriangulation: typeof delaunayTriangulation;
+    delaunayTriangulationPoints: typeof delaunayTriangulationPoints;
+    poissonTriangulation: typeof poissonTriangulation;
+    poissonTriangulationPoints: typeof poissonTriangulationPoints;
+    refine: typeof refine;
+};
+
+export { type RefineOptions, delaunayTriangulation, delaunayTriangulationPoints, earCutTriangulation, poissonTriangulation, poissonTriangulationPoints, refine, triangulation };

package/dist/triangulation/index.js

@@ -0,0 +1,334 @@
+import { FillRule, triangulateD, pointInPolygonD, PointInPolygonResult } from 'clipper2-ts';
+import { Delaunay } from 'd3-delaunay';
+
+// src/triangulation/index.ts
+
+// 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/path.ts
+function path(rings, closed = true) {
+  return {
+    rings: rings.map((ring) => ring.map(cloneVec2)),
+    closed
+  };
+}
+function polygon(exterior, holes = []) {
+  return path([exterior, ...holes], true);
+}
+function normalizeRing(ring, eps = 1e-9) {
+  if (ring.length < 2) return ring.map(cloneVec2);
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (first && last && equalsVec2(first, last, eps)) {
+    return ring.slice(0, -1).map(cloneVec2);
+  }
+  return ring.map(cloneVec2);
+}
+FillRule.NonZero;
+function ringToPathD(ring) {
+  const pts = [];
+  for (const v of normalizeRing(ring)) {
+    pts.push({ x: v.x, y: v.y, z: 0 });
+  }
+  return pts;
+}
+function pathToPathsD(p) {
+  if (!p.closed || p.rings.length === 0) {
+    throw new Error("Boolean ops require a closed path with at least one ring");
+  }
+  return p.rings.map((ring) => ringToPathD(ring));
+}
+function pathDToRing(pd) {
+  return normalizeRing(pd.map((p) => vec2(p.x, p.y)));
+}
+function pointInRing(point, ring) {
+  const result = pointInPolygonD(
+    { x: point.x, y: point.y, z: 0 },
+    ringToPathD(ring)
+  );
+  return result === PointInPolygonResult.IsInside || result === PointInPolygonResult.IsOn;
+}
+
+// src/predicates/index.ts
+function containsPoint(p, point) {
+  if (!p.closed || !p.rings[0]) return false;
+  if (!pointInRing(point, p.rings[0])) return false;
+  for (let i = 1; i < p.rings.length; i++) {
+    const hole = p.rings[i];
+    if (hole && pointInRing(point, hole)) return false;
+  }
+  return true;
+}
+function bounds(p) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const ring of p.rings) {
+    for (const v of ring) {
+      minX = Math.min(minX, v.x);
+      minY = Math.min(minY, v.y);
+      maxX = Math.max(maxX, v.x);
+      maxY = Math.max(maxY, v.y);
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+  }
+  return { minX, minY, maxX, maxY };
+}
+
+// src/pointSet/index.ts
+function mulberry32(a) {
+  return function() {
+    let t = a += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function poisson(minDistance, minX, minY, maxX, maxY, seed = 1, maxAttempts = 30) {
+  const rng = mulberry32(seed >>> 0);
+  const r = Math.max(minDistance, 1e-9);
+  const cell = r / Math.SQRT2;
+  const w = maxX - minX;
+  const h = maxY - minY;
+  const gw = Math.max(1, Math.ceil(w / cell));
+  const gh = Math.max(1, Math.ceil(h / cell));
+  const grid = Array(gw * gh).fill(null);
+  const points = [];
+  const active = [];
+  const gx = (p) => Math.min(gw - 1, Math.floor((p.x - minX) / cell));
+  const gy = (p) => Math.min(gh - 1, Math.floor((p.y - minY) / cell));
+  const emit = (p) => {
+    const i = points.length;
+    points.push(p);
+    active.push(i);
+    grid[gy(p) * gw + gx(p)] = i;
+  };
+  emit({
+    x: minX + rng() * w,
+    y: minY + rng() * h
+  });
+  while (active.length > 0) {
+    const ai = Math.floor(rng() * active.length);
+    const i = active[ai];
+    const src = points[i];
+    let found = false;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const ang = rng() * Math.PI * 2;
+      const rad = r * (1 + rng());
+      const cand = {
+        x: src.x + Math.cos(ang) * rad,
+        y: src.y + Math.sin(ang) * rad
+      };
+      if (cand.x < minX || cand.x > maxX || cand.y < minY || cand.y > maxY) {
+        continue;
+      }
+      const cx = gx(cand);
+      const cy = gy(cand);
+      let ok = true;
+      for (let yy = Math.max(0, cy - 2); yy <= Math.min(gh - 1, cy + 2) && ok; yy++) {
+        for (let xx = Math.max(0, cx - 2); xx <= Math.min(gw - 1, cx + 2); xx++) {
+          const j = grid[yy * gw + xx];
+          if (j == null) continue;
+          const q = points[j];
+          if (Math.hypot(cand.x - q.x, cand.y - q.y) < r) {
+            ok = false;
+            break;
+          }
+        }
+      }
+      if (ok) {
+        emit(cand);
+        found = true;
+        break;
+      }
+    }
+    if (!found) active.splice(ai, 1);
+  }
+  return points;
+}
+
+// src/triangulation/index.ts
+function earCutTriangulation(p, options = {}) {
+  if (!p.closed || p.rings.length === 0) return [];
+  const { solution } = triangulateD(
+    pathToPathsD(p),
+    options.precision ?? 8,
+    options.useDelaunay ?? false
+  );
+  const tris = [];
+  for (const pd of solution) {
+    const ring = pathDToRing(pd);
+    if (ring.length >= 3) tris.push(polygon(ring.slice(0, 3)));
+  }
+  return tris;
+}
+function delaunayTriangulation(p) {
+  return earCutTriangulation(p, { useDelaunay: true });
+}
+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(path2, minDistance, seed = 1) {
+  if (!path2.closed || path2.rings.length === 0) return [];
+  const b = bounds(path2);
+  const samples = poisson(
+    minDistance,
+    b.minX,
+    b.minY,
+    b.maxX,
+    b.maxY,
+    seed
+  ).filter((pt) => containsPoint(path2, pt));
+  return dedupePoints([...pathVertices(path2), ...samples]);
+}
+function poissonTriangulation(path2, minDistance, seed = 1) {
+  const pts = poissonTriangulationPoints(path2, minDistance, seed);
+  return trianglesInsidePath(delaunayTriangulationPoints(pts), path2);
+}
+function refine(path2, options = {}) {
+  if (!path2.closed || path2.rings.length === 0) return [];
+  const minAngle = options.minAngle ?? 20 * Math.PI / 180;
+  const maxIterations = Math.max(1, options.maxIterations ?? 200);
+  const points = dedupePoints(pathVertices(path2));
+  if (points.length < 3) return [];
+  for (let iter = 0; iter < maxIterations; iter++) {
+    const tris = trianglesInsidePath(
+      delaunayTriangulationPoints(points),
+      path2
+    );
+    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 ring = skinny.rings[0];
+    const cc = circumcenter(ring[0], ring[1], ring[2]);
+    if (!cc) break;
+    const insert = containsPoint(path2, cc) ? cc : longestEdgeMidpoint(ring[0], ring[1], ring[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), path2);
+}
+function pathVertices(path2) {
+  const out = [];
+  for (const ring of path2.rings) {
+    for (const v of ring) 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, path2) {
+  return tris.filter((t) => {
+    const c = triangleCentroid(t);
+    return c != null && containsPoint(path2, 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
+};
+
+export { delaunayTriangulation, delaunayTriangulationPoints, earCutTriangulation, poissonTriangulation, poissonTriangulationPoints, refine, triangulation };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/triangulation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/vec2.ts","../../src/types/path.ts","../../src/clipper/convert.ts","../../src/predicates/index.ts","../../src/pointSet/index.ts","../../src/triangulation/index.ts"],"names":["path"],"mappings":"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","file":"index.js","sourcesContent":["/** 2D point / vector. */\nexport type Vec2 = {\n  x: number\n  y: number\n}\n\nexport function vec2(x: number, y: number): Vec2 {\n  return { x, y }\n}\n\nexport function cloneVec2(v: Vec2): Vec2 {\n  return { x: v.x, y: v.y }\n}\n\nexport function equalsVec2(a: Vec2, b: Vec2, eps = 1e-9): boolean {\n  return Math.abs(a.x - b.x) <= eps && Math.abs(a.y - b.y) <= eps\n}\n","import type { Vec2 } from './vec2.js'\nimport { cloneVec2, equalsVec2 } from './vec2.js'\n\n/** Ordered ring of vertices (typically without repeating the closing vertex). */\nexport type Ring = Vec2[]\n\n/**\n * A path: one exterior ring plus optional holes, or an open polyline.\n * `rings[0]` is the exterior (or the open polyline when `closed` is false).\n * Additional rings are holes (only meaningful when `closed` is true).\n */\nexport type Path = {\n  rings: Ring[]\n  closed: boolean\n}\n\nexport function path(rings: Ring[], closed = true): Path {\n  return {\n    rings: rings.map((ring) => ring.map(cloneVec2)),\n    closed,\n  }\n}\n\nexport function polyline(points: Ring): Path {\n  return path([points], false)\n}\n\nexport function polygon(exterior: Ring, holes: Ring[] = []): Path {\n  return path([exterior, ...holes], true)\n}\n\n/** Drop a trailing vertex that duplicates the first (SVG often closes this way). */\nexport function normalizeRing(ring: Ring, eps = 1e-9): Ring {\n  if (ring.length < 2) return ring.map(cloneVec2)\n  const first = ring[0]\n  const last = ring[ring.length - 1]\n  if (first && last && equalsVec2(first, last, eps)) {\n    return ring.slice(0, -1).map(cloneVec2)\n  }\n  return ring.map(cloneVec2)\n}\n\nexport function clonePath(p: Path): Path {\n  return {\n    closed: p.closed,\n    rings: p.rings.map((ring) => ring.map(cloneVec2)),\n  }\n}\n","import {\n  FillRule,\n  areaD,\n  differenceD,\n  intersectD,\n  isPositiveD,\n  pointInPolygonD,\n  PointInPolygonResult,\n  unionD,\n  xorD,\n  type PathD,\n  type PathsD,\n  type PointD,\n} from 'clipper2-ts'\nimport type { Group, Path, Ring, Vec2 } from '../types/index.js'\nimport { group, normalizeRing, path, vec2 } from '../types/index.js'\n\nexport const DEFAULT_FILL_RULE = FillRule.NonZero\n\nexport function ringToPathD(ring: Ring): PathD {\n  const pts: PointD[] = []\n  for (const v of normalizeRing(ring)) {\n    pts.push({ x: v.x, y: v.y, z: 0 })\n  }\n  return pts\n}\n\n/** Closed path → Clipper subject/clip paths (exterior + holes). */\nexport function pathToPathsD(p: Path): PathsD {\n  if (!p.closed || p.rings.length === 0) {\n    throw new Error('Boolean ops require a closed path with at least one ring')\n  }\n  return p.rings.map((ring) => ringToPathD(ring))\n}\n\nexport function pathsDToGroup(paths: PathsD): Group {\n  if (paths.length === 0) return group([])\n\n  const outers: { ring: Ring; holes: Ring[] }[] = []\n  const holes: Ring[] = []\n\n  for (const pd of paths) {\n    const ring = pathDToRing(pd)\n    if (ring.length < 3) continue\n    if (isPositiveD(pd)) {\n      outers.push({ ring, holes: [] })\n    } else {\n      holes.push(ring)\n    }\n  }\n\n  for (const hole of holes) {\n    const sample = hole[0]\n    if (!sample) continue\n    let assigned = false\n    for (const outer of outers) {\n      if (pointInRing(sample, outer.ring)) {\n        outer.holes.push(hole)\n        assigned = true\n        break\n      }\n    }\n    if (!assigned) {\n      // Treat unmatched negative rings as their own outers (orientation flip).\n      outers.push({ ring: [...hole].reverse(), holes: [] })\n    }\n  }\n\n  return group(outers.map((o) => path([o.ring, ...o.holes], true)))\n}\n\nexport function pathDToRing(pd: PathD): Ring {\n  return normalizeRing(pd.map((p) => vec2(p.x, p.y)))\n}\n\nexport function pointInRing(point: Vec2, ring: Ring): boolean {\n  const result = pointInPolygonD(\n    { x: point.x, y: point.y, z: 0 },\n    ringToPathD(ring),\n  )\n  return (\n    result === PointInPolygonResult.IsInside ||\n    result === PointInPolygonResult.IsOn\n  )\n}\n\nexport function clipUnion(a: PathsD, b: PathsD): PathsD {\n  return unionD(a, b, DEFAULT_FILL_RULE)\n}\n\nexport function clipIntersect(a: PathsD, b: PathsD): PathsD {\n  return intersectD(a, b, DEFAULT_FILL_RULE)\n}\n\nexport function clipDifference(a: PathsD, b: PathsD): PathsD {\n  return differenceD(a, b, DEFAULT_FILL_RULE)\n}\n\nexport function clipXor(a: PathsD, b: PathsD): PathsD {\n  return xorD(a, b, DEFAULT_FILL_RULE)\n}\n\nexport function pathsArea(paths: PathsD): number {\n  let sum = 0\n  for (const p of paths) {\n    sum += Math.abs(areaD(p))\n  }\n  return sum\n}\n","import type { Group, Path, Vec2 } from '../types/index.js'\nimport { vec2 } from '../types/index.js'\nimport {\n  pathToPathsD,\n  pathsArea,\n  pointInRing,\n} from '../clipper/convert.js'\n\n/** Signed area of a closed ring (shoelace). */\nexport function ringArea(ring: Vec2[]): number {\n  if (ring.length < 3) return 0\n  let sum = 0\n  for (let i = 0; i < ring.length; i++) {\n    const a = ring[i]!\n    const b = ring[(i + 1) % ring.length]!\n    sum += a.x * b.y - b.x * a.y\n  }\n  return sum / 2\n}\n\n/** Absolute area of a closed path (exterior minus holes). */\nexport function area(p: Path): number {\n  if (!p.closed || p.rings.length === 0) return 0\n  try {\n    return pathsArea(pathToPathsD(p))\n  } catch {\n    let total = 0\n    for (let i = 0; i < p.rings.length; i++) {\n      const a = Math.abs(ringArea(p.rings[i]!))\n      total += i === 0 ? a : -a\n    }\n    return Math.max(0, total)\n  }\n}\n\nexport function areaGroup(g: Group): number {\n  return g.paths.reduce((sum, p) => sum + area(p), 0)\n}\n\n/** Centroid of a closed exterior ring (ignores holes for Phase 2). */\nexport function centroid(p: Path): Vec2 {\n  const ring = p.rings[0]\n  if (!ring || ring.length === 0) return vec2(0, 0)\n  const a = ringArea(ring)\n  if (Math.abs(a) < 1e-12) {\n    let sx = 0\n    let sy = 0\n    for (const v of ring) {\n      sx += v.x\n      sy += v.y\n    }\n    return vec2(sx / ring.length, sy / ring.length)\n  }\n  let cx = 0\n  let cy = 0\n  for (let i = 0; i < ring.length; i++) {\n    const p0 = ring[i]!\n    const p1 = ring[(i + 1) % ring.length]!\n    const cross = p0.x * p1.y - p1.x * p0.y\n    cx += (p0.x + p1.x) * cross\n    cy += (p0.y + p1.y) * cross\n  }\n  return vec2(cx / (6 * a), cy / (6 * a))\n}\n\nexport function containsPoint(p: Path, point: Vec2): boolean {\n  if (!p.closed || !p.rings[0]) return false\n  if (!pointInRing(point, p.rings[0])) return false\n  for (let i = 1; i < p.rings.length; i++) {\n    const hole = p.rings[i]\n    if (hole && pointInRing(point, hole)) return false\n  }\n  return true\n}\n\nexport function bounds(p: Path): {\n  minX: number\n  minY: number\n  maxX: number\n  maxY: number\n} {\n  let minX = Infinity\n  let minY = Infinity\n  let maxX = -Infinity\n  let maxY = -Infinity\n  for (const ring of p.rings) {\n    for (const v of ring) {\n      minX = Math.min(minX, v.x)\n      minY = Math.min(minY, v.y)\n      maxX = Math.max(maxX, v.x)\n      maxY = Math.max(maxY, v.y)\n    }\n  }\n  if (!Number.isFinite(minX)) {\n    return { minX: 0, minY: 0, maxX: 0, maxY: 0 }\n  }\n  return { minX, minY, maxX, maxY }\n}\n\nexport function width(p: Path): number {\n  const b = bounds(p)\n  return b.maxX - b.minX\n}\n\nexport function height(p: Path): number {\n  const b = bounds(p)\n  return b.maxY - b.minY\n}\n\n/** Rough polygon similarity via absolute area difference relative to max area. */\nexport function areaSimilarity(a: Path, b: Path): number {\n  const aa = area(a)\n  const bb = area(b)\n  const denom = Math.max(aa, bb, 1e-12)\n  return 1 - Math.abs(aa - bb) / denom\n}\n\nexport const predicates = {\n  area,\n  areaGroup,\n  ringArea,\n  centroid,\n  containsPoint,\n  bounds,\n  width,\n  height,\n  areaSimilarity,\n}\n","import type { Vec2 } from '../types/index.js'\n\n/** Seeded uniform random points in an axis-aligned box. */\nexport function random(\n  count: number,\n  minX: number,\n  minY: number,\n  maxX: number,\n  maxY: number,\n  seed = 1,\n): Vec2[] {\n  const rng = mulberry32(seed >>> 0)\n  const out: Vec2[] = []\n  for (let i = 0; i < count; i++) {\n    out.push({\n      x: minX + rng() * (maxX - minX),\n      y: minY + rng() * (maxY - minY),\n    })\n  }\n  return out\n}\n\n/** Square lattice points covering [minX,maxX] × [minY,maxY]. */\nexport function squareGrid(\n  spacing: number,\n  minX: number,\n  minY: number,\n  maxX: number,\n  maxY: number,\n): Vec2[] {\n  const s = Math.max(spacing, 1e-9)\n  const out: Vec2[] = []\n  for (let x = minX; x <= maxX + 1e-12; x += s) {\n    for (let y = minY; y <= maxY + 1e-12; y += s) {\n      out.push({ x, y })\n    }\n  }\n  return out\n}\n\n/** Hexagonal lattice points covering the box. */\nexport function hexGrid(\n  spacing: number,\n  minX: number,\n  minY: number,\n  maxX: number,\n  maxY: number,\n): Vec2[] {\n  const s = Math.max(spacing, 1e-9)\n  const dx = s\n  const dy = s * Math.sqrt(3) * 0.5\n  const out: Vec2[] = []\n  let row = 0\n  for (let y = minY; y <= maxY + 1e-12; y += dy, row++) {\n    const x0 = minX + (row % 2 === 0 ? 0 : s * 0.5)\n    for (let x = x0; x <= maxX + 1e-12; x += dx) {\n      out.push({ x, y })\n    }\n  }\n  return out\n}\n\n/** Ring of `count` points around `center` with `radius`. */\nexport function ring(\n  count: number,\n  center: Vec2,\n  radius: number,\n): Vec2[] {\n  const out: Vec2[] = []\n  for (let i = 0; i < count; i++) {\n    const t = (i / count) * Math.PI * 2\n    out.push({\n      x: center.x + Math.cos(t) * radius,\n      y: center.y + Math.sin(t) * radius,\n    })\n  }\n  return out\n}\n\nfunction mulberry32(a: number): () => number {\n  return function () {\n    let t = (a += 0x6d2b79f5)\n    t = Math.imul(t ^ (t >>> 15), t | 1)\n    t ^= t + Math.imul(t ^ (t >>> 7), t | 61)\n    return ((t ^ (t >>> 14)) >>> 0) / 4294967296\n  }\n}\n\n/** Bridson-ish Poisson disk sample in a box (seeded). */\nexport function poisson(\n  minDistance: number,\n  minX: number,\n  minY: number,\n  maxX: number,\n  maxY: number,\n  seed = 1,\n  maxAttempts = 30,\n): Vec2[] {\n  const rng = mulberry32(seed >>> 0)\n  const r = Math.max(minDistance, 1e-9)\n  const cell = r / Math.SQRT2\n  const w = maxX - minX\n  const h = maxY - minY\n  const gw = Math.max(1, Math.ceil(w / cell))\n  const gh = Math.max(1, Math.ceil(h / cell))\n  const grid: (number | null)[] = Array(gw * gh).fill(null)\n  const points: Vec2[] = []\n  const active: number[] = []\n\n  const gx = (p: Vec2) => Math.min(gw - 1, Math.floor((p.x - minX) / cell))\n  const gy = (p: Vec2) => Math.min(gh - 1, Math.floor((p.y - minY) / cell))\n\n  const emit = (p: Vec2) => {\n    const i = points.length\n    points.push(p)\n    active.push(i)\n    grid[gy(p) * gw + gx(p)] = i\n  }\n\n  emit({\n    x: minX + rng() * w,\n    y: minY + rng() * h,\n  })\n\n  while (active.length > 0) {\n    const ai = Math.floor(rng() * active.length)\n    const i = active[ai]!\n    const src = points[i]!\n    let found = false\n    for (let attempt = 0; attempt < maxAttempts; attempt++) {\n      const ang = rng() * Math.PI * 2\n      const rad = r * (1 + rng())\n      const cand = {\n        x: src.x + Math.cos(ang) * rad,\n        y: src.y + Math.sin(ang) * rad,\n      }\n      if (\n        cand.x < minX ||\n        cand.x > maxX ||\n        cand.y < minY ||\n        cand.y > maxY\n      ) {\n        continue\n      }\n      const cx = gx(cand)\n      const cy = gy(cand)\n      let ok = true\n      for (let yy = Math.max(0, cy - 2); yy <= Math.min(gh - 1, cy + 2) && ok; yy++) {\n        for (let xx = Math.max(0, cx - 2); xx <= Math.min(gw - 1, cx + 2); xx++) {\n          const j = grid[yy * gw + xx]\n          if (j == null) continue\n          const q = points[j]!\n          if (Math.hypot(cand.x - q.x, cand.y - q.y) < r) {\n            ok = false\n            break\n          }\n        }\n      }\n      if (ok) {\n        emit(cand)\n        found = true\n        break\n      }\n    }\n    if (!found) active.splice(ai, 1)\n  }\n  return points\n}\n\n/** Drop points closer than `minDistance` (greedy keep-first). */\nexport function prunePointsWithinDistance(\n  points: Vec2[],\n  minDistance: number,\n): Vec2[] {\n  const r = Math.max(minDistance, 0)\n  const out: Vec2[] = []\n  for (const p of points) {\n    if (out.every((q) => Math.hypot(p.x - q.x, p.y - q.y) >= r)) {\n      out.push(p)\n    }\n  }\n  return out\n}\n\nexport const pointSet = {\n  random,\n  squareGrid,\n  hexGrid,\n  ring,\n  poisson,\n  prunePointsWithinDistance,\n}\n","import { triangulateD } from 'clipper2-ts'\nimport { Delaunay } from 'd3-delaunay'\nimport type { Path, Vec2 } from '../types/index.js'\nimport { polygon } from '../types/index.js'\nimport { pathToPathsD, pathDToRing } from '../clipper/convert.js'\nimport { bounds, containsPoint } from '../predicates/index.js'\nimport { poisson } from '../pointSet/index.js'\n\n/**\n * Triangulate a closed path into triangle polygons (Clipper2).\n * Holes are supported when present on the path. `useDelaunay` prefers\n * better-shaped triangles when Clipper can apply it.\n */\nexport function earCutTriangulation(\n  p: Path,\n  options: { useDelaunay?: boolean; precision?: number } = {},\n): Path[] {\n  if (!p.closed || p.rings.length === 0) return []\n  const { solution } = triangulateD(\n    pathToPathsD(p),\n    options.precision ?? 8,\n    options.useDelaunay ?? false,\n  )\n  const tris: Path[] = []\n  for (const pd of solution) {\n    const ring = pathDToRing(pd)\n    if (ring.length >= 3) tris.push(polygon(ring.slice(0, 3)))\n  }\n  return tris\n}\n\n/** Alias matching PGS naming for Clipper/Delaunay triangulation of a polygon. */\nexport function delaunayTriangulation(p: Path): Path[] {\n  return earCutTriangulation(p, { useDelaunay: true })\n}\n\n/** Delaunay triangulation of a point set (d3-delaunay). */\nexport function delaunayTriangulationPoints(points: Vec2[]): Path[] {\n  if (points.length < 3) return []\n  const delaunay = Delaunay.from(\n    points,\n    (d) => d.x,\n    (d) => d.y,\n  )\n  const tris: Path[] = []\n  const { triangles } = delaunay\n  for (let i = 0; i < triangles.length; i += 3) {\n    const a = points[triangles[i]!]!\n    const b = points[triangles[i + 1]!]!\n    const c = points[triangles[i + 2]!]!\n    tris.push(polygon([a, b, c]))\n  }\n  return tris\n}\n\n/**\n * Boundary vertices plus Poisson-disk Steiner points inside `path`.\n */\nexport function poissonTriangulationPoints(\n  path: Path,\n  minDistance: number,\n  seed = 1,\n): Vec2[] {\n  if (!path.closed || path.rings.length === 0) return []\n  const b = bounds(path)\n  const samples = poisson(\n    minDistance,\n    b.minX,\n    b.minY,\n    b.maxX,\n    b.maxY,\n    seed,\n  ).filter((pt) => containsPoint(path, pt))\n  return dedupePoints([...pathVertices(path), ...samples])\n}\n\n/**\n * Delaunay triangulation of a path with Poisson Steiner points inserted.\n * Triangles whose centroid falls outside the path (or in a hole) are dropped.\n */\nexport function poissonTriangulation(\n  path: Path,\n  minDistance: number,\n  seed = 1,\n): Path[] {\n  const pts = poissonTriangulationPoints(path, minDistance, seed)\n  return trianglesInsidePath(delaunayTriangulationPoints(pts), path)\n}\n\nexport type RefineOptions = {\n  /** Minimum allowed interior angle (radians). Default ≈ 20°. */\n  minAngle?: number\n  /** Safety cap on Steiner insertions. Default `200`. */\n  maxIterations?: number\n}\n\n/**\n * Ruppert-inspired angle refinement for plotter meshes.\n * Clean-room approximation (not a full constrained CDT): insert circumcenters\n * of skinny triangles when they lie inside the path; otherwise split the\n * longest edge of that triangle (simple encroachment stand-in).\n */\nexport function refine(path: Path, options: RefineOptions = {}): Path[] {\n  if (!path.closed || path.rings.length === 0) return []\n  const minAngle = options.minAngle ?? (20 * Math.PI) / 180\n  const maxIterations = Math.max(1, options.maxIterations ?? 200)\n  const points = dedupePoints(pathVertices(path))\n  if (points.length < 3) return []\n\n  for (let iter = 0; iter < maxIterations; iter++) {\n    const tris = trianglesInsidePath(\n      delaunayTriangulationPoints(points),\n      path,\n    )\n    if (tris.length === 0) break\n\n    let skinny: Path | null = null\n    let worst = minAngle\n    for (const t of tris) {\n      const a = minTriangleAngle(t)\n      if (a < worst) {\n        worst = a\n        skinny = t\n      }\n    }\n    if (!skinny) break\n\n    const ring = skinny.rings[0]!\n    const cc = circumcenter(ring[0]!, ring[1]!, ring[2]!)\n    if (!cc) break\n\n    const insert = containsPoint(path, cc)\n      ? cc\n      : longestEdgeMidpoint(ring[0]!, ring[1]!, ring[2]!)\n    if (\n      points.some((p) => Math.hypot(p.x - insert.x, p.y - insert.y) < 1e-9)\n    ) {\n      break\n    }\n    points.push(insert)\n  }\n\n  return trianglesInsidePath(delaunayTriangulationPoints(points), path)\n}\n\nfunction pathVertices(path: Path): Vec2[] {\n  const out: Vec2[] = []\n  for (const ring of path.rings) {\n    for (const v of ring) out.push({ x: v.x, y: v.y })\n  }\n  return out\n}\n\nfunction dedupePoints(points: Vec2[], eps = 1e-9): Vec2[] {\n  const out: Vec2[] = []\n  for (const p of points) {\n    if (out.some((q) => Math.hypot(q.x - p.x, q.y - p.y) < eps)) continue\n    out.push(p)\n  }\n  return out\n}\n\nfunction triangleCentroid(t: Path): Vec2 | null {\n  const r = t.rings[0]\n  if (!r || r.length < 3) return null\n  return {\n    x: (r[0]!.x + r[1]!.x + r[2]!.x) / 3,\n    y: (r[0]!.y + r[1]!.y + r[2]!.y) / 3,\n  }\n}\n\nfunction trianglesInsidePath(tris: Path[], path: Path): Path[] {\n  return tris.filter((t) => {\n    const c = triangleCentroid(t)\n    return c != null && containsPoint(path, c)\n  })\n}\n\nfunction minTriangleAngle(t: Path): number {\n  const r = t.rings[0]\n  if (!r || r.length < 3) return 0\n  const a = r[0]!\n  const b = r[1]!\n  const c = r[2]!\n  return Math.min(angleAt(a, b, c), angleAt(b, c, a), angleAt(c, a, b))\n}\n\nfunction angleAt(vertex: Vec2, p: Vec2, q: Vec2): number {\n  const ux = p.x - vertex.x\n  const uy = p.y - vertex.y\n  const vx = q.x - vertex.x\n  const vy = q.y - vertex.y\n  const lu = Math.hypot(ux, uy)\n  const lv = Math.hypot(vx, vy)\n  if (lu < 1e-18 || lv < 1e-18) return 0\n  const cos = Math.max(-1, Math.min(1, (ux * vx + uy * vy) / (lu * lv)))\n  return Math.acos(cos)\n}\n\nfunction circumcenter(a: Vec2, b: Vec2, c: Vec2): Vec2 | null {\n  const d =\n    2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y))\n  if (Math.abs(d) < 1e-18) return null\n  const a2 = a.x * a.x + a.y * a.y\n  const b2 = b.x * b.x + b.y * b.y\n  const c2 = c.x * c.x + c.y * c.y\n  return {\n    x: (a2 * (b.y - c.y) + b2 * (c.y - a.y) + c2 * (a.y - b.y)) / d,\n    y: (a2 * (c.x - b.x) + b2 * (a.x - c.x) + c2 * (b.x - a.x)) / d,\n  }\n}\n\nfunction longestEdgeMidpoint(a: Vec2, b: Vec2, c: Vec2): Vec2 {\n  const edges: [Vec2, Vec2][] = [\n    [a, b],\n    [b, c],\n    [c, a],\n  ]\n  let best = edges[0]!\n  let bestLen = -1\n  for (const e of edges) {\n    const len = Math.hypot(e[0].x - e[1].x, e[0].y - e[1].y)\n    if (len > bestLen) {\n      bestLen = len\n      best = e\n    }\n  }\n  return { x: (best[0].x + best[1].x) / 2, y: (best[0].y + best[1].y) / 2 }\n}\n\nexport const triangulation = {\n  earCutTriangulation,\n  delaunayTriangulation,\n  delaunayTriangulationPoints,\n  poissonTriangulation,\n  poissonTriangulationPoints,\n  refine,\n}\n"]}

package/dist/vec2-CWyXN1Wj.d.ts

@@ -0,0 +1,10 @@
+/** 2D point / vector. */
+type Vec2 = {
+    x: number;
+    y: number;
+};
+declare function vec2(x: number, y: number): Vec2;
+declare function cloneVec2(v: Vec2): Vec2;
+declare function equalsVec2(a: Vec2, b: Vec2, eps?: number): boolean;
+
+export { type Vec2 as V, cloneVec2 as c, equalsVec2 as e, vec2 as v };

package/dist/voronoi/index.d.ts

@@ -0,0 +1,31 @@
+import { V as Vec2 } from '../vec2-CWyXN1Wj.js';
+import { P as Path } from '../path-0RjhYjJs.js';
+import { G as Group } from '../group-BNjVVYSQ.js';
+
+type VoronoiOptions = {
+    /** Clip cells to this bbox; default padded bounds of the sites. */
+    bounds?: {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+    };
+};
+/**
+ * Voronoi cells for a point set as closed polygons (clipped to a bbox).
+ * PGS `compoundVoronoi` analogue — one path per site.
+ */
+declare function compoundVoronoi(sites: Vec2[], options?: VoronoiOptions): Group;
+/**
+ * Voronoi clipped to the interior of `container` (intersect each cell).
+ */
+declare function innerVoronoi(sites: Vec2[], container: Path, options?: VoronoiOptions): Group;
+/** Raw cell polygons without container clip (same as compoundVoronoi). */
+declare function innerVoronoiRaw(sites: Vec2[], options?: VoronoiOptions): Group;
+declare const voronoi: {
+    compoundVoronoi: typeof compoundVoronoi;
+    innerVoronoi: typeof innerVoronoi;
+    innerVoronoiRaw: typeof innerVoronoiRaw;
+};
+
+export { type VoronoiOptions, compoundVoronoi, innerVoronoi, innerVoronoiRaw, voronoi };