pattapatta 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.2.0
+
+### Minor Changes
+
+- e272ce5: Centered lattice packing with clipped overlap fills, hatch counts that cover the full path, poisson/refine triangulation, and expanded meshing (Urquhart/spanner graphs, quadrangulation, smooth/subdivide/simplify, merge and topology fixes).
+
+All notable changes to this project will be documented in this file.
+
+The format is maintained by [Changesets](https://github.com/changesets/changesets).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pattapatta contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,98 @@
+# pattapatta
+
+Pen-plotter geometry library (inspired by [PGS](https://github.com/micycle1/PGS)): hatching, circle packing, triangulation / meshing, boolean path ops, Voronoi, tilings, and SVG I/O for Node and the browser.
+
+**Stroke marks only** — solid area fills are not the goal.
+
+[![npm](https://img.shields.io/npm/v/pattapatta.svg)](https://www.npmjs.com/package/pattapatta)
+
+## Install
+
+```bash
+pnpm add pattapatta
+```
+
+Requires **Node ≥ 18** (ESM). Works in modern browsers via bundlers.
+
+## Quick example
+
+```ts
+import { createRect, union, hatchParallel, toSvg, group, segmentsToOpenPaths } from 'pattapatta'
+
+const a = createRect(0, 0, 2, 1)
+const b = createRect(1, 0, 2, 1)
+const merged = union(a, b)
+const strokes = hatchParallel(merged.paths[0]!, { spacing: 0.08, count: 40 })
+console.log(toSvg(group(segmentsToOpenPaths(strokes))))
+```
+
+```bash
+pnpm dlx pattapatta --help
+pnpm dlx pattapatta svg:roundtrip in.svg -o out.svg
+```
+
+## Docs site
+
+Live: [pattapatta.madorkestra.com](https://pattapatta.madorkestra.com) (GitHub Pages; deploys on push to `main`).
+
+Local documentation PWA (SvelteKit + shadcn):
+
+```bash
+pnpm install
+pnpm docs:dev
+pnpm docs:build
+pnpm docs:examples   # regenerate SVG figures
+```
+
+## Modules
+
+| Import | Role |
+|--------|------|
+| `pattapatta` | Types, SVG, all facades |
+| `pattapatta/shapeBoolean` | Union / intersect / subtract / occlusion |
+| `pattapatta/hatch` | Parallel / cross hatch fills |
+| `pattapatta/circlePacking` | Lattices (`overlap` \| `contained`), LEC, stochastic |
+| `pattapatta/triangulation` | Earcut, Delaunay, Poisson Steiner, refine |
+| `pattapatta/morphology` | Buffer, simplify, warps |
+| `pattapatta/meshing` | Graph faces, quadrangulation, mesh process / repair |
+| `pattapatta/voronoi` | Voronoi cells |
+| … | See `website/` API pages |
+
+## Releasing
+
+This repo uses [Changesets](https://github.com/changesets/changesets). Only the root `pattapatta` package is published; `website` is ignored. CI publishes via [npm trusted publishing (OIDC)](https://docs.npmjs.com/trusted-publishers) — no long-lived `NPM_TOKEN` (2FA-bypass tokens are being deprecated for direct publish; see [npm changelog](https://github.blog/changelog/2026-07-08-npm-install-time-security-and-gat-bypass2fa-deprecation/)).
+
+### One-time npm setup
+
+1. If the package is not on npm yet, publish once locally (trusted publishers can only be configured on an existing package):
+   ```bash
+   pnpm build && npm publish --access public --otp=<code>
+   ```
+2. On [npmjs.com](https://www.npmjs.com/) → **pattapatta** → **Settings** → **Trusted Publisher** → **GitHub Actions**:
+   - **Organization or user:** `MadOrkestra`
+   - **Repository:** `pattapatta`
+   - **Workflow filename:** `release.yml` (filename only)
+   - **Allowed actions:** include **`npm publish`** (not stage-only — Changesets publishes directly)
+3. Optionally under **Publishing access**, require 2FA and disallow tokens once OIDC works.
+4. Remove any repo `NPM_TOKEN` secret if it was only used for publish.
+
+### Routine releases
+
+1. In a PR that changes the library, run `pnpm changeset`, commit the file under `.changeset/`, and merge to `main`.
+2. The **Release** workflow opens or updates a **Version Packages** PR (bumps version, updates `CHANGELOG.md`).
+3. Merging that PR publishes to npm (OIDC + provenance) and creates a GitHub Release.
+
+Current package version is in `package.json` (e.g. `0.2.0`). If publish failed after a version bump, fix the trusted-publisher config (workflow name must be exactly `release.yml`) and re-run **Release** — Changesets will publish any version not yet on npm.
+
+Local checks used by CI:
+
+```bash
+pnpm install --frozen-lockfile
+pnpm test
+pnpm typecheck
+pnpm build
+```
+
+## License
+
+MIT — clean-room implementation (not a GPL line-port of PGS). See `docs/decisions/`.

package/dist/circle-BDbKfrdR.d.ts

@@ -0,0 +1,12 @@
+import { V as Vec2 } from './vec2-CWyXN1Wj.js';
+
+/** Circle with center (x, y) and radius r (PGS often stored radius in PVector.z). */
+type Circle = {
+    x: number;
+    y: number;
+    r: number;
+};
+declare function circle(x: number, y: number, r: number): Circle;
+declare function circleCenter(c: Circle): Vec2;
+
+export { type Circle as C, circleCenter as a, circle as c };

package/dist/circlePacking/index.d.ts

@@ -0,0 +1,78 @@
+import { V as Vec2 } from '../vec2-CWyXN1Wj.js';
+import { C as Circle } from '../circle-BDbKfrdR.js';
+import { P as Path } from '../path-0RjhYjJs.js';
+
+/**
+ * Lattice inclusion mode.
+ * - `overlap` (default): full-path fill — keep disks that overlap the path;
+ *   center the lattice so opposite-edge cutoffs match. Clip in SVG to cut at
+ *   the boundary (including holes).
+ * - `contained`: keep only disks fully inside the path (when you must stroke
+ *   complete circles); lattice centered with equal leftover margins.
+ */
+type LatticePackMode = 'overlap' | 'contained';
+/**
+ * Square lattice of equal circles.
+ * @see docs/decisions/0003-deferred-circle-packing.md
+ */
+declare function squareLatticePack(path: Path, diameter: number, mode?: LatticePackMode): Circle[];
+/**
+ * Hexagonal lattice of equal circles.
+ */
+declare function hexLatticePack(path: Path, diameter: number, mode?: LatticePackMode): Circle[];
+/**
+ * Seeded stochastic packing: sample random points, grow max non-overlapping
+ * radius (tangent to nearest circle or limited by distance to boundary).
+ * Triangulation Steiner mode deferred.
+ */
+declare function stochasticPack(path: Path, points: number, minRadius: number, seed?: number): Circle[];
+/**
+ * Pack up to `n` maximum inscribed circles via iterative largest-empty-circle
+ * search (grid + local refine). Circles are fully contained and non-overlapping.
+ * `tolerance` controls coarse grid step as a fraction of the bbox diagonal
+ * (PGS uses a related accuracy knob; values ~0.5–1 are reasonable).
+ *
+ * Deferred: `tangencyPack`, `trinscribedPack` — see ADR 0003.
+ */
+declare function maximumInscribedPack(path: Path, n: number, tolerance?: number): Circle[];
+/**
+ * Pack inscribed circles while radius stays ≥ `minRadius`.
+ */
+declare function maximumInscribedPackUntil(path: Path, minRadius: number, tolerance?: number): Circle[];
+/**
+ * Successive LECs inside `path`, treating `obstacles` as already-placed disks.
+ * Simpler than full PGS obstacle packing; sufficient for “avoid these circles.”
+ */
+declare function obstaclePack(path: Path, obstacles: Circle[], n: number, tolerance?: number): Circle[];
+/**
+ * Front-chain-inspired packing of (possibly varying) radii in the path envelope,
+ * then keep circles that overlap the path. Seeded for determinism.
+ * Grows until placement stalls (region effectively full); no fixed circle count.
+ * Not a line-by-line port of PGS FrontChainPacker — same role, approximate layout.
+ */
+declare function frontChainPack(path: Path, radiusMin: number, radiusMax: number, seed?: number): Circle[];
+/**
+ * Seed random circles in the envelope, then iteratively repulse overlaps;
+ * keep those that overlap the path (PGS repulsionPack role).
+ */
+declare function repulsionPack(path: Path, radiusMin: number, radiusMax: number, seed?: number, iterations?: number): Circle[];
+/** True if disk overlaps the filled path (including partial exterior overlap). */
+declare function circleOverlapsPath(c: Circle, path: Path): boolean;
+/** True if the disk lies fully inside the path. */
+declare function circleContainedInPath(c: Circle, path: Path): boolean;
+/** Distance from point to polygon: 0 if inside, else distance to boundary. */
+declare function distanceToPolygon(p: Vec2, path: Path): number;
+declare const circlePacking: {
+    squareLatticePack: typeof squareLatticePack;
+    hexLatticePack: typeof hexLatticePack;
+    stochasticPack: typeof stochasticPack;
+    maximumInscribedPack: typeof maximumInscribedPack;
+    maximumInscribedPackUntil: typeof maximumInscribedPackUntil;
+    obstaclePack: typeof obstaclePack;
+    frontChainPack: typeof frontChainPack;
+    repulsionPack: typeof repulsionPack;
+    circleOverlapsPath: typeof circleOverlapsPath;
+    circleContainedInPath: typeof circleContainedInPath;
+};
+
+export { type LatticePackMode, circleContainedInPath, circleOverlapsPath, circlePacking, distanceToPolygon, frontChainPack, hexLatticePack, maximumInscribedPack, maximumInscribedPackUntil, obstaclePack, repulsionPack, squareLatticePack, stochasticPack };

package/dist/circlePacking/index.js

@@ -0,0 +1,381 @@
+import { FillRule, pointInPolygonD, PointInPolygonResult } from 'clipper2-ts';
+
+// src/types/vec2.ts
+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 };
+}
+
+// src/types/path.ts
+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 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/circlePacking/index.ts
+function squareLatticePack(path2, diameter, mode = "overlap") {
+  const d = Math.max(diameter, 0.1);
+  const r = d / 2;
+  const b = bounds(path2);
+  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, path2)) out.push(c);
+    }
+  }
+  return out;
+}
+function hexLatticePack(path2, diameter, mode = "overlap") {
+  const d = Math.max(diameter, 0.1);
+  const r = d / 2;
+  const b = bounds(path2);
+  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, path2)) 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(path2, points, minRadius, seed = 1) {
+  const rng = mulberry32(seed >>> 0);
+  const b = bounds(path2);
+  const packing = [];
+  for (let attempt = 0; attempt < points; attempt++) {
+    const p = vecInBounds(b, rng);
+    if (!containsPoint(path2, p)) continue;
+    const maxR = clearanceRadius(p, path2, packing);
+    if (maxR < minRadius) continue;
+    packing.push(circle(p.x, p.y, maxR));
+  }
+  return packing;
+}
+function maximumInscribedPack(path2, n, tolerance = 1) {
+  return obstaclePack(path2, [], n, tolerance);
+}
+function maximumInscribedPackUntil(path2, minRadius, tolerance = 1) {
+  const packing = [];
+  const tol = Math.max(0.01, tolerance);
+  const minR = Math.max(0.01, minRadius);
+  for (; ; ) {
+    const next = findLargestEmptyCircle(path2, packing, tol);
+    if (!next || next.r < minR) break;
+    packing.push(next);
+  }
+  return packing;
+}
+function obstaclePack(path2, obstacles, n, tolerance = 1) {
+  const packing = obstacles.map((c) => ({ ...c }));
+  const placed = [];
+  const tol = Math.max(0.01, tolerance);
+  for (let i = 0; i < n; i++) {
+    const next = findLargestEmptyCircle(path2, packing, tol);
+    if (!next || next.r <= 1e-9) break;
+    packing.push(next);
+    placed.push(next);
+  }
+  return placed;
+}
+function frontChainPack(path2, 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(path2);
+  const packing = [];
+  const area = Math.max(1e-6, (b.maxX - b.minX) * (b.maxY - b.minY));
+  const capacity = Math.max(
+    4,
+    Math.ceil(area / (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, path2)) {
+      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 dist = base.r + r;
+    const c = circle(
+      base.x + Math.cos(ang) * dist,
+      base.y + Math.sin(ang) * dist,
+      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, path2)) {
+      packing.push(c);
+      fails = 0;
+    } else {
+      fails++;
+    }
+  }
+  return packing.filter((c) => circleOverlapsPath(c, path2));
+}
+function repulsionPack(path2, 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(path2);
+  const area = Math.max(1e-6, (b.maxX - b.minX) * (b.maxY - b.minY));
+  const avgR = (rMin + rMax) / 2;
+  const target = Math.max(
+    4,
+    Math.floor(area / (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 dist = Math.hypot(dx, dy) || 1e-9;
+        const minDist = a.r + bC.r;
+        if (dist >= minDist) continue;
+        const push = (minDist - dist) / 2 * 0.5;
+        const ux = dx / dist;
+        const uy = dy / dist;
+        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, path2));
+}
+function circleOverlapsPath(c, path2) {
+  const center = { x: c.x, y: c.y };
+  const dist = distanceToPolygon(center, path2);
+  return dist <= c.r * 0.95;
+}
+function circleContainedInPath(c, path2) {
+  const center = { x: c.x, y: c.y };
+  if (!containsPoint(path2, center)) return false;
+  return distanceToBoundary(center, path2) + 1e-9 >= c.r;
+}
+function distanceToPolygon(p, path2) {
+  if (containsPoint(path2, p)) return 0;
+  return distanceToBoundary(p, path2);
+}
+function findLargestEmptyCircle(path2, obstacles, tolerance) {
+  const b = bounds(path2);
+  const diag = Math.hypot(b.maxX - b.minX, b.maxY - b.minY) || 1;
+  const step = Math.max(diag * 0.02 * Math.sqrt(tolerance), diag * 0.01);
+  let best = null;
+  for (let x = b.minX; x <= b.maxX; x += step) {
+    for (let y = b.minY; y <= b.maxY; y += step) {
+      const p = { x, y };
+      if (!containsPoint(path2, p)) continue;
+      const r = clearanceRadius(p, path2, obstacles);
+      if (!best || r > best.r) best = circle(p.x, p.y, r);
+    }
+  }
+  if (!best) return null;
+  let cur = best;
+  let span = step;
+  for (let iter = 0; iter < 8; iter++) {
+    let improved = cur;
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        if (dx === 0 && dy === 0) continue;
+        const p = { x: cur.x + dx * span, y: cur.y + dy * span };
+        if (!containsPoint(path2, p)) continue;
+        const r = clearanceRadius(p, path2, obstacles);
+        if (r > improved.r) improved = circle(p.x, p.y, r);
+      }
+    }
+    cur = improved;
+    span *= 0.5;
+  }
+  return cur;
+}
+function clearanceRadius(p, path2, obstacles) {
+  let r = distanceToBoundary(p, path2);
+  for (const c of obstacles) {
+    r = Math.min(r, Math.hypot(p.x - c.x, p.y - c.y) - c.r);
+  }
+  return Math.max(0, r);
+}
+function 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, path2) {
+  let min = Infinity;
+  for (const ring of path2.rings) {
+    for (let i = 0; i < ring.length; i++) {
+      const a = ring[i];
+      const b = ring[(i + 1) % ring.length];
+      min = Math.min(min, pointSegmentDistance(p, a, b));
+    }
+  }
+  return min;
+}
+function pointSegmentDistance(p, a, b) {
+  const abx = b.x - a.x;
+  const aby = b.y - a.y;
+  const len2 = abx * abx + aby * aby;
+  if (len2 < 1e-18) return Math.hypot(p.x - a.x, p.y - a.y);
+  let t = ((p.x - a.x) * abx + (p.y - a.y) * aby) / len2;
+  t = Math.max(0, Math.min(1, t));
+  return Math.hypot(p.x - (a.x + t * abx), p.y - (a.y + t * aby));
+}
+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
+};
+
+export { circleContainedInPath, circleOverlapsPath, circlePacking, distanceToPolygon, frontChainPack, hexLatticePack, maximumInscribedPack, maximumInscribedPackUntil, obstaclePack, repulsionPack, squareLatticePack, stochasticPack };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map