@pixerate/editor 0.42.0 → 0.43.0

package/dist/vector/index.cjs

@@ -42,16 +42,24 @@ var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 var _chunkVNYRI265cjs = require('../chunk-VNYRI265.cjs');
 
 
+
+
 var _chunkMR3Z4OQIcjs = require('../chunk-MR3Z4OQI.cjs');
 
 
 var _chunkXZ4L3R4Kcjs = require('../chunk-XZ4L3R4K.cjs');
 
 
+
+
 var _chunkA6PHCAGXcjs = require('../chunk-A6PHCAGX.cjs');
 
 // src/vector/types.ts
 var VECTOR_CORNER_KINDS = ["round", "inverted", "chamfer"];
+var VECTOR_GRADIENT_TYPES = ["linear", "radial", "conic", "reflected", "diamond"];
+var VECTOR_GRADIENT_SPREADS = ["pad", "reflect", "repeat"];
+var VECTOR_GRADIENT_INTERPOLATIONS = ["srgb", "linear", "oklab"];
+var VECTOR_STROKE_GRADIENT_MODES = ["within", "along", "across"];
 var VECTOR_ARROWHEADS = ["triangle", "arrow", "open", "circle", "square", "bar"];
 var VECTOR_BLEND_SPACINGS = ["steps", "distance", "smoothColor"];
 var VECTOR_TOOLS = [
@@ -70,20 +78,824 @@ var VECTOR_TOOLS = [
   "width",
   "shapeBuilder",
   "paintBucket",
-  "blend"
+  "blend",
+  "gradient"
 ];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
 var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater"];
 var VECTOR_MERGE_MODES = ["merge", "add", "subtract", "intersect", "exclude"];
 
-// src/vector/corners.ts
-var EPS = 1e-9;
-var MIN_SINE = 1e-6;
+// src/vector/gradient.ts
+var clamp = (v2, lo, hi) => Math.min(hi, Math.max(lo, v2));
+var IDENTITY = [1, 0, 0, 1, 0, 0];
+var mul = (a, b) => [
+  b[0] * a[0] + b[2] * a[1],
+  b[1] * a[0] + b[3] * a[1],
+  b[0] * a[2] + b[2] * a[3],
+  b[1] * a[2] + b[3] * a[3],
+  b[0] * a[4] + b[2] * a[5] + b[4],
+  b[1] * a[4] + b[3] * a[5] + b[5]
+];
+var apply = (m, p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] });
+var invert = (m) => {
+  const [a, b, c, d, e, f] = m;
+  const det = a * d - b * c;
+  if (!Number.isFinite(det) || Math.abs(det) < 1e-18) return null;
+  return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
+};
+var isIdentity = (m) => m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0;
 var sub = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
 var add = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
-var mul = (a, k) => ({ x: a.x * k, y: a.y * k });
+var scale = (a, k) => ({ x: a.x * k, y: a.y * k });
 var dot = (a, b) => a.x * b.x + a.y * b.y;
+var perp = (v2) => ({ x: -v2.y, y: v2.x });
+var finitePoint = (p) => !!p && typeof p === "object" && Number.isFinite(p.x) && Number.isFinite(p.y);
+var fmt = (n, digits = 4) => {
+  const k = 10 ** digits;
+  const v2 = Math.round(n * k) / k;
+  return Object.is(v2, -0) ? "0" : String(v2);
+};
+var fmtMatrix = (m) => `matrix(${m.map((n) => fmt(n, 6)).join(" ")})`;
+function isVectorGradient(paint) {
+  return !!paint && typeof paint === "object" && VECTOR_GRADIENT_TYPES.includes(paint.type) && Array.isArray(paint.stops);
+}
+function parseVectorColor(color) {
+  const hex = _chunkA6PHCAGXcjs.normalizeTokenColor.call(void 0, color);
+  if (hex === null) return null;
+  const c = _chunkA6PHCAGXcjs.hexToRgba.call(void 0, hex);
+  return [c.r, c.g, c.b, c.a];
+}
+var toLinear = (c) => c <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+var toGamma = (c) => {
+  const v2 = clamp(c, 0, 1);
+  return v2 <= 31308e-7 ? 12.92 * v2 : 1.055 * v2 ** (1 / 2.4) - 0.055;
+};
+function intoSpace(space, [r, g, b]) {
+  if (space === "linear") return [toLinear(r), toLinear(g), toLinear(b)];
+  if (space === "oklab") {
+    const c = _chunkMR3Z4OQIcjs.rgbToOklab.call(void 0, r, g, b);
+    return [c.l, c.a, c.b];
+  }
+  return [r, g, b];
+}
+function outOfSpace(space, [x, y, z]) {
+  if (space === "linear") return [toGamma(x), toGamma(y), toGamma(z)];
+  if (space === "oklab") {
+    const c = _chunkMR3Z4OQIcjs.oklabToRgb.call(void 0, { l: x, a: y, b: z, alpha: 1 });
+    return [c.r, c.g, c.b];
+  }
+  return [clamp(x, 0, 1), clamp(y, 0, 1), clamp(z, 0, 1)];
+}
+var MID_MIN = 0.01;
+var MID_MAX = 0.99;
+var VECTOR_GRADIENT_MIN_STOPS = 2;
+function gradientMidpointRemap(u, m) {
+  const mid = clamp(m, MID_MIN, MID_MAX);
+  if (Math.abs(mid - 0.5) < 1e-6) return u;
+  return u <= mid ? 0.5 * u / mid : 0.5 + 0.5 * (u - mid) / (1 - mid);
+}
+var hasMidpoint = (s) => s.midpoint !== void 0 && Number.isFinite(s.midpoint) && Math.abs(s.midpoint - 0.5) > 1e-3;
+function sortedVectorGradientStops(g) {
+  return (_nullishCoalesce(g.stops, () => ( []))).filter((s) => s && Number.isFinite(s.offset) && typeof s.color === "string").map((s, i) => ({ s: { ...s, offset: clamp(s.offset, 0, 1) }, i })).sort((a, b) => a.s.offset - b.s.offset || a.i - b.i).map((e) => e.s);
+}
+function vectorGradientNeedsExpansion(g) {
+  return (_nullishCoalesce(g.interpolation, () => ( "srgb"))) !== "srgb" || (_nullishCoalesce(g.smoothness, () => ( 0))) > 0 || (_nullishCoalesce(g.stops, () => ( []))).some(hasMidpoint);
+}
+function vectorGradientRamp(g) {
+  const space = g.interpolation && VECTOR_GRADIENT_INTERPOLATIONS.includes(g.interpolation) ? g.interpolation : "srgb";
+  const smooth = clamp(Number.isFinite(g.smoothness) ? g.smoothness : 0, 0, 1);
+  const pts = [];
+  for (const s of sortedVectorGradientStops(g)) {
+    const c = parseVectorColor(s.color);
+    if (!c) return null;
+    pts.push({ t: s.offset, v: intoSpace(space, c), a: c[3] * clamp(_nullishCoalesce(s.opacity, () => ( 1)), 0, 1), mid: _nullishCoalesce(s.midpoint, () => ( 0.5)) });
+  }
+  return {
+    sample(t) {
+      const n = pts.length;
+      if (!n) return [0, 0, 0, 0];
+      const first = pts[0];
+      const last = pts[n - 1];
+      const at2 = (p) => [...outOfSpace(space, p.v), p.a];
+      if (!(t > first.t) || n < 2) return at2(first);
+      if (t >= last.t) return at2(last);
+      let i = 0;
+      while (i + 2 < n && !(t >= pts[i].t && t <= pts[i + 1].t)) i++;
+      const p0 = pts[i];
+      const p1 = pts[i + 1];
+      const h = Math.max(p1.t - p0.t, 1e-6);
+      const u = gradientMidpointRemap((t - p0.t) / h, p0.mid);
+      const alpha = p0.a + (p1.a - p0.a) * u;
+      if (smooth <= 0) return [...outOfSpace(space, [0, 1, 2].map((c) => p0.v[c] + (p1.v[c] - p0.v[c]) * u)), alpha];
+      const tangent2 = (k) => {
+        const [a, b] = k === 0 ? [0, 1] : k === n - 1 ? [n - 2, n - 1] : [k - 1, k + 1];
+        const d = Math.max(pts[b].t - pts[a].t, 1e-6);
+        const half = k === 0 || k === n - 1 ? 0.5 : 1;
+        return [0, 1, 2].map((c) => (pts[b].v[c] - pts[a].v[c]) / d * half);
+      };
+      const m0 = tangent2(i);
+      const m1 = tangent2(i + 1);
+      const u2 = u * u;
+      const u3 = u2 * u;
+      const h00 = 2 * u3 - 3 * u2 + 1;
+      const h10 = u3 - 2 * u2 + u;
+      const h01 = -2 * u3 + 3 * u2;
+      const h11 = u3 - u2;
+      const v2 = [0, 1, 2].map((c) => {
+        const linear = p0.v[c] + (p1.v[c] - p0.v[c]) * u;
+        const spline = h00 * p0.v[c] + h10 * h * m0[c] + h01 * p1.v[c] + h11 * h * m1[c];
+        const value = linear + (spline - linear) * smooth;
+        return clamp(value, Math.min(p0.v[c], p1.v[c]), Math.max(p0.v[c], p1.v[c]));
+      });
+      return [...outOfSpace(space, v2), alpha];
+    }
+  };
+}
+function sampleVectorGradient(g, t) {
+  const ramp = vectorGradientRamp(g);
+  if (ramp) {
+    const [r, gg, b, a] = ramp.sample(t);
+    return { color: _chunkA6PHCAGXcjs.rgbaToHex.call(void 0, r, gg, b), opacity: a };
+  }
+  const stops = sortedVectorGradientStops(g);
+  const s = _nullishCoalesce([...stops].reverse().find((x) => x.offset <= t), () => ( stops[0]));
+  return s ? { color: s.color, opacity: _nullishCoalesce(s.opacity, () => ( 1)) } : { color: "#000000", opacity: 0 };
+}
+var stopOf = (offset, c) => {
+  const color = _chunkA6PHCAGXcjs.rgbaToHex.call(void 0, c[0], c[1], c[2]);
+  const opacity = Math.round(c[3] * 1e4) / 1e4;
+  return opacity < 1 ? { offset, color, opacity } : { offset, color };
+};
+var maxDiff = (a, b) => Math.max(Math.abs(a[0] - b[0]), Math.abs(a[1] - b[1]), Math.abs(a[2] - b[2]), Math.abs(a[3] - b[3]));
+var lerpRgba = (a, b, u) => [0, 1, 2, 3].map((c) => a[c] + (b[c] - a[c]) * u);
+function expandVectorGradientStops(g, options = {}) {
+  const stops = sortedVectorGradientStops(g);
+  const plain3 = () => stops.map(({ offset, color, opacity }) => opacity !== void 0 && opacity !== 1 ? { offset, color, opacity } : { offset, color });
+  if (!vectorGradientNeedsExpansion(g)) return plain3();
+  const ramp = vectorGradientRamp(g);
+  if (!ramp || stops.length < 2) return plain3();
+  const tol = _nullishCoalesce(options.tolerance, () => ( 0.5 / 255));
+  const sRgbOnly = (_nullishCoalesce(g.interpolation, () => ( "srgb"))) === "srgb" && !((_nullishCoalesce(g.smoothness, () => ( 0))) > 0);
+  const own = (s) => {
+    const c = parseVectorColor(s.color);
+    return [c[0], c[1], c[2], c[3] * clamp(_nullishCoalesce(s.opacity, () => ( 1)), 0, 1)];
+  };
+  const out = [];
+  const push = (offset, c) => out.push(stopOf(offset, c));
+  for (let i = 0; i < stops.length; i++) {
+    const a = stops[i];
+    const b = stops[i + 1];
+    push(a.offset, own(a));
+    if (!b || b.offset - a.offset < 1e-9) continue;
+    const knots = [a.offset];
+    if (hasMidpoint(a)) knots.push(a.offset + (b.offset - a.offset) * clamp(a.midpoint, MID_MIN, MID_MAX));
+    knots.push(b.offset);
+    const inside = (t) => ramp.sample(clamp(t, a.offset + 1e-9, b.offset - 1e-9));
+    for (let k = 0; k + 1 < knots.length; k++) {
+      const t0 = knots[k];
+      const t1 = knots[k + 1];
+      if (k > 0) push(t0, inside(t0));
+      if (sRgbOnly) continue;
+      const refine = (x0, c0, x1, c1, depth) => {
+        const xm = (x0 + x1) / 2;
+        const cm = inside(xm);
+        const ok = depth >= 8 || [0.03, 0.1, 0.25, 0.5, 0.75, 0.9, 0.97].every((f) => maxDiff(inside(x0 + (x1 - x0) * f), lerpRgba(c0, c1, f)) <= tol);
+        if (ok) return;
+        refine(x0, c0, xm, cm, depth + 1);
+        push(xm, cm);
+        refine(xm, cm, x1, c1, depth + 1);
+      };
+      refine(t0, inside(t0), t1, inside(t1), 0);
+    }
+  }
+  return out;
+}
+function samplePlainStops(stops, t) {
+  const parsed = stops.map((s) => {
+    const c = _nullishCoalesce(parseVectorColor(s.color), () => ( [0, 0, 0, 1]));
+    return { t: s.offset, c: [c[0], c[1], c[2], c[3] * (_nullishCoalesce(s.opacity, () => ( 1)))] };
+  });
+  if (!parsed.length) return [0, 0, 0, 0];
+  if (t <= parsed[0].t) return parsed[0].c;
+  for (let i = 0; i + 1 < parsed.length; i++) {
+    const a = parsed[i];
+    const b = parsed[i + 1];
+    if (t <= b.t) return b.t - a.t < 1e-12 ? b.c : lerpRgba(a.c, b.c, (t - a.t) / (b.t - a.t));
+  }
+  return parsed[parsed.length - 1].c;
+}
+function reverseVectorGradient(g) {
+  const stops = sortedVectorGradientStops(g).reverse();
+  const next = stops.map((s, i) => {
+    const following = stops[i + 1];
+    const mid = following ? 1 - (_nullishCoalesce(following.midpoint, () => ( 0.5))) : 0.5;
+    const { midpoint: _m, ...rest } = s;
+    return { ...rest, offset: 1 - s.offset, ...Math.abs(mid - 0.5) > 1e-6 ? { midpoint: mid } : {} };
+  });
+  return { ...g, stops: next };
+}
+function placeStop(stops, stop) {
+  let i = stops.findIndex((o) => o.offset > stop.offset);
+  if (i < 0) i = stops.length;
+  stops.splice(i, 0, stop);
+  return i;
+}
+function insertVectorGradientStop(g, offset) {
+  const at2 = clamp(offset, 0, 1);
+  const { color, opacity } = sampleVectorGradient(g, at2);
+  const stops = sortedVectorGradientStops(g);
+  const index = placeStop(stops, opacity < 1 ? { offset: at2, color, opacity } : { offset: at2, color });
+  return { stops, index };
+}
+function moveVectorGradientStop(stops, index, offset) {
+  const next = stops.map((s2) => ({ ...s2 }));
+  if (index < 0 || index >= next.length) return { stops: next, index };
+  const [s] = next.splice(index, 1);
+  return { stops: next, index: placeStop(next, { ...s, offset: clamp(offset, 0, 1) }) };
+}
+function removeVectorGradientStop(stops, index) {
+  if (stops.length <= VECTOR_GRADIENT_MIN_STOPS || index < 0 || index >= stops.length) return null;
+  return stops.filter((_, i) => i !== index);
+}
+function vectorGradientMidpointPosition(stops, index) {
+  const a = stops[index];
+  const b = stops[index + 1];
+  if (!a || !b) return null;
+  return a.offset + (b.offset - a.offset) * (_nullishCoalesce(a.midpoint, () => ( 0.5)));
+}
+function vectorGradientMidpointFromPosition(stops, index, pos) {
+  const a = stops[index];
+  const b = stops[index + 1];
+  if (!a || !b) return null;
+  const span = Math.max(b.offset - a.offset, 1e-6);
+  return clamp((pos - a.offset) / span, 0.05, 0.95);
+}
+function spanVectorGradientStops(g, from, to, expanded = expandVectorGradientStops(g)) {
+  if (to < from) {
+    const s = spanVectorGradientStops(g, to, from, expanded);
+    return s.map((x) => ({ ...x, offset: 1 - x.offset })).reverse();
+  }
+  const d = to - from;
+  const at2 = (offset, t) => stopOf(offset, samplePlainStops(expanded, t));
+  const out = [at2(0, from)];
+  if (d > 1e-9) {
+    for (const s of expanded) if (s.offset > from && s.offset < to) out.push({ ...s, offset: (s.offset - from) / d });
+  }
+  out.push(at2(1, to));
+  return out;
+}
+var hasExplicitGradientGeometry = (g) => finitePoint(g.start) && finitePoint(g.end);
+function shorthandPoints(g) {
+  if (g.type === "linear" || g.type === "reflected") {
+    const c = _chunkVNYRI265cjs.angleToSvgLinearCoords.call(void 0, Number.isFinite(g.angle) ? g.angle : 180);
+    const start2 = g.type === "linear" ? { x: c.x1, y: c.y1 } : { x: 0.5, y: 0.5 };
+    const end = { x: c.x2, y: c.y2 };
+    return { start: start2, end, width: add(start2, perp(sub(end, start2))) };
+  }
+  const start = { x: Number.isFinite(g.cx) ? g.cx : 0.5, y: Number.isFinite(g.cy) ? g.cy : 0.5 };
+  const r = Number.isFinite(g.r) ? g.r : 0.5;
+  if (g.type === "radial") return { start, end: { x: start.x + r, y: start.y }, width: { x: start.x, y: start.y + r } };
+  const a = (Number.isFinite(g.angle) ? g.angle : 90) * Math.PI / 180;
+  const dir = { x: Math.sin(a), y: -Math.cos(a) };
+  return { start, end: add(start, scale(dir, r)), width: add(start, scale(perp(dir), r)) };
+}
+function vectorGradientPoints(g) {
+  const explicit = hasExplicitGradientGeometry(g);
+  const base = explicit ? null : shorthandPoints(g);
+  const start = explicit ? { x: g.start.x, y: g.start.y } : base.start;
+  const end = explicit ? { x: g.end.x, y: g.end.y } : base.end;
+  const width = explicit ? finitePoint(g.width) ? { x: g.width.x, y: g.width.y } : add(start, perp(sub(end, start))) : base.width;
+  return {
+    start,
+    end,
+    width,
+    focal: g.type === "radial" && finitePoint(g.focal) ? { x: g.focal.x, y: g.focal.y } : null,
+    focalRadius: g.type === "radial" ? clamp(Number.isFinite(g.focalRadius) ? g.focalRadius : 0, 0, 0.99) : 0,
+    units: explicit && g.units === "userSpaceOnUse" ? "userSpaceOnUse" : "objectBoundingBox"
+  };
+}
+function vectorBoxMatrix(bounds) {
+  if (!bounds) return IDENTITY;
+  let { x, y, width: w, height: h } = bounds;
+  const fallback = Math.max(w, h, 1e-9) > 1e-9 ? Math.max(w, h) : 1;
+  if (!(w > 1e-9)) {
+    x -= fallback / 2 - w / 2;
+    w = fallback;
+  }
+  if (!(h > 1e-9)) {
+    y -= fallback / 2 - h / 2;
+    h = fallback;
+  }
+  return [w, 0, 0, h, x, y];
+}
+var framePointsMatrix = (p) => [p.end.x - p.start.x, p.end.y - p.start.y, p.width.x - p.start.x, p.width.y - p.start.y, p.start.x, p.start.y];
+function vectorGradientUnitsMatrix(g, bounds) {
+  return vectorGradientPoints(g).units === "objectBoundingBox" ? vectorBoxMatrix(bounds) : IDENTITY;
+}
+function vectorGradientMatrix(g, bounds) {
+  return mul(framePointsMatrix(vectorGradientPoints(g)), vectorGradientUnitsMatrix(g, bounds));
+}
+var FOCAL_MAX = 0.99;
+function unitFocal(g) {
+  const p = vectorGradientPoints(g);
+  if (!p.focal && !(p.focalRadius > 0)) return null;
+  const inv = invert(framePointsMatrix(p));
+  if (!inv) return null;
+  let f = p.focal ? apply(inv, p.focal) : { x: 0, y: 0 };
+  const reach = FOCAL_MAX * (1 - p.focalRadius);
+  const r = Math.hypot(f.x, f.y);
+  if (r > reach) f = scale(f, reach / r);
+  return { f, fr: p.focalRadius };
+}
+function vectorGradientFocalParam(q, f = { x: 0, y: 0 }, fr = 0) {
+  const d = sub(q, f);
+  const dr = 1 - fr;
+  const a = dot(f, f) - dr * dr;
+  const b = dot(d, f) - fr * dr;
+  const c = dot(d, d) - fr * fr;
+  if (Math.abs(a) < 1e-12) return Math.abs(b) < 1e-12 ? 0 : -c / (2 * b);
+  return (-b - Math.sqrt(Math.max(0, b * b - a * c))) / a;
+}
+function vectorGradientParam(type, q, focal) {
+  switch (type) {
+    case "linear":
+      return q.x;
+    case "reflected":
+      return Math.abs(q.x);
+    case "diamond":
+      return Math.abs(q.x) + Math.abs(q.y);
+    case "conic": {
+      const turn = Math.atan2(q.y, q.x) / (2 * Math.PI);
+      return turn - Math.floor(turn);
+    }
+    case "radial":
+      return focal ? vectorGradientFocalParam(q, focal.f, focal.fr) : Math.hypot(q.x, q.y);
+  }
+}
+function applyVectorGradientSpread(t, spread = "pad") {
+  if (!Number.isFinite(t)) return 0;
+  if (spread === "repeat") return t - Math.floor(t);
+  if (spread === "reflect") {
+    const m = (t % 2 + 2) % 2;
+    return m <= 1 ? m : 2 - m;
+  }
+  return clamp(t, 0, 1);
+}
+function vectorGradientTAt(g, bounds, p) {
+  const inv = invert(vectorGradientMatrix(g, bounds));
+  if (!inv) return 0;
+  const raw = vectorGradientParam(g.type, apply(inv, p), g.type === "radial" ? unitFocal(g) : null);
+  return g.type === "conic" ? raw : applyVectorGradientSpread(raw, _nullishCoalesce(g.spread, () => ( "pad")));
+}
+function sampleVectorGradientAt(g, bounds, p) {
+  const t = vectorGradientTAt(g, bounds, p);
+  const ramp = vectorGradientRamp(g);
+  return ramp ? ramp.sample(t) : samplePlainStops(sortedVectorGradientStops(g), t);
+}
+function vectorGradientAspect(g) {
+  const p = vectorGradientPoints(g);
+  const u = sub(p.end, p.start);
+  const l2 = dot(u, u);
+  return l2 > 1e-18 ? dot(sub(p.width, p.start), perp(u)) / l2 : 1;
+}
+function explicitVectorGradient(g) {
+  const p = vectorGradientPoints(g);
+  const { angle: _a, cx: _cx, cy: _cy, r: _r, ...rest } = g;
+  return {
+    ...rest,
+    start: p.start,
+    end: p.end,
+    width: p.width,
+    ...p.focal ? { focal: p.focal } : {},
+    units: p.units
+  };
+}
+function pinVectorGradient(g, bounds) {
+  const e = explicitVectorGradient(g);
+  if (e.units === "userSpaceOnUse") return e;
+  const m = vectorBoxMatrix(bounds);
+  return { ...e, start: apply(m, e.start), end: apply(m, e.end), width: apply(m, e.width), ...e.focal ? { focal: apply(m, e.focal) } : {}, units: "userSpaceOnUse" };
+}
+function transformVectorGradient(g, m) {
+  if (!hasExplicitGradientGeometry(g) || g.units !== "userSpaceOnUse" || isIdentity(m)) return g;
+  const p = vectorGradientPoints(g);
+  return { ...g, start: apply(m, p.start), end: apply(m, p.end), width: apply(m, p.width), ...p.focal ? { focal: apply(m, p.focal) } : {} };
+}
+function transformVectorPaint(paint, m) {
+  return isVectorGradient(paint) ? transformVectorGradient(paint, m) : paint;
+}
+var isCentredVectorGradient = (type) => type === "radial" || type === "conic" || type === "diamond";
+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);
+  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, _nullishCoalesce(_optionalChain([f, 'optionalAccess', _2 => _2.f]), () => ( { x: 0, y: 0 }))) : null
+  };
+}
+function withMainAxis(p, start, end) {
+  const before = invert(framePointsMatrix(p));
+  const u = sub(p.end, p.start);
+  const l2 = dot(u, u);
+  const w = sub(p.width, p.start);
+  const rel = l2 > 1e-18 ? { a: dot(w, u) / l2, b: dot(w, perp(u)) / l2 } : { a: 0, b: 1 };
+  const u2 = sub(end, start);
+  const width = add(start, add(scale(u2, rel.a), scale(perp(u2), rel.b)));
+  const next = { start, end, width };
+  const focal = p.focal && before ? apply(framePointsMatrix(next), apply(before, p.focal)) : p.focal;
+  return { ...next, focal };
+}
+function moveVectorGradientHandle(g, bounds, handle, to, from = to) {
+  const pinned = pinVectorGradient(g, bounds);
+  const p = vectorGradientPoints(pinned);
+  const set = (q) => {
+    const next = { ...pinned, ...q };
+    if (next.focal === null || next.focal === void 0) delete next.focal;
+    return next;
+  };
+  switch (handle) {
+    case "start": {
+      const d = sub(to, from);
+      return set({ start: add(p.start, d), end: add(p.end, d), width: add(p.width, d), focal: p.focal ? add(p.focal, d) : null });
+    }
+    case "end":
+    case "radius": {
+      if (Math.hypot(to.x - p.start.x, to.y - p.start.y) < 1e-6) return pinned;
+      const n = withMainAxis(p, p.start, to);
+      return set({ end: n.end, width: n.width, focal: n.focal });
+    }
+    case "aspect": {
+      const u = sub(p.end, p.start);
+      const l2 = dot(u, u);
+      if (l2 < 1e-18) return pinned;
+      let aspect = dot(sub(to, p.start), perp(u)) / l2;
+      if (Math.abs(aspect) < 0.01) aspect = aspect < 0 ? -0.01 : 0.01;
+      const before = invert(framePointsMatrix(p));
+      const width = add(p.start, scale(perp(u), aspect));
+      const focal = p.focal && before ? apply(framePointsMatrix({ start: p.start, end: p.end, width }), apply(before, p.focal)) : null;
+      return set({ width, focal });
+    }
+    case "focal": {
+      const frame2 = framePointsMatrix(p);
+      const inv = invert(frame2);
+      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) });
+    }
+  }
+}
+function setVectorGradientVector(g, bounds, start, end) {
+  const pinned = pinVectorGradient(g, bounds);
+  const p = vectorGradientPoints(pinned);
+  const aspect = Math.abs(vectorGradientAspect(pinned)) > 1e-6 ? vectorGradientAspect(pinned) : 1;
+  const u = sub(end, start);
+  const width = add(start, scale(perp(u), aspect));
+  const before = invert(framePointsMatrix(p));
+  const focal = p.focal && before ? apply(framePointsMatrix({ start, end, width }), apply(before, p.focal)) : null;
+  const next = { ...pinned, start, end, width };
+  if (focal) next.focal = focal;
+  else delete next.focal;
+  return next;
+}
+var VECTOR_GRADIENT_MAX_PERIODS = 64;
+function wholePeriod(stops) {
+  const out = stops.map((s) => ({ ...s }));
+  if (out.length && out[0].offset > 0) out.unshift({ ...out[0], offset: 0 });
+  const last = out[out.length - 1];
+  if (last && last.offset < 1) out.push({ ...last, offset: 1 });
+  return out;
+}
+function periodicVectorGradientStops(stops, lo, hi, mirrored) {
+  const period = wholePeriod(stops);
+  const back = reverseVectorGradient({ stops: period }).stops;
+  const n = Math.max(1, hi - lo);
+  const out = [];
+  for (let j = 0; j < n; j++) {
+    const one = mirrored(lo + j) ? back : period;
+    for (const s of one) out.push({ ...s, offset: (j + s.offset) / n });
+  }
+  return out;
+}
+function expandVectorGradientSpread(g, bounds, area) {
+  const m = vectorGradientMatrix(g, bounds);
+  const inv = invert(m);
+  const spread = _nullishCoalesce(g.spread, () => ( "pad"));
+  const reflected = g.type === "reflected";
+  if (!inv || !reflected && spread === "pad") return null;
+  const odd = (k) => (k % 2 + 2) % 2 === 1;
+  const stops = expandVectorGradientStops(g);
+  const along2 = (a, b, mirrored2, capped2 = false) => ({
+    start: apply(m, { x: a, y: 0 }),
+    end: apply(m, { x: b, y: 0 }),
+    from: a,
+    to: b,
+    matrix: m,
+    stops: periodicVectorGradientStops(stops, a, b, mirrored2),
+    capped: capped2
+  });
+  if (reflected && spread === "pad") return along2(-1, 1, (k) => k < 0);
+  const us = boxCorners(area).map((c) => apply(inv, c).x);
+  let lo = Math.floor(Math.min(...us));
+  let hi = Math.ceil(Math.max(...us));
+  if (reflected) {
+    lo = Math.min(lo, -1);
+    hi = Math.max(hi, 1);
+  }
+  hi = Math.max(hi, lo + 1);
+  if (!reflected && lo >= 0 && hi <= 1) return null;
+  const capped = hi - lo > VECTOR_GRADIENT_MAX_PERIODS;
+  if (capped) {
+    lo = Math.max(lo, -VECTOR_GRADIENT_MAX_PERIODS / 2);
+    hi = lo + VECTOR_GRADIENT_MAX_PERIODS;
+  }
+  const mirrored = reflected ? (k) => {
+    const j = k >= 0 ? k : -k - 1;
+    const own = spread === "reflect" && odd(j);
+    return k < 0 ? !own : own;
+  } : (k) => spread === "reflect" && odd(k);
+  return along2(lo, hi, mirrored, capped);
+}
+var boxCorners = (b) => [
+  { x: b.x, y: b.y },
+  { x: b.x + b.width, y: b.y },
+  { x: b.x + b.width, y: b.y + b.height },
+  { x: b.x, y: b.y + b.height }
+];
+var toSvgStops = (stops) => stops.map((s) => ({ offset: `${fmt(s.offset * 100, 3)}%`, 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 padBounds = (b, pad) => ({ x: b.x - pad, y: b.y - pad, width: b.width + 2 * pad, height: b.height + 2 * pad });
+var vectorGradientArea = (bounds) => padBounds(_nullishCoalesce(bounds, () => ( { x: 0, y: 0, width: 1, height: 1 })), 1);
+var transformAttr = (m) => isIdentity(m) ? {} : { gradientTransform: fmtMatrix(m) };
+function minScale(m) {
+  const [a, b, c, d] = m;
+  const p = a * a + b * b;
+  const q = c * c + d * d;
+  const r = a * c + b * d;
+  return Math.sqrt(Math.max(0, (p + q - Math.sqrt((p - q) ** 2 + 4 * r * r)) / 2));
+}
+function patternAttrs(area) {
+  const [x, y, w, h] = [area.x, area.y, Math.max(area.width, 1e-3), Math.max(area.height, 1e-3)].map((n) => fmt(n, 3));
+  return { patternUnits: "userSpaceOnUse", x, y, width: w, height: h, viewBox: `${x} ${y} ${w} ${h}` };
+}
+function patternDef(id, area, gradients, tiles) {
+  return {
+    id,
+    type: "pattern",
+    attrs: patternAttrs(area),
+    gradients,
+    tiles
+  };
+}
+function vectorGradientSvgDefs(g, id, options = {}) {
+  const precision = _nullishCoalesce(options.precision, () => ( 3));
+  const bounds = _nullishCoalesce(options.bounds, () => ( null));
+  const area = _nullishCoalesce(options.area, () => ( vectorGradientArea(bounds)));
+  const spread = g.spread && VECTOR_GRADIENT_SPREADS.includes(g.spread) ? g.spread : "pad";
+  const stops = expandVectorGradientStops(g);
+  const p = vectorGradientPoints(g);
+  const unitsM = vectorGradientUnitsMatrix(g, bounds);
+  const frameM = mul(framePointsMatrix(p), unitsM);
+  const spreadAttr = (s) => s === "pad" ? {} : { spreadMethod: s };
+  const base = { gradientUnits: "userSpaceOnUse" };
+  switch (g.type) {
+    case "linear":
+    case "reflected": {
+      if (g.type === "reflected" && spread !== "reflect") {
+        const ex = expandVectorGradientSpread(g, bounds, area);
+        const [a, b] = ex ? [ex.from, ex.to] : [-1, 1];
+        const st = _nullishCoalesce(_optionalChain([ex, 'optionalAccess', _3 => _3.stops]), () => ( periodicVectorGradientStops(stops, -1, 1, (k) => k < 0)));
+        return [{ id, type: "linear", attrs: { ...base, x1: a, y1: 0, x2: b, y2: 0, gradientTransform: fmtMatrix(frameM) }, stops: toSvgStops(st) }];
+      }
+      const u = sub(p.end, p.start);
+      const w = sub(p.width, p.start);
+      const square = Math.abs(dot(u, w)) <= 1e-9 * Math.max(dot(u, u), dot(w, w), 1e-18);
+      const coords = square ? { x1: fmt(p.start.x, 6), y1: fmt(p.start.y, 6), x2: fmt(p.end.x, 6), y2: fmt(p.end.y, 6), ...transformAttr(unitsM) } : { x1: 0, y1: 0, x2: 1, y2: 0, gradientTransform: fmtMatrix(frameM) };
+      return [{ id, type: "linear", attrs: { ...base, ...coords, ...spreadAttr(spread) }, stops: toSvgStops(stops) }];
+    }
+    case "radial": {
+      const f = unitFocal(g);
+      const attrs = { ...base, cx: 0, cy: 0, r: 1, gradientTransform: fmtMatrix(frameM), ...spreadAttr(spread) };
+      if (f && (Math.abs(f.f.x) > 1e-9 || Math.abs(f.f.y) > 1e-9)) {
+        attrs.fx = fmt(f.f.x, 6);
+        attrs.fy = fmt(f.f.y, 6);
+      }
+      if (f && f.fr > 0) attrs.fr = fmt(f.fr, 6);
+      return [{ id, type: "radial", attrs, stops: toSvgStops(stops) }];
+    }
+    case "diamond": {
+      const inv = invert(frameM);
+      if (!inv) return [patternDef(id, area, [], [{ d: polygonD(boxCorners(area), precision), fill: _nullishCoalesce(_optionalChain([stops, 'access', _4 => _4[stops.length - 1], 'optionalAccess', _5 => _5.color]), () => ( "none")) }])];
+      const reach = 2 * Math.max(...boxCorners(area).map((c) => {
+        const q = apply(inv, c);
+        return Math.abs(q.x) + Math.abs(q.y);
+      })) + 1;
+      const delta = Math.min(0.05 * reach, 0.75 / Math.max(minScale(frameM), 1e-9));
+      const gradients = [];
+      const tiles = [];
+      [[1, 1], [-1, 1], [-1, -1], [1, -1]].forEach(([sx, sy], k) => {
+        const gid = `${id}-q${k}`;
+        gradients.push({ id: gid, type: "linear", attrs: { ...base, x1: 0, y1: 0, x2: sx / 2, y2: sy / 2, gradientTransform: fmtMatrix(frameM), ...spreadAttr(spread) }, stops: toSvgStops(stops) });
+        const quad = [{ x: -delta * sx, y: -delta * sy }, { x: reach * sx, y: -delta * sy }, { x: -delta * sx, y: reach * sy }].map((q) => apply(frameM, q));
+        tiles.push({ d: polygonD(quad, precision), fill: `url(#${gid})` });
+      });
+      return [patternDef(id, area, gradients, tiles)];
+    }
+    case "conic":
+      return [conicPattern(id, frameM, stops, area, _nullishCoalesce(options.wedges, () => ( 72)), precision)];
+  }
+}
+function conicPattern(id, frameM, stops, area, wedges, precision) {
+  const inv = invert(frameM);
+  const n = Math.max(8, Math.min(720, Math.round(wedges)));
+  const half = Math.PI / n;
+  if (!inv || !stops.length) return patternDef(id, area, [], [{ d: polygonD(boxCorners(area), precision), fill: _nullishCoalesce(_optionalChain([stops, 'access', _6 => _6[0], 'optionalAccess', _7 => _7.color]), () => ( "none")) }]);
+  const reach = (Math.max(...boxCorners(area).map((c) => Math.hypot(apply(inv, c).x, apply(inv, c).y))) + 1) / Math.cos(half);
+  const overlap = Math.min(half, 2e-3);
+  const gradients = [];
+  const tiles = [];
+  for (let k = 0; k < n; k++) {
+    const a0 = 2 * Math.PI * k / n;
+    const a1 = 2 * Math.PI * (k + 1) / n;
+    const mid = (a0 + a1) / 2;
+    const tau = { x: -Math.sin(mid), y: Math.cos(mid) };
+    const s = Math.sin(half);
+    const at2 = (angle) => (Math.sin(angle - mid) / s + 1) / 2;
+    const t0 = k / n;
+    const t1 = (k + 1) / n;
+    const own = [stopOf(0, samplePlainStops(stops, t0))];
+    for (const st of stops) if (st.offset > t0 && st.offset < t1) own.push({ ...st, offset: at2(st.offset * 2 * Math.PI) });
+    own.push(stopOf(1, samplePlainStops(stops, t1)));
+    const gid = `${id}-w${k}`;
+    gradients.push({
+      id: gid,
+      type: "linear",
+      attrs: { gradientUnits: "userSpaceOnUse", x1: fmt(-s * tau.x, 6), y1: fmt(-s * tau.y, 6), x2: fmt(s * tau.x, 6), y2: fmt(s * tau.y, 6), gradientTransform: fmtMatrix(frameM) },
+      stops: toSvgStops(own)
+    });
+    const from = a0 - (k === 0 ? 0 : overlap);
+    const pts = [{ x: 0, y: 0 }, { x: reach * Math.cos(from), y: reach * Math.sin(from) }, { x: reach * Math.cos(a1), y: reach * Math.sin(a1) }].map((q) => apply(frameM, q));
+    tiles.push({ d: polygonD(pts, precision), fill: `url(#${gid})` });
+  }
+  return patternDef(id, area, gradients, tiles);
+}
+var num = (v2, fallback = 0) => {
+  if (v2 === void 0) return fallback;
+  const n = typeof v2 === "number" ? v2 : parseFloat(v2);
+  return Number.isFinite(n) ? n : fallback;
+};
+var parseMatrixAttr = (v2) => {
+  const m = typeof v2 === "string" ? /^matrix\(([^)]*)\)$/.exec(v2.trim()) : null;
+  if (!m) return IDENTITY;
+  const n = m[1].split(/[\s,]+/).map(Number);
+  return n.length === 6 && n.every(Number.isFinite) ? n : IDENTITY;
+};
+var plainOf = (stops) => stops.map((s) => ({ offset: parseFloat(s.offset) / (s.offset.endsWith("%") ? 100 : 1), color: s.stopColor, ...s.stopOpacity !== void 0 ? { opacity: s.stopOpacity } : {} }));
+function inTile(d, p) {
+  const n = _nullishCoalesce(_optionalChain([d, 'access', _8 => _8.match, 'call', _9 => _9(/-?[\d.]+(?:e-?\d+)?/gi), 'optionalAccess', _10 => _10.map, 'call', _11 => _11(Number)]), () => ( []));
+  let inside = false;
+  for (let i = 0, j = n.length - 2; i + 1 < n.length; j = i, i += 2) {
+    const [xi, yi, xj, yj] = [n[i], n[i + 1], n[j], n[j + 1]];
+    if (yi > p.y !== yj > p.y && p.x < (xj - xi) * (p.y - yi) / (yj - yi) + xi) inside = !inside;
+  }
+  return inside;
+}
+function sampleVectorPaintDefAt(defs, id, p) {
+  const all = /* @__PURE__ */ new Map();
+  for (const d of defs) {
+    all.set(d.id, d);
+    if (d.type === "pattern") for (const gd of d.gradients) all.set(gd.id, gd);
+  }
+  const paint = (ref, q) => {
+    const url = /^url\(#(.+)\)$/.exec(ref);
+    if (!url) return parseVectorColor(ref);
+    const def = all.get(url[1]);
+    if (!def) return null;
+    if (def.type === "pattern") {
+      for (let i = def.tiles.length - 1; i >= 0; i--) if (inTile(def.tiles[i].d, q)) return paint(def.tiles[i].fill, q);
+      return null;
+    }
+    const inv = _nullishCoalesce(invert(parseMatrixAttr(def.attrs.gradientTransform)), () => ( IDENTITY));
+    const local = apply(inv, q);
+    const spread = _nullishCoalesce(def.attrs.spreadMethod, () => ( "pad"));
+    let t;
+    if (def.type === "radial") {
+      const r = num(def.attrs.r, 0.5);
+      const c = { x: num(def.attrs.cx), y: num(def.attrs.cy) };
+      const f = { x: num(def.attrs.fx, c.x), y: num(def.attrs.fy, c.y) };
+      const u = { x: (local.x - c.x) / r, y: (local.y - c.y) / r };
+      t = vectorGradientFocalParam(u, { x: (f.x - c.x) / r, y: (f.y - c.y) / r }, num(def.attrs.fr) / r);
+    } else {
+      const a = { x: num(def.attrs.x1), y: num(def.attrs.y1) };
+      const b = { x: num(def.attrs.x2, 1), y: num(def.attrs.y2) };
+      const v2 = sub(b, a);
+      const l2 = dot(v2, v2);
+      t = l2 > 1e-18 ? dot(sub(local, a), v2) / l2 : 0;
+    }
+    return samplePlainStops(plainOf(def.stops), applyVectorGradientSpread(t, spread));
+  };
+  return paint(`url(#${id})`, p);
+}
+var readPoint = (v2) => finitePoint(v2) ? { x: v2.x, y: v2.y } : void 0;
+function sanitizeVectorGradient(input) {
+  if (!input || typeof input !== "object") return null;
+  const r = input;
+  if (!VECTOR_GRADIENT_TYPES.includes(r.type) || !Array.isArray(r.stops)) return null;
+  const stops = [];
+  for (const s of r.stops) {
+    if (!s || typeof s !== "object") continue;
+    const x = s;
+    if (typeof x.color !== "string" || typeof x.offset !== "number" || !Number.isFinite(x.offset)) continue;
+    const stop = { offset: clamp(x.offset, 0, 1), color: x.color.slice(0, 100) };
+    if (typeof x.opacity === "number" && Number.isFinite(x.opacity) && x.opacity !== 1) stop.opacity = clamp(x.opacity, 0, 1);
+    if (typeof x.midpoint === "number" && Number.isFinite(x.midpoint) && Math.abs(x.midpoint - 0.5) > 1e-6) stop.midpoint = clamp(x.midpoint, 0.05, 0.95);
+    stops.push(stop);
+  }
+  if (!stops.length) return null;
+  const g = { type: r.type, stops };
+  for (const k of ["angle", "cx", "cy", "r"]) if (typeof r[k] === "number" && Number.isFinite(r[k])) g[k] = r[k];
+  const start = readPoint(r.start);
+  const end = readPoint(r.end);
+  if (start && end) {
+    g.start = start;
+    g.end = end;
+    const width = readPoint(r.width);
+    if (width) g.width = width;
+    if (r.units === "userSpaceOnUse" || r.units === "objectBoundingBox") g.units = r.units;
+  }
+  const focal = readPoint(r.focal);
+  if (focal && g.type === "radial") g.focal = focal;
+  if (typeof r.focalRadius === "number" && r.focalRadius > 0 && g.type === "radial") g.focalRadius = clamp(r.focalRadius, 0, 0.99);
+  if (VECTOR_GRADIENT_SPREADS.includes(r.spread) && r.spread !== "pad") g.spread = r.spread;
+  if (VECTOR_GRADIENT_INTERPOLATIONS.includes(r.interpolation) && r.interpolation !== "srgb") g.interpolation = r.interpolation;
+  if (typeof r.smoothness === "number" && r.smoothness > 0) g.smoothness = clamp(r.smoothness, 0, 1);
+  if (VECTOR_STROKE_GRADIENT_MODES.includes(r.strokeMode) && r.strokeMode !== "within") g.strokeMode = r.strokeMode;
+  return g;
+}
+function convertVectorGradient(g, type) {
+  if (g.type === type) return g;
+  const next = { ...g, type };
+  if (type !== "radial") {
+    delete next.focal;
+    delete next.focalRadius;
+  }
+  if (!hasExplicitGradientGeometry(g)) {
+    if (isCentredVectorGradient(type) !== isCentredVectorGradient(g.type)) {
+      delete next.angle;
+      delete next.cx;
+      delete next.cy;
+      delete next.r;
+    }
+  }
+  return next;
+}
+function defaultVectorGradient(type = "linear", from) {
+  if (isVectorGradient(from)) return convertVectorGradient(from, type);
+  const colour = typeof from === "string" && parseVectorColor(from) ? from : "#000000";
+  return { type, stops: [{ offset: 0, color: colour }, { offset: 1, color: "#ffffff" }] };
+}
+function applyVectorGradientPatch(g, patch) {
+  const { aspect, reverse: reverse2, type, ...fields } = patch;
+  let next = type && type !== g.type ? convertVectorGradient(g, type) : { ...g };
+  const record = next;
+  for (const [k, v2] of Object.entries(fields)) {
+    if (v2 === void 0) continue;
+    if (v2 === null) delete record[k];
+    else record[k] = v2;
+  }
+  if ((fields.start || fields.end) && !hasExplicitGradientGeometry(next)) {
+    const p = vectorGradientPoints({ ...g, start: void 0, end: void 0 });
+    next.start = _nullishCoalesce(next.start, () => ( p.start));
+    next.end = _nullishCoalesce(next.end, () => ( p.end));
+  }
+  if (aspect !== void 0 && Number.isFinite(aspect)) {
+    const e = explicitVectorGradient(next);
+    const u = sub(e.end, e.start);
+    const a = Math.abs(aspect) < 0.01 ? aspect < 0 ? -0.01 : 0.01 : aspect;
+    next = { ...e, width: add(e.start, scale(perp(u), a)) };
+  }
+  if (reverse2) next = reverseVectorGradient(next);
+  const clean2 = sanitizeVectorGradient(next);
+  if (!clean2) return null;
+  clean2.stops = sortedVectorGradientStops(clean2);
+  return clean2;
+}
+
+// src/vector/corners.ts
+var EPS = 1e-9;
+var MIN_SINE = 1e-6;
+var sub2 = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
+var add2 = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
+var mul2 = (a, k) => ({ x: a.x * k, y: a.y * k });
+var dot2 = (a, b) => a.x * b.x + a.y * b.y;
 var cross = (a, b) => a.x * b.y - a.y * b.x;
 var len = (a) => Math.hypot(a.x, a.y);
 var pt = (p) => [p.x, p.y];
@@ -102,9 +914,9 @@ var Side = class {
   direction() {
     const p0 = vec(this.curve[0]);
     for (const q of this.curve.slice(1)) {
-      const d = sub(vec(q), p0);
+      const d = sub2(vec(q), p0);
       const l = len(d);
-      if (l > EPS) return mul(d, 1 / l);
+      if (l > EPS) return mul2(d, 1 / l);
     }
     return null;
   }
@@ -112,12 +924,12 @@ var Side = class {
   at(s, u) {
     if (this.straight) {
       const t2 = this.length > EPS ? Math.min(1, Math.max(0, s / this.length)) : 0;
-      return { t: t2, p: add(vec(this.curve[0]), mul(u, s)), dir: u };
+      return { t: t2, p: add2(vec(this.curve[0]), mul2(u, s)), dir: u };
     }
     const t = _chunkVNYRI265cjs.segmentParamAtLength.call(void 0, this.curve, s, this.length);
     const d = vec(_chunkVNYRI265cjs.segmentDerivative.call(void 0, this.curve, t));
     const l = len(d);
-    return { t, p: vec(_chunkVNYRI265cjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul(d, 1 / l) : u };
+    return { t, p: vec(_chunkVNYRI265cjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul2(d, 1 / l) : u };
   }
 };
 function cornerOf(sp, s, i) {
@@ -136,7 +948,7 @@ function cornerOf(sp, s, i) {
   const lu = sideU.length;
   const lv = sideV.length;
   if (!(lu > EPS && lv > EPS) || !Number.isFinite(lu) || !Number.isFinite(lv)) return null;
-  const cos = Math.max(-1, Math.min(1, dot(u, v2)));
+  const cos = Math.max(-1, Math.min(1, dot2(u, v2)));
   const sin = Math.abs(cross(u, v2));
   if (sin <= MIN_SINE) return null;
   return { subpath: s, index: i, at: { x: a.x, y: a.y }, u, v: v2, lu, lv, cos, sin, angle: Math.atan2(sin, cos) * 180 / Math.PI, maxRadius: Math.min(lu, lv) / 2 * sin / (1 + cos), sideU, sideV };
@@ -158,8 +970,8 @@ function vectorCorners(subpaths) {
 }
 var cornerSetback = (c, r) => r * (1 + c.cos) / c.sin;
 var fitCornerRadius = (c, radius) => Number.isFinite(radius) ? Math.min(Math.max(0, radius), c.maxRadius) : 0;
-var cornerBisectorPoint = (c, k) => add(c.at, mul(add(c.u, c.v), k));
-var cornerRadiusChange = (c, d) => dot(d, add(c.u, c.v)) * c.sin / (2 + 2 * c.cos);
+var cornerBisectorPoint = (c, k) => add2(c.at, mul2(add2(c.u, c.v), k));
+var cornerRadiusChange = (c, d) => dot2(d, add2(c.u, c.v)) * c.sin / (2 + 2 * c.cos);
 function arcHandle(cos) {
   const c = Math.max(-1, Math.min(1, cos));
   const sinHalf = Math.sqrt(Math.max(0, (1 - c) / 2));
@@ -167,9 +979,9 @@ function arcHandle(cos) {
   return 4 / 3 * sinHalf / (1 + cosHalf);
 }
 function squareTo(a, b) {
-  const w = sub(b, mul(a, dot(a, b)));
+  const w = sub2(b, mul2(a, dot2(a, b)));
   const l = len(w);
-  return l > EPS ? mul(w, 1 / l) : { x: 0, y: 0 };
+  return l > EPS ? mul2(w, 1 / l) : { x: 0, y: 0 };
 }
 function cutCorner(c, radius, kind) {
   const s = Math.min(cornerSetback(c, radius), Math.min(c.lu, c.lv) / 2);
@@ -178,19 +990,19 @@ function cutCorner(c, radius, kind) {
   const b = c.sideV.at(s, c.v);
   if (kind === "chamfer") return { tu: a.t, tv: b.t, start: a.p, out: null, in: null, end: b.p };
   if (kind === "inverted") {
-    const h = s * arcHandle(dot(a.dir, b.dir));
-    return { tu: a.t, tv: b.t, start: a.p, out: add(a.p, mul(squareTo(a.dir, b.dir), h)), in: add(b.p, mul(squareTo(b.dir, a.dir), h)), end: b.p };
+    const h = s * arcHandle(dot2(a.dir, b.dir));
+    return { tu: a.t, tv: b.t, start: a.p, out: add2(a.p, mul2(squareTo(a.dir, b.dir), h)), in: add2(b.p, mul2(squareTo(b.dir, a.dir), h)), end: b.p };
   }
-  const d1 = mul(a.dir, -1);
-  const d2 = mul(b.dir, -1);
-  const turn = Math.acos(Math.max(-1, Math.min(1, -dot(d1, d2))));
-  const chord = len(sub(b.p, a.p));
+  const d1 = mul2(a.dir, -1);
+  const d2 = mul2(b.dir, -1);
+  const turn = Math.acos(Math.max(-1, Math.min(1, -dot2(d1, d2))));
+  const chord = len(sub2(b.p, a.p));
   const k = turn < 1e-9 ? chord / 3 : 4 / 3 * Math.tan(turn / 4) * chord / (2 * Math.sin(turn / 2));
   if (!Number.isFinite(k)) return null;
-  return { tu: a.t, tv: b.t, start: a.p, out: add(a.p, mul(d1, k)), in: add(b.p, mul(d2, k)), end: b.p };
+  return { tu: a.t, tv: b.t, start: a.p, out: add2(a.p, mul2(d1, k)), in: add2(b.p, mul2(d2, k)), end: b.p };
 }
 var radiusOf = (a) => {
-  const r = _optionalChain([a, 'access', _2 => _2.corner, 'optionalAccess', _3 => _3.radius]);
+  const r = _optionalChain([a, 'access', _12 => _12.corner, 'optionalAccess', _13 => _13.radius]);
   return typeof r === "number" && r > 0 && Number.isFinite(r) ? r : 0;
 };
 function hasVectorCorners(subpaths) {
@@ -204,7 +1016,7 @@ function expandVectorCornersOf(sp, subpath = 0) {
     const c = cornerOf(sp, subpath, i);
     if (!c) return null;
     const fitted = fitCornerRadius(c, r);
-    return fitted > EPS ? cutCorner(c, fitted, _nullishCoalesce(_optionalChain([a, 'access', _4 => _4.corner, 'optionalAccess', _5 => _5.kind]), () => ( "round"))) : null;
+    return fitted > EPS ? cutCorner(c, fitted, _nullishCoalesce(_optionalChain([a, 'access', _14 => _14.corner, 'optionalAccess', _15 => _15.kind]), () => ( "round"))) : null;
   });
   if (!cuts.some(Boolean)) return { subpath: { closed: sp.closed, anchors: sp.anchors.map(plain) }, sources: sp.anchors.map((_, i) => i) };
   const trimmed = sp.anchors.map((a, j) => {
@@ -272,7 +1084,7 @@ function expandVectorCorners(subpaths) {
 function setAnchorCorner(a, radius, kind) {
   const { corner, ...rest } = a;
   const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;
-  const k = _nullishCoalesce(kind, () => ( _optionalChain([corner, 'optionalAccess', _6 => _6.kind])));
+  const k = _nullishCoalesce(kind, () => ( _optionalChain([corner, 'optionalAccess', _16 => _16.kind])));
   if (r <= 0 && !kind) return rest;
   return { ...rest, corner: { radius: r, ...k && k !== "round" ? { kind: k } : {} } };
 }
@@ -321,7 +1133,7 @@ function sanitizeWidthProfile(points) {
   return out.map((p, i) => [p, i]).sort((a, b) => a[0].t - b[0].t || a[1] - b[1]).map(([p]) => p);
 }
 function isUniformWidthProfile(points) {
-  return !_optionalChain([points, 'optionalAccess', _7 => _7.length]) || points.every((p) => p.left === 1 && p.right === 1);
+  return !_optionalChain([points, 'optionalAccess', _17 => _17.length]) || points.every((p) => p.left === 1 && p.right === 1);
 }
 function secant(pts, i, k) {
   const a = pts[i];
@@ -354,11 +1166,11 @@ function interp(pts, t, k) {
   return Math.max(0, w);
 }
 function widthProfileAt(points, t) {
-  if (!_optionalChain([points, 'optionalAccess', _8 => _8.length])) return { left: 1, right: 1 };
+  if (!_optionalChain([points, 'optionalAccess', _18 => _18.length])) return { left: 1, right: 1 };
   return { left: interp(points, t, "left"), right: interp(points, t, "right") };
 }
 function widthProfileMaxScale(points) {
-  if (!_optionalChain([points, 'optionalAccess', _9 => _9.length])) return 1;
+  if (!_optionalChain([points, 'optionalAccess', _19 => _19.length])) return 1;
   return points.reduce((m, p) => Math.max(m, p.left, p.right), 0);
 }
 function widthProfilePreset(id) {
@@ -368,7 +1180,7 @@ function widthProfilePreset(id) {
 function widthProfilePresetId(points) {
   if (isUniformWidthProfile(points)) return "uniform";
   const same = (a, b) => a.length === b.length && a.every((p, i) => Math.abs(p.t - b[i].t) < 1e-9 && Math.abs(p.left - b[i].left) < 1e-9 && Math.abs(p.right - b[i].right) < 1e-9);
-  return _nullishCoalesce(_optionalChain([VECTOR_WIDTH_PRESETS, 'access', _10 => _10.find, 'call', _11 => _11((p) => p.points.length && same(points, p.points)), 'optionalAccess', _12 => _12.id]), () => ( "custom"));
+  return _nullishCoalesce(_optionalChain([VECTOR_WIDTH_PRESETS, 'access', _20 => _20.find, 'call', _21 => _21((p) => p.points.length && same(points, p.points)), 'optionalAccess', _22 => _22.id]), () => ( "custom"));
 }
 function reverseWidthProfile(points) {
   return points.map((p) => ({ t: 1 - p.t, left: p.right, right: p.left })).reverse();
@@ -377,12 +1189,12 @@ function mirrorWidthProfile(points) {
   return points.map((p) => ({ t: p.t, left: p.right, right: p.left }));
 }
 function editable(points) {
-  return _optionalChain([points, 'optionalAccess', _13 => _13.length]) ? points.map((p) => ({ ...p })) : [sym(0, 1), sym(1, 1)];
+  return _optionalChain([points, 'optionalAccess', _23 => _23.length]) ? points.map((p) => ({ ...p })) : [sym(0, 1), sym(1, 1)];
 }
 function insertWidthPoint(points, t, sides2 = {}, options = {}) {
   const pts = editable(points);
   const tt = Math.min(Math.max(Number.isFinite(t) ? t : 0, 0), 1);
-  const here = widthProfileAt(_optionalChain([points, 'optionalAccess', _14 => _14.length]) ? points : null, tt);
+  const here = widthProfileAt(_optionalChain([points, 'optionalAccess', _24 => _24.length]) ? points : null, tt);
   const p = {
     t: tt,
     left: _nullishCoalesce(clean(sides2.left, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.left)),
@@ -453,7 +1265,7 @@ function generateWidthProfile(options) {
   const n = Math.max(8, Math.min(VECTOR_WIDTH_PROFILE_MAX_POINTS * 4, _nullishCoalesce(options.samples, () => ( Math.ceil(32 + cycles * 16)))));
   const raw = [];
   for (let i = 0; i <= n; i++) raw.push([i / n, taperWaveFactor(i / n, options.taper, options.wave)]);
-  const ts = [_optionalChain([options, 'access', _15 => _15.taper, 'optionalAccess', _16 => _16.startLength]), _optionalChain([options, 'access', _17 => _17.taper, 'optionalAccess', _18 => _18.endLength]) !== void 0 ? 1 - options.taper.endLength : void 0];
+  const ts = [_optionalChain([options, 'access', _25 => _25.taper, 'optionalAccess', _26 => _26.startLength]), _optionalChain([options, 'access', _27 => _27.taper, 'optionalAccess', _28 => _28.endLength]) !== void 0 ? 1 - options.taper.endLength : void 0];
   for (const t of ts) if (typeof t === "number" && t > 0 && t < 1) raw.push([t, taperWaveFactor(t, options.taper, options.wave)]);
   raw.sort((a, b) => a[0] - b[0]);
   const kept = simplifySamples(raw, _nullishCoalesce(options.tolerance, () => ( 0.01)), VECTOR_WIDTH_PROFILE_MAX_POINTS);
@@ -499,7 +1311,7 @@ function pressureWidthProfile(samples, options = {}) {
 // src/vector/varstroke.ts
 var SAMPLES_PER_SUBPATH = 128;
 var MAX_DASHES = 5e3;
-var sub2 = (a, b) => [a[0] - b[0], a[1] - b[1]];
+var sub3 = (a, b) => [a[0] - b[0], a[1] - b[1]];
 var along = (p, v2, k) => [p[0] + v2[0] * k, p[1] + v2[1] * k];
 var lerp = (a, b, u) => [a[0] + (b[0] - a[0]) * u, a[1] + (b[1] - a[1]) * u];
 var dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
@@ -590,11 +1402,11 @@ function arcPoints(c, a0, sweep, r0, r1, tol) {
   return out;
 }
 function crossing(a0, a1, b0, b1) {
-  const r = sub2(a1, a0);
-  const q = sub2(b1, b0);
+  const r = sub3(a1, a0);
+  const q = sub3(b1, b0);
   const den = r[0] * q[1] - r[1] * q[0];
   if (Math.abs(den) < 1e-12) return null;
-  const w = sub2(b0, a0);
+  const w = sub3(b0, a0);
   const t = (w[0] * q[1] - w[1] * q[0]) / den;
   const u = (w[0] * r[1] - w[1] * r[0]) / den;
   return t > 1e-9 && t <= 1 && u >= 0 && u < 1 - 1e-9 ? [a0[0] + r[0] * t, a0[1] + r[1] * t] : null;
@@ -620,7 +1432,7 @@ function variableStrokeRings(path, options) {
       const w = widthProfileAt(options.profile, s / len2);
       return [w.left * half, w.right * half];
     };
-    const intervals = _optionalChain([options, 'access', _19 => _19.dash, 'optionalAccess', _20 => _20.some, 'call', _21 => _21((v2) => v2 > 0)]) ? dashIntervals(options.dash, _nullishCoalesce(options.dashOffset, () => ( 0)), len2) : [[0, len2]];
+    const intervals = _optionalChain([options, 'access', _29 => _29.dash, 'optionalAccess', _30 => _30.some, 'call', _31 => _31((v2) => v2 > 0)]) ? dashIntervals(options.dash, _nullishCoalesce(options.dashOffset, () => ( 0)), len2) : [[0, len2]];
     const whole = intervals.length === 1 && intervals[0][0] <= 0 && intervals[0][1] >= len2;
     for (const [a, b] of intervals) {
       const [pa, ia] = at(poly, a);
@@ -638,7 +1450,7 @@ function variableStrokeRings(path, options) {
       const closed = whole && poly.closed;
       const m = run.length - 1;
       const dirs = [];
-      for (let i = 0; i < m; i++) dirs.push(unitOf(sub2(run[i + 1].p, run[i].p)));
+      for (let i = 0; i < m; i++) dirs.push(unitOf(sub3(run[i + 1].p, run[i].p)));
       const normals = dirs.map(leftNormal);
       const w = run.map((q) => sides2(q.s));
       const side = (sigma) => {
@@ -657,12 +1469,12 @@ function variableStrokeRings(path, options) {
           const d0 = dirs[i];
           const d1 = dirs[j];
           const cross2 = d0[0] * d1[1] - d0[1] * d1[0];
-          const dot2 = d0[0] * d1[0] + d0[1] * d1[1];
+          const dot3 = d0[0] * d1[0] + d0[1] * d1[1];
           const r0 = w[i + 1][k];
           const r1 = w[j][k];
           const e = E(i);
           const st = S(j);
-          if (Math.abs(cross2) < 1e-12 && dot2 > 0) {
+          if (Math.abs(cross2) < 1e-12 && dot3 > 0) {
             push(out, e);
             if (!seam) push(out, st);
             continue;
@@ -680,7 +1492,7 @@ function variableStrokeRings(path, options) {
             continue;
           }
           push(out, e);
-          const theta = uturn ? Math.PI : Math.atan2(cross2, dot2);
+          const theta = uturn ? Math.PI : Math.atan2(cross2, dot3);
           const r = (r0 + r1) / 2;
           const kind = run[i + 1].corner || seam && poly.corner[0] ? join : "round";
           if (r > 1e-9) {
@@ -700,10 +1512,10 @@ function variableStrokeRings(path, options) {
         if (closed && out.length > 1 && dist(out[0], out[out.length - 1]) <= 1e-12) out.pop();
         return out;
       };
-      const left = side(1);
+      const left2 = side(1);
       const right = side(-1);
       if (closed) {
-        rings.push(left, right.reverse());
+        rings.push(left2, right.reverse());
         continue;
       }
       const capPoints = (atStart) => {
@@ -725,7 +1537,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 [...left, ...capPoints(false), ...right.reverse(), ...capPoints(true)]) push(ring, q);
+      for (const q of [...left2, ...capPoints(false), ...right.reverse(), ...capPoints(true)]) push(ring, q);
       if (ring.length > 2) rings.push(ring);
     }
   }
@@ -788,7 +1600,7 @@ function evalSeg(seg, t) {
 }
 function strokePositionPoint(path, index, t) {
   const c = _chunkVNYRI265cjs.pathToContours.call(void 0, path)[index];
-  if (!_optionalChain([c, 'optionalAccess', _22 => _22.segments, 'access', _23 => _23.length])) return null;
+  if (!_optionalChain([c, 'optionalAccess', _32 => _32.segments, 'access', _33 => _33.length])) return null;
   const lengths = c.segments.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
   const total = lengths.reduce((a, b) => a + b, 0);
   let want = Math.min(Math.max(t, 0), 1) * total;
@@ -824,7 +1636,7 @@ function effectiveStrokeAlign(style, closedShape) {
   return closedShape ? a : "center";
 }
 function strokeWidthProfileOf(style) {
-  if (!_optionalChain([style, 'access', _24 => _24.strokeWidthProfile, 'optionalAccess', _25 => _25.length])) return null;
+  if (!_optionalChain([style, 'access', _34 => _34.strokeWidthProfile, 'optionalAccess', _35 => _35.length])) return null;
   const p = sanitizeWidthProfile(style.strokeWidthProfile);
   return isUniformWidthProfile(p) ? null : p;
 }
@@ -833,7 +1645,7 @@ function hasStrokeExtras(style) {
 }
 function vectorStrokeLineArea(parts, style, tolerance) {
   const profile = strokeWidthProfileOf(style);
-  const dash = _optionalChain([style, 'access', _26 => _26.strokeDasharray, 'optionalAccess', _27 => _27.length]) ? { dash: style.strokeDasharray } : {};
+  const dash = _optionalChain([style, 'access', _36 => _36.strokeDasharray, 'optionalAccess', _37 => _37.length]) ? { dash: style.strokeDasharray } : {};
   const join = _nullishCoalesce(style.strokeLinejoin, () => ( "miter"));
   const cap = _nullishCoalesce(style.strokeLinecap, () => ( "butt"));
   if (profile) return variableStrokeOutline(parts.line, { width: parts.drawWidth, profile, join, cap, ...dash, ...tolerance ? { tolerance } : {} });
@@ -841,8 +1653,8 @@ function vectorStrokeLineArea(parts, style, tolerance) {
 }
 var capExtent = (style, width) => style.strokeLinecap === "round" || style.strokeLinecap === "square" ? width / 2 : 0;
 function arrowheadWeight(style, end) {
-  const scale = end === "start" ? style.startArrowScale : style.endArrowScale;
-  const s = typeof scale === "number" && scale > 0 && Number.isFinite(scale) ? scale : 1;
+  const scale3 = end === "start" ? style.startArrowScale : style.endArrowScale;
+  const s = typeof scale3 === "number" && scale3 > 0 && Number.isFinite(scale3) ? scale3 : 1;
   const width = _nullishCoalesce(style.strokeWidth, () => ( 1));
   const profile = strokeWidthProfileOf(style);
   const at2 = profile ? widthProfileAt(profile, end === "start" ? 0 : 1) : null;
@@ -1082,7 +1894,7 @@ function tangentAt(s, t) {
   const d = _chunkVNYRI265cjs.segmentDerivative.call(void 0, s, t);
   return _nullishCoalesce(unit2(d[0], d[1]), () => ( startTangent(s)));
 }
-var perp = (v2) => [-v2[1], v2[0]];
+var perp2 = (v2) => [-v2[1], v2[0]];
 function effectPathLength(path) {
   let total = 0;
   for (const s of subsOf(path)) for (const seg of s.segs) total += _chunkVNYRI265cjs.segmentLength.call(void 0, seg);
@@ -1107,8 +1919,8 @@ var Measured = class {
   append(sa, sb, out) {
     for (const piece of _chunkVNYRI265cjs.trimSegments.call(void 0, this.segs, sa, sb, this.lens)) {
       if (degenerate(piece)) continue;
-      const last = _optionalChain([out, 'access', _28 => _28[out.length - 1], 'optionalAccess', _29 => _29.segs]);
-      const end = _optionalChain([last, 'optionalAccess', _30 => _30[last.length - 1], 'optionalAccess', _31 => _31.at, 'call', _32 => _32(-1)]);
+      const last = _optionalChain([out, 'access', _38 => _38[out.length - 1], 'optionalAccess', _39 => _39.segs]);
+      const end = _optionalChain([last, 'optionalAccess', _40 => _40[last.length - 1], 'optionalAccess', _41 => _41.at, 'call', _42 => _42(-1)]);
       if (!end || Math.hypot(end[0] - piece[0][0], end[1] - piece[0][1]) > 1e-6) out.push({ segs: [piece], closed: false });
       else last.push(piece);
     }
@@ -1252,9 +2064,9 @@ function twistPaths(paths, angle, center) {
   };
   return paths.map((p) => {
     const out = [];
-    for (const sub3 of subsOf(p)) {
+    for (const sub5 of subsOf(p)) {
       const segs = [];
-      for (const seg of sub3.segs) {
+      for (const seg of sub5.segs) {
         const cubic = seg.length === 2 ? [seg[0], seg[0], seg[1], seg[1]] : seg;
         const len2 = _chunkVNYRI265cjs.segmentLength.call(void 0, seg);
         const m = Math.min(64, Math.max(1, Math.ceil(Math.abs(a) * len2 / rmax / 0.15 + len2 / 50)));
@@ -1267,13 +2079,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: sub3.closed });
+      out.push({ segs, closed: sub5.closed });
     }
     return subsToPath(out);
   });
 }
-function resample(sub3, m) {
-  const segs = sub3.segs;
+function resample(sub5, m) {
+  const segs = sub5.segs;
   const n = segs.length;
   const lens = segs.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
   const out = [];
@@ -1282,7 +2094,7 @@ function resample(sub3, m) {
     for (let k = 0; k < m; k++) {
       if (k === 0) {
         const tout = startTangent(segs[j]);
-        const prev = sub3.closed || j > 0 ? (j + n - 1) % n : null;
+        const prev = sub5.closed || j > 0 ? (j + n - 1) % n : null;
         let tan = tout;
         if (prev !== null) {
           const tin = endTangent(segs[prev]);
@@ -1295,7 +2107,7 @@ function resample(sub3, m) {
       }
     }
   }
-  if (!sub3.closed) {
+  if (!sub5.closed) {
     const last = segs[n - 1];
     out.push({ p: last[last.length - 1], tan: endTangent(last), lenPrev: lens[n - 1] / m, lenNext: 0 });
   }
@@ -1323,14 +2135,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 sub3 of subsOf(p)) {
-      const s = resample(sub3, m);
+    for (const sub5 of subsOf(p)) {
+      const s = resample(sub5, m);
       const disp = s.map((x, i) => {
-        const n = perp(x.tan);
+        const n = perp2(x.tan);
         const d = i % 2 === 0 ? size : -size;
         return [n[0] * d, n[1] * d];
       });
-      const e = emit(s, disp, sub3.closed, smooth, 0.36);
+      const e = emit(s, disp, sub5.closed, smooth, 0.36);
       if (e) out.push(e);
     }
     return subsToPath(out);
@@ -1369,8 +2181,8 @@ function wigglePaths(paths, w) {
   let idx = 0;
   return paths.map((p) => {
     const out = [];
-    for (const sub3 of subsOf(p)) {
-      const s = resample(sub3, m);
+    for (const sub5 of subsOf(p)) {
+      const s = resample(sub5, m);
       const disp = s.map(() => {
         const i = BigInt(idx);
         const ox = noise(seed, i * 2n, t + idx * 0.37);
@@ -1378,7 +2190,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, sub3.closed, w.smooth, 1 / 3);
+      const e = emit(s, disp, sub5.closed, w.smooth, 1 / 3);
       if (e) out.push(e);
     }
     return subsToPath(out);
@@ -1402,9 +2214,9 @@ function vectorRepeaterCopies(r, pivot) {
   for (let i = 0; i < n; i++) {
     const k = i + offset;
     let m = translateMatrix(-pivot.x, -pivot.y);
-    m = multiplyMatrices(m, scaleMatrix(Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _33 => _33.scale, 'optionalAccess', _34 => _34.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _35 => _35.scale, 'optionalAccess', _36 => _36.y]), () => ( 100))) / 100, k)));
+    m = multiplyMatrices(m, scaleMatrix(Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _43 => _43.scale, 'optionalAccess', _44 => _44.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _45 => _45.scale, 'optionalAccess', _46 => _46.y]), () => ( 100))) / 100, k)));
     m = multiplyMatrices(m, rotateMatrix((_nullishCoalesce(r.rotation, () => ( 0))) * k));
-    m = multiplyMatrices(m, translateMatrix(pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _37 => _37.position, 'optionalAccess', _38 => _38.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _39 => _39.position, 'optionalAccess', _40 => _40.y]), () => ( 0))) * k));
+    m = multiplyMatrices(m, translateMatrix(pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _47 => _47.position, 'optionalAccess', _48 => _48.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _49 => _49.position, 'optionalAccess', _50 => _50.y]), () => ( 0))) * k));
     const t = n > 1 ? i / (n - 1) : 0;
     const partial = i + 1 === n && fract > 0 ? fract : 1;
     out.push({ index: i, matrix: m, opacity: Math.min(1, Math.max(0, (so + (eo - so) * t) * partial)) });
@@ -1544,7 +2356,7 @@ function normalizeVectorEffectParams(type, params, base) {
   if (!defaults) return null;
   const out = { ...defaults, ..._nullishCoalesce(base, () => ( {})) };
   for (const spec of VECTOR_EFFECT_PARAM_SPECS[type]) {
-    const v2 = _optionalChain([params, 'optionalAccess', _41 => _41[spec.key]]);
+    const v2 = _optionalChain([params, 'optionalAccess', _51 => _51[spec.key]]);
     if (v2 === void 0) continue;
     if (spec.kind === "number" && typeof v2 === "number" && Number.isFinite(v2)) out[spec.key] = Math.min(_nullishCoalesce(spec.max, () => ( Infinity)), Math.max(_nullishCoalesce(spec.min, () => ( -Infinity)), v2));
     else if (spec.kind === "boolean" && typeof v2 === "boolean") out[spec.key] = v2;
@@ -1559,10 +2371,10 @@ function createVectorEffect(type, id, params) {
 }
 var isEnabled = (e) => e.enabled !== false && !!VECTOR_EFFECT_DEFAULTS[e.type];
 function activeVectorEffects(node) {
-  return _nullishCoalesce(_optionalChain([node, 'access', _42 => _42.effects, 'optionalAccess', _43 => _43.filter, 'call', _44 => _44(isEnabled)]), () => ( []));
+  return _nullishCoalesce(_optionalChain([node, 'access', _52 => _52.effects, 'optionalAccess', _53 => _53.filter, 'call', _54 => _54(isEnabled)]), () => ( []));
 }
 function hasOwnVectorAppearance(node) {
-  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _45 => _45.effects, 'optionalAccess', _46 => _46.some, 'call', _47 => _47(isEnabled)]);
+  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _55 => _55.effects, 'optionalAccess', _56 => _56.some, 'call', _57 => _57(isEnabled)]);
 }
 var liveCache = /* @__PURE__ */ new WeakMap();
 function hasVectorAppearance(node) {
@@ -1574,7 +2386,7 @@ function hasVectorAppearance(node) {
   return v2;
 }
 function isVectorLiveBoolean(node) {
-  return _optionalChain([node, 'optionalAccess', _48 => _48.type]) === "group" && !!node.liveBoolean;
+  return _optionalChain([node, 'optionalAccess', _58 => _58.type]) === "group" && !!node.liveBoolean;
 }
 function vectorOperandOperation(group, child) {
   return _nullishCoalesce(_nullishCoalesce(child.booleanOperation, () => ( group.liveBoolean)), () => ( "union"));
@@ -1691,7 +2503,7 @@ var compareOrder = (a, b) => {
   for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
   return a.length - b.length;
 };
-var add2 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _49 => _49.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _50 => _50.y]), () => ( 0))) });
+var add3 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _59 => _59.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _60 => _60.y]), () => ( 0))) });
 var mapPaths = (shapes, fn) => {
   const out = fn(shapes.map((s) => s.path));
   return shapes.map((s, i) => ({ ...s, path: _nullishCoalesce(out[i], () => ( [])) }));
@@ -1713,7 +2525,7 @@ function applyVectorEffects(shapes, effects) {
         list = mapPaths(list, (p) => puckerBloatPaths(p, e.params.amount));
         break;
       case "twist":
-        list = mapPaths(list, (p) => twistPaths(p, e.params.angle, add2(pathsCenter(p), e.params.center)));
+        list = mapPaths(list, (p) => twistPaths(p, e.params.angle, add3(pathsCenter(p), e.params.center)));
         break;
       case "zigzag":
         list = mapPaths(list, (p) => zigzagPaths(p, e.params.size, e.params.ridges, e.params.smooth));
@@ -1736,7 +2548,7 @@ function applyVectorEffects(shapes, effects) {
         const copies = repeatPaths(
           list.map((s) => s.path),
           r,
-          add2(pathsCenter(list.map((s) => s.path)), r.anchor)
+          add3(pathsCenter(list.map((s) => s.path)), r.anchor)
         );
         const n = copies.length;
         const next = [];
@@ -1982,8 +2794,8 @@ function inferAnchorType(a) {
   const li = Math.hypot(ix, iy);
   const lo = Math.hypot(ox, oy);
   const cross2 = (ix * oy - iy * ox) / (li * lo);
-  const dot2 = (ix * ox + iy * oy) / (li * lo);
-  if (Math.abs(cross2) > 1e-3 || dot2 > 0) return "corner";
+  const dot3 = (ix * ox + iy * oy) / (li * lo);
+  if (Math.abs(cross2) > 1e-3 || dot3 > 0) return "corner";
   return Math.abs(li - lo) <= 1e-3 * Math.max(li, lo) ? "symmetric" : "smooth";
 }
 function bezierToSubpaths(input) {
@@ -2119,7 +2931,7 @@ function boundsFromPoints(a, b) {
 }
 function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX, options = {}) {
   if (node.visible === false) return false;
-  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _51 => _51.entered, 'optionalAccess', _52 => _52.has, 'call', _53 => _53(node.id)])))) node = expandVectorAppearance(node);
+  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _61 => _61.entered, 'optionalAccess', _62 => _62.has, 'call', _63 => _63(node.id)])))) node = expandVectorAppearance(node);
   if (node.type === "group") {
     const m = multiplyMatrices(nodeMatrix(node), parent);
     return node.children.some((c) => hitTestVectorNode(c, p, tolerance, m, options));
@@ -2218,20 +3030,23 @@ function mapAnchor(a, m) {
 }
 function bakeIntoGeometry(node, m) {
   if (isIdentityMatrix(m)) return node;
-  if (_optionalChain([node, 'access', _54 => _54.effects, 'optionalAccess', _55 => _55.length])) node = { ...node, effects: transformVectorEffects(node.effects, m) };
+  if (_optionalChain([node, 'access', _64 => _64.effects, 'optionalAccess', _65 => _65.length])) node = { ...node, effects: transformVectorEffects(node.effects, m) };
   if (node.type === "group") {
     const group = node;
     const children = group.children.map((c) => transformVectorNode(c, m));
-    const spine = _optionalChain([group, 'access', _56 => _56.blend, 'optionalAccess', _57 => _57.spine]);
+    const spine = _optionalChain([group, 'access', _66 => _66.blend, 'optionalAccess', _67 => _67.spine]);
     if (!spine) return { ...group, children };
     const moved = { closed: spine.closed, anchors: spine.anchors.map((a) => mapAnchor(a, m)) };
     return { ...group, children, blend: { ...group.blend, spine: moved } };
   }
   const path = node;
-  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _58 => _58.strokeWidthProfile, 'optionalAccess', _59 => _59.length]);
+  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _68 => _68.strokeWidthProfile, 'optionalAccess', _69 => _69.length]);
   return {
     ...path,
     ...mirrored ? { strokeWidthProfile: mirrorWidthProfile(path.strokeWidthProfile) } : {},
+    // Gradients in the node's own space move with its geometry.
+    ...isVectorGradient(path.fill) ? { fill: transformVectorPaint(path.fill, m) } : {},
+    ...isVectorGradient(path.stroke) ? { stroke: transformVectorPaint(path.stroke, m) } : {},
     subpaths: path.subpaths.map((sp) => ({
       closed: sp.closed,
       anchors: sp.anchors.map((a) => mapAnchor(a, m))
@@ -2334,12 +3149,12 @@ function insertAnchor(sp, segment, t) {
   const ia = segment;
   const ib = (segment + 1) % n;
   const seg = subpathSegment(sp, segment);
-  const [left, right] = _chunkVNYRI265cjs.splitSegment.call(void 0, seg, t);
-  const mid = left[left.length - 1];
+  const [left2, right] = _chunkVNYRI265cjs.splitSegment.call(void 0, seg, t);
+  const mid = left2[left2.length - 1];
   const anchor = { x: mid[0], y: mid[1] };
   if (seg.length === 4) {
-    anchors[ia].out = { x: left[1][0], y: left[1][1] };
-    anchor.in = { x: left[2][0], y: left[2][1] };
+    anchors[ia].out = { x: left2[1][0], y: left2[1][1] };
+    anchor.in = { x: left2[2][0], y: left2[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] };
@@ -2424,6 +3239,166 @@ function roundSubpaths(subpaths, precision = 3) {
   }));
 }
 
+// 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 _chunkVNYRI265cjs.pathToContours.call(void 0, subpathsToBezier(node.subpaths))) {
+    const segs = _chunkVNYRI265cjs.closeContour.call(void 0, contour);
+    if (!segs.length) continue;
+    const ring = _chunkVNYRI265cjs.flattenChain.call(void 0, 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 = _nullishCoalesce(options.precision, () => ( 3));
+  const mode = g.strokeMode === "across" ? "across" : "along";
+  const expanded = expandVectorGradientStops(g);
+  const reach = vectorStrokeReach(node) + 1;
+  const area = _nullishCoalesce(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 = _nullishCoalesce(node.strokeWidth, () => ( 1));
+  const align = _nullishCoalesce(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(_nullishCoalesce(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 = [];
@@ -2439,7 +3414,7 @@ function applyVectorCornersAttribute(subpaths, value) {
   for (const item of value.trim().split(/\s+/)) {
     const m = /^(\d+)\.(\d+):([\d.eE+-]+)(?::([a-z]+))?$/.exec(item);
     if (!m) continue;
-    const a = _optionalChain([subpaths, 'access', _60 => _60[+m[1]], 'optionalAccess', _61 => _61.anchors, 'access', _62 => _62[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _70 => _70[+m[1]], 'optionalAccess', _71 => _71.anchors, 'access', _72 => _72[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -2448,10 +3423,30 @@ function applyVectorCornersAttribute(subpaths, value) {
   return subpaths;
 }
 var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-function vectorPaintToSvg(paint, gradientId) {
-  if (!hasPaint(paint)) return { value: "none", gradient: null };
-  if (typeof paint === "string") return { value: paint, gradient: null };
-  return { value: `url(#${gradientId})`, gradient: _chunkVNYRI265cjs.gradientToSvgDef.call(void 0, paint, gradientId) };
+function vectorPathLocalBounds(node) {
+  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, 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 = _nullishCoalesce(options.role, () => ( "fill"));
+  const precision = _nullishCoalesce(options.precision, () => ( 3));
+  const key = `${gradientId}|${role}|${precision}`;
+  const owner = _nullishCoalesce(options.node, () => ( paint));
+  const cached = _optionalChain([paintCache, 'access', _73 => _73.get, 'call', _74 => _74(owner), 'optionalAccess', _75 => _75.get, 'call', _76 => _76(key)]);
+  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) {
@@ -2490,18 +3485,26 @@ function widthProfileFromAttribute(value) {
   if (!value) return [];
   return sanitizeWidthProfile(
     value.split(";").map((part) => {
-      const [t, left, right] = part.split(",").map((n) => parseFloat(n));
-      return { t, left, right: Number.isFinite(right) ? right : left };
+      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) {
+function gradientMarkup(def, extra = "") {
   const tag = def.type === "radial" ? "radialGradient" : "linearGradient";
   const attrs = Object.entries(def.attrs).map(([k, v2]) => ` ${k}="${escapeAttr(String(v2))}"`).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}>${stops}</${tag}>`;
+  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, v2]) => ` ${k}="${escapeAttr(String(v2))}"`).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;
@@ -2535,12 +3538,12 @@ function vectorDocumentToSvg(doc, options = {}) {
   const pretty = options.pretty !== false;
   const defs = [];
   const lines = [];
-  const num = (n) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, precision);
+  const num2 = (n) => _chunkVNYRI265cjs.formatNumber.call(void 0, 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) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
-    if (node.opacity !== void 0 && node.opacity < 1) out2 += ` opacity="${num(node.opacity)}"`;
+    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="${escapeAttr(JSON.stringify(node.blend))}"`;
@@ -2552,7 +3555,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (hasOwnVectorAppearance(node)) {
       const live2 = {
         kind: node.type,
-        ..._optionalChain([node, 'access', _63 => _63.effects, 'optionalAccess', _64 => _64.length]) ? { effects: node.effects } : {},
+        ..._optionalChain([node, 'access', _77 => _77.effects, 'optionalAccess', _78 => _78.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))}">`);
@@ -2574,19 +3577,18 @@ function vectorDocumentToSvg(doc, options = {}) {
       lines.push(`${indent(depth)}</g>`);
       return;
     }
-    const fill = vectorPaintToSvg(node.fill, `${prefix}fill-${node.id}`);
-    const stroke = vectorPaintToSvg(node.stroke, `${prefix}stroke-${node.id}`);
-    if (fill.gradient) defs.push(gradientMarkup(fill.gradient));
-    if (stroke.gradient) defs.push(gradientMarkup(stroke.gradient));
+    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 corners2 = vectorCornersAttribute(node.subpaths, precision);
     const live = corners2 ? ` data-vector-d="${_chunkVNYRI265cjs.bezierPathToSvg.call(void 0, subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners2}"` : "";
     const fillAttrs = ` fill="${escapeAttr(fill.value)}"${node.fillRule === "evenodd" ? ` fill-rule="evenodd"` : ""}`;
     const lineAttrs = (width) => {
-      let out2 = ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num(width)}"`;
+      let out2 = ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num2(width)}"`;
       if (node.strokeLinecap && node.strokeLinecap !== "butt") out2 += ` stroke-linecap="${node.strokeLinecap}"`;
       if (node.strokeLinejoin && node.strokeLinejoin !== "miter") out2 += ` stroke-linejoin="${node.strokeLinejoin}"`;
-      if (_optionalChain([node, 'access', _65 => _65.strokeDasharray, 'optionalAccess', _66 => _66.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      if (_optionalChain([node, 'access', _79 => _79.strokeDasharray, 'optionalAccess', _80 => _80.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
       return out2;
     };
     const parts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${prefix}clip-${node.id}`, precision) : void 0;
@@ -2594,19 +3596,19 @@ function vectorDocumentToSvg(doc, options = {}) {
       lines.push(`${indent(depth)}<path${common(node)} d="${d}"${fillAttrs}${stroke.value !== "none" ? lineAttrs(_nullishCoalesce(node.strokeWidth, () => ( 1))) : ""}${live}/>`);
       return;
     }
-    let data = ` data-vector-path="" data-vector-stroke-width="${num(_nullishCoalesce(node.strokeWidth, () => ( 1)))}"`;
+    let data = ` data-vector-path="" data-vector-stroke-width="${num2(_nullishCoalesce(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)}"`;
+    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 (_optionalChain([node, 'access', _67 => _67.strokeDasharray, 'optionalAccess', _68 => _68.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      if (_optionalChain([node, 'access', _81 => _81.strokeDasharray, 'optionalAccess', _82 => _82.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}/>`);
@@ -2623,7 +3625,7 @@ function vectorDocumentToSvg(doc, options = {}) {
           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)}"`;
+          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})"`;
         }
@@ -2635,8 +3637,8 @@ function vectorDocumentToSvg(doc, options = {}) {
     lines.push(`${indent(depth)}</g>`);
   };
   for (const node of doc.nodes) emit2(node, 1);
-  const w = num(doc.width);
-  const h = num(doc.height);
+  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>`);
@@ -2766,28 +3768,89 @@ var fraction = (s, fallback) => {
   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 ((el.name === "linearGradient" || el.name === "radialGradient") && el.attrs.id) raw.set(el.attrs.id, el);
+  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 resolveGradient(id, raw, seen = /* @__PURE__ */ new Set()) {
-  const el = raw.get(id);
-  if (!el || seen.has(id)) return null;
-  seen.add(id);
-  let stops = readStops(el);
-  const href = _nullishCoalesce(el.attrs.href, () => ( el.attrs["xlink:href"]));
-  if (!stops.length && _optionalChain([href, 'optionalAccess', _69 => _69.startsWith, 'call', _70 => _70("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _71 => _71(href.slice(1), raw, seen), 'optionalAccess', _72 => _72.stops]), () => ( []));
-  if (!stops.length) return null;
-  if (el.name === "radialGradient") {
-    return { type: "radial", cx: fraction(el.attrs.cx, 0.5), cy: fraction(el.attrs.cy, 0.5), r: fraction(el.attrs.r, 0.5), stops };
+function gradientFromAttribute(value) {
+  if (!value) return null;
+  try {
+    return sanitizeVectorGradient(JSON.parse(value));
+  } catch (e5) {
+    return null;
   }
-  const x1 = fraction(el.attrs.x1, 0);
-  const y1 = fraction(el.attrs.y1, 0);
-  const x2 = fraction(el.attrs.x2, 1);
-  const y2 = fraction(el.attrs.y2, 0);
-  const angle = Math.round((Math.atan2(x2 - x1, -(y2 - y1)) * 180 / Math.PI + 360) % 360);
-  return { type: "linear", angle, stops };
 }
+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 = _nullishCoalesce(el.attrs.href, () => ( el.attrs["xlink:href"]));
+    el = _optionalChain([href, 'optionalAccess', _83 => _83.startsWith, 'call', _84 => _84("#")]) ? raw.get(href.slice(1)) : void 0;
+  }
+  const attr = (name) => _optionalChain([chain, 'access', _85 => _85.find, 'call', _86 => _86((el) => el.attrs[name] !== void 0), 'optionalAccess', _87 => _87.attrs, 'access', _88 => _88[name]]);
+  const stops = _nullishCoalesce(chain.map(readStops).find((s) => s.length), () => ( []));
+  if (!stops.length) return null;
+  const user = attr("gradientUnits") === "userSpaceOnUse";
+  const t = parseSvgTransform(attr("gradientTransform"));
+  const plain3 = 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 && plain3 && !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 && plain3) {
+    const angle = Math.round((Math.atan2(x2 - x1, -(y2 - y1)) * 180 / Math.PI + 360) % 360);
+    const c = _chunkVNYRI265cjs.angleToSvgLinearCoords.call(void 0, 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 same = len2 > 0 && Math.abs((c.x2 - c.x1) * d.y - (c.y2 - c.y1) * d.x) < 1e-3 && Math.abs(along2(c.x1, c.y1) - along2(x1, y1)) < 1e-3 && Math.abs(along2(c.x2, c.y2) - along2(x2, y2)) < 1e-3;
+    if (same) return { type: "linear", angle, stops, ...spread };
+  }
+  const 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.");
@@ -2880,7 +3943,7 @@ function parseVectorSvg(svg, options = {}) {
     const part = (name) => g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === name);
     const fillEl = part("fill");
     const subpaths = fillEl ? shapeOf(fillEl) : null;
-    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _73 => _73.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _89 => _89.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style);
     const strokeEl = part("stroke");
@@ -2888,7 +3951,7 @@ function parseVectorSvg(svg, options = {}) {
     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 scale = (v2) => {
+    const scale3 = (v2) => {
       const n = v2 === void 0 ? NaN : parseFloat(v2);
       return n > 0 ? n : void 0;
     };
@@ -2912,12 +3975,12 @@ function parseVectorSvg(svg, options = {}) {
       ...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" } : {},
-      ...scale(a["data-vector-start-arrow-scale"]) ? { startArrowScale: scale(a["data-vector-start-arrow-scale"]) } : {},
-      ...scale(a["data-vector-end-arrow-scale"]) ? { endArrowScale: scale(a["data-vector-end-arrow-scale"]) } : {},
+      ...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 } : {},
-      ..._optionalChain([keptDash, 'optionalAccess', _74 => _74.length]) ? { strokeDasharray: keptDash } : {}
+      ..._optionalChain([keptDash, 'optionalAccess', _90 => _90.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
@@ -2925,7 +3988,7 @@ function parseVectorSvg(svg, options = {}) {
     let raw = {};
     try {
       raw = _nullishCoalesce(JSON.parse(g.attrs["data-vector-live"]), () => ( {}));
-    } catch (e5) {
+    } catch (e6) {
       raw = {};
     }
     const sourceEl = g.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === "source");
@@ -3006,6 +4069,72 @@ function parseVectorSvg(svg, options = {}) {
   return { width, height, nodes };
 }
 
+// src/vector/gradientTool.ts
+var VECTOR_GRADIENT_STOP_GAP = 12;
+var VECTOR_GRADIENT_MIDPOINT_GAP = 9;
+var VECTOR_GRADIENT_OFF_BAR = 24;
+var STOP_HIT = 6;
+var MIDPOINT_HIT = 5;
+var HANDLE_HIT = 6;
+var BAR_HIT = 5;
+var fmt3 = (n) => Math.round(n * 100) / 100;
+var apply2 = (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 vectorGradientTargetPath(doc, selection, target) {
+  for (const id of selection) {
+    const node = findVectorNode(doc.nodes, id);
+    if (!node) continue;
+    const path = collectPathNodes(node).find((p) => isVectorGradient(p[target]));
+    if (path) return path;
+  }
+  return null;
+}
+function getVectorGradientAnnotator(doc, selection, viewport, target) {
+  const path = vectorGradientTargetPath(doc, selection, target);
+  if (!path) return null;
+  const gradient = path[target];
+  const world = _nullishCoalesce(vectorWorldMatrix(doc.nodes, path.id), () => ( IDENTITY_MATRIX));
+  const screen = multiplyMatrices(world, [viewport.zoom, 0, 0, viewport.zoom, viewport.x, viewport.y]);
+  const bounds = vectorPathLocalBounds(path);
+  const h = vectorGradientHandles(gradient, bounds, screen);
+  const v2 = { x: h.end.x - h.start.x, y: h.end.y - h.start.y };
+  const len2 = Math.hypot(v2.x, v2.y);
+  const normal = len2 > 1e-9 ? { x: -v2.y / len2, y: v2.x / len2 } : { x: 0, y: 1 };
+  const at2 = (t, gap) => ({ x: h.start.x + v2.x * t + normal.x * gap, y: h.start.y + v2.y * t + normal.y * gap });
+  const sorted = sortedVectorGradientStops(gradient);
+  const stops = sorted.map((s, index) => ({ ...s, index, ...at2(s.offset, VECTOR_GRADIENT_STOP_GAP) }));
+  const midpoints = sorted.slice(0, -1).flatMap((s, index) => {
+    const pos = vectorGradientMidpointPosition(sorted, index);
+    return pos === null || sorted[index + 1].offset - s.offset < 1e-6 ? [] : [{ index, midpoint: _nullishCoalesce(s.midpoint, () => ( 0.5)), ...at2(pos, -VECTOR_GRADIENT_MIDPOINT_GAP) }];
+  });
+  let extent = null;
+  if (isCentredVectorGradient(gradient.type)) {
+    const frame2 = multiplyMatrices(vectorGradientMatrix(gradient, bounds), screen);
+    const pts = gradient.type === "diamond" ? [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: -1, y: 0 }, { x: 0, y: -1 }] : Array.from({ length: 48 }, (_, k) => ({ x: Math.cos(k * Math.PI / 24), y: Math.sin(k * Math.PI / 24) }));
+    extent = `M${pts.map((p) => apply2(frame2, p)).map((p) => `${fmt3(p.x)} ${fmt3(p.y)}`).join("L")}Z`;
+  }
+  return { nodeId: path.id, target, gradient, bounds, world, start: h.start, end: h.end, aspect: h.aspect, focal: h.focal, normal, stops, midpoints, extent };
+}
+function vectorGradientBarPosition(a, p) {
+  const v2 = { x: a.end.x - a.start.x, y: a.end.y - a.start.y };
+  const l2 = v2.x * v2.x + v2.y * v2.y;
+  const d = { x: p.x - a.start.x, y: p.y - a.start.y };
+  if (l2 < 1e-12) return { offset: 0, across: Math.hypot(d.x, d.y) };
+  return { offset: (d.x * v2.x + d.y * v2.y) / l2, across: d.x * a.normal.x + d.y * a.normal.y };
+}
+function hitVectorGradientAnnotator(a, p) {
+  const near2 = (q, r) => !!q && Math.hypot(q.x - p.x, q.y - p.y) <= r;
+  for (let i = a.stops.length - 1; i >= 0; i--) if (near2(a.stops[i], STOP_HIT)) return { kind: "stop", index: a.stops[i].index };
+  for (const m of a.midpoints) if (near2(m, MIDPOINT_HIT)) return { kind: "midpoint", index: m.index };
+  const centred = isCentredVectorGradient(a.gradient.type);
+  if (near2(a.end, HANDLE_HIT)) return { kind: "handle", handle: centred ? "radius" : "end" };
+  if (a.focal && near2(a.focal, HANDLE_HIT) && !near2(a.start, 1)) return { kind: "handle", handle: "focal" };
+  if (near2(a.start, HANDLE_HIT)) return { kind: "handle", handle: "start" };
+  if (near2(a.aspect, HANDLE_HIT)) return { kind: "handle", handle: "aspect" };
+  const { offset, across } = vectorGradientBarPosition(a, p);
+  if (offset >= 0 && offset <= 1 && across >= -BAR_HIT && across <= VECTOR_GRADIENT_STOP_GAP + STOP_HIT) return { kind: "bar", offset };
+  return null;
+}
+
 // 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];
@@ -3097,10 +4226,10 @@ function refineMorphContour(c, segments) {
   const extra = segments - have;
   const want = lens.map((l) => sum > 1e-12 ? l / sum * extra : extra / have);
   const parts = want.map((w) => 1 + Math.floor(w));
-  let left = segments - parts.reduce((a, b) => a + b, 0);
+  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; left > 0; i = (i + 1) % order.length, left--) parts[order[i]]++;
+  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;
@@ -3209,19 +4338,19 @@ function bestStart(fixed, free, useShapeContext) {
   const gsc = useShapeContext ? shapeContexts(ga, free.closed) : null;
   const m = Math.max(1, fn.length);
   const cost = (s) => {
-    let dot2 = 0;
+    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];
-      dot2 += p[0] * q[0] + p[1] * q[1];
+      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 - (dot2 * dot2 + cross2 * cross2) / (m * m));
-    const turn = 1 - Math.cos(Math.atan2(cross2, dot2));
+    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) };
@@ -3366,16 +4495,16 @@ function procrustes(a, b) {
   const ca = frame(pa).c;
   const cb = frame(pb).c;
   let ss = 0;
-  let dot2 = 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];
-    dot2 += p[0] * q[0] + p[1] * q[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, dot2), s: ss > 1e-12 ? Math.hypot(dot2, cross2) / ss : 1 };
+  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, _nullishCoalesce(options.rigidity, () => ( 1))));
@@ -3429,39 +4558,24 @@ function interpolateVectorColor(a, b, t) {
   if (t >= 1) return b;
   return _nullishCoalesce(_chunkMR3Z4OQIcjs.mixColorsOklab.call(void 0, a, b, t), () => ( (t < 0.5 ? a : b)));
 }
-function sortedStops(g) {
-  return g.stops.slice().sort((x, y) => x.offset - y.offset);
-}
-function sampleGradient(stops, offset) {
-  if (!stops.length) return { color: "transparent", opacity: 1 };
-  const first = stops[0];
-  const last = stops[stops.length - 1];
-  if (offset <= first.offset) return { color: first.color, opacity: _nullishCoalesce(first.opacity, () => ( 1)) };
-  if (offset >= last.offset) return { color: last.color, opacity: _nullishCoalesce(last.opacity, () => ( 1)) };
-  let i = 0;
-  while (i + 1 < stops.length && stops[i + 1].offset < offset) i++;
-  const x = stops[i];
-  const y = stops[i + 1];
-  const u = y.offset - x.offset > 1e-12 ? (offset - x.offset) / (y.offset - x.offset) : 1;
-  return { color: interpolateVectorColor(x.color, y.color, u), opacity: lerpN(_nullishCoalesce(x.opacity, () => ( 1)), _nullishCoalesce(y.opacity, () => ( 1)), u) };
-}
 function resampleGradientStops(g, offsets) {
-  const stops = sortedStops(g);
   return offsets.map((offset) => {
-    const s = sampleGradient(stops, offset);
-    return s.opacity < 1 ? { offset, color: s.color, opacity: s.opacity } : { offset, color: s.color };
+    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;
 }
-function lerpGradient(a, b, t) {
-  if (a.type !== b.type) return null;
-  let stopsA = sortedStops(a);
-  let stopsB = sortedStops(b);
-  if (stopsA.length !== stopsB.length) {
-    const offs = [...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+var lerpPoint = (a, b, t) => ({ x: lerpN(a.x, b.x, t), y: lerpN(a.y, b.y, t) });
+var sameColourModel = (a, b) => (_nullishCoalesce(a.interpolation, () => ( "srgb"))) === (_nullishCoalesce(b.interpolation, () => ( "srgb"))) && (_nullishCoalesce(a.smoothness, () => ( 0))) === (_nullishCoalesce(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);
@@ -3471,12 +4585,53 @@ function lerpGradient(a, b, t) {
     const opacity = lerpN(_nullishCoalesce(x.opacity, () => ( 1)), _nullishCoalesce(y.opacity, () => ( 1)), t);
     const stop = { offset: lerpN(x.offset, y.offset, t), color: interpolateVectorColor(x.color, y.color, t) };
     if (opacity < 1) stop.opacity = opacity;
+    const mid = lerpN(_nullishCoalesce(x.midpoint, () => ( 0.5)), _nullishCoalesce(y.midpoint, () => ( 0.5)), t);
+    if (Math.abs(mid - 0.5) > 1e-6) stop.midpoint = mid;
     return stop;
   });
-  if (a.type === "linear" && b.type === "linear") return { type: "linear", angle: lerpAngle(_nullishCoalesce(a.angle, () => ( 90)), _nullishCoalesce(b.angle, () => ( 90)), t), stops };
-  const ra = a;
-  const rb = b;
-  return { type: "radial", cx: lerpN(_nullishCoalesce(ra.cx, () => ( 0.5)), _nullishCoalesce(rb.cx, () => ( 0.5)), t), cy: lerpN(_nullishCoalesce(ra.cy, () => ( 0.5)), _nullishCoalesce(rb.cy, () => ( 0.5)), t), r: lerpN(_nullishCoalesce(ra.r, () => ( 0.5)), _nullishCoalesce(rb.r, () => ( 0.5)), t), stops };
+  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(_nullishCoalesce(a.angle, () => ( fallback)), _nullishCoalesce(b.angle, () => ( fallback)), t);
+    }
+    if (a.type !== "linear" && a.type !== "reflected") {
+      out.cx = lerpN(_nullishCoalesce(a.cx, () => ( 0.5)), _nullishCoalesce(b.cx, () => ( 0.5)), t);
+      out.cy = lerpN(_nullishCoalesce(a.cy, () => ( 0.5)), _nullishCoalesce(b.cy, () => ( 0.5)), t);
+      out.r = lerpN(_nullishCoalesce(a.r, () => ( 0.5)), _nullishCoalesce(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(_nullishCoalesce(pa.focal, () => ( pa.start)), _nullishCoalesce(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 }) };
@@ -3490,15 +4645,15 @@ function interpolateVectorPaint(a, b, t) {
   if (typeof a === "string" && pa && typeof b === "string" && pb) return interpolateVectorColor(a, b, t);
   if (!pa && typeof b === "string") return interpolateVectorColor("transparent", b, t);
   if (!pb && typeof a === "string") return interpolateVectorColor(a, "transparent", t);
-  const ga = pa && typeof a === "object" && a ? a : null;
-  const gb = pb && typeof b === "object" && b ? b : null;
+  const ga = pa && isVectorGradient(a) ? a : null;
+  const gb = pb && isVectorGradient(b) ? b : null;
   if (ga && gb) return _nullishCoalesce(lerpGradient(ga, gb, t), () => ( (t < 0.5 ? a : b)));
   if (gb) return _nullishCoalesce(lerpGradient(solidLike(pa ? a : null, gb), gb, t), () => ( b));
   if (ga) return _nullishCoalesce(lerpGradient(ga, solidLike(pb ? b : null, ga), t), () => ( a));
   return t < 0.5 ? a : b;
 }
 function interpolateWidthProfiles(a, b, t) {
-  if (!_optionalChain([a, 'optionalAccess', _75 => _75.length]) && !_optionalChain([b, 'optionalAccess', _76 => _76.length])) return null;
+  if (!_optionalChain([a, 'optionalAccess', _91 => _91.length]) && !_optionalChain([b, 'optionalAccess', _92 => _92.length])) return null;
   const at2 = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at2.filter((v2, i) => i === 0 || v2 - at2[i - 1] > 1e-6);
   return ts.map((pos) => {
@@ -3508,7 +4663,7 @@ function interpolateWidthProfiles(a, b, t) {
   });
 }
 function lerpDashes(a, b, t) {
-  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _77 => _77.length]) && d.some((v2) => v2 > 0);
+  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _93 => _93.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) => {
@@ -3535,7 +4690,7 @@ function interpolateVectorStyle(a, b, t) {
   for (const key of ["startArrowScale", "endArrowScale"])
     if (a[key] !== void 0 || b[key] !== void 0) out[key] = lerpN(_nullishCoalesce(a[key], () => ( 1)), _nullishCoalesce(b[key], () => ( 1)), t);
   const dash = lerpDashes(a.strokeDasharray, b.strokeDasharray, t);
-  if (_optionalChain([dash, 'optionalAccess', _78 => _78.length])) out.strokeDasharray = dash;
+  if (_optionalChain([dash, 'optionalAccess', _94 => _94.length])) out.strokeDasharray = dash;
   const profile = interpolateWidthProfiles(a.strokeWidthProfile, b.strokeWidthProfile, t);
   if (profile) out.strokeWidthProfile = profile;
   return out;
@@ -3546,7 +4701,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _79 => _79.strokeWidthProfile, 'optionalAccess', _80 => _80.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _95 => _95.strokeWidthProfile, 'optionalAccess', _96 => _96.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -3628,15 +4783,15 @@ function createVectorMorph(a, b, options = {}) {
   for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
     const x = pa[i];
     const y = pb[i];
-    const sub3 = { ...options, id: `${id}-${i}`, starts: void 0 };
+    const sub5 = { ...options, id: `${id}-${i}`, starts: void 0 };
     if (x && y) {
-      parts.push(preparePathMorph(x.path, y.path, sub3, x.m, y.m));
+      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), sub3, x.m, IDENTITY_MATRIX));
+      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, sub3, IDENTITY_MATRIX, y.m));
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub5, IDENTITY_MATRIX, y.m));
       opacities.push([y.opacity, y.opacity]);
     }
   }
@@ -3692,11 +4847,11 @@ function vectorBlendKeys(group) {
 }
 function resolveVectorBlendOptions(options) {
   return {
-    spacing: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _81 => _81.spacing]), () => ( "steps")),
-    steps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _82 => _82.steps]), () => ( DEFAULT_VECTOR_BLEND_STEPS)),
-    distance: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _83 => _83.distance]), () => ( DEFAULT_VECTOR_BLEND_DISTANCE)),
-    orientToSpine: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _84 => _84.orientToSpine]), () => ( false)),
-    linear: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _85 => _85.linear]), () => ( false))
+    spacing: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _97 => _97.spacing]), () => ( "steps")),
+    steps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _98 => _98.steps]), () => ( DEFAULT_VECTOR_BLEND_STEPS)),
+    distance: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _99 => _99.distance]), () => ( DEFAULT_VECTOR_BLEND_DISTANCE)),
+    orientToSpine: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _100 => _100.orientToSpine]), () => ( false)),
+    linear: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _101 => _101.linear]), () => ( false))
   };
 }
 function paintColors(p) {
@@ -3784,7 +4939,7 @@ function vectorBlendRailAt(rail, s) {
 function vectorBlendSpine(group) {
   const keys = vectorBlendKeys(group);
   if (keys.length < 2) return null;
-  const stored = _optionalChain([group, 'access', _86 => _86.blend, 'optionalAccess', _87 => _87.spine]);
+  const stored = _optionalChain([group, 'access', _102 => _102.blend, 'optionalAccess', _103 => _103.spine]);
   if (stored && stored.anchors.length >= 2) {
     const rail2 = vectorBlendRail(stored);
     if (rail2) {
@@ -3805,7 +4960,7 @@ function vectorBlendKeyTargets(group) {
 }
 var morphCache = /* @__PURE__ */ new WeakMap();
 function morphFor(a, b, blend) {
-  const starts = [_nullishCoalesce(_optionalChain([blend, 'access', _88 => _88.starts, 'optionalAccess', _89 => _89[a.id]]), () => ( null)), _nullishCoalesce(_optionalChain([blend, 'access', _90 => _90.starts, 'optionalAccess', _91 => _91[b.id]]), () => ( null))];
+  const starts = [_nullishCoalesce(_optionalChain([blend, 'access', _104 => _104.starts, 'optionalAccess', _105 => _105[a.id]]), () => ( null)), _nullishCoalesce(_optionalChain([blend, 'access', _106 => _106.starts, 'optionalAccess', _107 => _107[b.id]]), () => ( null))];
   const key = JSON.stringify([!!blend.linear, starts]);
   let inner = morphCache.get(a);
   if (!inner) morphCache.set(a, inner = /* @__PURE__ */ new WeakMap());
@@ -3904,7 +5059,7 @@ function releaseVectorBlend(group, newId) {
   const m = nodeMatrix(group);
   const opacity = group.opacity;
   const keys = vectorBlendKeys(group).map((c) => group.transform ? transformVectorNode(c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c);
-  const spine = _optionalChain([group, 'access', _92 => _92.blend, 'optionalAccess', _93 => _93.spine]);
+  const spine = _optionalChain([group, 'access', _108 => _108.blend, 'optionalAccess', _109 => _109.spine]);
   if (!spine || spine.anchors.length < 2) return keys;
   const path = { id: newId(), type: "path", name: "Spine", fill: null, stroke: null, subpaths: [{ closed: spine.closed, anchors: spine.anchors.map((a) => ({ ...a })) }] };
   return [...keys, group.transform ? transformVectorNode(path, m) : path];
@@ -3913,7 +5068,7 @@ function releaseVectorBlend(group, newId) {
 // src/vector/snap.ts
 var VECTOR_CONSTRUCTION_ANGLES = [0, 45, 90, 135];
 function constrainToLeave(leave, p) {
-  if (!_optionalChain([leave, 'optionalAccess', _94 => _94.constrain])) return p;
+  if (!_optionalChain([leave, 'optionalAccess', _110 => _110.constrain])) return p;
   const dx = p.x - leave.at.x;
   const dy = p.y - leave.at.y;
   switch (leave.constrain) {
@@ -4024,7 +5179,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
       moving.set(r.nodeId, set);
     }
     const t = _VectorSnapTargets.collect(doc, new Set(moving.keys()), "segments", false);
-    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _95 => _95.get, 'call', _96 => _96(id), 'optionalAccess', _97 => _97.has, 'call', _98 => _98(`${s}:${i}`)]), true);
+    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _111 => _111.get, 'call', _112 => _112(id), 'optionalAccess', _113 => _113.has, 'call', _114 => _114(`${s}:${i}`)]), true);
     return t.index();
   }
   /**
@@ -4143,7 +5298,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
         }
         const b = vectorNodeBounds(n, parent);
         const f = nodeFrame(n, parent, b);
-        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _99 => _99.centre]), () => ( null)));
+        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _115 => _115.centre]), () => ( null)));
       }
     };
     visit(doc.nodes, IDENTITY_MATRIX);
@@ -4188,7 +5343,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
       lines: lines2,
       labels: [this.label(q, kind)]
     });
-    if (_optionalChain([leave, 'optionalAccess', _100 => _100.constrain])) {
+    if (_optionalChain([leave, 'optionalAccess', _116 => _116.constrain])) {
       const q = constrainToLeave(leave, p);
       const hit = this.slide(leave.at, { x: q.x - leave.at.x, y: q.y - leave.at.y }, q, tol, true);
       return hit ? { point: hit.point, x: true, y: true, ...this.linedUp(hit.point, hit.from) } : none(q);
@@ -4204,7 +5359,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
     }
     const on = this.onSegment(near2);
     if (on) return at2(on, "path");
-    if (_optionalChain([leave, 'optionalAccess', _101 => _101.angles, 'optionalAccess', _102 => _102.length])) {
+    if (_optionalChain([leave, 'optionalAccess', _117 => _117.angles, 'optionalAccess', _118 => _118.length])) {
       const c = construction(leave, p, tol);
       if (c) {
         const hit = this.slide(leave.at, c.dir, c.point, tol, false);
@@ -4334,7 +5489,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
    * with nothing spaces the box evenly in its row or column. Returns the correction and guides.
    */
   snapRect(r, tol, options = {}) {
-    const axes = { x: _optionalChain([options, 'access', _103 => _103.axes, 'optionalAccess', _104 => _104.x]) !== false, y: _optionalChain([options, 'access', _105 => _105.axes, 'optionalAccess', _106 => _106.y]) !== false };
+    const axes = { x: _optionalChain([options, 'access', _119 => _119.axes, 'optionalAccess', _120 => _120.x]) !== false, y: _optionalChain([options, 'access', _121 => _121.axes, 'optionalAccess', _122 => _122.y]) !== false };
     const nearest = (lines, values) => {
       let best = null;
       for (const v2 of values) for (const l of linesNear(lines, v2, tol)) if (!best || Math.abs(l.v - v2) < Math.abs(best.d)) best = { d: l.v - v2, from: l.from };
@@ -4342,7 +5497,7 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
     };
     const bx = axes.x ? nearest(this.xs, [r.x, r.x + r.width / 2, r.x + r.width]) : null;
     const by = axes.y ? nearest(this.ys, [r.y, r.y + r.height / 2, r.y + r.height]) : null;
-    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _107 => _107.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _108 => _108.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
+    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _123 => _123.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _124 => _124.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
     const done = { ...r, x: r.x + out.dx, y: r.y + out.dy };
     if (bx) {
       const x = bx.from.x;
@@ -4465,9 +5620,9 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
       const on = this.nearestPoint(p, tol);
       const tries = [];
       if (on) tries.push({ tx: on.p.x, ty: on.p.y, s: { hx: null, hy: null, on } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _109 => _109.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _110 => _110.v]), () => ( null)), s: { hx, hy, on: null } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _111 => _111.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
-      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _112 => _112.v]), () => ( null)), s: { hx: null, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _125 => _125.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _126 => _126.v]), () => ( null)), s: { hx, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _127 => _127.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
+      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _128 => _128.v]), () => ( null)), s: { hx: null, hy, on: null } });
       for (const { tx, ty, s } of tries) {
         if (tx === null && ty === null) continue;
         const q = applyMatrix(toLocal, { x: _nullishCoalesce(tx, () => ( p.x)), y: _nullishCoalesce(ty, () => ( p.y)) });
@@ -4621,16 +5776,16 @@ function solveOnSegment(seg, base, cond) {
     return cond([p[0] - b[0], p[1] - b[1]], _chunkVNYRI265cjs.segmentDerivative.call(void 0, seg, t));
   };
   const vals = [];
-  let scale = 0;
+  let scale3 = 0;
   for (let i = 0; i <= CURVE_SAMPLES; i++) {
     const t = i / CURVE_SAMPLES;
     const p = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, t);
     const d = _chunkVNYRI265cjs.segmentDerivative.call(void 0, seg, t);
     const r = [p[0] - b[0], p[1] - b[1]];
     vals.push(cond(r, d));
-    scale = Math.max(scale, Math.hypot(r[0], r[1]) * Math.hypot(d[0], d[1]));
+    scale3 = Math.max(scale3, Math.hypot(r[0], r[1]) * Math.hypot(d[0], d[1]));
   }
-  if (!(scale > 0) || vals.every((v2) => Math.abs(v2) <= scale * 1e-12)) return [];
+  if (!(scale3 > 0) || vals.every((v2) => Math.abs(v2) <= scale3 * 1e-12)) return [];
   const out = [];
   for (let i = 0; i < CURVE_SAMPLES; i++) {
     const ga = vals[i];
@@ -4664,7 +5819,7 @@ function solveOnSegment(seg, base, cond) {
 
 // src/vector/pathEdit.ts
 var EPS4 = 1e-9;
-var unit3 = (x, y) => {
+var unit4 = (x, y) => {
   const l = Math.hypot(x, y);
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
 };
@@ -4677,14 +5832,14 @@ function cubicOf(sp, i) {
 var isLine = (sp, i) => subpathSegment(sp, i).length === 2;
 function startTangent2(c) {
   for (let k = 1; k < 4; k++) {
-    const u = unit3(c[k][0] - c[0][0], c[k][1] - c[0][1]);
+    const u = unit4(c[k][0] - c[0][0], c[k][1] - c[0][1]);
     if (u) return u;
   }
   return [1, 0];
 }
 function endTangent2(c) {
   for (let k = 2; k >= 0; k--) {
-    const u = unit3(c[3][0] - c[k][0], c[3][1] - c[k][1]);
+    const u = unit4(c[3][0] - c[k][0], c[3][1] - c[k][1]);
     if (u) return u;
   }
   return [1, 0];
@@ -4748,13 +5903,13 @@ function removeAnchorKeepingShape(sp, index) {
     const pi = (index + n - 1) % n;
     const ni = (index + 1) % n;
     if (!(isLine(sp, pi) && isLine(sp, index))) {
-      const left = cubicOf(sp, pi);
+      const left2 = cubicOf(sp, pi);
       const right = cubicOf(sp, index);
       const N = 16;
       const pts = [];
-      sample(left, N, pts, true);
+      sample(left2, N, pts, true);
       sample(right, N, pts, false);
-      const t0 = startTangent2(left);
+      const t0 = startTangent2(left2);
       const t1 = endTangent2(right);
       const { curve } = fitAcross(pts, N, t0, t1);
       if ([curve.p1, curve.p2].every((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]))) {
@@ -4956,7 +6111,7 @@ function smoothSubpath(sp, amount = 1, only) {
     const prev = orig[(i + n - 1) % n];
     const next = orig[(i + 1) % n];
     const p = orig[i];
-    const dir = unit3(next.x - prev.x, next.y - prev.y);
+    const dir = unit4(next.x - prev.x, next.y - prev.y);
     if (!dir) continue;
     const li = dist2(p, prev) / 3;
     const lo = dist2(p, next) / 3;
@@ -5091,9 +6246,9 @@ function facesOf(path, fillRule) {
 function splitIntoFaces(path, fillRule = "nonzero") {
   return facesOf(path, fillRule).map(faceToPath);
 }
-function rootsInUnit(a, b, c, d, scale) {
+function rootsInUnit(a, b, c, d, scale3) {
   const f = (t) => ((a * t + b) * t + c) * t + d;
-  const tol = 1e-12 * Math.max(1, scale);
+  const tol = 1e-12 * Math.max(1, scale3);
   const cuts = [0];
   const qa = 3 * a;
   const qb = 2 * b;
@@ -5150,9 +6305,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 scale = Math.sqrt(len2) * Math.max(1, ...seg.map((pt2) => Math.abs(pt2[0]) + Math.abs(pt2[1])));
+  const scale3 = 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, scale)) {
+  for (const t of rootsInUnit(...coeffs, scale3)) {
     const point = _chunkVNYRI265cjs.segmentPoint.call(void 0, 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 });
@@ -5897,7 +7052,7 @@ function getEditablePathIds(state) {
       }
     }
   }
-  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _113 => _113(state.document.nodes, id), 'optionalAccess', _114 => _114.type]) === "path");
+  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _129 => _129(state.document.nodes, id), 'optionalAccess', _130 => _130.type]) === "path");
 }
 function getVisibleAnchors(state) {
   const out = [];
@@ -5912,7 +7067,7 @@ function getVisibleHandles(state) {
   const seen = /* @__PURE__ */ new Set();
   const push = (node, s, i, handle) => {
     const sp = node.subpaths[s];
-    const a = _optionalChain([sp, 'optionalAccess', _115 => _115.anchors, 'access', _116 => _116[i]]);
+    const a = _optionalChain([sp, 'optionalAccess', _131 => _131.anchors, 'access', _132 => _132[i]]);
     if (!a || !a[handle]) return;
     const key = `${node.id}:${s}:${i}:${handle}`;
     if (seen.has(key)) return;
@@ -5921,8 +7076,8 @@ function getVisibleHandles(state) {
   };
   if (state.tool === "pen" && state.pen) {
     const node = findVectorNode(state.document.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _117 => _117.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
-    if (_optionalChain([node, 'optionalAccess', _118 => _118.type]) === "path" && sp) {
+    const sp = _optionalChain([node, 'optionalAccess', _133 => _133.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    if (_optionalChain([node, 'optionalAccess', _134 => _134.type]) === "path" && sp) {
       const last = sp.anchors.length - 1;
       push(node, state.pen.subpath, last, "in");
       push(node, state.pen.subpath, last, "out");
@@ -5960,11 +7115,11 @@ function getVectorCornerWidgets(state) {
       const side = Math.min(c.lu, c.lv);
       if (side * zoom < 3 * VECTOR_CORNER_WIDGET_INSET) continue;
       const a = node.subpaths[c.subpath].anchors[c.index];
-      const radius = _nullishCoalesce(_optionalChain([a, 'access', _119 => _119.corner, 'optionalAccess', _120 => _120.radius]), () => ( 0));
+      const radius = _nullishCoalesce(_optionalChain([a, 'access', _135 => _135.corner, 'optionalAccess', _136 => _136.radius]), () => ( 0));
       const drawn = fitCornerRadius(c, radius);
       const k = Math.min(Math.max(drawn / c.sin, VECTOR_CORNER_WIDGET_INSET / (zoom * Math.sqrt(1 + c.cos))), side / 2);
       const p = applyMatrix(m, cornerBisectorPoint(c, k));
-      out.push({ ref: { nodeId: id, subpath: c.subpath, index: c.index }, x: p.x, y: p.y, radius, drawnRadius: drawn, kind: _nullishCoalesce(_optionalChain([a, 'access', _121 => _121.corner, 'optionalAccess', _122 => _122.kind]), () => ( "round")), corner: c });
+      out.push({ ref: { nodeId: id, subpath: c.subpath, index: c.index }, x: p.x, y: p.y, radius, drawnRadius: drawn, kind: _nullishCoalesce(_optionalChain([a, 'access', _137 => _137.corner, 'optionalAccess', _138 => _138.kind]), () => ( "round")), corner: c });
     }
   }
   return out;
@@ -5987,13 +7142,13 @@ function getVectorWidthHandles(state) {
     const n = findVectorNode(state.document.nodes, id);
     if (n) for (const p of collectPathNodes(n)) ids.add(p.id);
   }
-  if (_optionalChain([state, 'access', _123 => _123.hover, 'optionalAccess', _124 => _124.nodeId])) ids.add(state.hover.nodeId);
-  if (_optionalChain([state, 'access', _125 => _125.interaction, 'optionalAccess', _126 => _126.type]) === "width") ids.add(state.interaction.ref.nodeId);
+  if (_optionalChain([state, 'access', _139 => _139.hover, 'optionalAccess', _140 => _140.nodeId])) ids.add(state.hover.nodeId);
+  if (_optionalChain([state, 'access', _141 => _141.interaction, 'optionalAccess', _142 => _142.type]) === "width") ids.add(state.interaction.ref.nodeId);
   for (const r of state.selectedWidthPoints) ids.add(r.nodeId);
   const out = [];
   for (const id of ids) {
     const node = findVectorNode(state.document.nodes, id);
-    if (_optionalChain([node, 'optionalAccess', _127 => _127.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _128 => _128.strokeWidthProfile, 'optionalAccess', _129 => _129.length])) continue;
+    if (_optionalChain([node, 'optionalAccess', _143 => _143.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _144 => _144.strokeWidthProfile, 'optionalAccess', _145 => _145.length])) continue;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) continue;
     const profile = sanitizeWidthProfile(node.strokeWidthProfile);
@@ -6026,7 +7181,7 @@ function getVectorWidthHandles(state) {
 }
 function getAnchor(doc, ref) {
   const node = findVectorNode(doc.nodes, ref.nodeId);
-  return _optionalChain([node, 'optionalAccess', _130 => _130.type]) === "path" ? _optionalChain([node, 'access', _131 => _131.subpaths, 'access', _132 => _132[ref.subpath], 'optionalAccess', _133 => _133.anchors, 'access', _134 => _134[ref.index]]) : void 0;
+  return _optionalChain([node, 'optionalAccess', _146 => _146.type]) === "path" ? _optionalChain([node, 'access', _147 => _147.subpaths, 'access', _148 => _148[ref.subpath], 'optionalAccess', _149 => _149.anchors, 'access', _150 => _150[ref.index]]) : void 0;
 }
 function getAnchorWorld(doc, ref) {
   const a = getAnchor(doc, ref);
@@ -6098,7 +7253,8 @@ var TOOL_LABELS = {
   width: "Width",
   shapeBuilder: "Shape Builder",
   paintBucket: "Paint Bucket",
-  blend: "Blend"
+  blend: "Blend",
+  gradient: "Gradient"
 };
 var TOOL_KEYS = {
   v: "select",
@@ -6116,7 +7272,8 @@ var TOOL_KEYS = {
   w: "width",
   m: "shapeBuilder",
   b: "paintBucket",
-  j: "blend"
+  j: "blend",
+  g: "gradient"
 };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
@@ -6137,7 +7294,8 @@ var VECTOR_TOOL_SHORTCUTS = {
   width: "W",
   shapeBuilder: "M",
   paintBucket: "B",
-  blend: "J"
+  blend: "J",
+  gradient: "G"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -6155,7 +7313,8 @@ var VECTOR_TOOL_GLYPHS = {
   width: "\u21F9",
   shapeBuilder: "\u2295",
   paintBucket: "\u25CD",
-  blend: "\u29D3"
+  blend: "\u29D3",
+  gradient: "\u25D0"
 };
 var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line"]);
 var BOOLEAN_OPS = {
@@ -6252,18 +7411,19 @@ var VectorEditorController = (_class5 = class {
   __init30() {this.blendStart = null}
   /** Options new blends get (the toolbars edit them along with the selected blend's). */
   __init31() {this.blendDefaults = {}}
+  __init32() {this.gradientEdit = { target: "fill", stop: null }}
   /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
-  __init32() {this.builderHoverKey = null}
+  __init33() {this.builderHoverKey = null}
   
   
-  __init33() {this.listeners = /* @__PURE__ */ new Set()}
-  __init34() {this.cleanups = []}
-  __init35() {this.applying = false}
+  __init34() {this.listeners = /* @__PURE__ */ new Set()}
+  __init35() {this.cleanups = []}
+  __init36() {this.applying = false}
   /** Set while a commit records a change that was already applied, so `restore` still reports it. */
-  __init36() {this.committing = false}
-  __init37() {this.revision = 0}
+  __init37() {this.committing = false}
+  __init38() {this.revision = 0}
   
-  constructor(options = {}) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);_class5.prototype.__init21.call(this);_class5.prototype.__init22.call(this);_class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this);_class5.prototype.__init25.call(this);_class5.prototype.__init26.call(this);_class5.prototype.__init27.call(this);_class5.prototype.__init28.call(this);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);_class5.prototype.__init32.call(this);_class5.prototype.__init33.call(this);_class5.prototype.__init34.call(this);_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);
+  constructor(options = {}) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);_class5.prototype.__init21.call(this);_class5.prototype.__init22.call(this);_class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this);_class5.prototype.__init25.call(this);_class5.prototype.__init26.call(this);_class5.prototype.__init27.call(this);_class5.prototype.__init28.call(this);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);_class5.prototype.__init32.call(this);_class5.prototype.__init33.call(this);_class5.prototype.__init34.call(this);_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);_class5.prototype.__init40.call(this);
     this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.HistoryManager)()));
     this.doc = options.document ? cloneVectorDocument(options.document) : { width: 800, height: 600, nodes: [] };
     this.doc = this.refreshed(this.doc);
@@ -6276,15 +7436,26 @@ var VectorEditorController = (_class5 = class {
     this.createId = _nullishCoalesce(options.createId, () => ( defaultCreateId));
     this.onChange = options.onChange;
     this.state = this.computeState();
+    this.connect();
+  }
+  /** Listens to the history (once; again after `destroy`). */
+  connect() {
+    if (this.cleanups.length) return;
     this.cleanups.push(
       this.history.subscribe((h) => {
-        const s = this.state;
-        if (this.applying || s.canUndo === h.canUndo && s.canRedo === h.canRedo && s.undoLabel === h.undoName && s.redoLabel === h.redoName) return;
-        this.notify();
+        if (!this.applying && this.historyDiffers(h)) this.notify();
       })
     );
+    if (this.historyDiffers(this.history.getState())) this.state = this.computeState();
   }
-  /** Stops listening to the history. */
+  historyDiffers(h) {
+    const s = this.state;
+    return s.canUndo !== h.canUndo || s.canRedo !== h.canRedo || s.undoLabel !== h.undoName || s.redoLabel !== h.redoName;
+  }
+  /**
+   * Stops listening to the history and drops all listeners. A later `subscribe` reconnects, so a
+   * controller torn down by React StrictMode's double effect keeps working when it is reused.
+   */
   destroy() {
     this.cleanups.splice(0).forEach((fn) => fn());
     this.listeners.clear();
@@ -6293,9 +7464,10 @@ var VectorEditorController = (_class5 = class {
   // State
   // -------------------------------------------------------------------------
   /** The current snapshot (stable until the next change). */
-  __init38() {this.getState = () => this.state}
+  __init39() {this.getState = () => this.state}
   /** Calls `listener` after every change. Returns an unsubscribe function. */
-  __init39() {this.subscribe = (listener) => {
+  __init40() {this.subscribe = (listener) => {
+    this.connect();
     this.listeners.add(listener);
     return () => {
       this.listeners.delete(listener);
@@ -6333,6 +7505,7 @@ var VectorEditorController = (_class5 = class {
       builder: this.builderPreview,
       blendStart: this.blendStart,
       blendDefaults: this.blendDefaults,
+      gradientEdit: this.gradientEdit,
       canUndo: h.canUndo,
       canRedo: h.canRedo,
       undoLabel: h.undoName,
@@ -6351,7 +7524,7 @@ var VectorEditorController = (_class5 = class {
     if (this.blendStart && !this.getNode(this.blendStart.nodeId)) this.blendStart = null;
     this.revision++;
     this.state = this.computeState();
-    if (docChanged) _optionalChain([this, 'access', _135 => _135.onChange, 'optionalCall', _136 => _136(this.doc)]);
+    if (docChanged) _optionalChain([this, 'access', _151 => _151.onChange, 'optionalCall', _152 => _152(this.doc)]);
     const state = this.state;
     this.listeners.forEach((listener) => {
       try {
@@ -6381,31 +7554,38 @@ var VectorEditorController = (_class5 = class {
     return applyMatrix(invertMatrix(this.worldOf(id, doc)), p);
   }
   cursorFor() {
-    if (_optionalChain([this, 'access', _137 => _137.drag, 'optionalAccess', _138 => _138.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
-    if (_optionalChain([this, 'access', _139 => _139.drag, 'optionalAccess', _140 => _140.kind]) === "rotate") return "grabbing";
-    if (_optionalChain([this, 'access', _141 => _141.drag, 'optionalAccess', _142 => _142.kind]) === "move") return "move";
+    if (_optionalChain([this, 'access', _153 => _153.drag, 'optionalAccess', _154 => _154.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
+    if (_optionalChain([this, 'access', _155 => _155.drag, 'optionalAccess', _156 => _156.kind]) === "rotate") return "grabbing";
+    if (_optionalChain([this, 'access', _157 => _157.drag, 'optionalAccess', _158 => _158.kind]) === "move") return "move";
     const h = this.hover;
     switch (this.tool) {
       case "select":
-        if (_optionalChain([h, 'optionalAccess', _143 => _143.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _144 => _144.frameOf, 'call', _145 => _145(this.selectedRoots()), 'optionalAccess', _146 => _146.angle]), () => ( 0)));
-        return _optionalChain([h, 'optionalAccess', _147 => _147.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _159 => _159.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _160 => _160.frameOf, 'call', _161 => _161(this.selectedRoots()), 'optionalAccess', _162 => _162.angle]), () => ( 0)));
+        return _optionalChain([h, 'optionalAccess', _163 => _163.nodeId]) ? "move" : "default";
       case "direct":
-        if (_optionalChain([h, 'optionalAccess', _148 => _148.anchor]) || _optionalChain([h, 'optionalAccess', _149 => _149.handle]) || _optionalChain([h, 'optionalAccess', _150 => _150.corner])) return "pointer";
-        if (_optionalChain([h, 'optionalAccess', _151 => _151.segment])) return "copy";
-        return _optionalChain([h, 'optionalAccess', _152 => _152.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _164 => _164.anchor]) || _optionalChain([h, 'optionalAccess', _165 => _165.handle]) || _optionalChain([h, 'optionalAccess', _166 => _166.corner])) return "pointer";
+        if (_optionalChain([h, 'optionalAccess', _167 => _167.segment])) return "copy";
+        return _optionalChain([h, 'optionalAccess', _168 => _168.nodeId]) ? "move" : "default";
       case "pen":
-        return _optionalChain([h, 'optionalAccess', _153 => _153.anchor]) ? "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _169 => _169.anchor]) ? "pointer" : "crosshair";
       case "width":
-        if (_optionalChain([this, 'access', _154 => _154.drag, 'optionalAccess', _155 => _155.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
-        if (_optionalChain([h, 'optionalAccess', _156 => _156.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
-        return _optionalChain([h, 'optionalAccess', _157 => _157.strokeSpot]) ? "copy" : "default";
+        if (_optionalChain([this, 'access', _170 => _170.drag, 'optionalAccess', _171 => _171.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
+        if (_optionalChain([h, 'optionalAccess', _172 => _172.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
+        return _optionalChain([h, 'optionalAccess', _173 => _173.strokeSpot]) ? "copy" : "default";
       case "shapeBuilder":
-        if (!_optionalChain([this, 'access', _158 => _158.builderPreview, 'optionalAccess', _159 => _159.faces, 'access', _160 => _160.length]) && !_optionalChain([this, 'access', _161 => _161.builderPreview, 'optionalAccess', _162 => _162.lines, 'access', _163 => _163.length])) return "crosshair";
+        if (!_optionalChain([this, 'access', _174 => _174.builderPreview, 'optionalAccess', _175 => _175.faces, 'access', _176 => _176.length]) && !_optionalChain([this, 'access', _177 => _177.builderPreview, 'optionalAccess', _178 => _178.lines, 'access', _179 => _179.length])) return "crosshair";
         return this.builderPreview.mode === "erase" ? "not-allowed" : "cell";
       case "paintBucket":
         return this.builderPreview ? "cell" : "crosshair";
       case "blend":
-        return _optionalChain([h, 'optionalAccess', _164 => _164.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _180 => _180.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
+      case "gradient": {
+        const part = _optionalChain([this, 'access', _181 => _181.drag, 'optionalAccess', _182 => _182.kind]) === "gradient" ? this.drag.part : _optionalChain([h, 'optionalAccess', _183 => _183.gradient]);
+        if (!part) return "crosshair";
+        if (part.kind === "bar") return this.drag ? "grabbing" : "copy";
+        if (part.kind === "handle" && part.handle === "start") return this.drag ? "grabbing" : "move";
+        return "pointer";
+      }
       default:
         return "crosshair";
     }
@@ -6426,11 +7606,11 @@ var VectorEditorController = (_class5 = class {
       this.selection = s.selection.filter((id) => this.getNode(id));
       this.anchors = s.anchors.filter((r) => getAnchor(this.doc, r));
       this.editingId = s.editingId && this.getNode(s.editingId) ? s.editingId : null;
-      this.pen = s.pen && _optionalChain([this, 'access', _165 => _165.getNode, 'call', _166 => _166(s.pen.nodeId), 'optionalAccess', _167 => _167.subpaths, 'optionalAccess', _168 => _168[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _184 => _184.getNode, 'call', _185 => _185(s.pen.nodeId), 'optionalAccess', _186 => _186.subpaths, 'optionalAccess', _187 => _187[s.pen.subpath]]) ? s.pen : null;
       if (this.widthPoints.length) {
         const kept = this.widthPoints.filter((r) => {
           const n = this.getNode(r.nodeId);
-          return _optionalChain([n, 'optionalAccess', _169 => _169.type]) === "path" && !!_optionalChain([n, 'access', _170 => _170.strokeWidthProfile, 'optionalAccess', _171 => _171[r.index]]);
+          return _optionalChain([n, 'optionalAccess', _188 => _188.type]) === "path" && !!_optionalChain([n, 'access', _189 => _189.strokeWidthProfile, 'optionalAccess', _190 => _190[r.index]]);
         });
         if (kept.length !== this.widthPoints.length) this.widthPoints = kept;
       }
@@ -6612,7 +7792,7 @@ var VectorEditorController = (_class5 = class {
       if (res.kind) {
         this.snappedToObject = true;
         this.setGuides(res);
-        return _optionalChain([leave, 'optionalAccess', _172 => _172.constrain]) ? res.point : { x: res.x ? res.point.x : this.gridValue(res.point.x), y: res.y ? res.point.y : this.gridValue(res.point.y) };
+        return _optionalChain([leave, 'optionalAccess', _191 => _191.constrain]) ? res.point : { x: res.x ? res.point.x : this.gridValue(res.point.x), y: res.y ? res.point.y : this.gridValue(res.point.y) };
       }
     }
     this.setGuides(null);
@@ -6630,14 +7810,14 @@ var VectorEditorController = (_class5 = class {
   /** Where the pointer at `p` would place a point with the pen or a shape tool (and the guides showing why). */
   hoverSnap(p, input) {
     if (this.tool === "pen") {
-      const sp = this.pen ? _optionalChain([this, 'access', _173 => _173.getNode, 'call', _174 => _174(this.pen.nodeId), 'optionalAccess', _175 => _175.subpaths, 'access', _176 => _176[this.pen.subpath]]) : void 0;
-      if (this.pen && sp && _optionalChain([this, 'access', _177 => _177.hover, 'optionalAccess', _178 => _178.anchor])) {
+      const sp = this.pen ? _optionalChain([this, 'access', _192 => _192.getNode, 'call', _193 => _193(this.pen.nodeId), 'optionalAccess', _194 => _194.subpaths, 'access', _195 => _195[this.pen.subpath]]) : void 0;
+      if (this.pen && sp && _optionalChain([this, 'access', _196 => _196.hover, 'optionalAccess', _197 => _197.anchor])) {
         this.setGuides(null);
         return p;
       }
       const last = this.pen && sp ? getAnchorWorld(this.doc, { nodeId: this.pen.nodeId, subpath: this.pen.subpath, index: sp.anchors.length - 1 }) : void 0;
       const leave = last ? { at: { x: last.x, y: last.y }, constrain: input.shift ? "angle" : null } : null;
-      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _179 => _179.pen, 'optionalAccess', _180 => _180.nodeId]), () => ( null))));
+      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _198 => _198.pen, 'optionalAccess', _199 => _199.nodeId]), () => ( null))));
     }
     if (SHAPE_TOOLS.has(this.tool)) return this.snapDrawn(p, null, input, () => this.drawingTargets(null));
     this.setGuides(null);
@@ -6785,7 +7965,7 @@ var VectorEditorController = (_class5 = class {
     if (d.fillRule) out.fillRule = d.fillRule;
     if (d.strokeAlign && d.strokeAlign !== "center") out.strokeAlign = d.strokeAlign;
     for (const key of ["startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale"]) if (d[key]) out[key] = d[key];
-    if (_optionalChain([d, 'access', _181 => _181.strokeWidthProfile, 'optionalAccess', _182 => _182.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
+    if (_optionalChain([d, 'access', _200 => _200.strokeWidthProfile, 'optionalAccess', _201 => _201.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     return out;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -6831,6 +8011,233 @@ var VectorEditorController = (_class5 = class {
     this.widthEdit = null;
     return this.setStyle({ strokeWidthProfile: points.length ? points : null }, _nullishCoalesce(options.ids, () => ( this.selection)), { label: points.length ? "Width Profile" : "Uniform Width" });
   }
+  // -------------------------------------------------------------------------
+  // Gradients
+  // -------------------------------------------------------------------------
+  /** Which paint (fill or stroke) the gradient tool and editor work on. */
+  setGradientTarget(target) {
+    if (target === this.gradientEdit.target) return;
+    this.gradientEdit = { target, stop: null };
+    this.notify();
+  }
+  /** Selects a stop of the gradient being edited (index into its sorted stops), or none. */
+  selectGradientStop(index) {
+    if (index === this.gradientEdit.stop) return;
+    this.gradientEdit = { ...this.gradientEdit, stop: index };
+    this.notify();
+  }
+  /** The gradient tool's annotator for the selection (screen pixels), or null when its paint is not a gradient. */
+  getGradientAnnotator() {
+    return getVectorGradientAnnotator(this.doc, this.selection, this.viewport, this.gradientEdit.target);
+  }
+  /** Unlocked paths of `ids` (default: the selection). */
+  gradientPaths(ids = this.selection) {
+    const out = /* @__PURE__ */ new Map();
+    for (const id of ids) {
+      const node = this.getNode(id);
+      if (node && !node.locked) {
+        for (const p of collectPathNodes(node)) if (!p.locked) out.set(p.id, p);
+      }
+    }
+    return [...out.values()];
+  }
+  /**
+   * Edits the gradient of the `target` paint (default: the editor's) of the selected (or given)
+   * paths with `patch`: a colour or no paint becomes a gradient (`patch.type`, default linear,
+   * from the colour to white). Consecutive edits with the same `merge` key are one undo step.
+   */
+  setGradient(patch, options = {}) {
+    const target = _nullishCoalesce(options.target, () => ( this.gradientEdit.target));
+    const paths = this.gradientPaths(_nullishCoalesce(options.ids, () => ( this.selection)));
+    if (!paths.length) return { ok: false, message: "Nothing is selected." };
+    const next = /* @__PURE__ */ new Map();
+    for (const path of paths) {
+      const paint = path[target];
+      const base = isVectorGradient(paint) ? paint : defaultVectorGradient(_nullishCoalesce(patch.type, () => ( "linear")), paint);
+      const g = applyVectorGradientPatch(base, patch);
+      if (!g) return { ok: false, message: "That is not a valid gradient: it needs at least one stop with an offset and a colour." };
+      next.set(path.id, { ...path, [target]: g });
+    }
+    this.change(_nullishCoalesce(options.label, () => ( "Gradient")), () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))), options.merge);
+    const stops = _nullishCoalesce(_optionalChain([next, 'access', _202 => _202.values, 'call', _203 => _203(), 'access', _204 => _204.next, 'call', _205 => _205(), 'access', _206 => _206.value, 'optionalAccess', _207 => _207[target], 'optionalAccess', _208 => _208.stops, 'access', _209 => _209.length]), () => ( 0));
+    if (this.gradientEdit.stop !== null && this.gradientEdit.stop >= stops) this.gradientEdit = { ...this.gradientEdit, stop: null };
+    return { ok: true };
+  }
+  /** Applies `fn` to every target gradient of the selection (paths whose paint is not a gradient are skipped). */
+  editGradients(label, fn, merge) {
+    const target = this.gradientEdit.target;
+    const paths = this.gradientPaths().filter((p) => isVectorGradient(p[target]));
+    if (!paths.length) return { ok: false, message: "The selection has no gradient." };
+    const next = /* @__PURE__ */ new Map();
+    for (const path of paths) {
+      const g = path[target];
+      const stops = fn(sortedVectorGradientStops(g));
+      if (!stops) return { ok: false, message: "A gradient keeps at least two stops." };
+      next.set(path.id, { ...path, [target]: { ...g, stops } });
+    }
+    this.change(label, () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))), merge);
+    return { ok: true };
+  }
+  /** Changes stop `index` (colour, opacity, offset or midpoint) of the selection's gradients; selects it. */
+  setGradientStop(index, patch, options = {}) {
+    let moved = index;
+    const result = this.editGradients(
+      "Gradient Stop",
+      (stops) => {
+        if (!stops[index]) return stops;
+        let next = stops.map((s, i) => {
+          if (i !== index) return s;
+          const out = { ...s };
+          if (patch.color !== void 0) out.color = patch.color;
+          if (patch.opacity !== void 0 && Number.isFinite(patch.opacity)) {
+            const o = Math.min(1, Math.max(0, patch.opacity));
+            if (o < 1) out.opacity = o;
+            else delete out.opacity;
+          }
+          if (patch.midpoint !== void 0 && Number.isFinite(patch.midpoint)) {
+            const m = Math.min(0.95, Math.max(0.05, patch.midpoint));
+            if (Math.abs(m - 0.5) > 1e-3) out.midpoint = m;
+            else delete out.midpoint;
+          }
+          return out;
+        });
+        if (patch.offset !== void 0 && Number.isFinite(patch.offset)) ({ stops: next, index: moved } = moveVectorGradientStop(next, index, patch.offset));
+        return next;
+      },
+      options.merge
+    );
+    if (result.ok) this.selectGradientStop(moved);
+    return result;
+  }
+  /** Adds a stop at `offset` (painting what the gradient paints there) to the selection's gradients and selects it. */
+  addGradientStop(offset) {
+    let index = 0;
+    const target = this.gradientEdit.target;
+    const result = this.editGradients("Add Gradient Stop", (stops) => {
+      const path = this.gradientPaths().find((p) => isVectorGradient(p[target]));
+      const r = insertVectorGradientStop({ ...path[target], stops }, offset);
+      index = r.index;
+      return r.stops;
+    });
+    if (result.ok) this.selectGradientStop(index);
+    return result;
+  }
+  /** Removes stop `index` of the selection's gradients (never below two stops). */
+  removeGradientStop(index) {
+    const result = this.editGradients("Delete Gradient Stop", (stops) => removeVectorGradientStop(stops, index));
+    if (result.ok) this.selectGradientStop(null);
+    return result;
+  }
+  /** Reverses the selection's gradients (stops and midpoints). */
+  reverseGradient() {
+    return this.setGradient({ reverse: true }, { label: "Reverse Gradient" });
+  }
+  /** `doc` with path `id`'s `target` paint replaced. */
+  withGradient(doc, id, target, g) {
+    return { ...doc, nodes: mapTree(doc.nodes, (n) => n.id === id ? { ...n, [target]: g } : n) };
+  }
+  downGradient(screen, p, input) {
+    const before = this.snapshot();
+    const a = this.getGradientAnnotator();
+    let part = a ? hitVectorGradientAnnotator(a, screen) : null;
+    if (a && part) {
+      if (part.kind === "handle" && part.handle === "start" && input.alt && a.gradient.type === "radial") part = { kind: "handle", handle: "focal" };
+      if (part.kind === "stop") this.gradientEdit = { ...this.gradientEdit, stop: part.index };
+      this.drag = { kind: "gradient", part, nodeId: a.nodeId, targets: [a.nodeId], annotator: a, start: screen, startDoc: p, before, base: this.doc, moved: false, stop: part.kind === "stop" ? part.index : null };
+      this.interaction = { type: "gradient", part: part.kind, ...part.kind === "handle" ? { handle: part.handle } : {} };
+      this.notify();
+      return;
+    }
+    const hit = this.hitPath(p);
+    if (hit && !this.gradientPaths().some((n) => n.id === hit.id)) {
+      this.selection = [hit.id];
+      this.gradientEdit = { ...this.gradientEdit, stop: null };
+    }
+    const targets = this.gradientPaths().map((n) => n.id);
+    if (!targets.length) {
+      if (this.selection.length) this.clearSelection();
+      return;
+    }
+    this.drag = { kind: "gradient", part: null, nodeId: null, targets, annotator: null, start: screen, startDoc: p, before, base: this.doc, moved: false, stop: null };
+    this.interaction = { type: "gradient", part: "create" };
+    this.notify();
+  }
+  moveGradient(drag, screen, p, input) {
+    if (!drag.moved && Math.hypot(screen.x - drag.start.x, screen.y - drag.start.y) < 3) return;
+    drag.moved = true;
+    const target = this.gradientEdit.target;
+    const base = drag.base;
+    const constrained = (from, to) => {
+      if (!input.shift) return to;
+      const ang = Math.round(Math.atan2(to.y - from.y, to.x - from.x) / (Math.PI / 4)) * (Math.PI / 4);
+      const len2 = Math.hypot(to.x - from.x, to.y - from.y);
+      return { x: from.x + Math.cos(ang) * len2, y: from.y + Math.sin(ang) * len2 };
+    };
+    if (!drag.part) {
+      const end = constrained(drag.startDoc, p);
+      let doc = base;
+      for (const id2 of drag.targets) {
+        const node2 = findVectorNode(base.nodes, id2);
+        if (!node2) continue;
+        const paint = node2[target];
+        const g2 = isVectorGradient(paint) ? paint : defaultVectorGradient("linear", paint);
+        doc = this.withGradient(doc, id2, target, setVectorGradientVector(g2, vectorPathLocalBounds(node2), this.toLocal(id2, drag.startDoc, base), this.toLocal(id2, end, base)));
+      }
+      this.doc = doc;
+      this.notify(true);
+      return;
+    }
+    const id = drag.nodeId;
+    const node = findVectorNode(base.nodes, id);
+    const g = node[target];
+    const bounds = vectorPathLocalBounds(node);
+    const local = (q) => this.toLocal(id, q, base);
+    const part = drag.part;
+    let next = g;
+    if (part.kind === "handle") {
+      let to = p;
+      if (part.handle === "end" || part.handle === "radius") to = constrained(this.screenToDocument(drag.annotator.start), p);
+      next = moveVectorGradientHandle(g, bounds, part.handle, local(to), local(drag.startDoc));
+    } else if (part.kind === "bar") {
+      next = moveVectorGradientHandle(g, bounds, "start", local(p), local(drag.startDoc));
+    } else {
+      const a = drag.annotator;
+      const pos = vectorGradientBarPosition(a, screen);
+      const stops = sortedVectorGradientStops(g);
+      if (part.kind === "stop") {
+        const off = Math.abs(pos.across - VECTOR_GRADIENT_STOP_GAP) > VECTOR_GRADIENT_OFF_BAR;
+        const removed = off ? removeVectorGradientStop(stops, part.index) : null;
+        if (removed) {
+          next = { ...g, stops: removed };
+          drag.stop = null;
+        } else {
+          const r = moveVectorGradientStop(stops, part.index, Math.min(1, Math.max(0, pos.offset)));
+          next = { ...g, stops: r.stops };
+          drag.stop = r.index;
+        }
+        this.interaction = { type: "gradient", part: "stop", ...removed ? { removing: true } : {} };
+        this.gradientEdit = { ...this.gradientEdit, stop: drag.stop };
+      } else {
+        const m = vectorGradientMidpointFromPosition(stops, part.index, pos.offset);
+        if (m !== null) next = { ...g, stops: stops.map((s, i) => i !== part.index ? s : Math.abs(m - 0.5) < 1e-3 ? (({ midpoint: _m, ...rest }) => rest)(s) : { ...s, midpoint: m }) };
+      }
+    }
+    this.doc = this.withGradient(base, id, target, next);
+    this.notify(true);
+  }
+  upGradient(drag) {
+    const part = drag.part;
+    if (!drag.moved) {
+      if (_optionalChain([part, 'optionalAccess', _210 => _210.kind]) === "bar") {
+        this.addGradientStop(part.offset);
+        return;
+      }
+      this.notify();
+      return;
+    }
+    const label = !part ? "Gradient" : part.kind === "stop" ? drag.stop === null ? "Delete Gradient Stop" : "Move Gradient Stop" : part.kind === "midpoint" ? "Gradient Midpoint" : part.kind === "bar" || part.kind === "handle" && part.handle === "start" ? "Move Gradient" : "Gradient Handle";
+    return this.commit(label, drag.before);
+  }
   /** Removes one width point of a path's profile. */
   removeWidthPoint(ref) {
     return this.removeWidthPoints([ref]);
@@ -6840,7 +8247,7 @@ var VectorEditorController = (_class5 = class {
     const byNode = /* @__PURE__ */ new Map();
     for (const r of refs) {
       const node = this.getNode(r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _183 => _183.type]) !== "path" || !_optionalChain([node, 'access', _184 => _184.strokeWidthProfile, 'optionalAccess', _185 => _185[r.index]])) continue;
+      if (_optionalChain([node, 'optionalAccess', _211 => _211.type]) !== "path" || !_optionalChain([node, 'access', _212 => _212.strokeWidthProfile, 'optionalAccess', _213 => _213[r.index]])) continue;
       byNode.set(r.nodeId, [..._nullishCoalesce(byNode.get(r.nodeId), () => ( [])), r.index]);
     }
     if (!byNode.size) return { ok: false, message: "There is no such width point." };
@@ -6858,12 +8265,12 @@ var VectorEditorController = (_class5 = class {
   }
   /** Selects width points (width tool); points on other paths than the first are dropped. */
   selectWidthPoints(refs) {
-    const first = _optionalChain([refs, 'access', _186 => _186[0], 'optionalAccess', _187 => _187.nodeId]);
+    const first = _optionalChain([refs, 'access', _214 => _214[0], 'optionalAccess', _215 => _215.nodeId]);
     const next = [];
     for (const r of refs) {
       if (r.nodeId !== first || next.some((q) => q.index === r.index)) continue;
       const n = this.getNode(r.nodeId);
-      if (_optionalChain([n, 'optionalAccess', _188 => _188.type]) === "path" && _optionalChain([n, 'access', _189 => _189.strokeWidthProfile, 'optionalAccess', _190 => _190[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
+      if (_optionalChain([n, 'optionalAccess', _216 => _216.type]) === "path" && _optionalChain([n, 'access', _217 => _217.strokeWidthProfile, 'optionalAccess', _218 => _218[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
     }
     this.widthPoints = next;
     this.notify();
@@ -6878,14 +8285,14 @@ var VectorEditorController = (_class5 = class {
    */
   setWidthPoint(target, values) {
     const node = this.getNode(target.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _191 => _191.type]) !== "path") return { ok: false, message: "There is no such path." };
+    if (_optionalChain([node, 'optionalAccess', _219 => _219.type]) !== "path") return { ok: false, message: "There is no such path." };
     const g = vectorStrokeWidthGeometry(node);
     if (!g || !(g.unit > 0)) return { ok: false, message: "The path has no visible stroke." };
-    const num = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? v2 : void 0;
-    const t = num(values.t);
-    const left = num(values.left);
-    const right = num(values.right);
-    const scale = (w) => w === void 0 ? void 0 : Math.max(0, w) / g.unit;
+    const num2 = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? v2 : void 0;
+    const t = num2(values.t);
+    const left2 = num2(values.left);
+    const right = num2(values.right);
+    const scale3 = (w) => w === void 0 ? void 0 : Math.max(0, w) / g.unit;
     const profile = sanitizeWidthProfile(node.strokeWidthProfile);
     let points;
     let index;
@@ -6893,11 +8300,11 @@ var VectorEditorController = (_class5 = class {
     if (existing === null) {
       if (t === void 0) return { ok: false, message: "A new width point needs a position t." };
       if (profile.length >= VECTOR_WIDTH_PROFILE_MAX_POINTS) return { ok: false, message: "The profile has too many width points." };
-      ({ points, index } = insertWidthPoint(profile.length ? profile : null, t, { left: scale(left), right: scale(right) }, { step: true }));
+      ({ points, index } = insertWidthPoint(profile.length ? profile : null, t, { left: scale3(left2), right: scale3(right) }, { step: true }));
     } else {
       const p = profile[existing];
       if (!p) return { ok: false, message: "There is no such width point." };
-      const sides2 = { left: _nullishCoalesce(scale(left), () => ( p.left)), right: _nullishCoalesce(scale(right), () => ( p.right)) };
+      const sides2 = { left: _nullishCoalesce(scale3(left2), () => ( p.left)), right: _nullishCoalesce(scale3(right), () => ( p.right)) };
       const tt = t === void 0 ? p.t : Math.min(Math.max(t, 0), 1);
       if (Math.abs(tt - p.t) <= VECTOR_WIDTH_SAME_T) {
         points = setWidthPoint(profile, existing, sides2);
@@ -6911,11 +8318,11 @@ var VectorEditorController = (_class5 = class {
         }
       }
     }
-    const subpath = _optionalChain([this, 'access', _192 => _192.widthEdit, 'optionalAccess', _193 => _193.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _194 => _194.widthPoints, 'access', _195 => _195.find, 'call', _196 => _196((r) => r.nodeId === node.id), 'optionalAccess', _197 => _197.subpath]), () => ( 0));
+    const subpath = _optionalChain([this, 'access', _220 => _220.widthEdit, 'optionalAccess', _221 => _221.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _222 => _222.widthPoints, 'access', _223 => _223.find, 'call', _224 => _224((r) => r.nodeId === node.id), 'optionalAccess', _225 => _225.subpath]), () => ( 0));
     const edit = this.widthEdit;
     this.change("Width Point", () => this.replaceNode(node.id, withStyle(node, { strokeWidthProfile: points })));
     this.widthPoints = [{ nodeId: node.id, index, subpath }];
-    if (_optionalChain([edit, 'optionalAccess', _198 => _198.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
+    if (_optionalChain([edit, 'optionalAccess', _226 => _226.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
     this.notify();
     return { ok: true };
   }
@@ -6949,7 +8356,7 @@ var VectorEditorController = (_class5 = class {
   /** The editor's view of point `index` (or of the stroke at `t` when index is null) of `nodeId`. */
   widthEditFor(nodeId, subpath, index, t) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _199 => _199.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _227 => _227.type]) !== "path") return null;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) return null;
     const profile = sanitizeWidthProfile(node.strokeWidthProfile);
@@ -6983,7 +8390,7 @@ var VectorEditorController = (_class5 = class {
     const refs = this.cornerTargets(options);
     if (!refs.length) return { ok: false, message: "Nothing is selected." };
     this.change("Corner Kind", () => {
-      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _200 => _200.corner, 'optionalAccess', _201 => _201.radius]), () => ( 0)), kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _228 => _228.corner, 'optionalAccess', _229 => _229.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
@@ -7105,7 +8512,7 @@ var VectorEditorController = (_class5 = class {
   updateEffect(nodeId, effectId, patch, options = {}) {
     const merge = options.merge === true ? `effect:${nodeId}:${effectId}` : options.merge || void 0;
     const node = this.getNode(nodeId);
-    const current = _optionalChain([node, 'optionalAccess', _202 => _202.effects, 'optionalAccess', _203 => _203.find, 'call', _204 => _204((e) => e.id === effectId)]);
+    const current = _optionalChain([node, 'optionalAccess', _230 => _230.effects, 'optionalAccess', _231 => _231.find, 'call', _232 => _232((e) => e.id === effectId)]);
     const label = current ? _nullishCoalesce(VECTOR_EFFECT_LABELS[current.type], () => ( "Effect")) : "Effect";
     return this.editEffects(
       nodeId,
@@ -7238,10 +8645,10 @@ var VectorEditorController = (_class5 = class {
     return this.selection.filter((id) => {
       let covered = false;
       const loc = locateVectorNode(this.doc.nodes, id);
-      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _205 => _205.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _233 => _233.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _206 => _206(this.doc.nodes, parent.id), 'optionalAccess', _207 => _207.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _234 => _234(this.doc.nodes, parent.id), 'optionalAccess', _235 => _235.parent]), () => ( null));
       }
       return !covered;
     });
@@ -7424,8 +8831,8 @@ var VectorEditorController = (_class5 = class {
     if (!ids.length) return null;
     const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
     if (locs.some((l) => !l)) return null;
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _208 => _208[0], 'access', _209 => _209.parent, 'optionalAccess', _210 => _210.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _211 => _211.parent, 'optionalAccess', _212 => _212.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _236 => _236[0], 'access', _237 => _237.parent, 'optionalAccess', _238 => _238.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _239 => _239.parent, 'optionalAccess', _240 => _240.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -7448,7 +8855,7 @@ var VectorEditorController = (_class5 = class {
   }
   /** Replaces selected groups with their children. */
   ungroup(options = {}) {
-    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _213 => _213.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _241 => _241.type]) === "group");
     if (!groups.length) return { ok: false, message: "Select a group to ungroup." };
     const set = new Set(groups.map((g) => g.id));
     this.change("Ungroup", () => {
@@ -7548,7 +8955,7 @@ var VectorEditorController = (_class5 = class {
       this.change(label, () => this.replaceNode(lone.id, { ...lone, liveBoolean: op, children }));
       return lone.id;
     }
-    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _214 => _214(this.doc.nodes, id2), 'optionalAccess', _215 => _215.parent]), () => ( null)));
+    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _242 => _242(this.doc.nodes, id2), 'optionalAccess', _243 => _243.parent]), () => ( null)));
     if (parents.every((g) => isVectorLiveBoolean(g))) {
       const set = new Set(roots);
       this.change(
@@ -7569,8 +8976,8 @@ var VectorEditorController = (_class5 = class {
       return parents[0].id;
     }
     if (nodes.length < 2) return null;
-    const parent = _nullishCoalesce(_optionalChain([parents, 'access', _216 => _216[0], 'optionalAccess', _217 => _217.id]), () => ( null));
-    if (parents.some((g) => (_nullishCoalesce(_optionalChain([g, 'optionalAccess', _218 => _218.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([parents, 'access', _244 => _244[0], 'optionalAccess', _245 => _245.id]), () => ( null));
+    if (parents.some((g) => (_nullishCoalesce(_optionalChain([g, 'optionalAccess', _246 => _246.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change(label, () => {
       const set = new Set(roots);
@@ -7618,7 +9025,7 @@ var VectorEditorController = (_class5 = class {
   }
   /** Splits selected compound paths into one path per subpath. */
   breakApart(options = {}) {
-    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _219 => _219.type]) === "path" && n.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _247 => _247.type]) === "path" && n.subpaths.length > 1);
     if (!paths.length) return { ok: false, message: "Select a compound path to break apart." };
     const created = [];
     const set = new Set(paths.map((p) => p.id));
@@ -7686,7 +9093,7 @@ var VectorEditorController = (_class5 = class {
     const out = /* @__PURE__ */ new Map();
     for (const id of _nullishCoalesce(ids, () => ( this.selection))) {
       const node = this.getNode(id);
-      const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _220 => _220(this.doc.nodes, id), 'optionalAccess', _221 => _221.parent]);
+      const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _248 => _248(this.doc.nodes, id), 'optionalAccess', _249 => _249.parent]);
       if (isVectorBlendGroup(group)) out.set(group.id, group);
     }
     return [...out.values()];
@@ -7704,8 +9111,8 @@ var VectorEditorController = (_class5 = class {
     });
     if (ids.length < 2) return null;
     const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _222 => _222[0], 'access', _223 => _223.parent, 'optionalAccess', _224 => _224.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _225 => _225.parent, 'optionalAccess', _226 => _226.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _250 => _250[0], 'access', _251 => _251.parent, 'optionalAccess', _252 => _252.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _253 => _253.parent, 'optionalAccess', _254 => _254.id]), () => ( null))) !== parent)) return null;
     const order = input.keepOrder ? ids : ids.slice().sort((a, b) => locs[ids.indexOf(a)].index - locs[ids.indexOf(b)].index);
     const blend = blendOptionsOf({ ...this.blendDefaults, ...input });
     if (input.starts) {
@@ -7747,7 +9154,7 @@ var VectorEditorController = (_class5 = class {
     const node = this.getNode(nodeId);
     if (!isVectorBlendGroup(group)) return { ok: false, message: `"${blendId}" is not a blend.` };
     if (!node || node.blendStep || node.locked || node.id === blendId) return { ok: false, message: `"${nodeId}" cannot be a key.` };
-    const parentOf = (id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _227 => _227(this.doc.nodes, id), 'optionalAccess', _228 => _228.parent, 'optionalAccess', _229 => _229.id]), () => ( null));
+    const parentOf = (id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _255 => _255(this.doc.nodes, id), 'optionalAccess', _256 => _256.parent, 'optionalAccess', _257 => _257.id]), () => ( null));
     if (parentOf(blendId) !== parentOf(nodeId)) return { ok: false, message: "The new key must sit beside the blend (same parent)." };
     const start = options.start;
     this.change("Blend", () => {
@@ -7817,7 +9224,7 @@ var VectorEditorController = (_class5 = class {
   replaceBlendSpine(options = {}) {
     const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
     const groups = this.blendTargets(roots);
-    const paths = roots.map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _230 => _230.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _231 => _231(this.doc.nodes, n.id), 'optionalAccess', _232 => _232.parent])));
+    const paths = roots.map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _258 => _258.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _259 => _259(this.doc.nodes, n.id), 'optionalAccess', _260 => _260.parent])));
     if (groups.length !== 1 || paths.length !== 1) return { ok: false, message: "Select one blend and one path to be its spine." };
     const group = groups[0];
     const path = paths[0];
@@ -7848,7 +9255,7 @@ var VectorEditorController = (_class5 = class {
   shapeBuilderMap(ids) {
     const roots = _nullishCoalesce(ids, () => ( this.selectedRoots()));
     const key = roots.join("\0");
-    if (_optionalChain([this, 'access', _233 => _233.builderCache, 'optionalAccess', _234 => _234.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
+    if (_optionalChain([this, 'access', _261 => _261.builderCache, 'optionalAccess', _262 => _262.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
     const entries = roots.length ? vectorPathEntries(this.doc, roots, { expand: false }) : [];
     const map = entries.length ? vectorShapeBuilderMap(entries) : null;
     this.builderCache = { doc: this.doc, key, map };
@@ -7908,9 +9315,9 @@ var VectorEditorController = (_class5 = class {
         const list = [];
         const r = plan.replace.get(i);
         if (r === void 0) list.push(node);
-        else if (_optionalChain([r, 'optionalAccess', _235 => _235.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _236 => _236.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _237 => _237.kind]) === "pieces") {
+        else if (_optionalChain([r, 'optionalAccess', _263 => _263.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _264 => _264.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _265 => _265.kind]) === "pieces") {
           r.paths.forEach(
             (path, k) => list.push({ ...node, id: k === 0 ? node.id : this.newId(), subpaths: bezierToSubpaths(toLocal(path)).map((sp) => ({ ...sp, closed: false })) })
           );
@@ -7944,7 +9351,7 @@ var VectorEditorController = (_class5 = class {
   }
   /** The paint bucket's map of the visible outlines, cached per document and gap. */
   fillMap(gap) {
-    if (_optionalChain([this, 'access', _238 => _238.fillCache, 'optionalAccess', _239 => _239.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
+    if (_optionalChain([this, 'access', _266 => _266.fillCache, 'optionalAccess', _267 => _267.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
     const map = vectorFillMap(this.doc, gap);
     this.fillCache = { doc: this.doc, gap, map };
     return map;
@@ -7958,8 +9365,8 @@ var VectorEditorController = (_class5 = class {
    */
   fillRegion(point, options = {}) {
     if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) return null;
-    const region = _optionalChain([this, 'access', _240 => _240.fillMap, 'call', _241 => _241(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _242 => _242.regionAt, 'call', _243 => _243([point.x, point.y])]);
-    if (!_optionalChain([region, 'optionalAccess', _244 => _244.length])) return null;
+    const region = _optionalChain([this, 'access', _268 => _268.fillMap, 'call', _269 => _269(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _270 => _270.regionAt, 'call', _271 => _271([point.x, point.y])]);
+    if (!_optionalChain([region, 'optionalAccess', _272 => _272.length])) return null;
     let below = null;
     const roots = new Set(this.selectedRoots());
     walkVectorNodes(this.doc.nodes, (n) => {
@@ -7985,7 +9392,7 @@ var VectorEditorController = (_class5 = class {
   /** Updates the Shape Builder / paint bucket highlight for the pointer at `p`; true when it changed. */
   hoverBuilder(p, alt) {
     if (this.tool === "paintBucket") {
-      const region = _nullishCoalesce(_optionalChain([this, 'access', _245 => _245.fillMap, 'call', _246 => _246(this.editing.fillGap), 'optionalAccess', _247 => _247.regionAt, 'call', _248 => _248([p.x, p.y])]), () => ( null));
+      const region = _nullishCoalesce(_optionalChain([this, 'access', _273 => _273.fillMap, 'call', _274 => _274(this.editing.fillGap), 'optionalAccess', _275 => _275.regionAt, 'call', _276 => _276([p.x, p.y])]), () => ( null));
       const key2 = region ? _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, region, { precision: 2 }) : null;
       if (key2 === this.builderHoverKey) return false;
       this.builderHoverKey = key2;
@@ -8093,7 +9500,7 @@ var VectorEditorController = (_class5 = class {
   /** `doc` with anchor `ref` moved to document point `to` by a Curvature-tool move. */
   curvatureMoved(doc, ref, to) {
     const node = findVectorNode(doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _249 => _249.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _277 => _277.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
     const q = this.toLocal(ref.nodeId, to, doc);
     const subpaths = node.subpaths.map((sp, i) => i === ref.subpath ? curvatureMoveAnchor(sp, ref.index, q) : sp);
     const nodes = mapTree(doc.nodes, (n) => n.id === ref.nodeId ? { ...node, subpaths } : n);
@@ -8102,7 +9509,7 @@ var VectorEditorController = (_class5 = class {
   /** `doc` with segment `ref` bent through document point `p` at parameter `t`. */
   bent(doc, ref, t, p) {
     const node = findVectorNode(doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _250 => _250.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _278 => _278.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
     const q = this.toLocal(ref.nodeId, p, doc);
     const subpaths = node.subpaths.map((sp, i) => i === ref.subpath ? bendSegment(sp, ref.segment, t, q) : sp);
     return { ...doc, nodes: mapTree(doc.nodes, (n) => n.id === ref.nodeId ? { ...node, subpaths } : n) };
@@ -8113,7 +9520,7 @@ var VectorEditorController = (_class5 = class {
    */
   bendSegment(ref, to, t = 0.5) {
     const node = this.getNode(ref.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _251 => _251.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _279 => _279.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
     if (!sp || ref.segment < 0 || ref.segment >= (sp.closed ? sp.anchors.length : sp.anchors.length - 1) || sp.anchors.length < 2) return { ok: false, message: "There is no such segment." };
     if (node.locked) return { ok: false, message: "The path is locked." };
     this.change("Bend Segment", () => {
@@ -8148,7 +9555,7 @@ var VectorEditorController = (_class5 = class {
   /** Adds an anchor on the nearest segment of `nodeId` to document point `point` (shape unchanged). */
   insertAnchorAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _252 => _252.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _280 => _280.type]) !== "path") return null;
     const hit = nearestSegment(node, this.toLocal(nodeId, point));
     if (!hit) return null;
     const { subpath, index } = insertAnchor(node.subpaths[hit.subpath], hit.segment, hit.t);
@@ -8192,7 +9599,7 @@ var VectorEditorController = (_class5 = class {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n = this.getNode(nodeId);
-      return _optionalChain([n, 'optionalAccess', _253 => _253.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n, 'optionalAccess', _281 => _281.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
     })() : this.anchors.map((r) => ({ nodeId: r.nodeId, subpath: r.subpath }));
     if (!targets.length) return { ok: false, message: "Select a path or points." };
     this.change(closed ? "Close Path" : "Open Path", () => {
@@ -8213,7 +9620,7 @@ var VectorEditorController = (_class5 = class {
       this.setDoc(
         mapTree(
           this.doc.nodes,
-          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _254 => _254.strokeWidthProfile, 'optionalAccess', _255 => _255.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
+          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _282 => _282.strokeWidthProfile, 'optionalAccess', _283 => _283.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
         )
       );
       this.anchors = [];
@@ -8351,7 +9758,7 @@ var VectorEditorController = (_class5 = class {
    */
   cutPathAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _256 => _256.type]) !== "path" || node.locked) return null;
+    if (_optionalChain([node, 'optionalAccess', _284 => _284.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
     const hit = nearestSegment(node, local);
     if (!hit) return null;
@@ -8401,7 +9808,7 @@ var VectorEditorController = (_class5 = class {
       if (n.visible === false || n.locked || parent && blocked.has(parent.id)) blocked.add(n.id);
     });
     const visible = (p) => !blocked.has(p.id);
-    if (_optionalChain([ids, 'optionalAccess', _257 => _257.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
+    if (_optionalChain([ids, 'optionalAccess', _285 => _285.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
     const box = polylineBounds(points.map(toPoint2), pad);
     if (!box) return [];
     const out = [];
@@ -8487,7 +9894,7 @@ var VectorEditorController = (_class5 = class {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _258 => _258.subpaths, 'access', _259 => _259[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _286 => _286.subpaths, 'access', _287 => _287[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -8531,19 +9938,19 @@ var VectorEditorController = (_class5 = class {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _260 => _260.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
-        } catch (e6) {
+          if (_optionalChain([data, 'optionalAccess', _288 => _288.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
+        } catch (e7) {
           nodes = null;
         }
       } else if (/<svg[\s>]/i.test(trimmed)) {
         try {
           nodes = parseVectorSvg(trimmed).nodes;
-        } catch (e7) {
+        } catch (e8) {
           nodes = null;
         }
       }
     } else nodes = this.clipboard;
-    if (!_optionalChain([nodes, 'optionalAccess', _261 => _261.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _289 => _289.length])) return [];
     const offset = _nullishCoalesce(options.offset, () => ( (text && !text.trim().startsWith("{") ? { x: 0, y: 0 } : { x: 10, y: 10 })));
     const copies = nodes.map((n) => transformVectorNode(this.freshIds(n), translateMatrix(offset.x, offset.y)));
     this.change("Paste", () => {
@@ -8594,7 +10001,7 @@ var VectorEditorController = (_class5 = class {
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
       const a = getAnchorWorld(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _262 => _262[ref.handle]]);
+      const h = _optionalChain([a, 'optionalAccess', _290 => _290[ref.handle]]);
       if (!h) continue;
       const s = this.documentToScreen(h);
       if (Math.hypot(s.x - screen.x, s.y - screen.y) <= this.hitRadius) return ref;
@@ -8714,6 +10121,13 @@ var VectorEditorController = (_class5 = class {
         const spot = this.strokeSpotAt(p);
         return spot ? { nodeId: spot.nodeId, strokeSpot: spot } : null;
       }
+      case "gradient": {
+        const a = this.getGradientAnnotator();
+        const part = a ? hitVectorGradientAnnotator(a, screen) : null;
+        if (a && part) return { nodeId: a.nodeId, gradient: part };
+        const path = this.hitPath(p);
+        return path ? { nodeId: path.id } : null;
+      }
       default:
         return null;
     }
@@ -8726,7 +10140,7 @@ var VectorEditorController = (_class5 = class {
     const shown = this.hitWidthHandleIn(screen, this.widthView());
     if (shown) return shown;
     const spot = this.strokeSpotAt(this.screenToDocument(screen));
-    return spot && spot.nodeId !== _optionalChain([this, 'access', _263 => _263.hover, 'optionalAccess', _264 => _264.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
+    return spot && spot.nodeId !== _optionalChain([this, 'access', _291 => _291.hover, 'optionalAccess', _292 => _292.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
   }
   hitWidthHandleIn(screen, view) {
     let best = null;
@@ -8781,9 +10195,9 @@ var VectorEditorController = (_class5 = class {
   downWidth(screen, p, input) {
     const hit = this.hitWidthHandle(screen);
     const spot = hit ? null : this.strokeSpotAt(p);
-    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _265 => _265.ref, 'access', _266 => _266.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _267 => _267.nodeId])));
+    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _293 => _293.ref, 'access', _294 => _294.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _295 => _295.nodeId])));
     const node = nodeId ? this.getNode(nodeId) : void 0;
-    const g = _optionalChain([node, 'optionalAccess', _268 => _268.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
+    const g = _optionalChain([node, 'optionalAccess', _296 => _296.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
     if (this.widthEdit) this.widthEdit = null;
     if (!node || node.type !== "path" || !g) {
       if (!input.shift) this.widthPoints = [];
@@ -8803,7 +10217,7 @@ var VectorEditorController = (_class5 = class {
     if (hit) {
       profile = sanitizeWidthProfile(node.strokeWidthProfile);
       ref = { nodeId: node.id, index: hit.ref.index, subpath: hit.ref.subpath };
-      t = _nullishCoalesce(_optionalChain([profile, 'access', _269 => _269[ref.index], 'optionalAccess', _270 => _270.t]), () => ( 0));
+      t = _nullishCoalesce(_optionalChain([profile, 'access', _297 => _297[ref.index], 'optionalAccess', _298 => _298.t]), () => ( 0));
       subpath = hit.ref.subpath;
       if (hit.ref.part === "center") mode = input.alt && profile.length < VECTOR_WIDTH_PROFILE_MAX_POINTS ? "copy" : "move";
       else if (input.alt) side = hit.ref.part;
@@ -8936,6 +10350,8 @@ var VectorEditorController = (_class5 = class {
         return this.downBuilder(p, input);
       case "blend":
         return this.downBlend(screen, p);
+      case "gradient":
+        return this.downGradient(screen, p, input);
       case "scissors": {
         const seg = this.nearestOutline(p);
         if (seg) this.cutPathAt(seg.nodeId, seg.point);
@@ -8958,7 +10374,7 @@ var VectorEditorController = (_class5 = class {
     let anchor = null;
     if (node.type === "path" && node.subpaths[0]) {
       const refs = node.subpaths[0].anchors.map((_, index) => ({ nodeId: node.id, subpath: 0, index }));
-      anchor = _nullishCoalesce(_optionalChain([this, 'access', _271 => _271.hitAnchor, 'call', _272 => _272(screen, refs), 'optionalAccess', _273 => _273.index]), () => ( null));
+      anchor = _nullishCoalesce(_optionalChain([this, 'access', _299 => _299.hitAnchor, 'call', _300 => _300(screen, refs), 'optionalAccess', _301 => _301.index]), () => ( null));
     }
     return { nodeId: node.id, anchor };
   }
@@ -9111,7 +10527,7 @@ var VectorEditorController = (_class5 = class {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _274 => _274.getNode, 'call', _275 => _275(this.pen.nodeId), 'optionalAccess', _276 => _276.subpaths, 'access', _277 => _277[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _302 => _302.getNode, 'call', _303 => _303(this.pen.nodeId), 'optionalAccess', _304 => _304.subpaths, 'access', _305 => _305[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -9227,6 +10643,8 @@ var VectorEditorController = (_class5 = class {
         this.viewport = { ...drag.viewport, x: drag.viewport.x + screen.x - drag.start.x, y: drag.viewport.y + screen.y - drag.start.y };
         this.notify();
         return;
+      case "gradient":
+        return this.moveGradient(drag, screen, p, input);
       case "move": {
         let dx = p.x - drag.start.x;
         let dy = p.y - drag.start.y;
@@ -9373,7 +10791,7 @@ var VectorEditorController = (_class5 = class {
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _278 => _278.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _306 => _306.type]) !== "path") return;
         const leave = { at: drag.start, constrain: input.shift ? drag.tool === "line" ? "angle" : "square" : null, curves: false };
         let end = this.snapDrawn(p, leave, input, () => drag.targets ??= this.drawingTargets(null));
         if (!this.snappedToObject && drag.tool !== "line" && !input.shift && !input.mod && this.snap.objects && drag.targets) end = this.matchShapeSize(drag.targets, drag.start, end, input.alt);
@@ -9447,14 +10865,14 @@ var VectorEditorController = (_class5 = class {
         for (const q of drag.lazy.push([p.x, p.y])) {
           if (Math.hypot(q[0] - last[0], q[1] - last[1]) * this.viewport.zoom < 1.5) continue;
           drag.points.push(q);
-          _optionalChain([drag, 'access', _279 => _279.pressures, 'optionalAccess', _280 => _280.push, 'call', _281 => _281(drag.pressure)]);
+          _optionalChain([drag, 'access', _307 => _307.pressures, 'optionalAccess', _308 => _308.push, 'call', _309 => _309(drag.pressure)]);
           moved = true;
         }
         const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _282 => _282.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _310 => _310.type]) !== "path") return;
         if (!moved) {
-          if (string && _optionalChain([this, 'access', _283 => _283.interaction, 'optionalAccess', _284 => _284.type]) === "draw") {
+          if (string && _optionalChain([this, 'access', _311 => _311.interaction, 'optionalAccess', _312 => _312.type]) === "draw") {
             this.interaction = { ...this.interaction, string: [{ x: string[0][0], y: string[0][1] }, { x: string[1][0], y: string[1][1] }] };
             this.notify();
           }
@@ -9490,8 +10908,8 @@ var VectorEditorController = (_class5 = class {
     }
     this.setGuides(res);
     return {
-      dx: _optionalChain([res, 'optionalAccess', _285 => _285.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
-      dy: _optionalChain([res, 'optionalAccess', _286 => _286.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+      dx: _optionalChain([res, 'optionalAccess', _313 => _313.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: _optionalChain([res, 'optionalAccess', _314 => _314.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
     };
   }
   /** The anchor a point drag snaps by, where it started: the grabbed one, else the moving one nearest the press. */
@@ -9570,7 +10988,7 @@ var VectorEditorController = (_class5 = class {
         if (drag.moved) return this.commit("Corner Radius", drag.before);
         if (drag.alt) {
           const kind = nextVectorCornerKind(drag.widget.kind);
-          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _287 => _287.corner, 'optionalAccess', _288 => _288.radius]), () => ( 0)), kind));
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _315 => _315.corner, 'optionalAccess', _316 => _316.radius]), () => ( 0)), kind));
           return this.commit("Corner Kind", drag.before);
         }
         const ref = drag.widget.ref;
@@ -9585,7 +11003,7 @@ var VectorEditorController = (_class5 = class {
           const several = drag.group.length > 0;
           if (drag.mode === "copy") this.widthPoints = [drag.ref];
           else if (drag.mode === "move" && several) {
-            this.widthPoints = [drag.source, ...drag.group].map((i) => ({ ...drag.ref, index: _nullishCoalesce(_optionalChain([drag, 'access', _289 => _289.renumber, 'optionalAccess', _290 => _290.get, 'call', _291 => _291(i)]), () => ( i)) }));
+            this.widthPoints = [drag.source, ...drag.group].map((i) => ({ ...drag.ref, index: _nullishCoalesce(_optionalChain([drag, 'access', _317 => _317.renumber, 'optionalAccess', _318 => _318.get, 'call', _319 => _319(i)]), () => ( i)) }));
           } else if (!several) this.widthPoints = [drag.ref];
           const label = drag.mode === "copy" ? "Copy Width Point" : drag.mode === "move" ? several ? "Move Width Points" : "Move Width Point" : several ? "Width Points" : "Width Point";
           return this.commit(label, drag.before);
@@ -9602,6 +11020,8 @@ var VectorEditorController = (_class5 = class {
       }
       case "builder":
         return this.upBuilder(drag);
+      case "gradient":
+        return this.upGradient(drag);
       case "stroke": {
         this.notify();
         if (drag.tool === "knife") this.knife(drag.points);
@@ -9627,14 +11047,14 @@ var VectorEditorController = (_class5 = class {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _292 => _292.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _320 => _320.type]) !== "path" || drag.points.length < 2) {
           this.doc = drag.before.doc;
           this.notify(true);
           return;
         }
         for (const q of drag.lazy.finish()) {
           drag.points.push(q);
-          _optionalChain([drag, 'access', _293 => _293.pressures, 'optionalAccess', _294 => _294.push, 'call', _295 => _295(drag.pressure)]);
+          _optionalChain([drag, 'access', _321 => _321.pressures, 'optionalAccess', _322 => _322.push, 'call', _323 => _323(drag.pressure)]);
         }
         const shape = this.editing.recognizeShapes ? recognizeInkShape(drag.points, { minSize: 6 / this.viewport.zoom }) : null;
         if (shape) {
@@ -9709,7 +11129,7 @@ var VectorEditorController = (_class5 = class {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _296 => _296.hover, 'optionalAccess', _297 => _297.segment, 'optionalAccess', _298 => _298.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _324 => _324.hover, 'optionalAccess', _325 => _325.segment, 'optionalAccess', _326 => _326.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
         const seg = node ? nearestSegment(node, this.toLocal(id, p)) : null;
@@ -9806,7 +11226,7 @@ var VectorEditorController = (_class5 = class {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _299 => _299.getNode, 'call', _300 => _300(this.selection[0]), 'optionalAccess', _301 => _301.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _327 => _327.getNode, 'call', _328 => _328(this.selection[0]), 'optionalAccess', _329 => _329.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -9816,6 +11236,7 @@ var VectorEditorController = (_class5 = class {
       case "Delete":
       case "Backspace":
         if (this.tool === "width" && this.widthPoints.length) return this.removeWidthPoints().ok;
+        if (this.tool === "gradient" && this.gradientEdit.stop !== null) return this.removeGradientStop(this.gradientEdit.stop).ok;
         if (this.pen) {
           const node = this.getNode(this.pen.nodeId);
           const sp = node.subpaths[this.pen.subpath];
@@ -9924,25 +11345,24 @@ function pencilPressureProfile(points, pressures) {
 }
 
 // src/vector/render.ts
-var fmt = (n) => Math.round(n * 100) / 100;
-var fmtMatrix = (m) => `matrix(${m.map((n) => Math.round(n * 1e6) / 1e6).join(" ")})`;
+var fmt4 = (n) => Math.round(n * 100) / 100;
+var fmtMatrix2 = (m) => `matrix(${m.map((n) => Math.round(n * 1e6) / 1e6).join(" ")})`;
 var VECTOR_BUILDER_HATCH_GAP = 6;
 function renderNode(stored, defs, idPrefix) {
   if (stored.visible === false) return null;
   const node = expandVectorAppearance(stored);
   if (node.type === "group") {
     const children = node.children.map((c) => renderNode(c, defs, idPrefix)).filter((c) => !!c);
-    return { kind: "group", id: node.id, ...node.transform ? { transform: fmtMatrix(node.transform) } : {}, opacity: _nullishCoalesce(node.opacity, () => ( 1)), children };
+    return { kind: "group", id: node.id, ...node.transform ? { transform: fmtMatrix2(node.transform) } : {}, opacity: _nullishCoalesce(node.opacity, () => ( 1)), children };
   }
-  const fill = vectorPaintToSvg(node.fill, `${idPrefix}fill-${node.id}`);
-  const stroke = vectorPaintToSvg(node.stroke, `${idPrefix}stroke-${node.id}`);
-  if (fill.gradient) defs.push(fill.gradient);
-  if (stroke.gradient) defs.push(stroke.gradient);
+  const fill = vectorPaintToSvg(node.fill, `${idPrefix}fill-${node.id}`, { node });
+  const stroke = vectorPaintToSvg(node.stroke, `${idPrefix}stroke-${node.id}`, { node, role: "stroke" });
+  defs.push(...fill.defs, ...stroke.defs);
   const strokeParts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${idPrefix}clip-${node.id}`) : void 0;
   return {
     kind: "path",
     id: node.id,
-    ...node.transform ? { transform: fmtMatrix(node.transform) } : {},
+    ...node.transform ? { transform: fmtMatrix2(node.transform) } : {},
     ...strokeParts ? { strokeParts } : {},
     d: vectorPathData(node),
     fill: fill.value,
@@ -9950,7 +11370,7 @@ function renderNode(stored, defs, idPrefix) {
     strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)),
     ...node.strokeLinecap ? { strokeLinecap: node.strokeLinecap } : {},
     ...node.strokeLinejoin ? { strokeLinejoin: node.strokeLinejoin } : {},
-    ..._optionalChain([node, 'access', _302 => _302.strokeDasharray, 'optionalAccess', _303 => _303.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
+    ..._optionalChain([node, 'access', _330 => _330.strokeDasharray, 'optionalAccess', _331 => _331.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1))
   };
@@ -9961,7 +11381,7 @@ function getVectorSceneRenderData(state, options = {}) {
   const nodes = state.document.nodes.map((n) => renderNode(n, defs, prefix)).filter((n) => !!n);
   const v2 = state.viewport;
   return {
-    transform: `translate(${fmt(v2.x)} ${fmt(v2.y)}) scale(${v2.zoom})`,
+    transform: `translate(${fmt4(v2.x)} ${fmt4(v2.y)}) scale(${v2.zoom})`,
     width: state.document.width,
     height: state.document.height,
     ...state.document.background ? { background: state.document.background } : {},
@@ -10004,9 +11424,9 @@ function getVectorOverlayRenderData(state) {
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _304 => _304.hover, 'optionalAccess', _305 => _305.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _332 => _332.hover, 'optionalAccess', _333 => _333.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _306 => _306.interaction, 'optionalAccess', _307 => _307.type]) !== "marquee") {
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _334 => _334.interaction, 'optionalAccess', _335 => _335.type]) !== "marquee") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
     selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
   }
@@ -10016,9 +11436,9 @@ function getVectorOverlayRenderData(state) {
     const a = getAnchorWorld(doc, ref);
     const s = toScreen(state, a);
     const closes = !!state.pen && state.pen.nodeId === ref.nodeId && state.pen.subpath === ref.subpath && ref.index === 0;
-    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( inferAnchorType(a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _308 => _308.hover, 'optionalAccess', _309 => _309.anchor]), ref), closes };
+    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( inferAnchorType(a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _336 => _336.hover, 'optionalAccess', _337 => _337.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _310 => _310.hover, 'optionalAccess', _311 => _311.anchor])) {
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _338 => _338.hover, 'optionalAccess', _339 => _339.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
@@ -10027,15 +11447,15 @@ function getVectorOverlayRenderData(state) {
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
     const a = getAnchorWorld(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _312 => _312[ref.handle]]);
+    const h = _optionalChain([a, 'optionalAccess', _340 => _340[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _313 => _313.hover, 'optionalAccess', _314 => _314.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _341 => _341.hover, 'optionalAccess', _342 => _342.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
     return [{ ref, x: s.x, y: s.y, anchorX: sa.x, anchorY: sa.y, hovered }];
   });
   let marquee = null;
-  if (_optionalChain([state, 'access', _315 => _315.interaction, 'optionalAccess', _316 => _316.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _343 => _343.interaction, 'optionalAccess', _344 => _344.type]) === "marquee") {
     const b = state.interaction.bounds;
     const tl = toScreen(state, b);
     marquee = { x: tl.x, y: tl.y, width: b.width * z, height: b.height * z };
@@ -10043,70 +11463,70 @@ function getVectorOverlayRenderData(state) {
   let penPreview = null;
   if (state.tool === "pen" && state.pen && state.pointer && !state.interaction) {
     const node = findVectorNode(doc.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _317 => _317.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _345 => _345.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
     const last = sp ? getAnchorWorld(doc, { nodeId: state.pen.nodeId, subpath: state.pen.subpath, index: sp.anchors.length - 1 }) : void 0;
     if (last) {
       const a = toScreen(state, last);
       const p = toScreen(state, state.pointer);
       const c = last.out ? toScreen(state, last.out) : null;
-      penPreview = c ? `M${fmt(a.x)} ${fmt(a.y)}Q${fmt(c.x)} ${fmt(c.y)} ${fmt(p.x)} ${fmt(p.y)}` : `M${fmt(a.x)} ${fmt(a.y)}L${fmt(p.x)} ${fmt(p.y)}`;
+      penPreview = c ? `M${fmt4(a.x)} ${fmt4(a.y)}Q${fmt4(c.x)} ${fmt4(c.y)} ${fmt4(p.x)} ${fmt4(p.y)}` : `M${fmt4(a.x)} ${fmt4(a.y)}L${fmt4(p.x)} ${fmt4(p.y)}`;
     }
   }
   const origin = toScreen(state, { x: 0, y: 0 });
   const artboard = { x: origin.x, y: origin.y, width: doc.width * z, height: doc.height * z };
   let status = null;
   const it = state.interaction;
-  if (_optionalChain([it, 'optionalAccess', _318 => _318.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _319 => _319.type]) === "move" || _optionalChain([it, 'optionalAccess', _320 => _320.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _321 => _321.type]) === "scale" || _optionalChain([it, 'optionalAccess', _322 => _322.type]) === "draw") {
+  if (_optionalChain([it, 'optionalAccess', _346 => _346.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _347 => _347.type]) === "move" || _optionalChain([it, 'optionalAccess', _348 => _348.type]) === "anchors") status = `\u0394 ${fmt4(it.dx)}, ${fmt4(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _349 => _349.type]) === "scale" || _optionalChain([it, 'optionalAccess', _350 => _350.type]) === "draw") {
     const b = it.type === "draw" ? findVectorNode(doc.nodes, it.nodeId) ? vectorNodeBounds(findVectorNode(doc.nodes, it.nodeId)) : null : state.selectionFrame;
-    if (b) status = `W ${fmt(b.width)} \xD7 H ${fmt(b.height)}`;
+    if (b) status = `W ${fmt4(b.width)} \xD7 H ${fmt4(b.height)}`;
   }
   const guides = { lines: [], labels: [] };
   if (state.guides) {
     for (const l of state.guides.lines) {
       const a = toScreen(state, { x: l.x1, y: l.y1 });
       const b = toScreen(state, { x: l.x2, y: l.y2 });
-      guides.lines.push({ kind: l.kind, x1: fmt(a.x), y1: fmt(a.y), x2: fmt(b.x), y2: fmt(b.y) });
+      guides.lines.push({ kind: l.kind, x1: fmt4(a.x), y1: fmt4(a.y), x2: fmt4(b.x), y2: fmt4(b.y) });
     }
     for (const l of state.guides.labels) {
       const p = toScreen(state, l);
-      guides.labels.push({ kind: l.kind, x: fmt(p.x), y: fmt(p.y), text: l.text });
+      guides.labels.push({ kind: l.kind, x: fmt4(p.x), y: fmt4(p.y), text: l.text });
     }
   }
   let toolStroke = null;
-  if (_optionalChain([it, 'optionalAccess', _323 => _323.type]) === "stroke") {
+  if (_optionalChain([it, 'optionalAccess', _351 => _351.type]) === "stroke") {
     const pts = it.points.map((q) => toScreen(state, q));
-    const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt(q.x)} ${fmt(q.y)}`).join("") + (pts.length === 1 ? `L${fmt(pts[0].x)} ${fmt(pts[0].y)}` : "");
-    toolStroke = { tool: it.tool, d, width: fmt(it.width * z) };
+    const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt4(q.x)} ${fmt4(q.y)}`).join("") + (pts.length === 1 ? `L${fmt4(pts[0].x)} ${fmt4(pts[0].y)}` : "");
+    toolStroke = { tool: it.tool, d, width: fmt4(it.width * z) };
   }
   let pencilString = null;
-  if (_optionalChain([it, 'optionalAccess', _324 => _324.type]) === "draw" && it.string) {
+  if (_optionalChain([it, 'optionalAccess', _352 => _352.type]) === "draw" && it.string) {
     const a = toScreen(state, it.string[0]);
     const b = toScreen(state, it.string[1]);
-    pencilString = { x1: fmt(a.x), y1: fmt(a.y), x2: fmt(b.x), y2: fmt(b.y) };
+    pencilString = { x1: fmt4(a.x), y1: fmt4(a.y), x2: fmt4(b.x), y2: fmt4(b.y) };
   }
-  const dragged = _optionalChain([it, 'optionalAccess', _325 => _325.type]) === "corner" ? it.ref : null;
+  const dragged = _optionalChain([it, 'optionalAccess', _353 => _353.type]) === "corner" ? it.ref : null;
   const cornerWidgets = getVectorCornerWidgets(state).map((w) => {
     const s = toScreen(state, w);
-    return { ref: w.ref, x: fmt(s.x), y: fmt(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _326 => _326.hover, 'optionalAccess', _327 => _327.corner]), w.ref), active: !!dragged };
+    return { ref: w.ref, x: fmt4(s.x), y: fmt4(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _354 => _354.hover, 'optionalAccess', _355 => _355.corner]), w.ref), active: !!dragged };
   });
-  if (_optionalChain([it, 'optionalAccess', _328 => _328.type]) === "corner") status = `R ${fmt(it.radius)}`;
-  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _329 => _329.hover, 'optionalAccess', _330 => _330.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  if (_optionalChain([it, 'optionalAccess', _356 => _356.type]) === "corner") status = `R ${fmt4(it.radius)}`;
+  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _357 => _357.hover, 'optionalAccess', _358 => _358.segment]) && !it ? (({ x, y }) => ({ x: fmt4(x), y: fmt4(y) }))(toScreen(state, state.hover.segment.point)) : null;
   const sc = (p) => {
     const q = toScreen(state, p);
-    return { x: fmt(q.x), y: fmt(q.y) };
+    return { x: fmt4(q.x), y: fmt4(q.y) };
   };
   const sameWidth = (a, b) => !!a && a.nodeId === b.nodeId && a.index === b.index;
   const widthPoints = getVectorWidthHandles(state).map((h) => {
     const c = sc(h);
-    const hw = _optionalChain([state, 'access', _331 => _331.hover, 'optionalAccess', _332 => _332.widthPoint]);
+    const hw = _optionalChain([state, 'access', _359 => _359.hover, 'optionalAccess', _360 => _360.widthPoint]);
     const hovered = hw && sameWidth(hw, h.ref) && hw.subpath === h.ref.subpath ? hw.part : null;
-    return { ref: h.ref, x: c.x, y: c.y, left: sc(h.left), right: sc(h.right), selected: h.selected, hovered, active: _optionalChain([it, 'optionalAccess', _333 => _333.type]) === "width" && sameWidth(it.ref, h.ref) };
+    return { ref: h.ref, x: c.x, y: c.y, left: sc(h.left), right: sc(h.right), selected: h.selected, hovered, active: _optionalChain([it, 'optionalAccess', _361 => _361.type]) === "width" && sameWidth(it.ref, h.ref) };
   });
-  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _334 => _334.hover, 'optionalAccess', _335 => _335.strokeSpot]) : null;
+  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _362 => _362.hover, 'optionalAccess', _363 => _363.strokeSpot]) : null;
   const widthSpot = spot ? { ...sc(spot.point), left: sc(spot.left), right: sc(spot.right) } : null;
-  if (_optionalChain([it, 'optionalAccess', _336 => _336.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt(it.width)}`;
+  if (_optionalChain([it, 'optionalAccess', _364 => _364.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt4(it.width)}`;
   let builder = null;
   if (state.builder) {
     const v2 = state.viewport;
@@ -10122,20 +11542,56 @@ function getVectorOverlayRenderData(state) {
       lines: state.builder.lines.map((l) => svg(_chunkVNYRI265cjs.transformBezierPath.call(void 0, l, view))),
       trail
     };
-    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _337 => _337.type]) === "builder") {
+    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _365 => _365.type]) === "builder") {
       const n = state.builder.faces.length;
       status = state.builder.mode === "erase" ? `Delete ${n} ${n === 1 ? "face" : "faces"}` : `Merge ${n} ${n === 1 ? "face" : "faces"}`;
     }
   }
   const blend = blendOverlay(state);
   if (state.tool === "blend" && !it) status = state.blendStart ? "Click another shape to blend into" : "Click a shape to blend from";
-  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder, blend };
+  let gradient = null;
+  if (state.tool === "gradient") {
+    gradient = gradientOverlay(state);
+    if (!gradient && !it) status = "Drag across a shape to set a gradient";
+    else if (_optionalChain([it, 'optionalAccess', _366 => _366.type]) === "gradient" && it.removing) status = "Release to delete the stop";
+  }
+  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder, blend, gradient };
+}
+function gradientOverlay(state) {
+  const a = getVectorGradientAnnotator(state.document, state.selection, state.viewport, state.gradientEdit.target);
+  if (!a) return null;
+  const hover = state.interaction ? null : _optionalChain([state, 'access', _367 => _367.hover, 'optionalAccess', _368 => _368.gradient]);
+  const handleHovered = (h) => _optionalChain([hover, 'optionalAccess', _369 => _369.kind]) === "handle" && hover.handle === h;
+  const pt2 = (p) => ({ x: fmt4(p.x), y: fmt4(p.y) });
+  const centred = isCentredVectorGradient(a.gradient.type);
+  const removing = _optionalChain([state, 'access', _370 => _370.interaction, 'optionalAccess', _371 => _371.type]) === "gradient" && !!state.interaction.removing;
+  return {
+    nodeId: a.nodeId,
+    type: a.gradient.type,
+    start: { ...pt2(a.start), hovered: handleHovered("start") },
+    end: { ...pt2(a.end), hovered: handleHovered(centred ? "radius" : "end"), handle: centred ? "radius" : "end" },
+    aspect: a.aspect ? { ...pt2(a.aspect), hovered: handleHovered("aspect") } : null,
+    focal: a.focal ? { ...pt2(a.focal), hovered: handleHovered("focal") } : null,
+    stops: a.stops.map((s) => ({
+      index: s.index,
+      ...pt2(s),
+      barX: fmt4(s.x - a.normal.x * VECTOR_GRADIENT_STOP_GAP),
+      barY: fmt4(s.y - a.normal.y * VECTOR_GRADIENT_STOP_GAP),
+      color: s.color,
+      opacity: _nullishCoalesce(s.opacity, () => ( 1)),
+      selected: state.gradientEdit.stop === s.index,
+      hovered: _optionalChain([hover, 'optionalAccess', _372 => _372.kind]) === "stop" && hover.index === s.index
+    })),
+    midpoints: a.midpoints.map((m) => ({ index: m.index, ...pt2(m), hovered: _optionalChain([hover, 'optionalAccess', _373 => _373.kind]) === "midpoint" && hover.index === m.index })),
+    extent: a.extent,
+    removing
+  };
 }
 function selectedBlends(state) {
   const out = /* @__PURE__ */ new Map();
   for (const id of state.selection) {
     const node = findVectorNode(state.document.nodes, id);
-    const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _338 => _338(state.document.nodes, id), 'optionalAccess', _339 => _339.parent]);
+    const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _374 => _374(state.document.nodes, id), 'optionalAccess', _375 => _375.parent]);
     if (isVectorBlendGroup(group)) out.set(group.id, group);
   }
   return [...out.values()];
@@ -10146,7 +11602,7 @@ function blendOverlay(state) {
   const doc = state.document;
   const sc = (p, m) => {
     const q = { x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] };
-    return { x: fmt(q.x), y: fmt(q.y) };
+    return { x: fmt4(q.x), y: fmt4(q.y) };
   };
   const spines = selectedBlends(state).flatMap((g) => {
     const s = vectorBlendSpine(g);
@@ -10167,11 +11623,11 @@ function blendOverlay(state) {
       const a = state.blendStart.anchor === null ? void 0 : getAnchorWorld(doc, { nodeId: from.id, subpath: 0, index: state.blendStart.anchor });
       start = { d: screenOutline(state, from, /* @__PURE__ */ new Set()), anchor: a ? sc(a, view) : null };
     }
-    const hovered = _optionalChain([state, 'access', _340 => _340.hover, 'optionalAccess', _341 => _341.nodeId]) ? findVectorNode(doc.nodes, state.hover.nodeId) : void 0;
-    if (_optionalChain([hovered, 'optionalAccess', _342 => _342.type]) === "path" && hovered.subpaths[0]) {
+    const hovered = _optionalChain([state, 'access', _376 => _376.hover, 'optionalAccess', _377 => _377.nodeId]) ? findVectorNode(doc.nodes, state.hover.nodeId) : void 0;
+    if (_optionalChain([hovered, 'optionalAccess', _378 => _378.type]) === "path" && hovered.subpaths[0]) {
       hovered.subpaths[0].anchors.forEach((_, index) => {
         const a = getAnchorWorld(doc, { nodeId: hovered.id, subpath: 0, index });
-        if (a) anchors.push({ ...sc(a, view), hovered: _optionalChain([state, 'access', _343 => _343.hover, 'optionalAccess', _344 => _344.anchor, 'optionalAccess', _345 => _345.index]) === index });
+        if (a) anchors.push({ ...sc(a, view), hovered: _optionalChain([state, 'access', _379 => _379.hover, 'optionalAccess', _380 => _380.anchor, 'optionalAccess', _381 => _381.index]) === index });
       });
     }
   }
@@ -10182,17 +11638,17 @@ function getVectorBlendControls(state) {
   const doc = state.document;
   const roots = state.selection.filter((id) => {
     const node = findVectorNode(doc.nodes, id);
-    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([locateVectorNode, 'call', _346 => _346(doc.nodes, id), 'optionalAccess', _347 => _347.parent, 'optionalAccess', _348 => _348.id]), () => ( "")));
+    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([locateVectorNode, 'call', _382 => _382(doc.nodes, id), 'optionalAccess', _383 => _383.parent, 'optionalAccess', _384 => _384.id]), () => ( "")));
   });
-  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _349 => _349(doc.nodes, id), 'optionalAccess', _350 => _350.parent, 'optionalAccess', _351 => _351.id]), () => ( null))));
-  const paths = roots.filter((id) => _optionalChain([findVectorNode, 'call', _352 => _352(doc.nodes, id), 'optionalAccess', _353 => _353.type]) === "path" && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _354 => _354(doc.nodes, id), 'optionalAccess', _355 => _355.parent])));
+  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _385 => _385(doc.nodes, id), 'optionalAccess', _386 => _386.parent, 'optionalAccess', _387 => _387.id]), () => ( null))));
+  const paths = roots.filter((id) => _optionalChain([findVectorNode, 'call', _388 => _388(doc.nodes, id), 'optionalAccess', _389 => _389.type]) === "path" && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _390 => _390(doc.nodes, id), 'optionalAccess', _391 => _391.parent])));
   const first = blends[0];
   return {
     ids: blends.map((g) => g.id),
     options: resolveVectorBlendOptions(first ? first.blend : state.blendDefaults),
     canBlend: roots.length >= 2 && parents.size === 1,
     canReplaceSpine: blends.length === 1 && paths.length === 1,
-    hasSpine: !!_optionalChain([first, 'optionalAccess', _356 => _356.blend, 'optionalAccess', _357 => _357.spine])
+    hasSpine: !!_optionalChain([first, 'optionalAccess', _392 => _392.blend, 'optionalAccess', _393 => _393.spine])
   };
 }
 function applyVectorBlendOptions(controller, patch) {
@@ -10224,7 +11680,7 @@ var VECTOR_OVERLAY_THEME = {
   builderHatchOpacity: 0.6
 };
 function vectorDiamondPath(x, y, r = VECTOR_OVERLAY_THEME.widthPointSize) {
-  return `M${fmt(x)} ${fmt(y - r)}L${fmt(x + r)} ${fmt(y)}L${fmt(x)} ${fmt(y + r)}L${fmt(x - r)} ${fmt(y)}Z`;
+  return `M${fmt4(x)} ${fmt4(y - r)}L${fmt4(x + r)} ${fmt4(y)}L${fmt4(x)} ${fmt4(y + r)}L${fmt4(x - r)} ${fmt4(y)}Z`;
 }
 function toVectorModifiers(event) {
   return { shift: !!event.shiftKey, alt: !!event.altKey, mod: !!(event.metaKey || event.ctrlKey) };
@@ -10245,7 +11701,7 @@ function isVectorTextTarget(target) {
   if (!el || typeof el !== "object") return false;
   const tag = (_nullishCoalesce(el.tagName, () => ( ""))).toUpperCase();
   if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
-  return !!el.isContentEditable || _optionalChain([el, 'access', _358 => _358.getAttribute, 'optionalCall', _359 => _359("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _394 => _394.getAttribute, 'optionalCall', _395 => _395("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -10253,12 +11709,12 @@ function getVectorSelectionStyle(state) {
     const node = findVectorNode(state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
-  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _360 => _360.selectedAnchors, 'optionalAccess', _361 => _361.length]);
+  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _396 => _396.selectedAnchors, 'optionalAccess', _397 => _397.length]);
   if (anchorMode) {
     for (const r of state.selectedAnchors) {
       if (paths.some((p) => p.id === r.nodeId)) continue;
       const node = findVectorNode(state.document.nodes, r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _362 => _362.type]) === "path") paths.push(node);
+      if (_optionalChain([node, 'optionalAccess', _398 => _398.type]) === "path") paths.push(node);
     }
   }
   if (!paths.length) return null;
@@ -10269,7 +11725,7 @@ function getVectorSelectionStyle(state) {
     for (const c of vectorCorners(p.subpaths)) {
       if (anchorMode && !state.selectedAnchors.some((r) => r.nodeId === p.id && r.subpath === c.subpath && r.index === c.index)) continue;
       const corner = p.subpaths[c.subpath].anchors[c.index].corner;
-      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _363 => _363.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _364 => _364.kind]), () => ( "round")) });
+      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _399 => _399.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _400 => _400.kind]), () => ( "round")) });
     }
   }
   const c0 = _nullishCoalesce(corners2[0], () => ( { radius: 0, kind: "round" }));
@@ -10329,6 +11785,45 @@ function vectorPaintToHex(paint) {
   const hex = m[1].length === 3 ? m[1].replace(/./g, (c) => c + c) : m[1];
   return `#${hex.toLowerCase()}`;
 }
+var VECTOR_GRADIENT_TYPE_LABELS = { linear: "Linear", radial: "Radial", conic: "Conic", reflected: "Reflected", diamond: "Diamond" };
+var VECTOR_GRADIENT_SPREAD_LABELS = { pad: "Pad", reflect: "Reflect", repeat: "Repeat" };
+var VECTOR_GRADIENT_INTERPOLATION_LABELS = { srgb: "sRGB", linear: "Linear light", oklab: "Oklab" };
+var VECTOR_STROKE_GRADIENT_MODE_LABELS = { within: "Within stroke", along: "Along stroke", across: "Across stroke" };
+function getVectorGradientEditor(state) {
+  const paths = [];
+  for (const id of state.selection) {
+    const node = findVectorNode(state.document.nodes, id);
+    if (node) paths.push(...collect(node));
+  }
+  if (!paths.length) return null;
+  const target = state.gradientEdit.target;
+  const paint = paths[0][target];
+  const gradient = isVectorGradient(paint) ? paint : null;
+  const sorted = gradient ? sortedVectorGradientStops(gradient) : [];
+  const stopIndex = state.gradientEdit.stop;
+  const stops = sorted.map((s, index) => ({ ...s, index, selected: index === stopIndex }));
+  const sel = stopIndex !== null && sorted[stopIndex] ? { ...sorted[stopIndex], index: stopIndex, last: stopIndex === sorted.length - 1 } : null;
+  const preview = gradient ? `linear-gradient(to right, ${expandVectorGradientStops(gradient).map((s) => {
+    const c = parseVectorColor(s.color);
+    const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _401 => _401[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
+    const color = c ? `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${Math.round(a * 1e3) / 1e3})` : s.color;
+    return `${color} ${Math.round(s.offset * 1e4) / 100}%`;
+  }).join(", ")})` : null;
+  return {
+    target,
+    gradient,
+    color: vectorPaintToHex(paint),
+    stops,
+    selected: sel,
+    preview,
+    type: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _402 => _402.type]), () => ( null)),
+    spread: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _403 => _403.spread]), () => ( "pad")),
+    interpolation: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _404 => _404.interpolation]), () => ( "srgb")),
+    smoothness: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _405 => _405.smoothness]), () => ( 0)),
+    strokeMode: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _406 => _406.strokeMode]), () => ( "within")),
+    mixed: paths.some((p) => JSON.stringify(_nullishCoalesce(p[target], () => ( null))) !== JSON.stringify(_nullishCoalesce(paint, () => ( null))))
+  };
+}
 var VECTOR_PATH_ACTIONS = [
   { id: "join", label: "\u22C8", title: "Join", shortcut: "J", enabled: (s, p) => s + p > 0, run: (c) => c.joinPaths() },
   { id: "average", label: "\u22B9", title: "Average Points", shortcut: "Alt+J", enabled: (_s, p) => p > 1, run: (c) => c.averageAnchors("both") },
@@ -10356,9 +11851,9 @@ function getVectorEffectsPanel(state) {
   if (!nodes.length) return null;
   const one = nodes.length === 1 ? nodes[0] : null;
   return {
-    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _365 => _365.id]), () => ( null)),
+    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _407 => _407.id]), () => ( null)),
     count: nodes.length,
-    effects: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _366 => _366.effects]), () => ( []))).map((e) => ({
+    effects: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _408 => _408.effects]), () => ( []))).map((e) => ({
       id: e.id,
       type: e.type,
       label: _nullishCoalesce(VECTOR_EFFECT_LABELS[e.type], () => ( e.type)),
@@ -10412,12 +11907,45 @@ var BLEND_PROPS = {
   linear: { type: "boolean", description: "Move anchors in straight lines instead of the rotation-aware morph." }
 };
 var checkBlendOptions = (params) => {
-  if (_optionalChain([params, 'optionalAccess', _367 => _367.spacing]) !== void 0 && !VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
-  if (_optionalChain([params, 'optionalAccess', _368 => _368.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
-  if (_optionalChain([params, 'optionalAccess', _369 => _369.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
+  if (_optionalChain([params, 'optionalAccess', _409 => _409.spacing]) !== void 0 && !VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
+  if (_optionalChain([params, 'optionalAccess', _410 => _410.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
+  if (_optionalChain([params, 'optionalAccess', _411 => _411.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
+};
+var POINT = { type: "object", properties: { x: { type: "number" }, y: { type: "number" } }, required: ["x", "y"] };
+var GRADIENT_PROPS = {
+  type: { type: "string", enum: VECTOR_GRADIENT_TYPES, description: "linear, radial, conic (an angle sweep), reflected (linear mirrored about the start) or diamond." },
+  stops: {
+    type: "array",
+    minItems: 1,
+    items: {
+      type: "object",
+      properties: {
+        offset: { type: "number", minimum: 0, maximum: 1 },
+        color: { type: "string", description: "A CSS colour." },
+        opacity: { type: "number", minimum: 0, maximum: 1 },
+        midpoint: { type: "number", minimum: 0.05, maximum: 0.95, description: "Where between this stop and the next the colours are half-mixed (default 0.5)." }
+      },
+      required: ["offset", "color"]
+    }
+  },
+  angle: { type: "number", description: "Shorthand direction in degrees (0 up, clockwise): linear / reflected direction across the box, conic start angle, diamond turn." },
+  cx: { type: "number", description: "Shorthand centre x of radial / conic / diamond gradients, a fraction of the box (default 0.5)." },
+  cy: { type: "number" },
+  r: { type: "number", description: "Shorthand radius, a fraction of the box (default 0.5)." },
+  start: { ...POINT, description: "Explicit start (centre of radial / conic / diamond), in `units`. Wins over the shorthand." },
+  end: { ...POINT, description: "Explicit end of the main axis (the radius of radial / conic / diamond)." },
+  width: { ...POINT, description: "End of the secondary axis (aspect and turn of radial / conic / diamond); default square to the main axis, as long." },
+  focal: { ...POINT, description: "Radial focal point (where t = 0), in `units`." },
+  focalRadius: { type: "number", minimum: 0, maximum: 0.99, description: "Radial focal circle radius as a fraction of the radius (SVG fr)." },
+  units: { type: "string", enum: ["objectBoundingBox", "userSpaceOnUse"], description: "Space of start / end / width / focal: fractions of the shape box (default) or the node's own coordinates." },
+  spread: { type: "string", enum: VECTOR_GRADIENT_SPREADS, description: "What paints past the ends: pad (default), reflect or repeat." },
+  interpolation: { type: "string", enum: VECTOR_GRADIENT_INTERPOLATIONS, description: "Colour mixing space: srgb (default), linear (light) or oklab." },
+  smoothness: { type: "number", minimum: 0, maximum: 1, description: "Bends the ramp along a smooth spline through the stops (0 = straight)." },
+  strokeMode: { type: "string", enum: VECTOR_STROKE_GRADIENT_MODES, description: "On strokes: within (default, like a fill), along the path or across it." }
 };
 var PAINT = {
-  description: 'A CSS colour, `null` for none, or a gradient `{ type: "linear", angle, stops: [{ offset, color }] }`.'
+  description: 'A CSS colour, `null` for none, or a gradient object: `{ type: "linear" | "radial" | "conic" | "reflected" | "diamond", stops: [{ offset, color, opacity?, midpoint? }] }` plus the shorthand `angle` / `cx, cy, r` or explicit `start`, `end`, `width`, `focal`, `focalRadius`, `units`, and `spread`, `interpolation`, `smoothness`, `strokeMode` (see vector.setGradient).',
+  anyOf: [{ type: "string" }, { type: "null" }, { type: "object", properties: GRADIENT_PROPS, required: ["type", "stops"] }]
 };
 var STYLE_PROPS = {
   fill: PAINT,
@@ -10438,6 +11966,10 @@ var STYLE_PROPS = {
 var pickStyle = (params) => {
   const out = {};
   for (const key of Object.keys(STYLE_PROPS)) if (params[key] !== void 0) out[key] = params[key];
+  for (const key of ["fill", "stroke"]) {
+    const paint = out[key];
+    if (paint && typeof paint === "object") out[key] = _nullishCoalesce(sanitizeVectorGradient(paint), () => ( fail(`${key} is not a valid gradient: give a type and at least one stop { offset, color }.`)));
+  }
   return out;
 };
 var check = (result) => {
@@ -10449,17 +11981,17 @@ function createVectorCommands(controller, options = {}) {
   const base = { group, ...options.scope ? { scope: options.scope } : {} };
   const hasSelection = () => controller.getState().selection.length ? true : "Nothing is selected.";
   const ids = (params) => {
-    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _370 => _370.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _412 => _412.ids]), () => ( controller.getState().selection));
     for (const id of list2) if (!controller.getNode(id)) fail(`There is no node "${id}".`);
     if (!list2.length) fail("Nothing is selected; pass ids.");
     return list2;
   };
-  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _371 => _371.ids, 'optionalAccess', _372 => _372.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _413 => _413.ids, 'optionalAccess', _414 => _414.length]) ? true : hasSelection();
   const anchorsOf = (refs) => {
     if (!refs) return [...controller.getState().selectedAnchors];
     for (const r of refs) {
       const node = controller.getNode(r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _373 => _373.type]) !== "path" || !_optionalChain([node, 'access', _374 => _374.subpaths, 'access', _375 => _375[r.subpath], 'optionalAccess', _376 => _376.anchors, 'access', _377 => _377[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+      if (_optionalChain([node, 'optionalAccess', _415 => _415.type]) !== "path" || !_optionalChain([node, 'access', _416 => _416.subpaths, 'access', _417 => _417[r.subpath], 'optionalAccess', _418 => _418.anchors, 'access', _419 => _419[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
     }
     return refs;
   };
@@ -10483,7 +12015,7 @@ function createVectorCommands(controller, options = {}) {
           ...n.type === "path" ? { fill: _nullishCoalesce(n.fill, () => ( null)), stroke: _nullishCoalesce(n.stroke, () => ( null)), strokeWidth: _nullishCoalesce(n.strokeWidth, () => ( 1)), d: vectorPathData(n, 2) } : { children: n.children.length },
           ...n.type === "group" && n.blend ? { blend: { ...resolveVectorBlendOptions(n.blend), spine: !!n.blend.spine, keys: vectorBlendKeys(n).map((k) => k.id) } } : {},
           ...n.blendStep ? { blendStep: true } : {},
-          ..._optionalChain([n, 'access', _378 => _378.effects, 'optionalAccess', _379 => _379.length]) ? { effects: n.effects } : {},
+          ..._optionalChain([n, 'access', _420 => _420.effects, 'optionalAccess', _421 => _421.length]) ? { effects: n.effects } : {},
           ...n.type === "group" && n.liveBoolean ? { liveBoolean: n.liveBoolean } : {},
           ...n.booleanOperation ? { booleanOperation: n.booleanOperation } : {}
         });
@@ -10555,7 +12087,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const id = controller.addPath(params.d, { ...pickStyle(params), ...params.name ? { name: params.name } : {} });
         const node = controller.getNode(id);
-        if (_optionalChain([node, 'optionalAccess', _380 => _380.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _422 => _422.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -10578,6 +12110,26 @@ function createVectorCommands(controller, options = {}) {
         return { ok: true };
       }
     },
+    {
+      ...base,
+      id: `${prefix}setGradient`,
+      label: "Gradient\u2026",
+      keywords: ["gradient", "linear", "radial", "conic", "angle", "reflected", "diamond", "stops", "midpoint", "oklab", "spread", "focal", "along stroke", "across stroke", "reverse"],
+      description: "Edits the gradient of the fill (default) or stroke of paths (groups apply to every path inside): any gradient field (missing ones keep their value; a colour becomes a gradient from it to white), `aspect` (secondary axis over main axis), `reverse` (flip the stops and midpoints), `focal` / `width` null to remove them. Midpoints, smoothness and oklab / linear interpolation export to SVG as extra stops; conic and diamond gradients as patterns.",
+      params: { type: "object", properties: { ids: IDS, target: { type: "string", enum: ["fill", "stroke"] }, ...GRADIENT_PROPS, aspect: { type: "number" }, reverse: { type: "boolean" } } },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        const { ids: _i, target, ...patch } = _nullishCoalesce(params, () => ( {}));
+        if (patch.type !== void 0 && !VECTOR_GRADIENT_TYPES.includes(patch.type)) fail(`Unknown gradient type "${patch.type}".`);
+        if (patch.stops !== void 0 && !(Array.isArray(patch.stops) && patch.stops.length)) fail("stops needs at least one { offset, color }.");
+        check(controller.setGradient(patch, { ids: ids(params), target: _nullishCoalesce(target, () => ( "fill")) }));
+        const id = ids(params)[0];
+        const node = id ? controller.getNode(id) : void 0;
+        const path = _optionalChain([node, 'optionalAccess', _423 => _423.type]) === "path" ? node : void 0;
+        return { ok: true, ...path ? { gradient: path[_nullishCoalesce(target, () => ( "fill"))] } : {} };
+      }
+    },
     {
       ...base,
       id: `${prefix}setCorners`,
@@ -10587,10 +12139,10 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { radius: { type: "number", minimum: 0 }, kind: { type: "string", enum: VECTOR_CORNER_KINDS }, ids: IDS, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        const refs = _optionalChain([params, 'optionalAccess', _381 => _381.anchors]) ? anchorsOf(params.anchors) : void 0;
-        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _382 => _382.ids]) ? ids(params) : void 0 };
-        if (_optionalChain([params, 'optionalAccess', _383 => _383.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
-        else if (_optionalChain([params, 'optionalAccess', _384 => _384.kind])) check(controller.setCornerKind(params.kind, target));
+        const refs = _optionalChain([params, 'optionalAccess', _424 => _424.anchors]) ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _425 => _425.ids]) ? ids(params) : void 0 };
+        if (_optionalChain([params, 'optionalAccess', _426 => _426.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
+        else if (_optionalChain([params, 'optionalAccess', _427 => _427.kind])) check(controller.setCornerKind(params.kind, target));
         else fail("Pass `radius` and / or `kind`.");
         return { ok: true };
       }
@@ -10625,12 +12177,12 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const target = { ids: ids(params) };
-        if (_optionalChain([params, 'optionalAccess', _385 => _385.preset])) check(controller.setWidthProfile(params.preset, target));
-        else if (_optionalChain([params, 'optionalAccess', _386 => _386.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
-        else if (_optionalChain([params, 'optionalAccess', _387 => _387.taper]) || _optionalChain([params, 'optionalAccess', _388 => _388.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
+        if (_optionalChain([params, 'optionalAccess', _428 => _428.preset])) check(controller.setWidthProfile(params.preset, target));
+        else if (_optionalChain([params, 'optionalAccess', _429 => _429.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
+        else if (_optionalChain([params, 'optionalAccess', _430 => _430.taper]) || _optionalChain([params, 'optionalAccess', _431 => _431.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
         else fail("Pass `preset`, `points`, `taper` or `wave`.");
         const node = controller.getNode(target.ids[0]);
-        return { ok: true, points: _optionalChain([node, 'optionalAccess', _389 => _389.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _432 => _432.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -10652,10 +12204,10 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        if (!_optionalChain([params, 'optionalAccess', _390 => _390.id])) fail("Pass the path `id`.");
+        if (!_optionalChain([params, 'optionalAccess', _433 => _433.id])) fail("Pass the path `id`.");
         check(controller.setWidthPoint({ nodeId: params.id, index: _nullishCoalesce(params.index, () => ( null)) }, { t: params.t, left: params.left, right: params.right }));
         const node = controller.getNode(params.id);
-        return { ok: true, points: _optionalChain([node, 'optionalAccess', _391 => _391.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _434 => _434.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -10668,7 +12220,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _392 => _392.ids]) ? ids(params) : void 0 });
+        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _435 => _435.ids]) ? ids(params) : void 0 });
         if (!created.length) fail("No selected path has a stroke.");
         return { ids: created };
       }
@@ -10785,7 +12337,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         if (params.params !== void 0 || params.enabled !== void 0) check(controller.updateEffect(params.nodeId, params.effectId, { params: params.params, enabled: params.enabled }));
         if (params.index !== void 0) check(controller.moveEffect(params.nodeId, params.effectId, params.index));
-        return { effects: _nullishCoalesce(_optionalChain([controller, 'access', _393 => _393.getNode, 'call', _394 => _394(params.nodeId), 'optionalAccess', _395 => _395.effects]), () => ( [])) };
+        return { effects: _nullishCoalesce(_optionalChain([controller, 'access', _436 => _436.getNode, 'call', _437 => _437(params.nodeId), 'optionalAccess', _438 => _438.effects]), () => ( [])) };
       }
     },
     {
@@ -10849,7 +12401,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         checkBlendOptions(params);
-        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _396 => _396.ids]) });
+        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _439 => _439.ids]) });
         if (!r.ok) fail(r.message);
         return { ok: true };
       }
@@ -10863,7 +12415,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _397 => _397.ids]) });
+        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _440 => _440.ids]) });
         if (!groups.length) fail("Select a blend to expand.");
         return { ids: groups };
       }
@@ -10877,7 +12429,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _398 => _398.ids]) });
+        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _441 => _441.ids]) });
         if (!released.length) fail("Select a blend to release.");
         return { ids: released };
       }
@@ -10891,7 +12443,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _399 => _399.ids]) });
+        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _442 => _442.ids]) });
         if (!r.ok) fail(r.message);
         return { ok: true };
       }
@@ -11005,7 +12557,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _400 => _400.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _443 => _443.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -11033,7 +12585,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { anchors: ANCHORS, keepShape: { type: "boolean" } } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _401 => _401.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _402 => _402.keepShape]) }));
+        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _444 => _444.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _445 => _445.keepShape]) }));
         return { ok: true };
       }
     },
@@ -11088,7 +12640,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS, tolerance: { type: "number", minimum: 0 } } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _403 => _403.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _404 => _404.tolerance]) }));
+        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _446 => _446.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _447 => _447.tolerance]) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -11102,7 +12654,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { axis: { type: "string", enum: ["horizontal", "vertical", "both"] }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _405 => _405.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _406 => _406.anchors]))));
+        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _448 => _448.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _449 => _449.anchors]))));
         return { ok: true };
       }
     },
@@ -11116,7 +12668,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _407 => _407.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _408 => _408.tolerance]) }));
+        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _450 => _450.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _451 => _451.tolerance]) }));
         return { ok: true };
       }
     },
@@ -11129,7 +12681,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS, amount: { type: "number", minimum: 0, maximum: 1 }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _409 => _409.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _410 => _410.amount]), refs: _optionalChain([params, 'optionalAccess', _411 => _411.anchors]) }));
+        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _452 => _452.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _453 => _453.amount]), refs: _optionalChain([params, 'optionalAccess', _454 => _454.anchors]) }));
         return { ok: true };
       }
     },
@@ -11142,14 +12694,14 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { nodeId: { type: "string" }, x: { type: "number" }, y: { type: "number" }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        if (_optionalChain([params, 'optionalAccess', _412 => _412.nodeId]) !== void 0) {
+        if (_optionalChain([params, 'optionalAccess', _455 => _455.nodeId]) !== void 0) {
           if (!controller.getNode(params.nodeId)) fail(`There is no node "${params.nodeId}".`);
           if (params.x === void 0 || params.y === void 0) fail("Pass x and y with nodeId.");
           const created = controller.cutPathAt(params.nodeId, { x: params.x, y: params.y });
           if (!created) fail("Nothing to cut there (the end of an open path, or a locked path).");
           return { ids: created };
         }
-        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _413 => _413.anchors]))));
+        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _456 => _456.anchors]))));
         return { ids: controller.getState().selection };
       }
     },
@@ -11200,7 +12752,7 @@ function createVectorCommands(controller, options = {}) {
       },
       run: (_ctx, params) => {
         const patch = {};
-        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _414 => _414[key]]) !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _457 => _457[key]]) !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -11225,7 +12777,7 @@ function createVectorCommands(controller, options = {}) {
       keywords: ["download", "save", "markup"],
       description: "Returns the document as SVG markup.",
       params: { type: "object", properties: { precision: { type: "integer", minimum: 0, maximum: 8 } } },
-      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _415 => _415.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _458 => _458.precision]) }) })
     },
     {
       ...base,
@@ -11519,5 +13071,70 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-exports.DEFAULT_VECTOR_BLEND_DISTANCE = DEFAULT_VECTOR_BLEND_DISTANCE; exports.DEFAULT_VECTOR_BLEND_STEPS = DEFAULT_VECTOR_BLEND_STEPS; exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BLEND_MAX_SMOOTH_STEPS = VECTOR_BLEND_MAX_SMOOTH_STEPS; exports.VECTOR_BLEND_MAX_STEPS = VECTOR_BLEND_MAX_STEPS; exports.VECTOR_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; exports.VECTOR_BLEND_SPACING_LABELS = VECTOR_BLEND_SPACING_LABELS; exports.VECTOR_BUILDER_HATCH_GAP = VECTOR_BUILDER_HATCH_GAP; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_EFFECT_DEFAULTS = VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_MENU = VECTOR_EFFECT_MENU; exports.VECTOR_EFFECT_PARAM_SPECS = VECTOR_EFFECT_PARAM_SPECS; exports.VECTOR_EFFECT_TYPES = VECTOR_EFFECT_TYPES; exports.VECTOR_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_MERGE_MODES = VECTOR_MERGE_MODES; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATHFINDER_ACTIONS = VECTOR_PATHFINDER_ACTIONS; exports.VECTOR_PATHFINDER_LABELS = VECTOR_PATHFINDER_LABELS; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.activeVectorEffects = activeVectorEffects; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorBlendOptions = applyVectorBlendOptions; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.applyVectorEffects = applyVectorEffects; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.clearVectorLiveBooleanCache = clearVectorLiveBooleanCache; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.correspondMorphContours = correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorEffect = createVectorEffect; exports.createVectorMorph = createVectorMorph; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.effectPathLength = effectPathLength; exports.effectPathVertexCount = effectPathVertexCount; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; exports.expandVectorAppearance = expandVectorAppearance; exports.expandVectorAppearances = expandVectorAppearances; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.foldVectorBooleanOperands = foldVectorBooleanOperands; exports.generateVectorBlendChildren = generateVectorBlendChildren; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorBlendControls = getVectorBlendControls; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorEffectsPanel = getVectorEffectsPanel; exports.getVectorEnteredGroups = getVectorEnteredGroups; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasOwnVectorAppearance = hasOwnVectorAppearance; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorAppearance = hasVectorAppearance; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertWidthPoint = insertWidthPoint; exports.interpolateMorphContours = interpolateMorphContours; exports.interpolateRigidMatrix = interpolateRigidMatrix; exports.interpolateVectorColor = interpolateVectorColor; exports.interpolateVectorPaint = interpolateVectorPaint; exports.interpolateVectorPaths = interpolateVectorPaths; exports.interpolateVectorStyle = interpolateVectorStyle; exports.interpolateWidthProfiles = interpolateWidthProfiles; exports.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorLiveBoolean = isVectorLiveBoolean; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mergePaths = mergePaths; exports.mirrorWidthProfile = mirrorWidthProfile; exports.morphContourToSubpath = morphContourToSubpath; exports.morphPathsCross = morphPathsCross; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.normalizeVectorEffectParams = normalizeVectorEffectParams; exports.offsetPaths = offsetPaths; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.pathsCenter = pathsCenter; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.puckerBloatPaths = puckerBloatPaths; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.refineMorphContour = refineMorphContour; exports.refreshVectorBlends = refreshVectorBlends; exports.releaseVectorBlend = releaseVectorBlend; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeWidthPoints = removeWidthPoints; exports.repeatPaths = repeatPaths; exports.resampleGradientStops = resampleGradientStops; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = reverseMorphContour; exports.reverseSubpath = reverseSubpath; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundCornerPaths = roundCornerPaths; exports.roundSubpaths = roundSubpaths; exports.samplePolyline = samplePolyline; exports.sanitizeVectorEffects = sanitizeVectorEffects; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.starSubpath = starSubpath; exports.strokePositionPoint = strokePositionPoint; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathToMorphContour = subpathToMorphContour; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorEffects = transformVectorEffects; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.trimIntervals = trimIntervals; exports.trimPaths = trimPaths; exports.trimPathsIndividually = trimPathsIndividually; exports.turnMorphContour = turnMorphContour; exports.twistPaths = twistPaths; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorAppearanceNodes = vectorAppearanceNodes; exports.vectorAppearanceOutline = vectorAppearanceOutline; exports.vectorAppearanceShapes = vectorAppearanceShapes; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorEnteredGroups = vectorEnteredGroups; exports.vectorFillMap = vectorFillMap; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorLiveBooleanSteps = vectorLiveBooleanSteps; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorOperandOperation = vectorOperandOperation; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorRepeaterCopies = vectorRepeaterCopies; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute; exports.wigglePaths = wigglePaths; exports.zigzagPaths = zigzagPaths;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_VECTOR_BLEND_DISTANCE = DEFAULT_VECTOR_BLEND_DISTANCE; exports.DEFAULT_VECTOR_BLEND_STEPS = DEFAULT_VECTOR_BLEND_STEPS; exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BLEND_MAX_SMOOTH_STEPS = VECTOR_BLEND_MAX_SMOOTH_STEPS; exports.VECTOR_BLEND_MAX_STEPS = VECTOR_BLEND_MAX_STEPS; exports.VECTOR_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; exports.VECTOR_BLEND_SPACING_LABELS = VECTOR_BLEND_SPACING_LABELS; exports.VECTOR_BUILDER_HATCH_GAP = VECTOR_BUILDER_HATCH_GAP; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_EFFECT_DEFAULTS = VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_MENU = VECTOR_EFFECT_MENU; exports.VECTOR_EFFECT_PARAM_SPECS = VECTOR_EFFECT_PARAM_SPECS; exports.VECTOR_EFFECT_TYPES = VECTOR_EFFECT_TYPES; exports.VECTOR_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_GRADIENT_INTERPOLATIONS = VECTOR_GRADIENT_INTERPOLATIONS; exports.VECTOR_GRADIENT_INTERPOLATION_LABELS = VECTOR_GRADIENT_INTERPOLATION_LABELS; exports.VECTOR_GRADIENT_MAX_PERIODS = VECTOR_GRADIENT_MAX_PERIODS; exports.VECTOR_GRADIENT_MIDPOINT_GAP = VECTOR_GRADIENT_MIDPOINT_GAP; exports.VECTOR_GRADIENT_MIN_STOPS = VECTOR_GRADIENT_MIN_STOPS; exports.VECTOR_GRADIENT_OFF_BAR = VECTOR_GRADIENT_OFF_BAR; exports.VECTOR_GRADIENT_SPREADS = VECTOR_GRADIENT_SPREADS; exports.VECTOR_GRADIENT_SPREAD_LABELS = VECTOR_GRADIENT_SPREAD_LABELS; exports.VECTOR_GRADIENT_STOP_GAP = VECTOR_GRADIENT_STOP_GAP; exports.VECTOR_GRADIENT_TYPES = VECTOR_GRADIENT_TYPES; exports.VECTOR_GRADIENT_TYPE_LABELS = VECTOR_GRADIENT_TYPE_LABELS; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_MERGE_MODES = VECTOR_MERGE_MODES; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATHFINDER_ACTIONS = VECTOR_PATHFINDER_ACTIONS; exports.VECTOR_PATHFINDER_LABELS = VECTOR_PATHFINDER_LABELS; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STROKE_GRADIENT_MODES = VECTOR_STROKE_GRADIENT_MODES; exports.VECTOR_STROKE_GRADIENT_MODE_LABELS = VECTOR_STROKE_GRADIENT_MODE_LABELS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.activeVectorEffects = activeVectorEffects; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorBlendOptions = applyVectorBlendOptions; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.applyVectorEffects = applyVectorEffects; exports.applyVectorGradientPatch = applyVectorGradientPatch; exports.applyVectorGradientSpread = applyVectorGradientSpread; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.clearVectorLiveBooleanCache = clearVectorLiveBooleanCache; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.convertVectorGradient = convertVectorGradient; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.correspondMorphContours = correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorEffect = createVectorEffect; exports.createVectorMorph = createVectorMorph; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.defaultVectorGradient = defaultVectorGradient; exports.effectPathLength = effectPathLength; exports.effectPathVertexCount = effectPathVertexCount; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; exports.expandVectorAppearance = expandVectorAppearance; exports.expandVectorAppearances = expandVectorAppearances; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.expandVectorGradientSpread = expandVectorGradientSpread; exports.expandVectorGradientStops = expandVectorGradientStops; exports.explicitVectorGradient = explicitVectorGradient; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.foldVectorBooleanOperands = foldVectorBooleanOperands; exports.generateVectorBlendChildren = generateVectorBlendChildren; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorBlendControls = getVectorBlendControls; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorEffectsPanel = getVectorEffectsPanel; exports.getVectorEnteredGroups = getVectorEnteredGroups; exports.getVectorGradientAnnotator = getVectorGradientAnnotator; exports.getVectorGradientEditor = getVectorGradientEditor; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.gradientMidpointRemap = gradientMidpointRemap; exports.hasExplicitGradientGeometry = hasExplicitGradientGeometry; exports.hasOwnVectorAppearance = hasOwnVectorAppearance; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorAppearance = hasVectorAppearance; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.hitVectorGradientAnnotator = hitVectorGradientAnnotator; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertVectorGradientStop = insertVectorGradientStop; exports.insertWidthPoint = insertWidthPoint; exports.interpolateMorphContours = interpolateMorphContours; exports.interpolateRigidMatrix = interpolateRigidMatrix; exports.interpolateVectorColor = interpolateVectorColor; exports.interpolateVectorPaint = interpolateVectorPaint; exports.interpolateVectorPaths = interpolateVectorPaths; exports.interpolateVectorStyle = interpolateVectorStyle; exports.interpolateWidthProfiles = interpolateWidthProfiles; exports.invertMatrix = invertMatrix; exports.isCentredVectorGradient = isCentredVectorGradient; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorGradient = isVectorGradient; exports.isVectorLiveBoolean = isVectorLiveBoolean; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mergePaths = mergePaths; exports.mirrorWidthProfile = mirrorWidthProfile; exports.morphContourToSubpath = morphContourToSubpath; exports.morphPathsCross = morphPathsCross; exports.moveAnchorHandle = moveAnchorHandle; exports.moveVectorGradientHandle = moveVectorGradientHandle; exports.moveVectorGradientStop = moveVectorGradientStop; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.normalizeVectorEffectParams = normalizeVectorEffectParams; exports.offsetPaths = offsetPaths; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorColor = parseVectorColor; exports.parseVectorSvg = parseVectorSvg; exports.pathsCenter = pathsCenter; exports.patternAttrs = patternAttrs; exports.periodicVectorGradientStops = periodicVectorGradientStops; exports.pinVectorGradient = pinVectorGradient; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.puckerBloatPaths = puckerBloatPaths; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.refineMorphContour = refineMorphContour; exports.refreshVectorBlends = refreshVectorBlends; exports.releaseVectorBlend = releaseVectorBlend; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeVectorGradientStop = removeVectorGradientStop; exports.removeWidthPoints = removeWidthPoints; exports.repeatPaths = repeatPaths; exports.resampleGradientStops = resampleGradientStops; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = reverseMorphContour; exports.reverseSubpath = reverseSubpath; exports.reverseVectorGradient = reverseVectorGradient; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundCornerPaths = roundCornerPaths; exports.roundSubpaths = roundSubpaths; exports.samplePlainStops = samplePlainStops; exports.samplePolyline = samplePolyline; exports.sampleVectorGradient = sampleVectorGradient; exports.sampleVectorGradientAt = sampleVectorGradientAt; exports.sampleVectorPaintDefAt = sampleVectorPaintDefAt; exports.sanitizeVectorEffects = sanitizeVectorEffects; exports.sanitizeVectorGradient = sanitizeVectorGradient; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setVectorGradientVector = setVectorGradientVector; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.sortedVectorGradientStops = sortedVectorGradientStops; exports.spanVectorGradientStops = spanVectorGradientStops; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.starSubpath = starSubpath; exports.strokePositionPoint = strokePositionPoint; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathToMorphContour = subpathToMorphContour; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorEffects = transformVectorEffects; exports.transformVectorGradient = transformVectorGradient; exports.transformVectorNode = transformVectorNode; exports.transformVectorPaint = transformVectorPaint; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.trimIntervals = trimIntervals; exports.trimPaths = trimPaths; exports.trimPathsIndividually = trimPathsIndividually; exports.turnMorphContour = turnMorphContour; exports.twistPaths = twistPaths; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorAppearanceNodes = vectorAppearanceNodes; exports.vectorAppearanceOutline = vectorAppearanceOutline; exports.vectorAppearanceShapes = vectorAppearanceShapes; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBoxMatrix = vectorBoxMatrix; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorEnteredGroups = vectorEnteredGroups; exports.vectorFillMap = vectorFillMap; exports.vectorGradientArea = vectorGradientArea; exports.vectorGradientAspect = vectorGradientAspect; exports.vectorGradientBarPosition = vectorGradientBarPosition; exports.vectorGradientFocalParam = vectorGradientFocalParam; exports.vectorGradientHandles = vectorGradientHandles; exports.vectorGradientMatrix = vectorGradientMatrix; exports.vectorGradientMidpointFromPosition = vectorGradientMidpointFromPosition; exports.vectorGradientMidpointPosition = vectorGradientMidpointPosition; exports.vectorGradientNeedsExpansion = vectorGradientNeedsExpansion; exports.vectorGradientParam = vectorGradientParam; exports.vectorGradientPoints = vectorGradientPoints; exports.vectorGradientRamp = vectorGradientRamp; exports.vectorGradientSvgDefs = vectorGradientSvgDefs; exports.vectorGradientTAt = vectorGradientTAt; exports.vectorGradientTargetPath = vectorGradientTargetPath; exports.vectorGradientUnitsMatrix = vectorGradientUnitsMatrix; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorLiveBooleanSteps = vectorLiveBooleanSteps; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorOperandOperation = vectorOperandOperation; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathLocalBounds = vectorPathLocalBounds; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorRepeaterCopies = vectorRepeaterCopies; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorStrokeGradientDefs = vectorStrokeGradientDefs; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute; exports.wigglePaths = wigglePaths; exports.zigzagPaths = zigzagPaths;
 //# sourceMappingURL=index.cjs.map