@pixerate/editor 0.96.0 → 0.98.0

package/dist/{chunk-4JLB2USO.js → chunk-YGZNGDIT.js}

@@ -28,6 +28,32 @@ import {
   transformBezierPath,
   trimSegments
 } from "./chunk-YCSFS3GK.js";
+import {
+  IDENTITY_MATRIX,
+  WARP_STYLES,
+  WARP_STYLE_LABELS,
+  applyMatrix,
+  clampMeshCount,
+  decomposeRigid,
+  evalWarpMesh,
+  evenKnots,
+  fitWarpMesh,
+  identityWarpMesh,
+  invertMatrix,
+  isIdentityMatrix,
+  isValidWarpMesh,
+  lerpVec2,
+  mapWarpMeshPoints,
+  matrixRotation,
+  multiplyMatrices,
+  resizeWarpMesh,
+  rotateMatrix,
+  scaleMatrix,
+  translateMatrix,
+  warpMeshColumns,
+  warpMeshRows,
+  warpPresetMesh
+} from "./chunk-KKREERP2.js";
 import {
   mixColorsOklab,
   oklabToRgb,
@@ -2001,573 +2027,6 @@ function mapBezierPath(path, f, tolerance = 0.1, options = {}) {
 }
 
 // src/vector/warp.ts
-var VECTOR_WARP_STYLES = [
-  "arc",
-  "arcLower",
-  "arcUpper",
-  "arch",
-  "bulge",
-  "shellLower",
-  "shellUpper",
-  "flag",
-  "wave",
-  "fish",
-  "rise",
-  "fisheye",
-  "inflate",
-  "squeeze",
-  "twist"
-];
-var VECTOR_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 v2 = j / 3;
-    const big = r + h * (up ? 1 - v2 : v2);
-    const at2 = (a) => [0.5 + big * Math.sin(a), cy + s * big * Math.cos(a)];
-    const tangent2 = (a) => [Math.cos(a), -s * Math.sin(a)];
-    const p0 = at2(-th / 2);
-    const p3 = at2(th / 2);
-    const t0 = tangent2(-th / 2);
-    const t1 = tangent2(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 vectorWarpPresetGrid(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 lerp3 = (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 = lerp3(p[0], p[1], t);
-  const b = lerp3(p[1], p[2], t);
-  const c = lerp3(p[2], p[3], t);
-  const d = lerp3(a, b, t);
-  const e = lerp3(b, c, t);
-  return [p[0], a, d, lerp3(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 = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? Math.min(1, Math.max(-1, v2 / 100)) : 0;
-function vectorWarpPresetMesh(preset, bounds) {
-  if (!VECTOR_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 = vectorWarpPresetGrid(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 vectorMeshColumns = (m) => 3 * (m.us.length - 1) + 1;
-var vectorMeshRows = (m) => 3 * (m.vs.length - 1) + 1;
-function isValidVectorMesh(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((v2, i) => typeof v2 === "number" && (i === 0 || v2 > 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 fitVectorMesh(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 clampCount = (n) => Math.min(64, Math.max(1, Math.round(Number.isFinite(n) ? n : 1)));
-function vectorIdentityMesh(bounds, columns = 1, rows = 1) {
-  return fitVectorMesh((s, t) => ({ x: bounds.x + s * bounds.width, y: bounds.y + t * bounds.height }), evenKnots(clampCount(columns)), evenKnots(clampCount(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 evalVectorMesh(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 = vectorMeshColumns(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 = vectorMeshColumns(m);
-  const ny = vectorMeshRows(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 splitVectorMeshU(m, s) {
-  const [pi, a] = locate(m.us, s);
-  if (!(a >= 0.01 && a <= 0.99)) return null;
-  const nx = vectorMeshColumns(m);
-  const ny = vectorMeshRows(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 splitVectorMeshV(m, t) {
-  const out = splitVectorMeshU(transposeMesh(m), t);
-  return out && transposeMesh(out);
-}
-function removeVectorMeshSplitU(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 = vectorMeshColumns(m);
-  const ny = vectorMeshRows(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 removeVectorMeshSplitV(m, k) {
-  const out = removeVectorMeshSplitU(transposeMesh(m), k);
-  return out && transposeMesh(out);
-}
-function mapVectorMeshPoints(m, f) {
-  return { us: m.us.slice(), vs: m.vs.slice(), points: m.points.map((p) => f(p)) };
-}
-function resizeVectorMesh(m, columns, rows) {
-  const cols = clampCount(columns);
-  const rws = clampCount(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, v2) => list.some((k) => Math.abs(k - v2) < 1e-12);
-  if (m.us.every((u) => has(us, u)) && m.vs.every((v2) => has(vs, v2))) {
-    let out = m;
-    for (const u of us) if (!has(out.us, u)) out = splitVectorMeshU(out, u) ?? out;
-    for (const v2 of vs) if (!has(out.vs, v2)) out = splitVectorMeshV(out, v2) ?? out;
-    return out;
-  }
-  return fitVectorMesh((s, t) => evalVectorMesh(m, s, t), us, vs);
-}
-function vectorMeshControlBounds(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 vectorMeshParamAt(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 = evalVectorMesh(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 = evalVectorMesh(m, s, t);
-    const qs = evalVectorMesh(m, s + h, t);
-    const qt = evalVectorMesh(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 = evalVectorMesh(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 = vectorMeshColumns(m);
-  i1 = Math.min(i1, nx);
-  j1 = Math.min(j1, vectorMeshRows(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 dragVectorMeshPoint(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 = vectorMeshColumns(base);
-  const ny = vectorMeshRows(base);
-  const i = index % nx;
-  const j = Math.floor(index / nx);
-  const shift = (ii, jj, v2) => {
-    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 + v2.x, y: p.y + v2.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 pullVectorMesh(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 = vectorMeshColumns(m);
-  const ny = vectorMeshRows(m);
-  const anchor = (ai, aj) => base.points[3 * aj * nx + 3 * ai] ?? { x: 0, y: 0 };
-  const at0 = evalVectorMesh(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, v2) => {
-    const p = m.points[idx];
-    m.points[idx] = { x: p.x + v2.x * k, y: p.y + v2.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 = evalVectorMesh(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 polylineAt(pts) {
   const acc = [0];
   for (let i = 1; i < pts.length; i++) acc.push(acc[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y));
@@ -2578,7 +2037,7 @@ function polylineAt(pts) {
     let i = 1;
     while (i < acc.length - 1 && acc[i] < L) i++;
     const seg = acc[i] - acc[i - 1];
-    return lerp3(pts[i - 1], pts[i], seg > 0 ? (L - acc[i - 1]) / seg : 0);
+    return lerpVec2(pts[i - 1], pts[i], seg > 0 ? (L - acc[i - 1]) / seg : 0);
   };
 }
 function sampleSubpath(sp, per = 24) {
@@ -2590,10 +2049,10 @@ function sampleSubpath(sp, per = 24) {
     const c = [{ x: a.x, y: a.y }, a.out ?? a, b.in ?? b, { x: b.x, y: b.y }];
     for (let k = 0; k < per; k++) {
       const t = k / per;
-      const ab = lerp3(c[0], c[1], t);
-      const bc = lerp3(c[1], c[2], t);
-      const cd = lerp3(c[2], c[3], t);
-      out.push(lerp3(lerp3(ab, bc, t), lerp3(bc, cd, t), t));
+      const ab = lerpVec2(c[0], c[1], t);
+      const bc = lerpVec2(c[1], c[2], t);
+      const cd = lerpVec2(c[2], c[3], t);
+      out.push(lerpVec2(lerpVec2(ab, bc, t), lerpVec2(bc, cd, t), t));
     }
   }
   return out;
@@ -2651,11 +2110,11 @@ function vectorMeshFromOutline(sp, columns = 4, rows = 4) {
       y: (1 - t) * T.y + t * B.y + (1 - s) * L.y + s * R.y - ((1 - s) * (1 - t) * p00.y + s * (1 - t) * p10.y + (1 - s) * t * p01.y + s * t * p11.y)
     };
   };
-  return fitVectorMesh(coons, evenKnots(clampCount(columns)), evenKnots(clampCount(rows)));
+  return fitWarpMesh(coons, evenKnots(clampMeshCount(columns)), evenKnots(clampMeshCount(rows)));
 }
 function vectorMeshOutline(m) {
-  const nx = vectorMeshColumns(m);
-  const ny = vectorMeshRows(m);
+  const nx = warpMeshColumns(m);
+  const ny = warpMeshRows(m);
   const pt2 = (i, j) => m.points[j * nx + i];
   const runs = [];
   for (let i = 0; i + 3 < nx; i += 3) runs.push([pt2(i, 0), pt2(i + 1, 0), pt2(i + 2, 0), pt2(i + 3, 0)]);
@@ -2668,31 +2127,6 @@ function vectorMeshOutline(m) {
   });
   return { closed: true, anchors };
 }
-function vectorMeshEditPoints(m) {
-  const nx = vectorMeshColumns(m);
-  const ny = vectorMeshRows(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 vectorMeshGridCurves(m) {
-  const nx = vectorMeshColumns(m);
-  const ny = vectorMeshRows(m);
-  const pt2 = (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([pt2(i, j), pt2(i + 1, j), pt2(i + 2, j), pt2(i + 3, j)]);
-  for (let i = 0; i < nx; i += 3) for (let j = 0; j + 3 < ny; j += 3) out.push([pt2(i, j), pt2(i, j + 1), pt2(i, j + 2), pt2(i, j + 3)]);
-  return out;
-}
 
 // src/vector/appearance.ts
 var VECTOR_EFFECT_DEFAULTS = {
@@ -2819,7 +2253,7 @@ var VECTOR_EFFECT_PARAM_SPECS = {
       key: "style",
       label: "Warp",
       kind: "select",
-      options: [...VECTOR_WARP_STYLES.map((value) => ({ value, label: VECTOR_WARP_STYLE_LABELS[value] })), { value: "mesh", label: "Mesh" }]
+      options: [...WARP_STYLES.map((value) => ({ value, label: WARP_STYLE_LABELS[value] })), { value: "mesh", label: "Mesh" }]
     },
     { key: "bend", label: "Bend %", kind: "number", min: -100, max: 100, step: 1, slider: true },
     { key: "horizontal", label: "Horizontal distortion %", kind: "number", min: -100, max: 100, step: 1, slider: true },
@@ -2839,16 +2273,16 @@ var VECTOR_EFFECT_PARAM_SPECS = {
 };
 var cloneMesh = (m) => ({ us: m.us.slice(), vs: m.vs.slice(), points: m.points.map((p) => ({ x: p.x, y: p.y })) });
 function vectorEnvelopeMesh(params, bounds) {
-  if (params.style === "mesh") return params.mesh ?? vectorIdentityMesh(bounds, params.columns, params.rows);
-  const preset = vectorWarpPresetMesh({ style: params.style, bend: params.bend, horizontal: params.horizontal, vertical: params.vertical, orientation: params.orientation }, bounds);
-  return preset ? resizeVectorMesh(preset, params.columns, params.rows) : vectorIdentityMesh(bounds, params.columns, params.rows);
+  if (params.style === "mesh") return params.mesh ?? identityWarpMesh(bounds, params.columns, params.rows);
+  const preset = warpPresetMesh({ style: params.style, bend: params.bend, horizontal: params.horizontal, vertical: params.vertical, orientation: params.orientation }, bounds);
+  return preset ? resizeWarpMesh(preset, params.columns, params.rows) : identityWarpMesh(bounds, params.columns, params.rows);
 }
 function vectorEnvelopeMap(params, bounds) {
   if (!bounds || !(bounds.width > 0 && bounds.height > 0)) return null;
-  const mesh = params.style === "mesh" ? params.mesh : vectorWarpPresetMesh({ style: params.style, bend: params.bend, horizontal: params.horizontal, vertical: params.vertical, orientation: params.orientation }, bounds);
+  const mesh = params.style === "mesh" ? params.mesh : warpPresetMesh({ style: params.style, bend: params.bend, horizontal: params.horizontal, vertical: params.vertical, orientation: params.orientation }, bounds);
   if (!mesh) return null;
   const { x, y, width, height } = bounds;
-  return (p) => evalVectorMesh(mesh, (p.x - x) / width, (p.y - y) / height);
+  return (p) => evalWarpMesh(mesh, (p.x - x) / width, (p.y - y) / height);
 }
 function pathsBounds(paths) {
   let minX = Infinity;
@@ -2890,12 +2324,12 @@ function normalizeVectorEffectParams(type, params, base) {
     o.rows = Math.round(o.rows);
     o.columns = Math.round(o.columns);
     const given = params?.mesh;
-    let mesh = given !== void 0 ? isValidVectorMesh(given) ? cloneMesh(given) : null : o.mesh;
+    let mesh = given !== void 0 ? isValidWarpMesh(given) ? cloneMesh(given) : null : o.mesh;
     if (o.style !== "mesh") mesh = null;
     if (mesh && given !== void 0) {
       o.columns = mesh.us.length - 1;
       o.rows = mesh.vs.length - 1;
-    } else if (mesh) mesh = resizeVectorMesh(mesh, o.columns, o.rows);
+    } else if (mesh) mesh = resizeWarpMesh(mesh, o.columns, o.rows);
     o.mesh = mesh;
   }
   return out;
@@ -3261,11 +2695,11 @@ function transformVectorEffects(effects, m, node) {
   const axisScale = Math.abs(m[1]) < 1e-12 && Math.abs(m[2]) < 1e-12 && m[0] > 0 && m[3] > 0;
   return effects.map((e) => {
     if (e.type === "envelope") {
-      if (e.params.style === "mesh") return e.params.mesh ? { ...e, params: { ...e.params, mesh: mapVectorMeshPoints(e.params.mesh, full) } } : e;
+      if (e.params.style === "mesh") return e.params.mesh ? { ...e, params: { ...e.params, mesh: mapWarpMeshPoints(e.params.mesh, full) } } : e;
       if (axisScale || !node) return e;
       const bounds = vectorEffectInputBounds(node, e.id);
       if (!bounds || !vectorEnvelopeMap(e.params, bounds)) return e;
-      return { ...e, params: { ...e.params, style: "mesh", mesh: mapVectorMeshPoints(vectorEnvelopeMesh(e.params, bounds), full) } };
+      return { ...e, params: { ...e.params, style: "mesh", mesh: mapWarpMeshPoints(vectorEnvelopeMesh(e.params, bounds), full) } };
     }
     if (e.type === "twist") return { ...e, params: { ...e.params, center: lin(e.params.center), angle: e.params.angle * mirror } };
     if (e.type === "repeater")
@@ -3540,55 +2974,6 @@ function nearestSegment(node, p) {
   });
   return best;
 }
-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 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, v2) {
-  return { x: m[0] * v2.x + m[2] * v2.y, y: m[1] * v2.x + m[3] * v2.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]
-  };
-}
 function mapAnchor(a, m) {
   const p = applyMatrix(m, a);
   const next = { x: p.x, y: p.y };
@@ -5856,30 +5241,8 @@ export {
   mapVectorPoints,
   mapVectorSubpaths,
   mapBezierPath,
-  VECTOR_WARP_STYLES,
-  VECTOR_WARP_STYLE_LABELS,
-  vectorWarpPresetGrid,
-  vectorWarpPresetMesh,
-  vectorMeshColumns,
-  vectorMeshRows,
-  isValidVectorMesh,
-  fitVectorMesh,
-  vectorIdentityMesh,
-  evalVectorMesh,
-  splitVectorMeshU,
-  splitVectorMeshV,
-  removeVectorMeshSplitU,
-  removeVectorMeshSplitV,
-  mapVectorMeshPoints,
-  resizeVectorMesh,
-  vectorMeshControlBounds,
-  vectorMeshParamAt,
-  dragVectorMeshPoint,
-  pullVectorMesh,
   vectorMeshFromOutline,
   vectorMeshOutline,
-  vectorMeshEditPoints,
-  vectorMeshGridCurves,
   VECTOR_EFFECT_DEFAULTS,
   VECTOR_EFFECT_LABELS,
   VECTOR_EFFECT_PARAM_SPECS,
@@ -5934,17 +5297,6 @@ export {
   vectorStrokeOutline,
   hitTestVectorNodes,
   nearestSegment,
-  IDENTITY_MATRIX,
-  multiplyMatrices,
-  translateMatrix,
-  scaleMatrix,
-  rotateMatrix,
-  applyMatrix,
-  isIdentityMatrix,
-  invertMatrix,
-  applyMatrixLinear,
-  matrixRotation,
-  decomposeRigid,
   transformVectorNode,
   vectorNodeRotation,
   vectorWorldMatrix,
@@ -5991,4 +5343,4 @@ export {
   parseSvgTransform,
   parseVectorSvg
 };
-//# sourceMappingURL=chunk-4JLB2USO.js.map
+//# sourceMappingURL=chunk-YGZNGDIT.js.map