@pixerate/editor 0.39.0 → 0.41.0

package/dist/vector/index.cjs

@@ -40,9 +40,19 @@ var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 
 var _chunkVNYRI265cjs = require('../chunk-VNYRI265.cjs');
 
+
+var _chunkMR3Z4OQIcjs = require('../chunk-MR3Z4OQI.cjs');
+
+
+var _chunkXZ4L3R4Kcjs = require('../chunk-XZ4L3R4K.cjs');
+
+
+var _chunkA6PHCAGXcjs = require('../chunk-A6PHCAGX.cjs');
+
 // src/vector/types.ts
 var VECTOR_CORNER_KINDS = ["round", "inverted", "chamfer"];
 var VECTOR_ARROWHEADS = ["triangle", "arrow", "open", "circle", "square", "bar"];
+var VECTOR_BLEND_SPACINGS = ["steps", "distance", "smoothColor"];
 var VECTOR_TOOLS = [
   "select",
   "direct",
@@ -58,7 +68,8 @@ var VECTOR_TOOLS = [
   "eraser",
   "width",
   "shapeBuilder",
-  "paintBucket"
+  "paintBucket",
+  "blend"
 ];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
@@ -829,7 +840,11 @@ var capExtent = (style, width) => style.strokeLinecap === "round" || style.strok
 function arrowheadWeight(style, end) {
   const scale = end === "start" ? style.startArrowScale : style.endArrowScale;
   const s = typeof scale === "number" && scale > 0 && Number.isFinite(scale) ? scale : 1;
-  return Math.max(0.25, (_nullishCoalesce(style.strokeWidth, () => ( 1))) * s);
+  const width = _nullishCoalesce(style.strokeWidth, () => ( 1));
+  const profile = strokeWidthProfileOf(style);
+  const at2 = profile ? widthProfileAt(profile, end === "start" ? 0 : 1) : null;
+  const here = at2 ? Math.max(width, width * (at2.left + at2.right) / 2) : width;
+  return Math.max(0.25, here * s);
 }
 function arrowheadInset(kind, hw, cap) {
   const l = 4 * hw;
@@ -1323,25 +1338,33 @@ function decomposeRigid(m) {
     residual: [cos * a + sin * b, -sin * a + cos * b, cos * c + sin * d, -sin * c + cos * d, 0, 0]
   };
 }
+function mapAnchor(a, m) {
+  const p = applyMatrix(m, a);
+  const next = { x: p.x, y: p.y };
+  if (a.in) next.in = applyMatrix(m, a.in);
+  if (a.out) next.out = applyMatrix(m, a.out);
+  if (a.type) next.type = a.type;
+  if (a.corner) next.corner = { ...a.corner };
+  return next;
+}
 function bakeIntoGeometry(node, m) {
   if (isIdentityMatrix(m)) return node;
-  if (node.type === "group") return { ...node, children: node.children.map((c) => transformVectorNode(c, m)) };
+  if (node.type === "group") {
+    const group = node;
+    const children = group.children.map((c) => transformVectorNode(c, m));
+    const spine = _optionalChain([group, 'access', _28 => _28.blend, 'optionalAccess', _29 => _29.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', _28 => _28.strokeWidthProfile, 'optionalAccess', _29 => _29.length]);
+  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _30 => _30.strokeWidthProfile, 'optionalAccess', _31 => _31.length]);
   return {
     ...path,
     ...mirrored ? { strokeWidthProfile: mirrorWidthProfile(path.strokeWidthProfile) } : {},
     subpaths: path.subpaths.map((sp) => ({
       closed: sp.closed,
-      anchors: sp.anchors.map((a) => {
-        const p = applyMatrix(m, a);
-        const next = { x: p.x, y: p.y };
-        if (a.in) next.in = applyMatrix(m, a.in);
-        if (a.out) next.out = applyMatrix(m, a.out);
-        if (a.type) next.type = a.type;
-        if (a.corner) next.corner = { ...a.corner };
-        return next;
-      })
+      anchors: sp.anchors.map((a) => mapAnchor(a, m))
     }))
   };
 }
@@ -1546,7 +1569,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', _30 => _30[+m[1]], 'optionalAccess', _31 => _31.anchors, 'access', _32 => _32[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _32 => _32[+m[1]], 'optionalAccess', _33 => _33.anchors, 'access', _34 => _34[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -1609,6 +1632,33 @@ function gradientMarkup(def) {
   const stops = def.stops.map((s) => `<stop offset="${s.offset}" stop-color="${escapeAttr(s.stopColor)}"${s.stopOpacity !== void 0 ? ` stop-opacity="${s.stopOpacity}"` : ""}/>`).join("");
   return `<${tag} id="${escapeAttr(def.id)}"${attrs}>${stops}</${tag}>`;
 }
+function blendFromAttribute(value, m) {
+  if (!value) return null;
+  let raw;
+  try {
+    raw = JSON.parse(value);
+  } catch (e3) {
+    return null;
+  }
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  const out = {};
+  if (r.spacing === "steps" || r.spacing === "distance" || r.spacing === "smoothColor") out.spacing = r.spacing;
+  if (typeof r.steps === "number" && Number.isFinite(r.steps)) out.steps = Math.min(1e3, Math.max(1, Math.round(r.steps)));
+  if (typeof r.distance === "number" && r.distance > 0) out.distance = r.distance;
+  if (typeof r.orientToSpine === "boolean") out.orientToSpine = r.orientToSpine;
+  if (typeof r.linear === "boolean") out.linear = r.linear;
+  if (r.starts && typeof r.starts === "object") {
+    const starts = Object.fromEntries(Object.entries(r.starts).filter((e) => Number.isInteger(e[1]) && e[1] >= 0));
+    if (Object.keys(starts).length) out.starts = starts;
+  }
+  const spine = r.spine;
+  if (spine && Array.isArray(spine.anchors) && spine.anchors.every((a) => a && Number.isFinite(a.x) && Number.isFinite(a.y))) {
+    const sp = { closed: !!spine.closed, anchors: spine.anchors.map((a) => ({ x: a.x, y: a.y, ...a.in ? { in: { x: a.in.x, y: a.in.y } } : {}, ...a.out ? { out: { x: a.out.x, y: a.out.y } } : {} })) };
+    out.spine = m === IDENTITY_MATRIX ? sp : transformVectorNode({ id: "", type: "path", subpaths: [sp] }, m).subpaths[0];
+  }
+  return out;
+}
 function vectorDocumentToSvg(doc, options = {}) {
   const precision = _nullishCoalesce(options.precision, () => ( 3));
   const prefix = _nullishCoalesce(options.idPrefix, () => ( "vg-"));
@@ -1622,6 +1672,8 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (node.transform) out2 += ` transform="matrix(${node.transform.map((n) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
     if (node.opacity !== void 0 && node.opacity < 1) out2 += ` opacity="${num(node.opacity)}"`;
     if (node.visible === false) out2 += ` display="none"`;
+    if (node.blendStep) out2 += ` data-vector-blend-step=""`;
+    if (node.type === "group" && node.blend) out2 += ` data-vector-blend="${escapeAttr(JSON.stringify(node.blend))}"`;
     return out2;
   };
   const emit = (node, depth) => {
@@ -1644,7 +1696,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       let out2 = ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num(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', _33 => _33.strokeDasharray, 'optionalAccess', _34 => _34.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      if (_optionalChain([node, 'access', _35 => _35.strokeDasharray, 'optionalAccess', _36 => _36.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
       return out2;
     };
     const parts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${prefix}clip-${node.id}`, precision) : void 0;
@@ -1664,7 +1716,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', _35 => _35.strokeDasharray, 'optionalAccess', _36 => _36.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      if (_optionalChain([node, 'access', _37 => _37.strokeDasharray, 'optionalAccess', _38 => _38.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
     }
     lines.push(`${indent(depth)}<g${common(node)}${data}>`);
     lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}"${fillAttrs}${live}/>`);
@@ -1833,7 +1885,7 @@ function resolveGradient(id, raw, seen = /* @__PURE__ */ new Set()) {
   seen.add(id);
   let stops = readStops(el);
   const href = _nullishCoalesce(el.attrs.href, () => ( el.attrs["xlink:href"]));
-  if (!stops.length && _optionalChain([href, 'optionalAccess', _37 => _37.startsWith, 'call', _38 => _38("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _39 => _39(href.slice(1), raw, seen), 'optionalAccess', _40 => _40.stops]), () => ( []));
+  if (!stops.length && _optionalChain([href, 'optionalAccess', _39 => _39.startsWith, 'call', _40 => _40("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _41 => _41(href.slice(1), raw, seen), 'optionalAccess', _42 => _42.stops]), () => ( []));
   if (!stops.length) return null;
   if (el.name === "radialGradient") {
     return { type: "radial", cx: fraction(el.attrs.cx, 0.5), cy: fraction(el.attrs.cy, 0.5), r: fraction(el.attrs.r, 0.5), stops };
@@ -1937,7 +1989,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', _41 => _41.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _43 => _43.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style);
     const strokeEl = part("stroke");
@@ -1974,7 +2026,7 @@ function parseVectorSvg(svg, options = {}) {
       ...profile.length ? { strokeWidthProfile: profile } : {},
       ...keptCap ? { strokeLinecap: keptCap } : {},
       ...keptJoin ? { strokeLinejoin: keptJoin } : {},
-      ..._optionalChain([keptDash, 'optionalAccess', _42 => _42.length]) ? { strokeDasharray: keptDash } : {}
+      ..._optionalChain([keptDash, 'optionalAccess', _44 => _44.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
@@ -1991,6 +2043,7 @@ function parseVectorSvg(svg, options = {}) {
         ...opacity !== void 0 && Number.isFinite(opacity) && opacity < 1 ? { opacity } : {},
         ...hidden ? { visible: false } : {}
       };
+      if (child.attrs["data-vector-blend-step"] !== void 0) continue;
       if (child.name === "g" && child.attrs["data-vector-path"] !== void 0) {
         const node2 = mergedPath(child, s, m, meta);
         if (node2) out.push(node2);
@@ -2000,6 +2053,8 @@ function parseVectorSvg(svg, options = {}) {
         const children = visit(child, s, m);
         if (!children.length) continue;
         const group = { id: idFor(child), type: "group", ...meta, children };
+        const blend = child.name === "g" ? blendFromAttribute(child.attrs["data-vector-blend"], m) : null;
+        if (blend) group.blend = blend;
         out.push(group);
         continue;
       }
@@ -2025,10 +2080,914 @@ function parseVectorSvg(svg, options = {}) {
   return { width, height, nodes };
 }
 
+// src/vector/blend.ts
+var lerpN = (a, b, t) => a + (b - a) * t;
+var lerpP = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+var toP = (v2) => [v2.x, v2.y];
+var mapP = (m, p) => [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
+var curvesOf = (c) => Math.max(0, (c.pts.length - 1) / 3) | 0;
+function subpathToMorphContour(sp, m = IDENTITY_MATRIX) {
+  const n = sp.anchors.length;
+  if (!n) return null;
+  const first = mapP(m, toP(sp.anchors[0]));
+  const pts = [first];
+  const count = n < 2 ? 0 : sp.closed ? n : n - 1;
+  for (let i = 0; i < count; i++) {
+    const a = sp.anchors[i];
+    const b = sp.anchors[(i + 1) % n];
+    const pa = toP(a);
+    const pb = toP(b);
+    const straight = (!a.out || a.out.x === a.x && a.out.y === a.y) && (!b.in || b.in.x === b.x && b.in.y === b.y);
+    const c1 = straight ? lerpP(pa, pb, 1 / 3) : toP(_nullishCoalesce(a.out, () => ( a)));
+    const c2 = straight ? lerpP(pa, pb, 2 / 3) : toP(_nullishCoalesce(b.in, () => ( b)));
+    pts.push(mapP(m, c1), mapP(m, c2), i === count - 1 && sp.closed ? first : mapP(m, pb));
+  }
+  return { closed: sp.closed && count > 0, pts };
+}
+function isStraight(p0, p1, p2, p3) {
+  const dx = p3[0] - p0[0];
+  const dy = p3[1] - p0[1];
+  const len2 = Math.hypot(dx, dy);
+  const tol = Math.max(1e-7, len2 * 1e-7);
+  if (len2 < 1e-12) return Math.hypot(p1[0] - p0[0], p1[1] - p0[1]) < tol && Math.hypot(p2[0] - p0[0], p2[1] - p0[1]) < tol;
+  const off = (p) => Math.abs((p[0] - p0[0]) * dy - (p[1] - p0[1]) * dx) / len2;
+  const along2 = (p) => ((p[0] - p0[0]) * dx + (p[1] - p0[1]) * dy) / (len2 * len2);
+  const u1 = along2(p1);
+  const u2 = along2(p2);
+  return off(p1) < tol && off(p2) < tol && u1 >= -1e-9 && u1 <= 1 + 1e-9 && u2 >= -1e-9 && u2 <= 1 + 1e-9;
+}
+function morphContourToSubpath(c, m = IDENTITY_MATRIX, closed = c.closed) {
+  const pts = isIdentityMatrix(m) ? c.pts : c.pts.map((p) => mapP(m, p));
+  const curves = curvesOf(c);
+  const dropLast = closed && c.closed && curves > 0;
+  const count = dropLast ? curves : curves + 1;
+  const anchors = [];
+  for (let k = 0; k < count; k++) anchors.push({ x: pts[3 * k][0], y: pts[3 * k][1] });
+  for (let k = 0; k < curves; k++) {
+    const p0 = pts[3 * k];
+    const p1 = pts[3 * k + 1];
+    const p2 = pts[3 * k + 2];
+    const p3 = pts[3 * k + 3];
+    if (isStraight(p0, p1, p2, p3)) continue;
+    anchors[k].out = { x: p1[0], y: p1[1] };
+    anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
+  }
+  for (const a of anchors) {
+    const type = inferAnchorType(a);
+    if (type !== "corner") a.type = type;
+  }
+  const isClosed = closed && curves > 0;
+  return { anchors: dropCollinear(anchors, isClosed), closed: isClosed };
+}
+function dropCollinear(anchors, closed) {
+  const out = anchors.slice();
+  const min = closed ? 3 : 2;
+  let i = closed ? 0 : 1;
+  while (out.length > min && i < out.length - (closed ? 0 : 1)) {
+    const n = out.length;
+    const a = out[(i - 1 + n) % n];
+    const b = out[i];
+    const c = out[(i + 1) % n];
+    const plain3 = !b.in && !b.out && !a.out && !c.in;
+    const ux = b.x - a.x;
+    const uy = b.y - a.y;
+    const vx = c.x - b.x;
+    const vy = c.y - b.y;
+    const len2 = Math.hypot(ux, uy) + Math.hypot(vx, vy);
+    if (plain3 && Math.abs(ux * vy - uy * vx) <= 1e-9 * Math.max(1, len2 * len2) && ux * vx + uy * vy >= 0) out.splice(i, 1);
+    else i++;
+  }
+  return out;
+}
+var segOf = (c, k) => c.pts.slice(3 * k, 3 * k + 4);
+function refineMorphContour(c, segments) {
+  const have = curvesOf(c);
+  if (have === 0) return { contour: { closed: c.closed, pts: Array.from({ length: 1 + 3 * segments }, () => [c.pts[0][0], c.pts[0][1]]) }, anchors: [0] };
+  const identity = Array.from({ length: c.closed ? have : have + 1 }, (_, i) => i);
+  if (have >= segments) return { contour: c, anchors: identity };
+  const segs = Array.from({ length: have }, (_, k) => segOf(c, k));
+  const lens = segs.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
+  const sum = lens.reduce((a, b) => a + b, 0);
+  const extra = segments - have;
+  const want = lens.map((l) => sum > 1e-12 ? l / sum * extra : extra / have);
+  const parts = want.map((w) => 1 + Math.floor(w));
+  let left = segments - parts.reduce((a, b) => a + b, 0);
+  const frac = want.map((w) => w - Math.floor(w));
+  const order = parts.map((_, i) => i).sort((a, b) => Math.abs(frac[b] - frac[a]) > 1e-9 ? frac[b] - frac[a] : a - b);
+  for (let i = 0; left > 0; i = (i + 1) % order.length, left--) parts[order[i]]++;
+  const pts = [c.pts[0]];
+  const anchors = [0];
+  let at2 = 0;
+  segs.forEach((seg, k) => {
+    const pieces = parts[k];
+    let rest = seg.slice();
+    let t0 = 0;
+    for (let j = 1; j < pieces; j++) {
+      const t = _chunkVNYRI265cjs.segmentParamAtLength.call(void 0, seg, lens[k] * j / pieces, lens[k]);
+      const u = Math.min(1, Math.max(0, (t - t0) / (1 - t0 || 1)));
+      const [l, r] = _chunkVNYRI265cjs.splitSegment.call(void 0, rest, u);
+      pts.push(l[1], l[2], l[3]);
+      rest = r;
+      t0 = t;
+    }
+    pts.push(rest[1], rest[2], k === have - 1 && c.closed ? c.pts[0] : rest[3]);
+    at2 += pieces;
+    if (k < have - 1 || !c.closed) anchors.push(at2);
+  });
+  return { contour: { closed: c.closed, pts }, anchors };
+}
+function reverseMorphContour(c) {
+  return { closed: c.closed, pts: c.pts.slice().reverse() };
+}
+function turnMorphContour(c, s) {
+  const n = curvesOf(c);
+  if (!c.closed || n === 0) return c;
+  const k = (s % n + n) % n;
+  if (k === 0) return c;
+  const body = c.pts.slice(1);
+  return { closed: true, pts: [c.pts[3 * k], ...body.slice(3 * k), ...body.slice(0, 3 * k)] };
+}
+function anchorPoints(c) {
+  const n = curvesOf(c);
+  const count = c.closed ? n : n + 1;
+  return Array.from({ length: Math.max(1, count) }, (_, k) => c.pts[3 * k]);
+}
+function polygonArea(pts) {
+  let s = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const a = pts[i];
+    const b = pts[(i + 1) % pts.length];
+    s += a[0] * b[1] - b[0] * a[1];
+  }
+  return s / 2;
+}
+function frame(v2) {
+  const n = Math.max(1, v2.length);
+  let cx = 0;
+  let cy = 0;
+  for (const p of v2) {
+    cx += p[0];
+    cy += p[1];
+  }
+  cx /= n;
+  cy /= n;
+  let s = 0;
+  for (const p of v2) s += (p[0] - cx) ** 2 + (p[1] - cy) ** 2;
+  return { c: [cx, cy], r: Math.max(1e-9, Math.sqrt(s / n)) };
+}
+var RBINS = 5;
+var ABINS = 12;
+var TURN_WEIGHT = 0.1;
+function shapeContexts(v2, closed) {
+  const { r } = frame(v2);
+  const n = v2.length;
+  return v2.map((p, i) => {
+    const prev = v2[closed ? (i - 1 + n) % n : Math.max(0, i - 1)];
+    const next = v2[closed ? (i + 1) % n : Math.min(n - 1, i + 1)];
+    const dir = Math.atan2(next[1] - prev[1], next[0] - prev[0]);
+    const h = new Float64Array(RBINS * ABINS);
+    let total = 0;
+    for (let j = 0; j < n; j++) {
+      if (i === j) continue;
+      const dx = v2[j][0] - p[0];
+      const dy = v2[j][1] - p[1];
+      const d = Math.hypot(dx, dy) / r;
+      const lr = (Math.log2(Math.max(d, 1e-6)) + 3) / 4 * RBINS;
+      if (!(lr >= 0 && lr < RBINS)) continue;
+      let ang = Math.atan2(dy, dx) - dir;
+      ang = (ang % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+      h[Math.floor(lr) * ABINS + Math.min(ABINS - 1, Math.floor(ang / (2 * Math.PI) * ABINS))] += 1;
+      total++;
+    }
+    if (total > 0) for (let k = 0; k < h.length; k++) h[k] /= total;
+    return h;
+  });
+}
+function chi2(a, b) {
+  let s = 0;
+  for (let k = 0; k < a.length; k++) {
+    const t = a[k] + b[k];
+    if (t > 1e-12) s += (a[k] - b[k]) * (a[k] - b[k]) / t;
+  }
+  return s / 2;
+}
+function bestStart(fixed, free, useShapeContext) {
+  const fa = anchorPoints(fixed);
+  const ga = anchorPoints(free);
+  const n = ga.length;
+  const ff = frame(fa);
+  const gf = frame(ga);
+  const fn = fa.map((p) => [(p[0] - ff.c[0]) / ff.r, (p[1] - ff.c[1]) / ff.r]);
+  const gn = ga.map((p) => [(p[0] - gf.c[0]) / gf.r, (p[1] - gf.c[1]) / gf.r]);
+  const fsc = useShapeContext ? shapeContexts(fa, fixed.closed) : null;
+  const gsc = useShapeContext ? shapeContexts(ga, free.closed) : null;
+  const m = Math.max(1, fn.length);
+  const cost = (s) => {
+    let dot2 = 0;
+    let cross2 = 0;
+    let sc = 0;
+    for (let i = 0; i < fn.length; i++) {
+      const j = free.closed ? (i + s) % n : i;
+      const p = fn[i];
+      const q = gn[j];
+      dot2 += p[0] * q[0] + p[1] * q[1];
+      cross2 += p[0] * q[1] - p[1] * q[0];
+      if (fsc && gsc) sc += chi2(fsc[i], gsc[j]);
+    }
+    const residual = Math.max(0, 1 - (dot2 * dot2 + cross2 * cross2) / (m * m));
+    const turn = 1 - Math.cos(Math.atan2(cross2, dot2));
+    return residual + TURN_WEIGHT * turn + sc / m;
+  };
+  if (!free.closed) return { start: 0, cost: cost(0) };
+  const stride = n > 96 ? Math.ceil(n / 48) : 1;
+  let best = { start: 0, cost: Infinity };
+  for (let s = 0; s < n; s += stride) {
+    const c = cost(s);
+    if (c < best.cost - 1e-12) best = { start: s, cost: c };
+  }
+  if (stride > 1) {
+    const s0 = best.start;
+    for (let d = 1; d < stride; d++)
+      for (const s of [(s0 + d) % n, (s0 - d + n) % n]) {
+        const c = cost(s);
+        if (c < best.cost - 1e-12) best = { start: s, cost: c };
+      }
+  }
+  return best;
+}
+function placeIn(c, from, to) {
+  const b = unionBounds([boundsOfPoints(c.pts)]);
+  const p = b ? [b.x + b.width / 2, b.y + b.height / 2] : c.pts[0];
+  if (!from || !to) return p;
+  const fx = from.width > 0 ? (p[0] - from.x) / from.width : 0.5;
+  const fy = from.height > 0 ? (p[1] - from.y) / from.height : 0.5;
+  return [to.x + to.width * fx, to.y + to.height * fy];
+}
+function boundsOfPoints(pts) {
+  if (!pts.length) return null;
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of pts) {
+    x0 = Math.min(x0, p[0]);
+    y0 = Math.min(y0, p[1]);
+    x1 = Math.max(x1, p[0]);
+    y1 = Math.max(y1, p[1]);
+  }
+  return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}
+function correspondMorphContours(a, b, options = {}) {
+  const minSeg = Math.max(1, Math.round(_nullishCoalesce(options.minSegments, () => ( 16))));
+  const maxSeg = Math.max(minSeg, Math.round(_nullishCoalesce(options.maxSegments, () => ( 400))));
+  const spacing = options.spacing && options.spacing > 0 ? options.spacing : null;
+  const useSC = options.shapeContext !== false;
+  const match = options.matchStart !== false;
+  const ba = boundsOfPoints(a.flatMap((c) => c.pts));
+  const bb = boundsOfPoints(b.flatMap((c) => c.pts));
+  const contourLength = (c) => {
+    let l = 0;
+    for (let k = 0; k < curvesOf(c); k++) l += _chunkVNYRI265cjs.segmentLength.call(void 0, segOf(c, k));
+    return l;
+  };
+  const pairs = [];
+  const [sa, sb] = _nullishCoalesce(options.starts, () => ( []));
+  for (let k = 0; k < Math.max(a.length, b.length); k++) {
+    const ca = a[k];
+    const cb = b[k];
+    const explicitA = k === 0 && sa !== null && sa !== void 0 ? sa : null;
+    const explicitB = k === 0 && sb !== null && sb !== void 0 ? sb : null;
+    const counts = [ca ? curvesOf(ca) : 0, cb ? curvesOf(cb) : 0];
+    const longest = Math.max(ca ? contourLength(ca) : 0, cb ? contourLength(cb) : 0);
+    let n = Math.max(counts[0], counts[1], minSeg, spacing ? Math.ceil(longest / spacing) : 0);
+    n = Math.max(counts[0], counts[1], Math.min(n, maxSeg));
+    const point = (c, from, to) => {
+      const p = placeIn(c, from, to);
+      return { closed: c.closed, pts: Array.from({ length: 1 + 3 * n }, () => [p[0], p[1]]) };
+    };
+    if (ca && cb) {
+      const ra = refineMorphContour(ca, n);
+      const rb = refineMorphContour(cb, n);
+      pairs.push({
+        x: ra.contour,
+        y: rb.contour,
+        point: false,
+        startX: explicitA === null ? null : _nullishCoalesce(ra.anchors[explicitA], () => ( null)),
+        startY: explicitB === null ? null : explicitB === rb.anchors.length - 1 && !cb.closed ? -1 : _nullishCoalesce(rb.anchors[explicitB], () => ( null))
+      });
+      if (explicitA !== null && !ca.closed && explicitA === ra.anchors.length - 1 && explicitA > 0) pairs[pairs.length - 1].startX = -1;
+    } else if (ca) pairs.push({ x: refineMorphContour(ca, n).contour, y: point(ca, ba, bb), point: true, startX: null, startY: null });
+    else if (cb) pairs.push({ x: point(cb, bb, ba), y: refineMorphContour(cb, n).contour, point: true, startX: null, startY: null });
+  }
+  const startAt = (c, s) => {
+    if (s === null) return c;
+    if (s === -1) return reverseMorphContour(c);
+    return c.closed ? turnMorphContour(c, s) : c;
+  };
+  const explicit = pairs.length > 0 && (pairs[0].startX !== null || pairs[0].startY !== null);
+  const ref = pairs.find((p) => !p.point && p.x.closed && p.y.closed);
+  const fixedBack = ref ? Math.sign(polygonArea(anchorPoints(ref.x))) !== Math.sign(polygonArea(anchorPoints(ref.y))) && Math.abs(polygonArea(anchorPoints(ref.y))) > 1e-12 : explicit ? false : null;
+  let best = null;
+  for (const back of fixedBack === null ? [false, true] : [fixedBack]) {
+    const xs = [];
+    const ys = [];
+    let cost = 0;
+    pairs.forEach((p, k) => {
+      let x = k === 0 ? startAt(p.x, p.startX) : p.x;
+      let y = k === 0 ? startAt(p.y, p.startY) : p.y;
+      if (back) y = reverseMorphContour(y);
+      if (p.point) {
+        xs.push(x);
+        ys.push(y);
+        return;
+      }
+      const pinned = k === 0 && explicit;
+      const turnX = !y.closed && x.closed;
+      if (match && !pinned && (y.closed || turnX)) {
+        const r = turnX ? bestStart(y, x, useSC) : bestStart(x, y, useSC);
+        if (turnX) x = turnMorphContour(x, r.start);
+        else y = turnMorphContour(y, r.start);
+        cost += r.cost;
+      } else cost += bestStart(x, { ...y, closed: false }, useSC).cost;
+      xs.push(x);
+      ys.push(y);
+    });
+    if (!best || cost < best.cost - 1e-9) best = { xs, ys, cost, back };
+  }
+  return best ? { a: best.xs, b: best.ys, reversed: best.back } : { a: [], b: [], reversed: false };
+}
+function morphPathsCross(a, b) {
+  let count = 0;
+  const d = (p, q, r) => (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
+  for (let k = 0; k < Math.min(a.length, b.length); k++) {
+    const pa = anchorPoints(a[k]);
+    const pb = anchorPoints(b[k]);
+    const n = Math.min(pa.length, pb.length);
+    for (let i = 0; i < n; i++)
+      for (let j = i + 1; j < n; j++) {
+        const d1 = d(pa[j], pb[j], pa[i]);
+        const d2 = d(pa[j], pb[j], pb[i]);
+        const d3 = d(pa[i], pb[i], pa[j]);
+        const d4 = d(pa[i], pb[i], pb[j]);
+        if (d1 * d2 < 0 && d3 * d4 < 0) count++;
+      }
+  }
+  return count;
+}
+function procrustes(a, b) {
+  const pa = a.flatMap(anchorPoints);
+  const pb = b.flatMap(anchorPoints);
+  const ca = frame(pa).c;
+  const cb = frame(pb).c;
+  let ss = 0;
+  let dot2 = 0;
+  let cross2 = 0;
+  for (let i = 0; i < Math.min(pa.length, pb.length); i++) {
+    const p = [pa[i][0] - ca[0], pa[i][1] - ca[1]];
+    const q = [pb[i][0] - cb[0], pb[i][1] - cb[1]];
+    ss += p[0] * p[0] + p[1] * p[1];
+    dot2 += p[0] * q[0] + p[1] * q[1];
+    cross2 += p[0] * q[1] - p[1] * q[0];
+  }
+  return { ca, cb, theta: Math.atan2(cross2, dot2), s: ss > 1e-12 ? Math.hypot(dot2, cross2) / ss : 1 };
+}
+function interpolateMorphContours(a, b, u, options = {}) {
+  const w = options.linear ? 0 : Math.min(1, Math.max(0, _nullishCoalesce(options.rigidity, () => ( 1))));
+  const sim = w > 0 ? _nullishCoalesce(options.similarity, () => ( procrustes(a, b))) : null;
+  const rot = (p, ang, k) => {
+    const c = Math.cos(ang);
+    const s = Math.sin(ang);
+    return [k * (c * p[0] - s * p[1]), k * (s * p[0] + c * p[1])];
+  };
+  const thetaU = sim ? sim.theta * u : 0;
+  const sU = sim ? Math.max(1e-9, sim.s) ** u : 1;
+  const cU = sim ? lerpP(sim.ca, sim.cb, u) : [0, 0];
+  return a.map((ca, k) => {
+    const cb = b[k];
+    const pts = ca.pts.map((p, i) => {
+      const q = _nullishCoalesce(cb.pts[i], () => ( p));
+      const linear = lerpP(p, q, u);
+      if (!sim) return linear;
+      const d = [p[0] - sim.ca[0], p[1] - sim.ca[1]];
+      const full = rot(d, sim.theta, sim.s);
+      const resid = [q[0] - (full[0] + sim.cb[0]), q[1] - (full[1] + sim.cb[1])];
+      const part = rot(d, thetaU, sU);
+      const rigid = [part[0] + cU[0] + resid[0] * u, part[1] + cU[1] + resid[1] * u];
+      return lerpP(linear, rigid, w);
+    });
+    return { closed: ca.closed && cb.closed, pts };
+  });
+}
+function interpolateRigidMatrix(a, b, t) {
+  const decompose = (m) => {
+    const sx2 = Math.hypot(m[0], m[1]);
+    const ang2 = sx2 > 1e-12 ? Math.atan2(m[1], m[0]) : 0;
+    const c2 = Math.cos(ang2);
+    const s2 = Math.sin(ang2);
+    return { e: m[4], f: m[5], ang: ang2, sx: sx2, sh: c2 * m[2] + s2 * m[3], sy: -s2 * m[2] + c2 * m[3] };
+  };
+  const p = decompose(a);
+  const q = decompose(b);
+  let turn = q.ang - p.ang;
+  turn = ((turn + Math.PI) % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI) - Math.PI;
+  const ang = p.ang + turn * t;
+  const sx = lerpN(p.sx, q.sx, t);
+  const sh = lerpN(p.sh, q.sh, t);
+  const sy = lerpN(p.sy, q.sy, t);
+  const c = Math.cos(ang);
+  const s = Math.sin(ang);
+  return [c * sx, s * sx, c * sh - s * sy, s * sh + c * sy, lerpN(p.e, q.e, t), lerpN(p.f, q.f, t)];
+}
+function interpolateVectorColor(a, b, t) {
+  if (t <= 0) return a;
+  if (t >= 1) return b;
+  return _nullishCoalesce(_chunkMR3Z4OQIcjs.mixColorsOklab.call(void 0, a, b, t), () => ( (t < 0.5 ? a : b)));
+}
+function sortedStops(g) {
+  return g.stops.slice().sort((x, y) => x.offset - y.offset);
+}
+function sampleGradient(stops, offset) {
+  if (!stops.length) return { color: "transparent", opacity: 1 };
+  const first = stops[0];
+  const last = stops[stops.length - 1];
+  if (offset <= first.offset) return { color: first.color, opacity: _nullishCoalesce(first.opacity, () => ( 1)) };
+  if (offset >= last.offset) return { color: last.color, opacity: _nullishCoalesce(last.opacity, () => ( 1)) };
+  let i = 0;
+  while (i + 1 < stops.length && stops[i + 1].offset < offset) i++;
+  const x = stops[i];
+  const y = stops[i + 1];
+  const u = y.offset - x.offset > 1e-12 ? (offset - x.offset) / (y.offset - x.offset) : 1;
+  return { color: interpolateVectorColor(x.color, y.color, u), opacity: lerpN(_nullishCoalesce(x.opacity, () => ( 1)), _nullishCoalesce(y.opacity, () => ( 1)), u) };
+}
+function resampleGradientStops(g, offsets) {
+  const stops = sortedStops(g);
+  return offsets.map((offset) => {
+    const s = sampleGradient(stops, offset);
+    return s.opacity < 1 ? { offset, color: s.color, opacity: s.opacity } : { offset, color: s.color };
+  });
+}
+function lerpAngle(a, b, t) {
+  const d = ((b - a + 180) % 360 + 360) % 360 - 180;
+  return a + d * t;
+}
+function lerpGradient(a, b, t) {
+  if (a.type !== b.type) return null;
+  let stopsA = sortedStops(a);
+  let stopsB = sortedStops(b);
+  if (stopsA.length !== stopsB.length) {
+    const offs = [...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    const common = offs.filter((o, i) => i === 0 || o - offs[i - 1] > 1e-4);
+    stopsA = resampleGradientStops(a, common);
+    stopsB = resampleGradientStops(b, common);
+  }
+  const stops = stopsA.map((x, i) => {
+    const y = stopsB[i];
+    const opacity = lerpN(_nullishCoalesce(x.opacity, () => ( 1)), _nullishCoalesce(y.opacity, () => ( 1)), t);
+    const stop = { offset: lerpN(x.offset, y.offset, t), color: interpolateVectorColor(x.color, y.color, t) };
+    if (opacity < 1) stop.opacity = opacity;
+    return stop;
+  });
+  if (a.type === "linear" && b.type === "linear") return { type: "linear", angle: lerpAngle(_nullishCoalesce(a.angle, () => ( 90)), _nullishCoalesce(b.angle, () => ( 90)), t), stops };
+  const ra = a;
+  const rb = b;
+  return { type: "radial", cx: lerpN(_nullishCoalesce(ra.cx, () => ( 0.5)), _nullishCoalesce(rb.cx, () => ( 0.5)), t), cy: lerpN(_nullishCoalesce(ra.cy, () => ( 0.5)), _nullishCoalesce(rb.cy, () => ( 0.5)), t), r: lerpN(_nullishCoalesce(ra.r, () => ( 0.5)), _nullishCoalesce(rb.r, () => ( 0.5)), t), stops };
+}
+function solidLike(color, like) {
+  return { ...like, stops: like.stops.map((s) => color === null ? { offset: s.offset, color: s.color, opacity: 0 } : { offset: s.offset, color }) };
+}
+function interpolateVectorPaint(a, b, t) {
+  if (t <= 0) return a;
+  if (t >= 1) return b;
+  const pa = hasPaint(a);
+  const pb = hasPaint(b);
+  if (!pa && !pb) return t < 0.5 ? a : b;
+  if (typeof a === "string" && pa && typeof b === "string" && pb) return interpolateVectorColor(a, b, t);
+  if (!pa && typeof b === "string") return interpolateVectorColor("transparent", b, t);
+  if (!pb && typeof a === "string") return interpolateVectorColor(a, "transparent", t);
+  const ga = pa && typeof a === "object" && a ? a : null;
+  const gb = pb && typeof b === "object" && b ? b : null;
+  if (ga && gb) return _nullishCoalesce(lerpGradient(ga, gb, t), () => ( (t < 0.5 ? a : b)));
+  if (gb) return _nullishCoalesce(lerpGradient(solidLike(pa ? a : null, gb), gb, t), () => ( b));
+  if (ga) return _nullishCoalesce(lerpGradient(ga, solidLike(pb ? b : null, ga), t), () => ( a));
+  return t < 0.5 ? a : b;
+}
+function interpolateWidthProfiles(a, b, t) {
+  if (!_optionalChain([a, 'optionalAccess', _45 => _45.length]) && !_optionalChain([b, 'optionalAccess', _46 => _46.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) => {
+    const x = widthProfileAt(a, pos);
+    const y = widthProfileAt(b, pos);
+    return { t: pos, left: lerpN(x.left, y.left, t), right: lerpN(x.right, y.right, t) };
+  });
+}
+function lerpDashes(a, b, t) {
+  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _47 => _47.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) => {
+    const e = even(p);
+    const out = [];
+    for (let i = 0; i < e.length; i += 2) out.push(e[i] + e[i + 1], 0);
+    return out;
+  };
+  const x = dashed(a) ? even(a) : solid(b);
+  const y = dashed(b) ? even(b) : solid(a);
+  if (x.length !== y.length) return t < 0.5 ? a : b;
+  return x.map((v2, i) => lerpN(v2, y[i], t));
+}
+var SWITCHED_KEYS = ["strokeLinecap", "strokeLinejoin", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign"];
+function interpolateVectorStyle(a, b, t) {
+  const near2 = t < 0.5 ? a : b;
+  const out = {};
+  const fill = interpolateVectorPaint(a.fill, b.fill, t);
+  if (fill !== void 0) out.fill = fill;
+  const stroke = interpolateVectorPaint(a.stroke, b.stroke, t);
+  if (stroke !== void 0) out.stroke = stroke;
+  if (a.strokeWidth !== void 0 || b.strokeWidth !== void 0) out.strokeWidth = lerpN(_nullishCoalesce(a.strokeWidth, () => ( 1)), _nullishCoalesce(b.strokeWidth, () => ( 1)), t);
+  for (const key of SWITCHED_KEYS) if (near2[key] !== void 0 && near2[key] !== null) out[key] = near2[key];
+  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', _48 => _48.length])) out.strokeDasharray = dash;
+  const profile = interpolateWidthProfiles(a.strokeWidthProfile, b.strokeWidthProfile, t);
+  if (profile) out.strokeWidthProfile = profile;
+  return out;
+}
+function reversedStyle(s) {
+  const out = { ...s };
+  out.startArrow = s.endArrow;
+  out.endArrow = s.startArrow;
+  out.startArrowScale = s.endArrowScale;
+  out.endArrowScale = s.startArrowScale;
+  if (_optionalChain([s, 'access', _49 => _49.strokeWidthProfile, 'optionalAccess', _50 => _50.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
+  for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
+  return out;
+}
+var STYLE_KEYS2 = [
+  "fill",
+  "stroke",
+  "strokeWidth",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeDasharray",
+  "fillRule",
+  "strokeAlign",
+  "startArrow",
+  "endArrow",
+  "arrowAlign",
+  "startArrowScale",
+  "endArrowScale",
+  "strokeWidthProfile"
+];
+function styleOf(n) {
+  const out = {};
+  for (const k of STYLE_KEYS2) if (n[k] !== void 0) out[k] = n[k];
+  return out;
+}
+function contoursOf(node, m) {
+  return expandVectorCorners(node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+}
+function preparePathMorph(a, b, options, ma = nodeMatrix(a), mb = nodeMatrix(b)) {
+  const corr = correspondMorphContours(contoursOf(a, ma), contoursOf(b, mb), options);
+  const sim = procrustes(corr.a, corr.b);
+  const styleA = styleOf(a);
+  const styleB = corr.reversed ? reversedStyle(styleOf(b)) : styleOf(b);
+  const rigid = !isIdentityMatrix(ma) || !isIdentityMatrix(mb);
+  const id = _nullishCoalesce(options.id, () => ( a.id));
+  return (t) => {
+    const contours = interpolateMorphContours(corr.a, corr.b, t, { linear: options.linear, rigidity: options.rigidity, similarity: sim });
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : IDENTITY_MATRIX;
+    const back = rigid ? invertMatrix(m) : IDENTITY_MATRIX;
+    const subpaths = contours.map((c, k) => {
+      const closed = t <= 0 ? corr.a[k].closed : t >= 1 ? corr.b[k].closed : corr.a[k].closed && corr.b[k].closed;
+      return morphContourToSubpath({ closed: corr.a[k].closed && corr.b[k].closed, pts: c.pts }, back, closed);
+    });
+    const node = { id, type: "path", subpaths, ...interpolateVectorStyle(styleA, styleB, t) };
+    const opacity = lerpN(_nullishCoalesce(a.opacity, () => ( 1)), _nullishCoalesce(b.opacity, () => ( 1)), t);
+    if (opacity < 1) node.opacity = opacity;
+    if (rigid && !isIdentityMatrix(m)) node.transform = m;
+    return node;
+  };
+}
+function flattenPaths(node, parent = IDENTITY_MATRIX) {
+  const m = multiplyMatrices(nodeMatrix(node), parent);
+  if (node.type === "path") return [{ path: node, m, opacity: 1 }];
+  const o = _nullishCoalesce(node.opacity, () => ( 1));
+  return node.children.filter((c) => c.visible !== false).flatMap((c) => flattenPaths(c, m)).map((e) => ({ ...e, opacity: e.opacity * o }));
+}
+var placedBounds = (path, m) => boundsOfPoints(contoursOf(path, m).flatMap((c) => c.pts));
+function collapsedPath(path, m, from, to) {
+  const own = placedBounds(path, m);
+  const c = own ? [own.x + own.width / 2, own.y + own.height / 2] : [0, 0];
+  const fx = from && from.width > 0 ? (c[0] - from.x) / from.width : 0.5;
+  const fy = from && from.height > 0 ? (c[1] - from.y) / from.height : 0.5;
+  const p = to ? { x: to.x + to.width * fx, y: to.y + to.height * fy } : { x: c[0], y: c[1] };
+  const subpaths = path.subpaths.map((sp) => ({ closed: sp.closed, anchors: sp.anchors.map(() => ({ x: p.x, y: p.y })) }));
+  const { transform: _t, ...rest } = path;
+  return { ...rest, subpaths };
+}
+function createVectorMorph(a, b, options = {}) {
+  if (a.type === "path" && b.type === "path") {
+    const at2 = preparePathMorph(a, b, options);
+    return { at: at2 };
+  }
+  const pa = flattenPaths(a);
+  const pb = flattenPaths(b);
+  const ba = unionBounds(pa.map((e) => placedBounds(e.path, e.m)));
+  const bb = unionBounds(pb.map((e) => placedBounds(e.path, e.m)));
+  const id = _nullishCoalesce(options.id, () => ( a.id));
+  const parts = [];
+  const opacities = [];
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i];
+    const y = pb[i];
+    const sub3 = { ...options, id: `${id}-${i}`, starts: void 0 };
+    if (x && y) {
+      parts.push(preparePathMorph(x.path, y.path, sub3, x.m, y.m));
+      opacities.push([x.opacity, y.opacity]);
+    } else if (x) {
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub3, x.m, IDENTITY_MATRIX));
+      opacities.push([x.opacity, x.opacity]);
+    } else if (y) {
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub3, IDENTITY_MATRIX, y.m));
+      opacities.push([y.opacity, y.opacity]);
+    }
+  }
+  return {
+    at: (t) => {
+      const children = parts.map((p, i) => {
+        const n = p(t);
+        const o = lerpN(opacities[i][0], opacities[i][1], t) * (_nullishCoalesce(n.opacity, () => ( 1)));
+        if (o < 1) n.opacity = o;
+        else delete n.opacity;
+        return n;
+      });
+      const group = { id, type: "group", children };
+      return group;
+    }
+  };
+}
+function interpolateVectorPaths(a, b, t, options = {}) {
+  return createVectorMorph(a, b, options).at(t);
+}
+var keyframeMorphs = /* @__PURE__ */ new WeakMap();
+function evaluateVectorPathKeyframes(keyframes, time, options = {}) {
+  const keys = keyframes.filter((k) => Number.isFinite(k.time)).sort((x, y) => x.time - y.time);
+  if (!keys.length) return null;
+  if (!(time > keys[0].time)) return keys[0].value;
+  const last = keys[keys.length - 1];
+  if (time >= last.time) return last.value;
+  let i = 0;
+  while (i + 1 < keys.length && keys[i + 1].time <= time) i++;
+  const a = keys[i];
+  const b = keys[i + 1];
+  if (time === a.time) return a.value;
+  if (a.easing === "hold") return a.value;
+  const span = b.time - a.time;
+  const u = Math.min(1, Math.max(0, _chunkXZ4L3R4Kcjs.evaluateEasing.call(void 0, a.easing, (time - a.time) / span, span)));
+  let inner = keyframeMorphs.get(a.value);
+  if (!inner) keyframeMorphs.set(a.value, inner = /* @__PURE__ */ new WeakMap());
+  let morph = inner.get(b.value);
+  if (!morph) inner.set(b.value, morph = createVectorMorph(a.value, b.value, options));
+  return morph.at(u);
+}
+
+// src/vector/blendGroup.ts
+var DEFAULT_VECTOR_BLEND_STEPS = 5;
+var DEFAULT_VECTOR_BLEND_DISTANCE = 20;
+var VECTOR_BLEND_MAX_STEPS = 1e3;
+var VECTOR_BLEND_MAX_SMOOTH_STEPS = 256;
+function isVectorBlendGroup(node) {
+  return !!node && node.type === "group" && !!node.blend;
+}
+function vectorBlendKeys(group) {
+  return group.children.filter((c) => !c.blendStep);
+}
+function resolveVectorBlendOptions(options) {
+  return {
+    spacing: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.spacing]), () => ( "steps")),
+    steps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.steps]), () => ( DEFAULT_VECTOR_BLEND_STEPS)),
+    distance: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.distance]), () => ( DEFAULT_VECTOR_BLEND_DISTANCE)),
+    orientToSpine: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.orientToSpine]), () => ( false)),
+    linear: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _55 => _55.linear]), () => ( false))
+  };
+}
+function paintColors(p) {
+  if (typeof p === "string") return [p];
+  if (p && typeof p === "object") return p.stops.map((s) => s.color);
+  return [];
+}
+function vectorBlendColorDistance(a, b) {
+  const pa = collectPathNodes(a)[0];
+  const pb = collectPathNodes(b)[0];
+  if (!pa || !pb) return 0;
+  let d = 0;
+  for (const key of ["fill", "stroke"]) {
+    const ca = paintColors(pa[key]);
+    const cb = paintColors(pb[key]);
+    ca.forEach((c, i) => {
+      const other = _nullishCoalesce(cb[i], () => ( cb[0]));
+      if (other === void 0) return;
+      const x = _chunkA6PHCAGXcjs.hexToRgba.call(void 0, c);
+      const y = _chunkA6PHCAGXcjs.hexToRgba.call(void 0, other);
+      if (!x || !y) return;
+      d = Math.max(d, Math.abs(x.r - y.r), Math.abs(x.g - y.g), Math.abs(x.b - y.b), Math.abs(x.a - y.a));
+    });
+  }
+  return d;
+}
+var centreOf = (n) => {
+  const b = vectorNodeBounds(n);
+  return b ? [b.x + b.width / 2, b.y + b.height / 2] : [0, 0];
+};
+function vectorBlendStepCount(a, b, options, length2) {
+  const o = resolveVectorBlendOptions(options);
+  if (o.spacing === "distance") {
+    const d = Math.max(0.01, o.distance);
+    return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(0, Math.round(length2 / d) - 1));
+  }
+  if (o.spacing === "smoothColor") {
+    const cd = vectorBlendColorDistance(a, b);
+    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)));
+  }
+  return Math.min(VECTOR_BLEND_MAX_STEPS, Math.max(1, Math.round(Number.isFinite(o.steps) ? o.steps : DEFAULT_VECTOR_BLEND_STEPS)));
+}
+function vectorBlendRail(sp) {
+  const pts = [];
+  const angles = [];
+  const push = (p, tangent2) => {
+    const last = pts[pts.length - 1];
+    if (last && Math.hypot(p[0] - last[0], p[1] - last[1]) < 1e-9) return;
+    pts.push(p);
+    angles.push(Math.atan2(tangent2[1], tangent2[0]));
+  };
+  const count = subpathSegmentCount(sp);
+  for (let i = 0; i < count; i++) {
+    const seg = subpathSegment(sp, i);
+    const samples = seg.length === 2 ? 1 : 32;
+    if (i === 0) push(seg[0], _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, 0));
+    for (let k = 1; k <= samples; k++) push(_chunkVNYRI265cjs.segmentPoint.call(void 0, seg, k / samples), _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, k / samples));
+  }
+  if (pts.length < 2) return null;
+  const cum = [0];
+  for (let i = 1; i < pts.length; i++) cum.push(cum[i - 1] + Math.hypot(pts[i][0] - pts[i - 1][0], pts[i][1] - pts[i - 1][1]));
+  return { pts, cum, angles, total: cum[cum.length - 1], closed: sp.closed };
+}
+function vectorBlendRailAt(rail, s) {
+  let len2 = Number.isFinite(s) ? s : 0;
+  if (rail.closed && rail.total > 0) len2 = (len2 % rail.total + rail.total) % rail.total;
+  len2 = Math.min(rail.total, Math.max(0, len2));
+  let lo = 0;
+  let hi = rail.cum.length - 1;
+  while (hi - lo > 1) {
+    const mid = lo + hi >> 1;
+    if (rail.cum[mid] <= len2) lo = mid;
+    else hi = mid;
+  }
+  const span = rail.cum[hi] - rail.cum[lo];
+  const u = span > 1e-12 ? (len2 - rail.cum[lo]) / span : 0;
+  const a = rail.pts[lo];
+  const b = rail.pts[hi];
+  return { point: [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u], angle: Math.atan2(b[1] - a[1], b[0] - a[0]) };
+}
+function vectorBlendSpine(group) {
+  const keys = vectorBlendKeys(group);
+  if (keys.length < 2) return null;
+  const stored = _optionalChain([group, 'access', _56 => _56.blend, 'optionalAccess', _57 => _57.spine]);
+  if (stored && stored.anchors.length >= 2) {
+    const rail2 = vectorBlendRail(stored);
+    if (rail2) {
+      const end = rail2.closed ? rail2.total * (1 - 1 / keys.length) : rail2.total;
+      return { spine: stored, rail: rail2, stops: keys.map((_, i) => end * i / (keys.length - 1)), replaced: true };
+    }
+  }
+  const centres = keys.map(centreOf);
+  const spine = { closed: false, anchors: centres.map((c) => ({ x: c[0], y: c[1] })) };
+  const stops = [0];
+  for (let i = 1; i < centres.length; i++) stops.push(stops[i - 1] + Math.hypot(centres[i][0] - centres[i - 1][0], centres[i][1] - centres[i - 1][1]));
+  const rail = _nullishCoalesce(vectorBlendRail(spine), () => ( { pts: centres, cum: stops, angles: centres.map(() => 0), total: stops[stops.length - 1], closed: false }));
+  return { spine, rail, stops, replaced: false };
+}
+function vectorBlendKeyTargets(group) {
+  const s = vectorBlendSpine(group);
+  return s ? s.stops.map((stop) => vectorBlendRailAt(s.rail, stop).point) : [];
+}
+var morphCache = /* @__PURE__ */ new WeakMap();
+function morphFor(a, b, blend) {
+  const starts = [_nullishCoalesce(_optionalChain([blend, 'access', _58 => _58.starts, 'optionalAccess', _59 => _59[a.id]]), () => ( null)), _nullishCoalesce(_optionalChain([blend, 'access', _60 => _60.starts, 'optionalAccess', _61 => _61[b.id]]), () => ( null))];
+  const key = JSON.stringify([!!blend.linear, starts]);
+  let inner = morphCache.get(a);
+  if (!inner) morphCache.set(a, inner = /* @__PURE__ */ new WeakMap());
+  let byKey = inner.get(b);
+  if (!byKey) inner.set(b, byKey = /* @__PURE__ */ new Map());
+  let morph = byKey.get(key);
+  if (!morph) byKey.set(key, morph = createVectorMorph(a, b, { linear: blend.linear, starts }));
+  return morph;
+}
+var wrapAngle = (a) => Math.atan2(Math.sin(a), Math.cos(a));
+function asStep(node, id) {
+  const rename = (n, nid) => n.type === "group" ? { ...n, id: nid, children: n.children.map((c, i) => rename(c, `${nid}.${i}`)) } : { ...n, id: nid };
+  return { ...rename(node, id), blendStep: true, locked: true };
+}
+function generateVectorBlendChildren(group) {
+  const keys = vectorBlendKeys(group);
+  const blend = group.blend;
+  if (!blend || keys.length < 2) return keys;
+  const spine = vectorBlendSpine(group);
+  if (!spine) return keys;
+  const out = [];
+  let counter = 0;
+  keys.forEach((a, i) => {
+    out.push(a);
+    const b = keys[i + 1];
+    if (!b) return;
+    const s0 = spine.stops[i];
+    const s1 = spine.stops[i + 1];
+    const n = vectorBlendStepCount(a, b, blend, Math.abs(s1 - s0));
+    const morph = morphFor(a, b, blend);
+    const p0 = vectorBlendRailAt(spine.rail, s0);
+    const p1 = vectorBlendRailAt(spine.rail, s1);
+    for (let j = 1; j <= n; j++) {
+      const t = j / (n + 1);
+      let step = morph.at(t);
+      if (spine.replaced) {
+        const p = vectorBlendRailAt(spine.rail, s0 + (s1 - s0) * t);
+        const dx = p.point[0] - (p0.point[0] + (p1.point[0] - p0.point[0]) * t);
+        const dy = p.point[1] - (p0.point[1] + (p1.point[1] - p0.point[1]) * t);
+        let m = Math.hypot(dx, dy) > 1e-9 ? translateMatrix(dx, dy) : IDENTITY_MATRIX;
+        if (blend.orientToSpine) {
+          const turn = wrapAngle(p.angle - (p0.angle + wrapAngle(p1.angle - p0.angle) * t));
+          if (Math.abs(turn) > 1e-9) {
+            const c = centreOf(step);
+            const origin = { x: c[0] + m[4], y: c[1] + m[5] };
+            m = multiplyMatrices(m, rotateMatrix(turn * 180 / Math.PI, origin));
+          }
+        }
+        if (m !== IDENTITY_MATRIX) step = transformVectorNode(step, m);
+      }
+      out.push(asStep(step, `${group.id}~${++counter}`));
+    }
+  });
+  return out;
+}
+var childrenCache = /* @__PURE__ */ new WeakMap();
+var sameList = (a, b) => a.length === b.length && a.every((n, i) => n === b[i]);
+function blendChildren(group) {
+  const keys = vectorBlendKeys(group);
+  const sig = `${group.id}|${JSON.stringify(group.blend)}`;
+  const cached = keys[0] ? childrenCache.get(keys[0]) : void 0;
+  let children;
+  if (cached && cached.sig === sig && sameList(cached.keys, keys)) children = cached.children;
+  else {
+    children = generateVectorBlendChildren(group);
+    if (keys[0]) childrenCache.set(keys[0], { sig, keys, children });
+  }
+  return sameList(children, group.children) ? group.children : children;
+}
+function refreshVectorBlends(nodes) {
+  let changed = false;
+  const out = nodes.map((n) => {
+    if (n.type !== "group") return n;
+    const inner = refreshVectorBlends(n.children);
+    let next = inner === n.children ? n : { ...n, children: inner };
+    if (next.blend) {
+      const children = blendChildren(next);
+      if (children !== next.children) next = { ...next, children };
+    }
+    if (next !== n) changed = true;
+    return next;
+  });
+  return changed ? out : nodes;
+}
+function plain2(node, newId) {
+  const { blendStep: _s, locked: _l, ...rest } = node;
+  const renamed = { ...rest, id: newId() };
+  if (renamed.type === "group") renamed.children = renamed.children.map((c) => plain2(c, newId));
+  return renamed;
+}
+function expandVectorBlend(group, newId) {
+  const { blend: _b, ...rest } = group;
+  return { ...rest, children: group.children.map((c) => c.blendStep ? plain2(c, newId) : c) };
+}
+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', _62 => _62.blend, 'optionalAccess', _63 => _63.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/snap.ts
 var VECTOR_CONSTRUCTION_ANGLES = [0, 45, 90, 135];
 function constrainToLeave(leave, p) {
-  if (!_optionalChain([leave, 'optionalAccess', _43 => _43.constrain])) return p;
+  if (!_optionalChain([leave, 'optionalAccess', _64 => _64.constrain])) return p;
   const dx = p.x - leave.at.x;
   const dy = p.y - leave.at.y;
   switch (leave.constrain) {
@@ -2139,7 +3098,7 @@ var VectorSnapTargets = (_class = 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', _44 => _44.get, 'call', _45 => _45(id), 'optionalAccess', _46 => _46.has, 'call', _47 => _47(`${s}:${i}`)]), true);
+    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _65 => _65.get, 'call', _66 => _66(id), 'optionalAccess', _67 => _67.has, 'call', _68 => _68(`${s}:${i}`)]), true);
     return t.index();
   }
   /**
@@ -2257,7 +3216,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
         }
         const b = vectorNodeBounds(n, parent);
         const f = nodeFrame(n, parent, b);
-        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _48 => _48.centre]), () => ( null)));
+        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _69 => _69.centre]), () => ( null)));
       }
     };
     visit(doc.nodes, IDENTITY_MATRIX);
@@ -2302,7 +3261,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       lines: lines2,
       labels: [this.label(q, kind)]
     });
-    if (_optionalChain([leave, 'optionalAccess', _49 => _49.constrain])) {
+    if (_optionalChain([leave, 'optionalAccess', _70 => _70.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);
@@ -2318,7 +3277,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     }
     const on = this.onSegment(near2);
     if (on) return at2(on, "path");
-    if (_optionalChain([leave, 'optionalAccess', _50 => _50.angles, 'optionalAccess', _51 => _51.length])) {
+    if (_optionalChain([leave, 'optionalAccess', _71 => _71.angles, 'optionalAccess', _72 => _72.length])) {
       const c = construction(leave, p, tol);
       if (c) {
         const hit = this.slide(leave.at, c.dir, c.point, tol, false);
@@ -2448,7 +3407,7 @@ var VectorSnapTargets = (_class = 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', _52 => _52.axes, 'optionalAccess', _53 => _53.x]) !== false, y: _optionalChain([options, 'access', _54 => _54.axes, 'optionalAccess', _55 => _55.y]) !== false };
+    const axes = { x: _optionalChain([options, 'access', _73 => _73.axes, 'optionalAccess', _74 => _74.x]) !== false, y: _optionalChain([options, 'access', _75 => _75.axes, 'optionalAccess', _76 => _76.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 };
@@ -2456,7 +3415,7 @@ var VectorSnapTargets = (_class = 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', _56 => _56.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _57 => _57.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
+    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _77 => _77.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _78 => _78.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;
@@ -2554,14 +3513,14 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
    * corner) slides along it until one of them is on a target. An axis that snaps to nothing
    * may match another object's width or height instead.
    */
-  snapScale(frame, handle, sx, sy, mods, tol) {
-    const toDoc = frame.angle ? rotateMatrix(frame.angle) : IDENTITY_MATRIX;
-    const toLocal = frame.angle ? rotateMatrix(-frame.angle) : IDENTITY_MATRIX;
+  snapScale(frame2, handle, sx, sy, mods, tol) {
+    const toDoc = frame2.angle ? rotateMatrix(frame2.angle) : IDENTITY_MATRIX;
+    const toLocal = frame2.angle ? rotateMatrix(-frame2.angle) : IDENTITY_MATRIX;
     const corner = handle.length === 2;
     const proportional = !!mods.shift;
-    const centre = { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 };
-    const origin = mods.alt ? centre : handlePos(opposite(handle), frame);
-    const hp = handlePos(handle, frame);
+    const centre = { x: frame2.x + frame2.width / 2, y: frame2.y + frame2.height / 2 };
+    const origin = mods.alt ? centre : handlePos(opposite(handle), frame2);
+    const hp = handlePos(handle, frame2);
     const d0 = { x: hp.x - origin.x, y: hp.y - origin.y };
     const valid = (n, s) => Number.isFinite(n) && n * s > 0;
     const nearest = (v2, lines) => {
@@ -2579,15 +3538,15 @@ var VectorSnapTargets = (_class = 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', _58 => _58.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _59 => _59.v]), () => ( null)), s: { hx, hy, on: null } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _60 => _60.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
-      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _61 => _61.v]), () => ( null)), s: { hx: null, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _79 => _79.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _80 => _80.v]), () => ( null)), s: { hx, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _81 => _81.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
+      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _82 => _82.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)) });
         let cx = (q.x - origin.x) / d0.x;
         let cy = (q.y - origin.y) / d0.y;
-        if (!frame.angle) {
+        if (!frame2.angle) {
           if (tx === null) cx = sx;
           if (ty === null) cy = sy;
         }
@@ -2616,7 +3575,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
         if (!best || (inLine === best.inLine ? moved < best.moved : !inLine)) best = { s, inLine, moved, snap: found2 };
       };
       for (const h of [handle, ...ends]) {
-        const hv = handlePos(h, frame);
+        const hv = handlePos(h, frame2);
         const v2 = { x: hv.x - origin.x, y: hv.y - origin.y };
         const base = applyMatrix(toDoc, { x: origin.x + c.x * v2.x, y: origin.y + c.y * v2.y });
         const dir = applyMatrix(toDoc, { x: e.x * v2.x, y: e.y * v2.y });
@@ -2651,25 +3610,25 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     const movesY = handle !== "e" && handle !== "w";
     const sized = [];
     if (!proportional) {
-      if (movesX && !snap.hx && !(frame.angle && snap.hy) && frame.width > 1e-9) {
-        const len2 = this.matchSize(Math.abs(out.sx) * frame.width, tol);
+      if (movesX && !snap.hx && !(frame2.angle && snap.hy) && frame2.width > 1e-9) {
+        const len2 = this.matchSize(Math.abs(out.sx) * frame2.width, tol);
         if (len2 !== null && len2 > 0) {
-          out.sx = Math.sign(out.sx || 1) * (len2 / frame.width);
+          out.sx = Math.sign(out.sx || 1) * (len2 / frame2.width);
           sized.push("x");
         }
       }
-      if (movesY && !snap.hy && !(frame.angle && snap.hx) && frame.height > 1e-9) {
-        const len2 = this.matchSize(Math.abs(out.sy) * frame.height, tol);
+      if (movesY && !snap.hy && !(frame2.angle && snap.hx) && frame2.height > 1e-9) {
+        const len2 = this.matchSize(Math.abs(out.sy) * frame2.height, tol);
         if (len2 !== null && len2 > 0) {
-          out.sy = Math.sign(out.sy || 1) * (len2 / frame.height);
+          out.sy = Math.sign(out.sy || 1) * (len2 / frame2.height);
           sized.push("y");
         }
       }
     }
-    const x0 = origin.x + (frame.x - origin.x) * out.sx;
-    const x1 = origin.x + (frame.x + frame.width - origin.x) * out.sx;
-    const y0 = origin.y + (frame.y - origin.y) * out.sy;
-    const y1 = origin.y + (frame.y + frame.height - origin.y) * out.sy;
+    const x0 = origin.x + (frame2.x - origin.x) * out.sx;
+    const x1 = origin.x + (frame2.x + frame2.width - origin.x) * out.sx;
+    const y0 = origin.y + (frame2.y - origin.y) * out.sy;
+    const y1 = origin.y + (frame2.y + frame2.height - origin.y) * out.sy;
     const box = { x0: Math.min(x0, x1), x1: Math.max(x0, x1), y0: Math.min(y0, y1), y1: Math.max(y0, y1) };
     const page = [
       { x: box.x0, y: box.y0 },
@@ -3958,6 +4917,15 @@ var DEFAULT_VECTOR_PATH_EDIT = {
   fillGap: 0
 };
 var VECTOR_PENCIL_STRING_PX = 100;
+function blendOptionsOf(input) {
+  const out = {};
+  if (input.spacing === "steps" || input.spacing === "distance" || input.spacing === "smoothColor") out.spacing = input.spacing;
+  if (typeof input.steps === "number" && Number.isFinite(input.steps)) out.steps = Math.min(1e3, Math.max(1, Math.round(input.steps)));
+  if (typeof input.distance === "number" && Number.isFinite(input.distance) && input.distance > 0) out.distance = input.distance;
+  if (typeof input.orientToSpine === "boolean") out.orientToSpine = input.orientToSpine;
+  if (typeof input.linear === "boolean") out.linear = input.linear;
+  return out;
+}
 var VECTOR_STYLE_KEYS = [
   "fill",
   "stroke",
@@ -4001,7 +4969,7 @@ function getEditablePathIds(state) {
       }
     }
   }
-  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _62 => _62(state.document.nodes, id), 'optionalAccess', _63 => _63.type]) === "path");
+  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _83 => _83(state.document.nodes, id), 'optionalAccess', _84 => _84.type]) === "path");
 }
 function getVisibleAnchors(state) {
   const out = [];
@@ -4016,7 +4984,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', _64 => _64.anchors, 'access', _65 => _65[i]]);
+    const a = _optionalChain([sp, 'optionalAccess', _85 => _85.anchors, 'access', _86 => _86[i]]);
     if (!a || !a[handle]) return;
     const key = `${node.id}:${s}:${i}:${handle}`;
     if (seen.has(key)) return;
@@ -4025,8 +4993,8 @@ function getVisibleHandles(state) {
   };
   if (state.tool === "pen" && state.pen) {
     const node = findVectorNode(state.document.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _66 => _66.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
-    if (_optionalChain([node, 'optionalAccess', _67 => _67.type]) === "path" && sp) {
+    const sp = _optionalChain([node, 'optionalAccess', _87 => _87.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    if (_optionalChain([node, 'optionalAccess', _88 => _88.type]) === "path" && sp) {
       const last = sp.anchors.length - 1;
       push(node, state.pen.subpath, last, "in");
       push(node, state.pen.subpath, last, "out");
@@ -4064,11 +5032,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', _68 => _68.corner, 'optionalAccess', _69 => _69.radius]), () => ( 0));
+      const radius = _nullishCoalesce(_optionalChain([a, 'access', _89 => _89.corner, 'optionalAccess', _90 => _90.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', _70 => _70.corner, 'optionalAccess', _71 => _71.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', _91 => _91.corner, 'optionalAccess', _92 => _92.kind]), () => ( "round")), corner: c });
     }
   }
   return out;
@@ -4078,6 +5046,12 @@ function vectorStrokeWidthGeometry(node) {
   const parts = vectorStrokeParts(subpathsToBezier(node.subpaths), node);
   return parts.line.length ? { line: parts.line, unit: parts.drawWidth / 2 } : null;
 }
+function shiftWidthPoints(profile, indices, dt) {
+  const moving = new Set(indices);
+  const tagged = profile.map((p, i) => ({ p: moving.has(i) ? { ...p, t: Math.min(Math.max(p.t + dt, 0), 1) } : { ...p }, i }));
+  tagged.sort((a, b) => a.p.t - b.p.t || a.i - b.i);
+  return { points: tagged.map((x) => x.p), renumber: new Map(tagged.map((x, k) => [x.i, k])) };
+}
 function getVectorWidthHandles(state) {
   if (state.tool !== "width") return [];
   const ids = /* @__PURE__ */ new Set();
@@ -4085,13 +5059,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', _72 => _72.hover, 'optionalAccess', _73 => _73.nodeId])) ids.add(state.hover.nodeId);
-  if (_optionalChain([state, 'access', _74 => _74.interaction, 'optionalAccess', _75 => _75.type]) === "width") ids.add(state.interaction.ref.nodeId);
-  if (state.selectedWidthPoint) ids.add(state.selectedWidthPoint.nodeId);
+  if (_optionalChain([state, 'access', _93 => _93.hover, 'optionalAccess', _94 => _94.nodeId])) ids.add(state.hover.nodeId);
+  if (_optionalChain([state, 'access', _95 => _95.interaction, 'optionalAccess', _96 => _96.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', _76 => _76.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _77 => _77.strokeWidthProfile, 'optionalAccess', _78 => _78.length])) continue;
+    if (_optionalChain([node, 'optionalAccess', _97 => _97.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _98 => _98.strokeWidthProfile, 'optionalAccess', _99 => _99.length])) continue;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) continue;
     const profile = sanitizeWidthProfile(node.strokeWidthProfile);
@@ -4106,7 +5080,6 @@ function getVectorWidthHandles(state) {
         const p = applyMatrix(m, c);
         const l = applyMatrix(m, { x: c.x + n.x * w.left * g.unit, y: c.y + n.y * w.left * g.unit });
         const r = applyMatrix(m, { x: c.x - n.x * w.right * g.unit, y: c.y - n.y * w.right * g.unit });
-        const sel = state.selectedWidthPoint;
         out.push({
           ref: { nodeId: id, index, subpath: sp },
           x: p.x,
@@ -4116,7 +5089,7 @@ function getVectorWidthHandles(state) {
           t: w.t,
           leftScale: w.left,
           rightScale: w.right,
-          selected: !!sel && sel.nodeId === id && sel.index === index
+          selected: state.selectedWidthPoints.some((r2) => r2.nodeId === id && r2.index === index)
         });
       });
     }
@@ -4125,7 +5098,7 @@ function getVectorWidthHandles(state) {
 }
 function getAnchor(doc, ref) {
   const node = findVectorNode(doc.nodes, ref.nodeId);
-  return _optionalChain([node, 'optionalAccess', _79 => _79.type]) === "path" ? _optionalChain([node, 'access', _80 => _80.subpaths, 'access', _81 => _81[ref.subpath], 'optionalAccess', _82 => _82.anchors, 'access', _83 => _83[ref.index]]) : void 0;
+  return _optionalChain([node, 'optionalAccess', _100 => _100.type]) === "path" ? _optionalChain([node, 'access', _101 => _101.subpaths, 'access', _102 => _102[ref.subpath], 'optionalAccess', _103 => _103.anchors, 'access', _104 => _104[ref.index]]) : void 0;
 }
 function getAnchorWorld(doc, ref) {
   const a = getAnchor(doc, ref);
@@ -4159,11 +5132,11 @@ function getTransformHandlePositions(box) {
     { handle: "rotate", x: x + w / 2, y: y - VECTOR_ROTATE_HANDLE_OFFSET }
   ];
 }
-function getVectorSelectionBoxGeometry(frame, viewport) {
+function getVectorSelectionBoxGeometry(frame2, viewport) {
   const z = viewport.zoom;
-  const box = { x: frame.x * z + viewport.x, y: frame.y * z + viewport.y, width: frame.width * z, height: frame.height * z };
-  const rot = rotateMatrix(frame.angle, { x: viewport.x, y: viewport.y });
-  const toScreen2 = (p) => frame.angle ? applyMatrix(rot, p) : { x: p.x, y: p.y };
+  const box = { x: frame2.x * z + viewport.x, y: frame2.y * z + viewport.y, width: frame2.width * z, height: frame2.height * z };
+  const rot = rotateMatrix(frame2.angle, { x: viewport.x, y: viewport.y });
+  const toScreen2 = (p) => frame2.angle ? applyMatrix(rot, p) : { x: p.x, y: p.y };
   const handles = getTransformHandlePositions(box).map((h) => ({ ...h, screen: toScreen2(h) }));
   const corners2 = [
     { x: box.x, y: box.y },
@@ -4172,7 +5145,7 @@ function getVectorSelectionBoxGeometry(frame, viewport) {
     { x: box.x, y: box.y + box.height }
   ].map(toScreen2);
   const r = (n) => Math.round(n * 1e3) / 1e3;
-  return { box, angle: frame.angle, transform: frame.angle ? `rotate(${r(frame.angle)} ${r(viewport.x)} ${r(viewport.y)})` : "", handles, corners: corners2 };
+  return { box, angle: frame2.angle, transform: frame2.angle ? `rotate(${r(frame2.angle)} ${r(viewport.x)} ${r(viewport.y)})` : "", handles, corners: corners2 };
 }
 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 };
@@ -4196,7 +5169,8 @@ var TOOL_LABELS = {
   eraser: "Eraser",
   width: "Width",
   shapeBuilder: "Shape Builder",
-  paintBucket: "Paint Bucket"
+  paintBucket: "Paint Bucket",
+  blend: "Blend"
 };
 var TOOL_KEYS = {
   v: "select",
@@ -4213,7 +5187,8 @@ var TOOL_KEYS = {
   e: "eraser",
   w: "width",
   m: "shapeBuilder",
-  b: "paintBucket"
+  b: "paintBucket",
+  j: "blend"
 };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
@@ -4233,7 +5208,8 @@ var VECTOR_TOOL_SHORTCUTS = {
   eraser: "E",
   width: "W",
   shapeBuilder: "M",
-  paintBucket: "B"
+  paintBucket: "B",
+  blend: "J"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -4250,7 +5226,8 @@ var VECTOR_TOOL_GLYPHS = {
   eraser: "\u232B",
   width: "\u21F9",
   shapeBuilder: "\u2295",
-  paintBucket: "\u25CD"
+  paintBucket: "\u25CD",
+  blend: "\u29D3"
 };
 var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line"]);
 var BOOLEAN_OPS = {
@@ -4312,45 +5289,50 @@ var VectorEditorController = (_class3 = class {
   
   __init9() {this.selection = []}
   __init10() {this.anchors = []}
-  __init11() {this.widthPoint = null}
-  __init12() {this.editingId = null}
-  __init13() {this.pen = null}
+  __init11() {this.widthPoints = []}
+  __init12() {this.widthEdit = null}
+  __init13() {this.editingId = null}
+  __init14() {this.pen = null}
   
   
   
   
   
   
-  __init14() {this.hover = null}
-  __init15() {this.pointer = null}
-  __init16() {this.drag = null}
-  __init17() {this.interaction = null}
-  __init18() {this.guides = null}
+  __init15() {this.hover = null}
+  __init16() {this.pointer = null}
+  __init17() {this.drag = null}
+  __init18() {this.interaction = null}
+  __init19() {this.guides = null}
   /** Whether the last `snapDrawn` landed on an object (guides may be hidden). */
-  __init19() {this.snappedToObject = false}
+  __init20() {this.snappedToObject = false}
   /** Drawing targets for hovering the pen and shape tools, kept while the document and the excluded path stay the same. */
-  __init20() {this.hoverTargets = null}
-  __init21() {this.spaceHeld = false}
-  __init22() {this.clipboard = null}
+  __init21() {this.hoverTargets = null}
+  __init22() {this.spaceHeld = false}
+  __init23() {this.clipboard = null}
   /** Shape Builder map of the selection, kept while the document and the selection stay the same. */
-  __init23() {this.builderCache = null}
+  __init24() {this.builderCache = null}
   /** Paint bucket map of the visible outlines. */
-  __init24() {this.fillCache = null}
-  __init25() {this.builderPreview = null}
+  __init25() {this.fillCache = null}
+  __init26() {this.builderPreview = null}
+  __init27() {this.blendStart = null}
+  /** Options new blends get (the toolbars edit them along with the selected blend's). */
+  __init28() {this.blendDefaults = {}}
   /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
-  __init26() {this.builderHoverKey = null}
+  __init29() {this.builderHoverKey = null}
   
   
-  __init27() {this.listeners = /* @__PURE__ */ new Set()}
-  __init28() {this.cleanups = []}
-  __init29() {this.applying = false}
+  __init30() {this.listeners = /* @__PURE__ */ new Set()}
+  __init31() {this.cleanups = []}
+  __init32() {this.applying = false}
   /** Set while a commit records a change that was already applied, so `restore` still reports it. */
-  __init30() {this.committing = false}
-  __init31() {this.revision = 0}
+  __init33() {this.committing = false}
+  __init34() {this.revision = 0}
   
-  constructor(options = {}) {;_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);_class3.prototype.__init24.call(this);_class3.prototype.__init25.call(this);_class3.prototype.__init26.call(this);_class3.prototype.__init27.call(this);_class3.prototype.__init28.call(this);_class3.prototype.__init29.call(this);_class3.prototype.__init30.call(this);_class3.prototype.__init31.call(this);_class3.prototype.__init32.call(this);_class3.prototype.__init33.call(this);
+  constructor(options = {}) {;_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);_class3.prototype.__init24.call(this);_class3.prototype.__init25.call(this);_class3.prototype.__init26.call(this);_class3.prototype.__init27.call(this);_class3.prototype.__init28.call(this);_class3.prototype.__init29.call(this);_class3.prototype.__init30.call(this);_class3.prototype.__init31.call(this);_class3.prototype.__init32.call(this);_class3.prototype.__init33.call(this);_class3.prototype.__init34.call(this);_class3.prototype.__init35.call(this);_class3.prototype.__init36.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);
     this.tool = _nullishCoalesce(options.tool, () => ( "select"));
     this.defaults = { ...DEFAULT_DEFAULTS, ..._nullishCoalesce(options.defaults, () => ( {})) };
     this.viewport = { x: 0, y: 0, zoom: 1, ..._nullishCoalesce(options.viewport, () => ( {})) };
@@ -4377,9 +5359,9 @@ var VectorEditorController = (_class3 = class {
   // State
   // -------------------------------------------------------------------------
   /** The current snapshot (stable until the next change). */
-  __init32() {this.getState = () => this.state}
+  __init35() {this.getState = () => this.state}
   /** Calls `listener` after every change. Returns an unsubscribe function. */
-  __init33() {this.subscribe = (listener) => {
+  __init36() {this.subscribe = (listener) => {
     this.listeners.add(listener);
     return () => {
       this.listeners.delete(listener);
@@ -4398,7 +5380,8 @@ var VectorEditorController = (_class3 = class {
       tool: this.tool,
       selection: this.selection,
       selectedAnchors: this.anchors,
-      selectedWidthPoint: this.widthPoint,
+      selectedWidthPoints: this.widthPoints,
+      widthPointEdit: this.widthEdit,
       editingId: this.editingId,
       selectionBounds: this.boundsOf(this.selection),
       selectionFrame: this.frameOf(this.selectedRoots()),
@@ -4414,6 +5397,8 @@ var VectorEditorController = (_class3 = class {
       pen: this.pen,
       pointer: this.pointer,
       builder: this.builderPreview,
+      blendStart: this.blendStart,
+      blendDefaults: this.blendDefaults,
       canUndo: h.canUndo,
       canRedo: h.canRedo,
       undoLabel: h.undoName,
@@ -4421,10 +5406,18 @@ var VectorEditorController = (_class3 = class {
       revision: this.revision
     };
   }
+  /** `doc` with its blends' steps brought up to date (the same object when they already are). */
+  refreshed(doc) {
+    const nodes = refreshVectorBlends(doc.nodes);
+    return nodes === doc.nodes ? doc : { ...doc, nodes };
+  }
   notify(docChanged = false) {
+    const fresh = this.refreshed(this.doc);
+    if (fresh !== this.doc) this.doc = fresh;
+    if (this.blendStart && !this.getNode(this.blendStart.nodeId)) this.blendStart = null;
     this.revision++;
     this.state = this.computeState();
-    if (docChanged) _optionalChain([this, 'access', _84 => _84.onChange, 'optionalCall', _85 => _85(this.doc)]);
+    if (docChanged) _optionalChain([this, 'access', _105 => _105.onChange, 'optionalCall', _106 => _106(this.doc)]);
     const state = this.state;
     this.listeners.forEach((listener) => {
       try {
@@ -4454,29 +5447,31 @@ var VectorEditorController = (_class3 = class {
     return applyMatrix(invertMatrix(this.worldOf(id, doc)), p);
   }
   cursorFor() {
-    if (_optionalChain([this, 'access', _86 => _86.drag, 'optionalAccess', _87 => _87.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
-    if (_optionalChain([this, 'access', _88 => _88.drag, 'optionalAccess', _89 => _89.kind]) === "rotate") return "grabbing";
-    if (_optionalChain([this, 'access', _90 => _90.drag, 'optionalAccess', _91 => _91.kind]) === "move") return "move";
+    if (_optionalChain([this, 'access', _107 => _107.drag, 'optionalAccess', _108 => _108.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
+    if (_optionalChain([this, 'access', _109 => _109.drag, 'optionalAccess', _110 => _110.kind]) === "rotate") return "grabbing";
+    if (_optionalChain([this, 'access', _111 => _111.drag, 'optionalAccess', _112 => _112.kind]) === "move") return "move";
     const h = this.hover;
     switch (this.tool) {
       case "select":
-        if (_optionalChain([h, 'optionalAccess', _92 => _92.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _93 => _93.frameOf, 'call', _94 => _94(this.selectedRoots()), 'optionalAccess', _95 => _95.angle]), () => ( 0)));
-        return _optionalChain([h, 'optionalAccess', _96 => _96.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _113 => _113.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _114 => _114.frameOf, 'call', _115 => _115(this.selectedRoots()), 'optionalAccess', _116 => _116.angle]), () => ( 0)));
+        return _optionalChain([h, 'optionalAccess', _117 => _117.nodeId]) ? "move" : "default";
       case "direct":
-        if (_optionalChain([h, 'optionalAccess', _97 => _97.anchor]) || _optionalChain([h, 'optionalAccess', _98 => _98.handle]) || _optionalChain([h, 'optionalAccess', _99 => _99.corner])) return "pointer";
-        if (_optionalChain([h, 'optionalAccess', _100 => _100.segment])) return "copy";
-        return _optionalChain([h, 'optionalAccess', _101 => _101.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _118 => _118.anchor]) || _optionalChain([h, 'optionalAccess', _119 => _119.handle]) || _optionalChain([h, 'optionalAccess', _120 => _120.corner])) return "pointer";
+        if (_optionalChain([h, 'optionalAccess', _121 => _121.segment])) return "copy";
+        return _optionalChain([h, 'optionalAccess', _122 => _122.nodeId]) ? "move" : "default";
       case "pen":
-        return _optionalChain([h, 'optionalAccess', _102 => _102.anchor]) ? "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _123 => _123.anchor]) ? "pointer" : "crosshair";
       case "width":
-        if (_optionalChain([this, 'access', _103 => _103.drag, 'optionalAccess', _104 => _104.kind]) === "width") return this.drag.mode === "move" ? "grabbing" : "ew-resize";
-        if (_optionalChain([h, 'optionalAccess', _105 => _105.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
-        return _optionalChain([h, 'optionalAccess', _106 => _106.strokeSpot]) ? "copy" : "default";
+        if (_optionalChain([this, 'access', _124 => _124.drag, 'optionalAccess', _125 => _125.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
+        if (_optionalChain([h, 'optionalAccess', _126 => _126.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
+        return _optionalChain([h, 'optionalAccess', _127 => _127.strokeSpot]) ? "copy" : "default";
       case "shapeBuilder":
-        if (!_optionalChain([this, 'access', _107 => _107.builderPreview, 'optionalAccess', _108 => _108.faces, 'access', _109 => _109.length]) && !_optionalChain([this, 'access', _110 => _110.builderPreview, 'optionalAccess', _111 => _111.lines, 'access', _112 => _112.length])) return "crosshair";
+        if (!_optionalChain([this, 'access', _128 => _128.builderPreview, 'optionalAccess', _129 => _129.faces, 'access', _130 => _130.length]) && !_optionalChain([this, 'access', _131 => _131.builderPreview, 'optionalAccess', _132 => _132.lines, 'access', _133 => _133.length])) return "crosshair";
         return this.builderPreview.mode === "erase" ? "not-allowed" : "cell";
       case "paintBucket":
         return this.builderPreview ? "cell" : "crosshair";
+      case "blend":
+        return _optionalChain([h, 'optionalAccess', _134 => _134.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
       default:
         return "crosshair";
     }
@@ -4489,6 +5484,7 @@ var VectorEditorController = (_class3 = class {
   }
   restore(s) {
     const docChanged = s.doc !== this.doc || this.committing;
+    if (!this.committing) this.widthEdit = null;
     this.committing = false;
     this.applying = true;
     try {
@@ -4496,7 +5492,14 @@ var VectorEditorController = (_class3 = 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', _113 => _113.getNode, 'call', _114 => _114(s.pen.nodeId), 'optionalAccess', _115 => _115.subpaths, 'optionalAccess', _116 => _116[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _135 => _135.getNode, 'call', _136 => _136(s.pen.nodeId), 'optionalAccess', _137 => _137.subpaths, 'optionalAccess', _138 => _138[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', _139 => _139.type]) === "path" && !!_optionalChain([n, 'access', _140 => _140.strokeWidthProfile, 'optionalAccess', _141 => _141[r.index]]);
+        });
+        if (kept.length !== this.widthPoints.length) this.widthPoints = kept;
+      }
     } finally {
       this.applying = false;
     }
@@ -4504,6 +5507,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** Records the change from `before` to the current state as one undo step. */
   commit(name, before) {
+    this.doc = this.refreshed(this.doc);
     const after = this.snapshot();
     if (before.doc === after.doc) {
       this.notify();
@@ -4602,9 +5606,11 @@ var VectorEditorController = (_class3 = class {
     this.tool = tool;
     this.hover = null;
     this.guides = null;
-    this.widthPoint = null;
+    this.widthPoints = [];
+    this.widthEdit = null;
     this.builderPreview = null;
     this.builderHoverKey = null;
+    this.blendStart = null;
     if (tool !== "direct") {
       this.anchors = [];
       this.editingId = null;
@@ -4663,7 +5669,7 @@ var VectorEditorController = (_class3 = class {
       if (res.kind) {
         this.snappedToObject = true;
         this.setGuides(res);
-        return _optionalChain([leave, 'optionalAccess', _117 => _117.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', _142 => _142.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);
@@ -4681,14 +5687,14 @@ var VectorEditorController = (_class3 = 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', _118 => _118.getNode, 'call', _119 => _119(this.pen.nodeId), 'optionalAccess', _120 => _120.subpaths, 'access', _121 => _121[this.pen.subpath]]) : void 0;
-      if (this.pen && sp && _optionalChain([this, 'access', _122 => _122.hover, 'optionalAccess', _123 => _123.anchor])) {
+      const sp = this.pen ? _optionalChain([this, 'access', _143 => _143.getNode, 'call', _144 => _144(this.pen.nodeId), 'optionalAccess', _145 => _145.subpaths, 'access', _146 => _146[this.pen.subpath]]) : void 0;
+      if (this.pen && sp && _optionalChain([this, 'access', _147 => _147.hover, 'optionalAccess', _148 => _148.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', _124 => _124.pen, 'optionalAccess', _125 => _125.nodeId]), () => ( null))));
+      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _149 => _149.pen, 'optionalAccess', _150 => _150.nodeId]), () => ( null))));
     }
     if (SHAPE_TOOLS.has(this.tool)) return this.snapDrawn(p, null, input, () => this.drawingTargets(null));
     this.setGuides(null);
@@ -4836,7 +5842,7 @@ var VectorEditorController = (_class3 = 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', _126 => _126.strokeWidthProfile, 'optionalAccess', _127 => _127.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
+    if (_optionalChain([d, 'access', _151 => _151.strokeWidthProfile, 'optionalAccess', _152 => _152.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     return out;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -4878,18 +5884,143 @@ var VectorEditorController = (_class3 = class {
       const p = profile;
       points = p.taper || p.wave ? generateWidthProfile(p) : [];
     }
-    this.widthPoint = null;
+    this.widthPoints = [];
+    this.widthEdit = null;
     return this.setStyle({ strokeWidthProfile: points.length ? points : null }, _nullishCoalesce(options.ids, () => ( this.selection)), { label: points.length ? "Width Profile" : "Uniform Width" });
   }
-  /** Removes one width point of a path's profile (the width tool's Delete). */
+  /** Removes one width point of a path's profile. */
   removeWidthPoint(ref) {
-    const node = this.getNode(ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _128 => _128.type]) !== "path" || !_optionalChain([node, 'access', _129 => _129.strokeWidthProfile, 'optionalAccess', _130 => _130[ref.index]])) return { ok: false, message: "There is no such width point." };
-    const rest = removeWidthPoints(sanitizeWidthProfile(node.strokeWidthProfile), [ref.index]);
-    this.widthPoint = null;
-    this.change("Delete Width Point", () => this.replaceNode(node.id, withStyle(node, { strokeWidthProfile: rest.length ? rest : null })));
+    return this.removeWidthPoints([ref]);
+  }
+  /** Removes width points (default: the selected ones — the width tool's Delete), as one undo step. */
+  removeWidthPoints(refs = this.widthPoints) {
+    const byNode = /* @__PURE__ */ new Map();
+    for (const r of refs) {
+      const node = this.getNode(r.nodeId);
+      if (_optionalChain([node, 'optionalAccess', _153 => _153.type]) !== "path" || !_optionalChain([node, 'access', _154 => _154.strokeWidthProfile, 'optionalAccess', _155 => _155[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." };
+    const count = [...byNode.values()].reduce((n, l) => n + new Set(l).size, 0);
+    this.widthPoints = [];
+    this.widthEdit = null;
+    this.change(count > 1 ? "Delete Width Points" : "Delete Width Point", () => {
+      for (const [id, indices] of byNode) {
+        const node = this.getNode(id);
+        const rest = removeWidthPoints(sanitizeWidthProfile(node.strokeWidthProfile), indices);
+        this.replaceNode(id, withStyle(node, { strokeWidthProfile: rest.length ? rest : null }));
+      }
+    });
+    return { ok: true };
+  }
+  /** Selects width points (width tool); points on other paths than the first are dropped. */
+  selectWidthPoints(refs) {
+    const first = _optionalChain([refs, 'access', _156 => _156[0], 'optionalAccess', _157 => _157.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', _158 => _158.type]) === "path" && _optionalChain([n, 'access', _159 => _159.strokeWidthProfile, 'optionalAccess', _160 => _160[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
+    }
+    this.widthPoints = next;
+    this.notify();
+  }
+  /**
+   * Sets one width point numerically: `index` names an existing point of path `nodeId`, null
+   * (or left out) adds one at `values.t`. `left` / `right` are side widths in document units
+   * (how far the stroke reaches on each side of the path), `t` the position along each subpath
+   * (0–1). A point moved onto another one's `t` makes a step there. Selects the point and
+   * refreshes an open width-point editor; one undo step. Ported from ArtCraft vectorcraft's
+   * Width Point Edit dialog (`crates/tools/src/distort/width.rs`, MIT OR Apache-2.0).
+   */
+  setWidthPoint(target, values) {
+    const node = this.getNode(target.nodeId);
+    if (_optionalChain([node, 'optionalAccess', _161 => _161.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 num = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? v2 : void 0;
+    const t = num(values.t);
+    const left = num(values.left);
+    const right = num(values.right);
+    const scale = (w) => w === void 0 ? void 0 : Math.max(0, w) / g.unit;
+    const profile = sanitizeWidthProfile(node.strokeWidthProfile);
+    let points;
+    let index;
+    const existing = _nullishCoalesce(target.index, () => ( null));
+    if (existing === null) {
+      if (t === void 0) return { ok: false, message: "A new width point needs a position t." };
+      if (profile.length >= VECTOR_WIDTH_PROFILE_MAX_POINTS) return { ok: false, message: "The profile has too many width points." };
+      ({ points, index } = insertWidthPoint(profile.length ? profile : null, t, { left: scale(left), right: scale(right) }, { step: true }));
+    } else {
+      const p = profile[existing];
+      if (!p) return { ok: false, message: "There is no such width point." };
+      const sides2 = { left: _nullishCoalesce(scale(left), () => ( p.left)), right: _nullishCoalesce(scale(right), () => ( p.right)) };
+      const tt = t === void 0 ? p.t : Math.min(Math.max(t, 0), 1);
+      if (Math.abs(tt - p.t) <= VECTOR_WIDTH_SAME_T) {
+        points = setWidthPoint(profile, existing, sides2);
+        index = existing;
+      } else {
+        const rest = removeWidthPoints(profile, [existing]);
+        if (rest.length) ({ points, index } = insertWidthPoint(rest, tt, sides2, { step: true }));
+        else {
+          points = [{ t: tt, ...sides2 }];
+          index = 0;
+        }
+      }
+    }
+    const subpath = _optionalChain([this, 'access', _162 => _162.widthEdit, 'optionalAccess', _163 => _163.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _164 => _164.widthPoints, 'access', _165 => _165.find, 'call', _166 => _166((r) => r.nodeId === node.id), 'optionalAccess', _167 => _167.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', _168 => _168.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
+    this.notify();
     return { ok: true };
   }
+  /**
+   * Opens the width-point editor (what a double-click with the width tool does) on a width
+   * point, or on a spot of a stroke (`t` without `index`: applying it adds a point there).
+   * Returns false when the path has no visible stroke.
+   */
+  openWidthPointEdit(target) {
+    const edit = this.widthEditFor(target.nodeId, _nullishCoalesce(target.subpath, () => ( 0)), _nullishCoalesce(target.index, () => ( null)), _nullishCoalesce(target.t, () => ( null)));
+    if (!edit) return false;
+    this.widthEdit = edit;
+    this.widthPoints = edit.index === null ? [] : [{ nodeId: edit.nodeId, index: edit.index, subpath: edit.subpath }];
+    this.notify();
+    return true;
+  }
+  /** Closes the width-point editor without changing anything. */
+  closeWidthPointEdit() {
+    if (!this.widthEdit) return;
+    this.widthEdit = null;
+    this.notify();
+  }
+  /** Applies `values` to the width point being edited (see `setWidthPoint`) and closes the editor. */
+  commitWidthPointEdit(values) {
+    const edit = this.widthEdit;
+    if (!edit) return { ok: false, message: "No width point is being edited." };
+    const r = this.setWidthPoint({ nodeId: edit.nodeId, index: edit.index }, edit.index === null ? { t: edit.t, ...values } : values);
+    if (r.ok) this.closeWidthPointEdit();
+    return r;
+  }
+  /** 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', _169 => _169.type]) !== "path") return null;
+    const g = vectorStrokeWidthGeometry(node);
+    if (!g) return null;
+    const profile = sanitizeWidthProfile(node.strokeWidthProfile);
+    const p = index === null ? null : profile[index];
+    if (index !== null && !p) return null;
+    const tt = p ? p.t : Math.min(Math.max(_nullishCoalesce(t, () => ( 0)), 0), 1);
+    const sides2 = _nullishCoalesce(p, () => ( widthProfileAt(profile.length ? profile : null, tt)));
+    const sp = Math.min(Math.max(0, subpath), Math.max(0, node.subpaths.length - 1));
+    const at2 = strokePositionPoint(g.line, sp, tt);
+    const round = (v2) => Math.round(v2 * 1e6) / 1e6;
+    const q = at2 ? applyMatrix(this.worldOf(nodeId), { x: at2.point[0], y: at2.point[1] }) : { x: 0, y: 0 };
+    const point = { x: round(q.x), y: round(q.y) };
+    return { nodeId, subpath: sp, index, t: round(tt), left: round(sides2.left * g.unit), right: round(sides2.right * g.unit), point };
+  }
   /**
    * Sets the live corner radius (and optionally the kind) of anchors: `refs`, else the selected
    * anchors (direct tool), else every anchor of the `ids` / selected paths. Radius 0 makes the
@@ -4909,7 +6040,7 @@ var VectorEditorController = (_class3 = 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', _131 => _131.corner, 'optionalAccess', _132 => _132.radius]), () => ( 0)), kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _170 => _170.corner, 'optionalAccess', _171 => _171.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
@@ -5048,10 +6179,10 @@ var VectorEditorController = (_class3 = class {
     return this.selection.filter((id) => {
       let covered = false;
       const loc = locateVectorNode(this.doc.nodes, id);
-      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _133 => _133.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _172 => _172.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _134 => _134(this.doc.nodes, parent.id), 'optionalAccess', _135 => _135.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _173 => _173(this.doc.nodes, parent.id), 'optionalAccess', _174 => _174.parent]), () => ( null));
       }
       return !covered;
     });
@@ -5104,24 +6235,24 @@ var VectorEditorController = (_class3 = class {
     return this.transform(translateMatrix(dx, dy), { ids: options.ids, label: "Move" });
   }
   /** The selection frame's centre in document space. */
-  frameCenter(frame) {
-    return applyMatrix(rotateMatrix(frame.angle), { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 });
+  frameCenter(frame2) {
+    return applyMatrix(rotateMatrix(frame2.angle), { x: frame2.x + frame2.width / 2, y: frame2.y + frame2.height / 2 });
   }
   /**
    * Scales along the selection box's own axes (rotated with the selection when its nodes
    * share a rotation) around `origin` (default: the box centre, in document space).
    */
   scale(sx, sy = sx, options = {}) {
-    const frame = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
-    if (!frame) return { ok: false, message: "Nothing is selected." };
-    const origin = applyMatrix(rotateMatrix(-frame.angle), _nullishCoalesce(options.origin, () => ( this.frameCenter(frame))));
-    return this.transform(this.inFrame(frame.angle, scaleMatrix(sx, sy, origin)), { ids: options.ids, label: "Scale" });
+    const frame2 = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
+    if (!frame2) return { ok: false, message: "Nothing is selected." };
+    const origin = applyMatrix(rotateMatrix(-frame2.angle), _nullishCoalesce(options.origin, () => ( this.frameCenter(frame2))));
+    return this.transform(this.inFrame(frame2.angle, scaleMatrix(sx, sy, origin)), { ids: options.ids, label: "Scale" });
   }
   /** Rotates clockwise by `degrees` around `origin` (default: the selection centre). */
   rotate(degrees, options = {}) {
-    const frame = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
-    if (!frame) return { ok: false, message: "Nothing is selected." };
-    const origin = _nullishCoalesce(options.origin, () => ( this.frameCenter(frame)));
+    const frame2 = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
+    if (!frame2) return { ok: false, message: "Nothing is selected." };
+    const origin = _nullishCoalesce(options.origin, () => ( this.frameCenter(frame2)));
     return this.transform(rotateMatrix(degrees, origin), { ids: options.ids, label: "Rotate" });
   }
   /** Sets each selected (or given) node's rotation to `degrees`, turning it around its own centre. */
@@ -5130,21 +6261,21 @@ var VectorEditorController = (_class3 = class {
     if (!ids.length) return { ok: false, message: "Nothing is selected." };
     this.change("Set Rotation", () => {
       for (const id of ids) {
-        const frame = this.frameOf([id]);
-        if (!frame) continue;
-        const delta = normalizeAngle(degrees - frame.angle);
-        if (Math.abs(delta) > 1e-9) this.doc = this.transformed(this.doc, /* @__PURE__ */ new Set([id]), rotateMatrix(delta, this.frameCenter(frame)));
+        const frame2 = this.frameOf([id]);
+        if (!frame2) continue;
+        const delta = normalizeAngle(degrees - frame2.angle);
+        if (Math.abs(delta) > 1e-9) this.doc = this.transformed(this.doc, /* @__PURE__ */ new Set([id]), rotateMatrix(delta, this.frameCenter(frame2)));
       }
     });
     return { ok: true };
   }
   /** Mirrors along the selection box's own axes. */
   flip(axis, options = {}) {
-    const frame = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
-    if (!frame) return { ok: false, message: "Nothing is selected." };
-    const c = { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 };
+    const frame2 = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
+    if (!frame2) return { ok: false, message: "Nothing is selected." };
+    const c = { x: frame2.x + frame2.width / 2, y: frame2.y + frame2.height / 2 };
     const m = axis === "horizontal" ? scaleMatrix(-1, 1, c) : scaleMatrix(1, -1, c);
-    return this.transform(this.inFrame(frame.angle, m), { ids: options.ids, label: axis === "horizontal" ? "Flip Horizontal" : "Flip Vertical" });
+    return this.transform(this.inFrame(frame2.angle, m), { ids: options.ids, label: axis === "horizontal" ? "Flip Horizontal" : "Flip Vertical" });
   }
   /**
    * Aligns the selected nodes to their combined bounds, or to the artboard when one node is
@@ -5234,8 +6365,8 @@ var VectorEditorController = (_class3 = 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', _136 => _136[0], 'access', _137 => _137.parent, 'optionalAccess', _138 => _138.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _139 => _139.parent, 'optionalAccess', _140 => _140.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _175 => _175[0], 'access', _176 => _176.parent, 'optionalAccess', _177 => _177.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _178 => _178.parent, 'optionalAccess', _179 => _179.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -5258,7 +6389,7 @@ var VectorEditorController = (_class3 = 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', _141 => _141.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _180 => _180.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", () => {
@@ -5271,7 +6402,7 @@ var VectorEditorController = (_class3 = class {
             const opacity = n.opacity;
             const m = nodeMatrix(n);
             out.push(
-              ...n.children.map((c) => n.transform ? transformVectorNode(c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c)
+              ...n.children.map((c) => c.blendStep ? (({ blendStep: _s, locked: _l, ...rest }) => rest)(c) : c).map((c) => n.transform ? transformVectorNode(c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c)
             );
           } else if (n.type === "group") {
             const children = flatten2(n.children);
@@ -5372,7 +6503,7 @@ var VectorEditorController = (_class3 = 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', _142 => _142.type]) === "path" && n.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _181 => _181.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));
@@ -5435,10 +6566,177 @@ var VectorEditorController = (_class3 = class {
     return nodes.map((n) => n.id);
   }
   /** The Shape Builder map of the selected (or given) paths, cached per document and selection. */
+  // -------------------------------------------------------------------------
+  // Blends
+  // -------------------------------------------------------------------------
+  /** Selected (or given) blend groups; a selected key or step counts as its blend. */
+  blendTargets(ids) {
+    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', _182 => _182(this.doc.nodes, id), 'optionalAccess', _183 => _183.parent]);
+      if (isVectorBlendGroup(group)) out.set(group.id, group);
+    }
+    return [...out.values()];
+  }
+  /**
+   * Blends two or more selected (or given) paths or groups: they become the keys of a live
+   * blend group (bottom to top, or in the order given with `keepOrder`) whose in-betweens are
+   * regenerated whenever a key or the options change. The keys must share a parent. Returns
+   * the blend group's id, or null.
+   */
+  blend(input = {}) {
+    const ids = [...new Set(_nullishCoalesce(input.ids, () => ( this.selectedRoots())))].filter((id2) => {
+      const n = this.getNode(id2);
+      return !!n && !n.blendStep && !n.locked;
+    });
+    if (ids.length < 2) return null;
+    const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _184 => _184[0], 'access', _185 => _185.parent, 'optionalAccess', _186 => _186.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _187 => _187.parent, 'optionalAccess', _188 => _188.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) {
+      const starts = Object.fromEntries(Object.entries(input.starts).filter(([k, v2]) => order.includes(k) && Number.isInteger(v2) && v2 >= 0));
+      if (Object.keys(starts).length) blend.starts = starts;
+    }
+    const id = this.newId();
+    this.change("Blend", () => {
+      const set = new Set(order);
+      const regroup = (list) => {
+        const members = order.map((m) => list.find((n) => n.id === m));
+        const top = Math.max(...members.map((m) => list.indexOf(m)));
+        const out = [];
+        list.forEach((n, i) => {
+          if (i === top) out.push({ id, type: "group", name: _nullishCoalesce(input.name, () => ( "Blend")), blend, children: members });
+          if (!set.has(n.id)) out.push(n);
+        });
+        return out;
+      };
+      if (parent === null) this.setDoc(regroup(this.doc.nodes));
+      else this.setDoc(mapTree(this.doc.nodes, (n) => n.id === parent && n.type === "group" ? { ...n, children: regroup(n.children) } : n));
+      this.selection = [id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return id;
+  }
+  /** Sets the options new blends get (spacing, steps, distance, orientation, morph). */
+  setBlendDefaults(patch) {
+    this.blendDefaults = { ...this.blendDefaults, ...blendOptionsOf(patch) };
+    this.notify();
+  }
+  /**
+   * Adds a node as the last key of a blend (it must share the blend's parent); `start` is the
+   * anchor of its first subpath the blend starts from. One undo step.
+   */
+  addBlendKey(blendId, nodeId, options = {}) {
+    const group = this.getNode(blendId);
+    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', _189 => _189(this.doc.nodes, id), 'optionalAccess', _190 => _190.parent, 'optionalAccess', _191 => _191.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", () => {
+      const blend = start !== null && start !== void 0 ? { ...group.blend, starts: { ...group.blend.starts, [nodeId]: start } } : group.blend;
+      const m = invertMatrix(nodeMatrix(group));
+      const key = group.transform ? transformVectorNode(node, m) : node;
+      const without = mapTree(this.doc.nodes, (n) => n.id === nodeId ? null : n);
+      this.setDoc(spliceTree(without, blendId, [{ ...group, blend, children: [...group.children, key] }]));
+      this.selection = [blendId];
+      this.anchors = [];
+    });
+    return { ok: true };
+  }
+  /** Changes the spacing, steps, distance, orientation or morph of the selected (or given) blends. */
+  setBlendOptions(patch, options = {}) {
+    const groups = this.blendTargets(options.ids);
+    if (!groups.length) return { ok: false, message: "Select a blend." };
+    const clean2 = blendOptionsOf(patch);
+    if (!Object.keys(clean2).length) return { ok: false, message: "No valid blend options were given." };
+    const set = new Set(groups.map((g) => g.id));
+    this.change("Blend Options", () => {
+      this.setDoc(mapTree(this.doc.nodes, (n) => set.has(n.id) && n.type === "group" && n.blend ? { ...n, blend: { ...n.blend, ...clean2 } } : n));
+    });
+    return { ok: true };
+  }
+  /** Expand: turns the selected (or given) blends into plain groups of their keys and steps. Returns their ids. */
+  expandBlend(options = {}) {
+    const groups = this.blendTargets(options.ids);
+    if (!groups.length) return [];
+    const set = new Set(groups.map((g) => g.id));
+    const used = /* @__PURE__ */ new Set();
+    walkVectorNodes(this.doc.nodes, (n) => used.add(n.id));
+    const fresh = () => {
+      let id = this.createId();
+      while (used.has(id)) id = this.createId();
+      used.add(id);
+      return id;
+    };
+    this.change("Expand Blend", () => {
+      this.setDoc(mapTree(this.doc.nodes, (n) => set.has(n.id) && n.type === "group" ? expandVectorBlend(n, fresh) : n));
+      this.selection = [...set];
+      this.anchors = [];
+    });
+    return [...set];
+  }
+  /** Release: replaces the selected (or given) blends with their keys (and a replaced spine as a path). */
+  releaseBlend(options = {}) {
+    const groups = this.blendTargets(options.ids);
+    if (!groups.length) return [];
+    const released = [];
+    this.change("Release Blend", () => {
+      for (const g of groups) {
+        const nodes = releaseVectorBlend(g, () => this.newId());
+        released.push(...nodes.map((n) => n.id));
+        this.setDoc(spliceTree(this.doc.nodes, g.id, nodes));
+      }
+      this.selection = released;
+      this.anchors = [];
+    });
+    return released;
+  }
+  /**
+   * Replace Spine: the selected blend's steps follow the selected path instead of the straight
+   * lines between its keys. The path's first subpath becomes the spine (the path is removed)
+   * and the keys move onto it, spread evenly by arc length.
+   */
+  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', _192 => _192.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _193 => _193(this.doc.nodes, n.id), 'optionalAccess', _194 => _194.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];
+    const first = path.subpaths.find((sp) => sp.anchors.length >= 2);
+    if (!first) return { ok: false, message: "The spine needs a path with at least two points." };
+    const m = multiplyMatrices(this.worldOf(path.id), invertMatrix(this.worldOf(group.id)));
+    const spine = transformVectorNode({ id: "", type: "path", subpaths: [first] }, m).subpaths[0];
+    this.change("Replace Spine", () => {
+      const withSpine = { ...group, blend: { ...group.blend, spine } };
+      const targets = vectorBlendKeyTargets(withSpine);
+      let k = 0;
+      const children = withSpine.children.map((c) => {
+        if (c.blendStep) return c;
+        const target = targets[k++];
+        const b = vectorNodeBounds(c);
+        if (!target || !b) return c;
+        const dx = target[0] - (b.x + b.width / 2);
+        const dy = target[1] - (b.y + b.height / 2);
+        return Math.hypot(dx, dy) > 1e-9 ? transformVectorNode(c, translateMatrix(dx, dy)) : c;
+      });
+      this.setDoc(mapTree(this.doc.nodes, (n) => n.id === path.id ? null : n.id === group.id ? { ...withSpine, children } : n));
+      this.selection = [group.id];
+      this.anchors = [];
+      if (this.editingId === path.id) this.editingId = null;
+    });
+    return { ok: true };
+  }
   shapeBuilderMap(ids) {
     const roots = _nullishCoalesce(ids, () => ( this.selectedRoots()));
     const key = roots.join("\0");
-    if (_optionalChain([this, 'access', _143 => _143.builderCache, 'optionalAccess', _144 => _144.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
+    if (_optionalChain([this, 'access', _195 => _195.builderCache, 'optionalAccess', _196 => _196.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
     const entries = roots.length ? vectorPathEntries(this.doc, roots) : [];
     const map = entries.length ? vectorShapeBuilderMap(entries) : null;
     this.builderCache = { doc: this.doc, key, map };
@@ -5498,9 +6796,9 @@ var VectorEditorController = (_class3 = class {
         const list = [];
         const r = plan.replace.get(i);
         if (r === void 0) list.push(node);
-        else if (_optionalChain([r, 'optionalAccess', _145 => _145.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _146 => _146.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _147 => _147.kind]) === "pieces") {
+        else if (_optionalChain([r, 'optionalAccess', _197 => _197.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _198 => _198.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _199 => _199.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 })) })
           );
@@ -5534,7 +6832,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** The paint bucket's map of the visible outlines, cached per document and gap. */
   fillMap(gap) {
-    if (_optionalChain([this, 'access', _148 => _148.fillCache, 'optionalAccess', _149 => _149.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
+    if (_optionalChain([this, 'access', _200 => _200.fillCache, 'optionalAccess', _201 => _201.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;
@@ -5548,8 +6846,8 @@ var VectorEditorController = (_class3 = class {
    */
   fillRegion(point, options = {}) {
     if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) return null;
-    const region = _optionalChain([this, 'access', _150 => _150.fillMap, 'call', _151 => _151(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _152 => _152.regionAt, 'call', _153 => _153([point.x, point.y])]);
-    if (!_optionalChain([region, 'optionalAccess', _154 => _154.length])) return null;
+    const region = _optionalChain([this, 'access', _202 => _202.fillMap, 'call', _203 => _203(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _204 => _204.regionAt, 'call', _205 => _205([point.x, point.y])]);
+    if (!_optionalChain([region, 'optionalAccess', _206 => _206.length])) return null;
     let below = null;
     const roots = new Set(this.selectedRoots());
     walkVectorNodes(this.doc.nodes, (n) => {
@@ -5575,7 +6873,7 @@ var VectorEditorController = (_class3 = 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', _155 => _155.fillMap, 'call', _156 => _156(this.editing.fillGap), 'optionalAccess', _157 => _157.regionAt, 'call', _158 => _158([p.x, p.y])]), () => ( null));
+      const region = _nullishCoalesce(_optionalChain([this, 'access', _207 => _207.fillMap, 'call', _208 => _208(this.editing.fillGap), 'optionalAccess', _209 => _209.regionAt, 'call', _210 => _210([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;
@@ -5683,7 +6981,7 @@ var VectorEditorController = (_class3 = 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', _159 => _159.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _211 => _211.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);
@@ -5692,7 +6990,7 @@ var VectorEditorController = (_class3 = 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', _160 => _160.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _212 => _212.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) };
@@ -5703,7 +7001,7 @@ var VectorEditorController = (_class3 = class {
    */
   bendSegment(ref, to, t = 0.5) {
     const node = this.getNode(ref.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _161 => _161.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _213 => _213.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", () => {
@@ -5738,7 +7036,7 @@ var VectorEditorController = (_class3 = 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', _162 => _162.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _214 => _214.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);
@@ -5782,7 +7080,7 @@ var VectorEditorController = (_class3 = class {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n = this.getNode(nodeId);
-      return _optionalChain([n, 'optionalAccess', _163 => _163.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n, 'optionalAccess', _215 => _215.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", () => {
@@ -5803,7 +7101,7 @@ var VectorEditorController = (_class3 = class {
       this.setDoc(
         mapTree(
           this.doc.nodes,
-          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _164 => _164.strokeWidthProfile, 'optionalAccess', _165 => _165.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
+          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _216 => _216.strokeWidthProfile, 'optionalAccess', _217 => _217.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
         )
       );
       this.anchors = [];
@@ -5941,7 +7239,7 @@ var VectorEditorController = (_class3 = class {
    */
   cutPathAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _166 => _166.type]) !== "path" || node.locked) return null;
+    if (_optionalChain([node, 'optionalAccess', _218 => _218.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
     const hit = nearestSegment(node, local);
     if (!hit) return null;
@@ -5991,7 +7289,7 @@ var VectorEditorController = (_class3 = 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', _167 => _167.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
+    if (_optionalChain([ids, 'optionalAccess', _219 => _219.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
     const box = polylineBounds(points.map(toPoint2), pad);
     if (!box) return [];
     const out = [];
@@ -6077,7 +7375,7 @@ var VectorEditorController = (_class3 = class {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _168 => _168.subpaths, 'access', _169 => _169[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _220 => _220.subpaths, 'access', _221 => _221[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -6121,19 +7419,19 @@ var VectorEditorController = (_class3 = class {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _170 => _170.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
-        } catch (e3) {
+          if (_optionalChain([data, 'optionalAccess', _222 => _222.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
+        } catch (e4) {
           nodes = null;
         }
       } else if (/<svg[\s>]/i.test(trimmed)) {
         try {
           nodes = parseVectorSvg(trimmed).nodes;
-        } catch (e4) {
+        } catch (e5) {
           nodes = null;
         }
       }
     } else nodes = this.clipboard;
-    if (!_optionalChain([nodes, 'optionalAccess', _171 => _171.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _223 => _223.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", () => {
@@ -6173,9 +7471,9 @@ var VectorEditorController = (_class3 = class {
   }
   hitTransformHandle(screen) {
     if (this.tool !== "select" || !this.selection.length) return null;
-    const frame = this.frameOf(this.selectedRoots());
-    if (!frame) return null;
-    const { box, handles } = getVectorSelectionBoxGeometry(frame, this.viewport);
+    const frame2 = this.frameOf(this.selectedRoots());
+    if (!frame2) return null;
+    const { box, handles } = getVectorSelectionBoxGeometry(frame2, this.viewport);
     const r = this.hitRadius + 2;
     const usable2 = box.width < 2 * r || box.height < 2 * r ? handles.filter((h) => h.handle.length === 2 || h.handle === "rotate") : handles;
     for (const h of usable2) if (Math.hypot(h.screen.x - screen.x, h.screen.y - screen.y) <= r * Math.SQRT2) return h.handle;
@@ -6184,7 +7482,7 @@ var VectorEditorController = (_class3 = class {
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
       const a = getAnchorWorld(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _172 => _172[ref.handle]]);
+      const h = _optionalChain([a, 'optionalAccess', _224 => _224[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;
@@ -6287,6 +7585,11 @@ var VectorEditorController = (_class3 = class {
         const seg = this.nearestOutline(p);
         return seg ? { nodeId: seg.nodeId, segment: seg } : null;
       }
+      case "blend": {
+        const hit = this.blendHit(screen, p);
+        if (!hit) return null;
+        return hit.anchor === null ? { nodeId: hit.nodeId } : { nodeId: hit.nodeId, anchor: { nodeId: hit.nodeId, subpath: 0, index: hit.anchor } };
+      }
       case "width": {
         const hit = this.hitWidthHandle(screen);
         if (hit) return { nodeId: hit.ref.nodeId, widthPoint: hit.ref };
@@ -6298,13 +7601,19 @@ var VectorEditorController = (_class3 = class {
     }
   }
   widthView() {
-    return { document: this.doc, selection: this.selection, tool: this.tool, hover: this.hover, interaction: this.interaction, selectedWidthPoint: this.widthPoint };
+    return { document: this.doc, selection: this.selection, tool: this.tool, hover: this.hover, interaction: this.interaction, selectedWidthPoints: this.widthPoints };
   }
   /** The width point centre or side end under `screen` (width tool). */
   hitWidthHandle(screen) {
+    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', _225 => _225.hover, 'optionalAccess', _226 => _226.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
+  }
+  hitWidthHandleIn(screen, view) {
     let best = null;
     let bestD = Infinity;
-    for (const h of getVectorWidthHandles(this.widthView())) {
+    for (const h of getVectorWidthHandles(view)) {
       for (const [part, q] of [["center", h], ["left", h.left], ["right", h.right]]) {
         const s = this.documentToScreen(q);
         const d = Math.hypot(s.x - screen.x, s.y - screen.y);
@@ -6354,14 +7663,13 @@ var VectorEditorController = (_class3 = class {
   downWidth(screen, p, input) {
     const hit = this.hitWidthHandle(screen);
     const spot = hit ? null : this.strokeSpotAt(p);
-    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _173 => _173.ref, 'access', _174 => _174.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _175 => _175.nodeId])));
+    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _227 => _227.ref, 'access', _228 => _228.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _229 => _229.nodeId])));
     const node = nodeId ? this.getNode(nodeId) : void 0;
-    const g = _optionalChain([node, 'optionalAccess', _176 => _176.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
+    const g = _optionalChain([node, 'optionalAccess', _230 => _230.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
+    if (this.widthEdit) this.widthEdit = null;
     if (!node || node.type !== "path" || !g) {
-      if (this.widthPoint) {
-        this.widthPoint = null;
-        this.notify();
-      }
+      if (!input.shift) this.widthPoints = [];
+      this.notify();
       return;
     }
     const before = this.snapshot();
@@ -6370,15 +7678,29 @@ var VectorEditorController = (_class3 = class {
     let ref;
     let mode = "width";
     let side = "both";
+    let group = [];
+    let shift = false;
     let t;
     let subpath;
     if (hit) {
       profile = sanitizeWidthProfile(node.strokeWidthProfile);
       ref = { nodeId: node.id, index: hit.ref.index, subpath: hit.ref.subpath };
-      t = _nullishCoalesce(_optionalChain([profile, 'access', _177 => _177[ref.index], 'optionalAccess', _178 => _178.t]), () => ( 0));
+      t = _nullishCoalesce(_optionalChain([profile, 'access', _231 => _231[ref.index], 'optionalAccess', _232 => _232.t]), () => ( 0));
       subpath = hit.ref.subpath;
-      if (hit.ref.part === "center") mode = "move";
+      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);
+      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];
+        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);
     } else {
       const near2 = nearestStrokePosition(g.line, [local.x, local.y]);
       const inserted = insertWidthPoint(strokeWidthProfileOf(node), near2.t);
@@ -6387,17 +7709,21 @@ var VectorEditorController = (_class3 = class {
       t = near2.t;
       ref = { nodeId: node.id, index: inserted.index, subpath };
       if (input.alt) side = near2.side;
+      this.widthPoints = [ref];
     }
     const at2 = strokePositionPoint(g.line, subpath, t);
     if (!at2) return;
     const base = { ...this.doc, nodes: mapTree(this.doc.nodes, (n) => n.id === node.id ? { ...n, strokeWidthProfile: profile } : n) };
     this.doc = base;
-    this.widthPoint = { nodeId: node.id, index: ref.index, subpath };
     this.drag = {
       kind: "width",
       ref,
       mode,
       side,
+      source: ref.index,
+      group,
+      shift,
+      renumber: null,
       origin: { x: at2.point[0], y: at2.point[1] },
       normal: { x: at2.tangent[1], y: -at2.tangent[0] },
       unit: g.unit,
@@ -6412,6 +7738,31 @@ var VectorEditorController = (_class3 = class {
     this.interaction = { type: "width", ref, mode, width: (w.left + w.right) * g.unit };
     this.notify(!hit);
   }
+  /**
+   * A width-tool slide to `t` on the dragged point's subpath lands exactly on another width
+   * point (not `skip`) within the pick distance on screen: dropping a point onto another makes
+   * a discontinuous point (two points at one `t`, the width steps there).
+   */
+  snapWidthT(drag, node, line2, t, skip) {
+    const m = this.worldOf(node.id, drag.base);
+    const at2 = strokePositionPoint(line2, drag.ref.subpath, t);
+    if (!at2) return t;
+    const here = this.documentToScreen(applyMatrix(m, { x: at2.point[0], y: at2.point[1] }));
+    let best = t;
+    let bestD = this.hitRadius;
+    drag.profile.forEach((w, i) => {
+      if (i === skip || drag.group.includes(i)) return;
+      const q = strokePositionPoint(line2, drag.ref.subpath, w.t);
+      if (!q) return;
+      const s = this.documentToScreen(applyMatrix(m, { x: q.point[0], y: q.point[1] }));
+      const d = Math.hypot(s.x - here.x, s.y - here.y);
+      if (d <= bestD) {
+        best = w.t;
+        bestD = d;
+      }
+    });
+    return best;
+  }
   /** The nearest outline point of any visible, unlocked path within the pick distance of document point `p`. */
   nearestOutline(p) {
     let best = null;
@@ -6465,6 +7816,8 @@ var VectorEditorController = (_class3 = class {
       case "shapeBuilder":
       case "paintBucket":
         return this.downBuilder(p, input);
+      case "blend":
+        return this.downBlend(screen, p);
       case "scissors": {
         const seg = this.nearestOutline(p);
         if (seg) this.cutPathAt(seg.nodeId, seg.point);
@@ -6480,13 +7833,53 @@ var VectorEditorController = (_class3 = class {
         return this.downShape(p, input);
     }
   }
+  /** The shape under the pointer for the Blend tool, and the anchor of its first subpath under it. */
+  blendHit(screen, p) {
+    const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance());
+    if (!node) return null;
+    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', _233 => _233.hitAnchor, 'call', _234 => _234(screen, refs), 'optionalAccess', _235 => _235.index]), () => ( null));
+    }
+    return { nodeId: node.id, anchor };
+  }
+  /** Blend tool: the first click picks the shape to blend from, the next one blends it into the shape clicked. */
+  downBlend(screen, p) {
+    const hit = this.blendHit(screen, p);
+    const start = this.blendStart;
+    if (!hit) {
+      if (start) {
+        this.blendStart = null;
+        this.notify();
+      }
+      return;
+    }
+    if (!start || start.nodeId === hit.nodeId) {
+      this.blendStart = hit;
+      this.selection = [hit.nodeId];
+      this.anchors = [];
+      this.notify();
+      return;
+    }
+    this.blendStart = null;
+    const first = this.getNode(start.nodeId);
+    if (isVectorBlendGroup(first)) {
+      if (!this.addBlendKey(first.id, hit.nodeId, { start: hit.anchor }).ok) this.notify();
+      return;
+    }
+    const starts = {};
+    if (start.anchor !== null) starts[start.nodeId] = start.anchor;
+    if (hit.anchor !== null) starts[hit.nodeId] = hit.anchor;
+    if (!this.blend({ ids: [start.nodeId, hit.nodeId], keepOrder: true, starts })) this.notify();
+  }
   downSelect(screen, p, input) {
     const handle = this.hitTransformHandle(screen);
     if (handle) {
-      const frame = this.frameOf(this.selectedRoots());
+      const frame2 = this.frameOf(this.selectedRoots());
       const before = this.snapshot();
-      const center = applyMatrix(rotateMatrix(frame.angle), { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 });
-      this.drag = handle === "rotate" ? { kind: "rotate", start: p, center, before, base: this.doc } : { kind: "scale", handle, start: p, frame, before, base: this.doc };
+      const center = applyMatrix(rotateMatrix(frame2.angle), { x: frame2.x + frame2.width / 2, y: frame2.y + frame2.height / 2 });
+      this.drag = handle === "rotate" ? { kind: "rotate", start: p, center, before, base: this.doc } : { kind: "scale", handle, start: p, frame: frame2, before, base: this.doc };
       this.interaction = handle === "rotate" ? { type: "rotate", angle: 0 } : { type: "scale", handle, sx: 1, sy: 1 };
       this.notify();
       return;
@@ -6600,7 +7993,7 @@ var VectorEditorController = (_class3 = class {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _179 => _179.getNode, 'call', _180 => _180(this.pen.nodeId), 'optionalAccess', _181 => _181.subpaths, 'access', _182 => _182[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _236 => _236.getNode, 'call', _237 => _237(this.pen.nodeId), 'optionalAccess', _238 => _238.subpaths, 'access', _239 => _239[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -6862,7 +8255,7 @@ var VectorEditorController = (_class3 = class {
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _183 => _183.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _240 => _240.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);
@@ -6896,19 +8289,35 @@ var VectorEditorController = (_class3 = class {
         drag.moved = true;
         const node = findVectorNode(drag.base.nodes, drag.ref.nodeId);
         const local = this.toLocal(node.id, p, drag.base);
+        const src = drag.profile[drag.source];
         let profile;
-        if (drag.mode === "move") {
+        let index = drag.source;
+        if (drag.mode !== "width") {
           const g = vectorStrokeWidthGeometry(node);
           const near2 = g ? nearestStrokePosition(g.line, [local.x, local.y], drag.ref.subpath) : null;
-          if (!near2) return;
-          profile = setWidthPoint(drag.profile, drag.ref.index, { t: near2.t });
+          if (!g || !near2) return;
+          const t = drag.group.length ? near2.t : this.snapWidthT(drag, node, g.line, near2.t, drag.source);
+          if (drag.mode === "copy") {
+            ({ points: profile, index } = insertWidthPoint(drag.profile, t, { left: src.left, right: src.right }, { step: true }));
+          } else if (drag.group.length) {
+            const shifted = shiftWidthPoints(drag.profile, [drag.source, ...drag.group], t - src.t);
+            profile = shifted.points;
+            drag.renumber = shifted.renumber;
+            index = _nullishCoalesce(shifted.renumber.get(drag.source), () => ( drag.source));
+          } else profile = setWidthPoint(drag.profile, drag.source, { t });
         } else {
           const off = ((local.x - drag.origin.x) * drag.normal.x + (local.y - drag.origin.y) * drag.normal.y) / drag.unit;
           const patch = drag.side === "both" ? { left: Math.abs(off), right: Math.abs(off) } : drag.side === "left" ? { left: Math.max(0, off) } : { right: Math.max(0, -off) };
-          profile = setWidthPoint(drag.profile, drag.ref.index, patch);
+          profile = setWidthPoint(drag.profile, drag.source, patch);
+          if (drag.group.length) {
+            const dl = profile[drag.source].left - src.left;
+            const dr = profile[drag.source].right - src.right;
+            for (const i of drag.group) profile = setWidthPoint(profile, i, { left: Math.max(0, drag.profile[i].left + dl), right: Math.max(0, drag.profile[i].right + dr) });
+          }
         }
         this.doc = { ...drag.base, nodes: mapTree(drag.base.nodes, (n) => n.id === node.id ? { ...n, strokeWidthProfile: profile } : n) };
-        const w = profile[drag.ref.index];
+        drag.ref = { ...drag.ref, index };
+        const w = profile[index];
         this.interaction = { type: "width", ref: drag.ref, mode: drag.mode, width: (w.left + w.right) * drag.unit };
         this.notify(true);
         return;
@@ -6920,14 +8329,14 @@ var VectorEditorController = (_class3 = 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', _184 => _184.pressures, 'optionalAccess', _185 => _185.push, 'call', _186 => _186(drag.pressure)]);
+          _optionalChain([drag, 'access', _241 => _241.pressures, 'optionalAccess', _242 => _242.push, 'call', _243 => _243(drag.pressure)]);
           moved = true;
         }
         const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _187 => _187.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _244 => _244.type]) !== "path") return;
         if (!moved) {
-          if (string && _optionalChain([this, 'access', _188 => _188.interaction, 'optionalAccess', _189 => _189.type]) === "draw") {
+          if (string && _optionalChain([this, 'access', _245 => _245.interaction, 'optionalAccess', _246 => _246.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();
           }
@@ -6963,8 +8372,8 @@ var VectorEditorController = (_class3 = class {
     }
     this.setGuides(res);
     return {
-      dx: _optionalChain([res, 'optionalAccess', _190 => _190.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
-      dy: _optionalChain([res, 'optionalAccess', _191 => _191.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+      dx: _optionalChain([res, 'optionalAccess', _247 => _247.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: _optionalChain([res, 'optionalAccess', _248 => _248.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. */
@@ -7043,7 +8452,7 @@ var VectorEditorController = (_class3 = 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', _192 => _192.corner, 'optionalAccess', _193 => _193.radius]), () => ( 0)), kind));
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _249 => _249.corner, 'optionalAccess', _250 => _250.radius]), () => ( 0)), kind));
           return this.commit("Corner Kind", drag.before);
         }
         const ref = drag.widget.ref;
@@ -7054,12 +8463,23 @@ var VectorEditorController = (_class3 = class {
         return;
       }
       case "width": {
-        if (drag.moved) return this.commit(drag.mode === "move" ? "Move Width Point" : "Width Point", drag.before);
+        if (drag.moved) {
+          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', _251 => _251.renumber, 'optionalAccess', _252 => _252.get, 'call', _253 => _253(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);
+        }
         if (drag.created) {
           this.doc = drag.before.doc;
-          this.widthPoint = null;
+          this.widthPoints = [];
           this.notify(true);
-        } else this.notify();
+        } else {
+          if (!drag.shift && drag.group.length) this.widthPoints = [drag.ref];
+          this.notify();
+        }
         return;
       }
       case "builder":
@@ -7089,14 +8509,14 @@ var VectorEditorController = (_class3 = class {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _194 => _194.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _254 => _254.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', _195 => _195.pressures, 'optionalAccess', _196 => _196.push, 'call', _197 => _197(drag.pressure)]);
+          _optionalChain([drag, 'access', _255 => _255.pressures, 'optionalAccess', _256 => _256.push, 'call', _257 => _257(drag.pressure)]);
         }
         const shape = this.editing.recognizeShapes ? recognizeInkShape(drag.points, { minSize: 6 / this.viewport.zoom }) : null;
         if (shape) {
@@ -7148,7 +8568,10 @@ var VectorEditorController = (_class3 = class {
     }
     this.restore(drag.before);
   }
-  /** Double click: select tool enters path editing, direct tool toggles an anchor or adds one. */
+  /**
+   * Double click: select tool enters path editing, direct tool toggles an anchor or adds one,
+   * width tool opens the width-point editor (`widthPointEdit`).
+   */
   doubleClick(screen) {
     const p = this.screenToDocument(screen);
     if (this.tool === "select") {
@@ -7168,7 +8591,7 @@ var VectorEditorController = (_class3 = class {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _198 => _198.hover, 'optionalAccess', _199 => _199.segment, 'optionalAccess', _200 => _200.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _258 => _258.hover, 'optionalAccess', _259 => _259.segment, 'optionalAccess', _260 => _260.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
         const seg = node ? nearestSegment(node, this.toLocal(id, p)) : null;
@@ -7176,6 +8599,16 @@ var VectorEditorController = (_class3 = class {
       }
       return;
     }
+    if (this.tool === "width") {
+      const hit = this.hitWidthHandle(screen);
+      if (hit) {
+        this.openWidthPointEdit(hit.ref);
+        return;
+      }
+      const spot = this.strokeSpotAt(p);
+      if (spot) this.openWidthPointEdit({ nodeId: spot.nodeId, subpath: spot.subpath, t: spot.t });
+      return;
+    }
     if (this.tool === "pen") this.finishPath();
   }
   // -------------------------------------------------------------------------
@@ -7236,11 +8669,15 @@ var VectorEditorController = (_class3 = class {
     switch (key) {
       case "Escape":
         if (this.drag) this.cancelDrag();
-        else if (this.tool === "width" && this.widthPoint) {
-          this.widthPoint = null;
+        else if (this.widthEdit) this.closeWidthPointEdit();
+        else if (this.tool === "width" && this.widthPoints.length) {
+          this.widthPoints = [];
           this.notify();
         } else if (this.pen) this.finishPath();
-        else if (this.tool === "direct" && this.anchors.length) {
+        else if (this.blendStart) {
+          this.blendStart = null;
+          this.notify();
+        } else if (this.tool === "direct" && this.anchors.length) {
           this.anchors = [];
           this.notify();
         } else if (this.tool !== "select") this.setTool("select");
@@ -7251,7 +8688,7 @@ var VectorEditorController = (_class3 = class {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _201 => _201.getNode, 'call', _202 => _202(this.selection[0]), 'optionalAccess', _203 => _203.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _261 => _261.getNode, 'call', _262 => _262(this.selection[0]), 'optionalAccess', _263 => _263.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -7260,7 +8697,7 @@ var VectorEditorController = (_class3 = class {
         return false;
       case "Delete":
       case "Backspace":
-        if (this.tool === "width" && this.widthPoint) return this.removeWidthPoint(this.widthPoint).ok;
+        if (this.tool === "width" && this.widthPoints.length) return this.removeWidthPoints().ok;
         if (this.pen) {
           const node = this.getNode(this.pen.nodeId);
           const sp = node.subpaths[this.pen.subpath];
@@ -7394,7 +8831,7 @@ function renderNode(node, defs, idPrefix) {
     strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)),
     ...node.strokeLinecap ? { strokeLinecap: node.strokeLinecap } : {},
     ...node.strokeLinejoin ? { strokeLinejoin: node.strokeLinejoin } : {},
-    ..._optionalChain([node, 'access', _204 => _204.strokeDasharray, 'optionalAccess', _205 => _205.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
+    ..._optionalChain([node, 'access', _264 => _264.strokeDasharray, 'optionalAccess', _265 => _265.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1))
   };
@@ -7443,9 +8880,9 @@ function getVectorOverlayRenderData(state) {
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _206 => _206.hover, 'optionalAccess', _207 => _207.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _266 => _266.hover, 'optionalAccess', _267 => _267.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _208 => _208.interaction, 'optionalAccess', _209 => _209.type]) !== "marquee") {
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _268 => _268.interaction, 'optionalAccess', _269 => _269.type]) !== "marquee") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
     selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
   }
@@ -7455,9 +8892,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', _210 => _210.hover, 'optionalAccess', _211 => _211.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', _270 => _270.hover, 'optionalAccess', _271 => _271.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _212 => _212.hover, 'optionalAccess', _213 => _213.anchor])) {
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _272 => _272.hover, 'optionalAccess', _273 => _273.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
@@ -7466,15 +8903,15 @@ function getVectorOverlayRenderData(state) {
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
     const a = getAnchorWorld(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _214 => _214[ref.handle]]);
+    const h = _optionalChain([a, 'optionalAccess', _274 => _274[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _215 => _215.hover, 'optionalAccess', _216 => _216.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _275 => _275.hover, 'optionalAccess', _276 => _276.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', _217 => _217.interaction, 'optionalAccess', _218 => _218.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _277 => _277.interaction, 'optionalAccess', _278 => _278.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 };
@@ -7482,7 +8919,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', _219 => _219.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _279 => _279.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);
@@ -7495,9 +8932,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', _220 => _220.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _221 => _221.type]) === "move" || _optionalChain([it, 'optionalAccess', _222 => _222.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _223 => _223.type]) === "scale" || _optionalChain([it, 'optionalAccess', _224 => _224.type]) === "draw") {
+  if (_optionalChain([it, 'optionalAccess', _280 => _280.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _281 => _281.type]) === "move" || _optionalChain([it, 'optionalAccess', _282 => _282.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _283 => _283.type]) === "scale" || _optionalChain([it, 'optionalAccess', _284 => _284.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 ${fmt(b.width)} \xD7 H ${fmt(b.height)}`;
   }
@@ -7514,24 +8951,24 @@ function getVectorOverlayRenderData(state) {
     }
   }
   let toolStroke = null;
-  if (_optionalChain([it, 'optionalAccess', _225 => _225.type]) === "stroke") {
+  if (_optionalChain([it, 'optionalAccess', _285 => _285.type]) === "stroke") {
     const pts = it.points.map((q) => toScreen(state, q));
     const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt(q.x)} ${fmt(q.y)}`).join("") + (pts.length === 1 ? `L${fmt(pts[0].x)} ${fmt(pts[0].y)}` : "");
     toolStroke = { tool: it.tool, d, width: fmt(it.width * z) };
   }
   let pencilString = null;
-  if (_optionalChain([it, 'optionalAccess', _226 => _226.type]) === "draw" && it.string) {
+  if (_optionalChain([it, 'optionalAccess', _286 => _286.type]) === "draw" && it.string) {
     const a = toScreen(state, it.string[0]);
     const b = toScreen(state, it.string[1]);
     pencilString = { x1: fmt(a.x), y1: fmt(a.y), x2: fmt(b.x), y2: fmt(b.y) };
   }
-  const dragged = _optionalChain([it, 'optionalAccess', _227 => _227.type]) === "corner" ? it.ref : null;
+  const dragged = _optionalChain([it, 'optionalAccess', _287 => _287.type]) === "corner" ? it.ref : null;
   const cornerWidgets = getVectorCornerWidgets(state).map((w) => {
     const s = toScreen(state, w);
-    return { ref: w.ref, x: fmt(s.x), y: fmt(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _228 => _228.hover, 'optionalAccess', _229 => _229.corner]), w.ref), active: !!dragged };
+    return { ref: w.ref, x: fmt(s.x), y: fmt(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _288 => _288.hover, 'optionalAccess', _289 => _289.corner]), w.ref), active: !!dragged };
   });
-  if (_optionalChain([it, 'optionalAccess', _230 => _230.type]) === "corner") status = `R ${fmt(it.radius)}`;
-  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _231 => _231.hover, 'optionalAccess', _232 => _232.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  if (_optionalChain([it, 'optionalAccess', _290 => _290.type]) === "corner") status = `R ${fmt(it.radius)}`;
+  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _291 => _291.hover, 'optionalAccess', _292 => _292.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
   const sc = (p) => {
     const q = toScreen(state, p);
     return { x: fmt(q.x), y: fmt(q.y) };
@@ -7539,13 +8976,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', _233 => _233.hover, 'optionalAccess', _234 => _234.widthPoint]);
+    const hw = _optionalChain([state, 'access', _293 => _293.hover, 'optionalAccess', _294 => _294.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', _235 => _235.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', _295 => _295.type]) === "width" && sameWidth(it.ref, h.ref) };
   });
-  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _236 => _236.hover, 'optionalAccess', _237 => _237.strokeSpot]) : null;
+  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _296 => _296.hover, 'optionalAccess', _297 => _297.strokeSpot]) : null;
   const widthSpot = spot ? { ...sc(spot.point), left: sc(spot.left), right: sc(spot.right) } : null;
-  if (_optionalChain([it, 'optionalAccess', _238 => _238.type]) === "width") status = it.mode === "move" ? "Move width point" : `W ${fmt(it.width)}`;
+  if (_optionalChain([it, 'optionalAccess', _298 => _298.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt(it.width)}`;
   let builder = null;
   if (state.builder) {
     const v2 = state.viewport;
@@ -7561,13 +8998,84 @@ 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', _239 => _239.type]) === "builder") {
+    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _299 => _299.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"}`;
     }
   }
-  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder };
+  const blend = blendOverlay(state);
+  if (state.tool === "blend" && !it) status = state.blendStart ? "Click another shape to blend into" : "Click a shape to blend from";
+  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder, blend };
 }
+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', _300 => _300(state.document.nodes, id), 'optionalAccess', _301 => _301.parent]);
+    if (isVectorBlendGroup(group)) out.set(group.id, group);
+  }
+  return [...out.values()];
+}
+function blendOverlay(state) {
+  const v2 = state.viewport;
+  const view = [v2.zoom, 0, 0, v2.zoom, v2.x, v2.y];
+  const doc = state.document;
+  const sc = (p, m) => {
+    const q = { x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] };
+    return { x: fmt(q.x), y: fmt(q.y) };
+  };
+  const spines = selectedBlends(state).flatMap((g) => {
+    const s = vectorBlendSpine(g);
+    if (!s) return [];
+    const m = multiplyMatrices(_nullishCoalesce(vectorWorldMatrix(doc.nodes, g.id), () => ( IDENTITY_MATRIX)), view);
+    const d = _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, _chunkVNYRI265cjs.transformBezierPath.call(void 0, subpathsToBezier([s.spine], { corners: false }), m), { precision: 2 });
+    const keys = s.stops.map((stop) => {
+      const p = vectorBlendRailAt(s.rail, stop).point;
+      return sc({ x: p[0], y: p[1] }, m);
+    });
+    return [{ id: g.id, d, keys, replaced: s.replaced }];
+  });
+  let start = null;
+  const anchors = [];
+  if (state.tool === "blend") {
+    const from = state.blendStart ? findVectorNode(doc.nodes, state.blendStart.nodeId) : void 0;
+    if (from && state.blendStart) {
+      const a = state.blendStart.anchor === null ? void 0 : getAnchorWorld(doc, { nodeId: from.id, subpath: 0, index: state.blendStart.anchor });
+      start = { d: screenOutline(state, from), anchor: a ? sc(a, view) : null };
+    }
+    const hovered = _optionalChain([state, 'access', _302 => _302.hover, 'optionalAccess', _303 => _303.nodeId]) ? findVectorNode(doc.nodes, state.hover.nodeId) : void 0;
+    if (_optionalChain([hovered, 'optionalAccess', _304 => _304.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', _305 => _305.hover, 'optionalAccess', _306 => _306.anchor, 'optionalAccess', _307 => _307.index]) === index });
+      });
+    }
+  }
+  return { spines, start, anchors };
+}
+function getVectorBlendControls(state) {
+  const blends = selectedBlends(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', _308 => _308(doc.nodes, id), 'optionalAccess', _309 => _309.parent, 'optionalAccess', _310 => _310.id]), () => ( "")));
+  });
+  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _311 => _311(doc.nodes, id), 'optionalAccess', _312 => _312.parent, 'optionalAccess', _313 => _313.id]), () => ( null))));
+  const paths = roots.filter((id) => _optionalChain([findVectorNode, 'call', _314 => _314(doc.nodes, id), 'optionalAccess', _315 => _315.type]) === "path" && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _316 => _316(doc.nodes, id), 'optionalAccess', _317 => _317.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', _318 => _318.blend, 'optionalAccess', _319 => _319.spine])
+  };
+}
+function applyVectorBlendOptions(controller, patch) {
+  controller.setBlendDefaults(patch);
+  if (getVectorBlendControls(controller.getState()).ids.length) controller.setBlendOptions(patch);
+}
+var VECTOR_BLEND_SPACING_LABELS = { steps: "Specified Steps", distance: "Specified Distance", smoothColor: "Smooth Color" };
 var VECTOR_OVERLAY_THEME = {
   accent: "#0ea5e9",
   /** Smart guide lines and labels. */
@@ -7613,7 +9121,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', _240 => _240.getAttribute, 'optionalCall', _241 => _241("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _320 => _320.getAttribute, 'optionalCall', _321 => _321("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -7621,12 +9129,12 @@ function getVectorSelectionStyle(state) {
     const node = findVectorNode(state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
-  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _242 => _242.selectedAnchors, 'optionalAccess', _243 => _243.length]);
+  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _322 => _322.selectedAnchors, 'optionalAccess', _323 => _323.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', _244 => _244.type]) === "path") paths.push(node);
+      if (_optionalChain([node, 'optionalAccess', _324 => _324.type]) === "path") paths.push(node);
     }
   }
   if (!paths.length) return null;
@@ -7637,7 +9145,7 @@ function getVectorSelectionStyle(state) {
     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', _245 => _245.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _246 => _246.kind]), () => ( "round")) });
+      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _325 => _325.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _326 => _326.kind]), () => ( "round")) });
     }
   }
   const c0 = _nullishCoalesce(corners2[0], () => ( { radius: 0, kind: "round" }));
@@ -7752,6 +9260,18 @@ var WIDTH_POINTS = {
   },
   description: "Variable-width profile points, interpolated smoothly (monotone cubic); two points at one `t` make a step. `null` or `[]` strokes at a uniform width."
 };
+var BLEND_PROPS = {
+  spacing: { type: "string", enum: ["steps", "distance", "smoothColor"], description: "How in-betweens are spaced (default steps)." },
+  steps: { type: "integer", minimum: 1, maximum: 1e3, description: "In-betweens between each pair of keys (steps spacing; default 5)." },
+  distance: { type: "number", exclusiveMinimum: 0, description: "Distance between in-betweens along the spine (distance spacing; default 20)." },
+  orientToSpine: { type: "boolean", description: "Turn the in-betweens with a replaced spine." },
+  linear: { type: "boolean", description: "Move anchors in straight lines instead of the rotation-aware morph." }
+};
+var checkBlendOptions = (params) => {
+  if (_optionalChain([params, 'optionalAccess', _327 => _327.spacing]) !== void 0 && !VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
+  if (_optionalChain([params, 'optionalAccess', _328 => _328.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
+  if (_optionalChain([params, 'optionalAccess', _329 => _329.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
+};
 var PAINT = {
   description: 'A CSS colour, `null` for none, or a gradient `{ type: "linear", angle, stops: [{ offset, color }] }`.'
 };
@@ -7785,17 +9305,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', _247 => _247.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _330 => _330.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', _248 => _248.ids, 'optionalAccess', _249 => _249.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _331 => _331.ids, 'optionalAccess', _332 => _332.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', _250 => _250.type]) !== "path" || !_optionalChain([node, 'access', _251 => _251.subpaths, 'access', _252 => _252[r.subpath], 'optionalAccess', _253 => _253.anchors, 'access', _254 => _254[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+      if (_optionalChain([node, 'optionalAccess', _333 => _333.type]) !== "path" || !_optionalChain([node, 'access', _334 => _334.subpaths, 'access', _335 => _335[r.subpath], 'optionalAccess', _336 => _336.anchors, 'access', _337 => _337[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
     }
     return refs;
   };
@@ -7816,7 +9336,9 @@ function createVectorCommands(controller, options = {}) {
           visible: n.visible !== false,
           locked: !!n.locked,
           selected: state.selection.includes(n.id),
-          ...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 === "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 } : {}
         });
         if (n.type === "group") visit(n.children, depth + 1);
       }
@@ -7886,7 +9408,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', _255 => _255.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _338 => _338.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -7918,10 +9440,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', _256 => _256.anchors]) ? anchorsOf(params.anchors) : void 0;
-        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _257 => _257.ids]) ? ids(params) : void 0 };
-        if (_optionalChain([params, 'optionalAccess', _258 => _258.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
-        else if (_optionalChain([params, 'optionalAccess', _259 => _259.kind])) check(controller.setCornerKind(params.kind, target));
+        const refs = _optionalChain([params, 'optionalAccess', _339 => _339.anchors]) ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _340 => _340.ids]) ? ids(params) : void 0 };
+        if (_optionalChain([params, 'optionalAccess', _341 => _341.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
+        else if (_optionalChain([params, 'optionalAccess', _342 => _342.kind])) check(controller.setCornerKind(params.kind, target));
         else fail("Pass `radius` and / or `kind`.");
         return { ok: true };
       }
@@ -7956,12 +9478,37 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const target = { ids: ids(params) };
-        if (_optionalChain([params, 'optionalAccess', _260 => _260.preset])) check(controller.setWidthProfile(params.preset, target));
-        else if (_optionalChain([params, 'optionalAccess', _261 => _261.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
-        else if (_optionalChain([params, 'optionalAccess', _262 => _262.taper]) || _optionalChain([params, 'optionalAccess', _263 => _263.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
+        if (_optionalChain([params, 'optionalAccess', _343 => _343.preset])) check(controller.setWidthProfile(params.preset, target));
+        else if (_optionalChain([params, 'optionalAccess', _344 => _344.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
+        else if (_optionalChain([params, 'optionalAccess', _345 => _345.taper]) || _optionalChain([params, 'optionalAccess', _346 => _346.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', _264 => _264.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _347 => _347.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}setWidthPoint`,
+      label: "Width Point\u2026",
+      keywords: ["width point", "variable width", "stroke width at", "taper", "profile"],
+      description: "Sets one width point of a path's stroke profile numerically: `index` names an existing point (see `vector.setWidthProfile`'s result), leave it out to add one at `t`. `left` / `right` are side widths in document units (how far the stroke reaches on each side), `t` the position along each subpath (0\u20131); a point moved onto another's `t` makes a step. Returns the profile.",
+      params: {
+        type: "object",
+        properties: {
+          id: { type: "string", description: "The path." },
+          index: { type: "integer", minimum: 0 },
+          t: { type: "number", minimum: 0, maximum: 1 },
+          left: { type: "number", minimum: 0 },
+          right: { type: "number", minimum: 0 }
+        },
+        required: ["id"]
+      },
+      undoable: true,
+      run: (_ctx, params) => {
+        if (!_optionalChain([params, 'optionalAccess', _348 => _348.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', _349 => _349.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -7974,7 +9521,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _265 => _265.ids]) ? ids(params) : void 0 });
+        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _350 => _350.ids]) ? ids(params) : void 0 });
         if (!created.length) fail("No selected path has a stroke.");
         return { ids: created };
       }
@@ -8036,6 +9583,86 @@ function createVectorCommands(controller, options = {}) {
         return { id };
       }
     },
+    {
+      ...base,
+      id: `${prefix}blend`,
+      label: "Make Blend\u2026",
+      keywords: ["blend", "morph", "tween", "interpolate", "in-between", "steps", "transition"],
+      description: "Blends two or more paths or groups (sharing a parent; bottom to top, or in the order given with keepOrder) into a live blend group: the in-betweens morph shape (anchors matched by arc length, the start and winding that twist least, rotation-aware so turning shapes turn) and paint (OKLab colours, gradients, stroke width, opacity, width profiles), and regenerate whenever a key changes. Spacing: `steps` (count between each pair of keys), `distance` (along the spine) or `smoothColor`. `starts` maps key ids to the anchor of their first subpath the blend starts from. Returns the blend id.",
+      params: {
+        type: "object",
+        properties: {
+          ids: IDS,
+          ...BLEND_PROPS,
+          keepOrder: { type: "boolean", description: "Blend in the order of `ids` instead of stacking order." },
+          starts: { type: "object", additionalProperties: { type: "integer", minimum: 0 }, description: "Start anchor per key id." }
+        }
+      },
+      undoable: true,
+      run: (_ctx, params) => {
+        checkBlendOptions(params);
+        const id = controller.blend({ ...params, ids: ids(params) });
+        if (!id) fail("Select two or more shapes that share a parent.");
+        return { id };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}blendOptions`,
+      label: "Blend Options\u2026",
+      keywords: ["blend", "steps", "spacing", "distance", "smooth color", "orientation", "align to path"],
+      description: "Changes the spacing (steps, distance or smoothColor), step count, distance, orient-to-spine and linear morph of the given (or selected) blends; their steps regenerate.",
+      params: { type: "object", properties: { ids: IDS, ...BLEND_PROPS } },
+      undoable: true,
+      run: (_ctx, params) => {
+        checkBlendOptions(params);
+        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _351 => _351.ids]) });
+        if (!r.ok) fail(r.message);
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}expandBlend`,
+      label: "Expand Blend",
+      keywords: ["blend", "expand", "flatten", "bake"],
+      description: "Expands the given (or selected) blends into plain groups of their keys and in-betweens (editable paths with fresh ids). Returns the group ids.",
+      params: { type: "object", properties: { ids: IDS } },
+      undoable: true,
+      run: (_ctx, params) => {
+        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _352 => _352.ids]) });
+        if (!groups.length) fail("Select a blend to expand.");
+        return { ids: groups };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}releaseBlend`,
+      label: "Release Blend",
+      keywords: ["blend", "release", "undo blend"],
+      description: "Releases the given (or selected) blends: the in-betweens go and the keys (plus a replaced spine, as an unpainted path) take the blend's place. Returns their ids.",
+      params: { type: "object", properties: { ids: IDS } },
+      undoable: true,
+      run: (_ctx, params) => {
+        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _353 => _353.ids]) });
+        if (!released.length) fail("Select a blend to release.");
+        return { ids: released };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}replaceSpine`,
+      label: "Replace Spine",
+      keywords: ["blend", "spine", "path", "follow", "along path"],
+      description: "With one blend and one path given (or selected): the path becomes the blend's spine (it is removed) and the keys move onto it, spread evenly by arc length; the in-betweens follow it.",
+      params: { type: "object", properties: { ids: IDS } },
+      undoable: true,
+      run: (_ctx, params) => {
+        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _354 => _354.ids]) });
+        if (!r.ok) fail(r.message);
+        return { ok: true };
+      }
+    },
     {
       ...base,
       id: `${prefix}pathfinder`,
@@ -8145,7 +9772,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _266 => _266.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _355 => _355.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -8173,7 +9800,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', _267 => _267.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _268 => _268.keepShape]) }));
+        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _356 => _356.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _357 => _357.keepShape]) }));
         return { ok: true };
       }
     },
@@ -8228,7 +9855,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', _269 => _269.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _270 => _270.tolerance]) }));
+        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _358 => _358.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _359 => _359.tolerance]) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -8242,7 +9869,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', _271 => _271.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _272 => _272.anchors]))));
+        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _360 => _360.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _361 => _361.anchors]))));
         return { ok: true };
       }
     },
@@ -8256,7 +9883,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _273 => _273.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _274 => _274.tolerance]) }));
+        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _362 => _362.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _363 => _363.tolerance]) }));
         return { ok: true };
       }
     },
@@ -8269,7 +9896,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', _275 => _275.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _276 => _276.amount]), refs: _optionalChain([params, 'optionalAccess', _277 => _277.anchors]) }));
+        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _364 => _364.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _365 => _365.amount]), refs: _optionalChain([params, 'optionalAccess', _366 => _366.anchors]) }));
         return { ok: true };
       }
     },
@@ -8282,14 +9909,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', _278 => _278.nodeId]) !== void 0) {
+        if (_optionalChain([params, 'optionalAccess', _367 => _367.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', _279 => _279.anchors]))));
+        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _368 => _368.anchors]))));
         return { ids: controller.getState().selection };
       }
     },
@@ -8340,7 +9967,7 @@ function createVectorCommands(controller, options = {}) {
       },
       run: (_ctx, params) => {
         const patch = {};
-        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _280 => _280[key]]) !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _369 => _369[key]]) !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -8365,7 +9992,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', _281 => _281.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _370 => _370.precision]) }) })
     },
     {
       ...base,
@@ -8579,5 +10206,43 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-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_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_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; 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_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.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.createVectorCommands = createVectorCommands; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorCornerWidgets = getVectorCornerWidgets; 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.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertWidthPoint = insertWidthPoint; exports.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mirrorWidthProfile = mirrorWidthProfile; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeWidthPoints = removeWidthPoints; exports.reverseSubpath = reverseSubpath; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.samplePolyline = samplePolyline; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; 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.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorFillMap = vectorFillMap; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; 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.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_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; 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_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.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorBlendOptions = applyVectorBlendOptions; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.correspondMorphContours = correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorMorph = createVectorMorph; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; 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.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; 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.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mirrorWidthProfile = mirrorWidthProfile; exports.morphContourToSubpath = morphContourToSubpath; exports.morphPathsCross = morphPathsCross; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; 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.removeWidthPoints = removeWidthPoints; exports.resampleGradientStops = resampleGradientStops; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = reverseMorphContour; exports.reverseSubpath = reverseSubpath; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.samplePolyline = samplePolyline; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; 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.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.turnMorphContour = turnMorphContour; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorFillMap = vectorFillMap; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; 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;
 //# sourceMappingURL=index.cjs.map