@pixerate/editor 0.113.0 → 0.115.0

package/dist/chunk-KB2YBCVS.js

@@ -1,2001 +0,0 @@
-import {
-  IDENTITY_MATRIX,
-  VECTOR_ARROWHEADS,
-  VECTOR_CORNER_KINDS,
-  activeVectorFilters,
-  bezierToSubpaths,
-  decomposeRigid,
-  ellipseSubpath,
-  expandVectorAppearance,
-  expandVectorCorners,
-  expandVectorGradientStops,
-  explicitVectorGradient,
-  hasExplicitGradientGeometry,
-  hasOwnVectorAppearance,
-  hasPaint,
-  hasStrokeExtras,
-  inferAnchorType,
-  invertMatrix,
-  isIdentityMatrix,
-  isVectorGradient,
-  isVectorMaskGroup,
-  lineSubpath,
-  multiplyMatrices,
-  needsVectorPaintLayers,
-  nodeMatrix,
-  normalizeVectorPaintStacks,
-  patternAttrs,
-  rectSubpath,
-  reverseWidthProfile,
-  rotateMatrix,
-  sampleVectorGradient,
-  sanitizeVectorEffects,
-  sanitizeVectorFills,
-  sanitizeVectorFilters,
-  sanitizeVectorGradient,
-  sanitizeVectorMask,
-  sanitizeVectorStrokes,
-  sanitizeWidthProfile,
-  scaleMatrix,
-  sortedVectorGradientStops,
-  spanVectorGradientStops,
-  strokeWidthProfileOf,
-  subpathsToBezier,
-  transformVectorEffects,
-  transformVectorNode,
-  translateMatrix,
-  unionBounds,
-  vectorAppearanceNodes,
-  vectorBlendModeCss,
-  vectorBlendModeFromCss,
-  vectorFills,
-  vectorFilterMarkup,
-  vectorFilterSvg,
-  vectorGradientArea,
-  vectorGradientPoints,
-  vectorGradientSvgDefs,
-  vectorMaskRenderData,
-  vectorNodeBounds,
-  vectorPaintLayerNodes,
-  vectorPathData,
-  vectorStrokeLineArea,
-  vectorStrokeOutlinePath,
-  vectorStrokeParts,
-  vectorStrokeReach,
-  vectorStrokeStackReach,
-  vectorStrokes,
-  widthProfileAt,
-  withVectorFills,
-  withVectorStrokes
-} from "./chunk-BLWCAQCW.js";
-import {
-  angleToSvgLinearCoords,
-  bezierPathBounds,
-  bezierPathToSvg,
-  closeContour,
-  flattenChain,
-  formatNumber,
-  pathToContours,
-  segmentLength,
-  segmentParamAtLength,
-  splitSegment
-} from "./chunk-YCSFS3GK.js";
-import {
-  evaluateEasing
-} from "./chunk-AGR4P4UZ.js";
-import {
-  mixColorsOklab
-} from "./chunk-ZRJMJIQU.js";
-
-// 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 = (v) => [v.x, v.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 len = Math.hypot(dx, dy);
-  const tol = Math.max(1e-7, len * 1e-7);
-  if (len < 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) / len;
-  const along = (p) => ((p[0] - p0[0]) * dx + (p[1] - p0[1]) * dy) / (len * len);
-  const u1 = along(p1);
-  const u2 = along(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 plain = !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 len = Math.hypot(ux, uy) + Math.hypot(vx, vy);
-    if (plain && Math.abs(ux * vy - uy * vx) <= 1e-9 * Math.max(1, len * len) && 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 at = 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]);
-    at += pieces;
-    if (k < have - 1 || !c.closed) anchors.push(at);
-  });
-  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(v) {
-  const n = Math.max(1, v.length);
-  let cx = 0;
-  let cy = 0;
-  for (const p of v) {
-    cx += p[0];
-    cy += p[1];
-  }
-  cx /= n;
-  cy /= n;
-  let s = 0;
-  for (const p of v) 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(v, closed) {
-  const { r } = frame(v);
-  const n = v.length;
-  return v.map((p, i) => {
-    const prev = v[closed ? (i - 1 + n) % n : Math.max(0, i - 1)];
-    const next = v[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 = v[j][0] - p[0];
-      const dy = v[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 dot = 0;
-    let cross = 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];
-      dot += p[0] * q[0] + p[1] * q[1];
-      cross += p[0] * q[1] - p[1] * q[0];
-      if (fsc && gsc) sc += chi2(fsc[i], gsc[j]);
-    }
-    const residual = Math.max(0, 1 - (dot * dot + cross * cross) / (m * m));
-    const turn = 1 - Math.cos(Math.atan2(cross, dot));
-    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 dot = 0;
-  let cross = 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];
-    dot += p[0] * q[0] + p[1] * q[1];
-    cross += p[0] * q[1] - p[1] * q[0];
-  }
-  return { ca, cb, theta: Math.atan2(cross, dot), s: ss > 1e-12 ? Math.hypot(dot, cross) / 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 near = 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 (near.spread && near.spread !== "pad") out.spread = near.spread;
-  if (near.strokeMode && near.strokeMode !== "within") out.strokeMode = near.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(near);
-    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 at = [...a ?? [], ...b ?? [], { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
-  const ts = at.filter((v, i) => i === 0 || v - at[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((v) => v > 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((v, i) => lerpN(v, y[i], t));
-}
-var SWITCHED_KEYS = ["strokeLinecap", "strokeLinejoin", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign"];
-function interpolateVectorStyle(a, b, t) {
-  const near = 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 (near[key] !== void 0 && near[key] !== null) out[key] = near[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 at = preparePathMorph(a, b, options);
-    return { at };
-  }
-  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 sub2 = { ...options, id: `${id}-${i}`, starts: void 0 };
-    if (x && y) {
-      parts.push(preparePathMorph(x.path, y.path, sub2, 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), sub2, 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, sub2, 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 fmt = (n, digits = 3) => {
-  const k = 10 ** digits;
-  const v = Math.round(n * k) / k;
-  return Object.is(v, -0) ? "0" : String(v);
-};
-var toSvgStops = (stops) => stops.map((s) => ({ offset: `${fmt(s.offset * 100)}%`, stopColor: s.color, ...s.opacity !== void 0 && s.opacity !== 1 ? { stopOpacity: Math.round(s.opacity * 1e4) / 1e4 } : {} }));
-var polygonD = (pts, precision) => `M${pts.map((p) => `${fmt(p.x, precision)} ${fmt(p.y, precision)}`).join("L")}Z`;
-var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
-var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
-var scale = (a, k) => ({ x: a.x * k, y: a.y * k });
-var left = (d) => ({ x: d.y, y: -d.x });
-var unit = (v) => {
-  const l = Math.hypot(v.x, v.y);
-  return l > 1e-12 ? { x: v.x / l, y: v.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: toSvgStops([{ ...s, offset: 0 }]) });
-    patches.push({ d: polygonD(pts, precision), fill: `url(#${gid})` });
-  };
-  const disc = (c, r) => Array.from({ length: 16 }, (_, k) => add(c, scale({ 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(unit(sub(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: add(p, scale(left(d), reach)), r: sub(p, scale(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 = scale(add(nin, nout), reach / den);
-        const rib = { l: add(p, m), r: sub(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) => [add(p, scale(left(d), reach)), add(add(p, scale(d, reach)), scale(left(d), reach)), sub(add(p, scale(d, reach)), scale(left(d), reach)), sub(p, scale(left(d), reach))];
-      solid(cap(a, scale(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 = scale(d, OVERLAP);
-      const quad = [from.l, add(to.l, ext), add(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: fmt(a.x, 4), y1: fmt(a.y, 4), x2: fmt(b.x, 4), y2: fmt(b.y, 4) },
-          stops: toSvgStops(spanVectorGradientStops(g, t0, t1, expanded))
-        });
-      } else {
-        const mid = scale(add(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 = add(mid, scale(nrm, reachL));
-        const p1 = sub(mid, scale(nrm, reachR));
-        gradients.push({
-          id: gid,
-          type: "linear",
-          attrs: { gradientUnits: "userSpaceOnUse", x1: fmt(p0.x, 4), y1: fmt(p0.y, 4), x2: fmt(p1.x, 4), y2: fmt(p1.y, 4) },
-          stops: toSvgStops(expanded)
-        });
-      }
-      slices.push({ d: polygonD(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 escapeAttr = (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, v]) => ` ${k}="${escapeAttr(String(v))}"`).join("");
-  const stops = def.stops.map((s) => `<stop offset="${s.offset}" stop-color="${escapeAttr(s.stopColor)}"${s.stopOpacity !== void 0 ? ` stop-opacity="${s.stopOpacity}"` : ""}/>`).join("");
-  return `<${tag} id="${escapeAttr(def.id)}"${attrs}${extra}>${stops}</${tag}>`;
-}
-function paintDefMarkup(def, gradient) {
-  const extra = gradient ? ` data-vector-gradient="${escapeAttr(JSON.stringify(gradient))}"` : "";
-  if (def.type !== "pattern") return gradientMarkup(def, extra);
-  const attrs = Object.entries(def.attrs).map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`).join("");
-  const inner = def.gradients.map((g) => gradientMarkup(g)).join("") + def.tiles.map((t) => `<path d="${t.d}" fill="${escapeAttr(t.fill)}"/>`).join("");
-  return `<pattern id="${escapeAttr(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 num = (n) => formatNumber(n, precision);
-  const indent = (depth) => pretty ? "  ".repeat(depth) : "";
-  const common = (node) => {
-    let out2 = ` id="${escapeAttr(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="${num(node.opacity)}"`;
-    if (node.visible === false) out2 += ` display="none"`;
-    if (node.blendStep) out2 += ` data-vector-blend-step=""`;
-    if (node.type === "group" && node.blend) out2 += ` data-vector-blend="${escapeAttr(JSON.stringify(node.blend))}"`;
-    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="${escapeAttr(JSON.stringify(node.filters))}"`;
-      if (filter) {
-        defs.push(vectorFilterMarkup(filter, data));
-        out2 += ` filter="url(#${escapeAttr(filter.id)})"`;
-      } else out2 += data;
-    }
-    return out2;
-  };
-  const layerAttrs = (layer) => {
-    let out2 = "";
-    if (layer.opacity !== void 0 && layer.opacity < 1) out2 += ` opacity="${num(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="${escapeAttr(strokeValue)}"/>`);
-      return out2;
-    }
-    let clip = "";
-    if (parts.clip) {
-      const rule = node.fillRule === "evenodd" ? "evenodd" : "nonzero";
-      const id = escapeAttr(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="${num(b.x)}" y="${num(b.y)}" width="${num(b.width)}" height="${num(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="${escapeAttr(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="${escapeAttr(strokeValue)}"/>`);
-    return out2;
-  };
-  const lineAttrsOf = (node, strokeValue) => (width) => {
-    let out2 = ` stroke="${escapeAttr(strokeValue)}" stroke-width="${num(width)}"`;
-    if (node.strokeLinecap && node.strokeLinecap !== "butt") out2 += ` stroke-linecap="${node.strokeLinecap}"`;
-    if (node.strokeLinejoin && node.strokeLinejoin !== "miter") out2 += ` stroke-linejoin="${node.strokeLinejoin}"`;
-    if (node.strokeDasharray?.length) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num).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="${escapeAttr(JSON.stringify(vectorFills(node)))}" data-vector-strokes="${escapeAttr(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="${escapeAttr(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 emit = (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="${escapeAttr(w2.id)}"` : "";
-      if (w2.transform) attrs += ` transform="${escapeAttr(w2.transform)}"`;
-      if (w2.clip) {
-        const shape = Object.entries(w2.clip.attrs).map(([k, v]) => ` ${k}="${formatNumber(v, 4)}"`).join("");
-        defs.push(`<clipPath id="${escapeAttr(w2.clip.id)}" clipPathUnits="objectBoundingBox"><${w2.clip.shape}${w2.clip.shapeId !== void 0 ? ` id="${escapeAttr(w2.clip.shapeId)}"` : ""}${shape}/></clipPath>`);
-        attrs += ` clip-path="url(#${escapeAttr(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 at = lines.length;
-    fn();
-    return lines.splice(at).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="${escapeAttr(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="${num(b.x)}" y="${num(b.y)}" width="${num(b.width)}" height="${num(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="${escapeAttr(mask.filter)}">${inner}</g>` : inner;
-      defs.push(`<mask id="${escapeAttr(mask.id)}" data-vector-part="mask-source" maskUnits="userSpaceOnUse" ${box}${mask.type === "alpha" ? ' mask-type="alpha"' : ""}>${drawn}</mask>`);
-      ref = ` mask="url(#${escapeAttr(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="${escapeAttr(mask.id)}">${mask.clip.map((c) => `<path d="${c.d}" clip-rule="${c.clipRule}"/>`).join("")}</clipPath>`);
-        ref = ` clip-path="url(#${escapeAttr(mask.id)})"`;
-      }
-    }
-    lines.push(`${indent(depth + 1)}<g data-vector-part="masked"${ref}>`);
-    for (const child of body) emit(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="${escapeAttr(JSON.stringify(live2))}">`);
-      lines.push(`${indent(depth + 1)}<g data-vector-part="appearance">`);
-      for (const shape of vectorAppearanceNodes(node)) emit(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;
-        emit({ ...source, id: `${node.id}~src` }, depth + 2);
-      } else for (const child of node.children) emit(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) emit(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="${escapeAttr(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="${num(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="${num(node.startArrowScale)}"`;
-    if (node.endArrowScale !== void 0 && node.endArrowScale !== 1) data += ` data-vector-end-arrow-scale="${num(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(num).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) emit(node, 1);
-  const w = num(doc.width);
-  const h = num(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="${escapeAttr(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 plain = t === IDENTITY_MATRIX || t[0] === 1 && t[1] === 0 && t[2] === 0 && t[3] === 1 && t[4] === 0 && t[5] === 0;
-  const at = (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 = at("cx", user ? 0 : 0.5);
-    const cy = at("cy", user ? 0 : 0.5);
-    const r = at("r", user ? 0 : 0.5);
-    const fx = attr("fx") !== void 0 ? at("fx", cx) : cx;
-    const fy = attr("fy") !== void 0 ? at("fy", cy) : cy;
-    const fr = attr("fr") !== void 0 ? at("fr", 0) : 0;
-    const focal = Math.abs(fx - cx) > 1e-9 || Math.abs(fy - cy) > 1e-9;
-    if (!user && plain && !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 = at("x1", 0);
-  const y1 = at("y1", 0);
-  const x2 = attr("x2") !== void 0 ? at("x2", 1) : user ? 0 : 1;
-  const y2 = at("y2", 0);
-  if (!user && plain) {
-    const angle = Math.round((Math.atan2(x2 - x1, -(y2 - y1)) * 180 / Math.PI + 360) % 360);
-    const c = angleToSvgLinearCoords(angle);
-    const len = Math.hypot(x2 - x1, y2 - y1);
-    const d = len > 0 ? { x: (x2 - x1) / len, y: (y2 - y1) / len } : { x: 0, y: 1 };
-    const along = (x, y) => x * d.x + y * d.y;
-    const same = len > 0 && Math.abs((c.x2 - c.x1) * d.y - (c.y2 - c.y1) * d.x) < 1e-3 && Math.abs(along(c.x1, c.y1) - along(x1, y1)) < 1e-3 && Math.abs(along(c.x2, c.y2) - along(x2, y2)) < 1e-3;
-    if (same) 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 v = value.trim();
-    const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec(v);
-    if (url) return resolveGradient(url[1], rawGradients) ?? null;
-    if (v === "none" || v === "") return null;
-    return v;
-  };
-  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 = (v) => {
-      try {
-        return v ? JSON.parse(v) : [];
-      } 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 = (v) => VECTOR_ARROWHEADS.includes(v) ? v : void 0;
-    const scale2 = (v) => {
-      const n = v === void 0 ? NaN : parseFloat(v);
-      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" } : {},
-      ...scale2(a["data-vector-start-arrow-scale"]) ? { startArrowScale: scale2(a["data-vector-start-arrow-scale"]) } : {},
-      ...scale2(a["data-vector-end-arrow-scale"]) ? { endArrowScale: scale2(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 strip = (n) => n.type === "path" ? withVectorStrokes(withVectorFills({ ...n, fill: null, stroke: null }, []), []) : { ...n, children: n.children.map(strip) };
-    const list = isClip ? inner.map(strip) : 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 invert = el?.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === "mask-invert");
-      sourceEl = invert ?? 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 {
-  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
-};
-//# sourceMappingURL=chunk-KB2YBCVS.js.map