@weasel-js/geom 1.10.1 → 1.11.0

package/dist/warp/index.js

@@ -0,0 +1,1316 @@
+import { boundsOfPath, keepCorner, fitPointRun } from '../chunk-HGF5OVEN.js';
+import { pathToAnchors, anchorsToPath } from '../chunk-Q66NA2FU.js';
+import '../chunk-CE7IY7TB.js';
+import { nestRings, flattenPolygon, resolveCrossings } from '../chunk-SASMXDBE.js';
+import { pointInPolygon } from '../chunk-J2O2B54M.js';
+import '../chunk-755Y4YZS.js';
+import { cubicPointAt } from '../chunk-B53BERKG.js';
+import earcut from 'earcut';
+
+// src/warp/quad.ts
+function bilinearQuad(q) {
+  const [a, b, c, d] = q;
+  return (u, v) => {
+    const w00 = (1 - u) * (1 - v);
+    const w10 = u * (1 - v);
+    const w11 = u * v;
+    const w01 = (1 - u) * v;
+    return {
+      x: w00 * a.x + w10 * b.x + w11 * c.x + w01 * d.x,
+      y: w00 * a.y + w10 * b.y + w11 * c.y + w01 * d.y
+    };
+  };
+}
+function squareToQuadHomography(q) {
+  if (!isConvex(q)) return null;
+  const [p0, p1, p2, p3] = q;
+  const sx = p0.x - p1.x + p2.x - p3.x;
+  const sy = p0.y - p1.y + p2.y - p3.y;
+  const dx1 = p1.x - p2.x;
+  const dx2 = p3.x - p2.x;
+  const dy1 = p1.y - p2.y;
+  const dy2 = p3.y - p2.y;
+  const den = dx1 * dy2 - dx2 * dy1;
+  if (den === 0) return null;
+  const g = (sx * dy2 - dx2 * sy) / den;
+  const h = (dx1 * sy - sx * dy1) / den;
+  return [
+    p1.x - p0.x + g * p1.x,
+    p3.x - p0.x + h * p3.x,
+    p0.x,
+    p1.y - p0.y + g * p1.y,
+    p3.y - p0.y + h * p3.y,
+    p0.y,
+    g,
+    h
+  ];
+}
+function projectiveQuad(q) {
+  const m = squareToQuadHomography(q);
+  if (!m) return null;
+  const [a, b, c, d, e, f, g, h] = m;
+  return (u, v) => {
+    const w = g * u + h * v + 1;
+    return { x: (a * u + b * v + c) / w, y: (d * u + e * v + f) / w };
+  };
+}
+function isConvex(q) {
+  let sign = 0;
+  for (let i = 0; i < 4; i++) {
+    const a = q[i];
+    const b = q[(i + 1) % 4];
+    const c = q[(i + 2) % 4];
+    const cross = (b.x - a.x) * (c.y - b.y) - (b.y - a.y) * (c.x - b.x);
+    if (cross === 0) return false;
+    if (sign === 0) sign = Math.sign(cross);
+    else if (Math.sign(cross) !== sign) return false;
+  }
+  return true;
+}
+
+// src/warp/mesh.ts
+function meshGridOver(box, rows, cols) {
+  return meshGridFrom((u, v) => ({ x: box.x + u * box.width, y: box.y + v * box.height }), rows, cols);
+}
+function meshGridFrom(map, rows, cols) {
+  const r = Math.max(1, Math.round(rows));
+  const c = Math.max(1, Math.round(cols));
+  const points = [];
+  for (let i = 0; i <= r; i++) {
+    for (let j = 0; j <= c; j++) points.push(map(j / c, i / r));
+  }
+  return { rows: r, cols: c, points };
+}
+function gridPoint(grid, i, j) {
+  if (i < 0) return extend(gridPoint(grid, 0, j), gridPoint(grid, 1, j));
+  if (i > grid.rows) return extend(gridPoint(grid, grid.rows, j), gridPoint(grid, grid.rows - 1, j));
+  if (j < 0) return extend(gridPoint(grid, i, 0), gridPoint(grid, i, 1));
+  if (j > grid.cols) return extend(gridPoint(grid, i, grid.cols), gridPoint(grid, i, grid.cols - 1));
+  return grid.points[i * (grid.cols + 1) + j];
+}
+var extend = (edge, inner) => ({ x: 2 * edge.x - inner.x, y: 2 * edge.y - inner.y });
+function catmullRom(p0, p1, p2, p3, t) {
+  const t2 = t * t;
+  return 0.5 * (2 * p1 + (p2 - p0) * t + (2 * p0 - 5 * p1 + 4 * p2 - p3) * t2 + (3 * p1 - p0 - 3 * p2 + p3) * t2 * t);
+}
+function catmullRomPoint(p, t) {
+  return {
+    x: catmullRom(p[0].x, p[1].x, p[2].x, p[3].x, t),
+    y: catmullRom(p[0].y, p[1].y, p[2].y, p[3].y, t)
+  };
+}
+function cellOf(s, n) {
+  const k = Math.min(n - 1, Math.max(0, Math.floor(s * n)));
+  return [k, s * n - k];
+}
+function bicubicMesh(grid) {
+  return (u, v) => {
+    const [j, s] = cellOf(u, grid.cols);
+    const [i, t] = cellOf(v, grid.rows);
+    const across = [];
+    for (let di = -1; di <= 2; di++) {
+      across.push(catmullRomPoint([-1, 0, 1, 2].map((dj) => gridPoint(grid, i + di, j + dj)), s));
+    }
+    return catmullRomPoint(across, t);
+  };
+}
+function coonsMesh(grid) {
+  const row = (i, j, s) => catmullRomPoint([-1, 0, 1, 2].map((dj) => gridPoint(grid, i, j + dj)), s);
+  const col = (i, j, t) => catmullRomPoint([-1, 0, 1, 2].map((di) => gridPoint(grid, i + di, j)), t);
+  return (u, v) => {
+    const [j, s] = cellOf(u, grid.cols);
+    const [i, t] = cellOf(v, grid.rows);
+    const top = row(i, j, s);
+    const bottom = row(i + 1, j, s);
+    const left = col(i, j, t);
+    const right = col(i, j + 1, t);
+    const p00 = gridPoint(grid, i, j);
+    const p10 = gridPoint(grid, i, j + 1);
+    const p01 = gridPoint(grid, i + 1, j);
+    const p11 = gridPoint(grid, i + 1, j + 1);
+    const blend = (k) => (1 - t) * top[k] + t * bottom[k] + (1 - s) * left[k] + s * right[k] - ((1 - s) * (1 - t) * p00[k] + s * (1 - t) * p10[k] + (1 - s) * t * p01[k] + s * t * p11[k]);
+    return { x: blend("x"), y: blend("y") };
+  };
+}
+
+// src/warp/profileCholesky.ts
+function symmetricRows(n) {
+  return Array.from({ length: n }, () => /* @__PURE__ */ new Map());
+}
+function addSymmetric(rows, i, j, v) {
+  const [r, c] = i >= j ? [i, j] : [j, i];
+  const row = rows[r];
+  row.set(c, (row.get(c) ?? 0) + v);
+}
+function reverseCuthillMcKee(rows) {
+  const n = rows.length;
+  const adj = Array.from({ length: n }, () => []);
+  rows.forEach((row, i) => row.forEach((_, j) => {
+    if (j !== i) {
+      adj[i].push(j);
+      adj[j].push(i);
+    }
+  }));
+  const degree = adj.map((a) => a.length);
+  const seen = new Uint8Array(n);
+  const order = [];
+  const byDegree = [...Array(n).keys()].sort((a, b) => degree[a] - degree[b]);
+  for (const root of byDegree) {
+    if (seen[root]) continue;
+    seen[root] = 1;
+    const queue = [root];
+    for (let head = 0; head < queue.length; head++) {
+      const v = queue[head];
+      order.push(v);
+      const next = adj[v].filter((w) => !seen[w]).sort((a, b) => degree[a] - degree[b]);
+      for (const w of next) {
+        seen[w] = 1;
+        queue.push(w);
+      }
+    }
+  }
+  return Int32Array.from(order.reverse());
+}
+function factorSymmetric(rows) {
+  const n = rows.length;
+  const order = reverseCuthillMcKee(rows);
+  const at = new Int32Array(n);
+  order.forEach((old, k) => {
+    at[old] = k;
+  });
+  const first = Int32Array.from({ length: n }, (_, k) => k);
+  rows.forEach((row, i) => row.forEach((_, j) => {
+    const a = at[i], b = at[j];
+    const r = Math.max(a, b), c = Math.min(a, b);
+    if (c < first[r]) first[r] = c;
+  }));
+  const start = new Int32Array(n + 1);
+  for (let k = 0; k < n; k++) start[k + 1] = start[k] + (k - first[k] + 1);
+  const L = new Float64Array(start[n]);
+  rows.forEach((row, i) => row.forEach((v, j) => {
+    const a = at[i], b = at[j];
+    const r = Math.max(a, b), c = Math.min(a, b);
+    L[start[r] + c - first[r]] += v;
+  }));
+  for (let i = 0; i < n; i++) {
+    const fi = first[i], si = start[i];
+    for (let j = fi; j <= i; j++) {
+      const fj = first[j], sj = start[j];
+      let sum = L[si + j - fi];
+      for (let k = Math.max(fi, fj); k < j; k++) sum -= L[si + k - fi] * L[sj + k - fj];
+      if (j === i) {
+        if (!(sum > 0)) return null;
+        L[si + i - fi] = Math.sqrt(sum);
+      } else {
+        L[si + j - fi] = sum / L[sj + j - fj];
+      }
+    }
+  }
+  return {
+    solve(b) {
+      const y = new Float64Array(n);
+      for (let k = 0; k < n; k++) y[k] = b[order[k]];
+      for (let i = 0; i < n; i++) {
+        const fi = first[i], si = start[i];
+        let sum = y[i];
+        for (let k = fi; k < i; k++) sum -= L[si + k - fi] * y[k];
+        y[i] = sum / L[si + i - fi];
+      }
+      for (let i = n - 1; i >= 0; i--) {
+        const fi = first[i], si = start[i];
+        y[i] /= L[si + i - fi];
+        const yi = y[i];
+        for (let k = fi; k < i; k++) y[k] -= L[si + k - fi] * yi;
+      }
+      const x = new Float64Array(n);
+      for (let k = 0; k < n; k++) x[order[k]] = y[k];
+      return x;
+    }
+  };
+}
+
+// src/warp/arapSystem.ts
+function split(full, freeIndex) {
+  const nFree = freeIndex.reduce((n, f) => f >= 0 ? n + 1 : n, 0);
+  const rows = symmetricRows(nFree);
+  const coupling = Array.from({ length: nFree }, () => ({ at: [], by: [] }));
+  full.forEach((row, i) => row.forEach((v, j) => {
+    const fi = freeIndex[i] >= 0, fj = freeIndex[j] >= 0;
+    if (fi && fj) addSymmetric(rows, freeIndex[i], freeIndex[j], v);
+    else if (fi) {
+      coupling[freeIndex[i]].at.push(j);
+      coupling[freeIndex[i]].by.push(v);
+    } else if (fj) {
+      coupling[freeIndex[j]].at.push(i);
+      coupling[freeIndex[j]].by.push(v);
+    }
+  }));
+  const factored = factorSymmetric(rows);
+  if (!factored) return null;
+  return { factored, coupling: coupling.map((c) => ({ at: Int32Array.from(c.at), by: Float64Array.from(c.by) })) };
+}
+function solveSplit(s, fixedValue, b) {
+  for (let f = 0; f < s.coupling.length; f++) {
+    const { at, by } = s.coupling[f];
+    for (let k = 0; k < at.length; k++) b[f] -= by[k] * fixedValue(at[k]);
+  }
+  return s.factored.solve(b);
+}
+function similarityEnergy(rest, tris, n) {
+  const rows = symmetricRows(2 * n);
+  const coef = new Float64Array(6);
+  const idx = new Int32Array(6);
+  for (let t = 0; t < tris.length; t += 3) {
+    for (let e = 0; e < 3; e++) {
+      const a = tris[t + e], b = tris[t + (e + 1) % 3], c = tris[t + (e + 2) % 3];
+      const dx = rest[2 * b] - rest[2 * a], dy = rest[2 * b + 1] - rest[2 * a + 1];
+      const ex = rest[2 * c] - rest[2 * a], ey = rest[2 * c + 1] - rest[2 * a + 1];
+      const d2 = dx * dx + dy * dy;
+      if (d2 === 0) continue;
+      const x = (ex * dx + ey * dy) / d2;
+      const y = (ey * dx - ex * dy) / d2;
+      idx.set([2 * a, 2 * a + 1, 2 * b, 2 * b + 1, 2 * c, 2 * c + 1]);
+      for (const r of [[-(1 - x), -y, -x, y, 1, 0], [y, -(1 - x), -y, -x, 0, 1]]) {
+        coef.set(r);
+        for (let i = 0; i < 6; i++) {
+          for (let j = 0; j <= i; j++) if (coef[i] !== 0 && coef[j] !== 0) addSymmetric(rows, idx[i], idx[j], coef[i] * coef[j]);
+        }
+      }
+    }
+  }
+  return rows;
+}
+function edgeEnergy(tris, n) {
+  const rows = symmetricRows(n);
+  for (let t = 0; t < tris.length; t += 3) {
+    for (let e = 0; e < 3; e++) {
+      const i = tris[t + e], j = tris[t + (e + 1) % 3];
+      addSymmetric(rows, i, i, 1);
+      addSymmetric(rows, j, j, 1);
+      addSymmetric(rows, i, j, -1);
+    }
+  }
+  return rows;
+}
+
+// src/warp/injective.ts
+function restFrames(rest, tris) {
+  const nt = tris.length / 3;
+  const inv = new Float64Array(4 * nt), area = new Float64Array(nt);
+  for (let t = 0; t < nt; t++) {
+    const a = tris[3 * t], b = tris[3 * t + 1], c = tris[3 * t + 2];
+    const ux = rest[2 * b] - rest[2 * a], uy = rest[2 * b + 1] - rest[2 * a + 1];
+    const vx = rest[2 * c] - rest[2 * a], vy = rest[2 * c + 1] - rest[2 * a + 1];
+    const det = ux * vy - uy * vx;
+    if (det === 0) continue;
+    inv.set([vy / det, -vx / det, -uy / det, ux / det], 4 * t);
+    area[t] = Math.abs(det) / 2;
+  }
+  return { inv, area };
+}
+var FLIP_MARGIN = 0.8;
+var ARMIJO = 1e-4;
+var AREA = 1;
+function jacobian(piece, pos, t, J) {
+  const { tris, frames } = piece;
+  if (frames.area[t] === 0) return false;
+  const a = tris[3 * t], b = tris[3 * t + 1], c = tris[3 * t + 2];
+  const ux = pos[2 * b] - pos[2 * a], uy = pos[2 * b + 1] - pos[2 * a + 1];
+  const vx = pos[2 * c] - pos[2 * a], vy = pos[2 * c + 1] - pos[2 * a + 1];
+  const m = frames.inv;
+  const i = 4 * t;
+  J[0] = ux * m[i] + vx * m[i + 2];
+  J[1] = ux * m[i + 1] + vx * m[i + 3];
+  J[2] = uy * m[i] + vy * m[i + 2];
+  J[3] = uy * m[i + 1] + vy * m[i + 3];
+  return true;
+}
+function flipBound(piece, pos, d) {
+  const { tris, rest } = piece;
+  let bound = Infinity;
+  for (let t = 0; t < tris.length; t += 3) {
+    const a = tris[t], b = tris[t + 1], c = tris[t + 2];
+    const side = Math.sign((rest[2 * b] - rest[2 * a]) * (rest[2 * c + 1] - rest[2 * a + 1]) - (rest[2 * b + 1] - rest[2 * a + 1]) * (rest[2 * c] - rest[2 * a]));
+    if (side === 0) continue;
+    const ux = pos[2 * b] - pos[2 * a], uy = pos[2 * b + 1] - pos[2 * a + 1];
+    const vx = pos[2 * c] - pos[2 * a], vy = pos[2 * c + 1] - pos[2 * a + 1];
+    const dux = d[2 * b] - d[2 * a], duy = d[2 * b + 1] - d[2 * a + 1];
+    const dvx = d[2 * c] - d[2 * a], dvy = d[2 * c + 1] - d[2 * a + 1];
+    const c0 = side * (ux * vy - uy * vx);
+    const c1 = side * (ux * dvy - uy * dvx + dux * vy - duy * vx);
+    const c2 = side * (dux * dvy - duy * dvx);
+    if (c0 <= 0) return 0;
+    bound = Math.min(bound, smallestPositiveRoot(c0, c1, c2));
+  }
+  return bound;
+}
+function smallestPositiveRoot(c0, c1, c2) {
+  if (Math.abs(c2) < 1e-14 * (Math.abs(c1) + Math.abs(c0))) return c1 < 0 ? -c0 / c1 : Infinity;
+  const disc = c1 * c1 - 4 * c2 * c0;
+  if (disc < 0) return Infinity;
+  const q = -0.5 * (c1 + Math.sign(c1 || 1) * Math.sqrt(disc));
+  const roots = [q / c2, c0 / q].filter((s) => s > 0 && Number.isFinite(s));
+  return roots.length ? Math.min(...roots) : Infinity;
+}
+var chi = (d, eps) => (d + Math.sqrt(eps * eps + d * d)) / 2;
+function untangleEnergy(piece, pos, eps) {
+  const J = new Float64Array(4);
+  const { area } = piece.frames;
+  let E = 0;
+  for (let t = 0; t < area.length; t++) {
+    if (!jacobian(piece, pos, t, J)) continue;
+    const d = J[0] * J[3] - J[1] * J[2];
+    const c = chi(d, eps);
+    if (!(c > 0)) return Infinity;
+    E += area[t] * (J[0] * J[0] + J[1] * J[1] + J[2] * J[2] + J[3] * J[3] + AREA * (d * d + 1)) / c;
+  }
+  return E;
+}
+function leastArea(piece, pos) {
+  const J = new Float64Array(4);
+  let least = Infinity;
+  for (let t = 0; t < piece.frames.area.length; t++) {
+    if (jacobian(piece, pos, t, J)) least = Math.min(least, J[0] * J[3] - J[1] * J[2]);
+  }
+  return least;
+}
+function gradient(piece, pos, eps) {
+  const { tris, frames } = piece;
+  const g = new Float64Array(pos.length);
+  const J = new Float64Array(4);
+  for (let t = 0; t < frames.area.length; t++) {
+    if (!jacobian(piece, pos, t, J)) continue;
+    const d = J[0] * J[3] - J[1] * J[2];
+    const root = Math.sqrt(eps * eps + d * d);
+    const c = (d + root) / 2;
+    const A = frames.area[t];
+    const top = J[0] * J[0] + J[1] * J[1] + J[2] * J[2] + J[3] * J[3] + AREA * (d * d + 1);
+    const dc = root === 0 ? 0.5 : (1 + d / root) / 2;
+    const s = 2 * A / c, r = A * (2 * AREA * d / c - top * dc / (c * c));
+    const g0 = s * J[0] + r * J[3], g1 = s * J[1] - r * J[2], g2 = s * J[2] - r * J[1], g3 = s * J[3] + r * J[0];
+    const m = frames.inv, i = 4 * t;
+    const gux = g0 * m[i] + g1 * m[i + 1], gvx = g0 * m[i + 2] + g1 * m[i + 3];
+    const guy = g2 * m[i] + g3 * m[i + 1], gvy = g2 * m[i + 2] + g3 * m[i + 3];
+    const a = tris[3 * t], b = tris[3 * t + 1], cc = tris[3 * t + 2];
+    g[2 * b] += gux;
+    g[2 * b + 1] += guy;
+    g[2 * cc] += gvx;
+    g[2 * cc + 1] += gvy;
+    g[2 * a] -= gux + gvx;
+    g[2 * a + 1] -= guy + gvy;
+  }
+  return g;
+}
+function turnedOver(piece, pos) {
+  return flipBound(piece, pos, new Float64Array(pos.length)) === 0;
+}
+function startingEps(piece, pos) {
+  return Math.max(1e-3, 2 * Math.abs(Math.min(0, leastArea(piece, pos))));
+}
+function nextEps(piece, pos, eps, before, after) {
+  const least = leastArea(piece, pos);
+  const sigma = Math.max(1 - after / before, 0.1);
+  const mu = (1 - sigma) * chi(least, eps);
+  return least < mu ? 2 * Math.sqrt(mu * (mu - least)) : 0;
+}
+function untangleRound(piece, pos, eps, energy) {
+  const { pinOf, freeOf, step2 } = piece;
+  const g = gradient(piece, pos, eps);
+  const nf = step2.coupling.length;
+  const bx = new Float64Array(nf), by = new Float64Array(nf);
+  for (let i = 0; i < pinOf.length; i++) {
+    if (freeOf[i] >= 0) {
+      bx[freeOf[i]] = -g[2 * i];
+      by[freeOf[i]] = -g[2 * i + 1];
+    }
+  }
+  const dx = solveSplit(step2, () => 0, bx);
+  const dy = solveSplit(step2, () => 0, by);
+  const d = new Float64Array(pos.length);
+  let slope = 0;
+  for (let i = 0; i < pinOf.length; i++) {
+    const f = freeOf[i];
+    if (f < 0) continue;
+    d[2 * i] = dx[f];
+    d[2 * i + 1] = dy[f];
+    slope += g[2 * i] * dx[f] + g[2 * i + 1] * dy[f];
+  }
+  let s = eps > 0 ? 1 : Math.min(1, FLIP_MARGIN * flipBound(piece, pos, d));
+  const next = new Float64Array(pos.length);
+  for (; s > 1e-12; s /= 2) {
+    for (let i = 0; i < next.length; i++) next[i] = pos[i] + s * d[i];
+    const e = untangleEnergy(piece, next, eps);
+    if (e <= energy + ARMIJO * s * slope) {
+      let moved = 0;
+      for (let i = 0; i < d.length; i += 2) moved = Math.max(moved, s * Math.hypot(d[i], d[i + 1]));
+      return { pos: next, energy: e, moved };
+    }
+  }
+  return { pos, energy, moved: 0 };
+}
+
+// src/warp/arapPiece.ts
+function buildPiece(mesh, verts, tris, pinAt, local) {
+  const n = verts.length;
+  verts.forEach((v, i) => {
+    local[v] = i;
+  });
+  const rest = new Float64Array(2 * n);
+  verts.forEach((v, i) => {
+    rest[2 * i] = mesh.vertices[2 * v];
+    rest[2 * i + 1] = mesh.vertices[2 * v + 1];
+  });
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (let i = 0; i < 2 * n; i += 2) {
+    x0 = Math.min(x0, rest[i]);
+    x1 = Math.max(x1, rest[i]);
+    y0 = Math.min(y0, rest[i + 1]);
+    y1 = Math.max(y1, rest[i + 1]);
+  }
+  const T = mesh.triangles;
+  const lt = new Int32Array(3 * tris.length);
+  tris.forEach((t, k) => {
+    for (let c = 0; c < 3; c++) lt[3 * k + c] = local[T[3 * t + c]];
+  });
+  const pinOf = Int32Array.from(verts, (v) => pinAt.get(v) ?? -1);
+  const freeOf = new Int32Array(n).fill(-1);
+  let nf = 0;
+  for (let i = 0; i < n; i++) if (pinOf[i] < 0) freeOf[i] = nf++;
+  const free2 = Int32Array.from({ length: 2 * n }, (_, u) => freeOf[u >> 1] < 0 ? -1 : 2 * freeOf[u >> 1] + (u & 1));
+  const step1 = split(similarityEnergy(rest, lt, n), free2);
+  const step2 = split(edgeEnergy(lt, n), freeOf);
+  if (!step1 || !step2) return null;
+  return { verts: Int32Array.from(verts), rest, size: Math.max(x1 - x0, y1 - y0), tris: lt, pinOf, freeOf, step1, step2, frames: restFrames(rest, lt) };
+}
+function similaritySolve(piece, targets) {
+  const { pinOf, freeOf, step1 } = piece;
+  const x = solveSplit(step1, (u) => targets[2 * pinOf[u >> 1] + (u & 1)], new Float64Array(step1.coupling.length));
+  const pos = new Float64Array(2 * pinOf.length);
+  for (let i = 0; i < pinOf.length; i++) {
+    for (let c = 0; c < 2; c++) pos[2 * i + c] = pinOf[i] >= 0 ? targets[2 * pinOf[i] + c] : x[2 * freeOf[i] + c];
+  }
+  return pos;
+}
+function rigidRound(piece, targets, pos) {
+  const { rest, tris, pinOf, freeOf, step2 } = piece;
+  const nf = step2.coupling.length;
+  const bx = new Float64Array(nf), by = new Float64Array(nf);
+  let energy = 0;
+  for (let t = 0; t < tris.length; t += 3) {
+    let dot = 0, cross = 0, sq = 0;
+    for (let e = 0; e < 3; e++) {
+      const i = tris[t + e], j = tris[t + (e + 1) % 3];
+      const px = rest[2 * i] - rest[2 * j], py = rest[2 * i + 1] - rest[2 * j + 1];
+      const qx = pos[2 * i] - pos[2 * j], qy = pos[2 * i + 1] - pos[2 * j + 1];
+      dot += px * qx + py * qy;
+      cross += px * qy - py * qx;
+      sq += px * px + py * py + qx * qx + qy * qy;
+    }
+    const len = Math.hypot(dot, cross);
+    energy += sq - 2 * len;
+    const cos = len === 0 ? 1 : dot / len, sin = len === 0 ? 0 : cross / len;
+    for (let e = 0; e < 3; e++) {
+      const i = tris[t + e], j = tris[t + (e + 1) % 3];
+      const ex = rest[2 * i] - rest[2 * j], ey = rest[2 * i + 1] - rest[2 * j + 1];
+      const fx = cos * ex - sin * ey, fy = sin * ex + cos * ey;
+      if (freeOf[i] >= 0) {
+        bx[freeOf[i]] += fx;
+        by[freeOf[i]] += fy;
+      }
+      if (freeOf[j] >= 0) {
+        bx[freeOf[j]] -= fx;
+        by[freeOf[j]] -= fy;
+      }
+    }
+  }
+  const x = solveSplit(step2, (u) => targets[2 * pinOf[u]], bx);
+  const y = solveSplit(step2, (u) => targets[2 * pinOf[u] + 1], by);
+  const out = new Float64Array(pos.length);
+  for (let i = 0; i < pinOf.length; i++) {
+    const p = pinOf[i];
+    out[2 * i] = p >= 0 ? targets[2 * p] : x[freeOf[i]];
+    out[2 * i + 1] = p >= 0 ? targets[2 * p + 1] : y[freeOf[i]];
+  }
+  return { pos: out, energy };
+}
+function placePiece(piece, pos, out) {
+  piece.verts.forEach((v, i) => {
+    out[2 * v] = pos[2 * i];
+    out[2 * v + 1] = pos[2 * i + 1];
+  });
+}
+
+// src/warp/arap.ts
+var ARAP_ROUNDS = 5;
+var ARAP_INJECTIVE_ROUNDS = 100;
+var SETTLED = 1e-4;
+function piecesOf(mesh) {
+  const n = mesh.vertices.length >> 1;
+  const parent = Int32Array.from({ length: n }, (_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) {
+      parent[i] = parent[parent[i]];
+      i = parent[i];
+    }
+    return i;
+  };
+  const T = mesh.triangles;
+  for (let t = 0; t + 2 < T.length; t += 3) {
+    parent[find(T[t + 1])] = find(T[t]);
+    parent[find(T[t + 2])] = find(T[t]);
+  }
+  const byRoot = /* @__PURE__ */ new Map();
+  const used = new Uint8Array(n);
+  for (let t = 0; t + 2 < T.length; t += 3) {
+    const r = find(T[t]);
+    let p = byRoot.get(r);
+    if (!p) {
+      p = { verts: [], tris: [] };
+      byRoot.set(r, p);
+    }
+    p.tris.push(t / 3);
+    for (let k = 0; k < 3; k++) if (!used[T[t + k]]) {
+      used[T[t + k]] = 1;
+      p.verts.push(T[t + k]);
+    }
+  }
+  return [...byRoot.values()];
+}
+function largestMove(a, b) {
+  let m = 0;
+  for (let i = 0; i < a.length; i += 2) m = Math.max(m, Math.hypot(b[i] - a[i], b[i + 1] - a[i + 1]));
+  return m;
+}
+function rigidFit(from, to) {
+  const k = from.length >> 1;
+  let pcx = 0, pcy = 0, qcx = 0, qcy = 0;
+  for (let i = 0; i < k; i++) {
+    pcx += from[2 * i];
+    pcy += from[2 * i + 1];
+    qcx += to[2 * i];
+    qcy += to[2 * i + 1];
+  }
+  pcx /= k;
+  pcy /= k;
+  qcx /= k;
+  qcy /= k;
+  let dot = 0, cross = 0;
+  for (let i = 0; i < k; i++) {
+    const px = from[2 * i] - pcx, py = from[2 * i + 1] - pcy;
+    const qx = to[2 * i] - qcx, qy = to[2 * i + 1] - qcy;
+    dot += px * qx + py * qy;
+    cross += px * qy - py * qx;
+  }
+  const len = Math.hypot(dot, cross);
+  const cos = len === 0 ? 1 : dot / len, sin = len === 0 ? 0 : cross / len;
+  return (x, y) => [cos * (x - pcx) - sin * (y - pcy) + qcx, sin * (x - pcx) + cos * (y - pcy) + qcy];
+}
+function createArapSolver(mesh, pinned) {
+  const n = mesh.vertices.length >> 1;
+  const pinAt = /* @__PURE__ */ new Map();
+  pinned.forEach((v, k) => {
+    if (!pinAt.has(v)) pinAt.set(v, k);
+  });
+  const local = new Int32Array(n);
+  const pinFrom = pinned.flatMap((v) => [mesh.vertices[2 * v], mesh.vertices[2 * v + 1]]);
+  const solved = [];
+  const carried = [];
+  for (const p of piecesOf(mesh)) {
+    const pins = [...new Set(p.verts.filter((v) => pinAt.has(v)).map((v) => pinAt.get(v)))];
+    const piece = pins.length >= 2 ? buildPiece(mesh, p.verts, p.tris, pinAt, local) : null;
+    if (piece) solved.push(piece);
+    else carried.push({ verts: p.verts, pin: pins.length === 1 ? pins[0] : -1 });
+  }
+  return {
+    solve(targets, opts = {}) {
+      const out = Float64Array.from(mesh.vertices);
+      const whole = carried.some((c) => c.pin < 0) && pinned.length > 0 ? rigidFit(pinFrom, targets) : null;
+      for (const { verts, pin } of carried) {
+        for (const v of verts) {
+          const x = mesh.vertices[2 * v], y = mesh.vertices[2 * v + 1];
+          if (pin >= 0) {
+            out[2 * v] = x + targets[2 * pin] - pinFrom[2 * pin];
+            out[2 * v + 1] = y + targets[2 * pin + 1] - pinFrom[2 * pin + 1];
+          } else if (whole) {
+            [out[2 * v], out[2 * v + 1]] = whole(x, y);
+          }
+        }
+      }
+      const { trace } = opts;
+      const report = (stage, round) => trace?.({ stage, round, vertices: Float64Array.from(out) });
+      const pos = solved.map((piece) => similaritySolve(piece, targets));
+      solved.forEach((piece, k) => placePiece(piece, pos[k], out));
+      report("similarity", 1);
+      solved.forEach((piece, k) => {
+        pos[k] = rigidRound(piece, targets, pos[k]).pos;
+        placePiece(piece, pos[k], out);
+      });
+      report("rigid", 1);
+      const rounds = Math.max(0, Math.floor(opts.iterations ?? ARAP_ROUNDS));
+      const live = solved.map(() => true);
+      for (let r = 1; r <= rounds && live.some(Boolean); r++) {
+        solved.forEach((piece, k) => {
+          if (!live[k]) return;
+          const next = rigidRound(piece, targets, pos[k]).pos;
+          live[k] = largestMove(pos[k], next) > SETTLED * piece.size;
+          pos[k] = next;
+          placePiece(piece, next, out);
+        });
+        report("local-global", r);
+      }
+      const injective = Math.max(0, Math.floor(opts.injectiveIterations ?? ARAP_INJECTIVE_ROUNDS));
+      const tangled = solved.map((piece, k) => injective > 0 && turnedOver(piece, pos[k]));
+      if (tangled.some(Boolean)) {
+        const state = solved.map((piece, k) => {
+          const eps = tangled[k] ? startingEps(piece, pos[k]) : 0;
+          return { pos: pos[k], eps, energy: tangled[k] ? untangleEnergy(piece, pos[k], eps) : 0, live: tangled[k] };
+        });
+        let r = 1;
+        for (; r <= injective && state.some((s) => s.live); r++) {
+          solved.forEach((piece, k) => {
+            const s = state[k];
+            if (!s.live) return;
+            const step = untangleRound(piece, s.pos, s.eps, s.energy);
+            const settled = step.moved <= SETTLED * piece.size || s.energy - step.energy <= SETTLED * step.energy;
+            s.pos = step.pos;
+            if (s.eps > 0) {
+              s.eps = nextEps(piece, s.pos, s.eps, s.energy, step.energy);
+              s.energy = untangleEnergy(piece, s.pos, s.eps);
+            } else {
+              s.energy = step.energy;
+              s.live = !settled;
+            }
+            placePiece(piece, s.pos, out);
+          });
+          report("injective", r);
+        }
+        let fell = false;
+        solved.forEach((piece, k) => {
+          if (!tangled[k] || !turnedOver(piece, state[k].pos)) return;
+          placePiece(piece, pos[k], out);
+          fell = true;
+        });
+        if (fell) report("injective", r);
+      }
+      return out;
+    }
+  };
+}
+
+// src/warp/meshMap.ts
+var EPS = 1e-9;
+function weights(V, T, t, x, y) {
+  const a = T[3 * t], b = T[3 * t + 1], c = T[3 * t + 2];
+  const ax = V[2 * a], ay = V[2 * a + 1];
+  const bx = V[2 * b] - ax, by = V[2 * b + 1] - ay;
+  const cx = V[2 * c] - ax, cy = V[2 * c + 1] - ay;
+  const det = bx * cy - by * cx;
+  if (det === 0) return null;
+  const px = x - ax, py = y - ay;
+  const w1 = (px * cy - py * cx) / det;
+  const w2 = (bx * py - by * px) / det;
+  return { tri: t, w0: 1 - w1 - w2, w1, w2 };
+}
+var outside = (s) => Math.max(0, -s.w0, -s.w1, -s.w2);
+function meshLocator(mesh) {
+  const V = mesh.vertices, T = mesh.triangles;
+  const nt = T.length / 3;
+  if (nt === 0) return () => null;
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (let i = 0; i < V.length; i += 2) {
+    x0 = Math.min(x0, V[i]);
+    x1 = Math.max(x1, V[i]);
+    y0 = Math.min(y0, V[i + 1]);
+    y1 = Math.max(y1, V[i + 1]);
+  }
+  const side = Math.max(1, Math.ceil(Math.sqrt(nt)));
+  const cw = (x1 - x0) / side || 1, ch = (y1 - y0) / side || 1;
+  const cell = (v, o, s) => Math.min(side - 1, Math.max(0, Math.floor((v - o) / s)));
+  const buckets = Array.from({ length: side * side }, () => []);
+  for (let t = 0; t < nt; t++) {
+    let tx0 = Infinity, ty0 = Infinity, tx1 = -Infinity, ty1 = -Infinity;
+    for (let k = 0; k < 3; k++) {
+      const v = T[3 * t + k];
+      tx0 = Math.min(tx0, V[2 * v]);
+      tx1 = Math.max(tx1, V[2 * v]);
+      ty0 = Math.min(ty0, V[2 * v + 1]);
+      ty1 = Math.max(ty1, V[2 * v + 1]);
+    }
+    for (let i = cell(tx0, x0, cw); i <= cell(tx1, x0, cw); i++) {
+      for (let j = cell(ty0, y0, ch); j <= cell(ty1, y0, ch); j++) buckets[j * side + i].push(t);
+    }
+  }
+  return (x, y) => {
+    const ci = cell(x, x0, cw), cj = cell(y, y0, ch);
+    let best = null;
+    let bestOut = Infinity;
+    for (let r = 0; r < side; r++) {
+      for (let i = ci - r; i <= ci + r; i++) {
+        for (let j = cj - r; j <= cj + r; j++) {
+          if (i < 0 || j < 0 || i >= side || j >= side) continue;
+          if (Math.max(Math.abs(i - ci), Math.abs(j - cj)) !== r) continue;
+          for (const t of buckets[j * side + i]) {
+            const s = weights(V, T, t, x, y);
+            if (!s) continue;
+            const o = outside(s);
+            if (o <= EPS) return s;
+            if (o < bestOut) {
+              bestOut = o;
+              best = s;
+            }
+          }
+        }
+      }
+      if (best && r >= 1) return best;
+    }
+    return best;
+  };
+}
+function placeSpot(T, at, s) {
+  const a = T[3 * s.tri], b = T[3 * s.tri + 1], c = T[3 * s.tri + 2];
+  return {
+    x: s.w0 * at[2 * a] + s.w1 * at[2 * b] + s.w2 * at[2 * c],
+    y: s.w0 * at[2 * a + 1] + s.w1 * at[2 * b + 1] + s.w2 * at[2 * c + 1]
+  };
+}
+
+// src/warp/refine.ts
+function orient(V, a, b, c) {
+  return (V[2 * b] - V[2 * a]) * (V[2 * c + 1] - V[2 * a + 1]) - (V[2 * b + 1] - V[2 * a + 1]) * (V[2 * c] - V[2 * a]);
+}
+function inCircle(V, a, b, c, d) {
+  const ax = V[2 * a] - V[2 * d], ay = V[2 * a + 1] - V[2 * d + 1];
+  const bx = V[2 * b] - V[2 * d], by = V[2 * b + 1] - V[2 * d + 1];
+  const cx = V[2 * c] - V[2 * d], cy = V[2 * c + 1] - V[2 * d + 1];
+  const det = (ax * ax + ay * ay) * (bx * cy - cx * by) - (bx * bx + by * by) * (ax * cy - cx * ay) + (cx * cx + cy * cy) * (ax * by - bx * ay);
+  return det > 1e-12 * (ax * ax + ay * ay + bx * bx + by * by + cx * cx + cy * cy) ** 2;
+}
+var Triangulation = class {
+  constructor(V, stride) {
+    this.V = V;
+    this.stride = stride;
+  }
+  V;
+  stride;
+  tris = [];
+  /** Directed edge `a→b` to the triangle having it, counter-clockwise. */
+  owner = /* @__PURE__ */ new Map();
+  free = [];
+  /** The triangle made last, where the next point's search starts. */
+  last = 0;
+  key(a, b) {
+    return a * this.stride + b;
+  }
+  add(a, b, c) {
+    const t = this.free.pop() ?? this.tris.length / 3;
+    this.last = t;
+    this.tris[3 * t] = a;
+    this.tris[3 * t + 1] = b;
+    this.tris[3 * t + 2] = c;
+    this.owner.set(this.key(a, b), t);
+    this.owner.set(this.key(b, c), t);
+    this.owner.set(this.key(c, a), t);
+    return t;
+  }
+  remove(t) {
+    const [a, b, c] = this.corners(t);
+    for (const [u, v] of [[a, b], [b, c], [c, a]]) if (this.owner.get(this.key(u, v)) === t) this.owner.delete(this.key(u, v));
+    this.tris[3 * t] = -1;
+    this.free.push(t);
+  }
+  corners(t) {
+    return [this.tris[3 * t], this.tris[3 * t + 1], this.tris[3 * t + 2]];
+  }
+  /** The triangle across edge `a→b` and its corner off that edge, if any. */
+  across(a, b) {
+    const t = this.owner.get(this.key(b, a));
+    if (t === void 0) return null;
+    const [x, y, z] = this.corners(t);
+    return { t, c: x !== a && x !== b ? x : y !== a && y !== b ? y : z };
+  }
+  /** Flip edge `a→b` of the triangle `(a, b, p)` while the triangle across it disagrees. */
+  legalize(a, b, p) {
+    const stack = [[a, b, p]];
+    while (stack.length > 0) {
+      const [u, v, w] = stack.pop();
+      const mine = this.owner.get(this.key(u, v));
+      const other = this.across(u, v);
+      if (mine === void 0 || !other || !inCircle(this.V, u, v, w, other.c)) continue;
+      const q = other.c;
+      if (orient(this.V, u, q, w) <= 0 || orient(this.V, q, v, w) <= 0) continue;
+      this.remove(mine);
+      this.remove(other.t);
+      this.add(u, q, w);
+      this.add(q, v, w);
+      stack.push([u, q, w], [q, v, w]);
+    }
+  }
+  /** Whether triangle `t` holds `p`, and on which edge if on one: -1 outside, 3 strictly inside. */
+  holds(t, p) {
+    const V = this.V;
+    const [a, b, c] = this.corners(t);
+    const area = orient(V, a, b, c);
+    const ws = [orient(V, b, c, p), orient(V, c, a, p), orient(V, a, b, p)];
+    if (ws.some((w) => w < -1e-9 * area)) return -1;
+    const flat = ws.findIndex((w) => w <= 1e-9 * area);
+    return flat < 0 ? 3 : flat;
+  }
+  /** The triangle holding `p`: walked to from `from` across the edges `p` lies beyond, or
+   *  found by a scan when the walk leaves the region. */
+  locate(p, from) {
+    let t = from;
+    for (let step = 0; t >= 0 && this.tris[3 * t] >= 0 && step < this.tris.length; step++) {
+      const on = this.holds(t, p);
+      if (on >= 0) return { t, on };
+      const [a, b, c] = this.corners(t);
+      const edge = [[b, c], [c, a], [a, b]].find(([u, v]) => orient(this.V, u, v, p) < 0);
+      t = this.across(edge[0], edge[1])?.t ?? -1;
+    }
+    for (let s = 0; s < this.tris.length / 3; s++) {
+      if (this.tris[3 * s] < 0) continue;
+      const on = this.holds(s, p);
+      if (on >= 0) return { t: s, on };
+    }
+    return null;
+  }
+  /** Split the triangle holding `p` (or the two sharing the edge it lies on). False when none holds it. */
+  insert(p) {
+    const found = this.locate(p, this.last);
+    if (!found) return false;
+    const { t } = found;
+    const [a, b, c] = this.corners(t);
+    const flat = found.on === 3 ? -1 : found.on;
+    if (flat < 0) {
+      this.remove(t);
+      this.add(a, b, p);
+      this.add(b, c, p);
+      this.add(c, a, p);
+      this.legalize(a, b, p);
+      this.legalize(b, c, p);
+      this.legalize(c, a, p);
+      return true;
+    }
+    const [u, v, w] = [[b, c, a], [c, a, b], [a, b, c]][flat];
+    const other = this.across(u, v);
+    this.remove(t);
+    this.add(v, w, p);
+    this.add(w, u, p);
+    const rim = [[v, w], [w, u]];
+    if (other) {
+      this.remove(other.t);
+      this.add(u, other.c, p);
+      this.add(other.c, v, p);
+      rim.push([u, other.c], [other.c, v]);
+    }
+    for (const [x, y] of rim) this.legalize(x, y, p);
+    return true;
+  }
+};
+function refineTriangulation(coords, triangles, firstInner) {
+  const n = coords.length / 2;
+  const mesh = new Triangulation(coords, n);
+  for (let i = 0; i + 2 < triangles.length; i += 3) {
+    const [a, b, c] = [triangles[i], triangles[i + 1], triangles[i + 2]];
+    const o = orient(coords, a, b, c);
+    if (o > 0) mesh.add(a, b, c);
+    else if (o < 0) mesh.add(a, c, b);
+  }
+  const live = () => Array.from({ length: mesh.tris.length / 3 }, (_, t) => t).filter((t) => mesh.tris[3 * t] >= 0);
+  for (const t of live()) {
+    if (mesh.tris[3 * t] < 0) continue;
+    const [a, b, c] = mesh.corners(t);
+    mesh.legalize(a, b, c);
+    mesh.legalize(b, c, a);
+    mesh.legalize(c, a, b);
+  }
+  for (let p = firstInner; p < n; p++) mesh.insert(p);
+  return live().flatMap((t) => mesh.corners(t));
+}
+
+// src/warp/puppetMesh.ts
+function ringsOf(path, tolerance) {
+  const flat = flattenPolygon(path, tolerance);
+  if (path.fillRule === "evenodd") return { flat, filled: (w) => w % 2 !== 0 };
+  const crossed = resolveCrossings(flat);
+  const nonzero = (w) => w !== 0;
+  if (crossed) return { flat: crossed, filled: nonzero };
+  const simple = nestRings(flat).every((r) => Math.abs(r.winding) <= 1);
+  return { flat: simple ? flat : resolveCrossings(flat, true), filled: nonzero };
+}
+function resample(coords, start, end, h) {
+  const out = [];
+  for (let i = start; i < end; i++) {
+    const j = i + 1 === end ? start : i + 1;
+    const ax = coords[2 * i], ay = coords[2 * i + 1];
+    const steps = Math.max(1, Math.ceil(Math.hypot(coords[2 * j] - ax, coords[2 * j + 1] - ay) / h));
+    for (let k = 0; k < steps; k++) {
+      const t = k / steps;
+      out.push({ x: ax + (coords[2 * j] - ax) * t, y: ay + (coords[2 * j + 1] - ay) * t, pins: [] });
+    }
+  }
+  return out.filter((p, i) => {
+    const q = out[(i + 1) % out.length];
+    return out.length < 2 || p.x !== q.x || p.y !== q.y;
+  });
+}
+function regionsOf(path, tolerance, h) {
+  const { flat, filled } = ringsOf(path, tolerance);
+  const rings = nestRings(flat);
+  const regions = /* @__PURE__ */ new Map();
+  let area = 0;
+  rings.forEach((r, i) => {
+    if (r.area === 0 || !filled(r.winding)) return;
+    if (r.parent >= 0 && filled(rings[r.parent].winding)) return;
+    regions.set(i, { rings: [resample(flat.coords, r.start, r.end, h)], inner: [] });
+    area += Math.abs(r.area);
+  });
+  rings.forEach((r) => {
+    const outer = r.area !== 0 && !filled(r.winding) ? regions.get(r.parent) : void 0;
+    if (!outer) return;
+    outer.rings.push(resample(flat.coords, r.start, r.end, h));
+    area -= Math.abs(r.area);
+  });
+  return { regions: [...regions.values()], area };
+}
+var flatRing = (ring) => ring.flatMap((p) => [p.x, p.y]);
+function inside(region, x, y, flats = region.rings.map(flatRing)) {
+  return flats.every((ring, i) => pointInPolygon(ring, x, y) === (i === 0));
+}
+function nearestEdge(region, x, y) {
+  let best = { d: Infinity, ring: 0, edge: 0, t: 0 };
+  region.rings.forEach((ring, r) => ring.forEach((a, i) => {
+    const b = ring[(i + 1) % ring.length];
+    const dx = b.x - a.x, dy = b.y - a.y;
+    const len2 = dx * dx + dy * dy;
+    const t = len2 > 0 ? Math.max(0, Math.min(1, ((x - a.x) * dx + (y - a.y) * dy) / len2)) : 0;
+    const d = Math.hypot(a.x + dx * t - x, a.y + dy * t - y);
+    if (d < best.d) best = { d, ring: r, edge: i, t };
+  }));
+  return best;
+}
+function placePin(regions, pin, k, h) {
+  const home = regions.find((r) => inside(r, pin.x, pin.y));
+  const near = (home ? [home] : regions).map((region) => ({ region, ...nearestEdge(region, pin.x, pin.y) })).reduce((a2, b2) => b2.d < a2.d ? b2 : a2);
+  const snap = 0.25 * h;
+  if (home && near.d > snap) {
+    const same = home.inner.find((p) => Math.hypot(p.x - pin.x, p.y - pin.y) < 1e-9 * h);
+    if (same) same.pins.push(k);
+    else home.inner.push({ x: pin.x, y: pin.y, pins: [k] });
+    return;
+  }
+  const ring = near.region.rings[near.ring];
+  const a = ring[near.edge], b = ring[(near.edge + 1) % ring.length];
+  const at = { x: a.x + (b.x - a.x) * near.t, y: a.y + (b.y - a.y) * near.t };
+  const da = Math.hypot(at.x - a.x, at.y - a.y), db = Math.hypot(at.x - b.x, at.y - b.y);
+  if (Math.min(da, db) <= snap) (da <= db ? a : b).pins.push(k);
+  else ring.splice(near.edge + 1, 0, { ...at, pins: [k] });
+}
+function clearanceTest(rings, r) {
+  const cells = /* @__PURE__ */ new Map();
+  const key = (i, j) => `${i},${j}`;
+  for (const ring of rings) {
+    ring.forEach((a, n) => {
+      const b = ring[(n + 1) % ring.length];
+      for (let i = Math.floor(Math.min(a.x, b.x) / r); i <= Math.floor(Math.max(a.x, b.x) / r); i++) {
+        for (let j = Math.floor(Math.min(a.y, b.y) / r); j <= Math.floor(Math.max(a.y, b.y) / r); j++) {
+          const k = key(i, j);
+          const list = cells.get(k);
+          if (list) list.push([a, b]);
+          else cells.set(k, [[a, b]]);
+        }
+      }
+    });
+  }
+  return (x, y) => {
+    const ci = Math.floor(x / r), cj = Math.floor(y / r);
+    for (let i = ci - 1; i <= ci + 1; i++) {
+      for (let j = cj - 1; j <= cj + 1; j++) {
+        for (const [a, b] of cells.get(key(i, j)) ?? []) {
+          const dx = b.x - a.x, dy = b.y - a.y;
+          const len2 = dx * dx + dy * dy;
+          const t = len2 > 0 ? Math.max(0, Math.min(1, ((x - a.x) * dx + (y - a.y) * dy) / len2)) : 0;
+          if (Math.hypot(a.x + dx * t - x, a.y + dy * t - y) < r) return true;
+        }
+      }
+    }
+    return false;
+  };
+}
+function crossingsAt(rings, y) {
+  const xs = [];
+  for (const ring of rings) {
+    ring.forEach((a, n) => {
+      const b = ring[(n + 1) % ring.length];
+      if (a.y > y !== b.y > y) xs.push(a.x + (y - a.y) * (b.x - a.x) / (b.y - a.y));
+    });
+  }
+  return xs.sort((p, q) => p - q);
+}
+function fillLattice(region, h) {
+  const outer = region.rings[0];
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const p of outer) {
+    x0 = Math.min(x0, p.x);
+    y0 = Math.min(y0, p.y);
+    x1 = Math.max(x1, p.x);
+    y1 = Math.max(y1, p.y);
+  }
+  const pins = [...region.inner];
+  const nearOutline = clearanceTest(region.rings, 0.5 * h);
+  const rowH = h * Math.sqrt(3) / 2;
+  for (let row = 0, y = y0 + rowH / 2; y < y1; row++, y += rowH) {
+    const xs = crossingsAt(region.rings, y);
+    let left = 0;
+    for (let x = x0 + (row % 2 ? h / 2 : h / 4); x < x1; x += h) {
+      while (left < xs.length && xs[left] < x) left++;
+      if (left % 2 === 0 || nearOutline(x, y)) continue;
+      if (pins.some((p) => Math.hypot(p.x - x, p.y - y) < 0.5 * h)) continue;
+      region.inner.push({ x, y, pins: [] });
+    }
+  }
+}
+function puppetMesh(path, pins, opts = {}) {
+  const box = boundsOfPath(path);
+  const size = Math.max(box.width, box.height);
+  const empty = { vertices: new Float64Array(0), triangles: new Uint32Array(0), pinVertex: new Int32Array(pins.length).fill(-1) };
+  if (!(size > 0)) return empty;
+  const tolerance = size / 1e3;
+  const rough = regionsOf(path, tolerance, size);
+  const h = Math.max(Math.sqrt(Math.max(rough.area, 0) / (opts.vertices ?? 400)), size / 400);
+  const { regions } = regionsOf(path, tolerance, h);
+  if (regions.length === 0) return empty;
+  pins.forEach((p, k) => placePin(regions, p, k, h));
+  const vertices = [];
+  const triangles = [];
+  const pinVertex = new Int32Array(pins.length).fill(-1);
+  for (const region of regions) {
+    fillLattice(region, h);
+    const points = [...region.rings.flat(), ...region.inner];
+    const holes = [];
+    let at = 0;
+    for (const ring of region.rings) {
+      if (at > 0) holes.push(at);
+      at += ring.length;
+    }
+    const offset = vertices.length / 2;
+    const coords = points.flatMap((p) => [p.x, p.y]);
+    const outline = earcut(coords.slice(0, 2 * at), holes.length > 0 ? holes : void 0);
+    for (const t of refineTriangulation(coords, outline, at)) triangles.push(t + offset);
+    points.forEach((p, i) => {
+      for (const k of p.pins) pinVertex[k] = offset + i;
+    });
+    vertices.push(...coords);
+  }
+  return { vertices: Float64Array.from(vertices), triangles: Uint32Array.from(triangles), pinVertex };
+}
+
+// src/warp/puppet.ts
+var rigs = /* @__PURE__ */ new WeakMap();
+function rigFor(source, pins) {
+  const key = pins.map((p) => `${p.from.x},${p.from.y}`).join(";");
+  const held = rigs.get(source);
+  if (held?.key === key) return held;
+  const mesh = puppetMesh(source, pins.map((p) => p.from));
+  const pinned = [...new Set(Array.from(mesh.pinVertex).filter((v) => v >= 0))];
+  const rig = { key, mesh, solver: createArapSolver(mesh, pinned), locate: meshLocator(mesh), spots: /* @__PURE__ */ new Map(), remembered: 0 };
+  rigs.set(source, rig);
+  return rig;
+}
+function puppetMap(source, pins) {
+  if (pins.length === 0) return (p) => ({ x: p.x, y: p.y });
+  const rig = rigFor(source, pins);
+  const at = solveRig(rig, pins);
+  if (!at) {
+    const dx = pins[0].to.x - pins[0].from.x, dy = pins[0].to.y - pins[0].from.y;
+    return (p) => ({ x: p.x + dx, y: p.y + dy });
+  }
+  return (p) => {
+    const spot = spotOf(rig, p);
+    return spot ? placeSpot(rig.mesh.triangles, at, spot) : { x: p.x, y: p.y };
+  };
+}
+function solveRig(rig, pins, opts) {
+  const targets = [];
+  const seen = /* @__PURE__ */ new Set();
+  pins.forEach((pin, k) => {
+    const v = rig.mesh.pinVertex[k];
+    if (v < 0 || seen.has(v)) return;
+    seen.add(v);
+    targets.push(pin.to.x + rig.mesh.vertices[2 * v] - pin.from.x, pin.to.y + rig.mesh.vertices[2 * v + 1] - pin.from.y);
+  });
+  return targets.length === 0 ? null : rig.solver.solve(targets, opts);
+}
+function puppetSolve(source, pins, opts) {
+  if (pins.length === 0) return null;
+  const rig = rigFor(source, pins);
+  const vertices = solveRig(rig, pins, opts);
+  return vertices ? { mesh: rig.mesh, vertices } : null;
+}
+var SPOT_CAP = 1 << 16;
+function spotOf(rig, p) {
+  let row = rig.spots.get(p.x);
+  const hit = row?.get(p.y);
+  if (hit !== void 0) return hit;
+  const spot = rig.locate(p.x, p.y);
+  if (++rig.remembered > SPOT_CAP) {
+    rig.spots.clear();
+    rig.remembered = 1;
+    row = void 0;
+  }
+  if (!row) {
+    row = /* @__PURE__ */ new Map();
+    rig.spots.set(p.x, row);
+  }
+  row.set(p.y, spot);
+  return spot;
+}
+function unwarpPoint(map, target, guess = target, tolerance = 1e-3) {
+  let p = { x: guess.x, y: guess.y };
+  for (let k = 0; k < 50; k++) {
+    const at = map(p);
+    const ex = target.x - at.x, ey = target.y - at.y;
+    if (Math.hypot(ex, ey) <= tolerance) break;
+    p = { x: p.x + ex, y: p.y + ey };
+  }
+  return p;
+}
+
+// src/warp/warpPath.ts
+var MIN_SAMPLES = 8;
+var MAX_SAMPLES = 64;
+var TANGENT_STEP = 1e-3;
+function warpPath(path, map, opts = {}) {
+  const tol = Math.max(opts.tolerance ?? 0.5, 1e-6);
+  const { anchors, closed } = pathToAnchors(path);
+  const out = anchors.map((sub, s) => warpSubpath(sub, closed[s], map, tol));
+  return anchorsToPath(out, closed, path);
+}
+function warpSubpath(sub, closed, map, tol) {
+  const n = sub.length;
+  if (n === 0) return [];
+  const out = [];
+  const segments = closed && n > 1 ? n : n - 1;
+  if (segments === 0) return [map(sub[0])];
+  for (let i = 0; i < segments; i++) {
+    const a = sub[i];
+    const b = sub[(i + 1) % n];
+    const at = segmentAt(a, b);
+    const count = sampleCount(a, b, tol);
+    const pts = [];
+    for (let k = 0; k <= count; k++) pts.push(map(at(k / count)));
+    const start = pts[0];
+    const end = pts[pts.length - 1];
+    const tStart = unit(sub2(map(at(TANGENT_STEP)), start));
+    const tEnd = unit(sub2(map(at(1 - TANGENT_STEP)), end));
+    const run = dedupe(pts);
+    const closing = closed && i === segments - 1;
+    if (run.length < 2) {
+      if (out.length === 0) out.push({ x: start.x, y: start.y });
+      if (!closing) {
+        out.push({ x: end.x, y: end.y });
+        keepCorner(out[out.length - 1], b);
+      }
+      continue;
+    }
+    fitPointRun(run, tStart, tEnd, tol, out, closing);
+    if (!closing) keepCorner(out[out.length - 1], b);
+  }
+  keepCorner(out[0], sub[0]);
+  return out;
+}
+function segmentAt(a, b) {
+  if (!a.outHandle && !b.inHandle) return (t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+  const c1 = a.outHandle ?? a;
+  const c2 = b.inHandle ?? b;
+  return (t) => cubicPointAt(a, c1, c2, b, t);
+}
+function sampleCount(a, b, tol) {
+  const c1 = a.outHandle ?? a;
+  const c2 = b.inHandle ?? b;
+  const len = Math.hypot(c1.x - a.x, c1.y - a.y) + Math.hypot(c2.x - c1.x, c2.y - c1.y) + Math.hypot(b.x - c2.x, b.y - c2.y);
+  return Math.min(MAX_SAMPLES, Math.max(MIN_SAMPLES, Math.ceil(len / (8 * tol))));
+}
+function dedupe(pts) {
+  return pts.filter((p, i) => i === 0 || p.x !== pts[i - 1].x || p.y !== pts[i - 1].y);
+}
+var sub2 = (p, q) => ({ x: p.x - q.x, y: p.y - q.y });
+function unit(p) {
+  const len = Math.hypot(p.x, p.y);
+  return len === 0 ? { x: 0, y: 0 } : { x: p.x / len, y: p.y / len };
+}
+
+// src/warp/pathWarp.ts
+function distortOver(box, mode = "free") {
+  const { x, y, width: w, height: h } = box;
+  return {
+    kind: "distort",
+    mode,
+    box: { ...box },
+    corners: [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }]
+  };
+}
+function envelopeOver(box, rows, cols, mapping = "bicubic") {
+  return { kind: "envelope", mapping, box: { ...box }, mesh: meshGridOver(box, rows, cols) };
+}
+function resizeEnvelope(warp, rows, cols) {
+  if (warp.mesh.rows === rows && warp.mesh.cols === cols) return warp;
+  return { ...warp, mesh: meshGridFrom(envelopeUvMap(warp), rows, cols) };
+}
+function envelopeUvMap(warp) {
+  return warp.mapping === "coons" ? coonsMesh(warp.mesh) : bicubicMesh(warp.mesh);
+}
+function boxUv(box, uv) {
+  const sx = box.width === 0 ? 0 : 1 / box.width;
+  const sy = box.height === 0 ? 0 : 1 / box.height;
+  return (p) => uv((p.x - box.x) * sx, (p.y - box.y) * sy);
+}
+function pathWarpMap(warp, source) {
+  switch (warp.kind) {
+    case "distort": {
+      const uv = (warp.mode === "perspective" ? projectiveQuad(warp.corners) : null) ?? bilinearQuad(warp.corners);
+      return boxUv(warp.box, uv);
+    }
+    case "envelope":
+      return boxUv(warp.box, envelopeUvMap(warp));
+    case "puppet":
+      return puppetMap(source, warp.pins);
+  }
+}
+function applyPathWarp(source, warp, tolerance = 0.5) {
+  return warpPath(source, pathWarpMap(warp, source), { tolerance });
+}
+function warpControls(warp) {
+  switch (warp.kind) {
+    case "distort":
+      return warp.corners;
+    case "envelope":
+      return warp.mesh.points;
+    case "puppet":
+      return warp.pins.map((p) => p.to);
+  }
+}
+function moveWarpControl(warp, index, to) {
+  const at = { x: to.x, y: to.y };
+  switch (warp.kind) {
+    case "distort": {
+      const corners = [...warp.corners];
+      if (index < 0 || index > 3) return warp;
+      corners[index] = at;
+      return { ...warp, corners };
+    }
+    case "envelope": {
+      if (index < 0 || index >= warp.mesh.points.length) return warp;
+      const points = [...warp.mesh.points];
+      points[index] = at;
+      return { ...warp, mesh: { ...warp.mesh, points } };
+    }
+    case "puppet": {
+      if (index < 0 || index >= warp.pins.length) return warp;
+      return { ...warp, pins: warp.pins.map((p, i) => i === index ? { from: p.from, to: at } : p) };
+    }
+  }
+}
+
+export { ARAP_INJECTIVE_ROUNDS, ARAP_ROUNDS, applyPathWarp, bicubicMesh, bilinearQuad, coonsMesh, createArapSolver, distortOver, envelopeOver, meshGridFrom, meshGridOver, moveWarpControl, pathWarpMap, projectiveQuad, puppetMap, puppetMesh, puppetSolve, resizeEnvelope, squareToQuadHomography, unwarpPoint, warpControls, warpPath };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map