pattapatta 0.2.0

package/dist/predicates/index.js

@@ -0,0 +1,159 @@
+import { FillRule, areaD, pointInPolygonD, PointInPolygonResult } from 'clipper2-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 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 pointInRing(point, ring) {
+  const result = pointInPolygonD(
+    { x: point.x, y: point.y, z: 0 },
+    ringToPathD(ring)
+  );
+  return result === PointInPolygonResult.IsInside || result === PointInPolygonResult.IsOn;
+}
+function pathsArea(paths) {
+  let sum = 0;
+  for (const p of paths) {
+    sum += Math.abs(areaD(p));
+  }
+  return sum;
+}
+
+// src/predicates/index.ts
+function ringArea(ring) {
+  if (ring.length < 3) return 0;
+  let sum = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % ring.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function area(p) {
+  if (!p.closed || p.rings.length === 0) return 0;
+  try {
+    return pathsArea(pathToPathsD(p));
+  } catch {
+    let total = 0;
+    for (let i = 0; i < p.rings.length; i++) {
+      const a = Math.abs(ringArea(p.rings[i]));
+      total += i === 0 ? a : -a;
+    }
+    return Math.max(0, total);
+  }
+}
+function areaGroup(g) {
+  return g.paths.reduce((sum, p) => sum + area(p), 0);
+}
+function centroid(p) {
+  const ring = p.rings[0];
+  if (!ring || ring.length === 0) return vec2(0, 0);
+  const a = ringArea(ring);
+  if (Math.abs(a) < 1e-12) {
+    let sx = 0;
+    let sy = 0;
+    for (const v of ring) {
+      sx += v.x;
+      sy += v.y;
+    }
+    return vec2(sx / ring.length, sy / ring.length);
+  }
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const p0 = ring[i];
+    const p1 = ring[(i + 1) % ring.length];
+    const cross = p0.x * p1.y - p1.x * p0.y;
+    cx += (p0.x + p1.x) * cross;
+    cy += (p0.y + p1.y) * cross;
+  }
+  return vec2(cx / (6 * a), cy / (6 * a));
+}
+function containsPoint(p, point) {
+  if (!p.closed || !p.rings[0]) return false;
+  if (!pointInRing(point, p.rings[0])) return false;
+  for (let i = 1; i < p.rings.length; i++) {
+    const hole = p.rings[i];
+    if (hole && pointInRing(point, hole)) return false;
+  }
+  return true;
+}
+function bounds(p) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const ring of p.rings) {
+    for (const v of ring) {
+      minX = Math.min(minX, v.x);
+      minY = Math.min(minY, v.y);
+      maxX = Math.max(maxX, v.x);
+      maxY = Math.max(maxY, v.y);
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+  }
+  return { minX, minY, maxX, maxY };
+}
+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
+};
+
+export { area, areaGroup, areaSimilarity, bounds, centroid, containsPoint, height, predicates, ringArea, width };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/predicates/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"],"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 {\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"]}

package/dist/processing/index.d.ts

@@ -0,0 +1,54 @@
+import { V as Vec2 } from '../vec2-CWyXN1Wj.js';
+import { S as Segment } from '../segment-BKuIFMKD.js';
+import { P as Path } from '../path-0RjhYjJs.js';
+import { G as Group } from '../group-BNjVVYSQ.js';
+
+/** Exterior ring as its own closed path (holes dropped). */
+declare function extractPerimeter(p: Path): Path;
+/** Alias for extractPerimeter. */
+declare function extractBoundary(p: Path): Path;
+/** Each hole as a separate closed path. */
+declare function extractHoles(p: Path): Path[];
+/**
+ * Insert vertices so no edge exceeds `maxSegLen`.
+ * Closed rings treat the wrap-around edge.
+ */
+declare function densify(p: Path, maxSegLen: number): Path;
+/** Drop holes whose absolute area is below `minArea`. */
+declare function removeSmallHoles(p: Path, minArea: number): Path;
+/** Seeded uniform random points inside a closed path. */
+declare function generateRandomPoints(p: Path, count: number, seed?: number): Vec2[];
+/** Axis-aligned grid samples that fall inside the path. */
+declare function generateRandomGridPoints(p: Path, spacing: number): Vec2[];
+/** Evenly spaced samples along the exterior perimeter. */
+declare function pointsOnExterior(p: Path, count: number): Vec2[];
+/** Exterior edges as segments. */
+declare function segmentsOnExterior(p: Path): Segment[];
+/**
+ * Cut `p` with the infinite line through `a`→`b`.
+ * Returns pieces on both sides (typically 0–2 paths).
+ */
+declare function slice(p: Path, a: Vec2, b: Vec2): Group;
+/** Split through the centroid with a vertical cut (left/right). */
+declare function centroidSplit(p: Path): Group;
+/** Union all closed paths in a group (dissolve overlapping contours). */
+declare function dissolve(paths: Path[]): Group;
+/** Vertex–edge intersection points between two path boundaries. */
+declare function intersectionPoints(a: Path, b: Path): Vec2[];
+declare const processing: {
+    extractPerimeter: typeof extractPerimeter;
+    extractBoundary: typeof extractBoundary;
+    extractHoles: typeof extractHoles;
+    densify: typeof densify;
+    removeSmallHoles: typeof removeSmallHoles;
+    generateRandomPoints: typeof generateRandomPoints;
+    generateRandomGridPoints: typeof generateRandomGridPoints;
+    pointsOnExterior: typeof pointsOnExterior;
+    segmentsOnExterior: typeof segmentsOnExterior;
+    slice: typeof slice;
+    centroidSplit: typeof centroidSplit;
+    dissolve: typeof dissolve;
+    intersectionPoints: typeof intersectionPoints;
+};
+
+export { centroidSplit, densify, dissolve, extractBoundary, extractHoles, extractPerimeter, generateRandomGridPoints, generateRandomPoints, intersectionPoints, pointsOnExterior, processing, removeSmallHoles, segmentsOnExterior, slice };

package/dist/processing/index.js

@@ -0,0 +1,457 @@
+import { FillRule, pointInPolygonD, PointInPolygonResult, intersectD, isPositiveD, unionD } from 'clipper2-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/segment.ts
+function segment(a, b) {
+  return { a, b };
+}
+
+// src/types/path.ts
+function path(rings, closed = true) {
+  return {
+    rings: rings.map((ring) => ring.map(cloneVec2)),
+    closed
+  };
+}
+function polygon(exterior, holes = []) {
+  return path([exterior, ...holes], true);
+}
+function normalizeRing(ring, eps = 1e-9) {
+  if (ring.length < 2) return ring.map(cloneVec2);
+  const first = ring[0];
+  const last = ring[ring.length - 1];
+  if (first && last && equalsVec2(first, last, eps)) {
+    return ring.slice(0, -1).map(cloneVec2);
+  }
+  return ring.map(cloneVec2);
+}
+function clonePath(p) {
+  return {
+    closed: p.closed,
+    rings: p.rings.map((ring) => ring.map(cloneVec2))
+  };
+}
+
+// src/types/group.ts
+function group(paths = []) {
+  return { paths: paths.map(clonePath) };
+}
+var DEFAULT_FILL_RULE = FillRule.NonZero;
+function ringToPathD(ring) {
+  const pts = [];
+  for (const v of normalizeRing(ring)) {
+    pts.push({ x: v.x, y: v.y, z: 0 });
+  }
+  return pts;
+}
+function pathToPathsD(p) {
+  if (!p.closed || p.rings.length === 0) {
+    throw new Error("Boolean ops require a closed path with at least one ring");
+  }
+  return p.rings.map((ring) => ringToPathD(ring));
+}
+function pathsDToGroup(paths) {
+  if (paths.length === 0) return group([]);
+  const outers = [];
+  const holes = [];
+  for (const pd of paths) {
+    const ring = pathDToRing(pd);
+    if (ring.length < 3) continue;
+    if (isPositiveD(pd)) {
+      outers.push({ ring, holes: [] });
+    } else {
+      holes.push(ring);
+    }
+  }
+  for (const hole of holes) {
+    const sample = hole[0];
+    if (!sample) continue;
+    let assigned = false;
+    for (const outer of outers) {
+      if (pointInRing(sample, outer.ring)) {
+        outer.holes.push(hole);
+        assigned = true;
+        break;
+      }
+    }
+    if (!assigned) {
+      outers.push({ ring: [...hole].reverse(), holes: [] });
+    }
+  }
+  return group(outers.map((o) => path([o.ring, ...o.holes], true)));
+}
+function pathDToRing(pd) {
+  return normalizeRing(pd.map((p) => vec2(p.x, p.y)));
+}
+function pointInRing(point, ring) {
+  const result = pointInPolygonD(
+    { x: point.x, y: point.y, z: 0 },
+    ringToPathD(ring)
+  );
+  return result === PointInPolygonResult.IsInside || result === PointInPolygonResult.IsOn;
+}
+function clipUnion(a, b) {
+  return unionD(a, b, DEFAULT_FILL_RULE);
+}
+function clipIntersect(a, b) {
+  return intersectD(a, b, DEFAULT_FILL_RULE);
+}
+
+// src/predicates/index.ts
+function ringArea(ring) {
+  if (ring.length < 3) return 0;
+  let sum = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % ring.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function centroid(p) {
+  const ring = p.rings[0];
+  if (!ring || ring.length === 0) return vec2(0, 0);
+  const a = ringArea(ring);
+  if (Math.abs(a) < 1e-12) {
+    let sx = 0;
+    let sy = 0;
+    for (const v of ring) {
+      sx += v.x;
+      sy += v.y;
+    }
+    return vec2(sx / ring.length, sy / ring.length);
+  }
+  let cx = 0;
+  let cy = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const p0 = ring[i];
+    const p1 = ring[(i + 1) % ring.length];
+    const cross = p0.x * p1.y - p1.x * p0.y;
+    cx += (p0.x + p1.x) * cross;
+    cy += (p0.y + p1.y) * cross;
+  }
+  return vec2(cx / (6 * a), cy / (6 * a));
+}
+function containsPoint(p, point) {
+  if (!p.closed || !p.rings[0]) return false;
+  if (!pointInRing(point, p.rings[0])) return false;
+  for (let i = 1; i < p.rings.length; i++) {
+    const hole = p.rings[i];
+    if (hole && pointInRing(point, hole)) return false;
+  }
+  return true;
+}
+function bounds(p) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const ring of p.rings) {
+    for (const v of ring) {
+      minX = Math.min(minX, v.x);
+      minY = Math.min(minY, v.y);
+      maxX = Math.max(maxX, v.x);
+      maxY = Math.max(maxY, v.y);
+    }
+  }
+  if (!Number.isFinite(minX)) {
+    return { minX: 0, minY: 0, maxX: 0, maxY: 0 };
+  }
+  return { minX, minY, maxX, maxY };
+}
+
+// src/shapeBoolean/index.ts
+function ensureClosed(p) {
+  if (!p.closed) {
+    throw new Error("shapeBoolean requires closed paths");
+  }
+  return p;
+}
+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);
+}
+
+// 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((ring) => densifyRing(ring, maxSegLen, p.closed)),
+    p.closed
+  );
+}
+function densifyRing(ring, maxSegLen, closed) {
+  if (ring.length < 2) return [...ring];
+  const out = [];
+  const n = ring.length;
+  const edges = closed ? n : n - 1;
+  for (let i = 0; i < edges; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    out.push(a);
+    const dist = Math.hypot(b.x - a.x, b.y - a.y);
+    const steps = Math.floor(dist / maxSegLen);
+    for (let s = 1; s < steps; s++) {
+      const t = s / steps;
+      out.push({
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t
+      });
+    }
+  }
+  if (!closed) out.push(ring[n - 1]);
+  return closed ? normalizeRing(out) : out;
+}
+function removeSmallHoles(p, minArea) {
+  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 >= minArea;
+  });
+  return path([exterior, ...kept], p.closed);
+}
+function generateRandomPoints(p, count, seed = 1) {
+  const rng = mulberry32(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 ring = p.rings[0];
+  if (!ring || ring.length < 2 || count <= 0) return [];
+  const lengths = edgeLengths(ring);
+  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(ring, lengths, target));
+  }
+  return out;
+}
+function segmentsOnExterior(p) {
+  const ring = p.rings[0];
+  if (!ring || ring.length < 2) return [];
+  const n = ring.length;
+  const closed = p.closed;
+  const edges = closed ? n : n - 1;
+  const out = [];
+  for (let i = 0; i < edges; i++) {
+    out.push(segment(ring[i], ring[(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 = segmentIntersection(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 ring of p.rings) {
+    const n = ring.length;
+    const edges = p.closed ? n : Math.max(0, n - 1);
+    for (let i = 0; i < edges; i++) {
+      out.push(segment(ring[i], ring[(i + 1) % n]));
+    }
+  }
+  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 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(ring, closed) {
+  const n = ring.length;
+  const edges = n ;
+  const lengths = [];
+  for (let i = 0; i < edges; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    lengths.push(Math.hypot(b.x - a.x, b.y - a.y));
+  }
+  return lengths;
+}
+function pointAtArcLength(ring, lengths, target) {
+  let remain = target;
+  const n = ring.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 = ring[i];
+      const b = ring[(i + 1) % n];
+      return {
+        x: a.x + (b.x - a.x) * t,
+        y: a.y + (b.y - a.y) * t
+      };
+    }
+    remain -= L;
+  }
+  return { ...ring[0] };
+}
+function shoelace(ring) {
+  let sum = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % ring.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function 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 processing = {
+  extractPerimeter,
+  extractBoundary,
+  extractHoles,
+  densify,
+  removeSmallHoles,
+  generateRandomPoints,
+  generateRandomGridPoints,
+  pointsOnExterior,
+  segmentsOnExterior,
+  slice,
+  centroidSplit,
+  dissolve,
+  intersectionPoints
+};
+
+export { centroidSplit, densify, dissolve, extractBoundary, extractHoles, extractPerimeter, generateRandomGridPoints, generateRandomPoints, intersectionPoints, pointsOnExterior, processing, removeSmallHoles, segmentsOnExterior, slice };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map