@pixerate/editor 0.108.0 → 0.109.0

package/dist/{chunk-HUQ7EHVI.js → chunk-BLWCAQCW.js}

@@ -9,7 +9,6 @@ import {
   fitCubicRun,
   fitCubics,
   flattenChain,
-  formatNumber,
   isStraightCubic,
   normalizeBezierPath,
   offsetPath,
@@ -34,33 +33,6 @@ import {
   windingNumber
 } from "./chunk-YCSFS3GK.js";
 import {
-  IDENTITY_MATRIX,
-  WARP_STYLES,
-  WARP_STYLE_LABELS,
-  applyMatrix,
-  clampMeshCount,
-  decomposeRigid,
-  evalWarpMesh,
-  evenKnots,
-  fitWarpMesh,
-  identityWarpMesh,
-  invertMatrix,
-  isIdentityMatrix,
-  isValidWarpMesh,
-  lerpVec2,
-  mapWarpMeshPoints,
-  matrixRotation,
-  multiplyMatrices,
-  resizeWarpMesh,
-  rotateMatrix,
-  scaleMatrix,
-  translateMatrix,
-  warpMeshColumns,
-  warpMeshRows,
-  warpPresetMesh
-} from "./chunk-KKREERP2.js";
-import {
-  mixColorsOklab,
   oklabToRgb,
   rgbToOklab
 } from "./chunk-ZRJMJIQU.js";
@@ -69,9 +41,6 @@ import {
   normalizeTokenColor,
   rgbaToHex
 } from "./chunk-TGD52FEZ.js";
-import {
-  evaluateEasing
-} from "./chunk-AGR4P4UZ.js";
 
 // src/vector/types.ts
 var VECTOR_CORNER_KINDS = ["round", "inverted", "chamfer"];
@@ -539,12 +508,12 @@ function vectorGradientHandles(g, bounds, toWorld = IDENTITY) {
   const p = vectorGradientPoints(g);
   const m = mul(vectorGradientUnitsMatrix(g, bounds), toWorld);
   const f = g.type === "radial" ? unitFocal(g) : null;
-  const frame2 = mul(framePointsMatrix(p), m);
+  const frame = mul(framePointsMatrix(p), m);
   return {
     start: apply(m, p.start),
     end: apply(m, p.end),
     aspect: isCentredVectorGradient(g.type) ? apply(m, p.width) : null,
-    focal: g.type === "radial" ? apply(frame2, f?.f ?? { x: 0, y: 0 }) : null
+    focal: g.type === "radial" ? apply(frame, f?.f ?? { x: 0, y: 0 }) : null
   };
 }
 function withMainAxis(p, start, end) {
@@ -590,15 +559,15 @@ function moveVectorGradientHandle(g, bounds, handle, to, from = to) {
       return set({ width, focal });
     }
     case "focal": {
-      const frame2 = framePointsMatrix(p);
-      const inv = invert(frame2);
+      const frame = framePointsMatrix(p);
+      const inv = invert(frame);
       if (!inv) return pinned;
       let q = apply(inv, to);
       const r = Math.hypot(q.x, q.y);
       if (r < 1e-6) return set({ focal: null });
       const reach = FOCAL_MAX * (1 - p.focalRadius);
       if (r > reach) q = scale(q, reach / r);
-      return set({ focal: apply(frame2, q) });
+      return set({ focal: apply(frame, q) });
     }
   }
 }
@@ -938,6 +907,65 @@ function applyVectorGradientPatch(g, patch) {
   return clean2;
 }
 
+// src/geom/affine.ts
+var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
+function multiplyMatrices(a, b) {
+  const [a0, a1, a2, a3, a4, a5] = a;
+  const [b0, b1, b2, b3, b4, b5] = b;
+  return [b0 * a0 + b2 * a1, b1 * a0 + b3 * a1, b0 * a2 + b2 * a3, b1 * a2 + b3 * a3, b0 * a4 + b2 * a5 + b4, b1 * a4 + b3 * a5 + b5];
+}
+var translateMatrix = (dx, dy) => [1, 0, 0, 1, dx, dy];
+function scaleMatrix(sx, sy, origin = { x: 0, y: 0 }) {
+  return [sx, 0, 0, sy, origin.x - sx * origin.x, origin.y - sy * origin.y];
+}
+function rotateMatrix(degrees, origin = { x: 0, y: 0 }) {
+  const r = degrees * Math.PI / 180;
+  const cos = Math.cos(r);
+  const sin = Math.sin(r);
+  return [cos, sin, -sin, cos, origin.x - cos * origin.x + sin * origin.y, origin.y - sin * origin.x - cos * origin.y];
+}
+function matrixAbout(m, origin) {
+  return multiplyMatrices(multiplyMatrices(translateMatrix(-origin.x, -origin.y), m), translateMatrix(origin.x, origin.y));
+}
+function skewMatrix(ax, ay, origin = { x: 0, y: 0 }) {
+  const tx = Math.tan(ax * Math.PI / 180);
+  const ty = Math.tan(ay * Math.PI / 180);
+  return matrixAbout([1, ty, tx, 1, 0, 0], origin);
+}
+function applyMatrix(m, p) {
+  return { x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] };
+}
+function isIdentityMatrix(m, eps = 1e-12) {
+  return Math.abs(m[0] - 1) < eps && Math.abs(m[1]) < eps && Math.abs(m[2]) < eps && Math.abs(m[3] - 1) < eps && Math.abs(m[4]) < eps && Math.abs(m[5]) < eps;
+}
+function invertMatrix(m) {
+  const [a, b, c, d, e, f] = m;
+  const det = a * d - b * c;
+  if (!det || !Number.isFinite(det)) return IDENTITY_MATRIX;
+  return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
+}
+function applyMatrixLinear(m, v2) {
+  return { x: m[0] * v2.x + m[2] * v2.y, y: m[1] * v2.x + m[3] * v2.y };
+}
+function matrixRotation(m) {
+  const [a, b, c, d] = m;
+  const mirrored = a * d - b * c < 0;
+  const deg = (mirrored ? Math.atan2(-b - c, d - a) : Math.atan2(b - c, a + d)) * 180 / Math.PI;
+  return Math.abs(deg) < 1e-9 ? 0 : deg;
+}
+function decomposeRigid(m) {
+  const [a, b, c, d, e, f] = m;
+  const deg = matrixRotation(m);
+  if (deg === 0) return { rigid: IDENTITY_MATRIX, residual: m };
+  const r = deg * Math.PI / 180;
+  const cos = Math.cos(r);
+  const sin = Math.sin(r);
+  return {
+    rigid: [cos, sin, -sin, cos, e, f],
+    residual: [cos * a + sin * b, -sin * a + cos * b, cos * c + sin * d, -sin * c + cos * d, 0, 0]
+  };
+}
+
 // src/vector/corners.ts
 var EPS = 1e-9;
 var MIN_SINE = 1e-6;
@@ -1281,8 +1309,8 @@ function removeWidthPoints(points, indices) {
 }
 function ease(u, e) {
   const x = Math.min(Math.max(u, 0), 1);
-  const round3 = Math.sqrt(Math.max(0, 1 - (1 - x) * (1 - x)));
-  return x + (round3 - x) * Math.min(Math.max(e, 0), 1);
+  const round2 = Math.sqrt(Math.max(0, 1 - (1 - x) * (1 - x)));
+  return x + (round2 - x) * Math.min(Math.max(e, 0), 1);
 }
 function taperWaveFactor(t, taper, wave) {
   let k = 1;
@@ -1561,10 +1589,10 @@ function variableStrokeRings(path, options) {
         if (closed && out.length > 1 && dist(out[0], out[out.length - 1]) <= 1e-12) out.pop();
         return out;
       };
-      const left2 = side(1);
+      const left = side(1);
       const right = side(-1);
       if (closed) {
-        rings.push(left2, right.reverse());
+        rings.push(left, right.reverse());
         continue;
       }
       const capPoints = (atStart) => {
@@ -1586,7 +1614,7 @@ function variableStrokeRings(path, options) {
         return atStart ? [along(R, o, ext), along(L, o, ext)] : [along(L, o, ext), along(R, o, ext)];
       };
       const ring = [];
-      for (const q of [...left2, ...capPoints(false), ...right.reverse(), ...capPoints(true)]) push(ring, q);
+      for (const q of [...left, ...capPoints(false), ...right.reverse(), ...capPoints(true)]) push(ring, q);
       if (ring.length > 2) rings.push(ring);
     }
   }
@@ -1702,8 +1730,8 @@ function vectorStrokeLineArea(parts, style, tolerance) {
 }
 var capExtent = (style, width) => style.strokeLinecap === "round" || style.strokeLinecap === "square" ? width / 2 : 0;
 function arrowheadWeight(style, end) {
-  const scale3 = end === "start" ? style.startArrowScale : style.endArrowScale;
-  const s = typeof scale3 === "number" && scale3 > 0 && Number.isFinite(scale3) ? scale3 : 1;
+  const scale2 = end === "start" ? style.startArrowScale : style.endArrowScale;
+  const s = typeof scale2 === "number" && scale2 > 0 && Number.isFinite(scale2) ? scale2 : 1;
   const width = style.strokeWidth ?? 1;
   const profile = strokeWidthProfileOf(style);
   const at2 = profile ? widthProfileAt(profile, end === "start" ? 0 : 1) : null;
@@ -2359,9 +2387,9 @@ function facesOf(path, fillRule) {
 function splitIntoFaces(path, fillRule = "nonzero") {
   return facesOf(path, fillRule).map(faceToPath);
 }
-function rootsInUnit(a, b, c, d, scale3) {
+function rootsInUnit(a, b, c, d, scale2) {
   const f = (t) => ((a * t + b) * t + c) * t + d;
-  const tol = 1e-12 * Math.max(1, scale3);
+  const tol = 1e-12 * Math.max(1, scale2);
   const cuts = [0];
   const qa = 3 * a;
   const qb = 2 * b;
@@ -2418,9 +2446,9 @@ function lineHits(p, q, seg) {
     coeffs = [-h0 + 3 * h1 - 3 * h2 + h3, 3 * h0 - 6 * h1 + 3 * h2, -3 * h0 + 3 * h1, h0];
   }
   if (coeffs.every((c) => Math.abs(c) < 1e-12 * Math.max(1, len2))) return [];
-  const scale3 = Math.sqrt(len2) * Math.max(1, ...seg.map((pt2) => Math.abs(pt2[0]) + Math.abs(pt2[1])));
+  const scale2 = Math.sqrt(len2) * Math.max(1, ...seg.map((pt2) => Math.abs(pt2[0]) + Math.abs(pt2[1])));
   const out = [];
-  for (const t of rootsInUnit(...coeffs, scale3)) {
+  for (const t of rootsInUnit(...coeffs, scale2)) {
     const point = segmentPoint(seg, t);
     const s = ((point[0] - p[0]) * dx + (point[1] - p[1]) * dy) / len2;
     if (s >= -1e-9 && s <= 1 + 1e-9) out.push({ s: Math.min(1, Math.max(0, s)), t, point });
@@ -3084,6 +3112,600 @@ function vectorMaskRenderData(group, id, filterId, precision = 3) {
   return { type: group.mask.type, invert: invert2, id, bounds, filter: `url(#${filterId})`, invertFilter: filter };
 }
 
+// src/geom/warp.ts
+var WARP_STYLES = [
+  "arc",
+  "arcLower",
+  "arcUpper",
+  "arch",
+  "bulge",
+  "shellLower",
+  "shellUpper",
+  "flag",
+  "wave",
+  "fish",
+  "rise",
+  "fisheye",
+  "inflate",
+  "squeeze",
+  "twist"
+];
+var WARP_STYLE_LABELS = {
+  arc: "Arc",
+  arcLower: "Arc Lower",
+  arcUpper: "Arc Upper",
+  arch: "Arch",
+  bulge: "Bulge",
+  shellLower: "Shell Lower",
+  shellUpper: "Shell Upper",
+  flag: "Flag",
+  wave: "Wave",
+  fish: "Fish",
+  rise: "Rise",
+  fisheye: "Fisheye",
+  inflate: "Inflate",
+  squeeze: "Squeeze",
+  twist: "Twist"
+};
+function restGrid() {
+  return [0, 1, 2, 3].map((j) => [0, 1, 2, 3].map((i) => [i / 3, j / 3]));
+}
+function edgeArc(y, b, up, h) {
+  if (Math.abs(b) < 1e-9) return [0, 1, 2, 3].map((i) => [i / 3, y]);
+  const th = Math.abs(b) * Math.PI;
+  const k = 4 / 3 * Math.tan(th / 4) * 0.5 / Math.sin(th / 2);
+  const s = b > 0 === up ? -1 : 1;
+  const c = Math.cos(th / 2);
+  const n = Math.sin(th / 2);
+  const dy = s * k * n / h;
+  return [
+    [0, y],
+    [k * c, y + dy],
+    [1 - k * c, y + dy],
+    [1, y]
+  ];
+}
+function arcGrid(b, h) {
+  if (Math.abs(b) < 1e-9) return restGrid();
+  const up = b > 0;
+  const th = Math.abs(b) * Math.PI;
+  const r = 0.5 / Math.sin(th / 2);
+  const k = 4 / 3 * Math.tan(th / 4);
+  const s = up ? -1 : 1;
+  const cy = up ? h + r * Math.cos(th / 2) : -r * Math.cos(th / 2);
+  return [0, 1, 2, 3].map((j) => {
+    const v2 = j / 3;
+    const big = r + h * (up ? 1 - v2 : v2);
+    const at2 = (a) => [0.5 + big * Math.sin(a), cy + s * big * Math.cos(a)];
+    const tangent2 = (a) => [Math.cos(a), -s * Math.sin(a)];
+    const p0 = at2(-th / 2);
+    const p3 = at2(th / 2);
+    const t0 = tangent2(-th / 2);
+    const t1 = tangent2(th / 2);
+    const l = k * big;
+    const pts = [p0, [p0[0] + l * t0[0], p0[1] + l * t0[1]], [p3[0] - l * t1[0], p3[1] - l * t1[1]], p3];
+    return pts.map((p) => [p[0], p[1] / h]);
+  });
+}
+function blendRows(top, bottom) {
+  return [0, 1, 2, 3].map((j) => {
+    const t = j / 3;
+    return [0, 1, 2, 3].map((i) => [top[i][0] + (bottom[i][0] - top[i][0]) * t, top[i][1] + (bottom[i][1] - top[i][1]) * t]);
+  });
+}
+var INNER = [
+  [1, 1, -1, -1],
+  [1, 2, 1, -1],
+  [2, 1, -1, 1],
+  [2, 2, 1, 1]
+];
+function warpPresetGrid(style, b, hd, vd, vertical, aspect) {
+  const h = vertical ? 1 / aspect : aspect;
+  if (vertical) [hd, vd] = [vd, hd];
+  let g = restGrid();
+  switch (style) {
+    case "arc":
+      g = arcGrid(b, h);
+      break;
+    case "arch":
+      g = [0, 1, 2, 3].map((j) => edgeArc(j / 3, b, true, h));
+      break;
+    case "bulge":
+      g = blendRows(edgeArc(0, b, true, h), edgeArc(1, b, false, h));
+      break;
+    case "arcLower":
+      g = blendRows(g[0], edgeArc(1, b, false, h));
+      break;
+    case "arcUpper":
+      g = blendRows(edgeArc(0, b, true, h), g[3]);
+      break;
+    // The bulging edge and the outer points of the row next to it come from Arc (bent the other
+    // way for Shell Lower); the rest stays put.
+    case "shellLower": {
+      const a = arcGrid(-b, h);
+      g[3] = a[3];
+      g[2][0] = a[2][0];
+      g[2][3] = a[2][3];
+      break;
+    }
+    case "shellUpper": {
+      const a = arcGrid(b, h);
+      g[0] = a[0];
+      g[1][0] = a[1][0];
+      g[1][3] = a[1][3];
+      break;
+    }
+    case "flag":
+      for (const row of g) {
+        row[1][1] -= 2 * b;
+        row[2][1] += 2 * b;
+      }
+      break;
+    case "wave":
+      for (const row of g.slice(1, 3)) {
+        row[1][1] += 4 / 3 * b;
+        row[2][1] -= 4 / 3 * b;
+      }
+      break;
+    case "fish":
+      [-2, -2 / 3, 2 / 3, 2].forEach((f, j) => {
+        g[j][1][1] += f * b;
+        g[j][2][1] -= f * b;
+      });
+      break;
+    case "rise":
+      for (const row of g) {
+        row[0][1] += 2 * b;
+        row[1][1] += 2 * b;
+      }
+      break;
+    case "fisheye":
+      for (const [j, i, dx, dy] of INNER) {
+        g[j][i][0] += dx * 2 * b / 3;
+        g[j][i][1] += dy * 2 * b / 3;
+      }
+      break;
+    // Edge midpoints move out (Inflate) or the sides in (Squeeze) by b/3, the inner points by b/9.
+    case "inflate":
+    case "squeeze": {
+      const s = style === "inflate" ? 1 : -1;
+      for (const p of g[0].slice(1, 3)) p[1] -= b / 3;
+      for (const p of g[3].slice(1, 3)) p[1] += b / 3;
+      for (const row of g.slice(1, 3)) {
+        row[0][0] -= s * b / 3;
+        row[3][0] += s * b / 3;
+      }
+      for (const [j, i, dx, dy] of INNER) {
+        g[j][i][0] += s * dx * b / 9;
+        g[j][i][1] += dy * b / 9;
+      }
+      break;
+    }
+    // The inner points turn round the centre (the other way for a negative bend).
+    case "twist": {
+      const a = Math.abs(b);
+      if (b >= 0) {
+        g[1][1][0] += a;
+        g[1][2][1] += a;
+        g[2][1][1] -= a;
+        g[2][2][0] -= a;
+      } else {
+        g[1][1][1] += a;
+        g[1][2][0] -= a;
+        g[2][1][0] += a;
+        g[2][2][1] -= a;
+      }
+      break;
+    }
+  }
+  if (vd !== 0) {
+    const moved = (row, s) => {
+      const m = [(row[0][0] + row[3][0]) / 2, (row[0][1] + row[3][1]) / 2];
+      return row.map((p) => [m[0] + (p[0] - m[0]) * s - p[0], m[1] + (p[1] - m[1]) * s - p[1]]);
+    };
+    const d0 = moved(g[0], 1 - vd);
+    const d3 = moved(g[3], 1 + vd);
+    g.forEach((row, j) => {
+      const t = j / 3;
+      row.forEach((p, i) => {
+        p[0] += d0[i][0] + (d3[i][0] - d0[i][0]) * t;
+        p[1] += d0[i][1] + (d3[i][1] - d0[i][1]) * t;
+      });
+    });
+  }
+  if (hd !== 0) {
+    for (let i = 0; i < 4; i++) {
+      const s = 1 + hd * (2 * i / 3 - 1);
+      const m = [(g[0][i][0] + g[3][i][0]) / 2, (g[0][i][1] + g[3][i][1]) / 2];
+      for (const row of g) row[i] = [m[0] + (row[i][0] - m[0]) * s, m[1] + (row[i][1] - m[1]) * s];
+    }
+  }
+  if (vertical) g = [0, 1, 2, 3].map((j) => [0, 1, 2, 3].map((i) => [g[i][j][1], g[i][j][0]]));
+  return g;
+}
+function bernstein(t) {
+  const s = 1 - t;
+  return [s * s * s, 3 * s * s * t, 3 * s * t * t, t * t * t];
+}
+var lerpVec2 = (a, b, t) => ({ x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t });
+function splitCubic(p, t) {
+  const a = lerpVec2(p[0], p[1], t);
+  const b = lerpVec2(p[1], p[2], t);
+  const c = lerpVec2(p[2], p[3], t);
+  const d = lerpVec2(a, b, t);
+  const e = lerpVec2(b, c, t);
+  return [p[0], a, d, lerpVec2(d, e, t), e, c, p[3]];
+}
+var BERN_INV = [
+  [1, 0, 0, 0],
+  [-5 / 6, 3, -1.5, 1 / 3],
+  [1 / 3, -1.5, 3, -5 / 6],
+  [0, 0, 0, 1]
+];
+var pct = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? Math.min(1, Math.max(-1, v2 / 100)) : 0;
+function warpPresetMesh(preset, bounds) {
+  if (!WARP_STYLES.includes(preset.style)) return null;
+  const { x, y, width: w, height: h } = bounds;
+  if (!(w > 0 && h > 0)) return null;
+  const b = pct(preset.bend);
+  const hd = pct(preset.horizontal);
+  const vd = pct(preset.vertical);
+  if (b === 0 && hd === 0 && vd === 0) return null;
+  const grid = warpPresetGrid(preset.style, b, hd, vd, preset.orientation === "vertical", h / w);
+  return { us: [0, 1], vs: [0, 1], points: grid.flat().map((p) => ({ x: x + p[0] * w, y: y + p[1] * h })) };
+}
+var warpMeshColumns = (m) => 3 * (m.us.length - 1) + 1;
+var warpMeshRows = (m) => 3 * (m.vs.length - 1) + 1;
+function isValidWarpMesh(m) {
+  if (!m || typeof m !== "object") return false;
+  const { us, vs, points } = m;
+  const knots = (k) => Array.isArray(k) && k.length >= 2 && k.length <= 65 && k[0] === 0 && k[k.length - 1] === 1 && k.every((v2, i) => typeof v2 === "number" && (i === 0 || v2 > k[i - 1]));
+  if (!knots(us) || !knots(vs) || !Array.isArray(points)) return false;
+  return points.length === (3 * (us.length - 1) + 1) * (3 * (vs.length - 1) + 1) && points.every((p) => !!p && Number.isFinite(p.x) && Number.isFinite(p.y));
+}
+function fitWarpMesh(f, us, vs) {
+  const pc = us.length - 1;
+  const pr = vs.length - 1;
+  const nx = 3 * pc + 1;
+  const points = new Array((3 * pr + 1) * nx);
+  for (let pj = 0; pj < pr; pj++) {
+    for (let pi = 0; pi < pc; pi++) {
+      const s = [0, 1, 2, 3].map(
+        (j) => [0, 1, 2, 3].map((i) => f(us[pi] + (us[pi + 1] - us[pi]) * i / 3, vs[pj] + (vs[pj + 1] - vs[pj]) * j / 3))
+      );
+      for (let j = 0; j < 4; j++) {
+        for (let i = 0; i < 4; i++) {
+          let x = 0;
+          let y = 0;
+          for (let a = 0; a < 4; a++) {
+            for (let b = 0; b < 4; b++) {
+              const k = BERN_INV[j][a] * BERN_INV[i][b];
+              x += k * s[a][b].x;
+              y += k * s[a][b].y;
+            }
+          }
+          points[(3 * pj + j) * nx + 3 * pi + i] = { x, y };
+        }
+      }
+    }
+  }
+  return { us: us.slice(), vs: vs.slice(), points };
+}
+var evenKnots = (n) => Array.from({ length: n + 1 }, (_, i) => i / n);
+var clampMeshCount = (n) => Math.min(64, Math.max(1, Math.round(Number.isFinite(n) ? n : 1)));
+function identityWarpMesh(bounds, columns = 1, rows = 1) {
+  return fitWarpMesh((s, t) => ({ x: bounds.x + s * bounds.width, y: bounds.y + t * bounds.height }), evenKnots(clampMeshCount(columns)), evenKnots(clampMeshCount(rows)));
+}
+function locate(knots, s) {
+  const n = knots.length - 1;
+  let i = 0;
+  while (i + 1 < n && s > knots[i + 1]) i++;
+  const w = knots[i + 1] - knots[i];
+  return [i, w > 0 ? (s - knots[i]) / w : 0];
+}
+function evalWarpMesh(m, s, t) {
+  const [pi, a] = locate(m.us, s);
+  const [pj, b] = locate(m.vs, t);
+  const ba = bernstein(a);
+  const bb = bernstein(b);
+  const nx = warpMeshColumns(m);
+  let x = 0;
+  let y = 0;
+  for (let j = 0; j < 4; j++) {
+    for (let i = 0; i < 4; i++) {
+      const p = m.points[(3 * pj + j) * nx + 3 * pi + i];
+      const k = ba[i] * bb[j];
+      x += p.x * k;
+      y += p.y * k;
+    }
+  }
+  return { x, y };
+}
+function transposeMesh(m) {
+  const nx = warpMeshColumns(m);
+  const ny = warpMeshRows(m);
+  const points = new Array(nx * ny);
+  for (let j = 0; j < ny; j++) for (let i = 0; i < nx; i++) points[i * ny + j] = m.points[j * nx + i];
+  return { us: m.vs.slice(), vs: m.us.slice(), points };
+}
+function splitWarpMeshU(m, s) {
+  const [pi, a] = locate(m.us, s);
+  if (!(a >= 0.01 && a <= 0.99)) return null;
+  const nx = warpMeshColumns(m);
+  const ny = warpMeshRows(m);
+  const points = [];
+  for (let j = 0; j < ny; j++) {
+    const row = m.points.slice(j * nx, (j + 1) * nx);
+    points.push(...row.slice(0, 3 * pi), ...splitCubic(row.slice(3 * pi, 3 * pi + 4), a), ...row.slice(3 * pi + 4));
+  }
+  const us = m.us.slice();
+  us.splice(pi + 1, 0, Math.min(1, Math.max(0, s)));
+  return { us, vs: m.vs.slice(), points };
+}
+function splitWarpMeshV(m, t) {
+  const out = splitWarpMeshU(transposeMesh(m), t);
+  return out && transposeMesh(out);
+}
+function removeWarpMeshSplitU(m, k) {
+  if (k <= 0 || k + 1 >= m.us.length) return null;
+  const a = (m.us[k] - m.us[k - 1]) / (m.us[k + 1] - m.us[k - 1]);
+  const nx = warpMeshColumns(m);
+  const ny = warpMeshRows(m);
+  const c0 = 3 * (k - 1);
+  const points = [];
+  for (let j = 0; j < ny; j++) {
+    const row = m.points.slice(j * nx, (j + 1) * nx);
+    const [p0, q1, r2, p3] = [row[c0], row[c0 + 1], row[c0 + 5], row[c0 + 6]];
+    const p1 = { x: (q1.x - (1 - a) * p0.x) / a, y: (q1.y - (1 - a) * p0.y) / a };
+    const p2 = { x: (r2.x - a * p3.x) / (1 - a), y: (r2.y - a * p3.y) / (1 - a) };
+    points.push(...row.slice(0, c0), p0, p1, p2, p3, ...row.slice(c0 + 7));
+  }
+  const us = m.us.slice();
+  us.splice(k, 1);
+  return { us, vs: m.vs.slice(), points };
+}
+function removeWarpMeshSplitV(m, k) {
+  const out = removeWarpMeshSplitU(transposeMesh(m), k);
+  return out && transposeMesh(out);
+}
+function mapWarpMeshPoints(m, f) {
+  return { us: m.us.slice(), vs: m.vs.slice(), points: m.points.map((p) => f(p)) };
+}
+function resizeWarpMesh(m, columns, rows) {
+  const cols = clampMeshCount(columns);
+  const rws = clampMeshCount(rows);
+  if (m.us.length - 1 === cols && m.vs.length - 1 === rws) return m;
+  const us = evenKnots(cols);
+  const vs = evenKnots(rws);
+  const has = (list, v2) => list.some((k) => Math.abs(k - v2) < 1e-12);
+  if (m.us.every((u) => has(us, u)) && m.vs.every((v2) => has(vs, v2))) {
+    let out = m;
+    for (const u of us) if (!has(out.us, u)) out = splitWarpMeshU(out, u) ?? out;
+    for (const v2 of vs) if (!has(out.vs, v2)) out = splitWarpMeshV(out, v2) ?? out;
+    return out;
+  }
+  return fitWarpMesh((s, t) => evalWarpMesh(m, s, t), us, vs);
+}
+function warpMeshControlBounds(m) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of m.points) {
+    minX = Math.min(minX, p.x);
+    minY = Math.min(minY, p.y);
+    maxX = Math.max(maxX, p.x);
+    maxY = Math.max(maxY, p.y);
+  }
+  return { x: minX, y: minY, width: maxX - minX, height: maxY - minY };
+}
+function warpMeshParamAt(m, p) {
+  const n = 48;
+  let best = { s: 0.5, t: 0.5, d: Infinity };
+  for (let j = 0; j <= n; j++) {
+    for (let i = 0; i <= n; i++) {
+      const q2 = evalWarpMesh(m, i / n, j / n);
+      const d = (q2.x - p.x) ** 2 + (q2.y - p.y) ** 2;
+      if (d < best.d) best = { s: i / n, t: j / n, d };
+    }
+  }
+  let { s, t } = best;
+  for (let k = 0; k < 12; k++) {
+    const h = 1e-5;
+    const q2 = evalWarpMesh(m, s, t);
+    const qs = evalWarpMesh(m, s + h, t);
+    const qt = evalWarpMesh(m, s, t + h);
+    const a = (qs.x - q2.x) / h;
+    const b = (qt.x - q2.x) / h;
+    const c = (qs.y - q2.y) / h;
+    const d = (qt.y - q2.y) / h;
+    const det = a * d - b * c;
+    if (Math.abs(det) < 1e-12) break;
+    const ex = p.x - q2.x;
+    const ey = p.y - q2.y;
+    s = Math.min(1, Math.max(0, s + (d * ex - b * ey) / det));
+    t = Math.min(1, Math.max(0, t + (a * ey - c * ex) / det));
+  }
+  const q = evalWarpMesh(m, s, t);
+  return { s, t, distance: Math.hypot(q.x - p.x, q.y - p.y) };
+}
+function smoothLines(m, i0, i1, j0, j1) {
+  const nx = warpMeshColumns(m);
+  i1 = Math.min(i1, nx);
+  j1 = Math.min(j1, warpMeshRows(m));
+  const triples = [];
+  for (let a = 1; a < m.us.length - 1; a++) {
+    if (3 * a >= i0 && 3 * a < i1)
+      for (let j = j0; j < j1; j++) triples.push([j * nx + 3 * a - 1, j * nx + 3 * a, j * nx + 3 * a + 1, m.us[a] - m.us[a - 1], m.us[a + 1] - m.us[a]]);
+  }
+  for (let b = 1; b < m.vs.length - 1; b++) {
+    if (3 * b >= j0 && 3 * b < j1)
+      for (let i = i0; i < i1; i++) triples.push([(3 * b - 1) * nx + i, 3 * b * nx + i, (3 * b + 1) * nx + i, m.vs[b] - m.vs[b - 1], m.vs[b + 1] - m.vs[b]]);
+  }
+  for (const [l, c, r, hl, hr] of triples) {
+    const pl = m.points[l];
+    const pc = m.points[c];
+    const pr = m.points[r];
+    const tx = ((pc.x - pl.x) / hl + (pr.x - pc.x) / hr) / 2;
+    const ty = ((pc.y - pl.y) / hl + (pr.y - pc.y) / hr) / 2;
+    m.points[l] = { x: pc.x - tx * hl, y: pc.y - ty * hl };
+    m.points[r] = { x: pc.x + tx * hr, y: pc.y + ty * hr };
+  }
+}
+function dragWarpMeshPoint(base, index, d) {
+  if (index < 0 || index >= base.points.length || !Number.isFinite(d.x) || !Number.isFinite(d.y)) return base;
+  const out = { us: base.us.slice(), vs: base.vs.slice(), points: base.points.slice() };
+  const nx = warpMeshColumns(base);
+  const ny = warpMeshRows(base);
+  const i = index % nx;
+  const j = Math.floor(index / nx);
+  const shift = (ii, jj, v2) => {
+    if (ii < 0 || jj < 0 || ii >= nx || jj >= ny) return;
+    const p = out.points[jj * nx + ii];
+    out.points[jj * nx + ii] = { x: p.x + v2.x, y: p.y + v2.y };
+  };
+  const span = (knots, k) => k > 0 && k + 1 < knots.length ? [knots[k] - knots[k - 1], knots[k + 1] - knots[k]] : null;
+  const ri = i % 3;
+  const rj = j % 3;
+  if (ri === 0 && rj === 0) {
+    for (let dj = -1; dj <= 1; dj++) for (let di = -1; di <= 1; di++) shift(i + di, j + dj, d);
+  } else if (ri === 0) {
+    for (let di = -1; di <= 1; di++) shift(i + di, j, d);
+    const sp = span(base.vs, Math.floor(j / 3) + (rj === 2 ? 1 : 0));
+    if (sp) {
+      const [other, k] = rj === 1 ? [j - 2, sp[0] / sp[1]] : [j + 2, sp[1] / sp[0]];
+      for (let di = -1; di <= 1; di++) shift(i + di, other, { x: -d.x * k, y: -d.y * k });
+    }
+  } else if (rj === 0) {
+    for (let dj = -1; dj <= 1; dj++) shift(i, j + dj, d);
+    const sp = span(base.us, Math.floor(i / 3) + (ri === 2 ? 1 : 0));
+    if (sp) {
+      const [other, k] = ri === 1 ? [i - 2, sp[0] / sp[1]] : [i + 2, sp[1] / sp[0]];
+      for (let dj = -1; dj <= 1; dj++) shift(other, j + dj, { x: -d.x * k, y: -d.y * k });
+    }
+  } else shift(i, j, d);
+  return out;
+}
+function pullWarpMesh(base, s, t, d) {
+  const BORDER_ZONE = 0.12;
+  const REACH = 1.8;
+  if (!Number.isFinite(d.x) || !Number.isFinite(d.y)) return base;
+  const m = { us: base.us.slice(), vs: base.vs.slice(), points: base.points.slice() };
+  const cols = m.us.length - 1;
+  const rows = m.vs.length - 1;
+  const [pi, a] = locate(m.us, s);
+  const [pj, b] = locate(m.vs, t);
+  const ba = bernstein(a);
+  const bb = bernstein(b);
+  const nx = warpMeshColumns(m);
+  const ny = warpMeshRows(m);
+  const anchor = (ai, aj) => base.points[3 * aj * nx + 3 * ai] ?? { x: 0, y: 0 };
+  const at0 = evalWarpMesh(base, s, t);
+  const target = { x: at0.x + d.x, y: at0.y + d.y };
+  let size = 1;
+  for (const k of ["x", "y"]) {
+    const vals = [anchor(pi, pj)[k], anchor(pi + 1, pj)[k], anchor(pi, pj + 1)[k], anchor(pi + 1, pj + 1)[k]];
+    size = Math.max(size, Math.max(...vals) - Math.min(...vals));
+  }
+  const radius = REACH * size;
+  const innerW = (ba[1] + ba[2]) * (bb[1] + bb[2]);
+  const interior = Math.min(1, Math.max(0, innerW / 0.5625));
+  const toBorder = Math.min(s, 1 - s, t, 1 - t);
+  const nearBorder = Math.min(1, Math.max(0, 1 - toBorder / BORDER_ZONE));
+  const meshCorner = (ai, aj) => (ai === 0 || ai === cols) && (aj === 0 || aj === rows);
+  const onBorder = (ai, aj) => ai === 0 || ai === cols || aj === 0 || aj === rows;
+  const reach = (ai, aj, wa, wb) => meshCorner(ai, aj) ? 0 : wa * wb * (onBorder(ai, aj) ? nearBorder : 1);
+  const corner = [
+    [pi, pj, reach(pi, pj, ba[0] + ba[1], bb[0] + bb[1])],
+    [pi + 1, pj, reach(pi + 1, pj, ba[2] + ba[3], bb[0] + bb[1])],
+    [pi, pj + 1, reach(pi, pj + 1, ba[0] + ba[1], bb[2] + bb[3])],
+    [pi + 1, pj + 1, reach(pi + 1, pj + 1, ba[2] + ba[3], bb[2] + bb[3])]
+  ];
+  const share = new Array((cols + 1) * (rows + 1)).fill(0);
+  for (let aj = 0; aj <= rows; aj++) {
+    for (let ai = 0; ai <= cols; ai++) {
+      const p = anchor(ai, aj);
+      const x = Math.min(1, Math.max(0, Math.hypot(p.x - at0.x, p.y - at0.y) / radius));
+      const fall = 0.5 * (1 + Math.cos(Math.PI * x));
+      const edge = meshCorner(ai, aj) ? 0 : onBorder(ai, aj) ? nearBorder : 1;
+      share[aj * (cols + 1) + ai] = fall * edge;
+    }
+  }
+  for (const [ai, aj, w] of corner) share[aj * (cols + 1) + ai] = Math.max(share[aj * (cols + 1) + ai], (1 - interior) * w);
+  const move = (idx, k, v2) => {
+    const p = m.points[idx];
+    m.points[idx] = { x: p.x + v2.x * k, y: p.y + v2.y * k };
+  };
+  for (let j = 0; j < ny; j++) {
+    for (let i = 0; i < nx; i++) {
+      const ai = Math.min(cols, Math.floor((i + 1) / 3));
+      const aj = Math.min(rows, Math.floor((j + 1) / 3));
+      move(j * nx + i, share[aj * (cols + 1) + ai], d);
+    }
+  }
+  let norm = 0;
+  for (const j of [1, 2]) for (const i of [1, 2]) norm += (ba[i] * bb[j]) ** 2;
+  const cornerNorm = corner.reduce((acc, c) => acc + c[2] * c[2], 0);
+  const innerPart = cornerNorm > 1e-12 ? Math.min(1, innerW / 0.15) : 1;
+  const edgeHandles = [];
+  for (const k of [1, 2]) {
+    if (pi === 0) edgeHandles.push([(3 * pj + k) * nx + 3 * pi, ba[0] * bb[k]]);
+    if (pi + 1 === cols) edgeHandles.push([(3 * pj + k) * nx + 3 * pi + 3, ba[3] * bb[k]]);
+    if (pj === 0) edgeHandles.push([3 * pj * nx + 3 * pi + k, ba[k] * bb[0]]);
+    if (pj + 1 === rows) edgeHandles.push([(3 * pj + 3) * nx + 3 * pi + k, ba[k] * bb[3]]);
+  }
+  const edgeNorm = edgeHandles.reduce((acc, e) => acc + e[1] * e[1], 0);
+  const edgePart = edgeNorm > 1e-12 ? nearBorder : 0;
+  const innerShare = (1 - edgePart) * innerPart;
+  const cornerShare = (1 - edgePart) * (1 - innerPart);
+  for (let iter = 0; iter < 60; iter++) {
+    const now = evalWarpMesh(m, s, t);
+    const rem = { x: target.x - now.x, y: target.y - now.y };
+    if (Math.hypot(rem.x, rem.y) < 1e-9) break;
+    if (innerShare > 0 && norm > 0) for (const j of [1, 2]) for (const i of [1, 2]) move((3 * pj + j) * nx + 3 * pi + i, ba[i] * bb[j] / norm * innerShare, rem);
+    if (edgePart > 0) for (const [idx, w] of edgeHandles) move(idx, w / edgeNorm * edgePart, rem);
+    if (cornerShare > 0 && cornerNorm > 0) {
+      for (const [ai, aj, w] of corner) {
+        const k = w / cornerNorm * cornerShare;
+        for (let dj = -1; dj <= 1; dj++) {
+          for (let di = -1; di <= 1; di++) {
+            const i = 3 * ai + di;
+            const j = 3 * aj + dj;
+            if (i >= 0 && j >= 0 && i < nx && j < ny) move(j * nx + i, k, rem);
+          }
+        }
+      }
+    }
+    for (let k = 0; k < 3; k++) smoothLines(m, Math.max(0, 3 * pi - 3), 3 * pi + 7, Math.max(0, 3 * pj - 3), 3 * pj + 7);
+  }
+  return m;
+}
+function warpMeshEditPoints(m) {
+  const nx = warpMeshColumns(m);
+  const ny = warpMeshRows(m);
+  const anchors = [];
+  const handles = [];
+  for (let j = 0; j < ny; j++) {
+    for (let i = 0; i < nx; i++) {
+      const ri = i % 3;
+      const rj = j % 3;
+      if (ri === 0 && rj === 0) anchors.push(j * nx + i);
+      else if (ri === 0) handles.push({ index: j * nx + i, anchor: (rj === 1 ? j - 1 : j + 1) * nx + i });
+      else if (rj === 0) handles.push({ index: j * nx + i, anchor: j * nx + (ri === 1 ? i - 1 : i + 1) });
+    }
+  }
+  return { anchors, handles };
+}
+function warpMeshGridCurves(m) {
+  const nx = warpMeshColumns(m);
+  const ny = warpMeshRows(m);
+  const pt2 = (i, j) => m.points[j * nx + i];
+  const out = [];
+  for (let j = 0; j < ny; j += 3) for (let i = 0; i + 3 < nx; i += 3) out.push([pt2(i, j), pt2(i + 1, j), pt2(i + 2, j), pt2(i + 3, j)]);
+  for (let i = 0; i < nx; i += 3) for (let j = 0; j + 3 < ny; j += 3) out.push([pt2(i, j), pt2(i, j + 1), pt2(i, j + 2), pt2(i, j + 3)]);
+  return out;
+}
+
 // src/vector/warp.ts
 function polylineAt(pts) {
   const acc = [0];
@@ -4203,12 +4825,12 @@ function insertAnchor(sp, segment, t) {
   const ia = segment;
   const ib = (segment + 1) % n;
   const seg = subpathSegment(sp, segment);
-  const [left2, right] = splitSegment(seg, t);
-  const mid = left2[left2.length - 1];
+  const [left, right] = splitSegment(seg, t);
+  const mid = left[left.length - 1];
   const anchor = { x: mid[0], y: mid[1] };
   if (seg.length === 4) {
-    anchors[ia].out = { x: left2[1][0], y: left2[1][1] };
-    anchor.in = { x: left2[2][0], y: left2[2][1] };
+    anchors[ia].out = { x: left[1][0], y: left[1][1] };
+    anchor.in = { x: left[2][0], y: left[2][1] };
     anchor.out = { x: right[1][0], y: right[1][1] };
     anchor.type = "smooth";
     anchors[ib].in = { x: right[2][0], y: right[2][1] };
@@ -4500,9 +5122,9 @@ function twistPaths(paths, angle, center) {
   };
   return paths.map((p) => {
     const out = [];
-    for (const sub5 of subsOf(p)) {
+    for (const sub4 of subsOf(p)) {
       const segs = [];
-      for (const seg of sub5.segs) {
+      for (const seg of sub4.segs) {
         const cubic = seg.length === 2 ? [seg[0], seg[0], seg[1], seg[1]] : seg;
         const len2 = segmentLength(seg);
         const m = Math.min(64, Math.max(1, Math.ceil(Math.abs(a) * len2 / rmax / 0.15 + len2 / 50)));
@@ -4515,13 +5137,13 @@ function twistPaths(paths, angle, center) {
           segs.push([p0, [p0[0] + h1[0], p0[1] + h1[1]], [p3[0] + h2[0], p3[1] + h2[1]], p3]);
         }
       }
-      out.push({ segs, closed: sub5.closed });
+      out.push({ segs, closed: sub4.closed });
     }
     return subsToPath(out);
   });
 }
-function resample(sub5, m) {
-  const segs = sub5.segs;
+function resample(sub4, m) {
+  const segs = sub4.segs;
   const n = segs.length;
   const lens = segs.map((s) => segmentLength(s));
   const out = [];
@@ -4530,7 +5152,7 @@ function resample(sub5, m) {
     for (let k = 0; k < m; k++) {
       if (k === 0) {
         const tout = startTangent(segs[j]);
-        const prev = sub5.closed || j > 0 ? (j + n - 1) % n : null;
+        const prev = sub4.closed || j > 0 ? (j + n - 1) % n : null;
         let tan = tout;
         if (prev !== null) {
           const tin = endTangent(segs[prev]);
@@ -4543,7 +5165,7 @@ function resample(sub5, m) {
       }
     }
   }
-  if (!sub5.closed) {
+  if (!sub4.closed) {
     const last = segs[n - 1];
     out.push({ p: last[last.length - 1], tan: endTangent(last), lenPrev: lens[n - 1] / m, lenNext: 0 });
   }
@@ -4571,14 +5193,14 @@ function zigzagPaths(paths, size, ridges, smooth = false) {
   const m = Math.min(1e3, Math.max(0, Math.round(Number.isFinite(ridges) ? ridges : 0))) + 1;
   return paths.map((p) => {
     const out = [];
-    for (const sub5 of subsOf(p)) {
-      const s = resample(sub5, m);
+    for (const sub4 of subsOf(p)) {
+      const s = resample(sub4, m);
       const disp = s.map((x, i) => {
         const n = perp2(x.tan);
         const d = i % 2 === 0 ? size : -size;
         return [n[0] * d, n[1] * d];
       });
-      const e = emit(s, disp, sub5.closed, smooth, 0.36);
+      const e = emit(s, disp, sub4.closed, smooth, 0.36);
       if (e) out.push(e);
     }
     return subsToPath(out);
@@ -4617,8 +5239,8 @@ function wigglePaths(paths, w) {
   let idx = 0;
   return paths.map((p) => {
     const out = [];
-    for (const sub5 of subsOf(p)) {
-      const s = resample(sub5, m);
+    for (const sub4 of subsOf(p)) {
+      const s = resample(sub4, m);
       const disp = s.map(() => {
         const i = BigInt(idx);
         const ox = noise(seed, i * 2n, t + idx * 0.37);
@@ -4626,7 +5248,7 @@ function wigglePaths(paths, w) {
         idx++;
         return [(sx * corr + ox * (1 - corr)) * w.size, (sy * corr + oy * (1 - corr)) * w.size];
       });
-      const e = emit(s, disp, sub5.closed, w.smooth, 1 / 3);
+      const e = emit(s, disp, sub4.closed, w.smooth, 1 / 3);
       if (e) out.push(e);
     }
     return subsToPath(out);
@@ -4667,1885 +5289,6 @@ function pathsCenter(paths) {
   return b ? { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 } : { x: 0, y: 0 };
 }
 
-// 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(a.out ?? a);
-    const c2 = straight ? lerpP(pa, pb, 2 / 3) : toP(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 plain2 = !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 (plain2 && 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) => segmentLength(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 left2 = 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; left2 > 0; i = (i + 1) % order.length, left2--) 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 = segmentParamAtLength(seg, lens[k] * j / pieces, lens[k]);
-      const u = Math.min(1, Math.max(0, (t - t0) / (1 - t0 || 1)));
-      const [l, r] = splitSegment(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 dot3 = 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];
-      dot3 += 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 - (dot3 * dot3 + cross2 * cross2) / (m * m));
-    const turn = 1 - Math.cos(Math.atan2(cross2, dot3));
-    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(options.minSegments ?? 16));
-  const maxSeg = Math.max(minSeg, Math.round(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 += segmentLength(segOf(c, k));
-    return l;
-  };
-  const pairs = [];
-  const [sa, sb] = 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 : ra.anchors[explicitA] ?? null,
-        startY: explicitB === null ? null : explicitB === rb.anchors.length - 1 && !cb.closed ? -1 : 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 dot3 = 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];
-    dot3 += p[0] * q[0] + p[1] * q[1];
-    cross2 += p[0] * q[1] - p[1] * q[0];
-  }
-  return { ca, cb, theta: Math.atan2(cross2, dot3), s: ss > 1e-12 ? Math.hypot(dot3, cross2) / ss : 1 };
-}
-function interpolateMorphContours(a, b, u, options = {}) {
-  const w = options.linear ? 0 : Math.min(1, Math.max(0, options.rigidity ?? 1));
-  const sim = w > 0 ? 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 = 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 mixColorsOklab(a, b, t) ?? (t < 0.5 ? a : b);
-}
-function resampleGradientStops(g, offsets) {
-  return offsets.map((offset) => {
-    const s = sampleVectorGradient(g, offset);
-    return s.opacity < 1 ? { offset, color: s.color, opacity: Math.round(s.opacity * 1e4) / 1e4 } : { offset, color: s.color };
-  });
-}
-function lerpAngle(a, b, t) {
-  const d = ((b - a + 180) % 360 + 360) % 360 - 180;
-  return a + d * t;
-}
-var lerpPoint = (a, b, t) => ({ x: lerpN(a.x, b.x, t), y: lerpN(a.y, b.y, t) });
-var sameColourModel = (a, b) => (a.interpolation ?? "srgb") === (b.interpolation ?? "srgb") && (a.smoothness ?? 0) === (b.smoothness ?? 0);
-function lerpStops(a, b, t) {
-  let stopsA = sortedVectorGradientStops(a);
-  let stopsB = sortedVectorGradientStops(b);
-  const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
-  if (resampled) {
-    const offs = [...expandVectorGradientStops(a), ...expandVectorGradientStops(b), ...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(x.opacity ?? 1, 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;
-    const mid = lerpN(x.midpoint ?? 0.5, y.midpoint ?? 0.5, t);
-    if (Math.abs(mid - 0.5) > 1e-6) stop.midpoint = mid;
-    return stop;
-  });
-  return { stops, resampled };
-}
-function lerpGradient(a, b, t) {
-  if (a.type !== b.type) return null;
-  const { stops, resampled } = lerpStops(a, b, t);
-  const near2 = t < 0.5 ? a : b;
-  const out = { type: a.type, stops };
-  if (!resampled) {
-    if (a.interpolation && a.interpolation !== "srgb") out.interpolation = a.interpolation;
-    if (a.smoothness) out.smoothness = a.smoothness;
-  }
-  if (near2.spread && near2.spread !== "pad") out.spread = near2.spread;
-  if (near2.strokeMode && near2.strokeMode !== "within") out.strokeMode = near2.strokeMode;
-  const ea = hasExplicitGradientGeometry(a);
-  const eb = hasExplicitGradientGeometry(b);
-  if (!ea && !eb) {
-    if (a.angle !== void 0 || b.angle !== void 0 || a.type === "linear" || a.type === "reflected") {
-      const fallback = a.type === "linear" || a.type === "reflected" ? 180 : 90;
-      out.angle = lerpAngle(a.angle ?? fallback, b.angle ?? fallback, t);
-    }
-    if (a.type !== "linear" && a.type !== "reflected") {
-      out.cx = lerpN(a.cx ?? 0.5, b.cx ?? 0.5, t);
-      out.cy = lerpN(a.cy ?? 0.5, b.cy ?? 0.5, t);
-      out.r = lerpN(a.r ?? 0.5, b.r ?? 0.5, t);
-    }
-    return out;
-  }
-  const pa = vectorGradientPoints(a);
-  const pb = vectorGradientPoints(b);
-  if (pa.units !== pb.units) {
-    const src = explicitVectorGradient(near2);
-    return { ...src, stops: out.stops, ...out.interpolation ? { interpolation: out.interpolation } : {}, ...out.smoothness ? { smoothness: out.smoothness } : {} };
-  }
-  out.start = lerpPoint(pa.start, pb.start, t);
-  out.end = lerpPoint(pa.end, pb.end, t);
-  out.width = lerpPoint(pa.width, pb.width, t);
-  out.units = pa.units;
-  if (a.type === "radial") {
-    if (pa.focal || pb.focal) out.focal = lerpPoint(pa.focal ?? pa.start, pb.focal ?? pb.start, t);
-    const fr = lerpN(pa.focalRadius, pb.focalRadius, t);
-    if (fr > 0) out.focalRadius = fr;
-  }
-  return out;
-}
-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 && isVectorGradient(a) ? a : null;
-  const gb = pb && isVectorGradient(b) ? b : null;
-  if (ga && gb) return lerpGradient(ga, gb, t) ?? (t < 0.5 ? a : b);
-  if (gb) return lerpGradient(solidLike(pa ? a : null, gb), gb, t) ?? b;
-  if (ga) return lerpGradient(ga, solidLike(pb ? b : null, ga), t) ?? a;
-  return t < 0.5 ? a : b;
-}
-function interpolateWidthProfiles(a, b, t) {
-  if (!a?.length && !b?.length) return null;
-  const at2 = [...a ?? [], ...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) => !!d?.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(a.strokeWidth ?? 1, 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(a[key] ?? 1, b[key] ?? 1, t);
-  const dash = lerpDashes(a.strokeDasharray, b.strokeDasharray, t);
-  if (dash?.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 (s.strokeWidthProfile?.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_KEYS = [
-  "fill",
-  "stroke",
-  "strokeWidth",
-  "strokeLinecap",
-  "strokeLinejoin",
-  "strokeDasharray",
-  "fillRule",
-  "strokeAlign",
-  "startArrow",
-  "endArrow",
-  "arrowAlign",
-  "startArrowScale",
-  "endArrowScale",
-  "strokeWidthProfile"
-];
-function styleOf(n) {
-  const out = {};
-  for (const k of STYLE_KEYS) 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 = 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(a.opacity ?? 1, 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 = 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 = 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 sub5 = { ...options, id: `${id}-${i}`, starts: void 0 };
-    if (x && y) {
-      parts.push(preparePathMorph(x.path, y.path, sub5, 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), sub5, 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, sub5, 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) * (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, evaluateEasing(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/gradientStroke.ts
-var SHARP = 1.25;
-var TOLERANCE = 0.2;
-var OVERLAP = 0.5;
-var fmt2 = (n, digits = 3) => {
-  const k = 10 ** digits;
-  const v2 = Math.round(n * k) / k;
-  return Object.is(v2, -0) ? "0" : String(v2);
-};
-var toSvgStops2 = (stops) => stops.map((s) => ({ offset: `${fmt2(s.offset * 100)}%`, stopColor: s.color, ...s.opacity !== void 0 && s.opacity !== 1 ? { stopOpacity: Math.round(s.opacity * 1e4) / 1e4 } : {} }));
-var polygonD2 = (pts, precision) => `M${pts.map((p) => `${fmt2(p.x, precision)} ${fmt2(p.y, precision)}`).join("L")}Z`;
-var add4 = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
-var sub4 = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
-var scale2 = (a, k) => ({ x: a.x * k, y: a.y * k });
-var left = (d) => ({ x: d.y, y: -d.x });
-var unit3 = (v2) => {
-  const l = Math.hypot(v2.x, v2.y);
-  return l > 1e-12 ? { x: v2.x / l, y: v2.y / l } : { x: 1, y: 0 };
-};
-function flattenedSubpaths(node) {
-  const out = [];
-  for (const contour of pathToContours(subpathsToBezier(node.subpaths))) {
-    const segs = closeContour(contour);
-    if (!segs.length) continue;
-    const ring = flattenChain(segs, TOLERANCE);
-    const pts = ring.map(([x, y]) => ({ x, y })).filter((p, i, a) => i === 0 || Math.hypot(p.x - a[i - 1].x, p.y - a[i - 1].y) > 1e-9);
-    if (contour.closed && pts.length > 2 && Math.hypot(pts[0].x - pts[pts.length - 1].x, pts[0].y - pts[pts.length - 1].y) < 1e-9) pts.pop();
-    if (pts.length >= 2) out.push({ pts, closed: contour.closed && pts.length > 2 });
-  }
-  return out;
-}
-var signedArea = (pts) => {
-  let a = 0;
-  for (let i = 0; i < pts.length; i++) {
-    const p = pts[i];
-    const q = pts[(i + 1) % pts.length];
-    a += p.x * q.y - q.x * p.y;
-  }
-  return a / 2;
-};
-function vectorStrokeGradientDefs(g, id, node, options = {}) {
-  const precision = options.precision ?? 3;
-  const mode = g.strokeMode === "across" ? "across" : "along";
-  const expanded = expandVectorGradientStops(g);
-  const reach = vectorStrokeReach(node) + 1;
-  const area = options.area ?? vectorGradientArea(options.bounds && { x: options.bounds.x - reach, y: options.bounds.y - reach, width: options.bounds.width + 2 * reach, height: options.bounds.height + 2 * reach });
-  const width = node.strokeWidth ?? 1;
-  const align = node.strokeAlign ?? "center";
-  const profile = strokeWidthProfileOf(node);
-  const gradients = [];
-  const patches = [];
-  const slices = [];
-  const colourAt = (t) => {
-    const s = spanVectorGradientStops(g, t, t, expanded)[0];
-    return s;
-  };
-  let counter = 0;
-  const solid = (pts, t) => {
-    const s = colourAt(t);
-    const gid = `${id}-p${counter++}`;
-    gradients.push({ id: gid, type: "linear", attrs: { gradientUnits: "userSpaceOnUse", x1: 0, y1: 0, x2: 1, y2: 0 }, stops: toSvgStops2([{ ...s, offset: 0 }]) });
-    patches.push({ d: polygonD2(pts, precision), fill: `url(#${gid})` });
-  };
-  const disc = (c, r) => Array.from({ length: 16 }, (_, k) => add4(c, scale2({ x: Math.cos(k * Math.PI / 8), y: Math.sin(k * Math.PI / 8) }, r)));
-  for (const { pts, closed } of flattenedSubpaths(node)) {
-    const n = pts.length;
-    const segCount = closed ? n : n - 1;
-    const dirs = [];
-    const lengths = [0];
-    for (let i = 0; i < segCount; i++) {
-      const a = pts[i];
-      const b = pts[(i + 1) % n];
-      dirs.push(unit3(sub4(b, a)));
-      lengths.push(lengths[i] + Math.hypot(b.x - a.x, b.y - a.y));
-    }
-    const total = lengths[segCount];
-    if (!(total > 1e-9)) continue;
-    const tAt = (i) => lengths[i] / total;
-    const clockwise = closed && signedArea(pts) > 0;
-    const visibleLeft = align === "center" || !closed ? null : align === "inside" ? !clockwise : clockwise;
-    const ribs = [];
-    for (let i = 0; i < n; i++) {
-      const p = pts[i];
-      const din = i > 0 || closed ? dirs[(i - 1 + segCount) % segCount] : null;
-      const dout = i < segCount ? dirs[i] : null;
-      const square = (d) => ({ l: add4(p, scale2(left(d), reach)), r: sub4(p, scale2(left(d), reach)) });
-      if (!din || !dout) {
-        const rib = square(din ?? dout);
-        ribs.push({ before: rib, after: rib });
-        continue;
-      }
-      const nin = left(din);
-      const nout = left(dout);
-      const den = 1 + nin.x * nout.x + nin.y * nout.y;
-      const stretch = den > 1e-12 ? Math.sqrt(2 / den) : Infinity;
-      if (stretch <= SHARP) {
-        const m = scale2(add4(nin, nout), reach / den);
-        const rib = { l: add4(p, m), r: sub4(p, m) };
-        ribs.push({ before: rib, after: rib });
-      } else {
-        ribs.push({ before: square(din), after: square(dout) });
-        solid(disc(p, reach * 1.5), tAt(i));
-      }
-    }
-    if (!closed) {
-      const d0 = dirs[0];
-      const d1 = dirs[segCount - 1];
-      const a = pts[0];
-      const b = pts[n - 1];
-      const cap = (p, d) => [add4(p, scale2(left(d), reach)), add4(add4(p, scale2(d, reach)), scale2(left(d), reach)), sub4(add4(p, scale2(d, reach)), scale2(left(d), reach)), sub4(p, scale2(left(d), reach))];
-      solid(cap(a, scale2(d0, -1)), 0);
-      solid(cap(b, d1), 1);
-    }
-    for (let i = 0; i < segCount; i++) {
-      const j = (i + 1) % n;
-      const a = pts[i];
-      const b = pts[j];
-      const d = dirs[i];
-      const from = ribs[i].after;
-      const to = ribs[j].before;
-      const ext = scale2(d, OVERLAP);
-      const quad = [from.l, add4(to.l, ext), add4(to.r, ext), from.r];
-      const gid = `${id}-s${counter++}`;
-      const t0 = tAt(i);
-      const t1 = closed && i === segCount - 1 ? 1 : tAt(i + 1);
-      if (mode === "along") {
-        gradients.push({
-          id: gid,
-          type: "linear",
-          attrs: { gradientUnits: "userSpaceOnUse", x1: fmt2(a.x, 4), y1: fmt2(a.y, 4), x2: fmt2(b.x, 4), y2: fmt2(b.y, 4) },
-          stops: toSvgStops2(spanVectorGradientStops(g, t0, t1, expanded))
-        });
-      } else {
-        const mid = scale2(add4(a, b), 0.5);
-        const side = widthProfileAt(profile, (t0 + t1) / 2);
-        const nrm = left(d);
-        const reachL = visibleLeft === null ? width / 2 * side.left : visibleLeft ? width * side.left : 0;
-        const reachR = visibleLeft === null ? width / 2 * side.right : visibleLeft ? 0 : width * side.right;
-        const p0 = add4(mid, scale2(nrm, reachL));
-        const p1 = sub4(mid, scale2(nrm, reachR));
-        gradients.push({
-          id: gid,
-          type: "linear",
-          attrs: { gradientUnits: "userSpaceOnUse", x1: fmt2(p0.x, 4), y1: fmt2(p0.y, 4), x2: fmt2(p1.x, 4), y2: fmt2(p1.y, 4) },
-          stops: toSvgStops2(expanded)
-        });
-      }
-      slices.push({ d: polygonD2(quad, precision), fill: `url(#${gid})` });
-    }
-  }
-  const def = {
-    id,
-    type: "pattern",
-    attrs: patternAttrs(area),
-    gradients,
-    tiles: [...patches, ...slices]
-  };
-  return [def];
-}
-
-// src/vector/svg.ts
-function vectorCornersAttribute(subpaths, precision = 3) {
-  const out = [];
-  subpaths.forEach(
-    (sp, s) => sp.anchors.forEach((a, i) => {
-      if (!a.corner || !(a.corner.radius > 0)) return;
-      out.push(`${s}.${i}:${formatNumber(a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
-    })
-  );
-  return out.join(" ");
-}
-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 = subpaths[+m[1]]?.anchors[+m[2]];
-    const radius = parseFloat(m[3]);
-    if (!a || !(radius > 0)) continue;
-    const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
-    a.corner = { radius, ...kind && kind !== "round" ? { kind } : {} };
-  }
-  return subpaths;
-}
-var escapeAttr2 = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-function vectorPathLocalBounds(node) {
-  const b = bezierPathBounds(subpathsToBezier(node.subpaths));
-  return b ? { x: b.minX, y: b.minY, width: b.maxX - b.minX, height: b.maxY - b.minY } : null;
-}
-var paintCache = /* @__PURE__ */ new WeakMap();
-function vectorPaintToSvg(paint, gradientId, options = {}) {
-  if (!hasPaint(paint)) return { value: "none", defs: [] };
-  if (typeof paint === "string") return { value: paint, defs: [] };
-  if (!isVectorGradient(paint)) return { value: "none", defs: [] };
-  const role = options.role ?? "fill";
-  const precision = options.precision ?? 3;
-  const key = `${gradientId}|${role}|${precision}`;
-  const owner = options.node ?? paint;
-  const cached = paintCache.get(owner)?.get(key);
-  if (cached && (!options.node || (role === "fill" ? options.node.fill : options.node.stroke) === paint)) return { value: `url(#${gradientId})`, defs: cached };
-  const node = options.node;
-  const bounds = node ? vectorPathLocalBounds(node) : null;
-  const reach = node && role === "stroke" ? vectorStrokeReach(node) + 1 : 1;
-  const area = bounds ? { x: bounds.x - reach, y: bounds.y - reach, width: bounds.width + 2 * reach, height: bounds.height + 2 * reach } : null;
-  const defs = node && role === "stroke" && (paint.strokeMode === "along" || paint.strokeMode === "across") ? vectorStrokeGradientDefs(paint, gradientId, node, { bounds, area, precision }) : vectorGradientSvgDefs(paint, gradientId, { bounds, area, precision });
-  let byKey = paintCache.get(owner);
-  if (!byKey) paintCache.set(owner, byKey = /* @__PURE__ */ new Map());
-  byKey.set(key, defs);
-  return { value: `url(#${gradientId})`, defs };
-}
-var partsCache = /* @__PURE__ */ new WeakMap();
-function vectorStrokeSvgParts(node, clipId, precision = 3) {
-  if (!hasPaint(node.stroke) || !hasStrokeExtras(node)) return void 0;
-  const hit = partsCache.get(node);
-  if (hit && hit.clipId === clipId && hit.precision === precision) return hit.parts;
-  const parts = computeStrokeSvgParts(node, clipId, precision);
-  partsCache.set(node, { clipId, precision, parts });
-  return parts;
-}
-function computeStrokeSvgParts(node, clipId, precision) {
-  const path = subpathsToBezier(node.subpaths);
-  const parts = vectorStrokeParts(path, node);
-  const profiled = !!strokeWidthProfileOf(node);
-  if (parts.align === "center" && !parts.heads.length && !profiled) return void 0;
-  let clip = null;
-  if (parts.align !== "center") {
-    const b = bezierPathBounds(path);
-    const pad = vectorStrokeReach(node) + 1;
-    const bounds = b ? { x: round2(b.minX - pad), y: round2(b.minY - pad), width: round2(b.maxX - b.minX + 2 * pad), height: round2(b.maxY - b.minY + 2 * pad) } : { x: 0, y: 0, width: 0, height: 0 };
-    clip = { kind: parts.align === "inside" ? "clip" : "mask", id: clipId, bounds };
-  }
-  return {
-    align: parts.align,
-    d: bezierPathToSvg(parts.line, { precision }),
-    width: parts.drawWidth,
-    ...profiled && (node.strokeWidth ?? 1) > 0 ? { outline: bezierPathToSvg(vectorStrokeLineArea(parts, node), { precision }) } : {},
-    clip,
-    heads: parts.heads.map((h) => bezierPathToSvg(h.path, { precision }))
-  };
-}
-function vectorNodeLocalPaintBounds(node) {
-  const drawn = expandVectorAppearance(node);
-  const reach = (n) => n.type === "path" ? vectorStrokeStackReach(n) : Math.max(0, ...n.children.map(reach));
-  let b;
-  if (drawn.type === "path") b = vectorPathLocalBounds(drawn);
-  else b = unionBounds(drawn.children.filter((c) => c.visible !== false).map((c) => vectorNodeBounds(c, IDENTITY_MATRIX)));
-  if (!b) return null;
-  const pad = reach(drawn);
-  return { x: b.x - pad, y: b.y - pad, width: b.width + 2 * pad, height: b.height + 2 * pad };
-}
-var filterCache = /* @__PURE__ */ new WeakMap();
-function vectorNodeFilterSvg(node, id) {
-  if (!node.filters?.length) return null;
-  const hit = filterCache.get(node);
-  if (hit && hit.id === id) return hit.filter;
-  const active = activeVectorFilters(node);
-  const filter = active.length ? vectorFilterSvg(active, id, vectorNodeLocalPaintBounds(node)) : null;
-  filterCache.set(node, { id, filter });
-  return filter;
-}
-function widthProfileToAttribute(points, precision = 4) {
-  return points.map((p) => [p.t, p.left, p.right].map((n) => formatNumber(n, precision)).join(",")).join(";");
-}
-function widthProfileFromAttribute(value) {
-  if (!value) return [];
-  return sanitizeWidthProfile(
-    value.split(";").map((part) => {
-      const [t, left2, right] = part.split(",").map((n) => parseFloat(n));
-      return { t, left: left2, right: Number.isFinite(right) ? right : left2 };
-    })
-  );
-}
-var round2 = (n) => Math.round(n * 100) / 100;
-function gradientMarkup(def, extra = "") {
-  const tag = def.type === "radial" ? "radialGradient" : "linearGradient";
-  const attrs = Object.entries(def.attrs).map(([k, v2]) => ` ${k}="${escapeAttr2(String(v2))}"`).join("");
-  const stops = def.stops.map((s) => `<stop offset="${s.offset}" stop-color="${escapeAttr2(s.stopColor)}"${s.stopOpacity !== void 0 ? ` stop-opacity="${s.stopOpacity}"` : ""}/>`).join("");
-  return `<${tag} id="${escapeAttr2(def.id)}"${attrs}${extra}>${stops}</${tag}>`;
-}
-function paintDefMarkup(def, gradient) {
-  const extra = gradient ? ` data-vector-gradient="${escapeAttr2(JSON.stringify(gradient))}"` : "";
-  if (def.type !== "pattern") return gradientMarkup(def, extra);
-  const attrs = Object.entries(def.attrs).map(([k, v2]) => ` ${k}="${escapeAttr2(String(v2))}"`).join("");
-  const inner = def.gradients.map((g) => gradientMarkup(g)).join("") + def.tiles.map((t) => `<path d="${t.d}" fill="${escapeAttr2(t.fill)}"/>`).join("");
-  return `<pattern id="${escapeAttr2(def.id)}"${attrs}${extra}>${inner}</pattern>`;
-}
-var paintMarkup = (paint, defs) => defs.map((d, i) => paintDefMarkup(d, i === 0 && isVectorGradient(paint) ? paint : void 0));
-function blendFromAttribute(value, m) {
-  if (!value) return null;
-  let raw;
-  try {
-    raw = JSON.parse(value);
-  } catch {
-    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 = options.precision ?? 3;
-  const prefix = options.idPrefix ?? "vg-";
-  const pretty = options.pretty !== false;
-  const defs = [];
-  const lines = [];
-  const num2 = (n) => formatNumber(n, precision);
-  const indent = (depth) => pretty ? "  ".repeat(depth) : "";
-  const common = (node) => {
-    let out2 = ` id="${escapeAttr2(node.id)}"`;
-    if (node.transform) out2 += ` transform="matrix(${node.transform.map((n) => formatNumber(n, 6)).join(" ")})"`;
-    if (node.opacity !== void 0 && node.opacity < 1) out2 += ` opacity="${num2(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="${escapeAttr2(JSON.stringify(node.blend))}"`;
-    if (node.booleanOperation) out2 += ` data-vector-boolean-operation="${node.booleanOperation}"`;
-    const blend = vectorBlendModeCss(node.blendMode);
-    if (blend) out2 += ` style="mix-blend-mode:${blend}"`;
-    if (node.filters?.length) {
-      const filter = vectorNodeFilterSvg(node, `${prefix}filter-${node.id}`);
-      const data = ` data-vector-filters="${escapeAttr2(JSON.stringify(node.filters))}"`;
-      if (filter) {
-        defs.push(vectorFilterMarkup(filter, data));
-        out2 += ` filter="url(#${escapeAttr2(filter.id)})"`;
-      } else out2 += data;
-    }
-    return out2;
-  };
-  const layerAttrs = (layer) => {
-    let out2 = "";
-    if (layer.opacity !== void 0 && layer.opacity < 1) out2 += ` opacity="${num2(layer.opacity)}"`;
-    const blend = vectorBlendModeCss(layer.blendMode);
-    if (blend) out2 += ` style="mix-blend-mode:${blend}"`;
-    return out2;
-  };
-  const strokePartLines = (node, parts, strokeValue, d, lineAttrs, depth) => {
-    const out2 = [];
-    if (options.strokes === "outline") {
-      const area = bezierPathToSvg(vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
-      out2.push(`${indent(depth)}<path data-vector-part="stroke-outline" d="${area}" fill="${escapeAttr2(strokeValue)}"/>`);
-      return out2;
-    }
-    let clip = "";
-    if (parts.clip) {
-      const rule = node.fillRule === "evenodd" ? "evenodd" : "nonzero";
-      const id = escapeAttr2(parts.clip.id);
-      if (parts.clip.kind === "clip") {
-        defs.push(`<clipPath id="${id}"><path d="${d}" clip-rule="${rule}"/></clipPath>`);
-        clip = ` clip-path="url(#${id})"`;
-      } else {
-        const b = parts.clip.bounds;
-        const box = `x="${num2(b.x)}" y="${num2(b.y)}" width="${num2(b.width)}" height="${num2(b.height)}"`;
-        defs.push(`<mask id="${id}" maskUnits="userSpaceOnUse" ${box}><rect ${box} fill="#fff"/><path d="${d}" fill="#000" fill-rule="${rule}"/></mask>`);
-        clip = ` mask="url(#${id})"`;
-      }
-    }
-    if (parts.outline !== void 0) out2.push(`${indent(depth)}<path data-vector-part="stroke-outline" d="${parts.outline}" fill="${escapeAttr2(strokeValue)}"${clip}/>`);
-    else out2.push(`${indent(depth)}<path data-vector-part="stroke" d="${parts.d}" fill="none"${lineAttrs(parts.width)}${clip}/>`);
-    for (const h2 of parts.heads) out2.push(`${indent(depth)}<path data-vector-part="head" d="${h2}" fill="${escapeAttr2(strokeValue)}"/>`);
-    return out2;
-  };
-  const lineAttrsOf = (node, strokeValue) => (width) => {
-    let out2 = ` stroke="${escapeAttr2(strokeValue)}" stroke-width="${num2(width)}"`;
-    if (node.strokeLinecap && node.strokeLinecap !== "butt") out2 += ` stroke-linecap="${node.strokeLinecap}"`;
-    if (node.strokeLinejoin && node.strokeLinejoin !== "miter") out2 += ` stroke-linejoin="${node.strokeLinejoin}"`;
-    if (node.strokeDasharray?.length) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
-    return out2;
-  };
-  const liveCorners = (node) => {
-    const corners = vectorCornersAttribute(node.subpaths, precision);
-    return corners ? ` data-vector-d="${bezierPathToSvg(subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners}"` : "";
-  };
-  const emitStacked = (node, depth) => {
-    const d = vectorPathData(node, precision);
-    const rule = node.fillRule === "evenodd" ? ` fill-rule="evenodd"` : "";
-    let data = ` data-vector-path="" data-vector-fills="${escapeAttr2(JSON.stringify(vectorFills(node)))}" data-vector-strokes="${escapeAttr2(JSON.stringify(vectorStrokes(node)))}"`;
-    if (node.fillRule === "evenodd") data += ` data-vector-fill-rule="evenodd"`;
-    lines.push(`${indent(depth)}<g${common(node)}${data}>`);
-    const layers = vectorPaintLayerNodes(node).filter((l) => l.drawn);
-    let geometry = liveCorners(node);
-    if (!layers.some((l) => l.kind === "fill")) {
-      lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}" fill="none"${rule}${geometry}/>`);
-      geometry = "";
-    }
-    for (const l of layers) {
-      const id = `${prefix}${l.kind}-${node.id}-${l.index}`;
-      const paint = vectorPaintToSvg(l.layer.paint, id, { node: l.node, precision, ...l.kind === "stroke" ? { role: "stroke" } : {} });
-      defs.push(...paintMarkup(l.layer.paint, paint.defs));
-      const attrs = ` data-vector-layer="${l.index}"${layerAttrs(l.layer)}`;
-      if (l.kind === "fill") {
-        lines.push(`${indent(depth + 1)}<path data-vector-part="fill"${attrs} d="${d}" fill="${escapeAttr2(paint.value)}"${rule}${geometry}/>`);
-        geometry = "";
-        continue;
-      }
-      const lineAttrs = lineAttrsOf(l.node, paint.value);
-      const parts = vectorStrokeSvgParts(l.node, `${prefix}clip-${node.id}-${l.index}`, precision);
-      if (!parts) {
-        lines.push(`${indent(depth + 1)}<path data-vector-part="stroke"${attrs} d="${d}" fill="none"${lineAttrs(l.node.strokeWidth ?? 1)}/>`);
-        continue;
-      }
-      lines.push(`${indent(depth + 1)}<g data-vector-part="stroke-layer"${attrs}>`);
-      lines.push(...strokePartLines(l.node, parts, paint.value, d, lineAttrs, depth + 2));
-      lines.push(`${indent(depth + 1)}</g>`);
-    }
-    lines.push(`${indent(depth)}</g>`);
-  };
-  const emit2 = (node, depth) => {
-    if (node.visible === false && !options.includeHidden) return;
-    const wrappers = options.wrap?.[node.id] ?? [];
-    wrappers.forEach((w2, i) => {
-      let attrs = w2.id !== void 0 ? ` id="${escapeAttr2(w2.id)}"` : "";
-      if (w2.transform) attrs += ` transform="${escapeAttr2(w2.transform)}"`;
-      if (w2.clip) {
-        const shape = Object.entries(w2.clip.attrs).map(([k, v2]) => ` ${k}="${formatNumber(v2, 4)}"`).join("");
-        defs.push(`<clipPath id="${escapeAttr2(w2.clip.id)}" clipPathUnits="objectBoundingBox"><${w2.clip.shape}${w2.clip.shapeId !== void 0 ? ` id="${escapeAttr2(w2.clip.shapeId)}"` : ""}${shape}/></clipPath>`);
-        attrs += ` clip-path="url(#${escapeAttr2(w2.clip.id)})"`;
-      }
-      lines.push(`${indent(depth + i)}<g${attrs}>`);
-    });
-    emitNode(node, depth + wrappers.length);
-    for (let i = wrappers.length - 1; i >= 0; i--) lines.push(`${indent(depth + i)}</g>`);
-  };
-  const capture = (fn) => {
-    const at2 = lines.length;
-    fn();
-    return lines.splice(at2).map((l) => l.trim()).join("");
-  };
-  const emitMaskGroup = (node, depth) => {
-    const [source, ...contents] = node.children;
-    const body = node.effects?.length && contents.length ? [{ id: `${node.id}~content`, type: "group", effects: node.effects, children: contents }] : contents;
-    const settings = { type: node.mask.type, ...node.mask.invert ? { invert: true } : {} };
-    lines.push(`${indent(depth)}<g${common(node)} data-vector-mask="${escapeAttr2(JSON.stringify(settings))}">`);
-    const mask = vectorMaskRenderData(node, `${prefix}mask-${node.id}`, `${prefix}mask-filter-${node.id}`, precision);
-    let ref = "";
-    if (mask && mask.type !== "clip") {
-      const b = mask.bounds;
-      const box = `x="${num2(b.x)}" y="${num2(b.y)}" width="${num2(b.width)}" height="${num2(b.height)}"`;
-      if (mask.invertFilter) defs.push(vectorFilterMarkup(mask.invertFilter));
-      const inner = capture(() => emitNode(source, depth + 1));
-      const drawn = mask.filter ? `<g data-vector-part="mask-invert" filter="${escapeAttr2(mask.filter)}">${inner}</g>` : inner;
-      defs.push(`<mask id="${escapeAttr2(mask.id)}" data-vector-part="mask-source" maskUnits="userSpaceOnUse" ${box}${mask.type === "alpha" ? ' mask-type="alpha"' : ""}>${drawn}</mask>`);
-      ref = ` mask="url(#${escapeAttr2(mask.id)})"`;
-    } else {
-      lines.push(`${indent(depth + 1)}<g data-vector-part="mask-source" display="none">`);
-      emitNode(source, depth + 2);
-      lines.push(`${indent(depth + 1)}</g>`);
-      if (mask?.clip) {
-        defs.push(`<clipPath id="${escapeAttr2(mask.id)}">${mask.clip.map((c) => `<path d="${c.d}" clip-rule="${c.clipRule}"/>`).join("")}</clipPath>`);
-        ref = ` clip-path="url(#${escapeAttr2(mask.id)})"`;
-      }
-    }
-    lines.push(`${indent(depth + 1)}<g data-vector-part="masked"${ref}>`);
-    for (const child of body) emit2(child, depth + 2);
-    lines.push(`${indent(depth + 1)}</g>`);
-    lines.push(`${indent(depth)}</g>`);
-  };
-  const emitNode = (node, depth) => {
-    if (isVectorMaskGroup(node)) {
-      emitMaskGroup(node, depth);
-      return;
-    }
-    if (hasOwnVectorAppearance(node)) {
-      const live2 = {
-        kind: node.type,
-        ...node.effects?.length ? { effects: node.effects } : {},
-        ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {}
-      };
-      lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr2(JSON.stringify(live2))}">`);
-      lines.push(`${indent(depth + 1)}<g data-vector-part="appearance">`);
-      for (const shape of vectorAppearanceNodes(node)) emit2(shape, depth + 2);
-      lines.push(`${indent(depth + 1)}</g>`);
-      lines.push(`${indent(depth + 1)}<g data-vector-part="source" display="none">`);
-      if (node.type === "path") {
-        const { effects: _e, transform: _t, opacity: _o, visible: _v, booleanOperation: _b, blendStep: _s, blendMode: _bm, filters: _f, ...source } = node;
-        emit2({ ...source, id: `${node.id}~src` }, depth + 2);
-      } else for (const child of node.children) emit2(child, depth + 2);
-      lines.push(`${indent(depth + 1)}</g>`);
-      lines.push(`${indent(depth)}</g>`);
-      return;
-    }
-    if (node.type === "group") {
-      lines.push(`${indent(depth)}<g${common(node)}>`);
-      for (const child of node.children) emit2(child, depth + 1);
-      lines.push(`${indent(depth)}</g>`);
-      return;
-    }
-    if (needsVectorPaintLayers(node)) {
-      emitStacked(node, depth);
-      return;
-    }
-    const fill = vectorPaintToSvg(node.fill, `${prefix}fill-${node.id}`, { node, precision });
-    const stroke = vectorPaintToSvg(node.stroke, `${prefix}stroke-${node.id}`, { node, role: "stroke", precision });
-    defs.push(...paintMarkup(node.fill, fill.defs), ...paintMarkup(node.stroke, stroke.defs));
-    const d = vectorPathData(node, precision);
-    const live = liveCorners(node);
-    const fillAttrs = ` fill="${escapeAttr2(fill.value)}"${node.fillRule === "evenodd" ? ` fill-rule="evenodd"` : ""}`;
-    const lineAttrs = lineAttrsOf(node, stroke.value);
-    const parts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${prefix}clip-${node.id}`, precision) : void 0;
-    if (!parts) {
-      lines.push(`${indent(depth)}<path${common(node)} d="${d}"${fillAttrs}${stroke.value !== "none" ? lineAttrs(node.strokeWidth ?? 1) : ""}${live}/>`);
-      return;
-    }
-    let data = ` data-vector-path="" data-vector-stroke-width="${num2(node.strokeWidth ?? 1)}"`;
-    if (parts.align !== "center") data += ` data-vector-stroke-align="${parts.align}"`;
-    if (node.startArrow) data += ` data-vector-start-arrow="${node.startArrow}"`;
-    if (node.endArrow) data += ` data-vector-end-arrow="${node.endArrow}"`;
-    if (node.arrowAlign && node.arrowAlign !== "extend") data += ` data-vector-arrow-align="${node.arrowAlign}"`;
-    if (node.startArrowScale !== void 0 && node.startArrowScale !== 1) data += ` data-vector-start-arrow-scale="${num2(node.startArrowScale)}"`;
-    if (node.endArrowScale !== void 0 && node.endArrowScale !== 1) data += ` data-vector-end-arrow-scale="${num2(node.endArrowScale)}"`;
-    const profile = strokeWidthProfileOf(node);
-    if (profile) {
-      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 (node.strokeDasharray?.length) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
-    }
-    lines.push(`${indent(depth)}<g${common(node)}${data}>`);
-    lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}"${fillAttrs}${live}/>`);
-    lines.push(...strokePartLines(node, parts, stroke.value, d, lineAttrs, depth + 1));
-    lines.push(`${indent(depth)}</g>`);
-  };
-  for (const node of doc.nodes) emit2(node, 1);
-  const w = num2(doc.width);
-  const h = num2(doc.height);
-  const nl = pretty ? "\n" : "";
-  const out = [`<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">`];
-  if (defs.length) out.push(`${indent(1)}<defs>${defs.join("")}</defs>`);
-  if (doc.background && options.background !== false && hasPaint(doc.background)) {
-    out.push(`${indent(1)}<rect width="${w}" height="${h}" fill="${escapeAttr2(doc.background)}"/>`);
-  }
-  out.push(...lines, "</svg>");
-  return out.join(nl);
-}
-var BOOLEAN_OPERATIONS = ["union", "subtract", "intersect", "exclude"];
-function parseXml(source) {
-  const text = source.replace(/<!--[\s\S]*?-->/g, "").replace(/<\?[\s\S]*?\?>/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "").replace(/<!DOCTYPE[^>[]*(\[[\s\S]*?\])?\s*>/gi, "");
-  const root = { name: "#root", attrs: {}, children: [] };
-  const stack = [root];
-  const tag = /<(\/?)([A-Za-z_][\w:.-]*)((?:\s+[^\s=/>]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?)*)\s*(\/?)>/g;
-  const attr = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
-  let m;
-  while (m = tag.exec(text)) {
-    const [, closing, rawName, rawAttrs, selfClosing] = m;
-    const name = rawName.replace(/^svg:/, "");
-    if (closing) {
-      for (let i = stack.length - 1; i > 0; i--) {
-        if (stack[i].name === name) {
-          stack.length = i;
-          break;
-        }
-      }
-      continue;
-    }
-    const attrs = {};
-    let a;
-    attr.lastIndex = 0;
-    while (a = attr.exec(rawAttrs)) attrs[a[1]] = decodeEntities(a[2] ?? a[3] ?? a[4] ?? "");
-    const el = { name, attrs, children: [] };
-    stack[stack.length - 1].children.push(el);
-    if (!selfClosing) stack.push(el);
-  }
-  const find = (el) => {
-    if (el.name === "svg") return el;
-    for (const c of el.children) {
-      const f = find(c);
-      if (f) return f;
-    }
-    return null;
-  };
-  return find(root);
-}
-function decodeEntities(s) {
-  return s.replace(/&#x([0-9a-f]+);/gi, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10))).replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
-}
-var numberList = (s) => (s ?? "").trim().split(/[\s,]+|(?=-)(?<![eE])/).filter(Boolean).map(Number).filter((n) => Number.isFinite(n));
-var length = (s, fallback = 0) => {
-  if (s === void 0) return fallback;
-  const n = parseFloat(s);
-  return Number.isFinite(n) ? n : fallback;
-};
-function parseSvgTransform(value) {
-  let m = IDENTITY_MATRIX;
-  if (!value) return m;
-  const re = /(matrix|translate|scale|rotate|skewX|skewY)\s*\(([^)]*)\)/g;
-  let t;
-  while (t = re.exec(value)) {
-    const n = numberList(t[2]);
-    let step = IDENTITY_MATRIX;
-    switch (t[1]) {
-      case "matrix":
-        if (n.length >= 6) step = [n[0], n[1], n[2], n[3], n[4], n[5]];
-        break;
-      case "translate":
-        step = translateMatrix(n[0] ?? 0, n[1] ?? 0);
-        break;
-      case "scale":
-        step = scaleMatrix(n[0] ?? 1, n[1] ?? n[0] ?? 1);
-        break;
-      case "rotate":
-        step = rotateMatrix(n[0] ?? 0, { x: n[1] ?? 0, y: n[2] ?? 0 });
-        break;
-      case "skewX":
-        step = [1, 0, Math.tan((n[0] ?? 0) * Math.PI / 180), 1, 0, 0];
-        break;
-      case "skewY":
-        step = [1, Math.tan((n[0] ?? 0) * Math.PI / 180), 0, 1, 0, 0];
-        break;
-    }
-    m = multiplyMatrices(step, m);
-  }
-  return m;
-}
-var STYLE_KEYS2 = {
-  fill: "fill",
-  stroke: "stroke",
-  "stroke-width": "strokeWidth",
-  "stroke-linecap": "strokeLinecap",
-  "stroke-linejoin": "strokeLinejoin",
-  "stroke-dasharray": "strokeDasharray",
-  "fill-rule": "fillRule",
-  "fill-opacity": "fillOpacity",
-  "stroke-opacity": "strokeOpacity",
-  "mix-blend-mode": "mixBlendMode",
-  filter: "filter"
-};
-function readStyle(el, parent) {
-  const { mixBlendMode: _m, filter: _f, ...inherited } = parent;
-  const out = { ...inherited };
-  for (const [attr, key] of Object.entries(STYLE_KEYS2)) if (el.attrs[attr] !== void 0) out[key] = el.attrs[attr].trim();
-  for (const decl of (el.attrs.style ?? "").split(";")) {
-    const i = decl.indexOf(":");
-    if (i < 0) continue;
-    const key = STYLE_KEYS2[decl.slice(0, i).trim()];
-    if (key) out[key] = decl.slice(i + 1).replace(/!important/, "").trim();
-  }
-  return out;
-}
-function readStops(el) {
-  return el.children.filter((c) => c.name === "stop").map((c) => {
-    const style = Object.fromEntries(
-      (c.attrs.style ?? "").split(";").map((d) => d.split(":").map((s) => s.trim())).filter((d) => d.length === 2)
-    );
-    const raw = c.attrs.offset ?? "0";
-    const offset = raw.endsWith("%") ? parseFloat(raw) / 100 : parseFloat(raw);
-    const opacity = style["stop-opacity"] ?? c.attrs["stop-opacity"];
-    return {
-      offset: Number.isFinite(offset) ? Math.max(0, Math.min(1, offset)) : 0,
-      color: style["stop-color"] ?? c.attrs["stop-color"] ?? "#000",
-      ...opacity !== void 0 ? { opacity: parseFloat(opacity) } : {}
-    };
-  });
-}
-var fraction = (s, fallback) => {
-  if (s === void 0) return fallback;
-  const n = parseFloat(s);
-  if (!Number.isFinite(n)) return fallback;
-  return s.trim().endsWith("%") ? n / 100 : n;
-};
-var PAINT_SERVERS = /* @__PURE__ */ new Set(["linearGradient", "radialGradient", "pattern"]);
-function collectGradients(el, raw) {
-  if (PAINT_SERVERS.has(el.name) && el.attrs.id) raw.set(el.attrs.id, el);
-  for (const c of el.children) collectGradients(c, raw);
-}
-function collectMasks(el, raw) {
-  if ((el.name === "clipPath" || el.name === "mask") && el.attrs.id) raw.set(el.attrs.id, el);
-  for (const c of el.children) collectMasks(c, raw);
-}
-function attrOrStyle(el, name) {
-  for (const decl of (el.attrs.style ?? "").split(";")) {
-    const i = decl.indexOf(":");
-    if (i >= 0 && decl.slice(0, i).trim() === name) return decl.slice(i + 1).replace(/!important/, "").trim();
-  }
-  return el.attrs[name];
-}
-function urlId(value) {
-  return /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec((value ?? "").trim())?.[1] ?? null;
-}
-function clipRulesAsFillRules(el) {
-  const attrs = { ...el.attrs };
-  const rule = attrOrStyle(el, "clip-rule");
-  if (rule) attrs["fill-rule"] = rule;
-  return { ...el, attrs, children: el.children.map(clipRulesAsFillRules) };
-}
-function collectFilters(el, raw) {
-  if (el.name === "filter" && el.attrs.id) raw.set(el.attrs.id, el);
-  for (const c of el.children) collectFilters(c, raw);
-}
-function filtersFromElement(el) {
-  const own = el.attrs["data-vector-filters"];
-  if (own !== void 0) {
-    try {
-      return sanitizeVectorFilters(JSON.parse(own));
-    } catch {
-      return [];
-    }
-  }
-  const prims = el.children.filter((c) => c.name.startsWith("fe"));
-  const out = [];
-  for (const p of prims) {
-    const std = numberList(p.attrs.stdDeviation)[0] ?? 0;
-    if (p.name === "feDropShadow") {
-      const style = Object.fromEntries(
-        (p.attrs.style ?? "").split(";").map((d) => d.split(":").map((x) => x.trim())).filter((d) => d.length === 2)
-      );
-      const opacity = parseFloat(style["flood-opacity"] ?? p.attrs["flood-opacity"] ?? "1");
-      out.push({
-        type: "dropShadow",
-        params: {
-          color: style["flood-color"] ?? p.attrs["flood-color"] ?? "#000000",
-          opacity: Number.isFinite(opacity) ? opacity : 1,
-          offsetX: length(p.attrs.dx, 2),
-          offsetY: length(p.attrs.dy, 2),
-          blur: std * 2,
-          spread: 0
-        }
-      });
-    } else if (p.name === "feGaussianBlur" && prims.length === 1 && (p.attrs.in === void 0 || p.attrs.in === "SourceGraphic")) {
-      out.push({ type: "layerBlur", params: { radius: std * 2 } });
-    } else return [];
-  }
-  return sanitizeVectorFilters(out);
-}
-function gradientFromAttribute(value) {
-  if (!value) return null;
-  try {
-    return sanitizeVectorGradient(JSON.parse(value));
-  } catch {
-    return null;
-  }
-}
-function resolveGradient(id, raw) {
-  const first = raw.get(id);
-  if (!first) return null;
-  const own = gradientFromAttribute(first.attrs["data-vector-gradient"]);
-  if (own) return own;
-  if (first.name === "pattern") return null;
-  const chain = [];
-  for (let el = first; el && !chain.includes(el) && chain.length < 32; ) {
-    chain.push(el);
-    const href = el.attrs.href ?? el.attrs["xlink:href"];
-    el = href?.startsWith("#") ? raw.get(href.slice(1)) : void 0;
-  }
-  const attr = (name) => chain.find((el) => el.attrs[name] !== void 0)?.attrs[name];
-  const stops = chain.map(readStops).find((s) => s.length) ?? [];
-  if (!stops.length) return null;
-  const user = attr("gradientUnits") === "userSpaceOnUse";
-  const t = parseSvgTransform(attr("gradientTransform"));
-  const plain2 = t === IDENTITY_MATRIX || t[0] === 1 && t[1] === 0 && t[2] === 0 && t[3] === 1 && t[4] === 0 && t[5] === 0;
-  const at2 = (name, fallback) => user ? length(attr(name), fallback) : fraction(attr(name), fallback);
-  const spreadAttr = attr("spreadMethod");
-  const spread = spreadAttr === "reflect" || spreadAttr === "repeat" ? { spread: spreadAttr } : {};
-  const map = (p) => applySvgMatrix(t, p);
-  if (first.name === "radialGradient") {
-    const cx = at2("cx", user ? 0 : 0.5);
-    const cy = at2("cy", user ? 0 : 0.5);
-    const r = at2("r", user ? 0 : 0.5);
-    const fx = attr("fx") !== void 0 ? at2("fx", cx) : cx;
-    const fy = attr("fy") !== void 0 ? at2("fy", cy) : cy;
-    const fr = attr("fr") !== void 0 ? at2("fr", 0) : 0;
-    const focal = Math.abs(fx - cx) > 1e-9 || Math.abs(fy - cy) > 1e-9;
-    if (!user && plain2 && !focal && !(fr > 0)) return { type: "radial", cx, cy, r, stops, ...spread };
-    const g = {
-      type: "radial",
-      stops,
-      start: map({ x: cx, y: cy }),
-      end: map({ x: cx + r, y: cy }),
-      width: map({ x: cx, y: cy + r }),
-      units: user ? "userSpaceOnUse" : "objectBoundingBox",
-      ...spread
-    };
-    if (focal) g.focal = map({ x: fx, y: fy });
-    if (fr > 0 && r > 0) g.focalRadius = Math.min(0.99, fr / r);
-    return g;
-  }
-  const x1 = at2("x1", 0);
-  const y1 = at2("y1", 0);
-  const x2 = attr("x2") !== void 0 ? at2("x2", 1) : user ? 0 : 1;
-  const y2 = at2("y2", 0);
-  if (!user && plain2) {
-    const angle = Math.round((Math.atan2(x2 - x1, -(y2 - y1)) * 180 / Math.PI + 360) % 360);
-    const c = angleToSvgLinearCoords(angle);
-    const len2 = Math.hypot(x2 - x1, y2 - y1);
-    const d = len2 > 0 ? { x: (x2 - x1) / len2, y: (y2 - y1) / len2 } : { x: 0, y: 1 };
-    const along2 = (x, y) => x * d.x + y * d.y;
-    const same2 = len2 > 0 && Math.abs((c.x2 - c.x1) * d.y - (c.y2 - c.y1) * d.x) < 1e-3 && Math.abs(along2(c.x1, c.y1) - along2(x1, y1)) < 1e-3 && Math.abs(along2(c.x2, c.y2) - along2(x2, y2)) < 1e-3;
-    if (same2) return { type: "linear", angle, stops, ...spread };
-  }
-  const start = { x: x1, y: y1 };
-  const end = { x: x2, y: y2 };
-  return {
-    type: "linear",
-    stops,
-    start: map(start),
-    end: map(end),
-    width: map({ x: x1 - (y2 - y1), y: y1 + (x2 - x1) }),
-    units: user ? "userSpaceOnUse" : "objectBoundingBox",
-    ...spread
-  };
-}
-var applySvgMatrix = (m, p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] });
-function parseVectorSvg(svg, options = {}) {
-  const root = parseXml(svg);
-  if (!root) throw new Error("The markup has no <svg> element.");
-  let counter = 0;
-  const usedIds = /* @__PURE__ */ new Set();
-  const createId = options.createId ?? (() => `node-${++counter}`);
-  const idFor = (el) => {
-    const id = el.attrs.id;
-    if (id && !usedIds.has(id)) {
-      usedIds.add(id);
-      return id;
-    }
-    let next = createId();
-    while (usedIds.has(next)) next = createId();
-    usedIds.add(next);
-    return next;
-  };
-  const rawGradients = /* @__PURE__ */ new Map();
-  collectGradients(root, rawGradients);
-  const rawFilters = /* @__PURE__ */ new Map();
-  collectFilters(root, rawFilters);
-  const rawMasks = /* @__PURE__ */ new Map();
-  collectMasks(root, rawMasks);
-  const resolving = /* @__PURE__ */ new Set();
-  const filtersOf = (value) => {
-    const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec((value ?? "").trim());
-    const el = url ? rawFilters.get(url[1]) : void 0;
-    return el ? filtersFromElement(el) : [];
-  };
-  const paint = (value) => {
-    const v2 = value.trim();
-    const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec(v2);
-    if (url) return resolveGradient(url[1], rawGradients) ?? null;
-    if (v2 === "none" || v2 === "") return null;
-    return v2;
-  };
-  const viewBox = numberList(root.attrs.viewBox);
-  const width = viewBox.length === 4 ? viewBox[2] : length(root.attrs.width, 300);
-  const height = viewBox.length === 4 ? viewBox[3] : length(root.attrs.height, 150);
-  const rootMatrix = viewBox.length === 4 ? translateMatrix(-viewBox[0], -viewBox[1]) : IDENTITY_MATRIX;
-  const SKIP = /* @__PURE__ */ new Set(["defs", "clipPath", "mask", "symbol", "style", "title", "desc", "metadata", "pattern", "marker", "filter", "text", "image", "use", "linearGradient", "radialGradient", "script", "foreignObject"]);
-  const shapeOf = (el) => {
-    const a = el.attrs;
-    switch (el.name) {
-      case "path": {
-        if (a["data-vector-d"] && a["data-vector-corners"]) {
-          const sharp = bezierToSubpaths(a["data-vector-d"]);
-          if (sharp.length) return applyVectorCornersAttribute(sharp, a["data-vector-corners"]);
-        }
-        return a.d ? bezierToSubpaths(a.d) : null;
-      }
-      case "rect": {
-        const w = length(a.width);
-        const h = length(a.height);
-        if (w <= 0 || h <= 0) return null;
-        const r = length(a.rx ?? a.ry, 0);
-        return [rectSubpath({ x: length(a.x), y: length(a.y), width: w, height: h }, r)];
-      }
-      case "circle": {
-        const r = length(a.r);
-        if (r <= 0) return null;
-        const cx = length(a.cx);
-        const cy = length(a.cy);
-        return [ellipseSubpath({ x: cx - r, y: cy - r, width: 2 * r, height: 2 * r })];
-      }
-      case "ellipse": {
-        const rx = length(a.rx);
-        const ry = length(a.ry);
-        if (rx <= 0 || ry <= 0) return null;
-        return [ellipseSubpath({ x: length(a.cx) - rx, y: length(a.cy) - ry, width: 2 * rx, height: 2 * ry })];
-      }
-      case "line":
-        return [lineSubpath({ x: length(a.x1), y: length(a.y1) }, { x: length(a.x2), y: length(a.y2) })];
-      case "polyline":
-      case "polygon": {
-        const n = numberList(a.points);
-        if (n.length < 4) return null;
-        const anchors = [];
-        for (let i = 0; i + 1 < n.length; i += 2) anchors.push({ x: n[i], y: n[i + 1] });
-        return [{ anchors, closed: el.name === "polygon" }];
-      }
-    }
-    return null;
-  };
-  const strokeStyle = (s) => ({
-    ...s.strokeWidth ? { strokeWidth: length(s.strokeWidth, 1) } : {},
-    ...s.strokeLinecap ? { strokeLinecap: s.strokeLinecap } : {},
-    ...s.strokeLinejoin ? { strokeLinejoin: s.strokeLinejoin } : {},
-    ...s.strokeDasharray && s.strokeDasharray !== "none" ? { strokeDasharray: numberList(s.strokeDasharray) } : {},
-    ...s.fillRule === "evenodd" ? { fillRule: "evenodd" } : {}
-  });
-  const placed = (node, m) => {
-    if (m === IDENTITY_MATRIX) return node;
-    const next = transformVectorNode(node, m);
-    const strokeScale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
-    if (strokeScale > 0 && Math.abs(strokeScale - 1) > 1e-9) {
-      if (hasPaint(next.stroke)) next.strokeWidth = (next.strokeWidth ?? 1) * strokeScale;
-      if (Array.isArray(next.strokes)) next.strokes = next.strokes.map((l) => (l.kind ?? "paint") === "paint" ? { ...l, strokeWidth: (l.strokeWidth ?? 1) * strokeScale } : l);
-    }
-    return normalizeVectorPaintStacks(next, "stack");
-  };
-  const withOpacities = (node, s) => {
-    let out = node;
-    const fo = s.fillOpacity !== void 0 ? fraction(s.fillOpacity, 1) : 1;
-    const so = s.strokeOpacity !== void 0 ? fraction(s.strokeOpacity, 1) : 1;
-    if (fo < 1 && hasPaint(out.fill)) out = withVectorFills(out, [{ paint: out.fill, opacity: Math.max(0, fo) }]);
-    if (so < 1 && hasPaint(out.stroke)) out = withVectorStrokes(out, vectorStrokes(out).map((l) => ({ ...l, opacity: Math.max(0, so) })));
-    return out;
-  };
-  const stackedPath = (g, _style, m, meta) => {
-    const fillEl = g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === "fill");
-    const subpaths = fillEl ? shapeOf(fillEl) : null;
-    if (!subpaths?.length) return null;
-    const parse = (v2) => {
-      try {
-        return v2 ? JSON.parse(v2) : [];
-      } catch {
-        return [];
-      }
-    };
-    let node = { id: idFor(g), type: "path", ...meta, subpaths, fill: null, stroke: null };
-    if (g.attrs["data-vector-fill-rule"] === "evenodd") node.fillRule = "evenodd";
-    node = withVectorFills(node, sanitizeVectorFills(parse(g.attrs["data-vector-fills"])));
-    node = withVectorStrokes(node, sanitizeVectorStrokes(parse(g.attrs["data-vector-strokes"])));
-    return placed(node, m);
-  };
-  const mergeStacked = (nodes2) => {
-    const out = [];
-    const key = (n) => JSON.stringify([n.subpaths, n.transform ?? null, n.opacity ?? 1, n.visible !== false, n.filters ?? null, n.blendMode ?? "normal", n.fillRule ?? "nonzero", n.booleanOperation ?? null]);
-    for (const n of nodes2) {
-      const prev = out[out.length - 1];
-      if (prev?.type === "path" && n.type === "path" && key(prev) === key(n)) {
-        const fills = vectorFills(n);
-        const strokesBefore = vectorStrokes(prev);
-        if (!(fills.length && strokesBefore.length)) {
-          let merged = withVectorFills(prev, [...vectorFills(prev), ...fills]);
-          merged = withVectorStrokes(merged, [...strokesBefore, ...vectorStrokes(n)]);
-          out[out.length - 1] = merged;
-          continue;
-        }
-      }
-      out.push(n);
-    }
-    return out;
-  };
-  const mergedPath = (g, style, m, meta) => {
-    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 || !subpaths?.length) return null;
-    const a = g.attrs;
-    const fs = readStyle(fillEl, style);
-    const strokeEl = part("stroke");
-    const outlineEl = part("stroke-outline");
-    const ss = strokeEl ? readStyle(strokeEl, style) : null;
-    const width2 = length(a["data-vector-stroke-width"], ss ? length(ss.strokeWidth, 1) : 1);
-    const arrow = (v2) => VECTOR_ARROWHEADS.includes(v2) ? v2 : void 0;
-    const scale3 = (v2) => {
-      const n = v2 === void 0 ? NaN : parseFloat(v2);
-      return n > 0 ? n : void 0;
-    };
-    const align = a["data-vector-stroke-align"];
-    const profile = widthProfileFromAttribute(a["data-vector-width-profile"]);
-    const kept = (key, values) => values.includes(a[key]) ? a[key] : void 0;
-    const keptCap = kept("data-vector-stroke-linecap", ["round", "square"]);
-    const keptJoin = kept("data-vector-stroke-linejoin", ["round", "bevel"]);
-    const keptDash = a["data-vector-stroke-dasharray"] ? numberList(a["data-vector-stroke-dasharray"]) : void 0;
-    const node = {
-      id: idFor(g),
-      type: "path",
-      ...meta,
-      subpaths,
-      fill: paint(fs.fill),
-      stroke: ss ? paint(ss.stroke) : outlineEl ? paint(readStyle(outlineEl, style).fill) : null,
-      ...ss ? strokeStyle(ss) : {},
-      ...fs.fillRule === "evenodd" ? { fillRule: "evenodd" } : {},
-      strokeWidth: width2,
-      ...align === "inside" || align === "outside" ? { strokeAlign: align } : {},
-      ...arrow(a["data-vector-start-arrow"]) ? { startArrow: arrow(a["data-vector-start-arrow"]) } : {},
-      ...arrow(a["data-vector-end-arrow"]) ? { endArrow: arrow(a["data-vector-end-arrow"]) } : {},
-      ...a["data-vector-arrow-align"] === "tip" ? { arrowAlign: "tip" } : {},
-      ...scale3(a["data-vector-start-arrow-scale"]) ? { startArrowScale: scale3(a["data-vector-start-arrow-scale"]) } : {},
-      ...scale3(a["data-vector-end-arrow-scale"]) ? { endArrowScale: scale3(a["data-vector-end-arrow-scale"]) } : {},
-      ...profile.length ? { strokeWidthProfile: profile } : {},
-      ...keptCap ? { strokeLinecap: keptCap } : {},
-      ...keptJoin ? { strokeLinejoin: keptJoin } : {},
-      ...keptDash?.length ? { strokeDasharray: keptDash } : {}
-    };
-    return placed(node, m);
-  };
-  const liveNode = (g, style, m, meta) => {
-    let raw = {};
-    try {
-      raw = JSON.parse(g.attrs["data-vector-live"]) ?? {};
-    } catch {
-      raw = {};
-    }
-    const sourceEl = g.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === "source");
-    if (!sourceEl) return null;
-    const inner = visit(sourceEl, style, m);
-    const effects = sanitizeVectorEffects(raw.effects);
-    const liveBoolean = BOOLEAN_OPERATIONS.includes(raw.liveBoolean) ? raw.liveBoolean : null;
-    const id = idFor(g);
-    if (raw.kind === "path") {
-      const path = inner.find((n) => n.type === "path");
-      if (!path) return null;
-      const { residual } = decomposeRigid(m);
-      const { visible: _v, ...rest } = path;
-      return { ...rest, id, ...meta, ...effects.length ? { effects: transformVectorEffects(effects, residual) } : {} };
-    }
-    if (!inner.length) return null;
-    const group = { id, type: "group", ...meta, children: inner };
-    if (effects.length) group.effects = transformVectorEffects(effects, m);
-    if (liveBoolean) group.liveBoolean = liveBoolean;
-    const blend = blendFromAttribute(g.attrs["data-vector-blend"], m);
-    if (blend) group.blend = blend;
-    return group;
-  };
-  const visit = (el, style, matrix) => {
-    const out = [];
-    for (const child of el.children) {
-      if (SKIP.has(child.name)) continue;
-      const nodes2 = visitOne(child, style, matrix);
-      out.push(...nodes2.length ? masked(child, nodes2, multiplyMatrices(parseSvgTransform(child.attrs.transform), matrix)) : nodes2);
-    }
-    return options.mergeStackedShapes ? mergeStacked(out) : out;
-  };
-  let rootStyle = { fill: "#000", stroke: "none", strokeWidth: "" };
-  const bboxMatrix = (nodes2) => {
-    const b = unionBounds(nodes2.map((n) => vectorNodeBounds(n)));
-    return b && b.width > 0 && b.height > 0 ? [b.width, 0, 0, b.height, b.x, b.y] : null;
-  };
-  const maskNode = (el, m, nodes2, units) => {
-    const id = el.attrs.id;
-    if (!id || resolving.has(id)) return null;
-    let space = m;
-    if (units === "objectBoundingBox") {
-      const box = bboxMatrix(nodes2);
-      if (!box) return null;
-      space = box;
-    }
-    resolving.add(id);
-    const isClip = el.name === "clipPath";
-    const content = isClip ? clipRulesAsFillRules(el) : el;
-    const inner = visit(content, readStyle(content, rootStyle), multiplyMatrices(parseSvgTransform(el.attrs.transform), space));
-    resolving.delete(id);
-    const strip2 = (n) => n.type === "path" ? withVectorStrokes(withVectorFills({ ...n, fill: null, stroke: null }, []), []) : { ...n, children: n.children.map(strip2) };
-    const list = isClip ? inner.map(strip2) : inner;
-    if (!list.length) return null;
-    return list.length === 1 ? list[0] : { id: idFor({ name: "g", attrs: {}, children: [] }), type: "group", name: isClip ? "Clip" : "Mask", children: list };
-  };
-  const masked = (el, nodes2, m) => {
-    let out = nodes2;
-    const clipEl = rawMasks.get(urlId(attrOrStyle(el, "clip-path")) ?? "");
-    if (clipEl?.name === "clipPath") {
-      const source = maskNode(clipEl, m, out, clipEl.attrs.clipPathUnits);
-      if (source) out = [{ id: idFor({ name: "g", attrs: {}, children: [] }), type: "group", name: "Clip Group", mask: { type: "clip" }, children: [source, ...out] }];
-    }
-    const maskEl = rawMasks.get(urlId(attrOrStyle(el, "mask")) ?? "");
-    if (maskEl?.name === "mask") {
-      const source = maskNode(maskEl, m, out, maskEl.attrs.maskContentUnits);
-      const type = attrOrStyle(maskEl, "mask-type") === "alpha" ? "alpha" : "luminance";
-      if (source) out = [{ id: idFor({ name: "g", attrs: {}, children: [] }), type: "group", name: "Opacity Mask", mask: { type }, children: [source, ...out] }];
-    }
-    return out;
-  };
-  const maskGroup = (g, style, m, meta) => {
-    let raw = null;
-    try {
-      raw = JSON.parse(g.attrs["data-vector-mask"]);
-    } catch {
-      raw = null;
-    }
-    const mask = sanitizeVectorMask(raw);
-    const part = (name) => g.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === name);
-    const maskedEl = part("masked");
-    if (!mask || !maskedEl) return null;
-    const id = idFor(g);
-    let sourceEl = part("mask-source");
-    if (!sourceEl) {
-      const el = rawMasks.get(urlId(maskedEl.attrs.mask) ?? "");
-      const invert2 = el?.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === "mask-invert");
-      sourceEl = invert2 ?? el;
-    }
-    const source = sourceEl ? visit(sourceEl, style, m)[0] : void 0;
-    let contents = visit(maskedEl, style, m);
-    let effects;
-    const wrapper = contents.length === 1 && contents[0].type === "group" && contents[0].id === `${id}~content` ? contents[0] : null;
-    if (wrapper?.type === "group") {
-      effects = wrapper.effects ?? void 0;
-      contents = wrapper.children;
-    }
-    if (!source) return contents.length ? { id, type: "group", ...meta, children: contents } : null;
-    return { id, type: "group", ...meta, mask, ...effects?.length ? { effects } : {}, children: [source, ...contents] };
-  };
-  const visitOne = (child, style, matrix) => {
-    const out = [];
-    const m = multiplyMatrices(parseSvgTransform(child.attrs.transform), matrix);
-    const s = readStyle(child, style);
-    const opacity = child.attrs.opacity !== void 0 ? parseFloat(child.attrs.opacity) : void 0;
-    const hidden = child.attrs.display === "none" || child.attrs.visibility === "hidden";
-    const blendMode = vectorBlendModeFromCss(s.mixBlendMode);
-    const filters = filtersOf(s.filter);
-    const meta = {
-      ...child.attrs["inkscape:label"] || child.attrs["data-name"] ? { name: child.attrs["inkscape:label"] ?? child.attrs["data-name"] } : {},
-      ...opacity !== void 0 && Number.isFinite(opacity) && opacity < 1 ? { opacity } : {},
-      ...hidden ? { visible: false } : {},
-      ...blendMode && blendMode !== "normal" ? { blendMode } : {},
-      ...filters.length ? { filters } : {}
-    };
-    if (child.attrs["data-vector-blend-step"] !== void 0) return out;
-    const operation = child.attrs["data-vector-boolean-operation"];
-    if (BOOLEAN_OPERATIONS.includes(operation)) meta.booleanOperation = operation;
-    if (child.name === "g" && child.attrs["data-vector-mask"] !== void 0) {
-      const node2 = maskGroup(child, s, m, meta);
-      if (node2) out.push(node2);
-      return out;
-    }
-    if (child.name === "g" && child.attrs["data-vector-live"] !== void 0) {
-      const node2 = liveNode(child, s, m, meta);
-      if (node2) out.push(node2);
-      return out;
-    }
-    if (child.name === "g" && child.attrs["data-vector-path"] !== void 0 && child.attrs["data-vector-fills"] !== void 0) {
-      const node2 = stackedPath(child, s, m, meta);
-      if (node2) out.push(node2);
-      return out;
-    }
-    if (child.name === "g" && child.attrs["data-vector-path"] !== void 0) {
-      const node2 = mergedPath(child, s, m, meta);
-      if (node2) out.push(node2);
-      return out;
-    }
-    if (child.name === "g" || child.name === "svg" || child.name === "a" || child.name === "switch") {
-      const children = visit(child, s, m);
-      if (!children.length) return out;
-      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);
-      return out;
-    }
-    const subpaths = shapeOf(child);
-    if (!subpaths || !subpaths.length) return out;
-    const node = placed(
-      withOpacities(
-        {
-          id: idFor(child),
-          type: "path",
-          ...meta,
-          subpaths,
-          fill: child.name === "line" ? null : paint(s.fill),
-          stroke: paint(s.stroke),
-          ...strokeStyle(s)
-        },
-        s
-      ),
-      m
-    );
-    out.push(node);
-    return out;
-  };
-  rootStyle = readStyle(root, rootStyle);
-  const nodes = visit(root, rootStyle, rootMatrix);
-  return { width, height, nodes };
-}
-
 export {
   VECTOR_CORNER_KINDS,
   VECTOR_GRADIENT_TYPES,
@@ -6611,6 +5354,19 @@ export {
   convertVectorGradient,
   defaultVectorGradient,
   applyVectorGradientPatch,
+  IDENTITY_MATRIX,
+  multiplyMatrices,
+  translateMatrix,
+  scaleMatrix,
+  rotateMatrix,
+  matrixAbout,
+  skewMatrix,
+  applyMatrix,
+  isIdentityMatrix,
+  invertMatrix,
+  applyMatrixLinear,
+  matrixRotation,
+  decomposeRigid,
   vectorCornerAt,
   vectorCorners,
   cornerSetback,
@@ -6741,6 +5497,28 @@ export {
   vectorMaskedLocalBounds,
   vectorMaskContentBounds,
   vectorMaskRenderData,
+  WARP_STYLES,
+  WARP_STYLE_LABELS,
+  warpPresetGrid,
+  warpPresetMesh,
+  warpMeshColumns,
+  warpMeshRows,
+  isValidWarpMesh,
+  fitWarpMesh,
+  identityWarpMesh,
+  evalWarpMesh,
+  splitWarpMeshU,
+  splitWarpMeshV,
+  removeWarpMeshSplitU,
+  removeWarpMeshSplitV,
+  mapWarpMeshPoints,
+  resizeWarpMesh,
+  warpMeshControlBounds,
+  warpMeshParamAt,
+  dragWarpMeshPoint,
+  pullWarpMesh,
+  warpMeshEditPoints,
+  warpMeshGridCurves,
   vectorMeshFromOutline,
   vectorMeshOutline,
   VECTOR_EFFECT_DEFAULTS,
@@ -6814,36 +5592,6 @@ export {
   polygonSubpath,
   starSubpath,
   lineSubpath,
-  roundSubpaths,
-  subpathToMorphContour,
-  morphContourToSubpath,
-  refineMorphContour,
-  reverseMorphContour,
-  turnMorphContour,
-  correspondMorphContours,
-  morphPathsCross,
-  interpolateMorphContours,
-  interpolateRigidMatrix,
-  interpolateVectorColor,
-  resampleGradientStops,
-  interpolateVectorPaint,
-  interpolateWidthProfiles,
-  interpolateVectorStyle,
-  createVectorMorph,
-  interpolateVectorPaths,
-  evaluateVectorPathKeyframes,
-  vectorStrokeGradientDefs,
-  vectorCornersAttribute,
-  applyVectorCornersAttribute,
-  vectorPathLocalBounds,
-  vectorPaintToSvg,
-  vectorStrokeSvgParts,
-  vectorNodeLocalPaintBounds,
-  vectorNodeFilterSvg,
-  widthProfileToAttribute,
-  widthProfileFromAttribute,
-  vectorDocumentToSvg,
-  parseSvgTransform,
-  parseVectorSvg
+  roundSubpaths
 };
-//# sourceMappingURL=chunk-HUQ7EHVI.js.map
+//# sourceMappingURL=chunk-BLWCAQCW.js.map