@pixerate/editor 0.43.0 → 0.45.0

package/dist/vector/index.cjs

@@ -37,6 +37,7 @@ var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 
 
 
+
 
 
 var _chunkVNYRI265cjs = require('../chunk-VNYRI265.cjs');
@@ -79,11 +80,12 @@ var VECTOR_TOOLS = [
   "shapeBuilder",
   "paintBucket",
   "blend",
-  "gradient"
+  "gradient",
+  "envelope"
 ];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
-var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater"];
+var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater", "envelope"];
 var VECTOR_MERGE_MODES = ["merge", "add", "subtract", "intersect", "exclude"];
 
 // src/vector/gradient.ts
@@ -482,6 +484,14 @@ function transformVectorGradient(g, m) {
   const p = vectorGradientPoints(g);
   return { ...g, start: apply(m, p.start), end: apply(m, p.end), width: apply(m, p.width), ...p.focal ? { focal: apply(m, p.focal) } : {} };
 }
+function mapVectorGradient(g, f) {
+  if (!hasExplicitGradientGeometry(g) || g.units !== "userSpaceOnUse") return g;
+  const p = vectorGradientPoints(g);
+  return { ...g, start: f(p.start), end: f(p.end), width: f(p.width), ...p.focal ? { focal: f(p.focal) } : {} };
+}
+function mapVectorPaint(paint, f) {
+  return isVectorGradient(paint) ? mapVectorGradient(paint, f) : paint;
+}
 function transformVectorPaint(paint, m) {
   return isVectorGradient(paint) ? transformVectorGradient(paint, m) : paint;
 }
@@ -1179,8 +1189,8 @@ function widthProfilePreset(id) {
 }
 function widthProfilePresetId(points) {
   if (isUniformWidthProfile(points)) return "uniform";
-  const same = (a, b) => a.length === b.length && a.every((p, i) => Math.abs(p.t - b[i].t) < 1e-9 && Math.abs(p.left - b[i].left) < 1e-9 && Math.abs(p.right - b[i].right) < 1e-9);
-  return _nullishCoalesce(_optionalChain([VECTOR_WIDTH_PRESETS, 'access', _20 => _20.find, 'call', _21 => _21((p) => p.points.length && same(points, p.points)), 'optionalAccess', _22 => _22.id]), () => ( "custom"));
+  const same2 = (a, b) => a.length === b.length && a.every((p, i) => Math.abs(p.t - b[i].t) < 1e-9 && Math.abs(p.left - b[i].left) < 1e-9 && Math.abs(p.right - b[i].right) < 1e-9);
+  return _nullishCoalesce(_optionalChain([VECTOR_WIDTH_PRESETS, 'access', _20 => _20.find, 'call', _21 => _21((p) => p.points.length && same2(points, p.points)), 'optionalAccess', _22 => _22.id]), () => ( "custom"));
 }
 function reverseWidthProfile(points) {
   return points.map((p) => ({ t: 1 - p.t, left: p.right, right: p.left })).reverse();
@@ -1200,10 +1210,10 @@ function insertWidthPoint(points, t, sides2 = {}, options = {}) {
     left: _nullishCoalesce(clean(sides2.left, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.left)),
     right: _nullishCoalesce(clean(sides2.right, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.right))
   };
-  const same = pts.findIndex((q) => Math.abs(q.t - tt) <= VECTOR_WIDTH_SAME_T);
-  if (same >= 0 && !options.step) {
-    pts[same] = { ...p, t: pts[same].t };
-    return { points: pts, index: same };
+  const same2 = pts.findIndex((q) => Math.abs(q.t - tt) <= VECTOR_WIDTH_SAME_T);
+  if (same2 >= 0 && !options.step) {
+    pts[same2] = { ...p, t: pts[same2].t };
+    return { points: pts, index: same2 };
   }
   let i = 0;
   while (i < pts.length && pts[i].t <= tt) i++;
@@ -1743,13 +1753,13 @@ function endOf(segs, atStart) {
   const last = segs[segs.length - 1];
   return { p: toVec(last[last.length - 1]), out: v(t[0], t[1]) };
 }
-function pointAlong(segs, fromStart, dist4) {
+function pointAlong(segs, fromStart, dist5) {
   const order = fromStart ? segs : [...segs].reverse();
   let acc = 0;
   for (const s of order) {
     const l = segLen(s);
-    if (acc + l >= dist4) {
-      const want = fromStart ? dist4 - acc : l - (dist4 - acc);
+    if (acc + l >= dist5) {
+      const want = fromStart ? dist5 - acc : l - (dist5 - acc);
       const pts = _chunkVNYRI265cjs.trimSegments.call(void 0, [s], 0, want);
       const p = pts.length ? pts[0][pts[0].length - 1] : s[0];
       return toVec(p);
@@ -2231,6 +2241,846 @@ function pathsCenter(paths) {
   return b ? { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 } : { x: 0, y: 0 };
 }
 
+// src/vector/pathMap.ts
+var MAX_PIECES = 1 << 20;
+var MAX_DEPTH = 6;
+var PROBES = [0.25, 0.5, 0.75];
+var lerp2 = (a, b, t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+var dist2 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var same = (a, b) => Math.abs(a.x - b.x) < 1e-9 && Math.abs(a.y - b.y) < 1e-9;
+function evalCubic(s, t) {
+  const ab = lerp2(s[0], s[1], t);
+  const bc = lerp2(s[1], s[2], t);
+  const cd = lerp2(s[2], s[3], t);
+  return lerp2(lerp2(ab, bc, t), lerp2(bc, cd, t), t);
+}
+function halves(s) {
+  const ab = lerp2(s[0], s[1], 0.5);
+  const bc = lerp2(s[1], s[2], 0.5);
+  const cd = lerp2(s[2], s[3], 0.5);
+  const abc = lerp2(ab, bc, 0.5);
+  const bcd = lerp2(bc, cd, 0.5);
+  const m = lerp2(abc, bcd, 0.5);
+  return [
+    [s[0], ab, abc, m],
+    [m, bcd, cd, s[3]]
+  ];
+}
+function offLine(p, a, b) {
+  const l = dist2(a, b);
+  return l < 1e-12 ? dist2(p, a) : Math.abs((b.x - a.x) * (a.y - p.y) - (a.x - p.x) * (b.y - a.y)) / l;
+}
+var mapAnchorPoints = (a, f) => {
+  const p = f(a);
+  return {
+    x: p.x,
+    y: p.y,
+    ...a.in ? { in: f(a.in) } : {},
+    ...a.out ? { out: f(a.out) } : {},
+    ...a.type && a.type !== "corner" ? { type: a.type } : {},
+    ...a.corner ? { corner: { ...a.corner } } : {}
+  };
+};
+function mapVectorPoints(subpaths, f) {
+  return subpaths.map((sp) => ({ closed: sp.closed, anchors: sp.anchors.map((a) => mapAnchorPoints(a, f)) }));
+}
+function splitMapped(seg, f, tol, depth, out) {
+  const mapped = seg.map(f);
+  const fits = PROBES.every((t) => dist2(f(evalCubic(seg, t)), evalCubic(mapped, t)) <= tol);
+  if (fits || depth === 0) {
+    out.push(mapped);
+    return;
+  }
+  const [a, b] = halves(seg);
+  splitMapped(a, f, tol, depth - 1, out);
+  splitMapped(b, f, tol, depth - 1, out);
+}
+var toPoint = (p) => [p.x, p.y];
+var toVec2 = (p) => ({ x: p[0], y: p[1] });
+function refit(seg, pieces, f, tol) {
+  if (pieces.length < 3) return pieces;
+  const n = pieces.length * 4;
+  const samples = [];
+  for (let i = 0; i <= n; i++) samples.push(toPoint(f(evalCubic(seg, i / n))));
+  const first = pieces[0];
+  const last = pieces[pieces.length - 1];
+  const t0 = !same(first[1], first[0]) ? first[1] : first[2];
+  const t1 = !same(last[2], last[3]) ? last[2] : last[1];
+  const fitted = _chunkVNYRI265cjs.fitCubicRun.call(void 0, samples, tol / 2, [t0.x - first[0].x, t0.y - first[0].y], [last[3].x - t1.x, last[3].y - t1.y]);
+  if (!fitted.length || fitted.length >= pieces.length) return pieces;
+  const chain = fitted.map((c) => [c.p0, c.p1, c.p2, c.p3]);
+  for (let i = 0; i < n; i++) {
+    const q = toPoint(f(evalCubic(seg, (i + 0.5) / n)));
+    let best = Infinity;
+    for (const c of chain) best = Math.min(best, _chunkVNYRI265cjs.segmentNearest.call(void 0, c, q).distance);
+    if (best > tol) return pieces;
+  }
+  return fitted.map((c) => [toVec2(c.p0), toVec2(c.p1), toVec2(c.p2), toVec2(c.p3)]);
+}
+function mapSegment(seg, f, tol, depth, fit) {
+  if (same(seg[1], seg[0]) && same(seg[2], seg[3])) {
+    const a = f(seg[0]);
+    const b = f(seg[3]);
+    if (PROBES.every((t) => offLine(f(lerp2(seg[0], seg[3], t)), a, b) <= tol)) return [[a, a, b, b]];
+    const line2 = [seg[0], lerp2(seg[0], seg[3], 1 / 3), lerp2(seg[0], seg[3], 2 / 3), seg[3]];
+    const out2 = [];
+    splitMapped(line2, f, tol, depth, out2);
+    return fit ? refit(line2, out2, f, tol) : out2;
+  }
+  const out = [];
+  splitMapped(seg, f, tol, depth, out);
+  return fit ? refit(seg, out, f, tol) : out;
+}
+function realign(a) {
+  if (!a.in || !a.out || same(a.in, a) || same(a.out, a)) return a;
+  const li = dist2(a.in, a);
+  const lo = dist2(a.out, a);
+  const dx = (a.x - a.in.x) / li + (a.out.x - a.x) / lo;
+  const dy = (a.y - a.in.y) / li + (a.out.y - a.y) / lo;
+  const l = Math.hypot(dx, dy);
+  if (l < 1e-12) return a;
+  const u = { x: dx / l, y: dy / l };
+  const type = a.type === "symmetric" && Math.abs(li - lo) > 1e-6 * Math.max(li, lo) ? "smooth" : a.type;
+  return { ...a, in: { x: a.x - u.x * li, y: a.y - u.y * li }, out: { x: a.x + u.x * lo, y: a.y + u.y * lo }, ...type ? { type } : {} };
+}
+var segmentOf = (sp, i) => {
+  const a = sp.anchors[i];
+  const b = sp.anchors[(i + 1) % sp.anchors.length];
+  return [{ x: a.x, y: a.y }, _nullishCoalesce(a.out, () => ( { x: a.x, y: a.y })), _nullishCoalesce(b.in, () => ( { x: b.x, y: b.y })), { x: b.x, y: b.y }];
+};
+function mapSubpath(sp, f, tol, depth, fit) {
+  const n = sp.anchors.length;
+  const count = n < 2 ? 0 : sp.closed ? n : n - 1;
+  if (!count) return mapVectorPoints([sp], f)[0];
+  const pieces = [];
+  for (let i = 0; i < count; i++) pieces.push(mapSegment(segmentOf(sp, i), f, tol, depth, fit));
+  const anchors = [];
+  const put = (a) => {
+    if (a.in && same(a.in, a)) delete a.in;
+    if (a.out && same(a.out, a)) delete a.out;
+    anchors.push(a.type === "smooth" || a.type === "symmetric" ? realign(a) : a);
+  };
+  sp.anchors.forEach((k, i) => {
+    const incoming = i > 0 ? pieces[i - 1] : sp.closed ? pieces[n - 1] : void 0;
+    const outgoing = pieces[i];
+    const p = f(k);
+    const a = { x: p.x, y: p.y };
+    const inCtrl = incoming ? incoming[incoming.length - 1][2] : k.in ? f(k.in) : null;
+    const outCtrl = outgoing ? outgoing[0][1] : k.out ? f(k.out) : null;
+    if (inCtrl) a.in = inCtrl;
+    if (outCtrl) a.out = outCtrl;
+    if (k.type && k.type !== "corner") a.type = k.type;
+    if (k.corner) a.corner = { ...k.corner };
+    put(a);
+    if (outgoing) for (let w = 1; w < outgoing.length; w++) put({ x: outgoing[w][0].x, y: outgoing[w][0].y, in: outgoing[w - 1][2], out: outgoing[w][1], type: "smooth" });
+  });
+  return { closed: sp.closed, anchors };
+}
+function mapVectorSubpaths(subpaths, f, tolerance = 0.1, options = {}) {
+  const tol = Number.isFinite(tolerance) && tolerance > 0 ? tolerance : 0.1;
+  const segments = subpaths.reduce((s, sp) => s + sp.anchors.length, 0);
+  let depth = MAX_DEPTH;
+  while (depth > 0 && segments * 2 ** depth > MAX_PIECES) depth--;
+  return subpaths.map((sp) => mapSubpath(sp, f, tol, depth, options.refit !== false));
+}
+function mapBezierPath(path, f, tolerance = 0.1, options = {}) {
+  return subpathsToBezier(mapVectorSubpaths(bezierToSubpaths(path), f, tolerance, options), { corners: false });
+}
+
+// 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 = _nullishCoalesce(splitVectorMeshU(out, u), () => ( out));
+    for (const v2 of vs) if (!has(out.vs, v2)) out = _nullishCoalesce(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) => _nullishCoalesce(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));
+  const total = acc[acc.length - 1];
+  return (u) => {
+    if (!(total > 0)) return pts[0];
+    const L = Math.min(1, Math.max(0, u)) * total;
+    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);
+  };
+}
+function sampleSubpath(sp, per = 24) {
+  const n = sp.anchors.length;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const a = sp.anchors[i];
+    const b = sp.anchors[(i + 1) % n];
+    const c = [{ x: a.x, y: a.y }, _nullishCoalesce(a.out, () => ( a)), _nullishCoalesce(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));
+    }
+  }
+  return out;
+}
+function vectorMeshFromOutline(sp, columns = 4, rows = 4) {
+  if (!sp.closed || sp.anchors.length < 2) return null;
+  let ring = sampleSubpath(sp);
+  const xs = ring.map((p) => p.x);
+  const ys = ring.map((p) => p.y);
+  const box = { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) };
+  if (!(box.x1 - box.x0 > 1e-9 && box.y1 - box.y0 > 1e-9)) return null;
+  const nearest = (c2) => {
+    let best = 0;
+    for (let i = 1; i < ring.length; i++) if (Math.hypot(ring[i].x - c2.x, ring[i].y - c2.y) < Math.hypot(ring[best].x - c2.x, ring[best].y - c2.y)) best = i;
+    return best;
+  };
+  const cornersOf = () => [
+    { x: box.x0, y: box.y0 },
+    { x: box.x1, y: box.y0 },
+    { x: box.x1, y: box.y1 },
+    { x: box.x0, y: box.y1 }
+  ].map(nearest);
+  let c = cornersOf();
+  const n = ring.length;
+  const fwd = (from, to) => (to - from + n) % n;
+  if (!(fwd(c[0], c[1]) < fwd(c[0], c[2]) && fwd(c[0], c[2]) < fwd(c[0], c[3]))) {
+    ring = ring.slice().reverse();
+    c = cornersOf();
+    if (!(fwd(c[0], c[1]) < fwd(c[0], c[2]) && fwd(c[0], c[2]) < fwd(c[0], c[3]))) return null;
+  }
+  if (new Set(c).size < 4) return null;
+  const walk = (from, to) => {
+    const out = [];
+    for (let i = from; ; i = (i + 1) % n) {
+      out.push(ring[i]);
+      if (i === to) break;
+    }
+    return out;
+  };
+  const top = polylineAt(walk(c[0], c[1]));
+  const right = polylineAt(walk(c[1], c[2]));
+  const bottomLR = polylineAt(walk(c[2], c[3]).reverse());
+  const leftTB = polylineAt(walk(c[3], c[0]).reverse());
+  const p00 = top(0);
+  const p10 = top(1);
+  const p01 = bottomLR(0);
+  const p11 = bottomLR(1);
+  const coons = (s, t) => {
+    const T = top(s);
+    const B = bottomLR(s);
+    const L = leftTB(t);
+    const R = right(t);
+    return {
+      x: (1 - t) * T.x + t * B.x + (1 - s) * L.x + s * R.x - ((1 - s) * (1 - t) * p00.x + s * (1 - t) * p10.x + (1 - s) * t * p01.x + s * t * p11.x),
+      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)));
+}
+function vectorMeshOutline(m) {
+  const nx = vectorMeshColumns(m);
+  const ny = vectorMeshRows(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)]);
+  for (let j = 0; j + 3 < ny; j += 3) runs.push([pt2(nx - 1, j), pt2(nx - 1, j + 1), pt2(nx - 1, j + 2), pt2(nx - 1, j + 3)]);
+  for (let i = nx - 1; i - 3 >= 0; i -= 3) runs.push([pt2(i, ny - 1), pt2(i - 1, ny - 1), pt2(i - 2, ny - 1), pt2(i - 3, ny - 1)]);
+  for (let j = ny - 1; j - 3 >= 0; j -= 3) runs.push([pt2(0, j), pt2(0, j - 1), pt2(0, j - 2), pt2(0, j - 3)]);
+  const anchors = runs.map((r, k) => {
+    const prev = runs[(k + runs.length - 1) % runs.length];
+    return { x: r[0].x, y: r[0].y, in: { ...prev[2] }, out: { ...r[1] } };
+  });
+  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 = {
   trim: { start: 0, end: 50, offset: 0, mode: "simultaneous" },
@@ -2251,7 +3101,8 @@ var VECTOR_EFFECT_DEFAULTS = {
     startOpacity: 100,
     endOpacity: 100,
     composite: "below"
-  }
+  },
+  envelope: { style: "arc", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", rows: 2, columns: 2, mesh: null }
 };
 var VECTOR_EFFECT_LABELS = {
   trim: "Trim Paths",
@@ -2262,7 +3113,8 @@ var VECTOR_EFFECT_LABELS = {
   wiggle: "Wiggle Paths",
   offset: "Offset Paths",
   merge: "Merge Paths",
-  repeater: "Repeater"
+  repeater: "Repeater",
+  envelope: "Envelope"
 };
 var VECTOR_EFFECT_PARAM_SPECS = {
   trim: [
@@ -2348,8 +3200,65 @@ var VECTOR_EFFECT_PARAM_SPECS = {
         { value: "above", label: "Above" }
       ]
     }
+  ],
+  envelope: [
+    {
+      key: "style",
+      label: "Warp",
+      kind: "select",
+      options: [...VECTOR_WARP_STYLES.map((value) => ({ value, label: VECTOR_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 },
+    { key: "vertical", label: "Vertical distortion %", kind: "number", min: -100, max: 100, step: 1, slider: true },
+    {
+      key: "orientation",
+      label: "Orientation",
+      kind: "select",
+      options: [
+        { value: "horizontal", label: "Horizontal" },
+        { value: "vertical", label: "Vertical" }
+      ]
+    },
+    { key: "rows", label: "Mesh rows", kind: "number", min: 1, max: 16, step: 1 },
+    { key: "columns", label: "Mesh columns", kind: "number", min: 1, max: 16, step: 1 }
   ]
 };
+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 _nullishCoalesce(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);
+}
+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);
+  if (!mesh) return null;
+  const { x, y, width, height } = bounds;
+  return (p) => evalVectorMesh(mesh, (p.x - x) / width, (p.y - y) / height);
+}
+function pathsBounds(paths) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of paths) {
+    const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, p);
+    if (!b) continue;
+    minX = Math.min(minX, b.minX);
+    minY = Math.min(minY, b.minY);
+    maxX = Math.max(maxX, b.maxX);
+    maxY = Math.max(maxY, b.maxY);
+  }
+  return minX <= maxX ? { x: minX, y: minY, width: maxX - minX, height: maxY - minY } : null;
+}
+function envelopePaths(paths, params) {
+  const bounds = pathsBounds(paths);
+  const f = vectorEnvelopeMap(params, bounds);
+  if (!f || !bounds) return paths;
+  const tol = Math.min(0.25, Math.max(0.01, Math.hypot(bounds.width, bounds.height) / 2e3));
+  return paths.map((p) => p.length ? mapBezierPath(p, f, tol) : p);
+}
 var isVec2 = (v2) => !!v2 && typeof v2 === "object" && Number.isFinite(v2.x) && Number.isFinite(v2.y);
 function normalizeVectorEffectParams(type, params, base) {
   const defaults = VECTOR_EFFECT_DEFAULTS[type];
@@ -2363,6 +3272,19 @@ function normalizeVectorEffectParams(type, params, base) {
     else if (spec.kind === "vec2" && isVec2(v2)) out[spec.key] = { x: v2.x, y: v2.y };
     else if (spec.kind === "select" && spec.options.some((o) => o.value === v2)) out[spec.key] = v2;
   }
+  if (type === "envelope") {
+    const o = out;
+    o.rows = Math.round(o.rows);
+    o.columns = Math.round(o.columns);
+    const given = _optionalChain([params, 'optionalAccess', _52 => _52.mesh]);
+    let mesh = given !== void 0 ? isValidVectorMesh(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);
+    o.mesh = mesh;
+  }
   return out;
 }
 function createVectorEffect(type, id, params) {
@@ -2371,10 +3293,10 @@ function createVectorEffect(type, id, params) {
 }
 var isEnabled = (e) => e.enabled !== false && !!VECTOR_EFFECT_DEFAULTS[e.type];
 function activeVectorEffects(node) {
-  return _nullishCoalesce(_optionalChain([node, 'access', _52 => _52.effects, 'optionalAccess', _53 => _53.filter, 'call', _54 => _54(isEnabled)]), () => ( []));
+  return _nullishCoalesce(_optionalChain([node, 'access', _53 => _53.effects, 'optionalAccess', _54 => _54.filter, 'call', _55 => _55(isEnabled)]), () => ( []));
 }
 function hasOwnVectorAppearance(node) {
-  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _55 => _55.effects, 'optionalAccess', _56 => _56.some, 'call', _57 => _57(isEnabled)]);
+  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _56 => _56.effects, 'optionalAccess', _57 => _57.some, 'call', _58 => _58(isEnabled)]);
 }
 var liveCache = /* @__PURE__ */ new WeakMap();
 function hasVectorAppearance(node) {
@@ -2386,7 +3308,7 @@ function hasVectorAppearance(node) {
   return v2;
 }
 function isVectorLiveBoolean(node) {
-  return _optionalChain([node, 'optionalAccess', _58 => _58.type]) === "group" && !!node.liveBoolean;
+  return _optionalChain([node, 'optionalAccess', _59 => _59.type]) === "group" && !!node.liveBoolean;
 }
 function vectorOperandOperation(group, child) {
   return _nullishCoalesce(_nullishCoalesce(child.booleanOperation, () => ( group.liveBoolean)), () => ( "union"));
@@ -2503,7 +3425,7 @@ var compareOrder = (a, b) => {
   for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
   return a.length - b.length;
 };
-var add3 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _59 => _59.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _60 => _60.y]), () => ( 0))) });
+var add3 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _60 => _60.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _61 => _61.y]), () => ( 0))) });
 var mapPaths = (shapes, fn) => {
   const out = fn(shapes.map((s) => s.path));
   return shapes.map((s, i) => ({ ...s, path: _nullishCoalesce(out[i], () => ( [])) }));
@@ -2543,6 +3465,11 @@ function applyVectorEffects(shapes, effects) {
         list = [{ ...first, path: mergePaths(list.map((s) => s.path), e.params.mode) }];
         break;
       }
+      case "envelope": {
+        const params = e.params;
+        list = mapPaths(list, (p) => envelopePaths(p, params));
+        break;
+      }
       case "repeater": {
         const r = e.params;
         const copies = repeatPaths(
@@ -2589,14 +3516,35 @@ function liveBooleanShapes(group) {
   return [{ source, path: foldVectorBooleanOperands(operands), opacity: 1, order: [0] }];
 }
 var shapeCache = /* @__PURE__ */ new WeakMap();
+function baseShapes(node) {
+  if (node.type === "path") return [{ source: node, path: subpathsToBezier(node.subpaths), opacity: 1, order: [] }];
+  if (node.liveBoolean) return liveBooleanShapes(node);
+  return node.children.flatMap((c, i) => childShapes(c, i));
+}
+function vectorEffectInputPaths(node, effectId) {
+  const list = _nullishCoalesce(node.effects, () => ( []));
+  const i = list.findIndex((e) => e.id === effectId);
+  if (i < 0) return null;
+  return applyVectorEffects(baseShapes(node), list.slice(0, i)).map((s) => s.path);
+}
+function vectorEffectInputBounds(node, effectId) {
+  const paths = vectorEffectInputPaths(node, effectId);
+  return paths ? pathsBounds(paths) : null;
+}
+function vectorNodeEnvelope(node) {
+  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _62 => _62.effects, 'optionalAccess', _63 => _63.find, 'call', _64 => _64((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
+}
+function vectorEnvelopeFrame(node, effectId) {
+  const e = effectId ? _optionalChain([node, 'access', _65 => _65.effects, 'optionalAccess', _66 => _66.find, 'call', _67 => _67((x) => x.id === effectId)]) : vectorNodeEnvelope(node);
+  if (!e || e.type !== "envelope") return null;
+  const bounds = vectorEffectInputBounds(node, e.id);
+  if (!bounds || !(bounds.width > 0 && bounds.height > 0)) return null;
+  return { effectId: e.id, bounds, mesh: vectorEnvelopeMesh(e.params, bounds) };
+}
 function vectorAppearanceShapes(node) {
   const hit = shapeCache.get(node);
   if (hit) return hit;
-  let base;
-  if (node.type === "path") base = [{ source: node, path: subpathsToBezier(node.subpaths), opacity: 1, order: [] }];
-  else if (node.liveBoolean) base = liveBooleanShapes(node);
-  else base = node.children.flatMap((c, i) => childShapes(c, i));
-  const out = applyVectorEffects(base, node.effects).sort((a, b) => compareOrder(a.order, b.order));
+  const out = applyVectorEffects(baseShapes(node), node.effects).sort((a, b) => compareOrder(a.order, b.order));
   shapeCache.set(node, out);
   return out;
 }
@@ -2693,10 +3641,19 @@ function sanitizeVectorEffects(value) {
   }
   return out;
 }
-function transformVectorEffects(effects, m) {
+function transformVectorEffects(effects, m, node) {
   const lin = (v2) => ({ x: m[0] * v2.x + m[2] * v2.y, y: m[1] * v2.x + m[3] * v2.y });
+  const full = (v2) => ({ x: m[0] * v2.x + m[2] * v2.y + m[4], y: m[1] * v2.x + m[3] * v2.y + m[5] });
   const mirror = m[0] * m[3] - m[1] * m[2] < 0 ? -1 : 1;
+  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 (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) } };
+    }
     if (e.type === "twist") return { ...e, params: { ...e.params, center: lin(e.params.center), angle: e.params.angle * mirror } };
     if (e.type === "repeater")
       return { ...e, params: { ...e.params, position: lin(e.params.position), anchor: lin(e.params.anchor), rotation: e.params.rotation * mirror } };
@@ -2931,7 +3888,7 @@ function boundsFromPoints(a, b) {
 }
 function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX, options = {}) {
   if (node.visible === false) return false;
-  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _61 => _61.entered, 'optionalAccess', _62 => _62.has, 'call', _63 => _63(node.id)])))) node = expandVectorAppearance(node);
+  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _68 => _68.entered, 'optionalAccess', _69 => _69.has, 'call', _70 => _70(node.id)])))) node = expandVectorAppearance(node);
   if (node.type === "group") {
     const m = multiplyMatrices(nodeMatrix(node), parent);
     return node.children.some((c) => hitTestVectorNode(c, p, tolerance, m, options));
@@ -3030,17 +3987,17 @@ function mapAnchor(a, m) {
 }
 function bakeIntoGeometry(node, m) {
   if (isIdentityMatrix(m)) return node;
-  if (_optionalChain([node, 'access', _64 => _64.effects, 'optionalAccess', _65 => _65.length])) node = { ...node, effects: transformVectorEffects(node.effects, m) };
+  if (_optionalChain([node, 'access', _71 => _71.effects, 'optionalAccess', _72 => _72.length])) node = { ...node, effects: transformVectorEffects(node.effects, m, node) };
   if (node.type === "group") {
     const group = node;
     const children = group.children.map((c) => transformVectorNode(c, m));
-    const spine = _optionalChain([group, 'access', _66 => _66.blend, 'optionalAccess', _67 => _67.spine]);
+    const spine = _optionalChain([group, 'access', _73 => _73.blend, 'optionalAccess', _74 => _74.spine]);
     if (!spine) return { ...group, children };
     const moved = { closed: spine.closed, anchors: spine.anchors.map((a) => mapAnchor(a, m)) };
     return { ...group, children, blend: { ...group.blend, spine: moved } };
   }
   const path = node;
-  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _68 => _68.strokeWidthProfile, 'optionalAccess', _69 => _69.length]);
+  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _75 => _75.strokeWidthProfile, 'optionalAccess', _76 => _76.length]);
   return {
     ...path,
     ...mirrored ? { strokeWidthProfile: mirrorWidthProfile(path.strokeWidthProfile) } : {},
@@ -3414,7 +4371,7 @@ function applyVectorCornersAttribute(subpaths, value) {
   for (const item of value.trim().split(/\s+/)) {
     const m = /^(\d+)\.(\d+):([\d.eE+-]+)(?::([a-z]+))?$/.exec(item);
     if (!m) continue;
-    const a = _optionalChain([subpaths, 'access', _70 => _70[+m[1]], 'optionalAccess', _71 => _71.anchors, 'access', _72 => _72[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _77 => _77[+m[1]], 'optionalAccess', _78 => _78.anchors, 'access', _79 => _79[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -3436,7 +4393,7 @@ function vectorPaintToSvg(paint, gradientId, options = {}) {
   const precision = _nullishCoalesce(options.precision, () => ( 3));
   const key = `${gradientId}|${role}|${precision}`;
   const owner = _nullishCoalesce(options.node, () => ( paint));
-  const cached = _optionalChain([paintCache, 'access', _73 => _73.get, 'call', _74 => _74(owner), 'optionalAccess', _75 => _75.get, 'call', _76 => _76(key)]);
+  const cached = _optionalChain([paintCache, 'access', _80 => _80.get, 'call', _81 => _81(owner), 'optionalAccess', _82 => _82.get, 'call', _83 => _83(key)]);
   if (cached && (!options.node || (role === "fill" ? options.node.fill : options.node.stroke) === paint)) return { value: `url(#${gradientId})`, defs: cached };
   const node = options.node;
   const bounds = node ? vectorPathLocalBounds(node) : null;
@@ -3555,7 +4512,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (hasOwnVectorAppearance(node)) {
       const live2 = {
         kind: node.type,
-        ..._optionalChain([node, 'access', _77 => _77.effects, 'optionalAccess', _78 => _78.length]) ? { effects: node.effects } : {},
+        ..._optionalChain([node, 'access', _84 => _84.effects, 'optionalAccess', _85 => _85.length]) ? { effects: node.effects } : {},
         ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {}
       };
       lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr(JSON.stringify(live2))}">`);
@@ -3588,7 +4545,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       let out2 = ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num2(width)}"`;
       if (node.strokeLinecap && node.strokeLinecap !== "butt") out2 += ` stroke-linecap="${node.strokeLinecap}"`;
       if (node.strokeLinejoin && node.strokeLinejoin !== "miter") out2 += ` stroke-linejoin="${node.strokeLinejoin}"`;
-      if (_optionalChain([node, 'access', _79 => _79.strokeDasharray, 'optionalAccess', _80 => _80.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
+      if (_optionalChain([node, 'access', _86 => _86.strokeDasharray, 'optionalAccess', _87 => _87.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
       return out2;
     };
     const parts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${prefix}clip-${node.id}`, precision) : void 0;
@@ -3608,7 +4565,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       data += ` data-vector-width-profile="${widthProfileToAttribute(profile)}"`;
       if (node.strokeLinecap && node.strokeLinecap !== "butt") data += ` data-vector-stroke-linecap="${node.strokeLinecap}"`;
       if (node.strokeLinejoin && node.strokeLinejoin !== "miter") data += ` data-vector-stroke-linejoin="${node.strokeLinejoin}"`;
-      if (_optionalChain([node, 'access', _81 => _81.strokeDasharray, 'optionalAccess', _82 => _82.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
+      if (_optionalChain([node, 'access', _88 => _88.strokeDasharray, 'optionalAccess', _89 => _89.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
     }
     lines.push(`${indent(depth)}<g${common(node)}${data}>`);
     lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}"${fillAttrs}${live}/>`);
@@ -3791,9 +4748,9 @@ function resolveGradient(id, raw) {
   for (let el = first; el && !chain.includes(el) && chain.length < 32; ) {
     chain.push(el);
     const href = _nullishCoalesce(el.attrs.href, () => ( el.attrs["xlink:href"]));
-    el = _optionalChain([href, 'optionalAccess', _83 => _83.startsWith, 'call', _84 => _84("#")]) ? raw.get(href.slice(1)) : void 0;
+    el = _optionalChain([href, 'optionalAccess', _90 => _90.startsWith, 'call', _91 => _91("#")]) ? raw.get(href.slice(1)) : void 0;
   }
-  const attr = (name) => _optionalChain([chain, 'access', _85 => _85.find, 'call', _86 => _86((el) => el.attrs[name] !== void 0), 'optionalAccess', _87 => _87.attrs, 'access', _88 => _88[name]]);
+  const attr = (name) => _optionalChain([chain, 'access', _92 => _92.find, 'call', _93 => _93((el) => el.attrs[name] !== void 0), 'optionalAccess', _94 => _94.attrs, 'access', _95 => _95[name]]);
   const stops = _nullishCoalesce(chain.map(readStops).find((s) => s.length), () => ( []));
   if (!stops.length) return null;
   const user = attr("gradientUnits") === "userSpaceOnUse";
@@ -3835,8 +4792,8 @@ function resolveGradient(id, raw) {
     const len2 = Math.hypot(x2 - x1, y2 - y1);
     const d = len2 > 0 ? { x: (x2 - x1) / len2, y: (y2 - y1) / len2 } : { x: 0, y: 1 };
     const along2 = (x, y) => x * d.x + y * d.y;
-    const same = len2 > 0 && Math.abs((c.x2 - c.x1) * d.y - (c.y2 - c.y1) * d.x) < 1e-3 && Math.abs(along2(c.x1, c.y1) - along2(x1, y1)) < 1e-3 && Math.abs(along2(c.x2, c.y2) - along2(x2, y2)) < 1e-3;
-    if (same) return { type: "linear", angle, stops, ...spread };
+    const same2 = len2 > 0 && Math.abs((c.x2 - c.x1) * d.y - (c.y2 - c.y1) * d.x) < 1e-3 && Math.abs(along2(c.x1, c.y1) - along2(x1, y1)) < 1e-3 && Math.abs(along2(c.x2, c.y2) - along2(x2, y2)) < 1e-3;
+    if (same2) return { type: "linear", angle, stops, ...spread };
   }
   const start = { x: x1, y: y1 };
   const end = { x: x2, y: y2 };
@@ -3943,7 +4900,7 @@ function parseVectorSvg(svg, options = {}) {
     const part = (name) => g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === name);
     const fillEl = part("fill");
     const subpaths = fillEl ? shapeOf(fillEl) : null;
-    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _89 => _89.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _96 => _96.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style);
     const strokeEl = part("stroke");
@@ -3980,7 +4937,7 @@ function parseVectorSvg(svg, options = {}) {
       ...profile.length ? { strokeWidthProfile: profile } : {},
       ...keptCap ? { strokeLinecap: keptCap } : {},
       ...keptJoin ? { strokeLinejoin: keptJoin } : {},
-      ..._optionalChain([keptDash, 'optionalAccess', _90 => _90.length]) ? { strokeDasharray: keptDash } : {}
+      ..._optionalChain([keptDash, 'optionalAccess', _97 => _97.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
@@ -4653,7 +5610,7 @@ function interpolateVectorPaint(a, b, t) {
   return t < 0.5 ? a : b;
 }
 function interpolateWidthProfiles(a, b, t) {
-  if (!_optionalChain([a, 'optionalAccess', _91 => _91.length]) && !_optionalChain([b, 'optionalAccess', _92 => _92.length])) return null;
+  if (!_optionalChain([a, 'optionalAccess', _98 => _98.length]) && !_optionalChain([b, 'optionalAccess', _99 => _99.length])) return null;
   const at2 = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at2.filter((v2, i) => i === 0 || v2 - at2[i - 1] > 1e-6);
   return ts.map((pos) => {
@@ -4663,7 +5620,7 @@ function interpolateWidthProfiles(a, b, t) {
   });
 }
 function lerpDashes(a, b, t) {
-  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _93 => _93.length]) && d.some((v2) => v2 > 0);
+  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _100 => _100.length]) && d.some((v2) => v2 > 0);
   if (!dashed(a) && !dashed(b)) return t < 0.5 ? a : b;
   const even = (p) => p.length % 2 ? [...p, ...p] : p;
   const solid = (p) => {
@@ -4690,7 +5647,7 @@ function interpolateVectorStyle(a, b, t) {
   for (const key of ["startArrowScale", "endArrowScale"])
     if (a[key] !== void 0 || b[key] !== void 0) out[key] = lerpN(_nullishCoalesce(a[key], () => ( 1)), _nullishCoalesce(b[key], () => ( 1)), t);
   const dash = lerpDashes(a.strokeDasharray, b.strokeDasharray, t);
-  if (_optionalChain([dash, 'optionalAccess', _94 => _94.length])) out.strokeDasharray = dash;
+  if (_optionalChain([dash, 'optionalAccess', _101 => _101.length])) out.strokeDasharray = dash;
   const profile = interpolateWidthProfiles(a.strokeWidthProfile, b.strokeWidthProfile, t);
   if (profile) out.strokeWidthProfile = profile;
   return out;
@@ -4701,7 +5658,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _95 => _95.strokeWidthProfile, 'optionalAccess', _96 => _96.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _102 => _102.strokeWidthProfile, 'optionalAccess', _103 => _103.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -4847,11 +5804,11 @@ function vectorBlendKeys(group) {
 }
 function resolveVectorBlendOptions(options) {
   return {
-    spacing: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _97 => _97.spacing]), () => ( "steps")),
-    steps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _98 => _98.steps]), () => ( DEFAULT_VECTOR_BLEND_STEPS)),
-    distance: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _99 => _99.distance]), () => ( DEFAULT_VECTOR_BLEND_DISTANCE)),
-    orientToSpine: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _100 => _100.orientToSpine]), () => ( false)),
-    linear: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _101 => _101.linear]), () => ( false))
+    spacing: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _104 => _104.spacing]), () => ( "steps")),
+    steps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _105 => _105.steps]), () => ( DEFAULT_VECTOR_BLEND_STEPS)),
+    distance: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _106 => _106.distance]), () => ( DEFAULT_VECTOR_BLEND_DISTANCE)),
+    orientToSpine: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _107 => _107.orientToSpine]), () => ( false)),
+    linear: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _108 => _108.linear]), () => ( false))
   };
 }
 function paintColors(p) {
@@ -4893,8 +5850,8 @@ function vectorBlendStepCount(a, b, options, length2) {
     if (cd > 1 / 255) return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(cd * 255 / 2)));
     const ba = vectorNodeBounds(a);
     const bb = vectorNodeBounds(b);
-    const dist4 = ba && bb ? Math.max(Math.abs(ba.x - bb.x), Math.abs(ba.y - bb.y), Math.abs(ba.x + ba.width - bb.x - bb.width), Math.abs(ba.y + ba.height - bb.y - bb.height)) : length2;
-    return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist4 / 2)));
+    const dist5 = ba && bb ? Math.max(Math.abs(ba.x - bb.x), Math.abs(ba.y - bb.y), Math.abs(ba.x + ba.width - bb.x - bb.width), Math.abs(ba.y + ba.height - bb.y - bb.height)) : length2;
+    return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist5 / 2)));
   }
   return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(1, Math.round(Number.isFinite(o.steps) ? o.steps : DEFAULT_VECTOR_BLEND_STEPS)));
 }
@@ -4939,7 +5896,7 @@ function vectorBlendRailAt(rail, s) {
 function vectorBlendSpine(group) {
   const keys = vectorBlendKeys(group);
   if (keys.length < 2) return null;
-  const stored = _optionalChain([group, 'access', _102 => _102.blend, 'optionalAccess', _103 => _103.spine]);
+  const stored = _optionalChain([group, 'access', _109 => _109.blend, 'optionalAccess', _110 => _110.spine]);
   if (stored && stored.anchors.length >= 2) {
     const rail2 = vectorBlendRail(stored);
     if (rail2) {
@@ -4960,7 +5917,7 @@ function vectorBlendKeyTargets(group) {
 }
 var morphCache = /* @__PURE__ */ new WeakMap();
 function morphFor(a, b, blend) {
-  const starts = [_nullishCoalesce(_optionalChain([blend, 'access', _104 => _104.starts, 'optionalAccess', _105 => _105[a.id]]), () => ( null)), _nullishCoalesce(_optionalChain([blend, 'access', _106 => _106.starts, 'optionalAccess', _107 => _107[b.id]]), () => ( null))];
+  const starts = [_nullishCoalesce(_optionalChain([blend, 'access', _111 => _111.starts, 'optionalAccess', _112 => _112[a.id]]), () => ( null)), _nullishCoalesce(_optionalChain([blend, 'access', _113 => _113.starts, 'optionalAccess', _114 => _114[b.id]]), () => ( null))];
   const key = JSON.stringify([!!blend.linear, starts]);
   let inner = morphCache.get(a);
   if (!inner) morphCache.set(a, inner = /* @__PURE__ */ new WeakMap());
@@ -5059,16 +6016,179 @@ function releaseVectorBlend(group, newId) {
   const m = nodeMatrix(group);
   const opacity = group.opacity;
   const keys = vectorBlendKeys(group).map((c) => group.transform ? transformVectorNode(c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c);
-  const spine = _optionalChain([group, 'access', _108 => _108.blend, 'optionalAccess', _109 => _109.spine]);
+  const spine = _optionalChain([group, 'access', _115 => _115.blend, 'optionalAccess', _116 => _116.spine]);
   if (!spine || spine.anchors.length < 2) return keys;
   const path = { id: newId(), type: "path", name: "Spine", fill: null, stroke: null, subpaths: [{ closed: spine.closed, anchors: spine.anchors.map((a) => ({ ...a })) }] };
   return [...keys, group.transform ? transformVectorNode(path, m) : path];
 }
 
+// src/vector/perspective.ts
+function solve8(rows) {
+  const m = rows.map((r) => r.slice());
+  for (let col = 0; col < 8; col++) {
+    let pivot = col;
+    for (let r = col + 1; r < 8; r++) if (Math.abs(m[r][col]) > Math.abs(m[pivot][col])) pivot = r;
+    if (!(Math.abs(m[pivot][col]) >= 1e-12)) return null;
+    [m[col], m[pivot]] = [m[pivot], m[col]];
+    const p = m[col];
+    for (let r = 0; r < 8; r++) {
+      if (r === col) continue;
+      const f = m[r][col] / p[col];
+      if (f !== 0) for (let k = 0; k < 9; k++) m[r][k] -= f * p[k];
+    }
+  }
+  const out = [];
+  for (let i = 0; i < 8; i++) {
+    const v2 = m[i][8] / m[i][i];
+    if (!Number.isFinite(v2)) return null;
+    out.push(v2);
+  }
+  return out;
+}
+function applyVectorHomography(h, p) {
+  const w = h[6] * p.x + h[7] * p.y + h[8];
+  if (!Number.isFinite(w) || Math.abs(w) < 1e-12) return null;
+  const x = (h[0] * p.x + h[1] * p.y + h[2]) / w;
+  const y = (h[3] * p.x + h[4] * p.y + h[5]) / w;
+  return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+}
+var finite = (p) => Number.isFinite(p.x) && Number.isFinite(p.y);
+function vectorHomography(from, to) {
+  if (from.length !== 4 || to.length !== 4 || ![...from, ...to].every(finite)) return null;
+  const rows = [];
+  for (let i = 0; i < 4; i++) {
+    const { x, y } = from[i];
+    const { x: u, y: v2 } = to[i];
+    rows.push([x, y, 1, 0, 0, 0, -u * x, -u * y, u]);
+    rows.push([0, 0, 0, x, y, 1, -v2 * x, -v2 * y, v2]);
+  }
+  const h = solve8(rows);
+  if (!h) return null;
+  const out = [h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7], 1];
+  for (let i = 0; i < 4; i++) {
+    const r = applyVectorHomography(out, from[i]);
+    const q = to[i];
+    const scale3 = 1 + Math.max(Math.abs(q.x), Math.abs(q.y));
+    if (!r || Math.abs(r.x - q.x) > 1e-6 * scale3 || Math.abs(r.y - q.y) > 1e-6 * scale3) return null;
+  }
+  return out;
+}
+function vectorHomographyKeepsQuad(h, quad) {
+  const ws = quad.map((p) => h[6] * p.x + h[7] * p.y + h[8]);
+  return ws.every((w) => w > 1e-9) || ws.every((w) => w < -1e-9);
+}
+function orderVectorQuad(points) {
+  if (points.length !== 4 || !points.every(finite)) return null;
+  const cx = points.reduce((s, p) => s + p.x, 0) / 4;
+  const cy = points.reduce((s, p) => s + p.y, 0) / 4;
+  const q = points.slice().sort((a, b) => Math.atan2(a.y - cy, a.x - cx) - Math.atan2(b.y - cy, b.x - cx));
+  let first = 0;
+  for (let i = 1; i < 4; i++) if (q[i].x + q[i].y < q[first].x + q[first].y) first = i;
+  const ordered = [...q.slice(first), ...q.slice(0, first)];
+  const cross2 = (o, a, b) => (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+  const turns = ordered.map((_, i) => cross2(ordered[i], ordered[(i + 1) % 4], ordered[(i + 2) % 4]));
+  const area = turns.reduce((s, t) => s + t, 0) / 2;
+  const xs = ordered.map((p) => p.x);
+  const ys = ordered.map((p) => p.y);
+  const size = Math.max(Math.max(...xs) - Math.min(...xs), Math.max(...ys) - Math.min(...ys));
+  const convex = turns.every((t) => t > 1e-9 * size * size);
+  return convex && area > 1e-6 * size * size ? ordered : null;
+}
+
+// src/vector/distort.ts
+var VECTOR_DISTORT_TOLERANCE = 0.05;
+var CORNER_INDEX = { nw: 0, ne: 1, se: 2, sw: 3 };
+var SIDE_CORNERS = { n: [0, 1], e: [1, 2], s: [2, 3], w: [3, 0] };
+var vectorBoxCorners = (b) => [
+  { x: b.x, y: b.y },
+  { x: b.x + b.width, y: b.y },
+  { x: b.x + b.width, y: b.y + b.height },
+  { x: b.x, y: b.y + b.height }
+];
+function vectorDistortQuad(b, handle, d, mode = "distort") {
+  const q = vectorBoxCorners(b);
+  const i = CORNER_INDEX[handle];
+  if (i !== void 0) {
+    if (mode === "perspective") {
+      if (Math.abs(d.x) >= Math.abs(d.y)) {
+        const partner = [1, 0, 3, 2][i];
+        q[i].x += d.x;
+        q[partner].x -= d.x;
+      } else {
+        const partner = [3, 2, 1, 0][i];
+        q[i].y += d.y;
+        q[partner].y -= d.y;
+      }
+    } else {
+      q[i].x += d.x;
+      q[i].y += d.y;
+    }
+    return q;
+  }
+  const side = SIDE_CORNERS[handle];
+  if (side) for (const k of side) q[k] = { x: q[k].x + d.x, y: q[k].y + d.y };
+  return q;
+}
+var about = (o, m) => multiplyMatrices(multiplyMatrices([1, 0, 0, 1, -o.x, -o.y], m), [1, 0, 0, 1, o.x, o.y]);
+function vectorShearForSide(b, handle, d, fromCenter = false) {
+  const center = { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+  if (handle === "n" || handle === "s") {
+    const o = fromCenter ? center : { x: center.x, y: handle === "n" ? b.y + b.height : b.y };
+    const lever = (handle === "n" ? b.y : b.y + b.height) - o.y;
+    return about(o, [1, 0, Math.abs(lever) > 1e-9 ? d.x / lever : 0, 1, 0, 0]);
+  }
+  if (handle === "e" || handle === "w") {
+    const o = fromCenter ? center : { x: handle === "w" ? b.x + b.width : b.x, y: center.y };
+    const lever = (handle === "w" ? b.x : b.x + b.width) - o.x;
+    return about(o, [1, Math.abs(lever) > 1e-9 ? d.y / lever : 0, 0, 1, 0, 0]);
+  }
+  return [1, 0, 0, 1, 0, 0];
+}
+function vectorSkewMatrix(ax, ay, origin = { x: 0, y: 0 }) {
+  const tx = Math.tan(ax * Math.PI / 180);
+  const ty = Math.tan(ay * Math.PI / 180);
+  return about(origin, [1, ty, tx, 1, 0, 0]);
+}
+function mapEffects(node, f) {
+  if (!_optionalChain([node, 'access', _117 => _117.effects, 'optionalAccess', _118 => _118.length])) return void 0;
+  return node.effects.map((e) => {
+    if (e.type !== "envelope") return e;
+    if (e.params.style === "mesh") return e.params.mesh ? { ...e, params: { ...e.params, mesh: mapVectorMeshPoints(e.params.mesh, f) } } : 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), f) } };
+  });
+}
+function distortVectorNode(node, parentToDoc, f, tolerance = VECTOR_DISTORT_TOLERANCE) {
+  const toDoc = multiplyMatrices(nodeMatrix(node), parentToDoc);
+  const inv = invertMatrix(toDoc);
+  const local = (p) => applyMatrix(inv, f(applyMatrix(toDoc, p)));
+  const effects = mapEffects(node, local);
+  if (node.type === "group") {
+    const group = node;
+    const children = group.children.map((c) => distortVectorNode(c, toDoc, f, tolerance));
+    const spine = _optionalChain([group, 'access', _119 => _119.blend, 'optionalAccess', _120 => _120.spine]);
+    return {
+      ...group,
+      children,
+      ...effects ? { effects } : {},
+      ...spine ? { blend: { ...group.blend, spine: mapVectorSubpaths([spine], local, tolerance)[0] } } : {}
+    };
+  }
+  const path = node;
+  return {
+    ...path,
+    ...effects ? { effects } : {},
+    ...path.fill !== void 0 ? { fill: mapVectorPaint(path.fill, local) } : {},
+    ...path.stroke !== void 0 ? { stroke: mapVectorPaint(path.stroke, local) } : {},
+    subpaths: mapVectorSubpaths(path.subpaths, local, tolerance)
+  };
+}
+
 // src/vector/snap.ts
 var VECTOR_CONSTRUCTION_ANGLES = [0, 45, 90, 135];
 function constrainToLeave(leave, p) {
-  if (!_optionalChain([leave, 'optionalAccess', _110 => _110.constrain])) return p;
+  if (!_optionalChain([leave, 'optionalAccess', _121 => _121.constrain])) return p;
   const dx = p.x - leave.at.x;
   const dy = p.y - leave.at.y;
   switch (leave.constrain) {
@@ -5106,8 +6226,8 @@ function within(sorted, key, v2, tol) {
 }
 var linesNear = (lines, v2, tol) => within(lines, (l) => l.v, v2, tol);
 var distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
-var toPoint = (p) => [p.x, p.y];
-var toVec2 = (p) => ({ x: p[0], y: p[1] });
+var toPoint2 = (p) => [p.x, p.y];
+var toVec3 = (p) => ({ x: p[0], y: p[1] });
 var LABELS = {
   anchor: "anchor",
   centre: "centre",
@@ -5179,7 +6299,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
       moving.set(r.nodeId, set);
     }
     const t = _VectorSnapTargets.collect(doc, new Set(moving.keys()), "segments", false);
-    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _111 => _111.get, 'call', _112 => _112(id), 'optionalAccess', _113 => _113.has, 'call', _114 => _114(`${s}:${i}`)]), true);
+    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _122 => _122.get, 'call', _123 => _123(id), 'optionalAccess', _124 => _124.has, 'call', _125 => _125(`${s}:${i}`)]), true);
     return t.index();
   }
   /**
@@ -5225,7 +6345,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
     const count = subpathSegmentCount(sp);
     for (let i = 0; i < count && budget > 0; i++) {
       if (moving(i) || moving((i + 1) % n)) continue;
-      const seg = subpathSegment(sp, i).map((q) => toPoint(applyMatrix(m, toVec2(q))));
+      const seg = subpathSegment(sp, i).map((q) => toPoint2(applyMatrix(m, toVec3(q))));
       let minX = Infinity;
       let minY = Infinity;
       let maxX = -Infinity;
@@ -5298,7 +6418,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
         }
         const b = vectorNodeBounds(n, parent);
         const f = nodeFrame(n, parent, b);
-        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _115 => _115.centre]), () => ( null)));
+        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _126 => _126.centre]), () => ( null)));
       }
     };
     visit(doc.nodes, IDENTITY_MATRIX);
@@ -5343,7 +6463,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
       lines: lines2,
       labels: [this.label(q, kind)]
     });
-    if (_optionalChain([leave, 'optionalAccess', _116 => _116.constrain])) {
+    if (_optionalChain([leave, 'optionalAccess', _127 => _127.constrain])) {
       const q = constrainToLeave(leave, p);
       const hit = this.slide(leave.at, { x: q.x - leave.at.x, y: q.y - leave.at.y }, q, tol, true);
       return hit ? { point: hit.point, x: true, y: true, ...this.linedUp(hit.point, hit.from) } : none(q);
@@ -5359,7 +6479,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
     }
     const on = this.onSegment(near2);
     if (on) return at2(on, "path");
-    if (_optionalChain([leave, 'optionalAccess', _117 => _117.angles, 'optionalAccess', _118 => _118.length])) {
+    if (_optionalChain([leave, 'optionalAccess', _128 => _128.angles, 'optionalAccess', _129 => _129.length])) {
       const c = construction(leave, p, tol);
       if (c) {
         const hit = this.slide(leave.at, c.dir, c.point, tol, false);
@@ -5432,7 +6552,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
   /** Target segments whose control box reaches `p` and which pass within `tol` of it, nearest first. */
   segmentsNear(p, tol) {
     const out = [];
-    const pt2 = toPoint(p);
+    const pt2 = toPoint2(p);
     for (const s of this.segments) {
       if (p.x < s.minX - tol || p.x > s.maxX + tol || p.y < s.minY - tol || p.y > s.maxY + tol) continue;
       const hit = _chunkVNYRI265cjs.segmentNearest.call(void 0, s.seg, pt2);
@@ -5441,7 +6561,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
     return out.sort((a, b) => a.distance - b.distance);
   }
   onSegment(near2) {
-    return near2.length ? toVec2(_chunkVNYRI265cjs.segmentPoint.call(void 0, near2[0].seg, near2[0].t)) : null;
+    return near2.length ? toVec3(_chunkVNYRI265cjs.segmentPoint.call(void 0, near2[0].seg, near2[0].t)) : null;
   }
   /** Where two of the target segments near `p` cross, the crossing nearest `p` within `tol`. */
   crossing(near2, p, tol) {
@@ -5451,7 +6571,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
     for (let i = 0; i < list.length; i++) {
       for (let j = i + 1; j < list.length; j++) {
         for (const hit of _chunkVNYRI265cjs.segmentIntersections.call(void 0, list[i].seg, list[j].seg)) {
-          const q = toVec2(hit.point);
+          const q = toVec3(hit.point);
           const d = distance(q, p);
           if (d <= tol && d < bestD) {
             best = q;
@@ -5489,7 +6609,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
    * with nothing spaces the box evenly in its row or column. Returns the correction and guides.
    */
   snapRect(r, tol, options = {}) {
-    const axes = { x: _optionalChain([options, 'access', _119 => _119.axes, 'optionalAccess', _120 => _120.x]) !== false, y: _optionalChain([options, 'access', _121 => _121.axes, 'optionalAccess', _122 => _122.y]) !== false };
+    const axes = { x: _optionalChain([options, 'access', _130 => _130.axes, 'optionalAccess', _131 => _131.x]) !== false, y: _optionalChain([options, 'access', _132 => _132.axes, 'optionalAccess', _133 => _133.y]) !== false };
     const nearest = (lines, values) => {
       let best = null;
       for (const v2 of values) for (const l of linesNear(lines, v2, tol)) if (!best || Math.abs(l.v - v2) < Math.abs(best.d)) best = { d: l.v - v2, from: l.from };
@@ -5497,7 +6617,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
     };
     const bx = axes.x ? nearest(this.xs, [r.x, r.x + r.width / 2, r.x + r.width]) : null;
     const by = axes.y ? nearest(this.ys, [r.y, r.y + r.height / 2, r.y + r.height]) : null;
-    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _123 => _123.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _124 => _124.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
+    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _134 => _134.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _135 => _135.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
     const done = { ...r, x: r.x + out.dx, y: r.y + out.dy };
     if (bx) {
       const x = bx.from.x;
@@ -5620,9 +6740,9 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
       const on = this.nearestPoint(p, tol);
       const tries = [];
       if (on) tries.push({ tx: on.p.x, ty: on.p.y, s: { hx: null, hy: null, on } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _125 => _125.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _126 => _126.v]), () => ( null)), s: { hx, hy, on: null } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _127 => _127.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
-      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _128 => _128.v]), () => ( null)), s: { hx: null, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _136 => _136.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _137 => _137.v]), () => ( null)), s: { hx, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _138 => _138.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
+      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _139 => _139.v]), () => ( null)), s: { hx: null, hy, on: null } });
       for (const { tx, ty, s } of tries) {
         if (tx === null && ty === null) continue;
         const q = applyMatrix(toLocal, { x: _nullishCoalesce(tx, () => ( p.x)), y: _nullishCoalesce(ty, () => ( p.y)) });
@@ -6030,7 +7150,7 @@ function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
   return cutSubpathAt(subpath, [index]);
 }
 var endOf2 = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
-var dist2 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var dist3 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
 function reverse(sp) {
   return {
     closed: sp.closed,
@@ -6057,7 +7177,7 @@ function joinSubpaths(subpaths, tolerance) {
     const sp = open[0];
     const first = sp.anchors[0];
     const last = sp.anchors[sp.anchors.length - 1];
-    if (sp.anchors.length > 2 && dist2(first, last) <= tolerance) {
+    if (sp.anchors.length > 2 && dist3(first, last) <= tolerance) {
       sp.anchors.pop();
       sp.anchors[0] = tidy({ ...first, in: _nullishCoalesce(last.in, () => ( null)) }, false);
     } else {
@@ -6073,7 +7193,7 @@ function joinSubpaths(subpaths, tolerance) {
       for (let j = i + 1; j < open.length; j++) {
         for (const ei of [false, true]) {
           for (const ej of [false, true]) {
-            const d = dist2(endOf2(open[i], ei), endOf2(open[j], ej));
+            const d = dist3(endOf2(open[i], ei), endOf2(open[j], ej));
             if (d < best.d) best = { d, i, j, ei, ej };
           }
         }
@@ -6113,8 +7233,8 @@ function smoothSubpath(sp, amount = 1, only) {
     const p = orig[i];
     const dir = unit4(next.x - prev.x, next.y - prev.y);
     if (!dir) continue;
-    const li = dist2(p, prev) / 3;
-    const lo = dist2(p, next) / 3;
+    const li = dist3(p, prev) / 3;
+    const lo = dist3(p, next) / 3;
     const hin = _nullishCoalesce(p.in, () => ( p));
     const hout = _nullishCoalesce(p.out, () => ( p));
     const target = (h, x, y) => ({ x: h.x + (x - h.x) * t, y: h.y + (y - h.y) * t });
@@ -6605,7 +7725,7 @@ function vectorInkShapeName(shape) {
       return shape.points.length === 3 ? "triangle" : "polygon";
   }
 }
-var dist3 = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
+var dist4 = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
 function bbox(pts) {
   if (!pts.length) return [0, 0, 0, 0];
   let [x0, y0] = pts[0];
@@ -6623,7 +7743,7 @@ function segDistance(a, b, p) {
   const dy = b[1] - a[1];
   const len2 = dx * dx + dy * dy;
   const t = len2 > 0 ? Math.min(1, Math.max(0, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2)) : 0;
-  return dist3([a[0] + t * dx, a[1] + t * dy], p);
+  return dist4([a[0] + t * dx, a[1] + t * dy], p);
 }
 function polygonDistance(c, p) {
   let best = Infinity;
@@ -6685,7 +7805,7 @@ function corners(p, diag) {
   let far = 0;
   let farD = 0;
   p.forEach((q, i) => {
-    const d = dist3(start, q);
+    const d = dist4(start, q);
     if (d > farD) {
       farD = d;
       far = i;
@@ -6712,7 +7832,7 @@ function corners(p, diag) {
     }
     let short = -1;
     for (let j = 0; j < n; j++) {
-      if (dist3(ring[j], ring[(j + 1) % n]) < 0.1 * diag) {
+      if (dist4(ring[j], ring[(j + 1) % n]) < 0.1 * diag) {
         short = j;
         break;
       }
@@ -6752,8 +7872,8 @@ function recognizeInkShape(points, options = {}) {
   const diag = Math.hypot(w, h);
   if (size < minSize) return null;
   let length2 = 0;
-  for (let i = 1; i < p.length; i++) length2 += dist3(p[i - 1], p[i]);
-  const gap = dist3(first, last);
+  for (let i = 1; i < p.length; i++) length2 += dist4(p[i - 1], p[i]);
+  const gap = dist4(first, last);
   if (gap > 0.85 * length2 && gap >= minSize) {
     const off = Math.max(...p.map((q) => segDistance(first, last, q)));
     if (off <= Math.max(0.06 * gap, 1.5 * minSize / 6)) return { kind: "line", a: first, b: last };
@@ -7052,7 +8172,7 @@ function getEditablePathIds(state) {
       }
     }
   }
-  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _129 => _129(state.document.nodes, id), 'optionalAccess', _130 => _130.type]) === "path");
+  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _140 => _140(state.document.nodes, id), 'optionalAccess', _141 => _141.type]) === "path");
 }
 function getVisibleAnchors(state) {
   const out = [];
@@ -7067,7 +8187,7 @@ function getVisibleHandles(state) {
   const seen = /* @__PURE__ */ new Set();
   const push = (node, s, i, handle) => {
     const sp = node.subpaths[s];
-    const a = _optionalChain([sp, 'optionalAccess', _131 => _131.anchors, 'access', _132 => _132[i]]);
+    const a = _optionalChain([sp, 'optionalAccess', _142 => _142.anchors, 'access', _143 => _143[i]]);
     if (!a || !a[handle]) return;
     const key = `${node.id}:${s}:${i}:${handle}`;
     if (seen.has(key)) return;
@@ -7076,8 +8196,8 @@ function getVisibleHandles(state) {
   };
   if (state.tool === "pen" && state.pen) {
     const node = findVectorNode(state.document.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _133 => _133.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
-    if (_optionalChain([node, 'optionalAccess', _134 => _134.type]) === "path" && sp) {
+    const sp = _optionalChain([node, 'optionalAccess', _144 => _144.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    if (_optionalChain([node, 'optionalAccess', _145 => _145.type]) === "path" && sp) {
       const last = sp.anchors.length - 1;
       push(node, state.pen.subpath, last, "in");
       push(node, state.pen.subpath, last, "out");
@@ -7115,11 +8235,11 @@ function getVectorCornerWidgets(state) {
       const side = Math.min(c.lu, c.lv);
       if (side * zoom < 3 * VECTOR_CORNER_WIDGET_INSET) continue;
       const a = node.subpaths[c.subpath].anchors[c.index];
-      const radius = _nullishCoalesce(_optionalChain([a, 'access', _135 => _135.corner, 'optionalAccess', _136 => _136.radius]), () => ( 0));
+      const radius = _nullishCoalesce(_optionalChain([a, 'access', _146 => _146.corner, 'optionalAccess', _147 => _147.radius]), () => ( 0));
       const drawn = fitCornerRadius(c, radius);
       const k = Math.min(Math.max(drawn / c.sin, VECTOR_CORNER_WIDGET_INSET / (zoom * Math.sqrt(1 + c.cos))), side / 2);
       const p = applyMatrix(m, cornerBisectorPoint(c, k));
-      out.push({ ref: { nodeId: id, subpath: c.subpath, index: c.index }, x: p.x, y: p.y, radius, drawnRadius: drawn, kind: _nullishCoalesce(_optionalChain([a, 'access', _137 => _137.corner, 'optionalAccess', _138 => _138.kind]), () => ( "round")), corner: c });
+      out.push({ ref: { nodeId: id, subpath: c.subpath, index: c.index }, x: p.x, y: p.y, radius, drawnRadius: drawn, kind: _nullishCoalesce(_optionalChain([a, 'access', _148 => _148.corner, 'optionalAccess', _149 => _149.kind]), () => ( "round")), corner: c });
     }
   }
   return out;
@@ -7142,13 +8262,13 @@ function getVectorWidthHandles(state) {
     const n = findVectorNode(state.document.nodes, id);
     if (n) for (const p of collectPathNodes(n)) ids.add(p.id);
   }
-  if (_optionalChain([state, 'access', _139 => _139.hover, 'optionalAccess', _140 => _140.nodeId])) ids.add(state.hover.nodeId);
-  if (_optionalChain([state, 'access', _141 => _141.interaction, 'optionalAccess', _142 => _142.type]) === "width") ids.add(state.interaction.ref.nodeId);
+  if (_optionalChain([state, 'access', _150 => _150.hover, 'optionalAccess', _151 => _151.nodeId])) ids.add(state.hover.nodeId);
+  if (_optionalChain([state, 'access', _152 => _152.interaction, 'optionalAccess', _153 => _153.type]) === "width") ids.add(state.interaction.ref.nodeId);
   for (const r of state.selectedWidthPoints) ids.add(r.nodeId);
   const out = [];
   for (const id of ids) {
     const node = findVectorNode(state.document.nodes, id);
-    if (_optionalChain([node, 'optionalAccess', _143 => _143.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _144 => _144.strokeWidthProfile, 'optionalAccess', _145 => _145.length])) continue;
+    if (_optionalChain([node, 'optionalAccess', _154 => _154.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _155 => _155.strokeWidthProfile, 'optionalAccess', _156 => _156.length])) continue;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) continue;
     const profile = sanitizeWidthProfile(node.strokeWidthProfile);
@@ -7181,7 +8301,7 @@ function getVectorWidthHandles(state) {
 }
 function getAnchor(doc, ref) {
   const node = findVectorNode(doc.nodes, ref.nodeId);
-  return _optionalChain([node, 'optionalAccess', _146 => _146.type]) === "path" ? _optionalChain([node, 'access', _147 => _147.subpaths, 'access', _148 => _148[ref.subpath], 'optionalAccess', _149 => _149.anchors, 'access', _150 => _150[ref.index]]) : void 0;
+  return _optionalChain([node, 'optionalAccess', _157 => _157.type]) === "path" ? _optionalChain([node, 'access', _158 => _158.subpaths, 'access', _159 => _159[ref.subpath], 'optionalAccess', _160 => _160.anchors, 'access', _161 => _161[ref.index]]) : void 0;
 }
 function getAnchorWorld(doc, ref) {
   const a = getAnchor(doc, ref);
@@ -7194,8 +8314,8 @@ function getVectorSelectionFrame(doc, ids) {
   const nodes = ids.map((id) => ({ node: findVectorNode(doc.nodes, id), parent: _nullishCoalesce(vectorParentMatrix(doc.nodes, id), () => ( IDENTITY_MATRIX)) })).filter((n) => n.node);
   if (!nodes.length) return null;
   const angles = nodes.map((n) => matrixRotation(multiplyMatrices(nodeMatrix(n.node), n.parent)));
-  const same = angles.every((a) => Math.abs(normalizeAngle(a - angles[0])) < 1e-6);
-  const angle = same ? angles[0] : 0;
+  const same2 = angles.every((a) => Math.abs(normalizeAngle(a - angles[0])) < 1e-6);
+  const angle = same2 ? angles[0] : 0;
   const unrotate = rotateMatrix(-angle);
   const b = unionBounds(nodes.map((n) => vectorNodeBounds(n.node, multiplyMatrices(n.parent, unrotate))));
   return b ? { ...b, angle } : null;
@@ -7230,6 +8350,13 @@ function getVectorSelectionBoxGeometry(frame2, viewport) {
   const r = (n) => Math.round(n * 1e3) / 1e3;
   return { box, angle: frame2.angle, transform: frame2.angle ? `rotate(${r(frame2.angle)} ${r(viewport.x)} ${r(viewport.y)})` : "", handles, corners: corners2 };
 }
+function getVectorEnvelopeTarget(doc, selection) {
+  if (selection.length !== 1) return null;
+  const node = findVectorNode(doc.nodes, selection[0]);
+  if (!node || !vectorNodeEnvelope(node)) return null;
+  const frame2 = vectorEnvelopeFrame(node);
+  return frame2 ? { node, frame: frame2, world: _nullishCoalesce(vectorWorldMatrix(doc.nodes, node.id), () => ( IDENTITY_MATRIX)) } : null;
+}
 var RESIZE_CURSOR_ORDER = ["ew-resize", "nwse-resize", "ns-resize", "nesw-resize"];
 var HANDLE_ANGLES = { e: 0, se: 45, s: 90, sw: 135, w: 180, nw: 225, n: 270, ne: 315 };
 function vectorResizeCursor(handle, angle = 0) {
@@ -7254,7 +8381,8 @@ var TOOL_LABELS = {
   shapeBuilder: "Shape Builder",
   paintBucket: "Paint Bucket",
   blend: "Blend",
-  gradient: "Gradient"
+  gradient: "Gradient",
+  envelope: "Envelope Mesh"
 };
 var TOOL_KEYS = {
   v: "select",
@@ -7273,7 +8401,8 @@ var TOOL_KEYS = {
   m: "shapeBuilder",
   b: "paintBucket",
   j: "blend",
-  g: "gradient"
+  g: "gradient",
+  u: "envelope"
 };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
@@ -7295,7 +8424,8 @@ var VECTOR_TOOL_SHORTCUTS = {
   shapeBuilder: "M",
   paintBucket: "B",
   blend: "J",
-  gradient: "G"
+  gradient: "G",
+  envelope: "U"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -7314,7 +8444,8 @@ var VECTOR_TOOL_GLYPHS = {
   shapeBuilder: "\u2295",
   paintBucket: "\u25CD",
   blend: "\u29D3",
-  gradient: "\u25D0"
+  gradient: "\u25D0",
+  envelope: "\u2317"
 };
 var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line"]);
 var BOOLEAN_OPS = {
@@ -7367,7 +8498,7 @@ function spliceTree(nodes, id, replacements) {
   }
   return changed ? out : nodes;
 }
-var toPoint2 = (p) => [p.x, p.y];
+var toPoint3 = (p) => [p.x, p.y];
 var placementOf = (n) => ({
   ...n.transform ? { transform: n.transform } : {},
   ...n.visible === false ? { visible: false } : {},
@@ -7412,18 +8543,19 @@ var VectorEditorController = (_class5 = class {
   /** Options new blends get (the toolbars edit them along with the selected blend's). */
   __init31() {this.blendDefaults = {}}
   __init32() {this.gradientEdit = { target: "fill", stop: null }}
+  __init33() {this.freeDistort = false}
   /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
-  __init33() {this.builderHoverKey = null}
+  __init34() {this.builderHoverKey = null}
   
   
-  __init34() {this.listeners = /* @__PURE__ */ new Set()}
-  __init35() {this.cleanups = []}
-  __init36() {this.applying = false}
+  __init35() {this.listeners = /* @__PURE__ */ new Set()}
+  __init36() {this.cleanups = []}
+  __init37() {this.applying = false}
   /** Set while a commit records a change that was already applied, so `restore` still reports it. */
-  __init37() {this.committing = false}
-  __init38() {this.revision = 0}
+  __init38() {this.committing = false}
+  __init39() {this.revision = 0}
   
-  constructor(options = {}) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);_class5.prototype.__init21.call(this);_class5.prototype.__init22.call(this);_class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this);_class5.prototype.__init25.call(this);_class5.prototype.__init26.call(this);_class5.prototype.__init27.call(this);_class5.prototype.__init28.call(this);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);_class5.prototype.__init32.call(this);_class5.prototype.__init33.call(this);_class5.prototype.__init34.call(this);_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);_class5.prototype.__init40.call(this);
+  constructor(options = {}) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);_class5.prototype.__init21.call(this);_class5.prototype.__init22.call(this);_class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this);_class5.prototype.__init25.call(this);_class5.prototype.__init26.call(this);_class5.prototype.__init27.call(this);_class5.prototype.__init28.call(this);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);_class5.prototype.__init32.call(this);_class5.prototype.__init33.call(this);_class5.prototype.__init34.call(this);_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);_class5.prototype.__init40.call(this);_class5.prototype.__init41.call(this);
     this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.HistoryManager)()));
     this.doc = options.document ? cloneVectorDocument(options.document) : { width: 800, height: 600, nodes: [] };
     this.doc = this.refreshed(this.doc);
@@ -7435,6 +8567,7 @@ var VectorEditorController = (_class5 = class {
     this.hitRadius = _nullishCoalesce(options.hitRadius, () => ( 6));
     this.createId = _nullishCoalesce(options.createId, () => ( defaultCreateId));
     this.onChange = options.onChange;
+    this.freeDistort = !!options.freeDistort;
     this.state = this.computeState();
     this.connect();
   }
@@ -7464,9 +8597,9 @@ var VectorEditorController = (_class5 = class {
   // State
   // -------------------------------------------------------------------------
   /** The current snapshot (stable until the next change). */
-  __init39() {this.getState = () => this.state}
+  __init40() {this.getState = () => this.state}
   /** Calls `listener` after every change. Returns an unsubscribe function. */
-  __init40() {this.subscribe = (listener) => {
+  __init41() {this.subscribe = (listener) => {
     this.connect();
     this.listeners.add(listener);
     return () => {
@@ -7506,6 +8639,7 @@ var VectorEditorController = (_class5 = class {
       blendStart: this.blendStart,
       blendDefaults: this.blendDefaults,
       gradientEdit: this.gradientEdit,
+      freeDistort: this.freeDistort,
       canUndo: h.canUndo,
       canRedo: h.canRedo,
       undoLabel: h.undoName,
@@ -7524,7 +8658,7 @@ var VectorEditorController = (_class5 = class {
     if (this.blendStart && !this.getNode(this.blendStart.nodeId)) this.blendStart = null;
     this.revision++;
     this.state = this.computeState();
-    if (docChanged) _optionalChain([this, 'access', _151 => _151.onChange, 'optionalCall', _152 => _152(this.doc)]);
+    if (docChanged) _optionalChain([this, 'access', _162 => _162.onChange, 'optionalCall', _163 => _163(this.doc)]);
     const state = this.state;
     this.listeners.forEach((listener) => {
       try {
@@ -7554,33 +8688,38 @@ var VectorEditorController = (_class5 = class {
     return applyMatrix(invertMatrix(this.worldOf(id, doc)), p);
   }
   cursorFor() {
-    if (_optionalChain([this, 'access', _153 => _153.drag, 'optionalAccess', _154 => _154.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
-    if (_optionalChain([this, 'access', _155 => _155.drag, 'optionalAccess', _156 => _156.kind]) === "rotate") return "grabbing";
-    if (_optionalChain([this, 'access', _157 => _157.drag, 'optionalAccess', _158 => _158.kind]) === "move") return "move";
+    if (_optionalChain([this, 'access', _164 => _164.drag, 'optionalAccess', _165 => _165.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
+    if (_optionalChain([this, 'access', _166 => _166.drag, 'optionalAccess', _167 => _167.kind]) === "rotate") return "grabbing";
+    if (_optionalChain([this, 'access', _168 => _168.drag, 'optionalAccess', _169 => _169.kind]) === "move") return "move";
     const h = this.hover;
     switch (this.tool) {
       case "select":
-        if (_optionalChain([h, 'optionalAccess', _159 => _159.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _160 => _160.frameOf, 'call', _161 => _161(this.selectedRoots()), 'optionalAccess', _162 => _162.angle]), () => ( 0)));
-        return _optionalChain([h, 'optionalAccess', _163 => _163.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _170 => _170.transformHandle]) && this.freeDistort && h.transformHandle !== "rotate") return "crosshair";
+        if (_optionalChain([h, 'optionalAccess', _171 => _171.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _172 => _172.frameOf, 'call', _173 => _173(this.selectedRoots()), 'optionalAccess', _174 => _174.angle]), () => ( 0)));
+        return _optionalChain([h, 'optionalAccess', _175 => _175.nodeId]) ? "move" : "default";
+      case "envelope":
+        if (_optionalChain([this, 'access', _176 => _176.drag, 'optionalAccess', _177 => _177.kind]) === "envelope") return "grabbing";
+        if (_optionalChain([h, 'optionalAccess', _178 => _178.envelope])) return h.envelope.index === null ? "grab" : "pointer";
+        return _optionalChain([h, 'optionalAccess', _179 => _179.nodeId]) ? "pointer" : "default";
       case "direct":
-        if (_optionalChain([h, 'optionalAccess', _164 => _164.anchor]) || _optionalChain([h, 'optionalAccess', _165 => _165.handle]) || _optionalChain([h, 'optionalAccess', _166 => _166.corner])) return "pointer";
-        if (_optionalChain([h, 'optionalAccess', _167 => _167.segment])) return "copy";
-        return _optionalChain([h, 'optionalAccess', _168 => _168.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _180 => _180.anchor]) || _optionalChain([h, 'optionalAccess', _181 => _181.handle]) || _optionalChain([h, 'optionalAccess', _182 => _182.corner])) return "pointer";
+        if (_optionalChain([h, 'optionalAccess', _183 => _183.segment])) return "copy";
+        return _optionalChain([h, 'optionalAccess', _184 => _184.nodeId]) ? "move" : "default";
       case "pen":
-        return _optionalChain([h, 'optionalAccess', _169 => _169.anchor]) ? "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _185 => _185.anchor]) ? "pointer" : "crosshair";
       case "width":
-        if (_optionalChain([this, 'access', _170 => _170.drag, 'optionalAccess', _171 => _171.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
-        if (_optionalChain([h, 'optionalAccess', _172 => _172.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
-        return _optionalChain([h, 'optionalAccess', _173 => _173.strokeSpot]) ? "copy" : "default";
+        if (_optionalChain([this, 'access', _186 => _186.drag, 'optionalAccess', _187 => _187.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
+        if (_optionalChain([h, 'optionalAccess', _188 => _188.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
+        return _optionalChain([h, 'optionalAccess', _189 => _189.strokeSpot]) ? "copy" : "default";
       case "shapeBuilder":
-        if (!_optionalChain([this, 'access', _174 => _174.builderPreview, 'optionalAccess', _175 => _175.faces, 'access', _176 => _176.length]) && !_optionalChain([this, 'access', _177 => _177.builderPreview, 'optionalAccess', _178 => _178.lines, 'access', _179 => _179.length])) return "crosshair";
+        if (!_optionalChain([this, 'access', _190 => _190.builderPreview, 'optionalAccess', _191 => _191.faces, 'access', _192 => _192.length]) && !_optionalChain([this, 'access', _193 => _193.builderPreview, 'optionalAccess', _194 => _194.lines, 'access', _195 => _195.length])) return "crosshair";
         return this.builderPreview.mode === "erase" ? "not-allowed" : "cell";
       case "paintBucket":
         return this.builderPreview ? "cell" : "crosshair";
       case "blend":
-        return _optionalChain([h, 'optionalAccess', _180 => _180.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _196 => _196.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
       case "gradient": {
-        const part = _optionalChain([this, 'access', _181 => _181.drag, 'optionalAccess', _182 => _182.kind]) === "gradient" ? this.drag.part : _optionalChain([h, 'optionalAccess', _183 => _183.gradient]);
+        const part = _optionalChain([this, 'access', _197 => _197.drag, 'optionalAccess', _198 => _198.kind]) === "gradient" ? this.drag.part : _optionalChain([h, 'optionalAccess', _199 => _199.gradient]);
         if (!part) return "crosshair";
         if (part.kind === "bar") return this.drag ? "grabbing" : "copy";
         if (part.kind === "handle" && part.handle === "start") return this.drag ? "grabbing" : "move";
@@ -7606,11 +8745,11 @@ var VectorEditorController = (_class5 = class {
       this.selection = s.selection.filter((id) => this.getNode(id));
       this.anchors = s.anchors.filter((r) => getAnchor(this.doc, r));
       this.editingId = s.editingId && this.getNode(s.editingId) ? s.editingId : null;
-      this.pen = s.pen && _optionalChain([this, 'access', _184 => _184.getNode, 'call', _185 => _185(s.pen.nodeId), 'optionalAccess', _186 => _186.subpaths, 'optionalAccess', _187 => _187[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _200 => _200.getNode, 'call', _201 => _201(s.pen.nodeId), 'optionalAccess', _202 => _202.subpaths, 'optionalAccess', _203 => _203[s.pen.subpath]]) ? s.pen : null;
       if (this.widthPoints.length) {
         const kept = this.widthPoints.filter((r) => {
           const n = this.getNode(r.nodeId);
-          return _optionalChain([n, 'optionalAccess', _188 => _188.type]) === "path" && !!_optionalChain([n, 'access', _189 => _189.strokeWidthProfile, 'optionalAccess', _190 => _190[r.index]]);
+          return _optionalChain([n, 'optionalAccess', _204 => _204.type]) === "path" && !!_optionalChain([n, 'access', _205 => _205.strokeWidthProfile, 'optionalAccess', _206 => _206[r.index]]);
         });
         if (kept.length !== this.widthPoints.length) this.widthPoints = kept;
       }
@@ -7792,7 +8931,7 @@ var VectorEditorController = (_class5 = class {
       if (res.kind) {
         this.snappedToObject = true;
         this.setGuides(res);
-        return _optionalChain([leave, 'optionalAccess', _191 => _191.constrain]) ? res.point : { x: res.x ? res.point.x : this.gridValue(res.point.x), y: res.y ? res.point.y : this.gridValue(res.point.y) };
+        return _optionalChain([leave, 'optionalAccess', _207 => _207.constrain]) ? res.point : { x: res.x ? res.point.x : this.gridValue(res.point.x), y: res.y ? res.point.y : this.gridValue(res.point.y) };
       }
     }
     this.setGuides(null);
@@ -7810,14 +8949,14 @@ var VectorEditorController = (_class5 = class {
   /** Where the pointer at `p` would place a point with the pen or a shape tool (and the guides showing why). */
   hoverSnap(p, input) {
     if (this.tool === "pen") {
-      const sp = this.pen ? _optionalChain([this, 'access', _192 => _192.getNode, 'call', _193 => _193(this.pen.nodeId), 'optionalAccess', _194 => _194.subpaths, 'access', _195 => _195[this.pen.subpath]]) : void 0;
-      if (this.pen && sp && _optionalChain([this, 'access', _196 => _196.hover, 'optionalAccess', _197 => _197.anchor])) {
+      const sp = this.pen ? _optionalChain([this, 'access', _208 => _208.getNode, 'call', _209 => _209(this.pen.nodeId), 'optionalAccess', _210 => _210.subpaths, 'access', _211 => _211[this.pen.subpath]]) : void 0;
+      if (this.pen && sp && _optionalChain([this, 'access', _212 => _212.hover, 'optionalAccess', _213 => _213.anchor])) {
         this.setGuides(null);
         return p;
       }
       const last = this.pen && sp ? getAnchorWorld(this.doc, { nodeId: this.pen.nodeId, subpath: this.pen.subpath, index: sp.anchors.length - 1 }) : void 0;
       const leave = last ? { at: { x: last.x, y: last.y }, constrain: input.shift ? "angle" : null } : null;
-      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _198 => _198.pen, 'optionalAccess', _199 => _199.nodeId]), () => ( null))));
+      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _214 => _214.pen, 'optionalAccess', _215 => _215.nodeId]), () => ( null))));
     }
     if (SHAPE_TOOLS.has(this.tool)) return this.snapDrawn(p, null, input, () => this.drawingTargets(null));
     this.setGuides(null);
@@ -7965,7 +9104,7 @@ var VectorEditorController = (_class5 = class {
     if (d.fillRule) out.fillRule = d.fillRule;
     if (d.strokeAlign && d.strokeAlign !== "center") out.strokeAlign = d.strokeAlign;
     for (const key of ["startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale"]) if (d[key]) out[key] = d[key];
-    if (_optionalChain([d, 'access', _200 => _200.strokeWidthProfile, 'optionalAccess', _201 => _201.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
+    if (_optionalChain([d, 'access', _216 => _216.strokeWidthProfile, 'optionalAccess', _217 => _217.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     return out;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -8059,7 +9198,7 @@ var VectorEditorController = (_class5 = class {
       next.set(path.id, { ...path, [target]: g });
     }
     this.change(_nullishCoalesce(options.label, () => ( "Gradient")), () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))), options.merge);
-    const stops = _nullishCoalesce(_optionalChain([next, 'access', _202 => _202.values, 'call', _203 => _203(), 'access', _204 => _204.next, 'call', _205 => _205(), 'access', _206 => _206.value, 'optionalAccess', _207 => _207[target], 'optionalAccess', _208 => _208.stops, 'access', _209 => _209.length]), () => ( 0));
+    const stops = _nullishCoalesce(_optionalChain([next, 'access', _218 => _218.values, 'call', _219 => _219(), 'access', _220 => _220.next, 'call', _221 => _221(), 'access', _222 => _222.value, 'optionalAccess', _223 => _223[target], 'optionalAccess', _224 => _224.stops, 'access', _225 => _225.length]), () => ( 0));
     if (this.gradientEdit.stop !== null && this.gradientEdit.stop >= stops) this.gradientEdit = { ...this.gradientEdit, stop: null };
     return { ok: true };
   }
@@ -8228,7 +9367,7 @@ var VectorEditorController = (_class5 = class {
   upGradient(drag) {
     const part = drag.part;
     if (!drag.moved) {
-      if (_optionalChain([part, 'optionalAccess', _210 => _210.kind]) === "bar") {
+      if (_optionalChain([part, 'optionalAccess', _226 => _226.kind]) === "bar") {
         this.addGradientStop(part.offset);
         return;
       }
@@ -8247,7 +9386,7 @@ var VectorEditorController = (_class5 = class {
     const byNode = /* @__PURE__ */ new Map();
     for (const r of refs) {
       const node = this.getNode(r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _211 => _211.type]) !== "path" || !_optionalChain([node, 'access', _212 => _212.strokeWidthProfile, 'optionalAccess', _213 => _213[r.index]])) continue;
+      if (_optionalChain([node, 'optionalAccess', _227 => _227.type]) !== "path" || !_optionalChain([node, 'access', _228 => _228.strokeWidthProfile, 'optionalAccess', _229 => _229[r.index]])) continue;
       byNode.set(r.nodeId, [..._nullishCoalesce(byNode.get(r.nodeId), () => ( [])), r.index]);
     }
     if (!byNode.size) return { ok: false, message: "There is no such width point." };
@@ -8265,12 +9404,12 @@ var VectorEditorController = (_class5 = class {
   }
   /** Selects width points (width tool); points on other paths than the first are dropped. */
   selectWidthPoints(refs) {
-    const first = _optionalChain([refs, 'access', _214 => _214[0], 'optionalAccess', _215 => _215.nodeId]);
+    const first = _optionalChain([refs, 'access', _230 => _230[0], 'optionalAccess', _231 => _231.nodeId]);
     const next = [];
     for (const r of refs) {
       if (r.nodeId !== first || next.some((q) => q.index === r.index)) continue;
       const n = this.getNode(r.nodeId);
-      if (_optionalChain([n, 'optionalAccess', _216 => _216.type]) === "path" && _optionalChain([n, 'access', _217 => _217.strokeWidthProfile, 'optionalAccess', _218 => _218[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
+      if (_optionalChain([n, 'optionalAccess', _232 => _232.type]) === "path" && _optionalChain([n, 'access', _233 => _233.strokeWidthProfile, 'optionalAccess', _234 => _234[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
     }
     this.widthPoints = next;
     this.notify();
@@ -8285,7 +9424,7 @@ var VectorEditorController = (_class5 = class {
    */
   setWidthPoint(target, values) {
     const node = this.getNode(target.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _219 => _219.type]) !== "path") return { ok: false, message: "There is no such path." };
+    if (_optionalChain([node, 'optionalAccess', _235 => _235.type]) !== "path") return { ok: false, message: "There is no such path." };
     const g = vectorStrokeWidthGeometry(node);
     if (!g || !(g.unit > 0)) return { ok: false, message: "The path has no visible stroke." };
     const num2 = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? v2 : void 0;
@@ -8318,11 +9457,11 @@ var VectorEditorController = (_class5 = class {
         }
       }
     }
-    const subpath = _optionalChain([this, 'access', _220 => _220.widthEdit, 'optionalAccess', _221 => _221.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _222 => _222.widthPoints, 'access', _223 => _223.find, 'call', _224 => _224((r) => r.nodeId === node.id), 'optionalAccess', _225 => _225.subpath]), () => ( 0));
+    const subpath = _optionalChain([this, 'access', _236 => _236.widthEdit, 'optionalAccess', _237 => _237.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _238 => _238.widthPoints, 'access', _239 => _239.find, 'call', _240 => _240((r) => r.nodeId === node.id), 'optionalAccess', _241 => _241.subpath]), () => ( 0));
     const edit = this.widthEdit;
     this.change("Width Point", () => this.replaceNode(node.id, withStyle(node, { strokeWidthProfile: points })));
     this.widthPoints = [{ nodeId: node.id, index, subpath }];
-    if (_optionalChain([edit, 'optionalAccess', _226 => _226.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
+    if (_optionalChain([edit, 'optionalAccess', _242 => _242.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
     this.notify();
     return { ok: true };
   }
@@ -8356,7 +9495,7 @@ var VectorEditorController = (_class5 = class {
   /** The editor's view of point `index` (or of the stroke at `t` when index is null) of `nodeId`. */
   widthEditFor(nodeId, subpath, index, t) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _227 => _227.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _243 => _243.type]) !== "path") return null;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) return null;
     const profile = sanitizeWidthProfile(node.strokeWidthProfile);
@@ -8390,7 +9529,7 @@ var VectorEditorController = (_class5 = class {
     const refs = this.cornerTargets(options);
     if (!refs.length) return { ok: false, message: "Nothing is selected." };
     this.change("Corner Kind", () => {
-      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _228 => _228.corner, 'optionalAccess', _229 => _229.radius]), () => ( 0)), kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _244 => _244.corner, 'optionalAccess', _245 => _245.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
@@ -8512,7 +9651,7 @@ var VectorEditorController = (_class5 = class {
   updateEffect(nodeId, effectId, patch, options = {}) {
     const merge = options.merge === true ? `effect:${nodeId}:${effectId}` : options.merge || void 0;
     const node = this.getNode(nodeId);
-    const current = _optionalChain([node, 'optionalAccess', _230 => _230.effects, 'optionalAccess', _231 => _231.find, 'call', _232 => _232((e) => e.id === effectId)]);
+    const current = _optionalChain([node, 'optionalAccess', _246 => _246.effects, 'optionalAccess', _247 => _247.find, 'call', _248 => _248((e) => e.id === effectId)]);
     const label = current ? _nullishCoalesce(VECTOR_EFFECT_LABELS[current.type], () => ( "Effect")) : "Effect";
     return this.editEffects(
       nodeId,
@@ -8521,7 +9660,8 @@ var VectorEditorController = (_class5 = class {
         const i = list.findIndex((e2) => e2.id === effectId);
         if (i < 0) return `Node "${nodeId}" has no effect "${effectId}".`;
         const e = list[i];
-        const params = patch.params ? normalizeVectorEffectParams(e.type, patch.params, e.params) : e.params;
+        const raw = patch.params && e.type === "envelope" && node ? this.envelopeParams(node, e, patch.params) : patch.params;
+        const params = raw ? normalizeVectorEffectParams(e.type, raw, e.params) : e.params;
         const next = { ...e, params, ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {} };
         if (next.enabled !== false) delete next.enabled;
         return list.map((x, j) => j === i ? next : x);
@@ -8645,10 +9785,10 @@ var VectorEditorController = (_class5 = class {
     return this.selection.filter((id) => {
       let covered = false;
       const loc = locateVectorNode(this.doc.nodes, id);
-      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _233 => _233.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _249 => _249.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _234 => _234(this.doc.nodes, parent.id), 'optionalAccess', _235 => _235.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _250 => _250(this.doc.nodes, parent.id), 'optionalAccess', _251 => _251.parent]), () => ( null));
       }
       return !covered;
     });
@@ -8661,6 +9801,318 @@ var VectorEditorController = (_class5 = class {
     if (!angle) return m;
     return multiplyMatrices(multiplyMatrices(rotateMatrix(-angle), m), rotateMatrix(angle));
   }
+  /** The selection frame's corners in document space, clockwise from the top left. */
+  frameCorners(frame2) {
+    const rot = rotateMatrix(frame2.angle);
+    return vectorBoxCorners(frame2).map((c) => frame2.angle ? applyMatrix(rot, c) : c);
+  }
+  /** `doc` with nodes `ids` sent through `f` (a map of document space), each in its own space (see `distortVectorNode`). */
+  distorted(doc, ids, f, tolerance = VECTOR_DISTORT_TOLERANCE) {
+    const visit = (list, parent) => {
+      let changed = false;
+      const out = list.map((n) => {
+        let next = n;
+        if (ids.has(n.id) && !n.locked) next = distortVectorNode(n, parent, f, tolerance);
+        else if (n.type === "group") {
+          const children = visit(n.children, multiplyMatrices(nodeMatrix(n), parent));
+          if (children !== n.children) next = { ...n, children };
+        }
+        if (next !== n) changed = true;
+        return next;
+      });
+      return changed ? out : list;
+    };
+    const nodes = visit(doc.nodes, IDENTITY_MATRIX);
+    return nodes === doc.nodes ? doc : { ...doc, nodes };
+  }
+  /**
+   * Free Distort mode of the selection box (`state.freeDistort`): dragging a corner distorts the
+   * selection in perspective, each corner on its own (Shift+Alt+Mod: symmetric perspective, the
+   * corner beside it moving the other way); dragging a side moves its two corners; Mod-dragging a
+   * side skews along it (Alt: about the centre). Each drag is one undo step.
+   */
+  setFreeDistort(on) {
+    if (this.freeDistort === on) return;
+    this.freeDistort = on;
+    this.notify();
+  }
+  /**
+   * Distorts the selected (or given) nodes so the corners of their selection box (clockwise from
+   * the top left, in the box's own rotation) land on `corners` (document space): a projective map,
+   * so straight lines stay straight. Curves are followed within `tolerance` (document units).
+   * One undo step.
+   */
+  distort(corners2, options = {}) {
+    const ids = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
+    const frame2 = this.frameOf(ids);
+    if (!frame2) return { ok: false, message: "Nothing is selected." };
+    if (!(frame2.width > 0 && frame2.height > 0)) return { ok: false, message: "The selection has no area to distort." };
+    const from = this.frameCorners(frame2);
+    const h = corners2.length === 4 ? vectorHomography(from, corners2) : null;
+    if (!h || !vectorHomographyKeepsQuad(h, from)) return { ok: false, message: "The four corners must make a convex quadrilateral, clockwise from the top left." };
+    this.change("Distort", () => {
+      this.doc = this.distorted(this.doc, new Set(ids), (p) => _nullishCoalesce(applyVectorHomography(h, p), () => ( p)), options.tolerance);
+    });
+    return { ok: true };
+  }
+  /**
+   * Skews the selected (or given) nodes along the selection box's own axes by `ax` degrees
+   * horizontally (x' = x + tan(ax)·y: vertical lines lean right for positive angles) and `ay`
+   * vertically, about `origin` (default: the box centre, document space). One undo step.
+   */
+  skew(ax, ay = 0, options = {}) {
+    const frame2 = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
+    if (!frame2) return { ok: false, message: "Nothing is selected." };
+    if (![ax, ay].every((v2) => Number.isFinite(v2) && Math.abs(v2) < 89.9)) return { ok: false, message: "Skew angles must be between \u221289.9\xB0 and 89.9\xB0." };
+    const origin = applyMatrix(rotateMatrix(-frame2.angle), _nullishCoalesce(options.origin, () => ( this.frameCenter(frame2))));
+    return this.transform(this.inFrame(frame2.angle, vectorSkewMatrix(ax, ay, origin)), { ids: options.ids, label: "Skew" });
+  }
+  /** A selection box handle dragged in Free Distort mode. */
+  moveDistort(drag, p, input) {
+    const angle = drag.frame.angle;
+    const unrotate = (v2) => angle ? applyMatrix(rotateMatrix(-angle), v2) : v2;
+    const q = unrotate(p);
+    const q0 = unrotate(drag.start);
+    const d = { x: q.x - q0.x, y: q.y - q0.y };
+    const ids = new Set(this.selectedRoots());
+    const from = this.frameCorners(drag.frame);
+    const corner = drag.handle.length === 2;
+    this.setGuides(null);
+    if (!corner && input.mod) {
+      const m = this.inFrame(angle, vectorShearForSide(drag.frame, drag.handle, d, !!input.alt));
+      drag.op = "Skew";
+      this.doc = this.transformed(drag.base, ids, m);
+      this.interaction = { type: "distort", mode: "skew", corners: from.map((c) => applyMatrix(m, c)) };
+      this.notify(true);
+      return;
+    }
+    const mode = corner && input.mod && input.alt && input.shift ? "perspective" : "distort";
+    const rot = rotateMatrix(angle);
+    const quad = vectorDistortQuad(drag.frame, drag.handle, d, mode).map((c) => angle ? applyMatrix(rot, c) : c);
+    const h = vectorHomography(from, quad);
+    if (!h || !vectorHomographyKeepsQuad(h, from)) return;
+    drag.op = mode === "perspective" ? "Perspective" : "Distort";
+    this.doc = this.distorted(drag.base, ids, (pt2) => _nullishCoalesce(applyVectorHomography(h, pt2), () => ( pt2)));
+    this.interaction = { type: "distort", mode, corners: quad };
+    this.notify(true);
+  }
+  // -------------------------------------------------------------------------
+  // Envelopes
+  // -------------------------------------------------------------------------
+  /** Selected (or given) roots that can carry an envelope. */
+  envelopeTargets(ids) {
+    return this.effectTargets(ids).filter((n) => !n.locked);
+  }
+  /** Envelope parameters for `node` after `patch`: a preset switched to a mesh becomes the mesh it stood for. */
+  envelopeParams(node, current, patch) {
+    if (patch.style !== "mesh" || patch.mesh !== void 0 || !current || current.params.style === "mesh") return patch;
+    const frame2 = vectorEnvelopeFrame(node, current.id);
+    if (!frame2) return patch;
+    const rows = typeof patch.rows === "number" ? patch.rows : current.params.rows;
+    const columns = typeof patch.columns === "number" ? patch.columns : current.params.columns;
+    return { ...patch, mesh: resizeVectorMesh(frame2.mesh, columns, rows) };
+  }
+  /**
+   * Gives the selected (or given) nodes an envelope distortion, or changes the one they have: a
+   * warp preset (`style` with `bend`, `horizontal` and `vertical` in percent and `orientation`) or
+   * a mesh (`style: 'mesh'` with `rows` and `columns`, and optionally its `mesh` points). The
+   * envelope stays live (an `envelope` effect: edit it with the Envelope tool, Expand Appearance
+   * bakes it). One undo step (with `merge`, consecutive changes fold into one, as a slider drag
+   * should). Returns the envelope of each node.
+   */
+  envelope(params = {}, options = {}) {
+    const targets = this.envelopeTargets(options.ids);
+    if (!targets.length) return [];
+    const out = [];
+    const next = /* @__PURE__ */ new Map();
+    const raw = params;
+    for (const node of targets) {
+      const list = _nullishCoalesce(node.effects, () => ( []));
+      const current = _nullishCoalesce(list.find((e) => e.type === "envelope"), () => ( null));
+      if (current) {
+        const p = normalizeVectorEffectParams("envelope", this.envelopeParams(node, current, raw), current.params);
+        const { enabled: _e, ...rest } = current;
+        next.set(node.id, { ...node, effects: list.map((e) => e === current ? { ...rest, params: p } : e) });
+        out.push({ nodeId: node.id, effectId: current.id });
+      } else {
+        let k = list.length + 1;
+        while (list.some((e) => e.id === `fx${k}`)) k++;
+        const effect = createVectorEffect("envelope", `fx${k}`, raw);
+        next.set(node.id, { ...node, effects: [...list, effect] });
+        out.push({ nodeId: node.id, effectId: effect.id });
+      }
+    }
+    const made = out.some((o) => !_optionalChain([targets, 'access', _252 => _252.find, 'call', _253 => _253((n) => n.id === o.nodeId), 'optionalAccess', _254 => _254.effects, 'optionalAccess', _255 => _255.some, 'call', _256 => _256((e) => e.id === o.effectId)]));
+    const merge = options.merge ? `envelope:${out.map((o) => o.nodeId).join(",")}` : void 0;
+    this.change(made ? params.style === "mesh" ? "Make Envelope with Mesh" : "Make Envelope with Warp" : "Edit Envelope", () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))), merge);
+    return out;
+  }
+  /**
+   * Make with Top Object: the topmost selected object's outline (a closed path) becomes the envelope
+   * of the other selected objects (grouped when there are several; they must share a parent), as a
+   * mesh of `columns × rows` patches whose border follows the outline. The top object is used up.
+   * One undo step; returns the id of the enveloped node.
+   */
+  makeEnvelopeWithTopObject(options = {}) {
+    const ids = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
+    if (ids.length < 2) return { ok: false, message: "Select the objects and, on top of them, the shape to use as the envelope." };
+    const order = /* @__PURE__ */ new Map();
+    walkVectorNodes(this.doc.nodes, (n) => order.set(n.id, order.size));
+    const sorted = ids.filter((id) => order.has(id)).sort((a, b) => order.get(a) - order.get(b));
+    const topId = sorted[sorted.length - 1];
+    const top = this.getNode(topId);
+    const outline = _optionalChain([top, 'optionalAccess', _257 => _257.type]) === "path" ? top.subpaths.find((sp) => sp.closed && sp.anchors.length > 1) : void 0;
+    if (!top || !outline) return { ok: false, message: "The top object must be a path with a closed outline." };
+    const contents = sorted.slice(0, -1).map((id) => this.getNode(id));
+    if (contents.some((n) => n.locked)) return { ok: false, message: "Locked objects cannot be enveloped." };
+    const parents = contents.map((n) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _258 => _258(this.doc.nodes, n.id), 'optionalAccess', _259 => _259.parent, 'optionalAccess', _260 => _260.id]), () => ( null)));
+    if (parents.some((p) => p !== parents[0])) return { ok: false, message: "The objects to envelope must be in the same group." };
+    const target = contents.length === 1 ? contents[0] : { id: this.newId(), type: "group", name: "Envelope", children: contents.map((n) => n) };
+    const parentToDoc = parents[0] ? this.worldOf(parents[0]) : IDENTITY_MATRIX;
+    const targetToDoc = multiplyMatrices(nodeMatrix(target), parentToDoc);
+    const toLocal = multiplyMatrices(this.worldOf(topId), invertMatrix(targetToDoc));
+    const local = {
+      closed: true,
+      anchors: outline.anchors.map((a) => ({
+        ...applyMatrix(toLocal, a),
+        ...a.in ? { in: applyMatrix(toLocal, a.in) } : {},
+        ...a.out ? { out: applyMatrix(toLocal, a.out) } : {}
+      }))
+    };
+    const mesh = vectorMeshFromOutline(local, _nullishCoalesce(options.columns, () => ( 4)), _nullishCoalesce(options.rows, () => ( 4)));
+    if (!mesh) return { ok: false, message: "The top object\u2019s outline is too small to use as an envelope." };
+    const list = _nullishCoalesce(target.effects, () => ( []));
+    let k = list.length + 1;
+    while (list.some((e) => e.id === `fx${k}`)) k++;
+    const effect = createVectorEffect("envelope", `fx${k}`, { style: "mesh", mesh });
+    const enveloped = { ...target, effects: [...list, effect] };
+    this.change("Make Envelope with Top Object", () => {
+      let nodes = spliceTree(this.doc.nodes, topId, []);
+      if (contents.length === 1) nodes = spliceTree(nodes, target.id, [enveloped]);
+      else {
+        const last = contents[contents.length - 1].id;
+        for (const n of contents.slice(0, -1)) nodes = spliceTree(nodes, n.id, []);
+        nodes = spliceTree(nodes, last, [enveloped]);
+      }
+      this.setDoc(nodes);
+      this.selection = [target.id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return { ok: true, nodeId: target.id };
+  }
+  /**
+   * Release: the selected (or given) nodes lose their envelope, and its shape (the mesh's border)
+   * comes back as a path above each of them. One undo step; returns the new paths' ids.
+   */
+  releaseEnvelope(options = {}) {
+    const targets = this.envelopeTargets(options.ids).filter((n) => _optionalChain([n, 'access', _261 => _261.effects, 'optionalAccess', _262 => _262.some, 'call', _263 => _263((e) => e.type === "envelope")]));
+    if (!targets.length) return [];
+    const created = [];
+    const replace = /* @__PURE__ */ new Map();
+    for (const node of targets) {
+      const effect = node.effects.find((e) => e.type === "envelope");
+      const frame2 = vectorEnvelopeFrame(node, effect.id);
+      const rest = node.effects.filter((e) => e !== effect);
+      const { effects: _e, ...plain3 } = node;
+      const kept = rest.length ? { ...plain3, effects: rest } : plain3;
+      if (!frame2) {
+        replace.set(node.id, [kept]);
+        continue;
+      }
+      const id = this.newId();
+      created.push(id);
+      const shape = {
+        id,
+        type: "path",
+        name: "Envelope",
+        ...node.transform ? { transform: node.transform } : {},
+        subpaths: [vectorMeshOutline(frame2.mesh)],
+        fill: null,
+        stroke: "#808080",
+        strokeWidth: 1
+      };
+      replace.set(node.id, [kept, shape]);
+    }
+    this.change("Release Envelope", () => {
+      let nodes = this.doc.nodes;
+      for (const [id, list] of replace) nodes = spliceTree(nodes, id, list);
+      this.setDoc(nodes);
+      this.selection = [...targets.map((n) => n.id), ...created];
+      this.anchors = [];
+    });
+    return created;
+  }
+  /** The selected node the Envelope tool edits, with its mesh (node space) and node → document matrix. */
+  envelopeTarget() {
+    const target = getVectorEnvelopeTarget(this.doc, this.selection);
+    return target && !target.node.locked ? target : null;
+  }
+  /** The envelope mesh point under `screen` (handles first), or a spot inside the mesh. */
+  hitEnvelope(screen, p) {
+    const target = this.envelopeTarget();
+    if (!target) return null;
+    const { mesh } = target.frame;
+    const pts = vectorMeshEditPoints(mesh);
+    let best = null;
+    let bestD = Infinity;
+    for (const index of [...pts.handles.map((h) => h.index), ...pts.anchors]) {
+      const s = this.documentToScreen(applyMatrix(target.world, mesh.points[index]));
+      const d = Math.hypot(s.x - screen.x, s.y - screen.y);
+      if (d <= this.hitRadius && d < bestD - 0.5) {
+        best = index;
+        bestD = d;
+      }
+    }
+    if (best !== null) return { target, index: best, s: 0, t: 0 };
+    const local = applyMatrix(invertMatrix(target.world), p);
+    const at2 = vectorMeshParamAt(mesh, local);
+    if (at2.distance > this.tolerance()) return null;
+    return { target, index: null, s: at2.s, t: at2.t };
+  }
+  downEnvelope(screen, p, input) {
+    const hit = this.hitEnvelope(screen, p);
+    if (hit) {
+      const { node: node2, frame: frame2 } = hit.target;
+      this.drag = {
+        kind: "envelope",
+        nodeId: node2.id,
+        effectId: frame2.effectId,
+        base: frame2.mesh,
+        baseDoc: this.doc,
+        before: this.snapshot(),
+        index: hit.index,
+        s: hit.s,
+        t: hit.t,
+        start: this.toLocal(node2.id, p),
+        moved: false
+      };
+      this.interaction = { type: "envelope", nodeId: node2.id, index: hit.index };
+      this.notify();
+      return;
+    }
+    const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
+    if (node) this.selection = input.shift ? this.selection.includes(node.id) ? this.selection.filter((id) => id !== node.id) : [...this.selection, node.id] : [node.id];
+    else if (!input.shift) this.selection = [];
+    this.anchors = [];
+    this.notify();
+  }
+  moveEnvelope(drag, p) {
+    const local = this.toLocal(drag.nodeId, p, drag.baseDoc);
+    const d = { x: local.x - drag.start.x, y: local.y - drag.start.y };
+    if (!drag.moved && Math.hypot(d.x, d.y) * this.viewport.zoom < 1) return;
+    drag.moved = true;
+    const mesh = drag.index !== null ? dragVectorMeshPoint(drag.base, drag.index, d) : pullVectorMesh(drag.base, drag.s, drag.t, d);
+    const nodes = mapTree(drag.baseDoc.nodes, (n) => {
+      if (n.id !== drag.nodeId) return n;
+      const effects = (_nullishCoalesce(n.effects, () => ( []))).map(
+        (e) => e.id === drag.effectId && e.type === "envelope" ? { ...e, params: { ...e.params, style: "mesh", mesh, columns: mesh.us.length - 1, rows: mesh.vs.length - 1 } } : e
+      );
+      return { ...n, effects };
+    });
+    this.doc = { ...drag.baseDoc, nodes };
+    this.notify(true);
+  }
   /** Applies a matrix to the selected (or given) nodes as one undo step. */
   transform(matrix, options = {}) {
     const ids = new Set(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
@@ -8831,8 +10283,8 @@ var VectorEditorController = (_class5 = class {
     if (!ids.length) return null;
     const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
     if (locs.some((l) => !l)) return null;
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _236 => _236[0], 'access', _237 => _237.parent, 'optionalAccess', _238 => _238.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _239 => _239.parent, 'optionalAccess', _240 => _240.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _264 => _264[0], 'access', _265 => _265.parent, 'optionalAccess', _266 => _266.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _267 => _267.parent, 'optionalAccess', _268 => _268.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -8855,7 +10307,7 @@ var VectorEditorController = (_class5 = class {
   }
   /** Replaces selected groups with their children. */
   ungroup(options = {}) {
-    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _241 => _241.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _269 => _269.type]) === "group");
     if (!groups.length) return { ok: false, message: "Select a group to ungroup." };
     const set = new Set(groups.map((g) => g.id));
     this.change("Ungroup", () => {
@@ -8955,7 +10407,7 @@ var VectorEditorController = (_class5 = class {
       this.change(label, () => this.replaceNode(lone.id, { ...lone, liveBoolean: op, children }));
       return lone.id;
     }
-    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _242 => _242(this.doc.nodes, id2), 'optionalAccess', _243 => _243.parent]), () => ( null)));
+    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _270 => _270(this.doc.nodes, id2), 'optionalAccess', _271 => _271.parent]), () => ( null)));
     if (parents.every((g) => isVectorLiveBoolean(g))) {
       const set = new Set(roots);
       this.change(
@@ -8976,8 +10428,8 @@ var VectorEditorController = (_class5 = class {
       return parents[0].id;
     }
     if (nodes.length < 2) return null;
-    const parent = _nullishCoalesce(_optionalChain([parents, 'access', _244 => _244[0], 'optionalAccess', _245 => _245.id]), () => ( null));
-    if (parents.some((g) => (_nullishCoalesce(_optionalChain([g, 'optionalAccess', _246 => _246.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([parents, 'access', _272 => _272[0], 'optionalAccess', _273 => _273.id]), () => ( null));
+    if (parents.some((g) => (_nullishCoalesce(_optionalChain([g, 'optionalAccess', _274 => _274.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change(label, () => {
       const set = new Set(roots);
@@ -9025,7 +10477,7 @@ var VectorEditorController = (_class5 = class {
   }
   /** Splits selected compound paths into one path per subpath. */
   breakApart(options = {}) {
-    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _247 => _247.type]) === "path" && n.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _275 => _275.type]) === "path" && n.subpaths.length > 1);
     if (!paths.length) return { ok: false, message: "Select a compound path to break apart." };
     const created = [];
     const set = new Set(paths.map((p) => p.id));
@@ -9093,7 +10545,7 @@ var VectorEditorController = (_class5 = class {
     const out = /* @__PURE__ */ new Map();
     for (const id of _nullishCoalesce(ids, () => ( this.selection))) {
       const node = this.getNode(id);
-      const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _248 => _248(this.doc.nodes, id), 'optionalAccess', _249 => _249.parent]);
+      const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _276 => _276(this.doc.nodes, id), 'optionalAccess', _277 => _277.parent]);
       if (isVectorBlendGroup(group)) out.set(group.id, group);
     }
     return [...out.values()];
@@ -9111,8 +10563,8 @@ var VectorEditorController = (_class5 = class {
     });
     if (ids.length < 2) return null;
     const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _250 => _250[0], 'access', _251 => _251.parent, 'optionalAccess', _252 => _252.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _253 => _253.parent, 'optionalAccess', _254 => _254.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _278 => _278[0], 'access', _279 => _279.parent, 'optionalAccess', _280 => _280.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _281 => _281.parent, 'optionalAccess', _282 => _282.id]), () => ( null))) !== parent)) return null;
     const order = input.keepOrder ? ids : ids.slice().sort((a, b) => locs[ids.indexOf(a)].index - locs[ids.indexOf(b)].index);
     const blend = blendOptionsOf({ ...this.blendDefaults, ...input });
     if (input.starts) {
@@ -9154,7 +10606,7 @@ var VectorEditorController = (_class5 = class {
     const node = this.getNode(nodeId);
     if (!isVectorBlendGroup(group)) return { ok: false, message: `"${blendId}" is not a blend.` };
     if (!node || node.blendStep || node.locked || node.id === blendId) return { ok: false, message: `"${nodeId}" cannot be a key.` };
-    const parentOf = (id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _255 => _255(this.doc.nodes, id), 'optionalAccess', _256 => _256.parent, 'optionalAccess', _257 => _257.id]), () => ( null));
+    const parentOf = (id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _283 => _283(this.doc.nodes, id), 'optionalAccess', _284 => _284.parent, 'optionalAccess', _285 => _285.id]), () => ( null));
     if (parentOf(blendId) !== parentOf(nodeId)) return { ok: false, message: "The new key must sit beside the blend (same parent)." };
     const start = options.start;
     this.change("Blend", () => {
@@ -9224,7 +10676,7 @@ var VectorEditorController = (_class5 = class {
   replaceBlendSpine(options = {}) {
     const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
     const groups = this.blendTargets(roots);
-    const paths = roots.map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _258 => _258.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _259 => _259(this.doc.nodes, n.id), 'optionalAccess', _260 => _260.parent])));
+    const paths = roots.map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _286 => _286.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _287 => _287(this.doc.nodes, n.id), 'optionalAccess', _288 => _288.parent])));
     if (groups.length !== 1 || paths.length !== 1) return { ok: false, message: "Select one blend and one path to be its spine." };
     const group = groups[0];
     const path = paths[0];
@@ -9255,7 +10707,7 @@ var VectorEditorController = (_class5 = class {
   shapeBuilderMap(ids) {
     const roots = _nullishCoalesce(ids, () => ( this.selectedRoots()));
     const key = roots.join("\0");
-    if (_optionalChain([this, 'access', _261 => _261.builderCache, 'optionalAccess', _262 => _262.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
+    if (_optionalChain([this, 'access', _289 => _289.builderCache, 'optionalAccess', _290 => _290.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
     const entries = roots.length ? vectorPathEntries(this.doc, roots, { expand: false }) : [];
     const map = entries.length ? vectorShapeBuilderMap(entries) : null;
     this.builderCache = { doc: this.doc, key, map };
@@ -9315,9 +10767,9 @@ var VectorEditorController = (_class5 = class {
         const list = [];
         const r = plan.replace.get(i);
         if (r === void 0) list.push(node);
-        else if (_optionalChain([r, 'optionalAccess', _263 => _263.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _264 => _264.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _265 => _265.kind]) === "pieces") {
+        else if (_optionalChain([r, 'optionalAccess', _291 => _291.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _292 => _292.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _293 => _293.kind]) === "pieces") {
           r.paths.forEach(
             (path, k) => list.push({ ...node, id: k === 0 ? node.id : this.newId(), subpaths: bezierToSubpaths(toLocal(path)).map((sp) => ({ ...sp, closed: false })) })
           );
@@ -9351,7 +10803,7 @@ var VectorEditorController = (_class5 = class {
   }
   /** The paint bucket's map of the visible outlines, cached per document and gap. */
   fillMap(gap) {
-    if (_optionalChain([this, 'access', _266 => _266.fillCache, 'optionalAccess', _267 => _267.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
+    if (_optionalChain([this, 'access', _294 => _294.fillCache, 'optionalAccess', _295 => _295.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
     const map = vectorFillMap(this.doc, gap);
     this.fillCache = { doc: this.doc, gap, map };
     return map;
@@ -9365,8 +10817,8 @@ var VectorEditorController = (_class5 = class {
    */
   fillRegion(point, options = {}) {
     if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) return null;
-    const region = _optionalChain([this, 'access', _268 => _268.fillMap, 'call', _269 => _269(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _270 => _270.regionAt, 'call', _271 => _271([point.x, point.y])]);
-    if (!_optionalChain([region, 'optionalAccess', _272 => _272.length])) return null;
+    const region = _optionalChain([this, 'access', _296 => _296.fillMap, 'call', _297 => _297(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _298 => _298.regionAt, 'call', _299 => _299([point.x, point.y])]);
+    if (!_optionalChain([region, 'optionalAccess', _300 => _300.length])) return null;
     let below = null;
     const roots = new Set(this.selectedRoots());
     walkVectorNodes(this.doc.nodes, (n) => {
@@ -9392,7 +10844,7 @@ var VectorEditorController = (_class5 = class {
   /** Updates the Shape Builder / paint bucket highlight for the pointer at `p`; true when it changed. */
   hoverBuilder(p, alt) {
     if (this.tool === "paintBucket") {
-      const region = _nullishCoalesce(_optionalChain([this, 'access', _273 => _273.fillMap, 'call', _274 => _274(this.editing.fillGap), 'optionalAccess', _275 => _275.regionAt, 'call', _276 => _276([p.x, p.y])]), () => ( null));
+      const region = _nullishCoalesce(_optionalChain([this, 'access', _301 => _301.fillMap, 'call', _302 => _302(this.editing.fillGap), 'optionalAccess', _303 => _303.regionAt, 'call', _304 => _304([p.x, p.y])]), () => ( null));
       const key2 = region ? _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, region, { precision: 2 }) : null;
       if (key2 === this.builderHoverKey) return false;
       this.builderHoverKey = key2;
@@ -9500,7 +10952,7 @@ var VectorEditorController = (_class5 = class {
   /** `doc` with anchor `ref` moved to document point `to` by a Curvature-tool move. */
   curvatureMoved(doc, ref, to) {
     const node = findVectorNode(doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _277 => _277.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _305 => _305.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
     const q = this.toLocal(ref.nodeId, to, doc);
     const subpaths = node.subpaths.map((sp, i) => i === ref.subpath ? curvatureMoveAnchor(sp, ref.index, q) : sp);
     const nodes = mapTree(doc.nodes, (n) => n.id === ref.nodeId ? { ...node, subpaths } : n);
@@ -9509,7 +10961,7 @@ var VectorEditorController = (_class5 = class {
   /** `doc` with segment `ref` bent through document point `p` at parameter `t`. */
   bent(doc, ref, t, p) {
     const node = findVectorNode(doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _278 => _278.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _306 => _306.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
     const q = this.toLocal(ref.nodeId, p, doc);
     const subpaths = node.subpaths.map((sp, i) => i === ref.subpath ? bendSegment(sp, ref.segment, t, q) : sp);
     return { ...doc, nodes: mapTree(doc.nodes, (n) => n.id === ref.nodeId ? { ...node, subpaths } : n) };
@@ -9520,7 +10972,7 @@ var VectorEditorController = (_class5 = class {
    */
   bendSegment(ref, to, t = 0.5) {
     const node = this.getNode(ref.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _279 => _279.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _307 => _307.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
     if (!sp || ref.segment < 0 || ref.segment >= (sp.closed ? sp.anchors.length : sp.anchors.length - 1) || sp.anchors.length < 2) return { ok: false, message: "There is no such segment." };
     if (node.locked) return { ok: false, message: "The path is locked." };
     this.change("Bend Segment", () => {
@@ -9555,7 +11007,7 @@ var VectorEditorController = (_class5 = class {
   /** Adds an anchor on the nearest segment of `nodeId` to document point `point` (shape unchanged). */
   insertAnchorAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _280 => _280.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _308 => _308.type]) !== "path") return null;
     const hit = nearestSegment(node, this.toLocal(nodeId, point));
     if (!hit) return null;
     const { subpath, index } = insertAnchor(node.subpaths[hit.subpath], hit.segment, hit.t);
@@ -9599,7 +11051,7 @@ var VectorEditorController = (_class5 = class {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n = this.getNode(nodeId);
-      return _optionalChain([n, 'optionalAccess', _281 => _281.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n, 'optionalAccess', _309 => _309.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
     })() : this.anchors.map((r) => ({ nodeId: r.nodeId, subpath: r.subpath }));
     if (!targets.length) return { ok: false, message: "Select a path or points." };
     this.change(closed ? "Close Path" : "Open Path", () => {
@@ -9620,7 +11072,7 @@ var VectorEditorController = (_class5 = class {
       this.setDoc(
         mapTree(
           this.doc.nodes,
-          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _282 => _282.strokeWidthProfile, 'optionalAccess', _283 => _283.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
+          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _310 => _310.strokeWidthProfile, 'optionalAccess', _311 => _311.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
         )
       );
       this.anchors = [];
@@ -9758,7 +11210,7 @@ var VectorEditorController = (_class5 = class {
    */
   cutPathAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _284 => _284.type]) !== "path" || node.locked) return null;
+    if (_optionalChain([node, 'optionalAccess', _312 => _312.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
     const hit = nearestSegment(node, local);
     if (!hit) return null;
@@ -9808,8 +11260,8 @@ var VectorEditorController = (_class5 = class {
       if (n.visible === false || n.locked || parent && blocked.has(parent.id)) blocked.add(n.id);
     });
     const visible = (p) => !blocked.has(p.id);
-    if (_optionalChain([ids, 'optionalAccess', _285 => _285.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
-    const box = polylineBounds(points.map(toPoint2), pad);
+    if (_optionalChain([ids, 'optionalAccess', _313 => _313.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
+    const box = polylineBounds(points.map(toPoint3), pad);
     if (!box) return [];
     const out = [];
     walkVectorNodes(this.doc.nodes, (n) => {
@@ -9822,7 +11274,7 @@ var VectorEditorController = (_class5 = class {
   /** A stroke's points in node `id`'s own space. */
   localPoints(id, points) {
     const inv = invertMatrix(this.worldOf(id));
-    return points.map((p) => toPoint2(applyMatrix(inv, p)));
+    return points.map((p) => toPoint3(applyMatrix(inv, p)));
   }
   /**
    * Knife: cuts closed paths along the polyline `points` (document space) wherever it crosses
@@ -9831,7 +11283,7 @@ var VectorEditorController = (_class5 = class {
    * when nothing was cut).
    */
   knife(points, options = {}) {
-    const pts = simplifyPolyline(points.map(toPoint2), 0.25 / this.viewport.zoom).map(([x, y]) => ({ x, y }));
+    const pts = simplifyPolyline(points.map(toPoint3), 0.25 / this.viewport.zoom).map(([x, y]) => ({ x, y }));
     if (pts.length < 2) return [];
     const plan = [];
     for (const node of this.strokeTargets(pts, options.ids, 0)) {
@@ -9860,7 +11312,7 @@ var VectorEditorController = (_class5 = class {
   erase(points, options = {}) {
     const width = _nullishCoalesce(options.size, () => ( this.editing.eraserSize));
     if (!(width > 0) || !points.length) return [];
-    const pts = simplifyPolyline(points.map(toPoint2), Math.min(width * 0.05, 0.25 / this.viewport.zoom));
+    const pts = simplifyPolyline(points.map(toPoint3), Math.min(width * 0.05, 0.25 / this.viewport.zoom));
     const region = eraserRegion(pts, width);
     if (!region.length) return [];
     const plan = [];
@@ -9894,7 +11346,7 @@ var VectorEditorController = (_class5 = class {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _286 => _286.subpaths, 'access', _287 => _287[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _314 => _314.subpaths, 'access', _315 => _315[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -9938,7 +11390,7 @@ var VectorEditorController = (_class5 = class {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _288 => _288.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
+          if (_optionalChain([data, 'optionalAccess', _316 => _316.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
         } catch (e7) {
           nodes = null;
         }
@@ -9950,7 +11402,7 @@ var VectorEditorController = (_class5 = class {
         }
       }
     } else nodes = this.clipboard;
-    if (!_optionalChain([nodes, 'optionalAccess', _289 => _289.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _317 => _317.length])) return [];
     const offset = _nullishCoalesce(options.offset, () => ( (text && !text.trim().startsWith("{") ? { x: 0, y: 0 } : { x: 10, y: 10 })));
     const copies = nodes.map((n) => transformVectorNode(this.freshIds(n), translateMatrix(offset.x, offset.y)));
     this.change("Paste", () => {
@@ -10001,7 +11453,7 @@ var VectorEditorController = (_class5 = class {
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
       const a = getAnchorWorld(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _290 => _290[ref.handle]]);
+      const h = _optionalChain([a, 'optionalAccess', _318 => _318[ref.handle]]);
       if (!h) continue;
       const s = this.documentToScreen(h);
       if (Math.hypot(s.x - screen.x, s.y - screen.y) <= this.hitRadius) return ref;
@@ -10128,6 +11580,12 @@ var VectorEditorController = (_class5 = class {
         const path = this.hitPath(p);
         return path ? { nodeId: path.id } : null;
       }
+      case "envelope": {
+        const hit = this.hitEnvelope(screen, p);
+        if (hit) return { nodeId: hit.target.node.id, envelope: { nodeId: hit.target.node.id, index: hit.index } };
+        const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
+        return node ? { nodeId: node.id } : null;
+      }
       default:
         return null;
     }
@@ -10140,7 +11598,7 @@ var VectorEditorController = (_class5 = class {
     const shown = this.hitWidthHandleIn(screen, this.widthView());
     if (shown) return shown;
     const spot = this.strokeSpotAt(this.screenToDocument(screen));
-    return spot && spot.nodeId !== _optionalChain([this, 'access', _291 => _291.hover, 'optionalAccess', _292 => _292.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
+    return spot && spot.nodeId !== _optionalChain([this, 'access', _319 => _319.hover, 'optionalAccess', _320 => _320.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
   }
   hitWidthHandleIn(screen, view) {
     let best = null;
@@ -10195,9 +11653,9 @@ var VectorEditorController = (_class5 = class {
   downWidth(screen, p, input) {
     const hit = this.hitWidthHandle(screen);
     const spot = hit ? null : this.strokeSpotAt(p);
-    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _293 => _293.ref, 'access', _294 => _294.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _295 => _295.nodeId])));
+    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _321 => _321.ref, 'access', _322 => _322.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _323 => _323.nodeId])));
     const node = nodeId ? this.getNode(nodeId) : void 0;
-    const g = _optionalChain([node, 'optionalAccess', _296 => _296.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
+    const g = _optionalChain([node, 'optionalAccess', _324 => _324.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
     if (this.widthEdit) this.widthEdit = null;
     if (!node || node.type !== "path" || !g) {
       if (!input.shift) this.widthPoints = [];
@@ -10217,19 +11675,19 @@ var VectorEditorController = (_class5 = class {
     if (hit) {
       profile = sanitizeWidthProfile(node.strokeWidthProfile);
       ref = { nodeId: node.id, index: hit.ref.index, subpath: hit.ref.subpath };
-      t = _nullishCoalesce(_optionalChain([profile, 'access', _297 => _297[ref.index], 'optionalAccess', _298 => _298.t]), () => ( 0));
+      t = _nullishCoalesce(_optionalChain([profile, 'access', _325 => _325[ref.index], 'optionalAccess', _326 => _326.t]), () => ( 0));
       subpath = hit.ref.subpath;
       if (hit.ref.part === "center") mode = input.alt && profile.length < VECTOR_WIDTH_PROFILE_MAX_POINTS ? "copy" : "move";
       else if (input.alt) side = hit.ref.part;
-      const same = this.widthPoints.length > 0 && this.widthPoints[0].nodeId === node.id;
-      const selected = same && this.widthPoints.some((r) => r.index === ref.index);
+      const same2 = this.widthPoints.length > 0 && this.widthPoints[0].nodeId === node.id;
+      const selected = same2 && this.widthPoints.some((r) => r.index === ref.index);
       if (input.shift && mode !== "copy") {
         if (selected) {
           this.widthPoints = this.widthPoints.filter((r) => r.index !== ref.index);
           this.notify();
           return;
         }
-        this.widthPoints = same ? [...this.widthPoints, ref] : [ref];
+        this.widthPoints = same2 ? [...this.widthPoints, ref] : [ref];
         shift = true;
       } else if (mode === "copy" || !selected) this.widthPoints = [ref];
       if (mode !== "copy") group = this.widthPoints.filter((r) => r.index !== ref.index).map((r) => r.index);
@@ -10352,6 +11810,8 @@ var VectorEditorController = (_class5 = class {
         return this.downBlend(screen, p);
       case "gradient":
         return this.downGradient(screen, p, input);
+      case "envelope":
+        return this.downEnvelope(screen, p, input);
       case "scissors": {
         const seg = this.nearestOutline(p);
         if (seg) this.cutPathAt(seg.nodeId, seg.point);
@@ -10374,7 +11834,7 @@ var VectorEditorController = (_class5 = class {
     let anchor = null;
     if (node.type === "path" && node.subpaths[0]) {
       const refs = node.subpaths[0].anchors.map((_, index) => ({ nodeId: node.id, subpath: 0, index }));
-      anchor = _nullishCoalesce(_optionalChain([this, 'access', _299 => _299.hitAnchor, 'call', _300 => _300(screen, refs), 'optionalAccess', _301 => _301.index]), () => ( null));
+      anchor = _nullishCoalesce(_optionalChain([this, 'access', _327 => _327.hitAnchor, 'call', _328 => _328(screen, refs), 'optionalAccess', _329 => _329.index]), () => ( null));
     }
     return { nodeId: node.id, anchor };
   }
@@ -10527,7 +11987,7 @@ var VectorEditorController = (_class5 = class {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _302 => _302.getNode, 'call', _303 => _303(this.pen.nodeId), 'optionalAccess', _304 => _304.subpaths, 'access', _305 => _305[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _330 => _330.getNode, 'call', _331 => _331(this.pen.nodeId), 'optionalAccess', _332 => _332.subpaths, 'access', _333 => _333[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -10645,6 +12105,8 @@ var VectorEditorController = (_class5 = class {
         return;
       case "gradient":
         return this.moveGradient(drag, screen, p, input);
+      case "envelope":
+        return this.moveEnvelope(drag, p);
       case "move": {
         let dx = p.x - drag.start.x;
         let dy = p.y - drag.start.y;
@@ -10665,6 +12127,7 @@ var VectorEditorController = (_class5 = class {
         return;
       }
       case "scale": {
+        if (this.freeDistort && drag.handle !== "rotate") return this.moveDistort(drag, p, input);
         const angle = drag.frame.angle;
         const q = angle ? applyMatrix(rotateMatrix(-angle), p) : p;
         let { sx, sy, origin } = scaleFor(drag.handle, drag.frame, q, input);
@@ -10791,7 +12254,7 @@ var VectorEditorController = (_class5 = class {
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _306 => _306.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _334 => _334.type]) !== "path") return;
         const leave = { at: drag.start, constrain: input.shift ? drag.tool === "line" ? "angle" : "square" : null, curves: false };
         let end = this.snapDrawn(p, leave, input, () => drag.targets ??= this.drawingTargets(null));
         if (!this.snappedToObject && drag.tool !== "line" && !input.shift && !input.mod && this.snap.objects && drag.targets) end = this.matchShapeSize(drag.targets, drag.start, end, input.alt);
@@ -10865,14 +12328,14 @@ var VectorEditorController = (_class5 = class {
         for (const q of drag.lazy.push([p.x, p.y])) {
           if (Math.hypot(q[0] - last[0], q[1] - last[1]) * this.viewport.zoom < 1.5) continue;
           drag.points.push(q);
-          _optionalChain([drag, 'access', _307 => _307.pressures, 'optionalAccess', _308 => _308.push, 'call', _309 => _309(drag.pressure)]);
+          _optionalChain([drag, 'access', _335 => _335.pressures, 'optionalAccess', _336 => _336.push, 'call', _337 => _337(drag.pressure)]);
           moved = true;
         }
         const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _310 => _310.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _338 => _338.type]) !== "path") return;
         if (!moved) {
-          if (string && _optionalChain([this, 'access', _311 => _311.interaction, 'optionalAccess', _312 => _312.type]) === "draw") {
+          if (string && _optionalChain([this, 'access', _339 => _339.interaction, 'optionalAccess', _340 => _340.type]) === "draw") {
             this.interaction = { ...this.interaction, string: [{ x: string[0][0], y: string[0][1] }, { x: string[1][0], y: string[1][1] }] };
             this.notify();
           }
@@ -10908,8 +12371,8 @@ var VectorEditorController = (_class5 = class {
     }
     this.setGuides(res);
     return {
-      dx: _optionalChain([res, 'optionalAccess', _313 => _313.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
-      dy: _optionalChain([res, 'optionalAccess', _314 => _314.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+      dx: _optionalChain([res, 'optionalAccess', _341 => _341.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: _optionalChain([res, 'optionalAccess', _342 => _342.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
     };
   }
   /** The anchor a point drag snaps by, where it started: the grabbed one, else the moving one nearest the press. */
@@ -10965,7 +12428,13 @@ var VectorEditorController = (_class5 = class {
         }
         return this.commit(drag.duplicated ? "Duplicate" : "Move", drag.before);
       case "scale":
-        return this.commit("Scale", drag.before);
+        return this.commit(_nullishCoalesce(drag.op, () => ( "Scale")), drag.before);
+      case "envelope":
+        if (!drag.moved) {
+          this.notify();
+          return;
+        }
+        return this.commit("Edit Envelope", drag.before);
       case "rotate":
         return this.commit("Rotate", drag.before);
       case "anchors":
@@ -10988,7 +12457,7 @@ var VectorEditorController = (_class5 = class {
         if (drag.moved) return this.commit("Corner Radius", drag.before);
         if (drag.alt) {
           const kind = nextVectorCornerKind(drag.widget.kind);
-          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _315 => _315.corner, 'optionalAccess', _316 => _316.radius]), () => ( 0)), kind));
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _343 => _343.corner, 'optionalAccess', _344 => _344.radius]), () => ( 0)), kind));
           return this.commit("Corner Kind", drag.before);
         }
         const ref = drag.widget.ref;
@@ -11003,7 +12472,7 @@ var VectorEditorController = (_class5 = class {
           const several = drag.group.length > 0;
           if (drag.mode === "copy") this.widthPoints = [drag.ref];
           else if (drag.mode === "move" && several) {
-            this.widthPoints = [drag.source, ...drag.group].map((i) => ({ ...drag.ref, index: _nullishCoalesce(_optionalChain([drag, 'access', _317 => _317.renumber, 'optionalAccess', _318 => _318.get, 'call', _319 => _319(i)]), () => ( i)) }));
+            this.widthPoints = [drag.source, ...drag.group].map((i) => ({ ...drag.ref, index: _nullishCoalesce(_optionalChain([drag, 'access', _345 => _345.renumber, 'optionalAccess', _346 => _346.get, 'call', _347 => _347(i)]), () => ( i)) }));
           } else if (!several) this.widthPoints = [drag.ref];
           const label = drag.mode === "copy" ? "Copy Width Point" : drag.mode === "move" ? several ? "Move Width Points" : "Move Width Point" : several ? "Width Points" : "Width Point";
           return this.commit(label, drag.before);
@@ -11047,14 +12516,14 @@ var VectorEditorController = (_class5 = class {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _320 => _320.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _348 => _348.type]) !== "path" || drag.points.length < 2) {
           this.doc = drag.before.doc;
           this.notify(true);
           return;
         }
         for (const q of drag.lazy.finish()) {
           drag.points.push(q);
-          _optionalChain([drag, 'access', _321 => _321.pressures, 'optionalAccess', _322 => _322.push, 'call', _323 => _323(drag.pressure)]);
+          _optionalChain([drag, 'access', _349 => _349.pressures, 'optionalAccess', _350 => _350.push, 'call', _351 => _351(drag.pressure)]);
         }
         const shape = this.editing.recognizeShapes ? recognizeInkShape(drag.points, { minSize: 6 / this.viewport.zoom }) : null;
         if (shape) {
@@ -11129,7 +12598,7 @@ var VectorEditorController = (_class5 = class {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _324 => _324.hover, 'optionalAccess', _325 => _325.segment, 'optionalAccess', _326 => _326.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _352 => _352.hover, 'optionalAccess', _353 => _353.segment, 'optionalAccess', _354 => _354.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
         const seg = node ? nearestSegment(node, this.toLocal(id, p)) : null;
@@ -11226,7 +12695,7 @@ var VectorEditorController = (_class5 = class {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _327 => _327.getNode, 'call', _328 => _328(this.selection[0]), 'optionalAccess', _329 => _329.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _355 => _355.getNode, 'call', _356 => _356(this.selection[0]), 'optionalAccess', _357 => _357.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -11370,7 +12839,7 @@ function renderNode(stored, defs, idPrefix) {
     strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)),
     ...node.strokeLinecap ? { strokeLinecap: node.strokeLinecap } : {},
     ...node.strokeLinejoin ? { strokeLinejoin: node.strokeLinejoin } : {},
-    ..._optionalChain([node, 'access', _330 => _330.strokeDasharray, 'optionalAccess', _331 => _331.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
+    ..._optionalChain([node, 'access', _358 => _358.strokeDasharray, 'optionalAccess', _359 => _359.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1))
   };
@@ -11424,11 +12893,11 @@ function getVectorOverlayRenderData(state) {
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _332 => _332.hover, 'optionalAccess', _333 => _333.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _360 => _360.hover, 'optionalAccess', _361 => _361.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _334 => _334.interaction, 'optionalAccess', _335 => _335.type]) !== "marquee") {
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _362 => _362.interaction, 'optionalAccess', _363 => _363.type]) !== "marquee" && _optionalChain([state, 'access', _364 => _364.interaction, 'optionalAccess', _365 => _365.type]) !== "distort") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
-    selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
+    selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles, freeDistort: state.freeDistort };
   }
   const selected = (r) => state.selectedAnchors.some((a) => a.nodeId === r.nodeId && a.subpath === r.subpath && a.index === r.index);
   const sameAnchor = (a, b) => !!a && a.nodeId === b.nodeId && a.subpath === b.subpath && a.index === b.index;
@@ -11436,9 +12905,9 @@ function getVectorOverlayRenderData(state) {
     const a = getAnchorWorld(doc, ref);
     const s = toScreen(state, a);
     const closes = !!state.pen && state.pen.nodeId === ref.nodeId && state.pen.subpath === ref.subpath && ref.index === 0;
-    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( inferAnchorType(a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _336 => _336.hover, 'optionalAccess', _337 => _337.anchor]), ref), closes };
+    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( inferAnchorType(a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _366 => _366.hover, 'optionalAccess', _367 => _367.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _338 => _338.hover, 'optionalAccess', _339 => _339.anchor])) {
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _368 => _368.hover, 'optionalAccess', _369 => _369.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
@@ -11447,15 +12916,15 @@ function getVectorOverlayRenderData(state) {
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
     const a = getAnchorWorld(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _340 => _340[ref.handle]]);
+    const h = _optionalChain([a, 'optionalAccess', _370 => _370[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _341 => _341.hover, 'optionalAccess', _342 => _342.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _371 => _371.hover, 'optionalAccess', _372 => _372.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
     return [{ ref, x: s.x, y: s.y, anchorX: sa.x, anchorY: sa.y, hovered }];
   });
   let marquee = null;
-  if (_optionalChain([state, 'access', _343 => _343.interaction, 'optionalAccess', _344 => _344.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _373 => _373.interaction, 'optionalAccess', _374 => _374.type]) === "marquee") {
     const b = state.interaction.bounds;
     const tl = toScreen(state, b);
     marquee = { x: tl.x, y: tl.y, width: b.width * z, height: b.height * z };
@@ -11463,7 +12932,7 @@ function getVectorOverlayRenderData(state) {
   let penPreview = null;
   if (state.tool === "pen" && state.pen && state.pointer && !state.interaction) {
     const node = findVectorNode(doc.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _345 => _345.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _375 => _375.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
     const last = sp ? getAnchorWorld(doc, { nodeId: state.pen.nodeId, subpath: state.pen.subpath, index: sp.anchors.length - 1 }) : void 0;
     if (last) {
       const a = toScreen(state, last);
@@ -11476,9 +12945,9 @@ function getVectorOverlayRenderData(state) {
   const artboard = { x: origin.x, y: origin.y, width: doc.width * z, height: doc.height * z };
   let status = null;
   const it = state.interaction;
-  if (_optionalChain([it, 'optionalAccess', _346 => _346.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _347 => _347.type]) === "move" || _optionalChain([it, 'optionalAccess', _348 => _348.type]) === "anchors") status = `\u0394 ${fmt4(it.dx)}, ${fmt4(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _349 => _349.type]) === "scale" || _optionalChain([it, 'optionalAccess', _350 => _350.type]) === "draw") {
+  if (_optionalChain([it, 'optionalAccess', _376 => _376.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _377 => _377.type]) === "move" || _optionalChain([it, 'optionalAccess', _378 => _378.type]) === "anchors") status = `\u0394 ${fmt4(it.dx)}, ${fmt4(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _379 => _379.type]) === "scale" || _optionalChain([it, 'optionalAccess', _380 => _380.type]) === "draw") {
     const b = it.type === "draw" ? findVectorNode(doc.nodes, it.nodeId) ? vectorNodeBounds(findVectorNode(doc.nodes, it.nodeId)) : null : state.selectionFrame;
     if (b) status = `W ${fmt4(b.width)} \xD7 H ${fmt4(b.height)}`;
   }
@@ -11495,24 +12964,24 @@ function getVectorOverlayRenderData(state) {
     }
   }
   let toolStroke = null;
-  if (_optionalChain([it, 'optionalAccess', _351 => _351.type]) === "stroke") {
+  if (_optionalChain([it, 'optionalAccess', _381 => _381.type]) === "stroke") {
     const pts = it.points.map((q) => toScreen(state, q));
     const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt4(q.x)} ${fmt4(q.y)}`).join("") + (pts.length === 1 ? `L${fmt4(pts[0].x)} ${fmt4(pts[0].y)}` : "");
     toolStroke = { tool: it.tool, d, width: fmt4(it.width * z) };
   }
   let pencilString = null;
-  if (_optionalChain([it, 'optionalAccess', _352 => _352.type]) === "draw" && it.string) {
+  if (_optionalChain([it, 'optionalAccess', _382 => _382.type]) === "draw" && it.string) {
     const a = toScreen(state, it.string[0]);
     const b = toScreen(state, it.string[1]);
     pencilString = { x1: fmt4(a.x), y1: fmt4(a.y), x2: fmt4(b.x), y2: fmt4(b.y) };
   }
-  const dragged = _optionalChain([it, 'optionalAccess', _353 => _353.type]) === "corner" ? it.ref : null;
+  const dragged = _optionalChain([it, 'optionalAccess', _383 => _383.type]) === "corner" ? it.ref : null;
   const cornerWidgets = getVectorCornerWidgets(state).map((w) => {
     const s = toScreen(state, w);
-    return { ref: w.ref, x: fmt4(s.x), y: fmt4(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _354 => _354.hover, 'optionalAccess', _355 => _355.corner]), w.ref), active: !!dragged };
+    return { ref: w.ref, x: fmt4(s.x), y: fmt4(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _384 => _384.hover, 'optionalAccess', _385 => _385.corner]), w.ref), active: !!dragged };
   });
-  if (_optionalChain([it, 'optionalAccess', _356 => _356.type]) === "corner") status = `R ${fmt4(it.radius)}`;
-  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _357 => _357.hover, 'optionalAccess', _358 => _358.segment]) && !it ? (({ x, y }) => ({ x: fmt4(x), y: fmt4(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  if (_optionalChain([it, 'optionalAccess', _386 => _386.type]) === "corner") status = `R ${fmt4(it.radius)}`;
+  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _387 => _387.hover, 'optionalAccess', _388 => _388.segment]) && !it ? (({ x, y }) => ({ x: fmt4(x), y: fmt4(y) }))(toScreen(state, state.hover.segment.point)) : null;
   const sc = (p) => {
     const q = toScreen(state, p);
     return { x: fmt4(q.x), y: fmt4(q.y) };
@@ -11520,13 +12989,13 @@ function getVectorOverlayRenderData(state) {
   const sameWidth = (a, b) => !!a && a.nodeId === b.nodeId && a.index === b.index;
   const widthPoints = getVectorWidthHandles(state).map((h) => {
     const c = sc(h);
-    const hw = _optionalChain([state, 'access', _359 => _359.hover, 'optionalAccess', _360 => _360.widthPoint]);
+    const hw = _optionalChain([state, 'access', _389 => _389.hover, 'optionalAccess', _390 => _390.widthPoint]);
     const hovered = hw && sameWidth(hw, h.ref) && hw.subpath === h.ref.subpath ? hw.part : null;
-    return { ref: h.ref, x: c.x, y: c.y, left: sc(h.left), right: sc(h.right), selected: h.selected, hovered, active: _optionalChain([it, 'optionalAccess', _361 => _361.type]) === "width" && sameWidth(it.ref, h.ref) };
+    return { ref: h.ref, x: c.x, y: c.y, left: sc(h.left), right: sc(h.right), selected: h.selected, hovered, active: _optionalChain([it, 'optionalAccess', _391 => _391.type]) === "width" && sameWidth(it.ref, h.ref) };
   });
-  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _362 => _362.hover, 'optionalAccess', _363 => _363.strokeSpot]) : null;
+  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _392 => _392.hover, 'optionalAccess', _393 => _393.strokeSpot]) : null;
   const widthSpot = spot ? { ...sc(spot.point), left: sc(spot.left), right: sc(spot.right) } : null;
-  if (_optionalChain([it, 'optionalAccess', _364 => _364.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt4(it.width)}`;
+  if (_optionalChain([it, 'optionalAccess', _394 => _394.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt4(it.width)}`;
   let builder = null;
   if (state.builder) {
     const v2 = state.viewport;
@@ -11542,7 +13011,7 @@ function getVectorOverlayRenderData(state) {
       lines: state.builder.lines.map((l) => svg(_chunkVNYRI265cjs.transformBezierPath.call(void 0, l, view))),
       trail
     };
-    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _365 => _365.type]) === "builder") {
+    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _395 => _395.type]) === "builder") {
       const n = state.builder.faces.length;
       status = state.builder.mode === "erase" ? `Delete ${n} ${n === 1 ? "face" : "faces"}` : `Merge ${n} ${n === 1 ? "face" : "faces"}`;
     }
@@ -11553,18 +13022,72 @@ function getVectorOverlayRenderData(state) {
   if (state.tool === "gradient") {
     gradient = gradientOverlay(state);
     if (!gradient && !it) status = "Drag across a shape to set a gradient";
-    else if (_optionalChain([it, 'optionalAccess', _366 => _366.type]) === "gradient" && it.removing) status = "Release to delete the stop";
+    else if (_optionalChain([it, 'optionalAccess', _396 => _396.type]) === "gradient" && it.removing) status = "Release to delete the stop";
   }
-  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder, blend, gradient };
+  let distort = null;
+  if (_optionalChain([it, 'optionalAccess', _397 => _397.type]) === "distort") {
+    const corners2 = it.corners.map(sc);
+    distort = { mode: it.mode, corners: corners2, d: corners2.map((c, i) => `${i ? "L" : "M"}${c.x} ${c.y}`).join("") + "Z" };
+    status = it.mode === "skew" ? "Skew" : it.mode === "perspective" ? "Perspective" : "Distort";
+  }
+  const envelope = state.tool === "envelope" ? envelopeOverlay(state) : null;
+  if (state.tool === "envelope" && !envelope && !it) status = "Select an object with an envelope to edit its mesh";
+  return { outlines, selectionBox, distort, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder, blend, gradient, envelope };
+}
+function envelopeOverlay(state) {
+  const target = getVectorEnvelopeTarget(state.document, state.selection);
+  if (!target) return null;
+  const v2 = state.viewport;
+  const m = multiplyMatrices(target.world, [v2.zoom, 0, 0, v2.zoom, v2.x, v2.y]);
+  const sc = (p) => ({ x: fmt4(m[0] * p.x + m[2] * p.y + m[4]), y: fmt4(m[1] * p.x + m[3] * p.y + m[5]) });
+  const { mesh } = target.frame;
+  const grid = vectorMeshGridCurves(mesh).map((c) => {
+    const [a, b, cc, d] = c.map(sc);
+    return `M${a.x} ${a.y}C${b.x} ${b.y} ${cc.x} ${cc.y} ${d.x} ${d.y}`;
+  }).join("");
+  const hover = _optionalChain([state, 'access', _398 => _398.hover, 'optionalAccess', _399 => _399.envelope, 'optionalAccess', _400 => _400.nodeId]) === target.node.id ? state.hover.envelope.index : void 0;
+  const it = state.interaction;
+  const active = _optionalChain([it, 'optionalAccess', _401 => _401.type]) === "envelope" && it.nodeId === target.node.id ? it.index : void 0;
+  const pts = vectorMeshEditPoints(mesh);
+  return {
+    nodeId: target.node.id,
+    grid,
+    anchors: pts.anchors.map((index) => ({ index, ...sc(mesh.points[index]), hovered: !it && hover === index, active: active === index })),
+    handles: pts.handles.map((h) => {
+      const a = sc(mesh.points[h.anchor]);
+      return { index: h.index, ...sc(mesh.points[h.index]), anchorX: a.x, anchorY: a.y, hovered: !it && hover === h.index, active: active === h.index };
+    })
+  };
+}
+var VECTOR_ENVELOPE_STYLE_OPTIONS = [
+  ...VECTOR_WARP_STYLES.map((value) => ({ value, label: VECTOR_WARP_STYLE_LABELS[value] })),
+  { value: "mesh", label: "Mesh" }
+];
+function getVectorEnvelopePanel(state) {
+  const nodes = state.selection.map((id) => findVectorNode(state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
+  if (!nodes.length) return null;
+  const one = nodes.length === 1 ? nodes[0] : null;
+  const first = _optionalChain([one, 'optionalAccess', _402 => _402.effects, 'optionalAccess', _403 => _403.find, 'call', _404 => _404((e) => e.type === "envelope")]);
+  const order = /* @__PURE__ */ new Map();
+  walkVectorNodes(state.document.nodes, (n) => order.set(n.id, order.size));
+  const top = nodes.length > 1 ? nodes.slice().sort((a, b) => (_nullishCoalesce(order.get(a.id), () => ( 0))) - (_nullishCoalesce(order.get(b.id), () => ( 0))))[nodes.length - 1] : null;
+  return {
+    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _405 => _405.id]), () => ( null)),
+    count: nodes.length,
+    envelope: _optionalChain([first, 'optionalAccess', _406 => _406.type]) === "envelope" ? { effectId: first.id, enabled: first.enabled !== false, params: first.params } : null,
+    canMake: nodes.some((n) => !n.locked),
+    canMakeWithTopObject: _optionalChain([top, 'optionalAccess', _407 => _407.type]) === "path" && top.subpaths.some((sp) => sp.closed && sp.anchors.length > 1),
+    canRelease: nodes.some((n) => !n.locked && !!_optionalChain([n, 'access', _408 => _408.effects, 'optionalAccess', _409 => _409.some, 'call', _410 => _410((e) => e.type === "envelope")]))
+  };
 }
 function gradientOverlay(state) {
   const a = getVectorGradientAnnotator(state.document, state.selection, state.viewport, state.gradientEdit.target);
   if (!a) return null;
-  const hover = state.interaction ? null : _optionalChain([state, 'access', _367 => _367.hover, 'optionalAccess', _368 => _368.gradient]);
-  const handleHovered = (h) => _optionalChain([hover, 'optionalAccess', _369 => _369.kind]) === "handle" && hover.handle === h;
+  const hover = state.interaction ? null : _optionalChain([state, 'access', _411 => _411.hover, 'optionalAccess', _412 => _412.gradient]);
+  const handleHovered = (h) => _optionalChain([hover, 'optionalAccess', _413 => _413.kind]) === "handle" && hover.handle === h;
   const pt2 = (p) => ({ x: fmt4(p.x), y: fmt4(p.y) });
   const centred = isCentredVectorGradient(a.gradient.type);
-  const removing = _optionalChain([state, 'access', _370 => _370.interaction, 'optionalAccess', _371 => _371.type]) === "gradient" && !!state.interaction.removing;
+  const removing = _optionalChain([state, 'access', _414 => _414.interaction, 'optionalAccess', _415 => _415.type]) === "gradient" && !!state.interaction.removing;
   return {
     nodeId: a.nodeId,
     type: a.gradient.type,
@@ -11580,9 +13103,9 @@ function gradientOverlay(state) {
       color: s.color,
       opacity: _nullishCoalesce(s.opacity, () => ( 1)),
       selected: state.gradientEdit.stop === s.index,
-      hovered: _optionalChain([hover, 'optionalAccess', _372 => _372.kind]) === "stop" && hover.index === s.index
+      hovered: _optionalChain([hover, 'optionalAccess', _416 => _416.kind]) === "stop" && hover.index === s.index
     })),
-    midpoints: a.midpoints.map((m) => ({ index: m.index, ...pt2(m), hovered: _optionalChain([hover, 'optionalAccess', _373 => _373.kind]) === "midpoint" && hover.index === m.index })),
+    midpoints: a.midpoints.map((m) => ({ index: m.index, ...pt2(m), hovered: _optionalChain([hover, 'optionalAccess', _417 => _417.kind]) === "midpoint" && hover.index === m.index })),
     extent: a.extent,
     removing
   };
@@ -11591,7 +13114,7 @@ function selectedBlends(state) {
   const out = /* @__PURE__ */ new Map();
   for (const id of state.selection) {
     const node = findVectorNode(state.document.nodes, id);
-    const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _374 => _374(state.document.nodes, id), 'optionalAccess', _375 => _375.parent]);
+    const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _418 => _418(state.document.nodes, id), 'optionalAccess', _419 => _419.parent]);
     if (isVectorBlendGroup(group)) out.set(group.id, group);
   }
   return [...out.values()];
@@ -11623,11 +13146,11 @@ function blendOverlay(state) {
       const a = state.blendStart.anchor === null ? void 0 : getAnchorWorld(doc, { nodeId: from.id, subpath: 0, index: state.blendStart.anchor });
       start = { d: screenOutline(state, from, /* @__PURE__ */ new Set()), anchor: a ? sc(a, view) : null };
     }
-    const hovered = _optionalChain([state, 'access', _376 => _376.hover, 'optionalAccess', _377 => _377.nodeId]) ? findVectorNode(doc.nodes, state.hover.nodeId) : void 0;
-    if (_optionalChain([hovered, 'optionalAccess', _378 => _378.type]) === "path" && hovered.subpaths[0]) {
+    const hovered = _optionalChain([state, 'access', _420 => _420.hover, 'optionalAccess', _421 => _421.nodeId]) ? findVectorNode(doc.nodes, state.hover.nodeId) : void 0;
+    if (_optionalChain([hovered, 'optionalAccess', _422 => _422.type]) === "path" && hovered.subpaths[0]) {
       hovered.subpaths[0].anchors.forEach((_, index) => {
         const a = getAnchorWorld(doc, { nodeId: hovered.id, subpath: 0, index });
-        if (a) anchors.push({ ...sc(a, view), hovered: _optionalChain([state, 'access', _379 => _379.hover, 'optionalAccess', _380 => _380.anchor, 'optionalAccess', _381 => _381.index]) === index });
+        if (a) anchors.push({ ...sc(a, view), hovered: _optionalChain([state, 'access', _423 => _423.hover, 'optionalAccess', _424 => _424.anchor, 'optionalAccess', _425 => _425.index]) === index });
       });
     }
   }
@@ -11638,17 +13161,17 @@ function getVectorBlendControls(state) {
   const doc = state.document;
   const roots = state.selection.filter((id) => {
     const node = findVectorNode(doc.nodes, id);
-    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([locateVectorNode, 'call', _382 => _382(doc.nodes, id), 'optionalAccess', _383 => _383.parent, 'optionalAccess', _384 => _384.id]), () => ( "")));
+    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([locateVectorNode, 'call', _426 => _426(doc.nodes, id), 'optionalAccess', _427 => _427.parent, 'optionalAccess', _428 => _428.id]), () => ( "")));
   });
-  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _385 => _385(doc.nodes, id), 'optionalAccess', _386 => _386.parent, 'optionalAccess', _387 => _387.id]), () => ( null))));
-  const paths = roots.filter((id) => _optionalChain([findVectorNode, 'call', _388 => _388(doc.nodes, id), 'optionalAccess', _389 => _389.type]) === "path" && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _390 => _390(doc.nodes, id), 'optionalAccess', _391 => _391.parent])));
+  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _429 => _429(doc.nodes, id), 'optionalAccess', _430 => _430.parent, 'optionalAccess', _431 => _431.id]), () => ( null))));
+  const paths = roots.filter((id) => _optionalChain([findVectorNode, 'call', _432 => _432(doc.nodes, id), 'optionalAccess', _433 => _433.type]) === "path" && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _434 => _434(doc.nodes, id), 'optionalAccess', _435 => _435.parent])));
   const first = blends[0];
   return {
     ids: blends.map((g) => g.id),
     options: resolveVectorBlendOptions(first ? first.blend : state.blendDefaults),
     canBlend: roots.length >= 2 && parents.size === 1,
     canReplaceSpine: blends.length === 1 && paths.length === 1,
-    hasSpine: !!_optionalChain([first, 'optionalAccess', _392 => _392.blend, 'optionalAccess', _393 => _393.spine])
+    hasSpine: !!_optionalChain([first, 'optionalAccess', _436 => _436.blend, 'optionalAccess', _437 => _437.spine])
   };
 }
 function applyVectorBlendOptions(controller, patch) {
@@ -11701,7 +13224,7 @@ function isVectorTextTarget(target) {
   if (!el || typeof el !== "object") return false;
   const tag = (_nullishCoalesce(el.tagName, () => ( ""))).toUpperCase();
   if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
-  return !!el.isContentEditable || _optionalChain([el, 'access', _394 => _394.getAttribute, 'optionalCall', _395 => _395("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _438 => _438.getAttribute, 'optionalCall', _439 => _439("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -11709,23 +13232,23 @@ function getVectorSelectionStyle(state) {
     const node = findVectorNode(state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
-  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _396 => _396.selectedAnchors, 'optionalAccess', _397 => _397.length]);
+  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _440 => _440.selectedAnchors, 'optionalAccess', _441 => _441.length]);
   if (anchorMode) {
     for (const r of state.selectedAnchors) {
       if (paths.some((p) => p.id === r.nodeId)) continue;
       const node = findVectorNode(state.document.nodes, r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _398 => _398.type]) === "path") paths.push(node);
+      if (_optionalChain([node, 'optionalAccess', _442 => _442.type]) === "path") paths.push(node);
     }
   }
   if (!paths.length) return null;
   const first = paths[0];
-  const same = (get) => paths.every((p) => JSON.stringify(_nullishCoalesce(get(p), () => ( null))) === JSON.stringify(_nullishCoalesce(get(first), () => ( null))));
+  const same2 = (get) => paths.every((p) => JSON.stringify(_nullishCoalesce(get(p), () => ( null))) === JSON.stringify(_nullishCoalesce(get(first), () => ( null))));
   const corners2 = [];
   for (const p of paths) {
     for (const c of vectorCorners(p.subpaths)) {
       if (anchorMode && !state.selectedAnchors.some((r) => r.nodeId === p.id && r.subpath === c.subpath && r.index === c.index)) continue;
       const corner = p.subpaths[c.subpath].anchors[c.index].corner;
-      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _399 => _399.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _400 => _400.kind]), () => ( "round")) });
+      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _443 => _443.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _444 => _444.kind]), () => ( "round")) });
     }
   }
   const c0 = _nullishCoalesce(corners2[0], () => ( { radius: 0, kind: "round" }));
@@ -11747,17 +13270,17 @@ function getVectorSelectionStyle(state) {
     corners: corners2.length,
     hasOpenPath: paths.some((p) => p.subpaths.some((sp) => !sp.closed && sp.anchors.length > 1)),
     mixed: {
-      fill: !same((p) => p.fill),
-      stroke: !same((p) => p.stroke),
-      strokeWidth: !same((p) => _nullishCoalesce(p.strokeWidth, () => ( 1))),
-      opacity: !same((p) => _nullishCoalesce(p.opacity, () => ( 1))),
-      strokeAlign: !same((p) => _nullishCoalesce(p.strokeAlign, () => ( "center"))),
-      startArrow: !same((p) => _nullishCoalesce(p.startArrow, () => ( null))),
-      endArrow: !same((p) => _nullishCoalesce(p.endArrow, () => ( null))),
-      arrowAlign: !same((p) => _nullishCoalesce(p.arrowAlign, () => ( "extend"))),
-      startArrowScale: !same((p) => _nullishCoalesce(p.startArrowScale, () => ( 1))),
-      endArrowScale: !same((p) => _nullishCoalesce(p.endArrowScale, () => ( 1))),
-      widthProfile: !same(profileOf),
+      fill: !same2((p) => p.fill),
+      stroke: !same2((p) => p.stroke),
+      strokeWidth: !same2((p) => _nullishCoalesce(p.strokeWidth, () => ( 1))),
+      opacity: !same2((p) => _nullishCoalesce(p.opacity, () => ( 1))),
+      strokeAlign: !same2((p) => _nullishCoalesce(p.strokeAlign, () => ( "center"))),
+      startArrow: !same2((p) => _nullishCoalesce(p.startArrow, () => ( null))),
+      endArrow: !same2((p) => _nullishCoalesce(p.endArrow, () => ( null))),
+      arrowAlign: !same2((p) => _nullishCoalesce(p.arrowAlign, () => ( "extend"))),
+      startArrowScale: !same2((p) => _nullishCoalesce(p.startArrowScale, () => ( 1))),
+      endArrowScale: !same2((p) => _nullishCoalesce(p.endArrowScale, () => ( 1))),
+      widthProfile: !same2(profileOf),
       cornerRadius: corners2.some((c) => c.radius !== c0.radius),
       cornerKind: corners2.some((c) => c.kind !== c0.kind)
     },
@@ -11805,7 +13328,7 @@ function getVectorGradientEditor(state) {
   const sel = stopIndex !== null && sorted[stopIndex] ? { ...sorted[stopIndex], index: stopIndex, last: stopIndex === sorted.length - 1 } : null;
   const preview = gradient ? `linear-gradient(to right, ${expandVectorGradientStops(gradient).map((s) => {
     const c = parseVectorColor(s.color);
-    const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _401 => _401[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
+    const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _445 => _445[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
     const color = c ? `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${Math.round(a * 1e3) / 1e3})` : s.color;
     return `${color} ${Math.round(s.offset * 1e4) / 100}%`;
   }).join(", ")})` : null;
@@ -11816,11 +13339,11 @@ function getVectorGradientEditor(state) {
     stops,
     selected: sel,
     preview,
-    type: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _402 => _402.type]), () => ( null)),
-    spread: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _403 => _403.spread]), () => ( "pad")),
-    interpolation: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _404 => _404.interpolation]), () => ( "srgb")),
-    smoothness: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _405 => _405.smoothness]), () => ( 0)),
-    strokeMode: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _406 => _406.strokeMode]), () => ( "within")),
+    type: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _446 => _446.type]), () => ( null)),
+    spread: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _447 => _447.spread]), () => ( "pad")),
+    interpolation: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _448 => _448.interpolation]), () => ( "srgb")),
+    smoothness: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _449 => _449.smoothness]), () => ( 0)),
+    strokeMode: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _450 => _450.strokeMode]), () => ( "within")),
     mixed: paths.some((p) => JSON.stringify(_nullishCoalesce(p[target], () => ( null))) !== JSON.stringify(_nullishCoalesce(paint, () => ( null))))
   };
 }
@@ -11851,22 +13374,23 @@ function getVectorEffectsPanel(state) {
   if (!nodes.length) return null;
   const one = nodes.length === 1 ? nodes[0] : null;
   return {
-    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _407 => _407.id]), () => ( null)),
+    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _451 => _451.id]), () => ( null)),
     count: nodes.length,
-    effects: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _408 => _408.effects]), () => ( []))).map((e) => ({
+    effects: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _452 => _452.effects]), () => ( []))).map((e) => ({
       id: e.id,
       type: e.type,
       label: _nullishCoalesce(VECTOR_EFFECT_LABELS[e.type], () => ( e.type)),
       enabled: e.enabled !== false,
       params: e.params,
-      specs: _nullishCoalesce(VECTOR_EFFECT_PARAM_SPECS[e.type], () => ( []))
+      // The Envelope panel (`getVectorEnvelopePanel`) edits an envelope's warp and mesh.
+      specs: e.type === "envelope" ? [] : _nullishCoalesce(VECTOR_EFFECT_PARAM_SPECS[e.type], () => ( []))
     })),
     expandable: nodes.some(hasVectorAppearance)
   };
 }
 
 // src/vector/commands.ts
-var EFFECT_PARAMS_DESCRIPTION = "Effect parameters (missing ones keep their value or default). trim: start, end (percent), offset (degrees), mode simultaneous|individual. roundCorners: radius. puckerBloat: amount (\u2212100\u2026100). twist: angle, center {x, y} (offset from the middle). zigzag: size, ridges, smooth. wiggle: size, detail, smooth, speed, correlation, phase, seed, time (seconds). offset: amount, join miter|round|bevel, miterLimit, copies, copyOffset. merge: mode merge|add|subtract|intersect|exclude. repeater: copies (fractions fade the last), offset, position {x, y}, anchor {x, y} (offset from the middle), rotation, scale {x, y} (percent), startOpacity, endOpacity (percent), composite below|above.";
+var EFFECT_PARAMS_DESCRIPTION = "Effect parameters (missing ones keep their value or default). trim: start, end (percent), offset (degrees), mode simultaneous|individual. roundCorners: radius. puckerBloat: amount (\u2212100\u2026100). twist: angle, center {x, y} (offset from the middle). zigzag: size, ridges, smooth. wiggle: size, detail, smooth, speed, correlation, phase, seed, time (seconds). offset: amount, join miter|round|bevel, miterLimit, copies, copyOffset. merge: mode merge|add|subtract|intersect|exclude. repeater: copies (fractions fade the last), offset, position {x, y}, anchor {x, y} (offset from the middle), rotation, scale {x, y} (percent), startOpacity, endOpacity (percent), composite below|above. envelope: style (a warp preset: arc|arcLower|arcUpper|arch|bulge|shellLower|shellUpper|flag|wave|fish|rise|fisheye|inflate|squeeze|twist, or mesh), bend, horizontal, vertical (percent, \u2212100\u2026100), orientation horizontal|vertical, rows, columns, mesh { us, vs, points } (node space; prefer vector.envelope).";
 var fail = (message) => {
   throw new Error(message);
 };
@@ -11907,9 +13431,9 @@ var BLEND_PROPS = {
   linear: { type: "boolean", description: "Move anchors in straight lines instead of the rotation-aware morph." }
 };
 var checkBlendOptions = (params) => {
-  if (_optionalChain([params, 'optionalAccess', _409 => _409.spacing]) !== void 0 && !VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
-  if (_optionalChain([params, 'optionalAccess', _410 => _410.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
-  if (_optionalChain([params, 'optionalAccess', _411 => _411.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
+  if (_optionalChain([params, 'optionalAccess', _453 => _453.spacing]) !== void 0 && !VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
+  if (_optionalChain([params, 'optionalAccess', _454 => _454.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
+  if (_optionalChain([params, 'optionalAccess', _455 => _455.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
 };
 var POINT = { type: "object", properties: { x: { type: "number" }, y: { type: "number" } }, required: ["x", "y"] };
 var GRADIENT_PROPS = {
@@ -11981,17 +13505,17 @@ function createVectorCommands(controller, options = {}) {
   const base = { group, ...options.scope ? { scope: options.scope } : {} };
   const hasSelection = () => controller.getState().selection.length ? true : "Nothing is selected.";
   const ids = (params) => {
-    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _412 => _412.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _456 => _456.ids]), () => ( controller.getState().selection));
     for (const id of list2) if (!controller.getNode(id)) fail(`There is no node "${id}".`);
     if (!list2.length) fail("Nothing is selected; pass ids.");
     return list2;
   };
-  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _413 => _413.ids, 'optionalAccess', _414 => _414.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _457 => _457.ids, 'optionalAccess', _458 => _458.length]) ? true : hasSelection();
   const anchorsOf = (refs) => {
     if (!refs) return [...controller.getState().selectedAnchors];
     for (const r of refs) {
       const node = controller.getNode(r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _415 => _415.type]) !== "path" || !_optionalChain([node, 'access', _416 => _416.subpaths, 'access', _417 => _417[r.subpath], 'optionalAccess', _418 => _418.anchors, 'access', _419 => _419[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+      if (_optionalChain([node, 'optionalAccess', _459 => _459.type]) !== "path" || !_optionalChain([node, 'access', _460 => _460.subpaths, 'access', _461 => _461[r.subpath], 'optionalAccess', _462 => _462.anchors, 'access', _463 => _463[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
     }
     return refs;
   };
@@ -12015,7 +13539,7 @@ function createVectorCommands(controller, options = {}) {
           ...n.type === "path" ? { fill: _nullishCoalesce(n.fill, () => ( null)), stroke: _nullishCoalesce(n.stroke, () => ( null)), strokeWidth: _nullishCoalesce(n.strokeWidth, () => ( 1)), d: vectorPathData(n, 2) } : { children: n.children.length },
           ...n.type === "group" && n.blend ? { blend: { ...resolveVectorBlendOptions(n.blend), spine: !!n.blend.spine, keys: vectorBlendKeys(n).map((k) => k.id) } } : {},
           ...n.blendStep ? { blendStep: true } : {},
-          ..._optionalChain([n, 'access', _420 => _420.effects, 'optionalAccess', _421 => _421.length]) ? { effects: n.effects } : {},
+          ..._optionalChain([n, 'access', _464 => _464.effects, 'optionalAccess', _465 => _465.length]) ? { effects: n.effects } : {},
           ...n.type === "group" && n.liveBoolean ? { liveBoolean: n.liveBoolean } : {},
           ...n.booleanOperation ? { booleanOperation: n.booleanOperation } : {}
         });
@@ -12087,7 +13611,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const id = controller.addPath(params.d, { ...pickStyle(params), ...params.name ? { name: params.name } : {} });
         const node = controller.getNode(id);
-        if (_optionalChain([node, 'optionalAccess', _422 => _422.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _466 => _466.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -12126,7 +13650,7 @@ function createVectorCommands(controller, options = {}) {
         check(controller.setGradient(patch, { ids: ids(params), target: _nullishCoalesce(target, () => ( "fill")) }));
         const id = ids(params)[0];
         const node = id ? controller.getNode(id) : void 0;
-        const path = _optionalChain([node, 'optionalAccess', _423 => _423.type]) === "path" ? node : void 0;
+        const path = _optionalChain([node, 'optionalAccess', _467 => _467.type]) === "path" ? node : void 0;
         return { ok: true, ...path ? { gradient: path[_nullishCoalesce(target, () => ( "fill"))] } : {} };
       }
     },
@@ -12139,10 +13663,10 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { radius: { type: "number", minimum: 0 }, kind: { type: "string", enum: VECTOR_CORNER_KINDS }, ids: IDS, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        const refs = _optionalChain([params, 'optionalAccess', _424 => _424.anchors]) ? anchorsOf(params.anchors) : void 0;
-        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _425 => _425.ids]) ? ids(params) : void 0 };
-        if (_optionalChain([params, 'optionalAccess', _426 => _426.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
-        else if (_optionalChain([params, 'optionalAccess', _427 => _427.kind])) check(controller.setCornerKind(params.kind, target));
+        const refs = _optionalChain([params, 'optionalAccess', _468 => _468.anchors]) ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _469 => _469.ids]) ? ids(params) : void 0 };
+        if (_optionalChain([params, 'optionalAccess', _470 => _470.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
+        else if (_optionalChain([params, 'optionalAccess', _471 => _471.kind])) check(controller.setCornerKind(params.kind, target));
         else fail("Pass `radius` and / or `kind`.");
         return { ok: true };
       }
@@ -12177,12 +13701,12 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const target = { ids: ids(params) };
-        if (_optionalChain([params, 'optionalAccess', _428 => _428.preset])) check(controller.setWidthProfile(params.preset, target));
-        else if (_optionalChain([params, 'optionalAccess', _429 => _429.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
-        else if (_optionalChain([params, 'optionalAccess', _430 => _430.taper]) || _optionalChain([params, 'optionalAccess', _431 => _431.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
+        if (_optionalChain([params, 'optionalAccess', _472 => _472.preset])) check(controller.setWidthProfile(params.preset, target));
+        else if (_optionalChain([params, 'optionalAccess', _473 => _473.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
+        else if (_optionalChain([params, 'optionalAccess', _474 => _474.taper]) || _optionalChain([params, 'optionalAccess', _475 => _475.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
         else fail("Pass `preset`, `points`, `taper` or `wave`.");
         const node = controller.getNode(target.ids[0]);
-        return { ok: true, points: _optionalChain([node, 'optionalAccess', _432 => _432.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _476 => _476.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -12204,10 +13728,10 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        if (!_optionalChain([params, 'optionalAccess', _433 => _433.id])) fail("Pass the path `id`.");
+        if (!_optionalChain([params, 'optionalAccess', _477 => _477.id])) fail("Pass the path `id`.");
         check(controller.setWidthPoint({ nodeId: params.id, index: _nullishCoalesce(params.index, () => ( null)) }, { t: params.t, left: params.left, right: params.right }));
         const node = controller.getNode(params.id);
-        return { ok: true, points: _optionalChain([node, 'optionalAccess', _434 => _434.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _478 => _478.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -12220,11 +13744,119 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _435 => _435.ids]) ? ids(params) : void 0 });
+        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _479 => _479.ids]) ? ids(params) : void 0 });
         if (!created.length) fail("No selected path has a stroke.");
         return { ids: created };
       }
     },
+    {
+      ...base,
+      id: `${prefix}distort`,
+      label: "Free Distort\u2026",
+      keywords: ["distort", "perspective", "free distort", "corners", "projective", "keystone"],
+      description: "Free Distort: moves the four corners of the selection box (clockwise from the top left, in the box\u2019s own rotation) to `corners` in document units, distorting the nodes in perspective (straight lines stay straight; curves are followed within `tolerance`). The corners must make a convex quadrilateral. One undo step.",
+      params: {
+        type: "object",
+        properties: {
+          ids: IDS,
+          corners: { type: "array", items: POINT, minItems: 4, maxItems: 4, description: "New top-left, top-right, bottom-right and bottom-left corners." },
+          tolerance: { type: "number", exclusiveMinimum: 0, description: "How closely curves follow the distortion (document units, default 0.05)." }
+        },
+        required: ["corners"]
+      },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.distort(params.corners, { ids: ids(params), tolerance: params.tolerance }));
+        const frame2 = controller.getState().selectionFrame;
+        return { ok: true, bounds: frame2 ? { x: frame2.x, y: frame2.y, width: frame2.width, height: frame2.height } : null };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}skew`,
+      label: "Skew\u2026",
+      keywords: ["skew", "shear", "slant", "oblique"],
+      description: "Skews nodes along the selection box\u2019s axes: `ax` degrees horizontally (vertical lines lean right for positive angles) and `ay` degrees vertically, about the box centre or `origin`. One undo step.",
+      params: {
+        type: "object",
+        properties: {
+          ids: IDS,
+          ax: { type: "number", minimum: -89.9, maximum: 89.9 },
+          ay: { type: "number", minimum: -89.9, maximum: 89.9 },
+          origin: POINT
+        }
+      },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.skew(_nullishCoalesce(params.ax, () => ( 0)), _nullishCoalesce(params.ay, () => ( 0)), { ids: ids(params), origin: params.origin }));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}envelope`,
+      label: "Envelope Distort\u2026",
+      keywords: ["envelope", "warp", "mesh", "arc", "arch", "bulge", "flag", "wave", "fish", "rise", "fisheye", "inflate", "squeeze", "twist", "shell", "bend", "distort"],
+      description: "Envelope distortion that stays editable (a live `envelope` effect). Give `preset` (with `bend`, `horizontal`, `vertical` in percent, \u2212100\u2026100, and `orientation`) to warp, or `mesh` ({ rows, columns } and optionally `points`, the control grid row by row in the node\u2019s own space) for an editable mesh; a node that already has an envelope is changed. `topObject: true` uses the topmost selected closed path as the envelope of the others; `release: true` removes the envelope and gives back its shape as a path; `expand: true` bakes it (Expand Appearance). One undo step.",
+      params: {
+        type: "object",
+        properties: {
+          ids: IDS,
+          preset: { type: "string", enum: VECTOR_WARP_STYLES },
+          bend: { type: "number", minimum: -100, maximum: 100 },
+          horizontal: { type: "number", minimum: -100, maximum: 100 },
+          vertical: { type: "number", minimum: -100, maximum: 100 },
+          orientation: { type: "string", enum: ["horizontal", "vertical"] },
+          mesh: {
+            type: "object",
+            properties: {
+              rows: { type: "integer", minimum: 1, maximum: 16 },
+              columns: { type: "integer", minimum: 1, maximum: 16 },
+              points: { type: "array", items: POINT, description: "(3\xB7columns + 1) \xD7 (3\xB7rows + 1) control points, row by row (node space)." }
+            }
+          },
+          topObject: { type: "boolean" },
+          release: { type: "boolean" },
+          expand: { type: "boolean" }
+        }
+      },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        const target = ids(params);
+        if (params.release) return { released: target, shapes: controller.releaseEnvelope({ ids: target }) };
+        if (params.expand) return { expanded: controller.expandAppearance({ ids: target }) };
+        if (params.topObject) {
+          const r = controller.makeEnvelopeWithTopObject({ ids: target, rows: _optionalChain([params, 'access', _480 => _480.mesh, 'optionalAccess', _481 => _481.rows]), columns: _optionalChain([params, 'access', _482 => _482.mesh, 'optionalAccess', _483 => _483.columns]) });
+          check(r);
+          return { nodeId: r.nodeId };
+        }
+        if (params.preset !== void 0 && !VECTOR_WARP_STYLES.includes(params.preset)) fail(`Unknown warp preset "${params.preset}".`);
+        const patch = {};
+        if (params.preset) patch.style = params.preset;
+        for (const k of ["bend", "horizontal", "vertical"]) if (params[k] !== void 0) patch[k] = params[k];
+        if (params.orientation) patch.orientation = params.orientation;
+        if (params.mesh) {
+          if (params.preset) fail("Give either `preset` or `mesh`, not both.");
+          patch.style = "mesh";
+          const columns = _nullishCoalesce(params.mesh.columns, () => ( 2));
+          const rows = _nullishCoalesce(params.mesh.rows, () => ( 2));
+          patch.columns = columns;
+          patch.rows = rows;
+          if (params.mesh.points) {
+            const even = (n) => Array.from({ length: n + 1 }, (_, i) => i / n);
+            const mesh = { us: even(columns), vs: even(rows), points: params.mesh.points.map((p) => ({ x: p.x, y: p.y })) };
+            if (!isValidVectorMesh(mesh)) fail(`A ${columns} \xD7 ${rows} mesh needs ${(3 * columns + 1) * (3 * rows + 1)} finite points.`);
+            patch.mesh = mesh;
+          }
+        }
+        const made = controller.envelope(patch, { ids: target });
+        if (!made.length) fail("Nothing to envelope.");
+        return { envelopes: made };
+      }
+    },
     {
       ...base,
       id: `${prefix}transform`,
@@ -12337,7 +13969,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         if (params.params !== void 0 || params.enabled !== void 0) check(controller.updateEffect(params.nodeId, params.effectId, { params: params.params, enabled: params.enabled }));
         if (params.index !== void 0) check(controller.moveEffect(params.nodeId, params.effectId, params.index));
-        return { effects: _nullishCoalesce(_optionalChain([controller, 'access', _436 => _436.getNode, 'call', _437 => _437(params.nodeId), 'optionalAccess', _438 => _438.effects]), () => ( [])) };
+        return { effects: _nullishCoalesce(_optionalChain([controller, 'access', _484 => _484.getNode, 'call', _485 => _485(params.nodeId), 'optionalAccess', _486 => _486.effects]), () => ( [])) };
       }
     },
     {
@@ -12401,7 +14033,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         checkBlendOptions(params);
-        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _439 => _439.ids]) });
+        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _487 => _487.ids]) });
         if (!r.ok) fail(r.message);
         return { ok: true };
       }
@@ -12415,7 +14047,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _440 => _440.ids]) });
+        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _488 => _488.ids]) });
         if (!groups.length) fail("Select a blend to expand.");
         return { ids: groups };
       }
@@ -12429,7 +14061,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _441 => _441.ids]) });
+        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _489 => _489.ids]) });
         if (!released.length) fail("Select a blend to release.");
         return { ids: released };
       }
@@ -12443,7 +14075,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _442 => _442.ids]) });
+        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _490 => _490.ids]) });
         if (!r.ok) fail(r.message);
         return { ok: true };
       }
@@ -12557,7 +14189,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _443 => _443.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _491 => _491.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -12585,7 +14217,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { anchors: ANCHORS, keepShape: { type: "boolean" } } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _444 => _444.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _445 => _445.keepShape]) }));
+        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _492 => _492.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _493 => _493.keepShape]) }));
         return { ok: true };
       }
     },
@@ -12640,7 +14272,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS, tolerance: { type: "number", minimum: 0 } } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _446 => _446.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _447 => _447.tolerance]) }));
+        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _494 => _494.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _495 => _495.tolerance]) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -12654,7 +14286,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { axis: { type: "string", enum: ["horizontal", "vertical", "both"] }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _448 => _448.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _449 => _449.anchors]))));
+        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _496 => _496.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _497 => _497.anchors]))));
         return { ok: true };
       }
     },
@@ -12668,7 +14300,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _450 => _450.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _451 => _451.tolerance]) }));
+        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _498 => _498.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _499 => _499.tolerance]) }));
         return { ok: true };
       }
     },
@@ -12681,7 +14313,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS, amount: { type: "number", minimum: 0, maximum: 1 }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _452 => _452.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _453 => _453.amount]), refs: _optionalChain([params, 'optionalAccess', _454 => _454.anchors]) }));
+        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _500 => _500.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _501 => _501.amount]), refs: _optionalChain([params, 'optionalAccess', _502 => _502.anchors]) }));
         return { ok: true };
       }
     },
@@ -12694,14 +14326,14 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { nodeId: { type: "string" }, x: { type: "number" }, y: { type: "number" }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        if (_optionalChain([params, 'optionalAccess', _455 => _455.nodeId]) !== void 0) {
+        if (_optionalChain([params, 'optionalAccess', _503 => _503.nodeId]) !== void 0) {
           if (!controller.getNode(params.nodeId)) fail(`There is no node "${params.nodeId}".`);
           if (params.x === void 0 || params.y === void 0) fail("Pass x and y with nodeId.");
           const created = controller.cutPathAt(params.nodeId, { x: params.x, y: params.y });
           if (!created) fail("Nothing to cut there (the end of an open path, or a locked path).");
           return { ids: created };
         }
-        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _456 => _456.anchors]))));
+        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _504 => _504.anchors]))));
         return { ids: controller.getState().selection };
       }
     },
@@ -12752,7 +14384,7 @@ function createVectorCommands(controller, options = {}) {
       },
       run: (_ctx, params) => {
         const patch = {};
-        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _457 => _457[key]]) !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _505 => _505[key]]) !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -12777,7 +14409,7 @@ function createVectorCommands(controller, options = {}) {
       keywords: ["download", "save", "markup"],
       description: "Returns the document as SVG markup.",
       params: { type: "object", properties: { precision: { type: "integer", minimum: 0, maximum: 8 } } },
-      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _458 => _458.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _506 => _506.precision]) }) })
     },
     {
       ...base,
@@ -13136,5 +14768,54 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-exports.DEFAULT_VECTOR_BLEND_DISTANCE = DEFAULT_VECTOR_BLEND_DISTANCE; exports.DEFAULT_VECTOR_BLEND_STEPS = DEFAULT_VECTOR_BLEND_STEPS; exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BLEND_MAX_SMOOTH_STEPS = VECTOR_BLEND_MAX_SMOOTH_STEPS; exports.VECTOR_BLEND_MAX_STEPS = VECTOR_BLEND_MAX_STEPS; exports.VECTOR_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; exports.VECTOR_BLEND_SPACING_LABELS = VECTOR_BLEND_SPACING_LABELS; exports.VECTOR_BUILDER_HATCH_GAP = VECTOR_BUILDER_HATCH_GAP; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_EFFECT_DEFAULTS = VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_MENU = VECTOR_EFFECT_MENU; exports.VECTOR_EFFECT_PARAM_SPECS = VECTOR_EFFECT_PARAM_SPECS; exports.VECTOR_EFFECT_TYPES = VECTOR_EFFECT_TYPES; exports.VECTOR_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_GRADIENT_INTERPOLATIONS = VECTOR_GRADIENT_INTERPOLATIONS; exports.VECTOR_GRADIENT_INTERPOLATION_LABELS = VECTOR_GRADIENT_INTERPOLATION_LABELS; exports.VECTOR_GRADIENT_MAX_PERIODS = VECTOR_GRADIENT_MAX_PERIODS; exports.VECTOR_GRADIENT_MIDPOINT_GAP = VECTOR_GRADIENT_MIDPOINT_GAP; exports.VECTOR_GRADIENT_MIN_STOPS = VECTOR_GRADIENT_MIN_STOPS; exports.VECTOR_GRADIENT_OFF_BAR = VECTOR_GRADIENT_OFF_BAR; exports.VECTOR_GRADIENT_SPREADS = VECTOR_GRADIENT_SPREADS; exports.VECTOR_GRADIENT_SPREAD_LABELS = VECTOR_GRADIENT_SPREAD_LABELS; exports.VECTOR_GRADIENT_STOP_GAP = VECTOR_GRADIENT_STOP_GAP; exports.VECTOR_GRADIENT_TYPES = VECTOR_GRADIENT_TYPES; exports.VECTOR_GRADIENT_TYPE_LABELS = VECTOR_GRADIENT_TYPE_LABELS; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_MERGE_MODES = VECTOR_MERGE_MODES; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATHFINDER_ACTIONS = VECTOR_PATHFINDER_ACTIONS; exports.VECTOR_PATHFINDER_LABELS = VECTOR_PATHFINDER_LABELS; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STROKE_GRADIENT_MODES = VECTOR_STROKE_GRADIENT_MODES; exports.VECTOR_STROKE_GRADIENT_MODE_LABELS = VECTOR_STROKE_GRADIENT_MODE_LABELS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.activeVectorEffects = activeVectorEffects; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorBlendOptions = applyVectorBlendOptions; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.applyVectorEffects = applyVectorEffects; exports.applyVectorGradientPatch = applyVectorGradientPatch; exports.applyVectorGradientSpread = applyVectorGradientSpread; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.clearVectorLiveBooleanCache = clearVectorLiveBooleanCache; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.convertVectorGradient = convertVectorGradient; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.correspondMorphContours = correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorEffect = createVectorEffect; exports.createVectorMorph = createVectorMorph; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.defaultVectorGradient = defaultVectorGradient; exports.effectPathLength = effectPathLength; exports.effectPathVertexCount = effectPathVertexCount; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; exports.expandVectorAppearance = expandVectorAppearance; exports.expandVectorAppearances = expandVectorAppearances; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.expandVectorGradientSpread = expandVectorGradientSpread; exports.expandVectorGradientStops = expandVectorGradientStops; exports.explicitVectorGradient = explicitVectorGradient; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.foldVectorBooleanOperands = foldVectorBooleanOperands; exports.generateVectorBlendChildren = generateVectorBlendChildren; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorBlendControls = getVectorBlendControls; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorEffectsPanel = getVectorEffectsPanel; exports.getVectorEnteredGroups = getVectorEnteredGroups; exports.getVectorGradientAnnotator = getVectorGradientAnnotator; exports.getVectorGradientEditor = getVectorGradientEditor; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.gradientMidpointRemap = gradientMidpointRemap; exports.hasExplicitGradientGeometry = hasExplicitGradientGeometry; exports.hasOwnVectorAppearance = hasOwnVectorAppearance; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorAppearance = hasVectorAppearance; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.hitVectorGradientAnnotator = hitVectorGradientAnnotator; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertVectorGradientStop = insertVectorGradientStop; exports.insertWidthPoint = insertWidthPoint; exports.interpolateMorphContours = interpolateMorphContours; exports.interpolateRigidMatrix = interpolateRigidMatrix; exports.interpolateVectorColor = interpolateVectorColor; exports.interpolateVectorPaint = interpolateVectorPaint; exports.interpolateVectorPaths = interpolateVectorPaths; exports.interpolateVectorStyle = interpolateVectorStyle; exports.interpolateWidthProfiles = interpolateWidthProfiles; exports.invertMatrix = invertMatrix; exports.isCentredVectorGradient = isCentredVectorGradient; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorGradient = isVectorGradient; exports.isVectorLiveBoolean = isVectorLiveBoolean; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mergePaths = mergePaths; exports.mirrorWidthProfile = mirrorWidthProfile; exports.morphContourToSubpath = morphContourToSubpath; exports.morphPathsCross = morphPathsCross; exports.moveAnchorHandle = moveAnchorHandle; exports.moveVectorGradientHandle = moveVectorGradientHandle; exports.moveVectorGradientStop = moveVectorGradientStop; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.normalizeVectorEffectParams = normalizeVectorEffectParams; exports.offsetPaths = offsetPaths; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorColor = parseVectorColor; exports.parseVectorSvg = parseVectorSvg; exports.pathsCenter = pathsCenter; exports.patternAttrs = patternAttrs; exports.periodicVectorGradientStops = periodicVectorGradientStops; exports.pinVectorGradient = pinVectorGradient; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.puckerBloatPaths = puckerBloatPaths; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.refineMorphContour = refineMorphContour; exports.refreshVectorBlends = refreshVectorBlends; exports.releaseVectorBlend = releaseVectorBlend; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeVectorGradientStop = removeVectorGradientStop; exports.removeWidthPoints = removeWidthPoints; exports.repeatPaths = repeatPaths; exports.resampleGradientStops = resampleGradientStops; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = reverseMorphContour; exports.reverseSubpath = reverseSubpath; exports.reverseVectorGradient = reverseVectorGradient; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundCornerPaths = roundCornerPaths; exports.roundSubpaths = roundSubpaths; exports.samplePlainStops = samplePlainStops; exports.samplePolyline = samplePolyline; exports.sampleVectorGradient = sampleVectorGradient; exports.sampleVectorGradientAt = sampleVectorGradientAt; exports.sampleVectorPaintDefAt = sampleVectorPaintDefAt; exports.sanitizeVectorEffects = sanitizeVectorEffects; exports.sanitizeVectorGradient = sanitizeVectorGradient; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setVectorGradientVector = setVectorGradientVector; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.sortedVectorGradientStops = sortedVectorGradientStops; exports.spanVectorGradientStops = spanVectorGradientStops; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.starSubpath = starSubpath; exports.strokePositionPoint = strokePositionPoint; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathToMorphContour = subpathToMorphContour; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorEffects = transformVectorEffects; exports.transformVectorGradient = transformVectorGradient; exports.transformVectorNode = transformVectorNode; exports.transformVectorPaint = transformVectorPaint; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.trimIntervals = trimIntervals; exports.trimPaths = trimPaths; exports.trimPathsIndividually = trimPathsIndividually; exports.turnMorphContour = turnMorphContour; exports.twistPaths = twistPaths; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorAppearanceNodes = vectorAppearanceNodes; exports.vectorAppearanceOutline = vectorAppearanceOutline; exports.vectorAppearanceShapes = vectorAppearanceShapes; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBoxMatrix = vectorBoxMatrix; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorEnteredGroups = vectorEnteredGroups; exports.vectorFillMap = vectorFillMap; exports.vectorGradientArea = vectorGradientArea; exports.vectorGradientAspect = vectorGradientAspect; exports.vectorGradientBarPosition = vectorGradientBarPosition; exports.vectorGradientFocalParam = vectorGradientFocalParam; exports.vectorGradientHandles = vectorGradientHandles; exports.vectorGradientMatrix = vectorGradientMatrix; exports.vectorGradientMidpointFromPosition = vectorGradientMidpointFromPosition; exports.vectorGradientMidpointPosition = vectorGradientMidpointPosition; exports.vectorGradientNeedsExpansion = vectorGradientNeedsExpansion; exports.vectorGradientParam = vectorGradientParam; exports.vectorGradientPoints = vectorGradientPoints; exports.vectorGradientRamp = vectorGradientRamp; exports.vectorGradientSvgDefs = vectorGradientSvgDefs; exports.vectorGradientTAt = vectorGradientTAt; exports.vectorGradientTargetPath = vectorGradientTargetPath; exports.vectorGradientUnitsMatrix = vectorGradientUnitsMatrix; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorLiveBooleanSteps = vectorLiveBooleanSteps; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorOperandOperation = vectorOperandOperation; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathLocalBounds = vectorPathLocalBounds; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorRepeaterCopies = vectorRepeaterCopies; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorStrokeGradientDefs = vectorStrokeGradientDefs; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute; exports.wigglePaths = wigglePaths; exports.zigzagPaths = zigzagPaths;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_VECTOR_BLEND_DISTANCE = DEFAULT_VECTOR_BLEND_DISTANCE; exports.DEFAULT_VECTOR_BLEND_STEPS = DEFAULT_VECTOR_BLEND_STEPS; exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BLEND_MAX_SMOOTH_STEPS = VECTOR_BLEND_MAX_SMOOTH_STEPS; exports.VECTOR_BLEND_MAX_STEPS = VECTOR_BLEND_MAX_STEPS; exports.VECTOR_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; exports.VECTOR_BLEND_SPACING_LABELS = VECTOR_BLEND_SPACING_LABELS; exports.VECTOR_BUILDER_HATCH_GAP = VECTOR_BUILDER_HATCH_GAP; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_DISTORT_TOLERANCE = VECTOR_DISTORT_TOLERANCE; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_EFFECT_DEFAULTS = VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_MENU = VECTOR_EFFECT_MENU; exports.VECTOR_EFFECT_PARAM_SPECS = VECTOR_EFFECT_PARAM_SPECS; exports.VECTOR_EFFECT_TYPES = VECTOR_EFFECT_TYPES; exports.VECTOR_ENVELOPE_STYLE_OPTIONS = VECTOR_ENVELOPE_STYLE_OPTIONS; exports.VECTOR_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_GRADIENT_INTERPOLATIONS = VECTOR_GRADIENT_INTERPOLATIONS; exports.VECTOR_GRADIENT_INTERPOLATION_LABELS = VECTOR_GRADIENT_INTERPOLATION_LABELS; exports.VECTOR_GRADIENT_MAX_PERIODS = VECTOR_GRADIENT_MAX_PERIODS; exports.VECTOR_GRADIENT_MIDPOINT_GAP = VECTOR_GRADIENT_MIDPOINT_GAP; exports.VECTOR_GRADIENT_MIN_STOPS = VECTOR_GRADIENT_MIN_STOPS; exports.VECTOR_GRADIENT_OFF_BAR = VECTOR_GRADIENT_OFF_BAR; exports.VECTOR_GRADIENT_SPREADS = VECTOR_GRADIENT_SPREADS; exports.VECTOR_GRADIENT_SPREAD_LABELS = VECTOR_GRADIENT_SPREAD_LABELS; exports.VECTOR_GRADIENT_STOP_GAP = VECTOR_GRADIENT_STOP_GAP; exports.VECTOR_GRADIENT_TYPES = VECTOR_GRADIENT_TYPES; exports.VECTOR_GRADIENT_TYPE_LABELS = VECTOR_GRADIENT_TYPE_LABELS; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_MERGE_MODES = VECTOR_MERGE_MODES; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATHFINDER_ACTIONS = VECTOR_PATHFINDER_ACTIONS; exports.VECTOR_PATHFINDER_LABELS = VECTOR_PATHFINDER_LABELS; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STROKE_GRADIENT_MODES = VECTOR_STROKE_GRADIENT_MODES; exports.VECTOR_STROKE_GRADIENT_MODE_LABELS = VECTOR_STROKE_GRADIENT_MODE_LABELS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WARP_STYLES = VECTOR_WARP_STYLES; exports.VECTOR_WARP_STYLE_LABELS = VECTOR_WARP_STYLE_LABELS; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.activeVectorEffects = activeVectorEffects; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorBlendOptions = applyVectorBlendOptions; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.applyVectorEffects = applyVectorEffects; exports.applyVectorGradientPatch = applyVectorGradientPatch; exports.applyVectorGradientSpread = applyVectorGradientSpread; exports.applyVectorHomography = applyVectorHomography; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.clearVectorLiveBooleanCache = clearVectorLiveBooleanCache; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.convertVectorGradient = convertVectorGradient; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.correspondMorphContours = correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorEffect = createVectorEffect; exports.createVectorMorph = createVectorMorph; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.defaultVectorGradient = defaultVectorGradient; exports.distortVectorNode = distortVectorNode; exports.dragVectorMeshPoint = dragVectorMeshPoint; exports.effectPathLength = effectPathLength; exports.effectPathVertexCount = effectPathVertexCount; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.evalVectorMesh = evalVectorMesh; exports.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; exports.expandVectorAppearance = expandVectorAppearance; exports.expandVectorAppearances = expandVectorAppearances; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.expandVectorGradientSpread = expandVectorGradientSpread; exports.expandVectorGradientStops = expandVectorGradientStops; exports.explicitVectorGradient = explicitVectorGradient; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.fitVectorMesh = fitVectorMesh; exports.foldVectorBooleanOperands = foldVectorBooleanOperands; exports.generateVectorBlendChildren = generateVectorBlendChildren; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorBlendControls = getVectorBlendControls; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorEffectsPanel = getVectorEffectsPanel; exports.getVectorEnteredGroups = getVectorEnteredGroups; exports.getVectorEnvelopePanel = getVectorEnvelopePanel; exports.getVectorEnvelopeTarget = getVectorEnvelopeTarget; exports.getVectorGradientAnnotator = getVectorGradientAnnotator; exports.getVectorGradientEditor = getVectorGradientEditor; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.gradientMidpointRemap = gradientMidpointRemap; exports.hasExplicitGradientGeometry = hasExplicitGradientGeometry; exports.hasOwnVectorAppearance = hasOwnVectorAppearance; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorAppearance = hasVectorAppearance; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.hitVectorGradientAnnotator = hitVectorGradientAnnotator; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertVectorGradientStop = insertVectorGradientStop; exports.insertWidthPoint = insertWidthPoint; exports.interpolateMorphContours = interpolateMorphContours; exports.interpolateRigidMatrix = interpolateRigidMatrix; exports.interpolateVectorColor = interpolateVectorColor; exports.interpolateVectorPaint = interpolateVectorPaint; exports.interpolateVectorPaths = interpolateVectorPaths; exports.interpolateVectorStyle = interpolateVectorStyle; exports.interpolateWidthProfiles = interpolateWidthProfiles; exports.invertMatrix = invertMatrix; exports.isCentredVectorGradient = isCentredVectorGradient; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isValidVectorMesh = isValidVectorMesh; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorGradient = isVectorGradient; exports.isVectorLiveBoolean = isVectorLiveBoolean; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.mapBezierPath = mapBezierPath; exports.mapVectorGradient = mapVectorGradient; exports.mapVectorMeshPoints = mapVectorMeshPoints; exports.mapVectorPaint = mapVectorPaint; exports.mapVectorPoints = mapVectorPoints; exports.mapVectorSubpaths = mapVectorSubpaths; exports.matrixRotation = matrixRotation; exports.mergePaths = mergePaths; exports.mirrorWidthProfile = mirrorWidthProfile; exports.morphContourToSubpath = morphContourToSubpath; exports.morphPathsCross = morphPathsCross; exports.moveAnchorHandle = moveAnchorHandle; exports.moveVectorGradientHandle = moveVectorGradientHandle; exports.moveVectorGradientStop = moveVectorGradientStop; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.normalizeVectorEffectParams = normalizeVectorEffectParams; exports.offsetPaths = offsetPaths; exports.orderVectorQuad = orderVectorQuad; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorColor = parseVectorColor; exports.parseVectorSvg = parseVectorSvg; exports.pathsCenter = pathsCenter; exports.patternAttrs = patternAttrs; exports.periodicVectorGradientStops = periodicVectorGradientStops; exports.pinVectorGradient = pinVectorGradient; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.puckerBloatPaths = puckerBloatPaths; exports.pullVectorMesh = pullVectorMesh; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.refineMorphContour = refineMorphContour; exports.refreshVectorBlends = refreshVectorBlends; exports.releaseVectorBlend = releaseVectorBlend; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeVectorGradientStop = removeVectorGradientStop; exports.removeVectorMeshSplitU = removeVectorMeshSplitU; exports.removeVectorMeshSplitV = removeVectorMeshSplitV; exports.removeWidthPoints = removeWidthPoints; exports.repeatPaths = repeatPaths; exports.resampleGradientStops = resampleGradientStops; exports.resizeVectorMesh = resizeVectorMesh; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = reverseMorphContour; exports.reverseSubpath = reverseSubpath; exports.reverseVectorGradient = reverseVectorGradient; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundCornerPaths = roundCornerPaths; exports.roundSubpaths = roundSubpaths; exports.samplePlainStops = samplePlainStops; exports.samplePolyline = samplePolyline; exports.sampleVectorGradient = sampleVectorGradient; exports.sampleVectorGradientAt = sampleVectorGradientAt; exports.sampleVectorPaintDefAt = sampleVectorPaintDefAt; exports.sanitizeVectorEffects = sanitizeVectorEffects; exports.sanitizeVectorGradient = sanitizeVectorGradient; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setVectorGradientVector = setVectorGradientVector; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.solve8 = solve8; exports.sortedVectorGradientStops = sortedVectorGradientStops; exports.spanVectorGradientStops = spanVectorGradientStops; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.splitVectorMeshU = splitVectorMeshU; exports.splitVectorMeshV = splitVectorMeshV; exports.starSubpath = starSubpath; exports.strokePositionPoint = strokePositionPoint; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathToMorphContour = subpathToMorphContour; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorEffects = transformVectorEffects; exports.transformVectorGradient = transformVectorGradient; exports.transformVectorNode = transformVectorNode; exports.transformVectorPaint = transformVectorPaint; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.trimIntervals = trimIntervals; exports.trimPaths = trimPaths; exports.trimPathsIndividually = trimPathsIndividually; exports.turnMorphContour = turnMorphContour; exports.twistPaths = twistPaths; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorAppearanceNodes = vectorAppearanceNodes; exports.vectorAppearanceOutline = vectorAppearanceOutline; exports.vectorAppearanceShapes = vectorAppearanceShapes; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBoxCorners = vectorBoxCorners; exports.vectorBoxMatrix = vectorBoxMatrix; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDistortQuad = vectorDistortQuad; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorEffectInputBounds = vectorEffectInputBounds; exports.vectorEffectInputPaths = vectorEffectInputPaths; exports.vectorEnteredGroups = vectorEnteredGroups; exports.vectorEnvelopeFrame = vectorEnvelopeFrame; exports.vectorEnvelopeMap = vectorEnvelopeMap; exports.vectorEnvelopeMesh = vectorEnvelopeMesh; exports.vectorFillMap = vectorFillMap; exports.vectorGradientArea = vectorGradientArea; exports.vectorGradientAspect = vectorGradientAspect; exports.vectorGradientBarPosition = vectorGradientBarPosition; exports.vectorGradientFocalParam = vectorGradientFocalParam; exports.vectorGradientHandles = vectorGradientHandles; exports.vectorGradientMatrix = vectorGradientMatrix; exports.vectorGradientMidpointFromPosition = vectorGradientMidpointFromPosition; exports.vectorGradientMidpointPosition = vectorGradientMidpointPosition; exports.vectorGradientNeedsExpansion = vectorGradientNeedsExpansion; exports.vectorGradientParam = vectorGradientParam; exports.vectorGradientPoints = vectorGradientPoints; exports.vectorGradientRamp = vectorGradientRamp; exports.vectorGradientSvgDefs = vectorGradientSvgDefs; exports.vectorGradientTAt = vectorGradientTAt; exports.vectorGradientTargetPath = vectorGradientTargetPath; exports.vectorGradientUnitsMatrix = vectorGradientUnitsMatrix; exports.vectorHomography = vectorHomography; exports.vectorHomographyKeepsQuad = vectorHomographyKeepsQuad; exports.vectorIdentityMesh = vectorIdentityMesh; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorLiveBooleanSteps = vectorLiveBooleanSteps; exports.vectorMeshColumns = vectorMeshColumns; exports.vectorMeshControlBounds = vectorMeshControlBounds; exports.vectorMeshEditPoints = vectorMeshEditPoints; exports.vectorMeshFromOutline = vectorMeshFromOutline; exports.vectorMeshGridCurves = vectorMeshGridCurves; exports.vectorMeshOutline = vectorMeshOutline; exports.vectorMeshParamAt = vectorMeshParamAt; exports.vectorMeshRows = vectorMeshRows; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeEnvelope = vectorNodeEnvelope; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorOperandOperation = vectorOperandOperation; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathLocalBounds = vectorPathLocalBounds; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorRepeaterCopies = vectorRepeaterCopies; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorShearForSide = vectorShearForSide; exports.vectorSkewMatrix = vectorSkewMatrix; exports.vectorStrokeGradientDefs = vectorStrokeGradientDefs; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWarpPresetGrid = vectorWarpPresetGrid; exports.vectorWarpPresetMesh = vectorWarpPresetMesh; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute; exports.wigglePaths = wigglePaths; exports.zigzagPaths = zigzagPaths;
 //# sourceMappingURL=index.cjs.map