@pixerate/editor 0.107.0 → 0.109.0

package/dist/chunk-KKREERP2.js

@@ -1,694 +0,0 @@
-// src/geom/affine.ts
-var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
-function multiplyMatrices(a, b) {
-  const [a0, a1, a2, a3, a4, a5] = a;
-  const [b0, b1, b2, b3, b4, b5] = b;
-  return [b0 * a0 + b2 * a1, b1 * a0 + b3 * a1, b0 * a2 + b2 * a3, b1 * a2 + b3 * a3, b0 * a4 + b2 * a5 + b4, b1 * a4 + b3 * a5 + b5];
-}
-var translateMatrix = (dx, dy) => [1, 0, 0, 1, dx, dy];
-function scaleMatrix(sx, sy, origin = { x: 0, y: 0 }) {
-  return [sx, 0, 0, sy, origin.x - sx * origin.x, origin.y - sy * origin.y];
-}
-function rotateMatrix(degrees, origin = { x: 0, y: 0 }) {
-  const r = degrees * Math.PI / 180;
-  const cos = Math.cos(r);
-  const sin = Math.sin(r);
-  return [cos, sin, -sin, cos, origin.x - cos * origin.x + sin * origin.y, origin.y - sin * origin.x - cos * origin.y];
-}
-function matrixAbout(m, origin) {
-  return multiplyMatrices(multiplyMatrices(translateMatrix(-origin.x, -origin.y), m), translateMatrix(origin.x, origin.y));
-}
-function skewMatrix(ax, ay, origin = { x: 0, y: 0 }) {
-  const tx = Math.tan(ax * Math.PI / 180);
-  const ty = Math.tan(ay * Math.PI / 180);
-  return matrixAbout([1, ty, tx, 1, 0, 0], origin);
-}
-function applyMatrix(m, p) {
-  return { x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] };
-}
-function isIdentityMatrix(m, eps = 1e-12) {
-  return Math.abs(m[0] - 1) < eps && Math.abs(m[1]) < eps && Math.abs(m[2]) < eps && Math.abs(m[3] - 1) < eps && Math.abs(m[4]) < eps && Math.abs(m[5]) < eps;
-}
-function invertMatrix(m) {
-  const [a, b, c, d, e, f] = m;
-  const det = a * d - b * c;
-  if (!det || !Number.isFinite(det)) return IDENTITY_MATRIX;
-  return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
-}
-function applyMatrixLinear(m, v) {
-  return { x: m[0] * v.x + m[2] * v.y, y: m[1] * v.x + m[3] * v.y };
-}
-function matrixRotation(m) {
-  const [a, b, c, d] = m;
-  const mirrored = a * d - b * c < 0;
-  const deg = (mirrored ? Math.atan2(-b - c, d - a) : Math.atan2(b - c, a + d)) * 180 / Math.PI;
-  return Math.abs(deg) < 1e-9 ? 0 : deg;
-}
-function decomposeRigid(m) {
-  const [a, b, c, d, e, f] = m;
-  const deg = matrixRotation(m);
-  if (deg === 0) return { rigid: IDENTITY_MATRIX, residual: m };
-  const r = deg * Math.PI / 180;
-  const cos = Math.cos(r);
-  const sin = Math.sin(r);
-  return {
-    rigid: [cos, sin, -sin, cos, e, f],
-    residual: [cos * a + sin * b, -sin * a + cos * b, cos * c + sin * d, -sin * c + cos * d, 0, 0]
-  };
-}
-
-// src/geom/warp.ts
-var WARP_STYLES = [
-  "arc",
-  "arcLower",
-  "arcUpper",
-  "arch",
-  "bulge",
-  "shellLower",
-  "shellUpper",
-  "flag",
-  "wave",
-  "fish",
-  "rise",
-  "fisheye",
-  "inflate",
-  "squeeze",
-  "twist"
-];
-var WARP_STYLE_LABELS = {
-  arc: "Arc",
-  arcLower: "Arc Lower",
-  arcUpper: "Arc Upper",
-  arch: "Arch",
-  bulge: "Bulge",
-  shellLower: "Shell Lower",
-  shellUpper: "Shell Upper",
-  flag: "Flag",
-  wave: "Wave",
-  fish: "Fish",
-  rise: "Rise",
-  fisheye: "Fisheye",
-  inflate: "Inflate",
-  squeeze: "Squeeze",
-  twist: "Twist"
-};
-function restGrid() {
-  return [0, 1, 2, 3].map((j) => [0, 1, 2, 3].map((i) => [i / 3, j / 3]));
-}
-function edgeArc(y, b, up, h) {
-  if (Math.abs(b) < 1e-9) return [0, 1, 2, 3].map((i) => [i / 3, y]);
-  const th = Math.abs(b) * Math.PI;
-  const k = 4 / 3 * Math.tan(th / 4) * 0.5 / Math.sin(th / 2);
-  const s = b > 0 === up ? -1 : 1;
-  const c = Math.cos(th / 2);
-  const n = Math.sin(th / 2);
-  const dy = s * k * n / h;
-  return [
-    [0, y],
-    [k * c, y + dy],
-    [1 - k * c, y + dy],
-    [1, y]
-  ];
-}
-function arcGrid(b, h) {
-  if (Math.abs(b) < 1e-9) return restGrid();
-  const up = b > 0;
-  const th = Math.abs(b) * Math.PI;
-  const r = 0.5 / Math.sin(th / 2);
-  const k = 4 / 3 * Math.tan(th / 4);
-  const s = up ? -1 : 1;
-  const cy = up ? h + r * Math.cos(th / 2) : -r * Math.cos(th / 2);
-  return [0, 1, 2, 3].map((j) => {
-    const v = j / 3;
-    const big = r + h * (up ? 1 - v : v);
-    const at = (a) => [0.5 + big * Math.sin(a), cy + s * big * Math.cos(a)];
-    const tangent = (a) => [Math.cos(a), -s * Math.sin(a)];
-    const p0 = at(-th / 2);
-    const p3 = at(th / 2);
-    const t0 = tangent(-th / 2);
-    const t1 = tangent(th / 2);
-    const l = k * big;
-    const pts = [p0, [p0[0] + l * t0[0], p0[1] + l * t0[1]], [p3[0] - l * t1[0], p3[1] - l * t1[1]], p3];
-    return pts.map((p) => [p[0], p[1] / h]);
-  });
-}
-function blendRows(top, bottom) {
-  return [0, 1, 2, 3].map((j) => {
-    const t = j / 3;
-    return [0, 1, 2, 3].map((i) => [top[i][0] + (bottom[i][0] - top[i][0]) * t, top[i][1] + (bottom[i][1] - top[i][1]) * t]);
-  });
-}
-var INNER = [
-  [1, 1, -1, -1],
-  [1, 2, 1, -1],
-  [2, 1, -1, 1],
-  [2, 2, 1, 1]
-];
-function warpPresetGrid(style, b, hd, vd, vertical, aspect) {
-  const h = vertical ? 1 / aspect : aspect;
-  if (vertical) [hd, vd] = [vd, hd];
-  let g = restGrid();
-  switch (style) {
-    case "arc":
-      g = arcGrid(b, h);
-      break;
-    case "arch":
-      g = [0, 1, 2, 3].map((j) => edgeArc(j / 3, b, true, h));
-      break;
-    case "bulge":
-      g = blendRows(edgeArc(0, b, true, h), edgeArc(1, b, false, h));
-      break;
-    case "arcLower":
-      g = blendRows(g[0], edgeArc(1, b, false, h));
-      break;
-    case "arcUpper":
-      g = blendRows(edgeArc(0, b, true, h), g[3]);
-      break;
-    // The bulging edge and the outer points of the row next to it come from Arc (bent the other
-    // way for Shell Lower); the rest stays put.
-    case "shellLower": {
-      const a = arcGrid(-b, h);
-      g[3] = a[3];
-      g[2][0] = a[2][0];
-      g[2][3] = a[2][3];
-      break;
-    }
-    case "shellUpper": {
-      const a = arcGrid(b, h);
-      g[0] = a[0];
-      g[1][0] = a[1][0];
-      g[1][3] = a[1][3];
-      break;
-    }
-    case "flag":
-      for (const row of g) {
-        row[1][1] -= 2 * b;
-        row[2][1] += 2 * b;
-      }
-      break;
-    case "wave":
-      for (const row of g.slice(1, 3)) {
-        row[1][1] += 4 / 3 * b;
-        row[2][1] -= 4 / 3 * b;
-      }
-      break;
-    case "fish":
-      [-2, -2 / 3, 2 / 3, 2].forEach((f, j) => {
-        g[j][1][1] += f * b;
-        g[j][2][1] -= f * b;
-      });
-      break;
-    case "rise":
-      for (const row of g) {
-        row[0][1] += 2 * b;
-        row[1][1] += 2 * b;
-      }
-      break;
-    case "fisheye":
-      for (const [j, i, dx, dy] of INNER) {
-        g[j][i][0] += dx * 2 * b / 3;
-        g[j][i][1] += dy * 2 * b / 3;
-      }
-      break;
-    // Edge midpoints move out (Inflate) or the sides in (Squeeze) by b/3, the inner points by b/9.
-    case "inflate":
-    case "squeeze": {
-      const s = style === "inflate" ? 1 : -1;
-      for (const p of g[0].slice(1, 3)) p[1] -= b / 3;
-      for (const p of g[3].slice(1, 3)) p[1] += b / 3;
-      for (const row of g.slice(1, 3)) {
-        row[0][0] -= s * b / 3;
-        row[3][0] += s * b / 3;
-      }
-      for (const [j, i, dx, dy] of INNER) {
-        g[j][i][0] += s * dx * b / 9;
-        g[j][i][1] += dy * b / 9;
-      }
-      break;
-    }
-    // The inner points turn round the centre (the other way for a negative bend).
-    case "twist": {
-      const a = Math.abs(b);
-      if (b >= 0) {
-        g[1][1][0] += a;
-        g[1][2][1] += a;
-        g[2][1][1] -= a;
-        g[2][2][0] -= a;
-      } else {
-        g[1][1][1] += a;
-        g[1][2][0] -= a;
-        g[2][1][0] += a;
-        g[2][2][1] -= a;
-      }
-      break;
-    }
-  }
-  if (vd !== 0) {
-    const moved = (row, s) => {
-      const m = [(row[0][0] + row[3][0]) / 2, (row[0][1] + row[3][1]) / 2];
-      return row.map((p) => [m[0] + (p[0] - m[0]) * s - p[0], m[1] + (p[1] - m[1]) * s - p[1]]);
-    };
-    const d0 = moved(g[0], 1 - vd);
-    const d3 = moved(g[3], 1 + vd);
-    g.forEach((row, j) => {
-      const t = j / 3;
-      row.forEach((p, i) => {
-        p[0] += d0[i][0] + (d3[i][0] - d0[i][0]) * t;
-        p[1] += d0[i][1] + (d3[i][1] - d0[i][1]) * t;
-      });
-    });
-  }
-  if (hd !== 0) {
-    for (let i = 0; i < 4; i++) {
-      const s = 1 + hd * (2 * i / 3 - 1);
-      const m = [(g[0][i][0] + g[3][i][0]) / 2, (g[0][i][1] + g[3][i][1]) / 2];
-      for (const row of g) row[i] = [m[0] + (row[i][0] - m[0]) * s, m[1] + (row[i][1] - m[1]) * s];
-    }
-  }
-  if (vertical) g = [0, 1, 2, 3].map((j) => [0, 1, 2, 3].map((i) => [g[i][j][1], g[i][j][0]]));
-  return g;
-}
-function bernstein(t) {
-  const s = 1 - t;
-  return [s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t];
-}
-var lerpVec2 = (a, b, t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
-function splitCubic(p, t) {
-  const a = lerpVec2(p[0], p[1], t);
-  const b = lerpVec2(p[1], p[2], t);
-  const c = lerpVec2(p[2], p[3], t);
-  const d = lerpVec2(a, b, t);
-  const e = lerpVec2(b, c, t);
-  return [p[0], a, d, lerpVec2(d, e, t), e, c, p[3]];
-}
-var BERN_INV = [
-  [1, 0, 0, 0],
-  [-5 / 6, 3, -1.5, 1 / 3],
-  [1 / 3, -1.5, 3, -5 / 6],
-  [0, 0, 0, 1]
-];
-var pct = (v) => typeof v === "number" && Number.isFinite(v) ? Math.min(1, Math.max(-1, v / 100)) : 0;
-function warpPresetMesh(preset, bounds) {
-  if (!WARP_STYLES.includes(preset.style)) return null;
-  const { x, y, width: w, height: h } = bounds;
-  if (!(w > 0 && h > 0)) return null;
-  const b = pct(preset.bend);
-  const hd = pct(preset.horizontal);
-  const vd = pct(preset.vertical);
-  if (b === 0 && hd === 0 && vd === 0) return null;
-  const grid = warpPresetGrid(preset.style, b, hd, vd, preset.orientation === "vertical", h / w);
-  return { us: [0, 1], vs: [0, 1], points: grid.flat().map((p) => ({ x: x + p[0] * w, y: y + p[1] * h })) };
-}
-var warpMeshColumns = (m) => 3 * (m.us.length - 1) + 1;
-var warpMeshRows = (m) => 3 * (m.vs.length - 1) + 1;
-function isValidWarpMesh(m) {
-  if (!m || typeof m !== "object") return false;
-  const { us, vs, points } = m;
-  const knots = (k) => Array.isArray(k) && k.length >= 2 && k.length <= 65 && k[0] === 0 && k[k.length - 1] === 1 && k.every((v, i) => typeof v === "number" && (i === 0 || v > k[i - 1]));
-  if (!knots(us) || !knots(vs) || !Array.isArray(points)) return false;
-  return points.length === (3 * (us.length - 1) + 1) * (3 * (vs.length - 1) + 1) && points.every((p) => !!p && Number.isFinite(p.x) && Number.isFinite(p.y));
-}
-function fitWarpMesh(f, us, vs) {
-  const pc = us.length - 1;
-  const pr = vs.length - 1;
-  const nx = 3 * pc + 1;
-  const points = new Array((3 * pr + 1) * nx);
-  for (let pj = 0; pj < pr; pj++) {
-    for (let pi = 0; pi < pc; pi++) {
-      const s = [0, 1, 2, 3].map(
-        (j) => [0, 1, 2, 3].map((i) => f(us[pi] + (us[pi + 1] - us[pi]) * i / 3, vs[pj] + (vs[pj + 1] - vs[pj]) * j / 3))
-      );
-      for (let j = 0; j < 4; j++) {
-        for (let i = 0; i < 4; i++) {
-          let x = 0;
-          let y = 0;
-          for (let a = 0; a < 4; a++) {
-            for (let b = 0; b < 4; b++) {
-              const k = BERN_INV[j][a] * BERN_INV[i][b];
-              x += k * s[a][b].x;
-              y += k * s[a][b].y;
-            }
-          }
-          points[(3 * pj + j) * nx + 3 * pi + i] = { x, y };
-        }
-      }
-    }
-  }
-  return { us: us.slice(), vs: vs.slice(), points };
-}
-var evenKnots = (n) => Array.from({ length: n + 1 }, (_, i) => i / n);
-var clampMeshCount = (n) => Math.min(64, Math.max(1, Math.round(Number.isFinite(n) ? n : 1)));
-function identityWarpMesh(bounds, columns = 1, rows = 1) {
-  return fitWarpMesh((s, t) => ({ x: bounds.x + s * bounds.width, y: bounds.y + t * bounds.height }), evenKnots(clampMeshCount(columns)), evenKnots(clampMeshCount(rows)));
-}
-function locate(knots, s) {
-  const n = knots.length - 1;
-  let i = 0;
-  while (i + 1 < n && s > knots[i + 1]) i++;
-  const w = knots[i + 1] - knots[i];
-  return [i, w > 0 ? (s - knots[i]) / w : 0];
-}
-function evalWarpMesh(m, s, t) {
-  const [pi, a] = locate(m.us, s);
-  const [pj, b] = locate(m.vs, t);
-  const ba = bernstein(a);
-  const bb = bernstein(b);
-  const nx = warpMeshColumns(m);
-  let x = 0;
-  let y = 0;
-  for (let j = 0; j < 4; j++) {
-    for (let i = 0; i < 4; i++) {
-      const p = m.points[(3 * pj + j) * nx + 3 * pi + i];
-      const k = ba[i] * bb[j];
-      x += p.x * k;
-      y += p.y * k;
-    }
-  }
-  return { x, y };
-}
-function transposeMesh(m) {
-  const nx = warpMeshColumns(m);
-  const ny = warpMeshRows(m);
-  const points = new Array(nx * ny);
-  for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) points[i * ny + j] = m.points[j * nx + i];
-  return { us: m.vs.slice(), vs: m.us.slice(), points };
-}
-function splitWarpMeshU(m, s) {
-  const [pi, a] = locate(m.us, s);
-  if (!(a >= 0.01 && a <= 0.99)) return null;
-  const nx = warpMeshColumns(m);
-  const ny = warpMeshRows(m);
-  const points = [];
-  for (let j = 0; j < ny; j++) {
-    const row = m.points.slice(j * nx, (j + 1) * nx);
-    points.push(...row.slice(0, 3 * pi), ...splitCubic(row.slice(3 * pi, 3 * pi + 4), a), ...row.slice(3 * pi + 4));
-  }
-  const us = m.us.slice();
-  us.splice(pi + 1, 0, Math.min(1, Math.max(0, s)));
-  return { us, vs: m.vs.slice(), points };
-}
-function splitWarpMeshV(m, t) {
-  const out = splitWarpMeshU(transposeMesh(m), t);
-  return out && transposeMesh(out);
-}
-function removeWarpMeshSplitU(m, k) {
-  if (k <= 0 || k + 1 >= m.us.length) return null;
-  const a = (m.us[k] - m.us[k - 1]) / (m.us[k + 1] - m.us[k - 1]);
-  const nx = warpMeshColumns(m);
-  const ny = warpMeshRows(m);
-  const c0 = 3 * (k - 1);
-  const points = [];
-  for (let j = 0; j < ny; j++) {
-    const row = m.points.slice(j * nx, (j + 1) * nx);
-    const [p0, q1, r2, p3] = [row[c0], row[c0 + 1], row[c0 + 5], row[c0 + 6]];
-    const p1 = { x: (q1.x - (1 - a) * p0.x) / a, y: (q1.y - (1 - a) * p0.y) / a };
-    const p2 = { x: (r2.x - a * p3.x) / (1 - a), y: (r2.y - a * p3.y) / (1 - a) };
-    points.push(...row.slice(0, c0), p0, p1, p2, p3, ...row.slice(c0 + 7));
-  }
-  const us = m.us.slice();
-  us.splice(k, 1);
-  return { us, vs: m.vs.slice(), points };
-}
-function removeWarpMeshSplitV(m, k) {
-  const out = removeWarpMeshSplitU(transposeMesh(m), k);
-  return out && transposeMesh(out);
-}
-function mapWarpMeshPoints(m, f) {
-  return { us: m.us.slice(), vs: m.vs.slice(), points: m.points.map((p) => f(p)) };
-}
-function resizeWarpMesh(m, columns, rows) {
-  const cols = clampMeshCount(columns);
-  const rws = clampMeshCount(rows);
-  if (m.us.length - 1 === cols && m.vs.length - 1 === rws) return m;
-  const us = evenKnots(cols);
-  const vs = evenKnots(rws);
-  const has = (list, v) => list.some((k) => Math.abs(k - v) < 1e-12);
-  if (m.us.every((u) => has(us, u)) && m.vs.every((v) => has(vs, v))) {
-    let out = m;
-    for (const u of us) if (!has(out.us, u)) out = splitWarpMeshU(out, u) ?? out;
-    for (const v of vs) if (!has(out.vs, v)) out = splitWarpMeshV(out, v) ?? out;
-    return out;
-  }
-  return fitWarpMesh((s, t) => evalWarpMesh(m, s, t), us, vs);
-}
-function warpMeshControlBounds(m) {
-  let minX = Infinity;
-  let minY = Infinity;
-  let maxX = -Infinity;
-  let maxY = -Infinity;
-  for (const p of m.points) {
-    minX = Math.min(minX, p.x);
-    minY = Math.min(minY, p.y);
-    maxX = Math.max(maxX, p.x);
-    maxY = Math.max(maxY, p.y);
-  }
-  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
-}
-function warpMeshParamAt(m, p) {
-  const n = 48;
-  let best = { s: 0.5, t: 0.5, d: Infinity };
-  for (let j = 0; j <= n; j++) {
-    for (let i = 0; i <= n; i++) {
-      const q2 = evalWarpMesh(m, i / n, j / n);
-      const d = (q2.x - p.x) ** 2 + (q2.y - p.y) ** 2;
-      if (d < best.d) best = { s: i / n, t: j / n, d };
-    }
-  }
-  let { s, t } = best;
-  for (let k = 0; k < 12; k++) {
-    const h = 1e-5;
-    const q2 = evalWarpMesh(m, s, t);
-    const qs = evalWarpMesh(m, s + h, t);
-    const qt = evalWarpMesh(m, s, t + h);
-    const a = (qs.x - q2.x) / h;
-    const b = (qt.x - q2.x) / h;
-    const c = (qs.y - q2.y) / h;
-    const d = (qt.y - q2.y) / h;
-    const det = a * d - b * c;
-    if (Math.abs(det) < 1e-12) break;
-    const ex = p.x - q2.x;
-    const ey = p.y - q2.y;
-    s = Math.min(1, Math.max(0, s + (d * ex - b * ey) / det));
-    t = Math.min(1, Math.max(0, t + (a * ey - c * ex) / det));
-  }
-  const q = evalWarpMesh(m, s, t);
-  return { s, t, distance: Math.hypot(q.x - p.x, q.y - p.y) };
-}
-function smoothLines(m, i0, i1, j0, j1) {
-  const nx = warpMeshColumns(m);
-  i1 = Math.min(i1, nx);
-  j1 = Math.min(j1, warpMeshRows(m));
-  const triples = [];
-  for (let a = 1; a < m.us.length - 1; a++) {
-    if (3 * a >= i0 && 3 * a < i1)
-      for (let j = j0; j < j1; j++) triples.push([j * nx + 3 * a - 1, j * nx + 3 * a, j * nx + 3 * a + 1, m.us[a] - m.us[a - 1], m.us[a + 1] - m.us[a]]);
-  }
-  for (let b = 1; b < m.vs.length - 1; b++) {
-    if (3 * b >= j0 && 3 * b < j1)
-      for (let i = i0; i < i1; i++) triples.push([(3 * b - 1) * nx + i, 3 * b * nx + i, (3 * b + 1) * nx + i, m.vs[b] - m.vs[b - 1], m.vs[b + 1] - m.vs[b]]);
-  }
-  for (const [l, c, r, hl, hr] of triples) {
-    const pl = m.points[l];
-    const pc = m.points[c];
-    const pr = m.points[r];
-    const tx = ((pc.x - pl.x) / hl + (pr.x - pc.x) / hr) / 2;
-    const ty = ((pc.y - pl.y) / hl + (pr.y - pc.y) / hr) / 2;
-    m.points[l] = { x: pc.x - tx * hl, y: pc.y - ty * hl };
-    m.points[r] = { x: pc.x + tx * hr, y: pc.y + ty * hr };
-  }
-}
-function dragWarpMeshPoint(base, index, d) {
-  if (index < 0 || index >= base.points.length || !Number.isFinite(d.x) || !Number.isFinite(d.y)) return base;
-  const out = { us: base.us.slice(), vs: base.vs.slice(), points: base.points.slice() };
-  const nx = warpMeshColumns(base);
-  const ny = warpMeshRows(base);
-  const i = index % nx;
-  const j = Math.floor(index / nx);
-  const shift = (ii, jj, v) => {
-    if (ii < 0 || jj < 0 || ii >= nx || jj >= ny) return;
-    const p = out.points[jj * nx + ii];
-    out.points[jj * nx + ii] = { x: p.x + v.x, y: p.y + v.y };
-  };
-  const span = (knots, k) => k > 0 && k + 1 < knots.length ? [knots[k] - knots[k - 1], knots[k + 1] - knots[k]] : null;
-  const ri = i % 3;
-  const rj = j % 3;
-  if (ri === 0 && rj === 0) {
-    for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) shift(i + di, j + dj, d);
-  } else if (ri === 0) {
-    for (let di = -1; di <= 1; di++) shift(i + di, j, d);
-    const sp = span(base.vs, Math.floor(j / 3) + (rj === 2 ? 1 : 0));
-    if (sp) {
-      const [other, k] = rj === 1 ? [j - 2, sp[0] / sp[1]] : [j + 2, sp[1] / sp[0]];
-      for (let di = -1; di <= 1; di++) shift(i + di, other, { x: -d.x * k, y: -d.y * k });
-    }
-  } else if (rj === 0) {
-    for (let dj = -1; dj <= 1; dj++) shift(i, j + dj, d);
-    const sp = span(base.us, Math.floor(i / 3) + (ri === 2 ? 1 : 0));
-    if (sp) {
-      const [other, k] = ri === 1 ? [i - 2, sp[0] / sp[1]] : [i + 2, sp[1] / sp[0]];
-      for (let dj = -1; dj <= 1; dj++) shift(other, j + dj, { x: -d.x * k, y: -d.y * k });
-    }
-  } else shift(i, j, d);
-  return out;
-}
-function pullWarpMesh(base, s, t, d) {
-  const BORDER_ZONE = 0.12;
-  const REACH = 1.8;
-  if (!Number.isFinite(d.x) || !Number.isFinite(d.y)) return base;
-  const m = { us: base.us.slice(), vs: base.vs.slice(), points: base.points.slice() };
-  const cols = m.us.length - 1;
-  const rows = m.vs.length - 1;
-  const [pi, a] = locate(m.us, s);
-  const [pj, b] = locate(m.vs, t);
-  const ba = bernstein(a);
-  const bb = bernstein(b);
-  const nx = warpMeshColumns(m);
-  const ny = warpMeshRows(m);
-  const anchor = (ai, aj) => base.points[3 * aj * nx + 3 * ai] ?? { x: 0, y: 0 };
-  const at0 = evalWarpMesh(base, s, t);
-  const target = { x: at0.x + d.x, y: at0.y + d.y };
-  let size = 1;
-  for (const k of ["x", "y"]) {
-    const vals = [anchor(pi, pj)[k], anchor(pi + 1, pj)[k], anchor(pi, pj + 1)[k], anchor(pi + 1, pj + 1)[k]];
-    size = Math.max(size, Math.max(...vals) - Math.min(...vals));
-  }
-  const radius = REACH * size;
-  const innerW = (ba[1] + ba[2]) * (bb[1] + bb[2]);
-  const interior = Math.min(1, Math.max(0, innerW / 0.5625));
-  const toBorder = Math.min(s, 1 - s, t, 1 - t);
-  const nearBorder = Math.min(1, Math.max(0, 1 - toBorder / BORDER_ZONE));
-  const meshCorner = (ai, aj) => (ai === 0 || ai === cols) && (aj === 0 || aj === rows);
-  const onBorder = (ai, aj) => ai === 0 || ai === cols || aj === 0 || aj === rows;
-  const reach = (ai, aj, wa, wb) => meshCorner(ai, aj) ? 0 : wa * wb * (onBorder(ai, aj) ? nearBorder : 1);
-  const corner = [
-    [pi, pj, reach(pi, pj, ba[0] + ba[1], bb[0] + bb[1])],
-    [pi + 1, pj, reach(pi + 1, pj, ba[2] + ba[3], bb[0] + bb[1])],
-    [pi, pj + 1, reach(pi, pj + 1, ba[0] + ba[1], bb[2] + bb[3])],
-    [pi + 1, pj + 1, reach(pi + 1, pj + 1, ba[2] + ba[3], bb[2] + bb[3])]
-  ];
-  const share = new Array((cols + 1) * (rows + 1)).fill(0);
-  for (let aj = 0; aj <= rows; aj++) {
-    for (let ai = 0; ai <= cols; ai++) {
-      const p = anchor(ai, aj);
-      const x = Math.min(1, Math.max(0, Math.hypot(p.x - at0.x, p.y - at0.y) / radius));
-      const fall = 0.5 * (1 + Math.cos(Math.PI * x));
-      const edge = meshCorner(ai, aj) ? 0 : onBorder(ai, aj) ? nearBorder : 1;
-      share[aj * (cols + 1) + ai] = fall * edge;
-    }
-  }
-  for (const [ai, aj, w] of corner) share[aj * (cols + 1) + ai] = Math.max(share[aj * (cols + 1) + ai], (1 - interior) * w);
-  const move = (idx, k, v) => {
-    const p = m.points[idx];
-    m.points[idx] = { x: p.x + v.x * k, y: p.y + v.y * k };
-  };
-  for (let j = 0; j < ny; j++) {
-    for (let i = 0; i < nx; i++) {
-      const ai = Math.min(cols, Math.floor((i + 1) / 3));
-      const aj = Math.min(rows, Math.floor((j + 1) / 3));
-      move(j * nx + i, share[aj * (cols + 1) + ai], d);
-    }
-  }
-  let norm = 0;
-  for (const j of [1, 2]) for (const i of [1, 2]) norm += (ba[i] * bb[j]) ** 2;
-  const cornerNorm = corner.reduce((acc, c) => acc + c[2] * c[2], 0);
-  const innerPart = cornerNorm > 1e-12 ? Math.min(1, innerW / 0.15) : 1;
-  const edgeHandles = [];
-  for (const k of [1, 2]) {
-    if (pi === 0) edgeHandles.push([(3 * pj + k) * nx + 3 * pi, ba[0] * bb[k]]);
-    if (pi + 1 === cols) edgeHandles.push([(3 * pj + k) * nx + 3 * pi + 3, ba[3] * bb[k]]);
-    if (pj === 0) edgeHandles.push([3 * pj * nx + 3 * pi + k, ba[k] * bb[0]]);
-    if (pj + 1 === rows) edgeHandles.push([(3 * pj + 3) * nx + 3 * pi + k, ba[k] * bb[3]]);
-  }
-  const edgeNorm = edgeHandles.reduce((acc, e) => acc + e[1] * e[1], 0);
-  const edgePart = edgeNorm > 1e-12 ? nearBorder : 0;
-  const innerShare = (1 - edgePart) * innerPart;
-  const cornerShare = (1 - edgePart) * (1 - innerPart);
-  for (let iter = 0; iter < 60; iter++) {
-    const now = evalWarpMesh(m, s, t);
-    const rem = { x: target.x - now.x, y: target.y - now.y };
-    if (Math.hypot(rem.x, rem.y) < 1e-9) break;
-    if (innerShare > 0 && norm > 0) for (const j of [1, 2]) for (const i of [1, 2]) move((3 * pj + j) * nx + 3 * pi + i, ba[i] * bb[j] / norm * innerShare, rem);
-    if (edgePart > 0) for (const [idx, w] of edgeHandles) move(idx, w / edgeNorm * edgePart, rem);
-    if (cornerShare > 0 && cornerNorm > 0) {
-      for (const [ai, aj, w] of corner) {
-        const k = w / cornerNorm * cornerShare;
-        for (let dj = -1; dj <= 1; dj++) {
-          for (let di = -1; di <= 1; di++) {
-            const i = 3 * ai + di;
-            const j = 3 * aj + dj;
-            if (i >= 0 && j >= 0 && i < nx && j < ny) move(j * nx + i, k, rem);
-          }
-        }
-      }
-    }
-    for (let k = 0; k < 3; k++) smoothLines(m, Math.max(0, 3 * pi - 3), 3 * pi + 7, Math.max(0, 3 * pj - 3), 3 * pj + 7);
-  }
-  return m;
-}
-function warpMeshEditPoints(m) {
-  const nx = warpMeshColumns(m);
-  const ny = warpMeshRows(m);
-  const anchors = [];
-  const handles = [];
-  for (let j = 0; j < ny; j++) {
-    for (let i = 0; i < nx; i++) {
-      const ri = i % 3;
-      const rj = j % 3;
-      if (ri === 0 && rj === 0) anchors.push(j * nx + i);
-      else if (ri === 0) handles.push({ index: j * nx + i, anchor: (rj === 1 ? j - 1 : j + 1) * nx + i });
-      else if (rj === 0) handles.push({ index: j * nx + i, anchor: j * nx + (ri === 1 ? i - 1 : i + 1) });
-    }
-  }
-  return { anchors, handles };
-}
-function warpMeshGridCurves(m) {
-  const nx = warpMeshColumns(m);
-  const ny = warpMeshRows(m);
-  const pt = (i, j) => m.points[j * nx + i];
-  const out = [];
-  for (let j = 0; j < ny; j += 3) for (let i = 0; i + 3 < nx; i += 3) out.push([pt(i, j), pt(i + 1, j), pt(i + 2, j), pt(i + 3, j)]);
-  for (let i = 0; i < nx; i += 3) for (let j = 0; j + 3 < ny; j += 3) out.push([pt(i, j), pt(i, j + 1), pt(i, j + 2), pt(i, j + 3)]);
-  return out;
-}
-
-export {
-  IDENTITY_MATRIX,
-  multiplyMatrices,
-  translateMatrix,
-  scaleMatrix,
-  rotateMatrix,
-  matrixAbout,
-  skewMatrix,
-  applyMatrix,
-  isIdentityMatrix,
-  invertMatrix,
-  applyMatrixLinear,
-  matrixRotation,
-  decomposeRigid,
-  WARP_STYLES,
-  WARP_STYLE_LABELS,
-  warpPresetGrid,
-  lerpVec2,
-  warpPresetMesh,
-  warpMeshColumns,
-  warpMeshRows,
-  isValidWarpMesh,
-  fitWarpMesh,
-  evenKnots,
-  clampMeshCount,
-  identityWarpMesh,
-  evalWarpMesh,
-  splitWarpMeshU,
-  splitWarpMeshV,
-  removeWarpMeshSplitU,
-  removeWarpMeshSplitV,
-  mapWarpMeshPoints,
-  resizeWarpMesh,
-  warpMeshControlBounds,
-  warpMeshParamAt,
-  dragWarpMeshPoint,
-  pullWarpMesh,
-  warpMeshEditPoints,
-  warpMeshGridCurves
-};
-//# sourceMappingURL=chunk-KKREERP2.js.map