@pixerate/editor 0.35.0 → 0.37.0

package/dist/vector/index.cjs

@@ -27,20 +27,994 @@ var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 
 
 
-var _chunkBGNPT5PEcjs = require('../chunk-BGNPT5PE.cjs');
+
+
+
+
+
+
+
+var _chunkGVB7ZPLZcjs = require('../chunk-GVB7ZPLZ.cjs');
 
 // src/vector/types.ts
-var VECTOR_TOOLS = ["select", "direct", "pen", "pencil", "rect", "ellipse", "polygon", "star", "line", "scissors", "knife", "eraser"];
+var VECTOR_CORNER_KINDS = ["round", "inverted", "chamfer"];
+var VECTOR_ARROWHEADS = ["triangle", "arrow", "open", "circle", "square", "bar"];
+var VECTOR_TOOLS = ["select", "direct", "pen", "pencil", "rect", "ellipse", "polygon", "star", "line", "scissors", "knife", "eraser", "width"];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 
-// src/vector/geometry.ts
+// src/vector/corners.ts
 var EPS = 1e-9;
+var MIN_SINE = 1e-6;
+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 dot = (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];
+var vec = (p) => ({ x: p[0], y: p[1] });
+var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
+var Side = class {
+  
+  
+  
+  constructor(a, h1, h2, b) {
+    this.straight = onAnchor(a, h1) && onAnchor(b, h2);
+    this.curve = this.straight ? [pt(a), pt(b)] : [pt(a), pt(_nullishCoalesce(h1, () => ( a))), pt(_nullishCoalesce(h2, () => ( b))), pt(b)];
+    this.length = this.straight ? Math.hypot(b.x - a.x, b.y - a.y) : _chunkGVB7ZPLZcjs.segmentLength.call(void 0, this.curve);
+  }
+  /** Unit direction the side leaves the corner in (towards its first control point off the corner). */
+  direction() {
+    const p0 = vec(this.curve[0]);
+    for (const q of this.curve.slice(1)) {
+      const d = sub(vec(q), p0);
+      const l = len(d);
+      if (l > EPS) return mul(d, 1 / l);
+    }
+    return null;
+  }
+  /** The point `s` along the side from the corner: its parameter, position and the direction the side runs on in there. */
+  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 };
+    }
+    const t = _chunkGVB7ZPLZcjs.segmentParamAtLength.call(void 0, this.curve, s, this.length);
+    const d = vec(_chunkGVB7ZPLZcjs.segmentDerivative.call(void 0, this.curve, t));
+    const l = len(d);
+    return { t, p: vec(_chunkGVB7ZPLZcjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul(d, 1 / l) : u };
+  }
+};
+function cornerOf(sp, s, i) {
+  const n = sp.anchors.length;
+  if (n < 2 || !sp.closed && (i === 0 || i === n - 1)) return null;
+  if (n === 2 && sp.closed) return null;
+  const a = sp.anchors[i];
+  if (a.type === "smooth" || a.type === "symmetric") return null;
+  const prev = sp.anchors[(i - 1 + n) % n];
+  const next = sp.anchors[(i + 1) % n];
+  const sideU = new Side(a, a.in, prev.out, prev);
+  const sideV = new Side(a, a.out, next.in, next);
+  const u = sideU.direction();
+  const v2 = sideV.direction();
+  if (!u || !v2) return null;
+  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 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 };
+}
+var strip = ({ sideU: _u, sideV: _v, ...info }) => info;
+function vectorCornerAt(sp, index, subpath = 0) {
+  const c = cornerOf(sp, subpath, index);
+  return c ? strip(c) : null;
+}
+function vectorCorners(subpaths) {
+  const out = [];
+  subpaths.forEach((sp, s) => {
+    for (let i = 0; i < sp.anchors.length; i++) {
+      const c = cornerOf(sp, s, i);
+      if (c) out.push(strip(c));
+    }
+  });
+  return out;
+}
+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);
+function arcHandle(cos) {
+  const c = Math.max(-1, Math.min(1, cos));
+  const sinHalf = Math.sqrt(Math.max(0, (1 - c) / 2));
+  const cosHalf = Math.sqrt(Math.max(0, (1 + c) / 2));
+  return 4 / 3 * sinHalf / (1 + cosHalf);
+}
+function squareTo(a, b) {
+  const w = sub(b, mul(a, dot(a, b)));
+  const l = len(w);
+  return l > EPS ? mul(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);
+  if (!(s > EPS)) return null;
+  const a = c.sideU.at(s, c.u);
+  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 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 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 };
+}
+var radiusOf = (a) => {
+  const r = _optionalChain([a, 'access', _2 => _2.corner, 'optionalAccess', _3 => _3.radius]);
+  return typeof r === "number" && r > 0 && Number.isFinite(r) ? r : 0;
+};
+function hasVectorCorners(subpaths) {
+  return subpaths.some((sp) => sp.anchors.some((a) => radiusOf(a) > 0));
+}
+function expandVectorCornersOf(sp, subpath = 0) {
+  const n = sp.anchors.length;
+  const cuts = sp.anchors.map((a, i) => {
+    const r = radiusOf(a);
+    if (!r) return null;
+    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;
+  });
+  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) => {
+    const k = (j + 1) % n;
+    if (k === 0 && !sp.closed) return void 0;
+    const b = sp.anchors[k];
+    const from = cuts[j];
+    const to = cuts[k];
+    if (!from && !to) return void 0;
+    if (onAnchor(a, a.out) && onAnchor(b, b.in)) return { out: null, in: null };
+    const s0 = from ? from.tv : 0;
+    const s1 = to ? 1 - to.tu : 1;
+    const seg = [pt(a), pt(_nullishCoalesce(a.out, () => ( a))), pt(_nullishCoalesce(b.in, () => ( b))), pt(b)];
+    const part = _chunkGVB7ZPLZcjs.subSegment.call(void 0, seg, s0, Math.max(s0, s1));
+    return { out: vec(part[1]), in: vec(part[2]) };
+  });
+  const anchors = [];
+  const sources = [];
+  let closing = null;
+  const handleIn = (i, a) => {
+    const t = trimmed[(i - 1 + n) % n];
+    return t ? t.in : _nullishCoalesce(a.in, () => ( null));
+  };
+  const handleOut = (i, a) => {
+    const t = trimmed[i];
+    return t ? t.out : _nullishCoalesce(a.out, () => ( null));
+  };
+  sp.anchors.forEach((a, i) => {
+    const c = cuts[i];
+    if (!c) {
+      anchors.push(withHandles({ x: a.x, y: a.y, ...a.type ? { type: a.type } : {} }, handleIn(i, a), handleOut(i, a)));
+      sources.push(i);
+      return;
+    }
+    const start = withHandles({ x: c.start.x, y: c.start.y }, handleIn(i, a), c.out);
+    const end = withHandles({ x: c.end.x, y: c.end.y }, c.in, handleOut(i, a));
+    if (i === 0 && sp.closed) closing = start;
+    else {
+      anchors.push(start);
+      sources.push(i);
+    }
+    anchors.push(end);
+    sources.push(i);
+  });
+  if (closing) {
+    anchors.push(closing);
+    sources.push(0);
+  }
+  return { subpath: { closed: sp.closed, anchors }, sources };
+}
+function withHandles(a, hin, hout) {
+  if (hin && !onAnchor(a, hin)) a.in = { x: hin.x, y: hin.y };
+  if (hout && !onAnchor(a, hout)) a.out = { x: hout.x, y: hout.y };
+  return a;
+}
+function plain(a) {
+  if (!("corner" in a)) return a;
+  const { corner: _c, ...rest } = a;
+  return rest;
+}
+function expandVectorCorners(subpaths) {
+  if (!hasVectorCorners(subpaths)) return subpaths;
+  return subpaths.map((sp, s) => sp.anchors.some((a) => radiusOf(a) > 0) ? expandVectorCornersOf(sp, s).subpath : sp);
+}
+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])));
+  if (r <= 0 && !kind) return rest;
+  return { ...rest, corner: { radius: r, ...k && k !== "round" ? { kind: k } : {} } };
+}
+function nextVectorCornerKind(kind) {
+  return kind === "inverted" ? "chamfer" : kind === "chamfer" ? "round" : "inverted";
+}
+function setSubpathCorners(sp, radius, kind) {
+  return { closed: sp.closed, anchors: sp.anchors.map((a) => setAnchorCorner(a, radius, kind)) };
+}
+
+// src/vector/width.ts
+var VECTOR_WIDTH_PROFILE_MAX_POINTS = 64;
+var VECTOR_WIDTH_PROFILE_MAX_SCALE = 1e3;
+var VECTOR_WIDTH_SAME_T = 1e-6;
+var sym = (t, s) => ({ t, left: s, right: s });
+var VECTOR_WIDTH_PRESETS = [
+  { id: "uniform", label: "Uniform", points: [] },
+  { id: "taperStart", label: "Taper start", points: [sym(0, 0), sym(1, 1)] },
+  { id: "taperEnd", label: "Taper end", points: [sym(0, 1), sym(1, 0)] },
+  { id: "taperBoth", label: "Taper both", points: [sym(0, 0), sym(0.5, 1), sym(1, 0)] },
+  // Full width at the ends, swelling to twice the width in the middle.
+  { id: "bulge", label: "Bulge", points: [sym(0, 1), sym(0.5, 2), sym(1, 1)] },
+  // Full width at the ends, pinched to a quarter in the middle.
+  { id: "pinch", label: "Pinch", points: [sym(0, 1), sym(0.5, 0.25), sym(1, 1)] },
+  // A round head a fifth of the way along, then a long taper to the end.
+  { id: "teardrop", label: "Teardrop", points: [sym(0, 0), sym(0.2, 1), sym(1, 0)] },
+  // Two swells between narrow necks.
+  { id: "wave", label: "Wave", points: [sym(0, 0.3), sym(0.25, 1), sym(0.5, 0.3), sym(0.75, 1), sym(1, 0.3)] },
+  // A pen stroke: a quick press, a slow lift.
+  { id: "pressure", label: "Pressure", points: [sym(0, 0.15), sym(0.12, 0.85), sym(0.45, 1), sym(0.8, 0.7), sym(1, 0.05)] }
+];
+var VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESETS.map((p) => p.id);
+var clean = (v2, max) => typeof v2 === "number" && Number.isFinite(v2) ? Math.min(Math.max(v2, 0), max) : null;
+function sanitizeWidthProfile(points) {
+  if (!Array.isArray(points)) return [];
+  const out = [];
+  for (const p of points) {
+    if (!p || typeof p !== "object") continue;
+    const t = clean(p.t, 1);
+    const l = clean(p.left, VECTOR_WIDTH_PROFILE_MAX_SCALE);
+    const r = clean(p.right, VECTOR_WIDTH_PROFILE_MAX_SCALE);
+    if (t === null || l === null && r === null) continue;
+    out.push({ t, left: _nullishCoalesce(l, () => ( r)), right: _nullishCoalesce(r, () => ( l)) });
+    if (out.length >= VECTOR_WIDTH_PROFILE_MAX_POINTS) break;
+  }
+  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);
+}
+function secant(pts, i, k) {
+  const a = pts[i];
+  const b = pts[i + 1];
+  return a && b && b.t - a.t > 1e-12 ? (b[k] - a[k]) / (b.t - a.t) : 0;
+}
+function tangent(pts, i, k) {
+  const last = pts.length - 1;
+  if (i <= 0) return secant(pts, 0, k);
+  if (i >= last) return secant(pts, last - 1, k);
+  const d0 = secant(pts, i - 1, k);
+  const d1 = secant(pts, i, k);
+  return d0 * d1 <= 0 ? 0 : 2 * d0 * d1 / (d0 + d1);
+}
+function interp(pts, t, k) {
+  const first = pts[0];
+  const last = pts[pts.length - 1];
+  if (!(t > first.t)) return first[k];
+  if (t >= last.t) return last[k];
+  let i = 0;
+  while (i + 1 < pts.length && pts[i + 1].t <= t) i++;
+  const a = pts[i];
+  const b = pts[i + 1];
+  const h = b.t - a.t;
+  if (h <= 1e-12) return b[k];
+  const u = (t - a.t) / h;
+  const u2 = u * u;
+  const u3 = u2 * u;
+  const w = (2 * u3 - 3 * u2 + 1) * a[k] + (u3 - 2 * u2 + u) * h * tangent(pts, i, k) + (3 * u2 - 2 * u3) * b[k] + (u3 - u2) * h * tangent(pts, i + 1, k);
+  return Math.max(0, w);
+}
+function widthProfileAt(points, t) {
+  if (!_optionalChain([points, 'optionalAccess', _8 => _8.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;
+  return points.reduce((m, p) => Math.max(m, p.left, p.right), 0);
+}
+function widthProfilePreset(id) {
+  const p = VECTOR_WIDTH_PRESETS.find((q) => q.id === id);
+  return p ? p.points.map((q) => ({ ...q })) : null;
+}
+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"));
+}
+function reverseWidthProfile(points) {
+  return points.map((p) => ({ t: 1 - p.t, left: p.right, right: p.left })).reverse();
+}
+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)];
+}
+function insertWidthPoint(points, t, sides = {}, 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 p = {
+    t: tt,
+    left: _nullishCoalesce(clean(sides.left, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.left)),
+    right: _nullishCoalesce(clean(sides.right, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.right))
+  };
+  const same = pts.findIndex((q) => Math.abs(q.t - tt) <= VECTOR_WIDTH_SAME_T);
+  if (same >= 0 && !options.step) {
+    pts[same] = { ...p, t: pts[same].t };
+    return { points: pts, index: same };
+  }
+  let i = 0;
+  while (i < pts.length && pts[i].t <= tt) i++;
+  if (pts.length >= VECTOR_WIDTH_PROFILE_MAX_POINTS) return { points: pts, index: Math.max(0, i - 1) };
+  pts.splice(i, 0, p);
+  return { points: pts, index: i };
+}
+function setWidthPoint(points, index, patch) {
+  const pts = points.map((p2) => ({ ...p2 }));
+  const p = pts[index];
+  if (!p) return pts;
+  if (typeof patch.t === "number" && Number.isFinite(patch.t)) {
+    const lo = index > 0 ? pts[index - 1].t : 0;
+    const hi = index < pts.length - 1 ? pts[index + 1].t : 1;
+    p.t = Math.min(Math.max(patch.t, lo), Math.max(hi, lo));
+  }
+  const l = clean(patch.left, VECTOR_WIDTH_PROFILE_MAX_SCALE);
+  const r = clean(patch.right, VECTOR_WIDTH_PROFILE_MAX_SCALE);
+  if (l !== null) p.left = l;
+  if (r !== null) p.right = r;
+  return pts;
+}
+function removeWidthPoints(points, indices) {
+  const drop = new Set(indices);
+  return points.filter((_, i) => !drop.has(i)).map((p) => ({ ...p }));
+}
+function ease(u, e) {
+  const x = Math.min(Math.max(u, 0), 1);
+  const round = Math.sqrt(Math.max(0, 1 - (1 - x) * (1 - x)));
+  return x + (round - x) * Math.min(Math.max(e, 0), 1);
+}
+function taperWaveFactor(t, taper, wave) {
+  let k = 1;
+  if (taper) {
+    let ls = Math.max(0, _nullishCoalesce(taper.startLength, () => ( 0)));
+    let le = Math.max(0, _nullishCoalesce(taper.endLength, () => ( 0)));
+    if (ls + le > 1) {
+      const f = 1 / (ls + le);
+      ls *= f;
+      le *= f;
+    }
+    const sw = Math.min(Math.max(_nullishCoalesce(taper.startWidth, () => ( 0)), 0), 1);
+    const ew = Math.min(Math.max(_nullishCoalesce(taper.endWidth, () => ( 0)), 0), 1);
+    if (ls > 0 && t < ls) k = Math.min(k, sw + (1 - sw) * ease(t / ls, _nullishCoalesce(taper.startEase, () => ( 0))));
+    if (le > 0 && t > 1 - le) k = Math.min(k, ew + (1 - ew) * ease((1 - t) / le, _nullishCoalesce(taper.endEase, () => ( 0))));
+  }
+  if (wave) {
+    const cycles = _nullishCoalesce(wave.cycles, () => ( 4));
+    const amount = Math.min(Math.max(_nullishCoalesce(wave.amount, () => ( 0.5)), 0), 1);
+    if (cycles > 0 && amount > 0) {
+      const ph = 2 * Math.PI * t * cycles + (_nullishCoalesce(wave.phase, () => ( 0))) * Math.PI / 180;
+      k *= 1 - amount * (0.5 - 0.5 * Math.cos(ph));
+    }
+  }
+  return k;
+}
+function generateWidthProfile(options) {
+  const cycles = options.wave ? Math.max(0, _nullishCoalesce(options.wave.cycles, () => ( 4))) : 0;
+  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];
+  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);
+  return kept.map(([t, k]) => sym(t, k));
+}
+function simplifySamples(samples, tolerance, max) {
+  if (samples.length <= 2) return samples.slice();
+  const keep = new Array(samples.length).fill(false);
+  keep[0] = keep[samples.length - 1] = true;
+  const stack = [[0, samples.length - 1]];
+  while (stack.length) {
+    const [a, b] = stack.pop();
+    const [ta, va] = samples[a];
+    const [tb, vb] = samples[b];
+    let worst = -1;
+    let err = tolerance;
+    for (let i = a + 1; i < b; i++) {
+      const [t, v2] = samples[i];
+      const lin = tb - ta > 1e-12 ? va + (vb - va) * (t - ta) / (tb - ta) : va;
+      const e = Math.abs(v2 - lin);
+      if (e > err) {
+        err = e;
+        worst = i;
+      }
+    }
+    if (worst >= 0) {
+      keep[worst] = true;
+      stack.push([a, worst], [worst, b]);
+    }
+  }
+  let out = samples.filter((_, i) => keep[i]);
+  while (out.length > max) out = out.filter((_, i) => i === 0 || i === out.length - 1 || i % 2 === 0);
+  return out;
+}
+var VECTOR_PRESSURE_NOMINAL = 0.5;
+function pressureWidthProfile(samples, options = {}) {
+  const raw = samples.filter((s) => Number.isFinite(s.t) && Number.isFinite(s.pressure)).map((s) => [Math.min(Math.max(s.t, 0), 1), Math.max(0.05, Math.min(1, Math.max(0, s.pressure)) / VECTOR_PRESSURE_NOMINAL)]);
+  if (raw.length < 2) return [];
+  if (raw.every((s) => Math.abs(s[1] - raw[0][1]) < 1e-6)) return [];
+  return simplifySamples(raw, _nullishCoalesce(options.tolerance, () => ( 0.02)), VECTOR_WIDTH_PROFILE_MAX_POINTS).map(([t, k]) => sym(t, Math.round(k * 1e3) / 1e3));
+}
+
+// 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 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]);
+var unitOf = (v2) => {
+  const l = Math.hypot(v2[0], v2[1]);
+  return l > 0 ? [v2[0] / l, v2[1] / l] : [1, 0];
+};
+var leftNormal = (d) => [d[1], -d[0]];
+function flatten(segments, closed, tol) {
+  const pts = [];
+  const corner = [];
+  const push = (p, isCorner) => {
+    const last = pts[pts.length - 1];
+    if (last && dist(last, p) <= 1e-9) {
+      corner[corner.length - 1] ||= isCorner;
+      return;
+    }
+    pts.push(p);
+    corner.push(isCorner);
+  };
+  for (const seg of segments) {
+    const flat = _chunkGVB7ZPLZcjs.flattenChain.call(void 0, [seg], tol);
+    if (dist(seg[0], seg[seg.length - 1]) <= 1e-12 && flat.length > 1) flat.push(seg[seg.length - 1]);
+    flat.forEach((p, i) => push(p, i === 0 || i === flat.length - 1));
+  }
+  if (closed && pts.length > 2 && dist(pts[0], pts[pts.length - 1]) > 1e-9) push(pts[0], true);
+  if (pts.length < 2) return null;
+  let total = 0;
+  for (let i = 1; i < pts.length; i++) total += dist(pts[i - 1], pts[i]);
+  if (!(total > 0)) return null;
+  const step = Math.max(total / SAMPLES_PER_SUBPATH, tol);
+  const fine = [pts[0]];
+  const fineCorner = [corner[0]];
+  for (let i = 1; i < pts.length; i++) {
+    const n = Math.max(1, Math.ceil(dist(pts[i - 1], pts[i]) / step));
+    for (let k = 1; k <= n; k++) {
+      fine.push(k === n ? pts[i] : lerp(pts[i - 1], pts[i], k / n));
+      fineCorner.push(k === n ? corner[i] : false);
+    }
+  }
+  const s = [0];
+  for (let i = 1; i < fine.length; i++) s.push(s[i - 1] + dist(fine[i - 1], fine[i]));
+  return { pts: fine, s, corner: fineCorner, closed };
+}
+function dashIntervals(pattern, offset, len2) {
+  let pat = pattern.map((v2) => Number.isFinite(v2) ? Math.max(0, v2) : 0);
+  if (pat.length % 2 === 1) pat = [...pat, ...pat];
+  const period = pat.reduce((a, b) => a + b, 0);
+  if (pat.length < 2 || !(period > 1e-9) || !(len2 > 0)) return [[0, len2]];
+  let pos = ((Number.isFinite(offset) ? offset : 0) % period + period) % period;
+  let idx = 0;
+  while (pos >= pat[idx]) {
+    pos -= pat[idx];
+    idx = (idx + 1) % pat.length;
+  }
+  const out = [];
+  let s = 0;
+  let guard = 0;
+  while (s < len2 && guard++ < MAX_DASHES * pat.length) {
+    const e = Math.min(s + pat[idx] - pos, len2);
+    if (idx % 2 === 0 && e >= s) out.push([s, e]);
+    s += pat[idx] - pos;
+    pos = 0;
+    idx = (idx + 1) % pat.length;
+  }
+  return out;
+}
+function at(poly, t) {
+  let i = 1;
+  while (i < poly.pts.length - 1 && poly.s[i] <= t) i++;
+  const a = poly.s[i - 1];
+  const b = poly.s[i];
+  const u = b > a ? Math.min(Math.max((t - a) / (b - a), 0), 1) : 0;
+  return [lerp(poly.pts[i - 1], poly.pts[i], u), i];
+}
+function arcPoints(c, a0, sweep, r0, r1, tol) {
+  const r = Math.max(r0, r1);
+  if (!(r > tol * 0.5) || !Number.isFinite(sweep)) return [];
+  const stepAngle = 2 * Math.acos(Math.min(Math.max(1 - tol / r, -1), 1));
+  const n = Math.min(128, Math.max(2, Math.ceil(Math.abs(sweep) / Math.max(stepAngle, 1e-3))));
+  const out = [];
+  for (let k = 1; k < n; k++) {
+    const f = k / n;
+    const a = a0 + sweep * f;
+    const rr = r0 + (r1 - r0) * f;
+    out.push([c[0] + Math.cos(a) * rr, c[1] + Math.sin(a) * rr]);
+  }
+  return out;
+}
+function crossing(a0, a1, b0, b1) {
+  const r = sub2(a1, a0);
+  const q = sub2(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 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;
+}
+function variableStrokeRings(path, options) {
+  const half = options.width / 2;
+  if (!(half > 0) || !Number.isFinite(half)) return [];
+  const tol = options.tolerance && options.tolerance > 0 ? options.tolerance : 0.05;
+  const join = _nullishCoalesce(options.join, () => ( "miter"));
+  const cap = _nullishCoalesce(options.cap, () => ( "butt"));
+  const miterLimit = options.miterLimit && options.miterLimit >= 1 ? options.miterLimit : 4;
+  const rings = [];
+  const push = (out, p) => {
+    const last = out[out.length - 1];
+    if (!last || dist(last, p) > 1e-12) out.push(p);
+  };
+  for (const contour of _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path)) {
+    if (!contour.segments.length) continue;
+    const poly = flatten(contour.segments, contour.closed, Math.min(tol, half) / 4);
+    if (!poly) continue;
+    const len2 = poly.s[poly.s.length - 1];
+    const sides = (s) => {
+      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 whole = intervals.length === 1 && intervals[0][0] <= 0 && intervals[0][1] >= len2;
+    for (const [a, b] of intervals) {
+      const [pa, ia] = at(poly, a);
+      const [pb, ib] = at(poly, b);
+      const pts = [{ p: pa, s: a, corner: poly.corner[0] && a <= 0 }];
+      for (let i = ia; i < ib; i++) pts.push({ p: poly.pts[i], s: poly.s[i], corner: poly.corner[i] });
+      pts.push({ p: pb, s: b, corner: false });
+      const run = pts.filter((q, i) => i === 0 || dist(q.p, pts[i - 1].p) > 1e-9);
+      if (run.length < 2) {
+        const [l, r] = sides(a);
+        const w2 = (l + r) / 2;
+        if (cap === "round" && w2 > 0) rings.push([[pa[0] + w2, pa[1]], ...arcPoints(pa, 0, 2 * Math.PI, w2, w2, tol)]);
+        continue;
+      }
+      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)));
+      const normals = dirs.map(leftNormal);
+      const w = run.map((q) => sides(q.s));
+      const side = (sigma) => {
+        const k = sigma > 0 ? 0 : 1;
+        const S = (i) => along(run[i].p, normals[i], sigma * w[i][k]);
+        const E = (i) => along(run[i + 1].p, normals[i], sigma * w[i + 1][k]);
+        const out = [S(0)];
+        for (let i = 0; i < m; i++) {
+          const seam = i === m - 1;
+          if (seam && !closed) {
+            push(out, E(i));
+            break;
+          }
+          const j = seam ? 0 : i + 1;
+          const p = run[i + 1].p;
+          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 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) {
+            push(out, e);
+            if (!seam) push(out, st);
+            continue;
+          }
+          const uturn = Math.abs(cross2) < 1e-12;
+          const outer = uturn ? sigma > 0 : cross2 * sigma > 0;
+          if (!outer) {
+            const x = seam ? null : crossing(out[out.length - 1], e, st, E(j));
+            if (x) push(out, x);
+            else {
+              push(out, e);
+              push(out, p);
+              if (!seam) push(out, st);
+            }
+            continue;
+          }
+          push(out, e);
+          const theta = uturn ? Math.PI : Math.atan2(cross2, dot2);
+          const r = (r0 + r1) / 2;
+          const kind = run[i + 1].corner || seam && poly.corner[0] ? join : "round";
+          if (r > 1e-9) {
+            if (kind === "round") {
+              if (r * (1 - Math.cos(Math.abs(theta) / 2)) > tol * 0.25) {
+                for (const q of arcPoints(p, Math.atan2(e[1] - p[1], e[0] - p[0]), theta, r0, r1, tol)) push(out, q);
+              }
+            } else if (kind === "miter") {
+              const halfCos = Math.cos(theta / 2);
+              const bis = [normals[i][0] + normals[j][0], normals[i][1] + normals[j][1]];
+              const bl = Math.hypot(bis[0], bis[1]);
+              if (halfCos > 1e-6 && 1 / halfCos <= miterLimit && bl > 1e-9) push(out, along(p, bis, sigma * r / halfCos / bl));
+            }
+          }
+          if (!seam) push(out, st);
+        }
+        if (closed && out.length > 1 && dist(out[0], out[out.length - 1]) <= 1e-12) out.pop();
+        return out;
+      };
+      const left = side(1);
+      const right = side(-1);
+      if (closed) {
+        rings.push(left, right.reverse());
+        continue;
+      }
+      const capPoints = (atStart) => {
+        if (cap === "butt") return [];
+        const i = atStart ? 0 : m;
+        const d = atStart ? dirs[0] : dirs[m - 1];
+        const [l, r] = w[i];
+        if (!(l + r > 1e-9)) return [];
+        const p = run[i].p;
+        const n = leftNormal(d);
+        const L = along(p, n, l);
+        const R = along(p, n, -r);
+        if (cap === "round") {
+          const a0 = Math.atan2(d[1], d[0]) + (atStart ? Math.PI / 2 : -Math.PI / 2);
+          return arcPoints(p, a0, Math.PI, atStart ? r : l, atStart ? l : r, tol);
+        }
+        const ext = (l + r) / 2;
+        const o = atStart ? [-d[0], -d[1]] : d;
+        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);
+      if (ring.length > 2) rings.push(ring);
+    }
+  }
+  return rings;
+}
+function variableStrokeOutline(path, options) {
+  const pieces = variableStrokeRings(path, options);
+  if (!pieces.length) return [];
+  const tol = options.tolerance && options.tolerance > 0 ? options.tolerance : 0.05;
+  let polygons;
+  try {
+    polygons = _chunkGVB7ZPLZcjs.polygonBoolean.call(void 0, "union", [{ rings: pieces, fillRule: "nonzero" }]);
+  } catch (e2) {
+    return [];
+  }
+  const out = [];
+  for (const polygon2 of polygons) {
+    for (const ring of polygon2) {
+      if (ring.length < 3) continue;
+      const cubics = _chunkGVB7ZPLZcjs.fitCubics.call(void 0, ring, tol, { closed: true, cornerAngleDeg: 25 });
+      if (!cubics.length) continue;
+      out.push({ type: "M", x: cubics[0].p0[0], y: cubics[0].p0[1] });
+      cubics.forEach((c, i) => {
+        if (_chunkGVB7ZPLZcjs.isStraightCubic.call(void 0, c, tol * 0.02)) {
+          if (i < cubics.length - 1) out.push({ type: "L", x: c.p3[0], y: c.p3[1] });
+        } else out.push({ type: "C", x1: c.p1[0], y1: c.p1[1], x2: c.p2[0], y2: c.p2[1], x: c.p3[0], y: c.p3[1] });
+      });
+      out.push({ type: "Z" });
+    }
+  }
+  return out;
+}
+function nearestStrokePosition(path, p, only) {
+  let best = null;
+  _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path).forEach((c, ci) => {
+    if (!c.segments.length || only !== void 0 && ci !== only) return;
+    const lengths = c.segments.map((s) => _chunkGVB7ZPLZcjs.segmentLength.call(void 0, s));
+    const total = lengths.reduce((a, b) => a + b, 0);
+    if (!(total > 0)) return;
+    let acc = 0;
+    c.segments.forEach((seg, si) => {
+      const near2 = _chunkGVB7ZPLZcjs.segmentNearest.call(void 0, seg, p);
+      if (!best || near2.distance < best.distance) {
+        const s = acc + _chunkGVB7ZPLZcjs.segmentLength.call(void 0, seg, 0, near2.t);
+        const tan = _chunkGVB7ZPLZcjs.segmentTangent.call(void 0, seg, near2.t);
+        const pt2 = seg.length === 2 ? lerp(seg[0], seg[1], near2.t) : evalSeg(seg, near2.t);
+        const n = leftNormal([tan[0], tan[1]]);
+        const side = (p[0] - pt2[0]) * n[0] + (p[1] - pt2[1]) * n[1] >= 0 ? "left" : "right";
+        best = { contour: ci, t: Math.min(Math.max(s / total, 0), 1), distance: near2.distance, side, point: pt2, tangent: [tan[0], tan[1]], length: total };
+      }
+      acc += lengths[si];
+    });
+  });
+  return best;
+}
+function evalSeg(seg, t) {
+  let pts = seg.map((q) => [q[0], q[1]]);
+  while (pts.length > 1) pts = pts.slice(1).map((q, i) => lerp(pts[i], q, t));
+  return pts[0];
+}
+function strokePositionPoint(path, index, t) {
+  const c = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path)[index];
+  if (!_optionalChain([c, 'optionalAccess', _22 => _22.segments, 'access', _23 => _23.length])) return null;
+  const lengths = c.segments.map((s) => _chunkGVB7ZPLZcjs.segmentLength.call(void 0, s));
+  const total = lengths.reduce((a, b) => a + b, 0);
+  let want = Math.min(Math.max(t, 0), 1) * total;
+  for (let i = 0; i < c.segments.length; i++) {
+    const seg = c.segments[i];
+    if (want <= lengths[i] + 1e-12 || i === c.segments.length - 1) {
+      let lo = 0;
+      let hi = 1;
+      const target = Math.min(want, lengths[i]);
+      for (let k = 0; k < 40; k++) {
+        const mid = (lo + hi) / 2;
+        if (_chunkGVB7ZPLZcjs.segmentLength.call(void 0, seg, 0, mid) < target) lo = mid;
+        else hi = mid;
+      }
+      const u = (lo + hi) / 2;
+      const tan = _chunkGVB7ZPLZcjs.segmentTangent.call(void 0, seg, u);
+      return { point: evalSeg(seg, u), tangent: [tan[0], tan[1]] };
+    }
+    want -= lengths[i];
+  }
+  return null;
+}
+
+// src/vector/stroke.ts
+var KAPPA = 0.5522847498307936;
+var NOTCH = 0.7;
+function isClosedBezierShape(path) {
+  const contours = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
+  return contours.length > 0 && contours.every((c) => c.closed);
+}
+function effectiveStrokeAlign(style, closedShape) {
+  const a = _nullishCoalesce(style.strokeAlign, () => ( "center"));
+  return closedShape ? a : "center";
+}
+function strokeWidthProfileOf(style) {
+  if (!_optionalChain([style, 'access', _24 => _24.strokeWidthProfile, 'optionalAccess', _25 => _25.length])) return null;
+  const p = sanitizeWidthProfile(style.strokeWidthProfile);
+  return isUniformWidthProfile(p) ? null : p;
+}
+function hasStrokeExtras(style) {
+  return (_nullishCoalesce(style.strokeAlign, () => ( "center"))) !== "center" || !!style.startArrow || !!style.endArrow || !!strokeWidthProfileOf(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 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 } : {} });
+  return _chunkGVB7ZPLZcjs.outlineStroke.call(void 0, parts.line, { width: parts.drawWidth, join, cap, ...dash, ...tolerance ? { 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;
+  return Math.max(0.25, (_nullishCoalesce(style.strokeWidth, () => ( 1))) * s);
+}
+function arrowheadInset(kind, hw, cap) {
+  const l = 4 * hw;
+  const solid = (back) => Math.max(back / 2, cap);
+  switch (kind) {
+    case "triangle":
+    case "circle":
+    case "square":
+      return solid(l);
+    case "arrow":
+      return solid(NOTCH * l);
+    case "bar":
+      return solid(0.75 * hw);
+    case "open":
+      return Math.max(hw * Math.sqrt(l * l + l * l / 4) / (l / 2), cap);
+  }
+}
+var v = (x, y) => ({ x, y });
+var plus = (a, b, k = 1) => ({ x: a.x + b.x * k, y: a.y + b.y * k });
+var unit = (a) => {
+  const l = Math.hypot(a.x, a.y);
+  return l > 0 ? { x: a.x / l, y: a.y / l } : { x: 1, y: 0 };
+};
+function polygon(pts) {
+  return [{ type: "M", x: pts[0].x, y: pts[0].y }, ...pts.slice(1).map((p) => ({ type: "L", x: p.x, y: p.y })), { type: "Z" }];
+}
+function circle(c, r) {
+  const k = r * KAPPA;
+  const { x, y } = c;
+  return [
+    { type: "M", x: x + r, y },
+    { type: "C", x1: x + r, y1: y + k, x2: x + k, y2: y + r, x, y: y + r },
+    { type: "C", x1: x - k, y1: y + r, x2: x - r, y2: y + k, x: x - r, y },
+    { type: "C", x1: x - r, y1: y - k, x2: x - k, y2: y - r, x, y: y - r },
+    { type: "C", x1: x + k, y1: y - r, x2: x + r, y2: y - k, x: x + r, y },
+    { type: "Z" }
+  ];
+}
+function arrowheadPath(kind, tip, dir, hw) {
+  const n = v(-dir.y, dir.x);
+  const l = 4 * hw;
+  const half = l / 2;
+  const base = plus(tip, dir, -l);
+  switch (kind) {
+    case "triangle":
+      return polygon([tip, plus(base, n, half), plus(base, n, -half)]);
+    case "arrow":
+      return polygon([tip, plus(base, n, half), plus(tip, dir, -NOTCH * l), plus(base, n, -half)]);
+    case "open": {
+      const t = hw;
+      const a = plus(base, n, half);
+      const b = plus(base, n, -half);
+      const ua = unit(plus(a, tip, -1));
+      const ub = unit(plus(b, tip, -1));
+      const na = v(-ua.y, ua.x);
+      const nb = v(ub.y, -ub.x);
+      const inner = plus(tip, dir, -(t * Math.hypot(a.x - tip.x, a.y - tip.y)) / half);
+      return polygon([tip, a, plus(a, na, t), inner, plus(b, nb, t), b]);
+    }
+    case "circle":
+      return circle(plus(tip, dir, -half), half);
+    case "square":
+      return polygon([plus(tip, n, half), plus(base, n, half), plus(base, n, -half), plus(tip, n, -half)]);
+    case "bar": {
+      const t = 0.75 * hw;
+      return polygon([plus(tip, n, half), plus(plus(tip, n, half), dir, -t), plus(plus(tip, n, -half), dir, -t), plus(tip, n, -half)]);
+    }
+  }
+}
+var toVec = (p) => ({ x: p[0], y: p[1] });
+var segLen = (s) => _chunkGVB7ZPLZcjs.segmentLength.call(void 0, s);
+function endOf(segs, atStart) {
+  const long = (s2) => segLen(s2) > 1e-9;
+  if (atStart) {
+    const s2 = _nullishCoalesce(segs.find(long), () => ( segs[0]));
+    const t2 = _chunkGVB7ZPLZcjs.segmentTangent.call(void 0, s2, 0);
+    return { p: toVec(segs[0][0]), out: v(-t2[0], -t2[1]) };
+  }
+  const s = _nullishCoalesce([...segs].reverse().find(long), () => ( segs[segs.length - 1]));
+  const t = _chunkGVB7ZPLZcjs.segmentTangent.call(void 0, s, 1);
+  const last = segs[segs.length - 1];
+  return { p: toVec(last[last.length - 1]), out: v(t[0], t[1]) };
+}
+function pointAlong(segs, fromStart, dist4) {
+  const order = fromStart ? segs : [...segs].reverse();
+  let acc = 0;
+  for (const s of order) {
+    const l = segLen(s);
+    if (acc + l >= dist4) {
+      const want = fromStart ? dist4 - acc : l - (dist4 - acc);
+      const pts = _chunkGVB7ZPLZcjs.trimSegments.call(void 0, [s], 0, want);
+      const p = pts.length ? pts[0][pts[0].length - 1] : s[0];
+      return toVec(p);
+    }
+    acc += l;
+  }
+  return null;
+}
+function vectorStrokeParts(path, style) {
+  const width = _nullishCoalesce(style.strokeWidth, () => ( 1));
+  const contours = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
+  const closedShape = contours.length > 0 && contours.every((c) => c.closed);
+  const align = effectiveStrokeAlign(style, closedShape);
+  const drawWidth = align === "center" ? width : width * 2;
+  const heads = [];
+  if (!contours.length || !style.startArrow && !style.endArrow) return { align, line: path, drawWidth, heads };
+  const first = contours[0];
+  const last = contours[contours.length - 1];
+  const cap = capExtent(style, width);
+  const tipMode = style.arrowAlign === "tip";
+  const trims = contours.map(() => [0, 0]);
+  const place = (end, contour, ci) => {
+    const kind = end === "start" ? style.startArrow : style.endArrow;
+    if (!kind || contour.closed) return;
+    const hw = arrowheadWeight(style, end);
+    const inset = arrowheadInset(kind, hw, cap);
+    const atStart = end === "start";
+    const { p, out } = endOf(contour.segments, atStart);
+    let tip;
+    let dir;
+    if (tipMode) {
+      const q = pointAlong(contour.segments, atStart, inset);
+      const d = q ? v(p.x - q.x, p.y - q.y) : null;
+      dir = d && Math.hypot(d.x, d.y) > 1e-9 ? unit(d) : out;
+      tip = p;
+      trims[ci][atStart ? 0 : 1] = inset;
+    } else {
+      tip = plus(p, out, inset);
+      dir = out;
+    }
+    heads.push({ end, kind, tip, dir, inset, path: arrowheadPath(kind, tip, dir, hw) });
+  };
+  place("start", first, 0);
+  place("end", last, contours.length - 1);
+  if (!tipMode || !heads.length) return { align, line: path, drawWidth, heads };
+  const trimmed = contours.map((c, i) => {
+    const [s0, s1] = trims[i];
+    if (!s0 && !s1) return c;
+    const lengths = c.segments.map(segLen);
+    const total = lengths.reduce((a, b) => a + b, 0);
+    return { closed: false, segments: total - s1 > s0 ? _chunkGVB7ZPLZcjs.trimSegments.call(void 0, c.segments, s0, total - s1, lengths) : [] };
+  });
+  return { align, line: _chunkGVB7ZPLZcjs.contoursToPath.call(void 0, trimmed), drawWidth, heads };
+}
+function vectorStrokeOutlinePath(path, style) {
+  const parts = vectorStrokeParts(path, style);
+  const stroke = vectorStrokeLineArea(parts, style);
+  const fill = { path, fillRule: _nullishCoalesce(style.fillRule, () => ( "nonzero")) };
+  let area = stroke;
+  if (parts.align === "inside") area = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "intersection", [stroke, fill]).path;
+  else if (parts.align === "outside") area = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "difference", [stroke, fill]).path;
+  if (!parts.heads.length) return area;
+  return _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "union", [area, ...parts.heads.map((h) => h.path)]).path;
+}
+function hitTestVectorStroke(path, p, style, tolerance = 0) {
+  const parts = vectorStrokeParts(path, style);
+  const point = [p.x, p.y];
+  const width = _nullishCoalesce(style.strokeWidth, () => ( 1));
+  for (const h of parts.heads) {
+    if (_chunkGVB7ZPLZcjs.pointInBezierPath.call(void 0, h.path, point) || tolerance > 0 && _chunkGVB7ZPLZcjs.distanceToBezierPath.call(void 0, h.path, point) <= tolerance) return true;
+  }
+  if (!parts.line.length) return false;
+  const profile = strokeWidthProfileOf(style);
+  let d;
+  let reach = width / 2;
+  if (profile) {
+    const near2 = nearestStrokePosition(parts.line, point);
+    if (!near2) return false;
+    d = near2.distance;
+    const w = widthProfileAt(profile, near2.t);
+    reach = width / 2 * (near2.side === "left" ? w.left : w.right);
+    if (parts.align !== "center") reach *= 2;
+    const atEnd = near2.t <= 1e-9 || near2.t >= 1 - 1e-9;
+    if (atEnd && (style.strokeLinecap === "round" || style.strokeLinecap === "square") && d > reach) {
+      reach = Math.max(reach, width / 2 * (w.left + w.right) / 2);
+    }
+  } else {
+    d = _chunkGVB7ZPLZcjs.distanceToBezierPath.call(void 0, parts.line, point);
+    if (parts.align !== "center") reach = width;
+  }
+  if (parts.align === "center") return d <= reach + tolerance;
+  if (d > reach + tolerance) return false;
+  if (d <= tolerance) return true;
+  const inside = _chunkGVB7ZPLZcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(style.fillRule, () => ( "nonzero")));
+  return parts.align === "inside" ? inside : !inside;
+}
+function vectorStrokeReach(style) {
+  const width = (_nullishCoalesce(style.strokeWidth, () => ( 1))) * widthProfileMaxScale(strokeWidthProfileOf(style));
+  const align = _nullishCoalesce(style.strokeAlign, () => ( "center"));
+  let reach = align === "center" ? width / 2 : align === "outside" ? width : 0;
+  if (style.strokeLinejoin !== "round" && style.strokeLinejoin !== "bevel") reach *= 4;
+  for (const end of ["start", "end"]) {
+    if (end === "start" ? style.startArrow : style.endArrow) reach = Math.max(reach, 8 * arrowheadWeight(style, end) + width);
+  }
+  return reach;
+}
+
+// src/vector/geometry.ts
+var EPS2 = 1e-9;
 var cloneAnchor = (a) => ({
   x: a.x,
   y: a.y,
   ...a.in ? { in: { x: a.in.x, y: a.in.y } } : {},
   ...a.out ? { out: { x: a.out.x, y: a.out.y } } : {},
-  ...a.type && a.type !== "corner" ? { type: a.type } : {}
+  ...a.type && a.type !== "corner" ? { type: a.type } : {},
+  ...a.corner ? { corner: { ...a.corner } } : {}
 });
 var cloneSubpath = (s) => ({ anchors: s.anchors.map(cloneAnchor), closed: s.closed });
 function cloneVectorNode(node) {
@@ -58,7 +1032,7 @@ function hasPaint(paint) {
   return true;
 }
 var handleOf = (a, side) => _nullishCoalesce(a[side], () => ( { x: a.x, y: a.y }));
-var isOnAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
+var isOnAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS2 && Math.abs(h.y - a.y) < EPS2;
 function subpathSegmentCount(sp) {
   const n = sp.anchors.length;
   if (n < 2) return 0;
@@ -72,9 +1046,9 @@ function subpathSegment(sp, i) {
   const c2 = handleOf(b, "in");
   return [[a.x, a.y], [c1.x, c1.y], [c2.x, c2.y], [b.x, b.y]];
 }
-function subpathsToBezier(subpaths) {
+function subpathsToBezier(subpaths, options = {}) {
   const out = [];
-  for (const sp of subpaths) {
+  for (const sp of options.corners === false ? subpaths : expandVectorCorners(subpaths)) {
     if (sp.anchors.length === 0) continue;
     const first = sp.anchors[0];
     out.push({ type: "M", x: first.x, y: first.y });
@@ -94,7 +1068,7 @@ function vectorNodeToBezier(node) {
 }
 function vectorPathData(input, precision = 3) {
   const subpaths = Array.isArray(input) ? input : input.subpaths;
-  return _chunkBGNPT5PEcjs.bezierPathToSvg.call(void 0, subpathsToBezier(subpaths), { precision });
+  return _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, subpathsToBezier(subpaths), { precision });
 }
 function inferAnchorType(a) {
   if (isOnAnchor(a, a.in) || isOnAnchor(a, a.out)) return "corner";
@@ -104,13 +1078,13 @@ function inferAnchorType(a) {
   const oy = a.out.y - a.y;
   const li = Math.hypot(ix, iy);
   const lo = Math.hypot(ox, oy);
-  const cross = (ix * oy - iy * ox) / (li * lo);
-  const dot = (ix * ox + iy * oy) / (li * lo);
-  if (Math.abs(cross) > 1e-3 || dot > 0) return "corner";
+  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";
   return Math.abs(li - lo) <= 1e-3 * Math.max(li, lo) ? "symmetric" : "smooth";
 }
 function bezierToSubpaths(input) {
-  const path = _chunkBGNPT5PEcjs.toBezierPath.call(void 0, input);
+  const path = _chunkGVB7ZPLZcjs.toBezierPath.call(void 0, input);
   const out = [];
   let current = null;
   const last = () => current.anchors[current.anchors.length - 1];
@@ -207,14 +1181,14 @@ function nodeMatrix(node) {
 function vectorPathWorldBezier(node, parent = IDENTITY_MATRIX) {
   const m = multiplyMatrices(nodeMatrix(node), parent);
   const path = subpathsToBezier(node.subpaths);
-  return isIdentityMatrix(m) ? path : _chunkBGNPT5PEcjs.transformBezierPath.call(void 0, path, m);
+  return isIdentityMatrix(m) ? path : _chunkGVB7ZPLZcjs.transformBezierPath.call(void 0, path, m);
 }
 function vectorNodeBounds(node, parent = IDENTITY_MATRIX) {
   if (node.type === "group") {
     const m = multiplyMatrices(nodeMatrix(node), parent);
     return unionBounds(node.children.map((c) => vectorNodeBounds(c, m)));
   }
-  const b = _chunkBGNPT5PEcjs.bezierPathBounds.call(void 0, vectorPathWorldBezier(node, parent));
+  const b = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, vectorPathWorldBezier(node, parent));
   if (!b) return null;
   return { x: b.minX, y: b.minY, width: b.maxX - b.minX, height: b.maxY - b.minY };
 }
@@ -248,9 +1222,13 @@ function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX) {
   const path = vectorPathWorldBezier(node, parent);
   if (path.length === 0) return false;
   const point = [p.x, p.y];
-  if (hasPaint(node.fill) && _chunkBGNPT5PEcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
-  const reach = (hasPaint(node.stroke) ? (_nullishCoalesce(node.strokeWidth, () => ( 1))) / 2 : 0) + tolerance;
-  return _chunkBGNPT5PEcjs.distanceToBezierPath.call(void 0, path, point) <= reach;
+  if (hasPaint(node.fill) && _chunkGVB7ZPLZcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
+  if (hasPaint(node.stroke)) return hitTestVectorStroke(path, p, node, tolerance);
+  return _chunkGVB7ZPLZcjs.distanceToBezierPath.call(void 0, path, point) <= tolerance;
+}
+function vectorStrokeOutline(node, parent = IDENTITY_MATRIX) {
+  if (!hasPaint(node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return [];
+  return vectorStrokeOutlinePath(vectorPathWorldBezier(node, parent), node);
 }
 function hitTestVectorNodes(nodes, p, tolerance = 0) {
   for (let i = nodes.length - 1; i >= 0; i--) {
@@ -266,10 +1244,10 @@ function nearestSegment(node, p) {
     const count = subpathSegmentCount(sp);
     for (let i = 0; i < count; i++) {
       const seg = subpathSegment(sp, i);
-      const hit = _chunkBGNPT5PEcjs.segmentNearest.call(void 0, seg, [p.x, p.y]);
+      const hit = _chunkGVB7ZPLZcjs.segmentNearest.call(void 0, seg, [p.x, p.y]);
       if (!best || hit.distance < best.distance) {
-        const pt = _chunkBGNPT5PEcjs.segmentPoint.call(void 0, seg, hit.t);
-        best = { subpath: s, segment: i, t: hit.t, point: { x: pt[0], y: pt[1] }, distance: hit.distance };
+        const pt2 = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, hit.t);
+        best = { subpath: s, segment: i, t: hit.t, point: { x: pt2[0], y: pt2[1] }, distance: hit.distance };
       }
     }
   });
@@ -303,8 +1281,8 @@ function invertMatrix(m) {
   if (!det || !Number.isFinite(det)) return IDENTITY_MATRIX;
   return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
 }
-function applyMatrixLinear(m, v) {
-  return { x: m[0] * v.x + m[2] * v.y, y: m[1] * v.x + m[3] * v.y };
+function applyMatrixLinear(m, v2) {
+  return { x: m[0] * v2.x + m[2] * v2.y, y: m[1] * v2.x + m[3] * v2.y };
 }
 function matrixRotation(m) {
   const [a, b, c, d] = m;
@@ -328,8 +1306,10 @@ function bakeIntoGeometry(node, m) {
   if (isIdentityMatrix(m)) return node;
   if (node.type === "group") return { ...node, children: node.children.map((c) => transformVectorNode(c, m)) };
   const path = node;
+  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _28 => _28.strokeWidthProfile, 'optionalAccess', _29 => _29.length]);
   return {
     ...path,
+    ...mirrored ? { strokeWidthProfile: mirrorWidthProfile(path.strokeWidthProfile) } : {},
     subpaths: path.subpaths.map((sp) => ({
       closed: sp.closed,
       anchors: sp.anchors.map((a) => {
@@ -338,6 +1318,7 @@ function bakeIntoGeometry(node, m) {
         if (a.in) next.in = applyMatrix(m, a.in);
         if (a.out) next.out = applyMatrix(m, a.out);
         if (a.type) next.type = a.type;
+        if (a.corner) next.corner = { ...a.corner };
         return next;
       })
     }))
@@ -389,12 +1370,12 @@ function moveAnchorHandle(a, side, pos, breakHandles = false) {
   if (breakHandles) delete next.type;
   const dx = pos.x - a.x;
   const dy = pos.y - a.y;
-  const len = Math.hypot(dx, dy);
+  const len2 = Math.hypot(dx, dy);
   if (type === "symmetric") next[other] = { x: a.x - dx, y: a.y - dy };
-  else if (type === "smooth" && len > EPS) {
+  else if (type === "smooth" && len2 > EPS2) {
     const o = a[other];
-    const olen = o ? Math.hypot(o.x - a.x, o.y - a.y) : len;
-    next[other] = { x: a.x - dx / len * olen, y: a.y - dy / len * olen };
+    const olen = o ? Math.hypot(o.x - a.x, o.y - a.y) : len2;
+    next[other] = { x: a.x - dx / len2 * olen, y: a.y - dy / len2 * olen };
   }
   if (isOnAnchor(next, next.in)) delete next.in;
   if (isOnAnchor(next, next.out)) delete next.out;
@@ -421,15 +1402,15 @@ function convertAnchor(sp, index, type) {
   else if (prev && next) dir = { x: next.x - prev.x, y: next.y - prev.y };
   else if (next) dir = { x: next.x - a.x, y: next.y - a.y };
   else if (prev) dir = { x: a.x - prev.x, y: a.y - prev.y };
-  if (!dir || Math.hypot(dir.x, dir.y) < EPS) return { anchors, closed: sp.closed };
+  if (!dir || Math.hypot(dir.x, dir.y) < EPS2) return { anchors, closed: sp.closed };
   const dl = Math.hypot(dir.x, dir.y);
   const ux = dir.x / dl;
   const uy = dir.y / dl;
   lenIn = a.in && !isOnAnchor(a, a.in) ? Math.hypot(a.in.x - a.x, a.in.y - a.y) : prev ? Math.hypot(prev.x - a.x, prev.y - a.y) / 3 : 0;
   lenOut = a.out && !isOnAnchor(a, a.out) ? Math.hypot(a.out.x - a.x, a.out.y - a.y) : next ? Math.hypot(next.x - a.x, next.y - a.y) / 3 : 0;
   if (type === "symmetric") lenIn = lenOut = (lenIn + lenOut) / 2 || Math.max(lenIn, lenOut);
-  if (lenIn > EPS) a.in = { x: a.x - ux * lenIn, y: a.y - uy * lenIn };
-  if (lenOut > EPS) a.out = { x: a.x + ux * lenOut, y: a.y + uy * lenOut };
+  if (lenIn > EPS2) a.in = { x: a.x - ux * lenIn, y: a.y - uy * lenIn };
+  if (lenOut > EPS2) a.out = { x: a.x + ux * lenOut, y: a.y + uy * lenOut };
   a.type = type;
   return { anchors, closed: sp.closed };
 }
@@ -439,7 +1420,7 @@ function insertAnchor(sp, segment, t) {
   const ia = segment;
   const ib = (segment + 1) % n;
   const seg = subpathSegment(sp, segment);
-  const [left, right] = _chunkBGNPT5PEcjs.splitSegment.call(void 0, seg, t);
+  const [left, right] = _chunkGVB7ZPLZcjs.splitSegment.call(void 0, seg, t);
   const mid = left[left.length - 1];
   const anchor = { x: mid[0], y: mid[1] };
   if (seg.length === 4) {
@@ -465,37 +1446,24 @@ function reverseSubpath(sp) {
     if (a.out) next.in = { ...a.out };
     if (a.in) next.out = { ...a.in };
     if (a.type) next.type = a.type;
+    if (a.corner) next.corner = { ...a.corner };
     return next;
   });
   return { anchors, closed: sp.closed };
 }
-var KAPPA = 0.5522847498307936;
-function rectSubpath(b, radius = 0) {
+var KAPPA2 = 0.5522847498307936;
+function rectSubpath(b, radius = 0, kind) {
   const { x, y, width: w, height: h } = b;
-  const r = Math.max(0, Math.min(radius, w / 2, h / 2));
-  if (r <= EPS) {
-    return { anchors: [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }], closed: true };
-  }
-  const k = r * KAPPA;
-  const anchors = [
-    { x: x + r, y, in: { x: x + r - k, y } },
-    { x: x + w - r, y, out: { x: x + w - r + k, y } },
-    { x: x + w, y: y + r, in: { x: x + w, y: y + r - k } },
-    { x: x + w, y: y + h - r, out: { x: x + w, y: y + h - r + k } },
-    { x: x + w - r, y: y + h, in: { x: x + w - r + k, y: y + h } },
-    { x: x + r, y: y + h, out: { x: x + r - k, y: y + h } },
-    { x, y: y + h - r, in: { x, y: y + h - r + k } },
-    { x, y: y + r, out: { x, y: y + r - k } }
-  ];
-  return { anchors, closed: true };
+  const sp = { anchors: [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }], closed: true };
+  return radius > 0 ? setSubpathCorners(sp, radius, kind) : sp;
 }
 function ellipseSubpath(b) {
   const rx = b.width / 2;
   const ry = b.height / 2;
   const cx = b.x + rx;
   const cy = b.y + ry;
-  const kx = rx * KAPPA;
-  const ky = ry * KAPPA;
+  const kx = rx * KAPPA2;
+  const ky = ry * KAPPA2;
   return {
     closed: true,
     anchors: [
@@ -543,15 +1511,80 @@ function roundSubpaths(subpaths, precision = 3) {
 }
 
 // src/vector/svg.ts
+function vectorCornersAttribute(subpaths, precision = 3) {
+  const out = [];
+  subpaths.forEach(
+    (sp, s) => sp.anchors.forEach((a, i) => {
+      if (!a.corner || !(a.corner.radius > 0)) return;
+      out.push(`${s}.${i}:${_chunkGVB7ZPLZcjs.formatNumber.call(void 0, a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
+    })
+  );
+  return out.join(" ");
+}
+function applyVectorCornersAttribute(subpaths, value) {
+  for (const item of value.trim().split(/\s+/)) {
+    const m = /^(\d+)\.(\d+):([\d.eE+-]+)(?::([a-z]+))?$/.exec(item);
+    if (!m) continue;
+    const a = _optionalChain([subpaths, 'access', _30 => _30[+m[1]], 'optionalAccess', _31 => _31.anchors, 'access', _32 => _32[+m[2]]]);
+    const radius = parseFloat(m[3]);
+    if (!a || !(radius > 0)) continue;
+    const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
+    a.corner = { radius, ...kind && kind !== "round" ? { kind } : {} };
+  }
+  return subpaths;
+}
 var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 function 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: _chunkBGNPT5PEcjs.gradientToSvgDef.call(void 0, paint, gradientId) };
+  return { value: `url(#${gradientId})`, gradient: _chunkGVB7ZPLZcjs.gradientToSvgDef.call(void 0, paint, gradientId) };
+}
+var partsCache = /* @__PURE__ */ new WeakMap();
+function vectorStrokeSvgParts(node, clipId, precision = 3) {
+  if (!hasPaint(node.stroke) || !hasStrokeExtras(node)) return void 0;
+  const hit = partsCache.get(node);
+  if (hit && hit.clipId === clipId && hit.precision === precision) return hit.parts;
+  const parts = computeStrokeSvgParts(node, clipId, precision);
+  partsCache.set(node, { clipId, precision, parts });
+  return parts;
+}
+function computeStrokeSvgParts(node, clipId, precision) {
+  const path = subpathsToBezier(node.subpaths);
+  const parts = vectorStrokeParts(path, node);
+  const profiled = !!strokeWidthProfileOf(node);
+  if (parts.align === "center" && !parts.heads.length && !profiled) return void 0;
+  let clip = null;
+  if (parts.align !== "center") {
+    const b = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, path);
+    const pad = vectorStrokeReach(node) + 1;
+    const bounds = b ? { x: round2(b.minX - pad), y: round2(b.minY - pad), width: round2(b.maxX - b.minX + 2 * pad), height: round2(b.maxY - b.minY + 2 * pad) } : { x: 0, y: 0, width: 0, height: 0 };
+    clip = { kind: parts.align === "inside" ? "clip" : "mask", id: clipId, bounds };
+  }
+  return {
+    align: parts.align,
+    d: _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, parts.line, { precision }),
+    width: parts.drawWidth,
+    ...profiled && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0 ? { outline: _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, vectorStrokeLineArea(parts, node), { precision }) } : {},
+    clip,
+    heads: parts.heads.map((h) => _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, h.path, { precision }))
+  };
 }
+function widthProfileToAttribute(points, precision = 4) {
+  return points.map((p) => [p.t, p.left, p.right].map((n) => _chunkGVB7ZPLZcjs.formatNumber.call(void 0, n, precision)).join(",")).join(";");
+}
+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 };
+    })
+  );
+}
+var round2 = (n) => Math.round(n * 100) / 100;
 function gradientMarkup(def) {
   const tag = def.type === "radial" ? "radialGradient" : "linearGradient";
-  const attrs = Object.entries(def.attrs).map(([k, v]) => ` ${k}="${escapeAttr(String(v))}"`).join("");
+  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}>`;
 }
@@ -561,11 +1594,11 @@ function vectorDocumentToSvg(doc, options = {}) {
   const pretty = options.pretty !== false;
   const defs = [];
   const lines = [];
-  const num = (n) => _chunkBGNPT5PEcjs.formatNumber.call(void 0, n, precision);
+  const num = (n) => _chunkGVB7ZPLZcjs.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) => _chunkBGNPT5PEcjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
+    if (node.transform) out2 += ` transform="matrix(${node.transform.map((n) => _chunkGVB7ZPLZcjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
     if (node.opacity !== void 0 && node.opacity < 1) out2 += ` opacity="${num(node.opacity)}"`;
     if (node.visible === false) out2 += ` display="none"`;
     return out2;
@@ -582,15 +1615,61 @@ function vectorDocumentToSvg(doc, options = {}) {
     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));
-    let attrs = `${common(node)} d="${vectorPathData(node, precision)}" fill="${escapeAttr(fill.value)}"`;
-    if (node.fillRule === "evenodd") attrs += ` fill-rule="evenodd"`;
-    if (stroke.value !== "none") {
-      attrs += ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num(_nullishCoalesce(node.strokeWidth, () => ( 1)))}"`;
-      if (node.strokeLinecap && node.strokeLinecap !== "butt") attrs += ` stroke-linecap="${node.strokeLinecap}"`;
-      if (node.strokeLinejoin && node.strokeLinejoin !== "miter") attrs += ` stroke-linejoin="${node.strokeLinejoin}"`;
-      if (_optionalChain([node, 'access', _2 => _2.strokeDasharray, 'optionalAccess', _3 => _3.length])) attrs += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
-    }
-    lines.push(`${indent(depth)}<path${attrs}/>`);
+    const d = vectorPathData(node, precision);
+    const corners2 = vectorCornersAttribute(node.subpaths, precision);
+    const live = corners2 ? ` data-vector-d="${_chunkGVB7ZPLZcjs.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)}"`;
+      if (node.strokeLinecap && node.strokeLinecap !== "butt") out2 += ` stroke-linecap="${node.strokeLinecap}"`;
+      if (node.strokeLinejoin && node.strokeLinejoin !== "miter") out2 += ` stroke-linejoin="${node.strokeLinejoin}"`;
+      if (_optionalChain([node, 'access', _33 => _33.strokeDasharray, 'optionalAccess', _34 => _34.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      return out2;
+    };
+    const parts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${prefix}clip-${node.id}`, precision) : void 0;
+    if (!parts) {
+      lines.push(`${indent(depth)}<path${common(node)} d="${d}"${fillAttrs}${stroke.value !== "none" ? lineAttrs(_nullishCoalesce(node.strokeWidth, () => ( 1))) : ""}${live}/>`);
+      return;
+    }
+    let data = ` data-vector-path="" data-vector-stroke-width="${num(_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)}"`;
+    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', _35 => _35.strokeDasharray, 'optionalAccess', _36 => _36.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+    }
+    lines.push(`${indent(depth)}<g${common(node)}${data}>`);
+    lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}"${fillAttrs}${live}/>`);
+    if (options.strokes === "outline") {
+      const area = _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
+      lines.push(`${indent(depth + 1)}<path data-vector-part="stroke-outline" d="${area}" fill="${escapeAttr(stroke.value)}"/>`);
+    } else {
+      let clip = "";
+      if (parts.clip) {
+        const rule = node.fillRule === "evenodd" ? "evenodd" : "nonzero";
+        const id = escapeAttr(parts.clip.id);
+        if (parts.clip.kind === "clip") {
+          defs.push(`<clipPath id="${id}"><path d="${d}" clip-rule="${rule}"/></clipPath>`);
+          clip = ` clip-path="url(#${id})"`;
+        } else {
+          const b = parts.clip.bounds;
+          const box = `x="${num(b.x)}" y="${num(b.y)}" width="${num(b.width)}" height="${num(b.height)}"`;
+          defs.push(`<mask id="${id}" maskUnits="userSpaceOnUse" ${box}><rect ${box} fill="#fff"/><path d="${d}" fill="#000" fill-rule="${rule}"/></mask>`);
+          clip = ` mask="url(#${id})"`;
+        }
+      }
+      if (parts.outline !== void 0) lines.push(`${indent(depth + 1)}<path data-vector-part="stroke-outline" d="${parts.outline}" fill="${escapeAttr(stroke.value)}"${clip}/>`);
+      else lines.push(`${indent(depth + 1)}<path data-vector-part="stroke" d="${parts.d}" fill="none"${lineAttrs(parts.width)}${clip}/>`);
+      for (const h2 of parts.heads) lines.push(`${indent(depth + 1)}<path data-vector-part="head" d="${h2}" fill="${escapeAttr(stroke.value)}"/>`);
+    }
+    lines.push(`${indent(depth)}</g>`);
   };
   for (const node of doc.nodes) emit(node, 1);
   const w = num(doc.width);
@@ -733,7 +1812,7 @@ function resolveGradient(id, raw, seen = /* @__PURE__ */ new Set()) {
   seen.add(id);
   let stops = readStops(el);
   const href = _nullishCoalesce(el.attrs.href, () => ( el.attrs["xlink:href"]));
-  if (!stops.length && _optionalChain([href, 'optionalAccess', _4 => _4.startsWith, 'call', _5 => _5("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _6 => _6(href.slice(1), raw, seen), 'optionalAccess', _7 => _7.stops]), () => ( []));
+  if (!stops.length && _optionalChain([href, 'optionalAccess', _37 => _37.startsWith, 'call', _38 => _38("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _39 => _39(href.slice(1), raw, seen), 'optionalAccess', _40 => _40.stops]), () => ( []));
   if (!stops.length) 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 };
@@ -765,11 +1844,11 @@ function parseVectorSvg(svg, options = {}) {
   const rawGradients = /* @__PURE__ */ new Map();
   collectGradients(root, rawGradients);
   const paint = (value) => {
-    const v = value.trim();
-    const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec(v);
+    const v2 = value.trim();
+    const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec(v2);
     if (url) return _nullishCoalesce(resolveGradient(url[1], rawGradients), () => ( null));
-    if (v === "none" || v === "") return null;
-    return v;
+    if (v2 === "none" || v2 === "") return null;
+    return v2;
   };
   const viewBox = numberList(root.attrs.viewBox);
   const width = viewBox.length === 4 ? viewBox[2] : length(root.attrs.width, 300);
@@ -779,8 +1858,13 @@ function parseVectorSvg(svg, options = {}) {
   const shapeOf = (el) => {
     const a = el.attrs;
     switch (el.name) {
-      case "path":
+      case "path": {
+        if (a["data-vector-d"] && a["data-vector-corners"]) {
+          const sharp = bezierToSubpaths(a["data-vector-d"]);
+          if (sharp.length) return applyVectorCornersAttribute(sharp, a["data-vector-corners"]);
+        }
         return a.d ? bezierToSubpaths(a.d) : null;
+      }
       case "rect": {
         const w = length(a.width);
         const h = length(a.height);
@@ -814,6 +1898,65 @@ function parseVectorSvg(svg, options = {}) {
     }
     return null;
   };
+  const strokeStyle = (s) => ({
+    ...s.strokeWidth ? { strokeWidth: length(s.strokeWidth, 1) } : {},
+    ...s.strokeLinecap ? { strokeLinecap: s.strokeLinecap } : {},
+    ...s.strokeLinejoin ? { strokeLinejoin: s.strokeLinejoin } : {},
+    ...s.strokeDasharray && s.strokeDasharray !== "none" ? { strokeDasharray: numberList(s.strokeDasharray) } : {},
+    ...s.fillRule === "evenodd" ? { fillRule: "evenodd" } : {}
+  });
+  const placed = (node, m) => {
+    if (m === IDENTITY_MATRIX) return node;
+    const next = transformVectorNode(node, m);
+    const strokeScale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
+    if (hasPaint(next.stroke) && strokeScale > 0 && Math.abs(strokeScale - 1) > 1e-9) next.strokeWidth = (_nullishCoalesce(next.strokeWidth, () => ( 1))) * strokeScale;
+    return next;
+  };
+  const mergedPath = (g, style, m, meta) => {
+    const part = (name) => g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === name);
+    const fillEl = part("fill");
+    const subpaths = fillEl ? shapeOf(fillEl) : null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _41 => _41.length])) return null;
+    const a = g.attrs;
+    const fs = readStyle(fillEl, style);
+    const strokeEl = part("stroke");
+    const outlineEl = part("stroke-outline");
+    const ss = strokeEl ? readStyle(strokeEl, style) : null;
+    const width2 = length(a["data-vector-stroke-width"], ss ? length(ss.strokeWidth, 1) : 1);
+    const arrow = (v2) => VECTOR_ARROWHEADS.includes(v2) ? v2 : void 0;
+    const scale = (v2) => {
+      const n = v2 === void 0 ? NaN : parseFloat(v2);
+      return n > 0 ? n : void 0;
+    };
+    const align = a["data-vector-stroke-align"];
+    const profile = widthProfileFromAttribute(a["data-vector-width-profile"]);
+    const kept = (key, values) => values.includes(a[key]) ? a[key] : void 0;
+    const keptCap = kept("data-vector-stroke-linecap", ["round", "square"]);
+    const keptJoin = kept("data-vector-stroke-linejoin", ["round", "bevel"]);
+    const keptDash = a["data-vector-stroke-dasharray"] ? numberList(a["data-vector-stroke-dasharray"]) : void 0;
+    const node = {
+      id: idFor(g),
+      type: "path",
+      ...meta,
+      subpaths,
+      fill: paint(fs.fill),
+      stroke: ss ? paint(ss.stroke) : outlineEl ? paint(readStyle(outlineEl, style).fill) : null,
+      ...ss ? strokeStyle(ss) : {},
+      ...fs.fillRule === "evenodd" ? { fillRule: "evenodd" } : {},
+      strokeWidth: width2,
+      ...align === "inside" || align === "outside" ? { strokeAlign: align } : {},
+      ...arrow(a["data-vector-start-arrow"]) ? { startArrow: arrow(a["data-vector-start-arrow"]) } : {},
+      ...arrow(a["data-vector-end-arrow"]) ? { endArrow: arrow(a["data-vector-end-arrow"]) } : {},
+      ...a["data-vector-arrow-align"] === "tip" ? { arrowAlign: "tip" } : {},
+      ...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"]) } : {},
+      ...profile.length ? { strokeWidthProfile: profile } : {},
+      ...keptCap ? { strokeLinecap: keptCap } : {},
+      ...keptJoin ? { strokeLinejoin: keptJoin } : {},
+      ..._optionalChain([keptDash, 'optionalAccess', _42 => _42.length]) ? { strokeDasharray: keptDash } : {}
+    };
+    return placed(node, m);
+  };
   const visit = (el, style, matrix) => {
     const out = [];
     for (const child of el.children) {
@@ -827,6 +1970,11 @@ function parseVectorSvg(svg, options = {}) {
         ...opacity !== void 0 && Number.isFinite(opacity) && opacity < 1 ? { opacity } : {},
         ...hidden ? { visible: false } : {}
       };
+      if (child.name === "g" && child.attrs["data-vector-path"] !== void 0) {
+        const node2 = mergedPath(child, s, m, meta);
+        if (node2) out.push(node2);
+        continue;
+      }
       if (child.name === "g" || child.name === "svg" || child.name === "a" || child.name === "switch") {
         const children = visit(child, s, m);
         if (!children.length) continue;
@@ -836,24 +1984,18 @@ function parseVectorSvg(svg, options = {}) {
       }
       const subpaths = shapeOf(child);
       if (!subpaths || !subpaths.length) continue;
-      let node = {
-        id: idFor(child),
-        type: "path",
-        ...meta,
-        subpaths,
-        fill: child.name === "line" ? null : paint(s.fill),
-        stroke: paint(s.stroke),
-        ...s.strokeWidth ? { strokeWidth: length(s.strokeWidth, 1) } : {},
-        ...s.strokeLinecap ? { strokeLinecap: s.strokeLinecap } : {},
-        ...s.strokeLinejoin ? { strokeLinejoin: s.strokeLinejoin } : {},
-        ...s.strokeDasharray && s.strokeDasharray !== "none" ? { strokeDasharray: numberList(s.strokeDasharray) } : {},
-        ...s.fillRule === "evenodd" ? { fillRule: "evenodd" } : {}
-      };
-      if (m !== IDENTITY_MATRIX) {
-        node = transformVectorNode(node, m);
-        const strokeScale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
-        if (hasPaint(node.stroke) && strokeScale > 0 && Math.abs(strokeScale - 1) > 1e-9) node.strokeWidth = (_nullishCoalesce(node.strokeWidth, () => ( 1))) * strokeScale;
-      }
+      const node = placed(
+        {
+          id: idFor(child),
+          type: "path",
+          ...meta,
+          subpaths,
+          fill: child.name === "line" ? null : paint(s.fill),
+          stroke: paint(s.stroke),
+          ...strokeStyle(s)
+        },
+        m
+      );
       out.push(node);
     }
     return out;
@@ -865,7 +2007,7 @@ function parseVectorSvg(svg, options = {}) {
 // src/vector/snap.ts
 var VECTOR_CONSTRUCTION_ANGLES = [0, 45, 90, 135];
 function constrainToLeave(leave, p) {
-  if (!_optionalChain([leave, 'optionalAccess', _8 => _8.constrain])) return p;
+  if (!_optionalChain([leave, 'optionalAccess', _43 => _43.constrain])) return p;
   const dx = p.x - leave.at.x;
   const dy = p.y - leave.at.y;
   switch (leave.constrain) {
@@ -876,9 +2018,9 @@ function constrainToLeave(leave, p) {
       return { x: leave.at.x + Math.sign(dx || 1) * s, y: leave.at.y + Math.sign(dy || 1) * s };
     }
     default: {
-      const len = Math.hypot(dx, dy);
+      const len2 = Math.hypot(dx, dy);
       const a = Math.round(Math.atan2(dy, dx) / (Math.PI / 4)) * (Math.PI / 4);
-      return { x: leave.at.x + Math.cos(a) * len, y: leave.at.y + Math.sin(a) * len };
+      return { x: leave.at.x + Math.cos(a) * len2, y: leave.at.y + Math.sin(a) * len2 };
     }
   }
 }
@@ -887,24 +2029,24 @@ var CROSSING_PAIRS = 32;
 var CURVE_SAMPLES = 48;
 var BISECT = 50;
 var EQUAL = 1e-6;
-function bound(sorted, key, v, strict) {
+function bound(sorted, key, v2, strict) {
   let lo = 0;
   let hi = sorted.length;
   while (lo < hi) {
     const mid = lo + hi >>> 1;
     const k = key(sorted[mid]);
-    if (strict ? k <= v : k < v) lo = mid + 1;
+    if (strict ? k <= v2 : k < v2) lo = mid + 1;
     else hi = mid;
   }
   return lo;
 }
-function within(sorted, key, v, tol) {
-  return sorted.slice(bound(sorted, key, v - tol, false), bound(sorted, key, v + tol, true));
+function within(sorted, key, v2, tol) {
+  return sorted.slice(bound(sorted, key, v2 - tol, false), bound(sorted, key, v2 + tol, true));
 }
-var linesNear = (lines, v, tol) => within(lines, (l) => l.v, v, tol);
+var linesNear = (lines, v2, tol) => within(lines, (l) => l.v, v2, tol);
 var distance = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
 var toPoint = (p) => [p.x, p.y];
-var toVec = (p) => ({ x: p[0], y: p[1] });
+var toVec2 = (p) => ({ x: p[0], y: p[1] });
 var LABELS = {
   anchor: "anchor",
   centre: "centre",
@@ -976,7 +2118,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       moving.set(r.nodeId, set);
     }
     const t = _VectorSnapTargets.collect(doc, new Set(moving.keys()), "segments", false);
-    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _9 => _9.get, 'call', _10 => _10(id), 'optionalAccess', _11 => _11.has, 'call', _12 => _12(`${s}:${i}`)]), true);
+    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _44 => _44.get, 'call', _45 => _45(id), 'optionalAccess', _46 => _46.has, 'call', _47 => _47(`${s}:${i}`)]), true);
     return t.index();
   }
   /**
@@ -1022,7 +2164,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     const count = subpathSegmentCount(sp);
     for (let i = 0; i < count && budget > 0; i++) {
       if (moving(i) || moving((i + 1) % n)) continue;
-      const seg = subpathSegment(sp, i).map((q) => toPoint(applyMatrix(m, toVec(q))));
+      const seg = subpathSegment(sp, i).map((q) => toPoint(applyMatrix(m, toVec2(q))));
       let minX = Infinity;
       let minY = Infinity;
       let maxX = -Infinity;
@@ -1094,7 +2236,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
         }
         const b = vectorNodeBounds(n, parent);
         const f = nodeFrame(n, parent, b);
-        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _13 => _13.centre]), () => ( null)));
+        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _48 => _48.centre]), () => ( null)));
       }
     };
     visit(doc.nodes, IDENTITY_MATRIX);
@@ -1131,7 +2273,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
    */
   snapFrom(p, leave, tol) {
     const none = (q) => ({ point: q, kind: null, x: false, y: false, lines: [], labels: [] });
-    const at = (q, kind, lines2 = []) => ({
+    const at2 = (q, kind, lines2 = []) => ({
       point: q,
       kind,
       x: true,
@@ -1139,23 +2281,23 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       lines: lines2,
       labels: [this.label(q, kind)]
     });
-    if (_optionalChain([leave, 'optionalAccess', _14 => _14.constrain])) {
+    if (_optionalChain([leave, 'optionalAccess', _49 => _49.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);
     }
     const point = this.nearestPoint(p, tol);
-    if (point) return at(point.p, point.kind);
+    if (point) return at2(point.p, point.kind);
     const near2 = this.segmentsNear(p, tol);
-    const crossing = this.crossing(near2, p, tol);
-    if (crossing) return at(crossing, "intersect");
+    const crossing2 = this.crossing(near2, p, tol);
+    if (crossing2) return at2(crossing2, "intersect");
     if (leave && leave.curves !== false) {
       const foot = this.curvePoint(near2, leave.at, p, tol);
-      if (foot) return at(foot.point, foot.kind, [line("construction", leave.at, foot.point)]);
+      if (foot) return at2(foot.point, foot.kind, [line("construction", leave.at, foot.point)]);
     }
     const on = this.onSegment(near2);
-    if (on) return at(on, "path");
-    if (_optionalChain([leave, 'optionalAccess', _15 => _15.angles, 'optionalAccess', _16 => _16.length])) {
+    if (on) return at2(on, "path");
+    if (_optionalChain([leave, 'optionalAccess', _50 => _50.angles, 'optionalAccess', _51 => _51.length])) {
       const c = construction(leave, p, tol);
       if (c) {
         const hit = this.slide(leave.at, c.dir, c.point, tol, false);
@@ -1166,9 +2308,9 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
         return { point: c.point, kind: "construction", x: true, y: true, lines: [line("construction", leave.at, c.point)], labels: [] };
       }
     }
-    const nearest = (lines2, v) => {
+    const nearest = (lines2, v2) => {
       let best = null;
-      for (const l of linesNear(lines2, v, tol)) if (!best || Math.abs(l.v - v) < Math.abs(best.v - v)) best = l;
+      for (const l of linesNear(lines2, v2, tol)) if (!best || Math.abs(l.v - v2) < Math.abs(best.v - v2)) best = l;
       return best;
     };
     const bx = nearest(this.xs, p.x);
@@ -1201,7 +2343,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
    * the nearest target line crosses it, at most twice `tol` away: where it lands and the
    * target point that line comes from.
    */
-  slide(at, dir, q, tol, ray) {
+  slide(at2, dir, q, tol, ray) {
     const len2 = dir.x * dir.x + dir.y * dir.y;
     if (!Number.isFinite(len2) || len2 <= 1e-18) return null;
     const reach = 2 * tol;
@@ -1209,10 +2351,10 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     for (const vertical of [true, false]) {
       const d = vertical ? dir.x : dir.y;
       if (Math.abs(d) <= 1e-9) continue;
-      const a = vertical ? at.x : at.y;
+      const a = vertical ? at2.x : at2.y;
       for (const l of linesNear(vertical ? this.xs : this.ys, vertical ? q.x : q.y, reach)) {
         const s = (l.v - a) / d;
-        const hit = vertical ? { x: l.v, y: at.y + dir.y * s } : { x: at.x + dir.x * s, y: l.v };
+        const hit = vertical ? { x: l.v, y: at2.y + dir.y * s } : { x: at2.x + dir.x * s, y: l.v };
         const moved = distance(hit, q);
         if (moved <= reach && (!ray || s > 0) && (!best || moved < best.moved)) best = { moved, point: hit, from: l.from };
       }
@@ -1228,16 +2370,16 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
   /** Target segments whose control box reaches `p` and which pass within `tol` of it, nearest first. */
   segmentsNear(p, tol) {
     const out = [];
-    const pt = toPoint(p);
+    const pt2 = toPoint(p);
     for (const s of this.segments) {
       if (p.x < s.minX - tol || p.x > s.maxX + tol || p.y < s.minY - tol || p.y > s.maxY + tol) continue;
-      const hit = _chunkBGNPT5PEcjs.segmentNearest.call(void 0, s.seg, pt);
+      const hit = _chunkGVB7ZPLZcjs.segmentNearest.call(void 0, s.seg, pt2);
       if (hit.distance <= tol) out.push({ seg: s.seg, t: hit.t, distance: hit.distance });
     }
     return out.sort((a, b) => a.distance - b.distance);
   }
   onSegment(near2) {
-    return near2.length ? toVec(_chunkBGNPT5PEcjs.segmentPoint.call(void 0, near2[0].seg, near2[0].t)) : null;
+    return near2.length ? toVec2(_chunkGVB7ZPLZcjs.segmentPoint.call(void 0, near2[0].seg, near2[0].t)) : null;
   }
   /** Where two of the target segments near `p` cross, the crossing nearest `p` within `tol`. */
   crossing(near2, p, tol) {
@@ -1246,8 +2388,8 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     let bestD = Infinity;
     for (let i = 0; i < list.length; i++) {
       for (let j = i + 1; j < list.length; j++) {
-        for (const hit of _chunkBGNPT5PEcjs.segmentIntersections.call(void 0, list[i].seg, list[j].seg)) {
-          const q = toVec(hit.point);
+        for (const hit of _chunkGVB7ZPLZcjs.segmentIntersections.call(void 0, list[i].seg, list[j].seg)) {
+          const q = toVec2(hit.point);
           const d = distance(q, p);
           if (d <= tol && d < bestD) {
             best = q;
@@ -1285,15 +2427,15 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
    * with nothing spaces the box evenly in its row or column. Returns the correction and guides.
    */
   snapRect(r, tol, options = {}) {
-    const axes = { x: _optionalChain([options, 'access', _17 => _17.axes, 'optionalAccess', _18 => _18.x]) !== false, y: _optionalChain([options, 'access', _19 => _19.axes, 'optionalAccess', _20 => _20.y]) !== false };
+    const axes = { x: _optionalChain([options, 'access', _52 => _52.axes, 'optionalAccess', _53 => _53.x]) !== false, y: _optionalChain([options, 'access', _54 => _54.axes, 'optionalAccess', _55 => _55.y]) !== false };
     const nearest = (lines, values) => {
       let best = null;
-      for (const v of values) for (const l of linesNear(lines, v, tol)) if (!best || Math.abs(l.v - v) < Math.abs(best.d)) best = { d: l.v - v, from: l.from };
+      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 };
       return best;
     };
     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', _21 => _21.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _22 => _22.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
+    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _56 => _56.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _57 => _57.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
     const done = { ...r, x: r.x + out.dx, y: r.y + out.dy };
     if (bx) {
       const x = bx.from.x;
@@ -1331,7 +2473,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
   evenSpacing(r, horizontal, tol) {
     const span = (b, x) => x ? [b.x, b.x + b.width] : [b.y, b.y + b.height];
     const [r0, r1] = span(r, horizontal);
-    const len = r1 - r0;
+    const len2 = r1 - r0;
     const [c0, c1] = span(r, !horizontal);
     const row = this.boxes.map((b) => ({ b, a0: span(b, horizontal)[0], a1: span(b, horizontal)[1] })).filter((e) => span(e.b, !horizontal)[0] < c1 && span(e.b, !horizontal)[1] > c0 && (e.a1 <= r0 + tol || e.a0 >= r1 - tol)).sort((a, b) => a.a0 - b.a0);
     if (!row.length) return null;
@@ -1351,20 +2493,20 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       if (e.a0 >= r1 - tol && (!after || e.a0 < after.a0)) after = e;
     }
     const starts = [];
-    if (before && after && after.a0 - before.a1 > len) starts.push({ start: (before.a1 + after.a0 - len) / 2, repeats: null });
+    if (before && after && after.a0 - before.a1 > len2) starts.push({ start: (before.a1 + after.a0 - len2) / 2, repeats: null });
     for (const { g } of pairs) {
       if (before) starts.push({ start: before.a1 + g, repeats: g });
-      if (after) starts.push({ start: after.a0 - g - len, repeats: g });
+      if (after) starts.push({ start: after.a0 - g - len2, repeats: g });
     }
     let pick = null;
     for (const s of starts) if (Math.abs(s.start - r0) <= tol && (!pick || Math.abs(s.start - r0) < Math.abs(pick.start - r0))) pick = s;
     if (!pick) return null;
     const { start, repeats } = pick;
-    const at = horizontal ? { ...r, x: start } : { ...r, y: start };
-    const end = start + len;
+    const at2 = horizontal ? { ...r, x: start } : { ...r, y: start };
+    const end = start + len2;
     const gaps = [];
-    if (before && (repeats === null || Math.abs(start - before.a1 - repeats) <= EQUAL)) gaps.push([before.a1, start, mid(before.b, at)]);
-    if (after && (repeats === null || Math.abs(after.a0 - end - repeats) <= EQUAL)) gaps.push([end, after.a0, mid(after.b, at)]);
+    if (before && (repeats === null || Math.abs(start - before.a1 - repeats) <= EQUAL)) gaps.push([before.a1, start, mid(before.b, at2)]);
+    if (after && (repeats === null || Math.abs(after.a0 - end - repeats) <= EQUAL)) gaps.push([end, after.a0, mid(after.b, at2)]);
     if (repeats !== null) {
       for (const p of pairs) if (Math.abs(p.g - repeats) <= EQUAL) gaps.push(p.gap);
     }
@@ -1372,9 +2514,9 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
   }
   /** A gap mark: a line across the gap with a tick at each end, and its length as a label. */
   gapMarks([u0, u1, c], horizontal, tick, out) {
-    const pt = (u, v) => horizontal ? { x: u, y: v } : { x: v, y: u };
-    out.lines.push(line("spacing", pt(u0, c), pt(u1, c)), line("spacing", pt(u0, c - tick), pt(u0, c + tick)), line("spacing", pt(u1, c - tick), pt(u1, c + tick)));
-    out.labels.push(this.label(pt((u0 + u1) / 2, c), "spacing", fmtLength(u1 - u0)));
+    const pt2 = (u, v2) => horizontal ? { x: u, y: v2 } : { x: v2, y: u };
+    out.lines.push(line("spacing", pt2(u0, c), pt2(u1, c)), line("spacing", pt2(u0, c - tick), pt2(u0, c + tick)), line("spacing", pt2(u1, c - tick), pt2(u1, c + tick)));
+    out.labels.push(this.label(pt2((u0 + u1) / 2, c), "spacing", fmtLength(u1 - u0)));
   }
   /** The other objects' side length nearest `length`, within `tol`, or null. */
   matchSize(length2, tol) {
@@ -1401,9 +2543,9 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     const hp = handlePos(handle, frame);
     const d0 = { x: hp.x - origin.x, y: hp.y - origin.y };
     const valid = (n, s) => Number.isFinite(n) && n * s > 0;
-    const nearest = (v, lines) => {
+    const nearest = (v2, lines) => {
       let best = null;
-      for (const l of linesNear(lines, v, tol)) if (!best || Math.abs(l.v - v) < Math.abs(best.v - v)) best = l;
+      for (const l of linesNear(lines, v2, tol)) if (!best || Math.abs(l.v - v2) < Math.abs(best.v - v2)) best = l;
       return best;
     };
     let nx = sx;
@@ -1416,9 +2558,9 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       const on = this.nearestPoint(p, tol);
       const tries = [];
       if (on) tries.push({ tx: on.p.x, ty: on.p.y, s: { hx: null, hy: null, on } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _23 => _23.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _24 => _24.v]), () => ( null)), s: { hx, hy, on: null } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _25 => _25.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
-      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _26 => _26.v]), () => ( null)), s: { hx: null, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _58 => _58.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _59 => _59.v]), () => ( null)), s: { hx, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _60 => _60.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
+      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _61 => _61.v]), () => ( null)), s: { hx: null, hy, on: null } });
       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)) });
@@ -1454,9 +2596,9 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       };
       for (const h of [handle, ...ends]) {
         const hv = handlePos(h, frame);
-        const v = { x: hv.x - origin.x, y: hv.y - origin.y };
-        const base = applyMatrix(toDoc, { x: origin.x + c.x * v.x, y: origin.y + c.y * v.y });
-        const dir = applyMatrix(toDoc, { x: e.x * v.x, y: e.y * v.y });
+        const v2 = { x: hv.x - origin.x, y: hv.y - origin.y };
+        const base = applyMatrix(toDoc, { x: origin.x + c.x * v2.x, y: origin.y + c.y * v2.y });
+        const dir = applyMatrix(toDoc, { x: e.x * v2.x, y: e.y * v2.y });
         const p = { x: base.x + dir.x * s0, y: base.y + dir.y * s0 };
         const l2 = dir.x * dir.x + dir.y * dir.y;
         const on = l2 > 1e-18 ? this.nearestPoint(p, tol) : null;
@@ -1489,16 +2631,16 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     const sized = [];
     if (!proportional) {
       if (movesX && !snap.hx && !(frame.angle && snap.hy) && frame.width > 1e-9) {
-        const len = this.matchSize(Math.abs(out.sx) * frame.width, tol);
-        if (len !== null && len > 0) {
-          out.sx = Math.sign(out.sx || 1) * (len / frame.width);
+        const len2 = this.matchSize(Math.abs(out.sx) * frame.width, tol);
+        if (len2 !== null && len2 > 0) {
+          out.sx = Math.sign(out.sx || 1) * (len2 / frame.width);
           sized.push("x");
         }
       }
       if (movesY && !snap.hy && !(frame.angle && snap.hx) && frame.height > 1e-9) {
-        const len = this.matchSize(Math.abs(out.sy) * frame.height, tol);
-        if (len !== null && len > 0) {
-          out.sy = Math.sign(out.sy || 1) * (len / frame.height);
+        const len2 = this.matchSize(Math.abs(out.sy) * frame.height, tol);
+        if (len2 !== null && len2 > 0) {
+          out.sy = Math.sign(out.sy || 1) * (len2 / frame.height);
           sized.push("y");
         }
       }
@@ -1549,14 +2691,14 @@ function line(kind, a, b) {
   return { kind, x1: a.x, y1: a.y, x2: b.x, y2: b.y };
 }
 function construction(leave, p, tol) {
-  const v = { x: p.x - leave.at.x, y: p.y - leave.at.y };
-  if (Math.hypot(v.x, v.y) <= tol) return null;
+  const v2 = { x: p.x - leave.at.x, y: p.y - leave.at.y };
+  if (Math.hypot(v2.x, v2.y) <= tol) return null;
   let best = null;
   for (const a of _nullishCoalesce(leave.angles, () => ( []))) {
     const r = a * Math.PI / 180;
     const exact = (n) => Math.abs(n) < 1e-12 ? 0 : n;
     const dir = { x: exact(Math.cos(r)), y: exact(-Math.sin(r)) };
-    const k = v.x * dir.x + v.y * dir.y;
+    const k = v2.x * dir.x + v2.y * dir.y;
     const point = { x: leave.at.x + dir.x * k, y: leave.at.y + dir.y * k };
     const d = distance(point, p);
     if (d <= tol && (!best || d < best.d)) best = { dir, point, d };
@@ -1568,20 +2710,20 @@ var crossCondition = (r, d) => r[0] * d[1] - r[1] * d[0];
 function solveOnSegment(seg, base, cond) {
   const b = [base.x, base.y];
   const g = (t) => {
-    const p = _chunkBGNPT5PEcjs.segmentPoint.call(void 0, seg, t);
-    return cond([p[0] - b[0], p[1] - b[1]], _chunkBGNPT5PEcjs.segmentDerivative.call(void 0, seg, t));
+    const p = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, t);
+    return cond([p[0] - b[0], p[1] - b[1]], _chunkGVB7ZPLZcjs.segmentDerivative.call(void 0, seg, t));
   };
   const vals = [];
   let scale = 0;
   for (let i = 0; i <= CURVE_SAMPLES; i++) {
     const t = i / CURVE_SAMPLES;
-    const p = _chunkBGNPT5PEcjs.segmentPoint.call(void 0, seg, t);
-    const d = _chunkBGNPT5PEcjs.segmentDerivative.call(void 0, seg, t);
+    const p = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, t);
+    const d = _chunkGVB7ZPLZcjs.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]));
   }
-  if (!(scale > 0) || vals.every((v) => Math.abs(v) <= scale * 1e-12)) return [];
+  if (!(scale > 0) || vals.every((v2) => Math.abs(v2) <= scale * 1e-12)) return [];
   const out = [];
   for (let i = 0; i < CURVE_SAMPLES; i++) {
     const ga = vals[i];
@@ -1603,8 +2745,8 @@ function solveOnSegment(seg, base, cond) {
       } else hi = m;
     }
     const t = (lo + hi) / 2;
-    const p = _chunkBGNPT5PEcjs.segmentPoint.call(void 0, seg, t);
-    const dv = _chunkBGNPT5PEcjs.segmentDerivative.call(void 0, seg, t);
+    const p = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, t);
+    const dv = _chunkGVB7ZPLZcjs.segmentDerivative.call(void 0, seg, t);
     const r = Math.hypot(p[0] - b[0], p[1] - b[1]);
     const dl = Math.hypot(dv[0], dv[1]);
     if (!(r > 1e-9 && dl > 0) || Math.abs(cond([p[0] - b[0], p[1] - b[1]], dv)) > 1e-6 * r * dl) continue;
@@ -1614,8 +2756,8 @@ function solveOnSegment(seg, base, cond) {
 }
 
 // src/vector/pathEdit.ts
-var EPS2 = 1e-9;
-var unit = (x, y) => {
+var EPS3 = 1e-9;
+var unit2 = (x, y) => {
   const l = Math.hypot(x, y);
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
 };
@@ -1628,26 +2770,26 @@ function cubicOf(sp, i) {
 var isLine = (sp, i) => subpathSegment(sp, i).length === 2;
 function startTangent(c) {
   for (let k = 1; k < 4; k++) {
-    const u = unit(c[k][0] - c[0][0], c[k][1] - c[0][1]);
+    const u = unit2(c[k][0] - c[0][0], c[k][1] - c[0][1]);
     if (u) return u;
   }
   return [1, 0];
 }
 function endTangent(c) {
   for (let k = 2; k >= 0; k--) {
-    const u = unit(c[3][0] - c[k][0], c[3][1] - c[k][1]);
+    const u = unit2(c[3][0] - c[k][0], c[3][1] - c[k][1]);
     if (u) return u;
   }
   return [1, 0];
 }
 function sample(c, n, out, withStart) {
-  for (let i = withStart ? 0 : 1; i <= n; i++) out.push(_chunkBGNPT5PEcjs.segmentPoint.call(void 0, c, i / n));
+  for (let i = withStart ? 0 : 1; i <= n; i++) out.push(_chunkGVB7ZPLZcjs.segmentPoint.call(void 0, c, i / n));
 }
-var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS2 && Math.abs(h.y - a.y) < EPS2;
+var onAnchor2 = (a, h) => !h || Math.abs(h.x - a.x) < EPS3 && Math.abs(h.y - a.y) < EPS3;
 function tidy(a, keepType = true) {
   const next = cloneAnchor(a);
-  if (onAnchor(next, next.in)) delete next.in;
-  if (onAnchor(next, next.out)) delete next.out;
+  if (onAnchor2(next, next.in)) delete next.in;
+  if (onAnchor2(next, next.out)) delete next.out;
   const shown = inferAnchorType(next);
   const type = keepType && a.type ? a.type === "symmetric" && shown !== "symmetric" ? shown === "corner" ? "corner" : "smooth" : a.type === "smooth" && shown === "corner" ? "corner" : a.type : shown;
   if (type === "corner") delete next.type;
@@ -1687,7 +2829,7 @@ function fitAcross(pts, N, t0, t1) {
     const u = [];
     for (let i = 0; i <= N; i++) u.push(k * i / N);
     for (let i = 1; i <= N; i++) u.push(k + (1 - k) * i / N);
-    return _chunkBGNPT5PEcjs.fitCubicWithTangents.call(void 0, pts, u, t0, t1);
+    return _chunkGVB7ZPLZcjs.fitCubicWithTangents.call(void 0, pts, u, t0, t1);
   };
   return goldenMin(fit, 0, 1);
 }
@@ -1747,7 +2889,7 @@ function bendSegment(sp, segment, t, p) {
   return { anchors, closed: sp.closed };
 }
 function subpathPointAt(sp, segment, t) {
-  const [x, y] = _chunkBGNPT5PEcjs.segmentPoint.call(void 0, subpathSegment(sp, segment), t);
+  const [x, y] = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, subpathSegment(sp, segment), t);
   return { x, y };
 }
 function curvatureMoveAnchor(sp, index, q) {
@@ -1755,8 +2897,8 @@ function curvatureMoveAnchor(sp, index, q) {
   const a = sp.anchors[index];
   if (!a) return { anchors, closed: sp.closed };
   const own = [
-    a.in && !onAnchor(a, a.in) ? { x: a.in.x - a.x, y: a.in.y - a.y } : null,
-    a.out && !onAnchor(a, a.out) ? { x: a.out.x - a.x, y: a.out.y - a.y } : null
+    a.in && !onAnchor2(a, a.in) ? { x: a.in.x - a.x, y: a.in.y - a.y } : null,
+    a.out && !onAnchor2(a, a.out) ? { x: a.out.x - a.x, y: a.out.y - a.y } : null
   ];
   const ends = [null, null];
   neighbours(sp, index).forEach((j, side) => {
@@ -1775,15 +2917,16 @@ function curvatureMoveAnchor(sp, index, q) {
   if (own[0]) moved.in = { x: q.x + own[0].x, y: q.y + own[0].y };
   if (own[1]) moved.out = { x: q.x + own[1].x, y: q.y + own[1].y };
   if (a.type) moved.type = a.type;
+  if (a.corner) moved.corner = { ...a.corner };
   const [prev, next] = ends;
   if (a.type && a.type !== "corner" && prev && next) {
     const dx = next.x - prev.x;
     const dy = next.y - prev.y;
     const l = Math.hypot(dx, dy);
     if (l > 1e-9) {
-      const len = (h, to) => h ? Math.hypot(h.x, h.y) : Math.hypot(q.x - to.x, q.y - to.y) / 3;
-      let li = len(own[0], prev);
-      let lo = len(own[1], next);
+      const len2 = (h, to) => h ? Math.hypot(h.x, h.y) : Math.hypot(q.x - to.x, q.y - to.y) / 3;
+      let li = len2(own[0], prev);
+      let lo = len2(own[1], next);
       if (a.type === "symmetric") li = lo = (li + lo) / 2;
       moved.in = { x: q.x - dx * li / l, y: q.y - dy * li / l };
       moved.out = { x: q.x + dx * lo / l, y: q.y + dy * lo / l };
@@ -1792,9 +2935,9 @@ function curvatureMoveAnchor(sp, index, q) {
   anchors[index] = moved;
   return { anchors, closed: sp.closed };
 }
-function cutSubpathAt(sp, at) {
+function cutSubpathAt(sp, at2) {
   const n = sp.anchors.length;
-  const cuts = [...new Set(at)].filter((i) => Number.isInteger(i) && i >= 0 && i < n && (sp.closed || i > 0 && i < n - 1)).sort((a, b) => a - b);
+  const cuts = [...new Set(at2)].filter((i) => Number.isInteger(i) && i >= 0 && i < n && (sp.closed || i > 0 && i < n - 1)).sort((a, b) => a - b);
   if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(cloneAnchor), closed: sp.closed }];
   const first = cuts[0];
   const run = sp.closed ? Array.from({ length: n + 1 }, (_, i) => sp.anchors[(first + i) % n]) : sp.anchors;
@@ -1824,8 +2967,8 @@ function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
   const { subpath, index } = insertAnchor(sp, segment, t);
   return cutSubpathAt(subpath, [index]);
 }
-var endOf = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
-var dist = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
+var endOf2 = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
+var dist2 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
 function reverse(sp) {
   return {
     closed: sp.closed,
@@ -1834,6 +2977,7 @@ function reverse(sp) {
       if (a.out) next.in = { ...a.out };
       if (a.in) next.out = { ...a.in };
       if (a.type) next.type = a.type;
+      if (a.corner) next.corner = { ...a.corner };
       return next;
     })
   };
@@ -1851,7 +2995,7 @@ function joinSubpaths(subpaths, tolerance) {
     const sp = open[0];
     const first = sp.anchors[0];
     const last = sp.anchors[sp.anchors.length - 1];
-    if (sp.anchors.length > 2 && dist(first, last) <= tolerance) {
+    if (sp.anchors.length > 2 && dist2(first, last) <= tolerance) {
       sp.anchors.pop();
       sp.anchors[0] = tidy({ ...first, in: _nullishCoalesce(last.in, () => ( null)) }, false);
     } else {
@@ -1867,7 +3011,7 @@ function joinSubpaths(subpaths, tolerance) {
       for (let j = i + 1; j < open.length; j++) {
         for (const ei of [false, true]) {
           for (const ej of [false, true]) {
-            const d = dist(endOf(open[i], ei), endOf(open[j], ej));
+            const d = dist2(endOf2(open[i], ei), endOf2(open[j], ej));
             if (d < best.d) best = { d, i, j, ei, ej };
           }
         }
@@ -1905,10 +3049,10 @@ 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 = unit(next.x - prev.x, next.y - prev.y);
+    const dir = unit2(next.x - prev.x, next.y - prev.y);
     if (!dir) continue;
-    const li = dist(p, prev) / 3;
-    const lo = dist(p, next) / 3;
+    const li = dist2(p, prev) / 3;
+    const lo = dist2(p, next) / 3;
     const hin = _nullishCoalesce(p.in, () => ( p));
     const hout = _nullishCoalesce(p.out, () => ( p));
     const target = (h, x, y) => ({ x: h.x + (x - h.x) * t, y: h.y + (y - h.y) * t });
@@ -1935,12 +3079,12 @@ function segsOf(sp) {
 function segsToSubpath(segs, closed, types) {
   if (!segs.length) return null;
   const anchors = [];
-  const at = (p) => ({ x: p[0], y: p[1] });
-  anchors.push(at(segs[0].c[0]));
+  const at2 = (p) => ({ x: p[0], y: p[1] });
+  anchors.push(at2(segs[0].c[0]));
   for (const s of segs) {
     const end = s.c[s.c.length - 1];
     if (!s.line) anchors[anchors.length - 1].out = { x: s.c[1][0], y: s.c[1][1] };
-    const next = at(end);
+    const next = at2(end);
     if (!s.line) next.in = { x: s.c[2][0], y: s.c[2][1] };
     anchors.push(next);
   }
@@ -1962,12 +3106,12 @@ function mergePair(a, b, tol) {
   if (a.line && b.line) {
     const cx = b3[0] - a0[0];
     const cy = b3[1] - a0[1];
-    const len = Math.hypot(cx, cy);
-    if (len < 1e-12) return null;
+    const len2 = Math.hypot(cx, cy);
+    if (len2 < 1e-12) return null;
     const mx = a3[0] - a0[0];
     const my = a3[1] - a0[1];
-    const along = (mx * cx + my * cy) / len;
-    return Math.abs((mx * cy - my * cx) / len) <= tol && along >= 0 && along <= len ? { c: [a0, b3], line: true } : null;
+    const along2 = (mx * cx + my * cy) / len2;
+    return Math.abs((mx * cy - my * cx) / len2) <= tol && along2 >= 0 && along2 <= len2 ? { c: [a0, b3], line: true } : null;
   }
   const ca = a.line ? [a0, a0, a3, a3] : a.c;
   const cb = b.line ? [a3, a3, b3, b3] : b.c;
@@ -2006,12 +3150,12 @@ function removeRedundantPoints(sp, tolerance) {
 }
 
 // src/vector/pathCut.ts
-var loopArea = (l) => _chunkBGNPT5PEcjs.contourSignedArea.call(void 0, l.segs);
+var loopArea = (l) => _chunkGVB7ZPLZcjs.contourSignedArea.call(void 0, l.segs);
 function loopSample(l) {
   const k = l.chord.findIndex((c) => !c);
-  return _chunkBGNPT5PEcjs.segmentPoint.call(void 0, l.segs[k >= 0 ? k : 0], 0.5);
+  return _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, l.segs[k >= 0 ? k : 0], 0.5);
 }
-var contains2 = (l, p) => _chunkBGNPT5PEcjs.windingNumber.call(void 0, [l.segs], p) !== 0;
+var contains2 = (l, p) => _chunkGVB7ZPLZcjs.windingNumber.call(void 0, [l.segs], p) !== 0;
 function groupFaces(loops) {
   const usable = loops.filter((l) => l.segs.length && Math.abs(loopArea(l)) > 1e-12);
   if (!usable.length) return [];
@@ -2027,12 +3171,12 @@ function groupFaces(loops) {
   return outers.reverse().map((o) => faces.get(o));
 }
 function faceToPath(face) {
-  return _chunkBGNPT5PEcjs.contoursToPath.call(void 0, face.loops.map((l) => ({ segments: l.segs, closed: true })));
+  return _chunkGVB7ZPLZcjs.contoursToPath.call(void 0, face.loops.map((l) => ({ segments: l.segs, closed: true })));
 }
 function facesOf(path, fillRule) {
-  const normalized = _chunkBGNPT5PEcjs.normalizeBezierPath.call(void 0, path, fillRule);
-  const loops = _chunkBGNPT5PEcjs.pathToContours.call(void 0, normalized).map((c) => {
-    const segs = _chunkBGNPT5PEcjs.closeContour.call(void 0, c, true).map((s) => s.slice());
+  const normalized = _chunkGVB7ZPLZcjs.normalizeBezierPath.call(void 0, path, fillRule);
+  const loops = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, normalized).map((c) => {
+    const segs = _chunkGVB7ZPLZcjs.closeContour.call(void 0, c, true).map((s) => s.slice());
     return { segs, chord: segs.map(() => false) };
   });
   return groupFaces(loops);
@@ -2091,7 +3235,7 @@ function lineHits(p, q, seg) {
   const dy = q[1] - p[1];
   const len2 = dx * dx + dy * dy;
   if (len2 < 1e-24) return [];
-  const h = (pt) => (pt[0] - p[0]) * -dy + (pt[1] - p[1]) * dx;
+  const h = (pt2) => (pt2[0] - p[0]) * -dy + (pt2[1] - p[1]) * dx;
   let coeffs;
   if (seg.length === 2) coeffs = [0, 0, h(seg[1]) - h(seg[0]), h(seg[0])];
   else {
@@ -2099,10 +3243,10 @@ 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((pt) => Math.abs(pt[0]) + Math.abs(pt[1])));
+  const scale = 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)) {
-    const point = _chunkBGNPT5PEcjs.segmentPoint.call(void 0, seg, t);
+    const point = _chunkGVB7ZPLZcjs.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 });
   }
@@ -2115,7 +3259,7 @@ function arc(l, a, b, eps) {
   const segs = [];
   const chord = [];
   const push = (k, t0, t1) => {
-    const piece = t0 <= 0 && t1 >= 1 ? l.segs[k].slice() : _chunkBGNPT5PEcjs.subSegment.call(void 0, l.segs[k], t0, t1);
+    const piece = t0 <= 0 && t1 >= 1 ? l.segs[k].slice() : _chunkGVB7ZPLZcjs.subSegment.call(void 0, l.segs[k], t0, t1);
     if (!degenerate(piece, eps)) {
       segs.push(piece);
       chord.push(l.chord[k]);
@@ -2140,7 +3284,7 @@ function knifePath(path, fillRule, knife) {
   if (pts.length < 2) return null;
   let faces = facesOf(path, fillRule);
   if (!faces.length) return null;
-  const b = _chunkBGNPT5PEcjs.bezierPathBounds.call(void 0, path);
+  const b = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, path);
   const size = b ? Math.max(b.maxX - b.minX, b.maxY - b.minY, 1) : 1;
   const eps = size * 1e-9;
   let cursor = -Infinity;
@@ -2154,7 +3298,7 @@ function knifePath(path, fillRule, knife) {
         const kb = { minX: Math.min(pts[m][0], pts[m + 1][0]), maxX: Math.max(pts[m][0], pts[m + 1][0]), minY: Math.min(pts[m][1], pts[m + 1][1]), maxY: Math.max(pts[m][1], pts[m + 1][1]) };
         face2.loops.forEach(
           (l, li) => l.segs.forEach((seg, si) => {
-            const sb = _chunkBGNPT5PEcjs.segmentBounds.call(void 0, seg);
+            const sb = _chunkGVB7ZPLZcjs.segmentBounds.call(void 0, seg);
             if (sb.maxX < kb.minX - eps || sb.minX > kb.maxX + eps || sb.maxY < kb.minY - eps || sb.minY > kb.maxY + eps) return;
             for (const h of lineHits(pts[m], pts[m + 1], seg)) {
               const s = m + h.s;
@@ -2169,7 +3313,7 @@ function knifePath(path, fillRule, knife) {
         const m = Math.min(pts.length - 2, Math.floor(s));
         const u = s - m;
         const q = [pts[m][0] + (pts[m + 1][0] - pts[m][0]) * u, pts[m][1] + (pts[m + 1][1] - pts[m][1]) * u];
-        return _chunkBGNPT5PEcjs.windingNumber.call(void 0, face2.loops.map((l) => l.segs), q) !== 0;
+        return _chunkGVB7ZPLZcjs.windingNumber.call(void 0, face2.loops.map((l) => l.segs), q) !== 0;
       };
       for (let i = 0; i < unique.length - 1; i++) {
         const from2 = unique[i];
@@ -2229,33 +3373,33 @@ function eraserRegion(points, width) {
     ];
   }
   const line2 = [{ type: "M", x: pts[0][0], y: pts[0][1] }, ...pts.slice(1).map((p) => ({ type: "L", x: p[0], y: p[1] }))];
-  return _chunkBGNPT5PEcjs.outlineStroke.call(void 0, line2, { width, cap: "round", join: "round" });
+  return _chunkGVB7ZPLZcjs.outlineStroke.call(void 0, line2, { width, cap: "round", join: "round" });
 }
 function eraseFromFill(path, fillRule, region) {
-  const overlap = _chunkBGNPT5PEcjs.pathBoolean.call(void 0, "intersection", [{ path, fillRule }, { path: region }]).path;
-  if (!_chunkBGNPT5PEcjs.pathToContours.call(void 0, overlap).some((c) => Math.abs(_chunkBGNPT5PEcjs.contourSignedArea.call(void 0, _chunkBGNPT5PEcjs.closeContour.call(void 0, c, true))) > 1e-9)) return null;
-  const rest = _chunkBGNPT5PEcjs.pathBoolean.call(void 0, "difference", [{ path, fillRule }, { path: region }]).path;
+  const overlap = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "intersection", [{ path, fillRule }, { path: region }]).path;
+  if (!_chunkGVB7ZPLZcjs.pathToContours.call(void 0, overlap).some((c) => Math.abs(_chunkGVB7ZPLZcjs.contourSignedArea.call(void 0, _chunkGVB7ZPLZcjs.closeContour.call(void 0, c, true))) > 1e-9)) return null;
+  const rest = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "difference", [{ path, fillRule }, { path: region }]).path;
   return splitIntoFaces(rest);
 }
 function eraseFromOutline(sp, region) {
-  const regionSegs = _chunkBGNPT5PEcjs.pathToContours.call(void 0, region).flatMap((c) => _chunkBGNPT5PEcjs.closeContour.call(void 0, c, true));
+  const regionSegs = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, region).flatMap((c) => _chunkGVB7ZPLZcjs.closeContour.call(void 0, c, true));
   if (!regionSegs.length) return null;
-  const rb = _chunkBGNPT5PEcjs.bezierPathBounds.call(void 0, region);
+  const rb = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, region);
   const count = subpathSegmentCount(sp);
   if (!rb || count === 0) return null;
-  const removed = (p) => _chunkBGNPT5PEcjs.pointInBezierPath.call(void 0, region, p, "nonzero");
+  const removed = (p) => _chunkGVB7ZPLZcjs.pointInBezierPath.call(void 0, region, p, "nonzero");
   const runs = [];
   let cur = [];
   let any = false;
   for (let i = 0; i < count; i++) {
     const seg = subpathSegment(sp, i);
-    const sb = _chunkBGNPT5PEcjs.segmentBounds.call(void 0, seg);
+    const sb = _chunkGVB7ZPLZcjs.segmentBounds.call(void 0, seg);
     const ts = [0, 1];
     if (!(sb.maxX < rb.minX || sb.minX > rb.maxX || sb.maxY < rb.minY || sb.minY > rb.maxY)) {
       for (const r of regionSegs) {
-        const b = _chunkBGNPT5PEcjs.segmentBounds.call(void 0, r);
+        const b = _chunkGVB7ZPLZcjs.segmentBounds.call(void 0, r);
         if (b.maxX < sb.minX || b.minX > sb.maxX || b.maxY < sb.minY || b.minY > sb.maxY) continue;
-        for (const hit of _chunkBGNPT5PEcjs.segmentIntersections.call(void 0, seg, r)) if (hit.ta > 1e-9 && hit.ta < 1 - 1e-9) ts.push(hit.ta);
+        for (const hit of _chunkGVB7ZPLZcjs.segmentIntersections.call(void 0, seg, r)) if (hit.ta > 1e-9 && hit.ta < 1 - 1e-9) ts.push(hit.ta);
       }
     }
     ts.sort((a, b) => a - b);
@@ -2263,7 +3407,7 @@ function eraseFromOutline(sp, region) {
       const t0 = ts[k];
       const t1 = ts[k + 1];
       if (t1 - t0 < 1e-9) continue;
-      if (removed(_chunkBGNPT5PEcjs.segmentPoint.call(void 0, seg, (t0 + t1) / 2))) {
+      if (removed(_chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, (t0 + t1) / 2))) {
         any = true;
         if (cur.length) runs.push(cur);
         cur = [];
@@ -2282,7 +3426,7 @@ function eraseFromOutline(sp, region) {
   for (const run of runs) {
     const anchors = [];
     for (const { seg, t0, t1 } of run) {
-      const c = _chunkBGNPT5PEcjs.subSegment.call(void 0, subpathSegment(sp, seg), t0, t1);
+      const c = _chunkGVB7ZPLZcjs.subSegment.call(void 0, subpathSegment(sp, seg), t0, t1);
       const line2 = c.length === 2;
       const start = c[0];
       const end = c[c.length - 1];
@@ -2326,12 +3470,12 @@ function simplifyPolyline(points, tolerance) {
     const [ax, ay] = points[a];
     const dx = points[b][0] - ax;
     const dy = points[b][1] - ay;
-    const len = Math.hypot(dx, dy);
+    const len2 = Math.hypot(dx, dy);
     let far = -1;
     let farD = 0;
     for (let i = a + 1; i < b; i++) {
       const [px, py] = points[i];
-      const d = len < 1e-12 ? Math.hypot(px - ax, py - ay) : Math.abs((px - ax) * dy - (py - ay) * dx) / len;
+      const d = len2 < 1e-12 ? Math.hypot(px - ax, py - ay) : Math.abs((px - ax) * dy - (py - ay) * dx) / len2;
       if (d > farD) {
         farD = d;
         far = i;
@@ -2399,7 +3543,7 @@ function vectorInkShapeName(shape) {
       return shape.points.length === 3 ? "triangle" : "polygon";
   }
 }
-var dist2 = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
+var dist3 = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1]);
 function bbox(pts) {
   if (!pts.length) return [0, 0, 0, 0];
   let [x0, y0] = pts[0];
@@ -2417,7 +3561,7 @@ function segDistance(a, b, p) {
   const dy = b[1] - a[1];
   const len2 = dx * dx + dy * dy;
   const t = len2 > 0 ? Math.min(1, Math.max(0, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2)) : 0;
-  return dist2([a[0] + t * dx, a[1] + t * dy], p);
+  return dist3([a[0] + t * dx, a[1] + t * dy], p);
 }
 function polygonDistance(c, p) {
   let best = Infinity;
@@ -2443,11 +3587,11 @@ function snapSquare(x, y, w, h) {
 }
 function turning(a, b, c) {
   const u = [b[0] - a[0], b[1] - a[1]];
-  const v = [c[0] - b[0], c[1] - b[1]];
+  const v2 = [c[0] - b[0], c[1] - b[1]];
   const lu = Math.hypot(u[0], u[1]);
-  const lv = Math.hypot(v[0], v[1]);
+  const lv = Math.hypot(v2[0], v2[1]);
   if (lu <= 0 || lv <= 0) return 0;
-  return Math.acos(Math.min(1, Math.max(-1, (u[0] * v[0] + u[1] * v[1]) / (lu * lv)))) * 180 / Math.PI;
+  return Math.acos(Math.min(1, Math.max(-1, (u[0] * v2[0] + u[1] * v2[1]) / (lu * lv)))) * 180 / Math.PI;
 }
 function rdp(p, eps) {
   const n = p.length;
@@ -2479,7 +3623,7 @@ function corners(p, diag) {
   let far = 0;
   let farD = 0;
   p.forEach((q, i) => {
-    const d = dist2(start, q);
+    const d = dist3(start, q);
     if (d > farD) {
       farD = d;
       far = i;
@@ -2506,7 +3650,7 @@ function corners(p, diag) {
     }
     let short = -1;
     for (let j = 0; j < n; j++) {
-      if (dist2(ring[j], ring[(j + 1) % n]) < 0.1 * diag) {
+      if (dist3(ring[j], ring[(j + 1) % n]) < 0.1 * diag) {
         short = j;
         break;
       }
@@ -2546,8 +3690,8 @@ function recognizeInkShape(points, options = {}) {
   const diag = Math.hypot(w, h);
   if (size < minSize) return null;
   let length2 = 0;
-  for (let i = 1; i < p.length; i++) length2 += dist2(p[i - 1], p[i]);
-  const gap = dist2(first, last);
+  for (let i = 1; i < p.length; i++) length2 += dist3(p[i - 1], p[i]);
+  const gap = dist3(first, last);
   if (gap > 0.85 * length2 && gap >= minSize) {
     const off = Math.max(...p.map((q) => segDistance(first, last, q)));
     if (off <= Math.max(0.06 * gap, 1.5 * minSize / 6)) return { kind: "line", a: first, b: last };
@@ -2573,8 +3717,31 @@ function recognizeInkShape(points, options = {}) {
 
 // src/vector/controller.ts
 var DEFAULT_VECTOR_SNAP = { grid: 0, objects: true, guides: true, threshold: 5, angles: VECTOR_CONSTRUCTION_ANGLES };
-var DEFAULT_VECTOR_PATH_EDIT = { keepShapeOnDelete: true, curvatureMoves: false, pencilSmoothing: 0, recognizeShapes: false, eraserSize: 10 };
+var DEFAULT_VECTOR_PATH_EDIT = {
+  keepShapeOnDelete: true,
+  curvatureMoves: false,
+  pencilSmoothing: 0,
+  recognizeShapes: false,
+  eraserSize: 10,
+  pencilPressure: "pen"
+};
 var VECTOR_PENCIL_STRING_PX = 100;
+var VECTOR_STYLE_KEYS = [
+  "fill",
+  "stroke",
+  "strokeWidth",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeDasharray",
+  "fillRule",
+  "strokeAlign",
+  "startArrow",
+  "endArrow",
+  "arrowAlign",
+  "startArrowScale",
+  "endArrowScale",
+  "strokeWidthProfile"
+];
 var VECTOR_CLIPBOARD_TYPE = "pixerate/vector";
 var DEFAULT_DEFAULTS = {
   fill: "#d4d4d8",
@@ -2602,7 +3769,7 @@ function getEditablePathIds(state) {
       }
     }
   }
-  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _27 => _27(state.document.nodes, id), 'optionalAccess', _28 => _28.type]) === "path");
+  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _62 => _62(state.document.nodes, id), 'optionalAccess', _63 => _63.type]) === "path");
 }
 function getVisibleAnchors(state) {
   const out = [];
@@ -2617,7 +3784,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', _29 => _29.anchors, 'access', _30 => _30[i]]);
+    const a = _optionalChain([sp, 'optionalAccess', _64 => _64.anchors, 'access', _65 => _65[i]]);
     if (!a || !a[handle]) return;
     const key = `${node.id}:${s}:${i}:${handle}`;
     if (seen.has(key)) return;
@@ -2626,8 +3793,8 @@ function getVisibleHandles(state) {
   };
   if (state.tool === "pen" && state.pen) {
     const node = findVectorNode(state.document.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _31 => _31.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
-    if (_optionalChain([node, 'optionalAccess', _32 => _32.type]) === "path" && sp) {
+    const sp = _optionalChain([node, 'optionalAccess', _66 => _66.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    if (_optionalChain([node, 'optionalAccess', _67 => _67.type]) === "path" && sp) {
       const last = sp.anchors.length - 1;
       push(node, state.pen.subpath, last, "in");
       push(node, state.pen.subpath, last, "out");
@@ -2635,9 +3802,9 @@ function getVisibleHandles(state) {
     return out;
   }
   if (state.tool !== "direct") return out;
-  const editable = new Set(getEditablePathIds(state));
+  const editable2 = new Set(getEditablePathIds(state));
   for (const ref of state.selectedAnchors) {
-    if (!editable.has(ref.nodeId)) continue;
+    if (!editable2.has(ref.nodeId)) continue;
     const node = findVectorNode(state.document.nodes, ref.nodeId);
     const sp = node.subpaths[ref.subpath];
     if (!sp) continue;
@@ -2651,9 +3818,82 @@ function getVisibleHandles(state) {
   }
   return out;
 }
+var VECTOR_CORNER_WIDGET_INSET = 10;
+function getVectorCornerWidgets(state) {
+  if (state.tool !== "direct" || state.pen) return [];
+  const zoom = state.viewport.zoom;
+  const out = [];
+  for (const id of getEditablePathIds(state)) {
+    const node = findVectorNode(state.document.nodes, id);
+    const picked = state.selectedAnchors.filter((r) => r.nodeId === id);
+    const m = _nullishCoalesce(vectorWorldMatrix(state.document.nodes, id), () => ( IDENTITY_MATRIX));
+    for (const c of vectorCorners(node.subpaths)) {
+      if (picked.length && !picked.some((r) => r.subpath === c.subpath && r.index === c.index)) continue;
+      const side = Math.min(c.lu, c.lv);
+      if (side * zoom < 3 * VECTOR_CORNER_WIDGET_INSET) continue;
+      const a = node.subpaths[c.subpath].anchors[c.index];
+      const radius = _nullishCoalesce(_optionalChain([a, 'access', _68 => _68.corner, 'optionalAccess', _69 => _69.radius]), () => ( 0));
+      const drawn = fitCornerRadius(c, radius);
+      const k = Math.min(Math.max(drawn / c.sin, VECTOR_CORNER_WIDGET_INSET / (zoom * Math.sqrt(1 + c.cos))), side / 2);
+      const p = applyMatrix(m, cornerBisectorPoint(c, k));
+      out.push({ ref: { nodeId: id, subpath: c.subpath, index: c.index }, x: p.x, y: p.y, radius, drawnRadius: drawn, kind: _nullishCoalesce(_optionalChain([a, 'access', _70 => _70.corner, 'optionalAccess', _71 => _71.kind]), () => ( "round")), corner: c });
+    }
+  }
+  return out;
+}
+function vectorStrokeWidthGeometry(node) {
+  if (!hasPaint(node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return null;
+  const parts = vectorStrokeParts(subpathsToBezier(node.subpaths), node);
+  return parts.line.length ? { line: parts.line, unit: parts.drawWidth / 2 } : null;
+}
+function getVectorWidthHandles(state) {
+  if (state.tool !== "width") return [];
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of state.selection) {
+    const n = findVectorNode(state.document.nodes, id);
+    if (n) for (const p of collectPathNodes(n)) ids.add(p.id);
+  }
+  if (_optionalChain([state, 'access', _72 => _72.hover, 'optionalAccess', _73 => _73.nodeId])) ids.add(state.hover.nodeId);
+  if (_optionalChain([state, 'access', _74 => _74.interaction, 'optionalAccess', _75 => _75.type]) === "width") ids.add(state.interaction.ref.nodeId);
+  if (state.selectedWidthPoint) ids.add(state.selectedWidthPoint.nodeId);
+  const out = [];
+  for (const id of ids) {
+    const node = findVectorNode(state.document.nodes, id);
+    if (_optionalChain([node, 'optionalAccess', _76 => _76.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _77 => _77.strokeWidthProfile, 'optionalAccess', _78 => _78.length])) continue;
+    const g = vectorStrokeWidthGeometry(node);
+    if (!g) continue;
+    const profile = sanitizeWidthProfile(node.strokeWidthProfile);
+    const m = _nullishCoalesce(vectorWorldMatrix(state.document.nodes, id), () => ( IDENTITY_MATRIX));
+    const contours = node.subpaths.length;
+    for (let sp = 0; sp < contours; sp++) {
+      profile.forEach((w, index) => {
+        const at2 = strokePositionPoint(g.line, sp, w.t);
+        if (!at2) return;
+        const n = { x: at2.tangent[1], y: -at2.tangent[0] };
+        const c = { x: at2.point[0], y: at2.point[1] };
+        const p = applyMatrix(m, c);
+        const l = applyMatrix(m, { x: c.x + n.x * w.left * g.unit, y: c.y + n.y * w.left * g.unit });
+        const r = applyMatrix(m, { x: c.x - n.x * w.right * g.unit, y: c.y - n.y * w.right * g.unit });
+        const sel = state.selectedWidthPoint;
+        out.push({
+          ref: { nodeId: id, index, subpath: sp },
+          x: p.x,
+          y: p.y,
+          left: l,
+          right: r,
+          t: w.t,
+          leftScale: w.left,
+          rightScale: w.right,
+          selected: !!sel && sel.nodeId === id && sel.index === index
+        });
+      });
+    }
+  }
+  return out;
+}
 function getAnchor(doc, ref) {
   const node = findVectorNode(doc.nodes, ref.nodeId);
-  return _optionalChain([node, 'optionalAccess', _33 => _33.type]) === "path" ? _optionalChain([node, 'access', _34 => _34.subpaths, 'access', _35 => _35[ref.subpath], 'optionalAccess', _36 => _36.anchors, 'access', _37 => _37[ref.index]]) : void 0;
+  return _optionalChain([node, 'optionalAccess', _79 => _79.type]) === "path" ? _optionalChain([node, 'access', _80 => _80.subpaths, 'access', _81 => _81[ref.subpath], 'optionalAccess', _82 => _82.anchors, 'access', _83 => _83[ref.index]]) : void 0;
 }
 function getAnchorWorld(doc, ref) {
   const a = getAnchor(doc, ref);
@@ -2721,9 +3961,10 @@ var TOOL_LABELS = {
   line: "Line",
   scissors: "Scissors",
   knife: "Knife",
-  eraser: "Eraser"
+  eraser: "Eraser",
+  width: "Width"
 };
-var TOOL_KEYS = { v: "select", a: "direct", p: "pen", n: "pencil", r: "rect", o: "ellipse", y: "polygon", s: "star", l: "line", c: "scissors", k: "knife", e: "eraser" };
+var TOOL_KEYS = { v: "select", a: "direct", p: "pen", n: "pencil", r: "rect", o: "ellipse", y: "polygon", s: "star", l: "line", c: "scissors", k: "knife", e: "eraser", w: "width" };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
 }
@@ -2739,7 +3980,8 @@ var VECTOR_TOOL_SHORTCUTS = {
   line: "L",
   scissors: "C",
   knife: "K",
-  eraser: "E"
+  eraser: "E",
+  width: "W"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -2753,7 +3995,8 @@ var VECTOR_TOOL_GLYPHS = {
   line: "\u2571",
   scissors: "\u2702",
   knife: "\u27CB",
-  eraser: "\u232B"
+  eraser: "\u232B",
+  width: "\u21F9"
 };
 var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line"]);
 var BOOLEAN_OPS = {
@@ -2807,35 +4050,36 @@ var VectorEditorController = (_class3 = class {
   
   __init9() {this.selection = []}
   __init10() {this.anchors = []}
-  __init11() {this.editingId = null}
-  __init12() {this.pen = null}
+  __init11() {this.widthPoint = null}
+  __init12() {this.editingId = null}
+  __init13() {this.pen = null}
   
   
   
   
   
   
-  __init13() {this.hover = null}
-  __init14() {this.pointer = null}
-  __init15() {this.drag = null}
-  __init16() {this.interaction = null}
-  __init17() {this.guides = null}
+  __init14() {this.hover = null}
+  __init15() {this.pointer = null}
+  __init16() {this.drag = null}
+  __init17() {this.interaction = null}
+  __init18() {this.guides = null}
   /** Whether the last `snapDrawn` landed on an object (guides may be hidden). */
-  __init18() {this.snappedToObject = false}
+  __init19() {this.snappedToObject = false}
   /** Drawing targets for hovering the pen and shape tools, kept while the document and the excluded path stay the same. */
-  __init19() {this.hoverTargets = null}
-  __init20() {this.spaceHeld = false}
-  __init21() {this.clipboard = null}
+  __init20() {this.hoverTargets = null}
+  __init21() {this.spaceHeld = false}
+  __init22() {this.clipboard = null}
   
   
-  __init22() {this.listeners = /* @__PURE__ */ new Set()}
-  __init23() {this.cleanups = []}
-  __init24() {this.applying = false}
+  __init23() {this.listeners = /* @__PURE__ */ new Set()}
+  __init24() {this.cleanups = []}
+  __init25() {this.applying = false}
   /** Set while a commit records a change that was already applied, so `restore` still reports it. */
-  __init25() {this.committing = false}
-  __init26() {this.revision = 0}
+  __init26() {this.committing = false}
+  __init27() {this.revision = 0}
   
-  constructor(options = {}) {;_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);_class3.prototype.__init24.call(this);_class3.prototype.__init25.call(this);_class3.prototype.__init26.call(this);_class3.prototype.__init27.call(this);_class3.prototype.__init28.call(this);
+  constructor(options = {}) {;_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);_class3.prototype.__init24.call(this);_class3.prototype.__init25.call(this);_class3.prototype.__init26.call(this);_class3.prototype.__init27.call(this);_class3.prototype.__init28.call(this);_class3.prototype.__init29.call(this);
     this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.HistoryManager)()));
     this.doc = options.document ? cloneVectorDocument(options.document) : { width: 800, height: 600, nodes: [] };
     this.tool = _nullishCoalesce(options.tool, () => ( "select"));
@@ -2864,9 +4108,9 @@ var VectorEditorController = (_class3 = class {
   // State
   // -------------------------------------------------------------------------
   /** The current snapshot (stable until the next change). */
-  __init27() {this.getState = () => this.state}
+  __init28() {this.getState = () => this.state}
   /** Calls `listener` after every change. Returns an unsubscribe function. */
-  __init28() {this.subscribe = (listener) => {
+  __init29() {this.subscribe = (listener) => {
     this.listeners.add(listener);
     return () => {
       this.listeners.delete(listener);
@@ -2885,6 +4129,7 @@ var VectorEditorController = (_class3 = class {
       tool: this.tool,
       selection: this.selection,
       selectedAnchors: this.anchors,
+      selectedWidthPoint: this.widthPoint,
       editingId: this.editingId,
       selectionBounds: this.boundsOf(this.selection),
       selectionFrame: this.frameOf(this.selectedRoots()),
@@ -2909,7 +4154,7 @@ var VectorEditorController = (_class3 = class {
   notify(docChanged = false) {
     this.revision++;
     this.state = this.computeState();
-    if (docChanged) _optionalChain([this, 'access', _38 => _38.onChange, 'optionalCall', _39 => _39(this.doc)]);
+    if (docChanged) _optionalChain([this, 'access', _84 => _84.onChange, 'optionalCall', _85 => _85(this.doc)]);
     const state = this.state;
     this.listeners.forEach((listener) => {
       try {
@@ -2939,20 +4184,24 @@ var VectorEditorController = (_class3 = class {
     return applyMatrix(invertMatrix(this.worldOf(id, doc)), p);
   }
   cursorFor() {
-    if (_optionalChain([this, 'access', _40 => _40.drag, 'optionalAccess', _41 => _41.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
-    if (_optionalChain([this, 'access', _42 => _42.drag, 'optionalAccess', _43 => _43.kind]) === "rotate") return "grabbing";
-    if (_optionalChain([this, 'access', _44 => _44.drag, 'optionalAccess', _45 => _45.kind]) === "move") return "move";
+    if (_optionalChain([this, 'access', _86 => _86.drag, 'optionalAccess', _87 => _87.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
+    if (_optionalChain([this, 'access', _88 => _88.drag, 'optionalAccess', _89 => _89.kind]) === "rotate") return "grabbing";
+    if (_optionalChain([this, 'access', _90 => _90.drag, 'optionalAccess', _91 => _91.kind]) === "move") return "move";
     const h = this.hover;
     switch (this.tool) {
       case "select":
-        if (_optionalChain([h, 'optionalAccess', _46 => _46.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _47 => _47.frameOf, 'call', _48 => _48(this.selectedRoots()), 'optionalAccess', _49 => _49.angle]), () => ( 0)));
-        return _optionalChain([h, 'optionalAccess', _50 => _50.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _92 => _92.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _93 => _93.frameOf, 'call', _94 => _94(this.selectedRoots()), 'optionalAccess', _95 => _95.angle]), () => ( 0)));
+        return _optionalChain([h, 'optionalAccess', _96 => _96.nodeId]) ? "move" : "default";
       case "direct":
-        if (_optionalChain([h, 'optionalAccess', _51 => _51.anchor]) || _optionalChain([h, 'optionalAccess', _52 => _52.handle])) return "pointer";
-        if (_optionalChain([h, 'optionalAccess', _53 => _53.segment])) return "copy";
-        return _optionalChain([h, 'optionalAccess', _54 => _54.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _97 => _97.anchor]) || _optionalChain([h, 'optionalAccess', _98 => _98.handle]) || _optionalChain([h, 'optionalAccess', _99 => _99.corner])) return "pointer";
+        if (_optionalChain([h, 'optionalAccess', _100 => _100.segment])) return "copy";
+        return _optionalChain([h, 'optionalAccess', _101 => _101.nodeId]) ? "move" : "default";
       case "pen":
-        return _optionalChain([h, 'optionalAccess', _55 => _55.anchor]) ? "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _102 => _102.anchor]) ? "pointer" : "crosshair";
+      case "width":
+        if (_optionalChain([this, 'access', _103 => _103.drag, 'optionalAccess', _104 => _104.kind]) === "width") return this.drag.mode === "move" ? "grabbing" : "ew-resize";
+        if (_optionalChain([h, 'optionalAccess', _105 => _105.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
+        return _optionalChain([h, 'optionalAccess', _106 => _106.strokeSpot]) ? "copy" : "default";
       default:
         return "crosshair";
     }
@@ -2972,7 +4221,7 @@ var VectorEditorController = (_class3 = class {
       this.selection = s.selection.filter((id) => this.getNode(id));
       this.anchors = s.anchors.filter((r) => getAnchor(this.doc, r));
       this.editingId = s.editingId && this.getNode(s.editingId) ? s.editingId : null;
-      this.pen = s.pen && _optionalChain([this, 'access', _56 => _56.getNode, 'call', _57 => _57(s.pen.nodeId), 'optionalAccess', _58 => _58.subpaths, 'optionalAccess', _59 => _59[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _107 => _107.getNode, 'call', _108 => _108(s.pen.nodeId), 'optionalAccess', _109 => _109.subpaths, 'optionalAccess', _110 => _110[s.pen.subpath]]) ? s.pen : null;
     } finally {
       this.applying = false;
     }
@@ -3033,12 +4282,12 @@ var VectorEditorController = (_class3 = class {
   // Viewport
   // -------------------------------------------------------------------------
   screenToDocument(p) {
-    const v = this.viewport;
-    return { x: (p.x - v.x) / v.zoom, y: (p.y - v.y) / v.zoom };
+    const v2 = this.viewport;
+    return { x: (p.x - v2.x) / v2.zoom, y: (p.y - v2.y) / v2.zoom };
   }
   documentToScreen(p) {
-    const v = this.viewport;
-    return { x: p.x * v.zoom + v.x, y: p.y * v.zoom + v.y };
+    const v2 = this.viewport;
+    return { x: p.x * v2.zoom + v2.x, y: p.y * v2.zoom + v2.y };
   }
   setViewport(viewport) {
     const next = { ...this.viewport, ...viewport };
@@ -3078,6 +4327,7 @@ var VectorEditorController = (_class3 = class {
     this.tool = tool;
     this.hover = null;
     this.guides = null;
+    this.widthPoint = null;
     if (tool !== "direct") {
       this.anchors = [];
       this.editingId = null;
@@ -3105,9 +4355,9 @@ var VectorEditorController = (_class3 = class {
   toggleSnapping(on = !this.snap.objects) {
     this.setSnap({ objects: on });
   }
-  gridValue(v) {
+  gridValue(v2) {
     const g = this.snap.grid;
-    return g > 0 ? Math.round(v / g) * g : v;
+    return g > 0 ? Math.round(v2 / g) * g : v2;
   }
   snapPoint(p) {
     return { x: this.gridValue(p.x), y: this.gridValue(p.y) };
@@ -3136,7 +4386,7 @@ var VectorEditorController = (_class3 = class {
       if (res.kind) {
         this.snappedToObject = true;
         this.setGuides(res);
-        return _optionalChain([leave, 'optionalAccess', _60 => _60.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', _111 => _111.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);
@@ -3154,14 +4404,14 @@ var VectorEditorController = (_class3 = class {
   /** Where the pointer at `p` would place a point with the pen or a shape tool (and the guides showing why). */
   hoverSnap(p, input) {
     if (this.tool === "pen") {
-      const sp = this.pen ? _optionalChain([this, 'access', _61 => _61.getNode, 'call', _62 => _62(this.pen.nodeId), 'optionalAccess', _63 => _63.subpaths, 'access', _64 => _64[this.pen.subpath]]) : void 0;
-      if (this.pen && sp && _optionalChain([this, 'access', _65 => _65.hover, 'optionalAccess', _66 => _66.anchor])) {
+      const sp = this.pen ? _optionalChain([this, 'access', _112 => _112.getNode, 'call', _113 => _113(this.pen.nodeId), 'optionalAccess', _114 => _114.subpaths, 'access', _115 => _115[this.pen.subpath]]) : void 0;
+      if (this.pen && sp && _optionalChain([this, 'access', _116 => _116.hover, 'optionalAccess', _117 => _117.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', _67 => _67.pen, 'optionalAccess', _68 => _68.nodeId]), () => ( null))));
+      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _118 => _118.pen, 'optionalAccess', _119 => _119.nodeId]), () => ( null))));
     }
     if (SHAPE_TOOLS.has(this.tool)) return this.snapDrawn(p, null, input, () => this.drawingTargets(null));
     this.setGuides(null);
@@ -3263,7 +4513,7 @@ var VectorEditorController = (_class3 = class {
     let subpath;
     switch (input.kind) {
       case "rect":
-        subpath = rectSubpath(b, _nullishCoalesce(input.cornerRadius, () => ( d.cornerRadius)));
+        subpath = rectSubpath(b);
         break;
       case "ellipse":
         subpath = ellipseSubpath(b);
@@ -3278,10 +4528,13 @@ var VectorEditorController = (_class3 = class {
         subpath = lineSubpath({ x: b.x, y: b.y }, { x: b.x + b.width, y: b.y + b.height });
         break;
     }
+    const radius = _nullishCoalesce(input.cornerRadius, () => ( d.cornerRadius));
+    const kind = _nullishCoalesce(input.cornerKind, () => ( d.cornerKind));
+    if ((input.kind === "rect" || input.kind === "polygon" || input.kind === "star") && radius > 0) subpath = setSubpathCorners(subpath, radius, kind);
     const names = { rect: "Rectangle", ellipse: "Ellipse", polygon: "Polygon", star: "Star", line: "Line" };
     const style = this.styleFor(input.kind === "line");
     const own = {};
-    for (const key of ["fill", "stroke", "strokeWidth", "strokeLinecap", "strokeLinejoin", "strokeDasharray", "fillRule"]) {
+    for (const key of VECTOR_STYLE_KEYS) {
       if (input[key] !== void 0) own[key] = input[key];
     }
     return { id: this.newId(), type: "path", name: _nullishCoalesce(input.name, () => ( names[input.kind])), ...style, ...own, subpaths: [subpath] };
@@ -3304,6 +4557,9 @@ var VectorEditorController = (_class3 = class {
     if (d.strokeLinejoin) out.strokeLinejoin = d.strokeLinejoin;
     if (d.strokeDasharray) out.strokeDasharray = d.strokeDasharray;
     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', _120 => _120.strokeWidthProfile, 'optionalAccess', _121 => _121.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     return out;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -3324,10 +4580,129 @@ var VectorEditorController = (_class3 = class {
     }
     if (!targets.size) return { ok: false, message: "Nothing is selected." };
     this.change(_nullishCoalesce(options.label, () => ( "Change Style")), () => {
-      this.setDoc(mapTree(this.doc.nodes, (n) => targets.has(n.id) ? { ...n, ...style } : n));
+      this.setDoc(mapTree(this.doc.nodes, (n) => targets.has(n.id) ? withStyle(n, style) : n));
+    });
+    return { ok: true };
+  }
+  /**
+   * Sets the variable-width profile of the selected (or given) paths: a preset id
+   * (`uniform` removes the profile), points, or a parametric taper / wave. Returns an error for
+   * an unknown preset.
+   */
+  setWidthProfile(profile, options = {}) {
+    let points;
+    if (profile === null) points = [];
+    else if (typeof profile === "string") {
+      const preset = widthProfilePreset(profile);
+      if (!preset) return { ok: false, message: `There is no width profile "${profile}".` };
+      points = preset;
+    } else if (Array.isArray(profile)) points = sanitizeWidthProfile(profile);
+    else {
+      const p = profile;
+      points = p.taper || p.wave ? generateWidthProfile(p) : [];
+    }
+    this.widthPoint = null;
+    return this.setStyle({ strokeWidthProfile: points.length ? points : null }, _nullishCoalesce(options.ids, () => ( this.selection)), { label: points.length ? "Width Profile" : "Uniform Width" });
+  }
+  /** Removes one width point of a path's profile (the width tool's Delete). */
+  removeWidthPoint(ref) {
+    const node = this.getNode(ref.nodeId);
+    if (_optionalChain([node, 'optionalAccess', _122 => _122.type]) !== "path" || !_optionalChain([node, 'access', _123 => _123.strokeWidthProfile, 'optionalAccess', _124 => _124[ref.index]])) return { ok: false, message: "There is no such width point." };
+    const rest = removeWidthPoints(sanitizeWidthProfile(node.strokeWidthProfile), [ref.index]);
+    this.widthPoint = null;
+    this.change("Delete Width Point", () => this.replaceNode(node.id, withStyle(node, { strokeWidthProfile: rest.length ? rest : null })));
+    return { ok: true };
+  }
+  /**
+   * Sets the live corner radius (and optionally the kind) of anchors: `refs`, else the selected
+   * anchors (direct tool), else every anchor of the `ids` / selected paths. Radius 0 makes the
+   * corners sharp again. Corners shrink to fit when drawn, so any radius is accepted.
+   */
+  setCornerRadius(radius, options = {}) {
+    if (!Number.isFinite(radius) || radius < 0) return { ok: false, message: "The radius must be a number of at least 0." };
+    const refs = this.cornerTargets(options);
+    if (!refs.length) return { ok: false, message: "Nothing is selected." };
+    this.change(radius > 0 ? "Corner Radius" : "Sharpen Corners", () => {
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, radius, options.kind));
+    });
+    return { ok: true };
+  }
+  /** Sets the live corner kind of the same anchors as `setCornerRadius`, keeping their radii. */
+  setCornerKind(kind, options = {}) {
+    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', _125 => _125.corner, 'optionalAccess', _126 => _126.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
+  /** Anchors a corner change applies to (see `setCornerRadius`). */
+  cornerTargets(options) {
+    if (options.refs) return options.refs.filter((r) => getAnchor(this.doc, r));
+    if (!options.ids && this.tool === "direct" && this.anchors.length) return this.anchors.slice();
+    const out = [];
+    for (const id of _nullishCoalesce(options.ids, () => ( this.selection))) {
+      const node = this.getNode(id);
+      if (!node) continue;
+      for (const p of collectPathNodes(node)) {
+        if (p.locked) continue;
+        p.subpaths.forEach((sp, s) => sp.anchors.forEach((_, i) => out.push({ nodeId: p.id, subpath: s, index: i })));
+      }
+    }
+    return out;
+  }
+  /**
+   * Outline Stroke: replaces each selected (or given) path's stroke with a filled path of the
+   * area it paints (alignment, joins, caps, dashes and arrowheads included), placed above a copy
+   * of the path that keeps the fill (left out when there is none). Returns the new paths' ids.
+   */
+  outlineStroke(options = {}) {
+    const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
+    const paths = [];
+    for (const id of roots) {
+      const node = this.getNode(id);
+      if (node) {
+        for (const p of collectPathNodes(node)) if (!p.locked && hasPaint(p.stroke) && (_nullishCoalesce(p.strokeWidth, () => ( 1))) > 0) paths.push(p);
+      }
+    }
+    if (!paths.length) return [];
+    const created = [];
+    const replace = /* @__PURE__ */ new Map();
+    for (const p of paths) {
+      const outline = bezierToSubpaths(vectorStrokeOutlinePath(subpathsToBezier(p.subpaths), p));
+      if (!outline.length) continue;
+      const {
+        stroke,
+        strokeWidth: _w,
+        strokeLinecap: _c,
+        strokeLinejoin: _j,
+        strokeDasharray: _d,
+        strokeAlign: _a,
+        startArrow: _s,
+        endArrow: _e,
+        arrowAlign: _al,
+        startArrowScale: _ss,
+        endArrowScale: _es,
+        strokeWidthProfile: _wp,
+        ...rest
+      } = cloneVectorNode(p);
+      const id = this.newId();
+      const strokeNode = { ...rest, id, name: `${_nullishCoalesce(p.name, () => ( "Path"))} Stroke`, subpaths: outline, fill: _nullishCoalesce(stroke, () => ( null)), stroke: null, fillRule: "nonzero" };
+      const list = hasPaint(p.fill) ? [{ ...rest, stroke: null }, strokeNode] : [strokeNode];
+      created.push(id);
+      replace.set(p.id, list);
+    }
+    if (!created.length) return [];
+    this.change("Outline Stroke", () => {
+      let nodes = this.doc.nodes;
+      for (const [id, list] of replace) nodes = spliceTree(nodes, id, list);
+      this.setDoc(nodes);
+      this.selection = created;
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return created;
+  }
   rename(id, name) {
     return this.updateNode(id, { name }, { label: "Rename" });
   }
@@ -3396,10 +4771,10 @@ var VectorEditorController = (_class3 = class {
     return this.selection.filter((id) => {
       let covered = false;
       const loc = locateVectorNode(this.doc.nodes, id);
-      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _69 => _69.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _127 => _127.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _70 => _70(this.doc.nodes, parent.id), 'optionalAccess', _71 => _71.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _128 => _128(this.doc.nodes, parent.id), 'optionalAccess', _129 => _129.parent]), () => ( null));
       }
       return !covered;
     });
@@ -3582,8 +4957,8 @@ var VectorEditorController = (_class3 = class {
     if (!ids.length) return null;
     const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
     if (locs.some((l) => !l)) return null;
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _72 => _72[0], 'access', _73 => _73.parent, 'optionalAccess', _74 => _74.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _75 => _75.parent, 'optionalAccess', _76 => _76.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _130 => _130[0], 'access', _131 => _131.parent, 'optionalAccess', _132 => _132.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _133 => _133.parent, 'optionalAccess', _134 => _134.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -3606,11 +4981,11 @@ var VectorEditorController = (_class3 = class {
   }
   /** Replaces selected groups with their children. */
   ungroup(options = {}) {
-    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _77 => _77.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _135 => _135.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", () => {
-      const flatten = (list) => {
+      const flatten2 = (list) => {
         const out = [];
         let changed = false;
         for (const n of list) {
@@ -3622,14 +4997,14 @@ var VectorEditorController = (_class3 = class {
               ...n.children.map((c) => n.transform ? transformVectorNode(c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c)
             );
           } else if (n.type === "group") {
-            const children = flatten(n.children);
+            const children = flatten2(n.children);
             if (children !== n.children) changed = true;
             out.push(children !== n.children ? { ...n, children } : n);
           } else out.push(n);
         }
         return changed ? out : list;
       };
-      this.setDoc(flatten(this.doc.nodes));
+      this.setDoc(flatten2(this.doc.nodes));
       this.selection = groups.flatMap((g) => g.children.map((c) => c.id));
     });
     return { ok: true };
@@ -3666,7 +5041,7 @@ var VectorEditorController = (_class3 = class {
     });
     const paths = [...new Set(order)].map((id2) => this.getNode(id2));
     if (paths.length < 2) return null;
-    const result = _chunkBGNPT5PEcjs.pathBoolean.call(void 0, 
+    const result = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, 
       BOOLEAN_OPS[op],
       paths.map((p) => ({
         path: vectorPathWorldBezier(
@@ -3716,11 +5091,11 @@ var VectorEditorController = (_class3 = class {
   /** A document-space path mapped into the parent space of node `id`. */
   intoParentSpace(id, path) {
     const parent = _nullishCoalesce(vectorParentMatrix(this.doc.nodes, id), () => ( IDENTITY_MATRIX));
-    return isRoot(parent) ? path : _chunkBGNPT5PEcjs.transformBezierPath.call(void 0, path, invertMatrix(parent));
+    return isRoot(parent) ? path : _chunkGVB7ZPLZcjs.transformBezierPath.call(void 0, path, invertMatrix(parent));
   }
   /** 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', _78 => _78.type]) === "path" && n.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _136 => _136.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));
@@ -3782,7 +5157,7 @@ var VectorEditorController = (_class3 = class {
   /** `doc` with anchor `ref` moved to document point `to` by a Curvature-tool move. */
   curvatureMoved(doc, ref, to) {
     const node = findVectorNode(doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _79 => _79.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _137 => _137.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);
@@ -3791,7 +5166,7 @@ var VectorEditorController = (_class3 = class {
   /** `doc` with segment `ref` bent through document point `p` at parameter `t`. */
   bent(doc, ref, t, p) {
     const node = findVectorNode(doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _80 => _80.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _138 => _138.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) };
@@ -3802,7 +5177,7 @@ var VectorEditorController = (_class3 = class {
    */
   bendSegment(ref, to, t = 0.5) {
     const node = this.getNode(ref.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _81 => _81.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _139 => _139.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", () => {
@@ -3837,7 +5212,7 @@ var VectorEditorController = (_class3 = class {
   /** Adds an anchor on the nearest segment of `nodeId` to document point `point` (shape unchanged). */
   insertAnchorAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _82 => _82.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _140 => _140.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);
@@ -3881,7 +5256,7 @@ var VectorEditorController = (_class3 = class {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n = this.getNode(nodeId);
-      return _optionalChain([n, 'optionalAccess', _83 => _83.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n, 'optionalAccess', _141 => _141.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", () => {
@@ -3899,7 +5274,12 @@ var VectorEditorController = (_class3 = class {
     const set = new Set(ids.flatMap((id) => this.getNode(id) ? collectPathNodes(this.getNode(id)) : []).map((p) => p.id));
     if (!set.size) return { ok: false, message: "Select a path." };
     this.change("Reverse Path", () => {
-      this.setDoc(mapTree(this.doc.nodes, (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath) } : n));
+      this.setDoc(
+        mapTree(
+          this.doc.nodes,
+          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _142 => _142.strokeWidthProfile, 'optionalAccess', _143 => _143.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
+        )
+      );
       this.anchors = [];
     });
     return { ok: true };
@@ -3930,7 +5310,7 @@ var VectorEditorController = (_class3 = class {
     const map = (p) => applyMatrix(m, p);
     return from.subpaths.map((sp) => ({
       closed: sp.closed,
-      anchors: sp.anchors.map((a) => ({ ...map(a), ...a.in ? { in: map(a.in) } : {}, ...a.out ? { out: map(a.out) } : {}, ...a.type ? { type: a.type } : {} }))
+      anchors: sp.anchors.map((a) => ({ ...map(a), ...a.in ? { in: map(a.in) } : {}, ...a.out ? { out: map(a.out) } : {}, ...a.type ? { type: a.type } : {}, ...a.corner ? { corner: { ...a.corner } } : {} }))
     }));
   }
   /**
@@ -3980,9 +5360,9 @@ var VectorEditorController = (_class3 = class {
     const cx = points.reduce((s, p) => s + p.at.x, 0) / points.length;
     const cy = points.reduce((s, p) => s + p.at.y, 0) / points.length;
     this.change("Average", () => {
-      for (const { ref, at } of points) {
-        const dx = axis === "horizontal" ? 0 : cx - at.x;
-        const dy = axis === "vertical" ? 0 : cy - at.y;
+      for (const { ref, at: at2 } of points) {
+        const dx = axis === "horizontal" ? 0 : cx - at2.x;
+        const dy = axis === "vertical" ? 0 : cy - at2.y;
         if (dx || dy) this.doc = this.movedAnchors(this.doc, [ref], dx, dy);
       }
     });
@@ -4035,7 +5415,7 @@ var VectorEditorController = (_class3 = class {
    */
   cutPathAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _84 => _84.type]) !== "path" || node.locked) return null;
+    if (_optionalChain([node, 'optionalAccess', _144 => _144.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
     const hit = nearestSegment(node, local);
     if (!hit) return null;
@@ -4066,8 +5446,8 @@ var VectorEditorController = (_class3 = class {
         const node = this.getNode(id);
         if (node.locked) continue;
         const ids = this.applyCuts(node, (sp, i) => {
-          const at = list.filter((r) => r.subpath === i).map((r) => r.index);
-          const pieces = at.length ? cutSubpathAt(sp, at) : null;
+          const at2 = list.filter((r) => r.subpath === i).map((r) => r.index);
+          const pieces = at2.length ? cutSubpathAt(sp, at2) : null;
           return pieces && !(pieces.length === 1 && pieces[0].closed === sp.closed) ? pieces : null;
         });
         if (ids) created.push(...ids);
@@ -4085,7 +5465,7 @@ var VectorEditorController = (_class3 = class {
       if (n.visible === false || n.locked || parent && blocked.has(parent.id)) blocked.add(n.id);
     });
     const visible = (p) => !blocked.has(p.id);
-    if (_optionalChain([ids, 'optionalAccess', _85 => _85.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
+    if (_optionalChain([ids, 'optionalAccess', _145 => _145.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 = [];
@@ -4141,10 +5521,10 @@ var VectorEditorController = (_class3 = class {
     const region = eraserRegion(pts, width);
     if (!region.length) return [];
     const plan = [];
-    const rb = _chunkBGNPT5PEcjs.bezierPathBounds.call(void 0, region);
+    const rb = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, region);
     const reach = rb ? [{ x: rb.minX, y: rb.minY }, { x: rb.maxX, y: rb.maxY }] : points;
     for (const node of this.strokeTargets(reach, options.ids, 0)) {
-      const local = _chunkBGNPT5PEcjs.transformBezierPath.call(void 0, region, invertMatrix(this.worldOf(node.id)));
+      const local = _chunkGVB7ZPLZcjs.transformBezierPath.call(void 0, region, invertMatrix(this.worldOf(node.id)));
       const live = node.subpaths.filter((sp) => sp.anchors.length > 1);
       if (!live.length) continue;
       if (hasPaint(node.fill) && live.every((sp) => sp.closed)) {
@@ -4171,7 +5551,7 @@ var VectorEditorController = (_class3 = class {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _86 => _86.subpaths, 'access', _87 => _87[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _146 => _146.subpaths, 'access', _147 => _147[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -4215,19 +5595,19 @@ var VectorEditorController = (_class3 = class {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _88 => _88.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
-        } catch (e2) {
+          if (_optionalChain([data, 'optionalAccess', _148 => _148.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
+        } catch (e3) {
           nodes = null;
         }
       } else if (/<svg[\s>]/i.test(trimmed)) {
         try {
           nodes = parseVectorSvg(trimmed).nodes;
-        } catch (e3) {
+        } catch (e4) {
           nodes = null;
         }
       }
     } else nodes = this.clipboard;
-    if (!_optionalChain([nodes, 'optionalAccess', _89 => _89.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _149 => _149.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", () => {
@@ -4278,13 +5658,29 @@ var VectorEditorController = (_class3 = class {
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
       const a = getAnchorWorld(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _90 => _90[ref.handle]]);
+      const h = _optionalChain([a, 'optionalAccess', _150 => _150[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;
     }
     return null;
   }
+  cornerView() {
+    return { ...this.view(), viewport: this.viewport };
+  }
+  hitCornerWidget(screen) {
+    let best = null;
+    let bestD = Infinity;
+    for (const w of getVectorCornerWidgets(this.cornerView())) {
+      const s = this.documentToScreen(w);
+      const d = Math.hypot(s.x - screen.x, s.y - screen.y);
+      if (d <= this.hitRadius && d < bestD) {
+        best = w;
+        bestD = d;
+      }
+    }
+    return best;
+  }
   hitAnchor(screen, refs) {
     let best = null;
     let bestD = Infinity;
@@ -4343,6 +5739,8 @@ var VectorEditorController = (_class3 = class {
         if (handle) return { nodeId: handle.nodeId, handle };
         const anchor = this.hitAnchor(screen, getVisibleAnchors(this.view()));
         if (anchor) return { nodeId: anchor.nodeId, anchor };
+        const widget = this.hitCornerWidget(screen);
+        if (widget) return { nodeId: widget.ref.nodeId, corner: widget.ref };
         for (const id of getEditablePathIds(this.view())) {
           const node = this.getNode(id);
           const seg = nearestSegment(node, this.toLocal(id, p));
@@ -4363,10 +5761,131 @@ var VectorEditorController = (_class3 = class {
         const seg = this.nearestOutline(p);
         return seg ? { nodeId: seg.nodeId, segment: seg } : null;
       }
+      case "width": {
+        const hit = this.hitWidthHandle(screen);
+        if (hit) return { nodeId: hit.ref.nodeId, widthPoint: hit.ref };
+        const spot = this.strokeSpotAt(p);
+        return spot ? { nodeId: spot.nodeId, strokeSpot: spot } : null;
+      }
       default:
         return null;
     }
   }
+  widthView() {
+    return { document: this.doc, selection: this.selection, tool: this.tool, hover: this.hover, interaction: this.interaction, selectedWidthPoint: this.widthPoint };
+  }
+  /** The width point centre or side end under `screen` (width tool). */
+  hitWidthHandle(screen) {
+    let best = null;
+    let bestD = Infinity;
+    for (const h of getVectorWidthHandles(this.widthView())) {
+      for (const [part, q] of [["center", h], ["left", h.left], ["right", h.right]]) {
+        const s = this.documentToScreen(q);
+        const d = Math.hypot(s.x - screen.x, s.y - screen.y);
+        if (d <= this.hitRadius && d < bestD - 1e-9) {
+          best = { ref: { ...h.ref, part } };
+          bestD = d;
+        }
+      }
+    }
+    return best;
+  }
+  /** The nearest stroked, unlocked visible path whose stroke is under document point `p` (width tool). */
+  strokeSpotAt(p) {
+    let best = null;
+    const tol = this.tolerance();
+    walkVectorNodes(this.doc.nodes, (n) => {
+      if (n.type !== "path" || n.visible === false || n.locked) return;
+      if (hiddenOrLocked(this.doc.nodes, n.id)) return;
+      const g = vectorStrokeWidthGeometry(n);
+      if (!g) return;
+      const m = this.worldOf(n.id);
+      const local = applyMatrix(invertMatrix(m), p);
+      const near2 = nearestStrokePosition(g.line, [local.x, local.y]);
+      if (!near2) return;
+      const profile = strokeWidthProfileOf(n);
+      const w = widthProfileAt(profile, near2.t);
+      const reach = Math.max(near2.side === "left" ? w.left : w.right, 0) * g.unit + tol;
+      if (near2.distance > reach || near2.distance > widthProfileMaxScale(profile) * g.unit + tol) return;
+      if (best && near2.distance >= best.distance) return;
+      const nx = near2.tangent[1];
+      const ny = -near2.tangent[0];
+      const [cx, cy] = near2.point;
+      best = {
+        nodeId: n.id,
+        subpath: near2.contour,
+        t: near2.t,
+        point: applyMatrix(m, { x: cx, y: cy }),
+        left: applyMatrix(m, { x: cx + nx * w.left * g.unit, y: cy + ny * w.left * g.unit }),
+        right: applyMatrix(m, { x: cx - nx * w.right * g.unit, y: cy - ny * w.right * g.unit }),
+        distance: near2.distance
+      };
+    });
+    if (!best) return null;
+    const { distance: _d, ...spot } = best;
+    return spot;
+  }
+  downWidth(screen, p, input) {
+    const hit = this.hitWidthHandle(screen);
+    const spot = hit ? null : this.strokeSpotAt(p);
+    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _151 => _151.ref, 'access', _152 => _152.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _153 => _153.nodeId])));
+    const node = nodeId ? this.getNode(nodeId) : void 0;
+    const g = _optionalChain([node, 'optionalAccess', _154 => _154.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
+    if (!node || node.type !== "path" || !g) {
+      if (this.widthPoint) {
+        this.widthPoint = null;
+        this.notify();
+      }
+      return;
+    }
+    const before = this.snapshot();
+    const local = this.toLocal(node.id, p);
+    let profile;
+    let ref;
+    let mode = "width";
+    let side = "both";
+    let t;
+    let subpath;
+    if (hit) {
+      profile = sanitizeWidthProfile(node.strokeWidthProfile);
+      ref = { nodeId: node.id, index: hit.ref.index, subpath: hit.ref.subpath };
+      t = _nullishCoalesce(_optionalChain([profile, 'access', _155 => _155[ref.index], 'optionalAccess', _156 => _156.t]), () => ( 0));
+      subpath = hit.ref.subpath;
+      if (hit.ref.part === "center") mode = "move";
+      else if (input.alt) side = hit.ref.part;
+    } else {
+      const near2 = nearestStrokePosition(g.line, [local.x, local.y]);
+      const inserted = insertWidthPoint(strokeWidthProfileOf(node), near2.t);
+      profile = inserted.points;
+      subpath = near2.contour;
+      t = near2.t;
+      ref = { nodeId: node.id, index: inserted.index, subpath };
+      if (input.alt) side = near2.side;
+    }
+    const at2 = strokePositionPoint(g.line, subpath, t);
+    if (!at2) return;
+    const base = { ...this.doc, nodes: mapTree(this.doc.nodes, (n) => n.id === node.id ? { ...n, strokeWidthProfile: profile } : n) };
+    this.doc = base;
+    this.widthPoint = { nodeId: node.id, index: ref.index, subpath };
+    this.drag = {
+      kind: "width",
+      ref,
+      mode,
+      side,
+      origin: { x: at2.point[0], y: at2.point[1] },
+      normal: { x: at2.tangent[1], y: -at2.tangent[0] },
+      unit: g.unit,
+      profile,
+      before,
+      base,
+      start: p,
+      moved: false,
+      created: !hit
+    };
+    const w = profile[ref.index];
+    this.interaction = { type: "width", ref, mode, width: (w.left + w.right) * g.unit };
+    this.notify(!hit);
+  }
   /** The nearest outline point of any visible, unlocked path within the pick distance of document point `p`. */
   nearestOutline(p) {
     let best = null;
@@ -4414,7 +5933,9 @@ var VectorEditorController = (_class3 = class {
       case "pen":
         return this.downPen(screen, p, input);
       case "pencil":
-        return this.downPencil(p);
+        return this.downPencil(p, input);
+      case "width":
+        return this.downWidth(screen, p, input);
       case "scissors": {
         const seg = this.nearestOutline(p);
         if (seg) this.cutPathAt(seg.nodeId, seg.point);
@@ -4500,6 +6021,13 @@ var VectorEditorController = (_class3 = class {
       this.notify();
       return;
     }
+    const widget = this.hitCornerWidget(screen);
+    if (widget) {
+      const refs = getVectorCornerWidgets(this.cornerView()).map((w) => w.ref);
+      this.drag = { kind: "corner", widget, refs, start: p, before: this.snapshot(), base: this.doc, moved: false, alt: !!input.alt, shift: !!input.shift };
+      this.notify();
+      return;
+    }
     for (const id of getEditablePathIds(this.view())) {
       const node = this.getNode(id);
       const seg = nearestSegment(node, this.toLocal(id, p));
@@ -4543,7 +6071,7 @@ var VectorEditorController = (_class3 = class {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _91 => _91.getNode, 'call', _92 => _92(this.pen.nodeId), 'optionalAccess', _93 => _93.subpaths, 'access', _94 => _94[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _157 => _157.getNode, 'call', _158 => _158(this.pen.nodeId), 'optionalAccess', _159 => _159.subpaths, 'access', _160 => _160[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -4557,10 +6085,10 @@ var VectorEditorController = (_class3 = class {
       }
       const last = getAnchorWorld(this.doc, { nodeId: pen.nodeId, subpath: pen.subpath, index: sp.anchors.length - 1 });
       const leave = { at: { x: last.x, y: last.y }, constrain: input.shift ? "angle" : null };
-      let pt2 = this.snapDrawn(p, leave, input, () => this.drawingTargets(pen.nodeId));
-      pt2 = this.toLocal(pen.nodeId, pt2);
+      let pt3 = this.snapDrawn(p, leave, input, () => this.drawingTargets(pen.nodeId));
+      pt3 = this.toLocal(pen.nodeId, pt3);
       const node2 = this.getNode(pen.nodeId);
-      const anchors = [...sp.anchors, { x: pt2.x, y: pt2.y }];
+      const anchors = [...sp.anchors, { x: pt3.x, y: pt3.y }];
       this.replaceNode(pen.nodeId, { ...node2, subpaths: node2.subpaths.map((s, i) => i === pen.subpath ? { ...s, anchors } : s) });
       const ref2 = { nodeId: pen.nodeId, subpath: pen.subpath, index: anchors.length - 1 };
       this.anchors = [ref2];
@@ -4588,8 +6116,8 @@ var VectorEditorController = (_class3 = class {
       this.notify(this.doc !== before.doc);
       return;
     }
-    const pt = this.snapDrawn(p, null, input, () => this.drawingTargets(null));
-    const node = { id: this.newId(), type: "path", name: "Path", ...this.styleFor(true), subpaths: [{ anchors: [{ x: pt.x, y: pt.y }], closed: false }] };
+    const pt2 = this.snapDrawn(p, null, input, () => this.drawingTargets(null));
+    const node = { id: this.newId(), type: "path", name: "Path", ...this.styleFor(true), subpaths: [{ anchors: [{ x: pt2.x, y: pt2.y }], closed: false }] };
     this.setDoc([...this.doc.nodes, node]);
     this.pen = { nodeId: node.id, subpath: 0 };
     this.selection = [node.id];
@@ -4600,7 +6128,7 @@ var VectorEditorController = (_class3 = class {
     this.interaction = { type: "pen", nodeId: node.id };
     this.notify(true);
   }
-  downPencil(p) {
+  downPencil(p, input = {}) {
     const before = this.snapshot();
     const node = {
       id: this.newId(),
@@ -4614,7 +6142,11 @@ var VectorEditorController = (_class3 = class {
     this.setDoc([...this.doc.nodes, node]);
     const lazy = new LazyMouse(this.editing.pencilSmoothing * VECTOR_PENCIL_STRING_PX / this.viewport.zoom);
     lazy.push([p.x, p.y]);
-    this.drag = { kind: "pencil", nodeId: node.id, points: [[p.x, p.y]], before, lazy };
+    const mode = this.editing.pencilPressure;
+    const hasPressure = typeof input.pressure === "number" && Number.isFinite(input.pressure);
+    const record = hasPressure && (mode === "all" || mode === "pen" && input.pointerType === "pen");
+    const pressure = hasPressure ? input.pressure : 0.5;
+    this.drag = { kind: "pencil", nodeId: node.id, points: [[p.x, p.y]], before, lazy, pressures: record ? [pressure] : null, pressure };
     this.interaction = { type: "draw", tool: "pencil", nodeId: node.id, bounds: { x: p.x, y: p.y, width: 0, height: 0 } };
     this.notify(true);
   }
@@ -4737,13 +6269,25 @@ var VectorEditorController = (_class3 = class {
       case "handle": {
         const anchor = getAnchorWorld(drag.base, drag.ref);
         const leave = anchor ? { at: { x: anchor.x, y: anchor.y }, constrain: input.shift ? "angle" : null } : null;
-        const pt = this.snapDrawn(p, leave, input, () => drag.targets ??= VectorSnapTargets.forHandle(drag.base, drag.ref.nodeId));
-        const local = this.toLocal(drag.ref.nodeId, pt, drag.base);
+        const pt2 = this.snapDrawn(p, leave, input, () => drag.targets ??= VectorSnapTargets.forHandle(drag.base, drag.ref.nodeId));
+        const local = this.toLocal(drag.ref.nodeId, pt2, drag.base);
         this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => moveAnchorHandle(a, drag.ref.handle, local, input.alt));
         this.interaction = { type: "handle", ref: drag.ref };
         this.notify(true);
         return;
       }
+      case "corner": {
+        if (!drag.moved && Math.hypot(p.x - drag.start.x, p.y - drag.start.y) * this.viewport.zoom < 3) return;
+        drag.moved = true;
+        const c = drag.widget.corner;
+        const inv = invertMatrix(this.worldOf(drag.widget.ref.nodeId, drag.base));
+        const d = applyMatrixLinear(inv, { x: p.x - drag.start.x, y: p.y - drag.start.y });
+        const radius = Math.max(0, Math.min(c.maxRadius, drag.widget.drawnRadius + cornerRadiusChange(c, d)));
+        this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, radius));
+        this.interaction = { type: "corner", ref: drag.widget.ref, radius };
+        this.notify(true);
+        return;
+      }
       case "bend": {
         if (!drag.moved && Math.hypot(p.x - drag.start.x, p.y - drag.start.y) * this.viewport.zoom < 2) return;
         drag.moved = true;
@@ -4769,10 +6313,10 @@ var VectorEditorController = (_class3 = class {
           return;
         }
         this.guides = null;
-        let pt = p;
-        if (input.shift) pt = constrain45(anchor, pt);
+        let pt2 = p;
+        if (input.shift) pt2 = constrain45(anchor, pt2);
         const side = drag.closing ? "in" : "out";
-        const pos = this.toLocal(drag.ref.nodeId, drag.closing ? { x: 2 * anchor.x - pt.x, y: 2 * anchor.y - pt.y } : pt, drag.base);
+        const pos = this.toLocal(drag.ref.nodeId, drag.closing ? { x: 2 * anchor.x - pt2.x, y: 2 * anchor.y - pt2.y } : pt2, drag.base);
         this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => {
           if (drag.outOnly || drag.altBreaks && input.alt) return moveAnchorHandle(a, side, pos, true);
           return moveAnchorHandle({ ...a, type: "symmetric" }, side, pos);
@@ -4782,7 +6326,7 @@ var VectorEditorController = (_class3 = class {
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _95 => _95.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _161 => _161.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);
@@ -4811,19 +6355,43 @@ var VectorEditorController = (_class3 = class {
         this.notify(true);
         return;
       }
+      case "width": {
+        if (!drag.moved && Math.hypot(p.x - drag.start.x, p.y - drag.start.y) * this.viewport.zoom < 2) return;
+        drag.moved = true;
+        const node = findVectorNode(drag.base.nodes, drag.ref.nodeId);
+        const local = this.toLocal(node.id, p, drag.base);
+        let profile;
+        if (drag.mode === "move") {
+          const g = vectorStrokeWidthGeometry(node);
+          const near2 = g ? nearestStrokePosition(g.line, [local.x, local.y], drag.ref.subpath) : null;
+          if (!near2) return;
+          profile = setWidthPoint(drag.profile, drag.ref.index, { t: near2.t });
+        } else {
+          const off = ((local.x - drag.origin.x) * drag.normal.x + (local.y - drag.origin.y) * drag.normal.y) / drag.unit;
+          const patch = drag.side === "both" ? { left: Math.abs(off), right: Math.abs(off) } : drag.side === "left" ? { left: Math.max(0, off) } : { right: Math.max(0, -off) };
+          profile = setWidthPoint(drag.profile, drag.ref.index, patch);
+        }
+        this.doc = { ...drag.base, nodes: mapTree(drag.base.nodes, (n) => n.id === node.id ? { ...n, strokeWidthProfile: profile } : n) };
+        const w = profile[drag.ref.index];
+        this.interaction = { type: "width", ref: drag.ref, mode: drag.mode, width: (w.left + w.right) * drag.unit };
+        this.notify(true);
+        return;
+      }
       case "pencil": {
         const last = drag.points[drag.points.length - 1];
         let moved = false;
+        if (typeof input.pressure === "number" && Number.isFinite(input.pressure)) drag.pressure = input.pressure;
         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', _162 => _162.pressures, 'optionalAccess', _163 => _163.push, 'call', _164 => _164(drag.pressure)]);
           moved = true;
         }
         const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _96 => _96.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _165 => _165.type]) !== "path") return;
         if (!moved) {
-          if (string && _optionalChain([this, 'access', _97 => _97.interaction, 'optionalAccess', _98 => _98.type]) === "draw") {
+          if (string && _optionalChain([this, 'access', _166 => _166.interaction, 'optionalAccess', _167 => _167.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();
           }
@@ -4859,8 +6427,8 @@ var VectorEditorController = (_class3 = class {
     }
     this.setGuides(res);
     return {
-      dx: _optionalChain([res, 'optionalAccess', _99 => _99.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
-      dy: _optionalChain([res, 'optionalAccess', _100 => _100.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+      dx: _optionalChain([res, 'optionalAccess', _168 => _168.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: _optionalChain([res, 'optionalAccess', _169 => _169.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. */
@@ -4885,19 +6453,19 @@ var VectorEditorController = (_class3 = class {
     const guides = { lines: [], labels: [] };
     for (const axis of ["x", "y"]) {
       const d = end[axis] - start[axis];
-      const len = Math.abs(d) > 1e-9 ? targets.matchSize(Math.abs(d) * k, tol) : null;
-      if (len === null || len <= 0) continue;
-      out[axis] = start[axis] + Math.sign(d) * len / k;
+      const len2 = Math.abs(d) > 1e-9 ? targets.matchSize(Math.abs(d) * k, tol) : null;
+      if (len2 === null || len2 <= 0) continue;
+      out[axis] = start[axis] + Math.sign(d) * len2 / k;
       const from = { ...out, [axis]: fromCentre ? 2 * start[axis] - out[axis] : start[axis] };
       guides.lines.push({ kind: "size", x1: from.x, y1: from.y, x2: out.x, y2: out.y });
-      guides.labels.push({ kind: "size", x: (from.x + out.x) / 2, y: (from.y + out.y) / 2, text: `${axis === "x" ? "W" : "H"} ${Math.round(len * 100) / 100}` });
+      guides.labels.push({ kind: "size", x: (from.x + out.x) / 2, y: (from.y + out.y) / 2, text: `${axis === "x" ? "W" : "H"} ${Math.round(len2 * 100) / 100}` });
     }
     this.setGuides(guides);
     return out;
   }
   /** Primary button released. */
   pointerUp(screen, input = {}) {
-    if (screen && this.drag && this.drag.kind !== "pan") this.pointerMove(screen, input);
+    if (screen && this.drag && this.drag.kind !== "pan") this.pointerMove(screen, { ...input, pressure: void 0 });
     const drag = this.drag;
     this.drag = null;
     this.interaction = null;
@@ -4935,6 +6503,29 @@ var VectorEditorController = (_class3 = class {
           return;
         }
         return this.commit("Bend Segment", drag.before);
+      case "corner": {
+        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', _170 => _170.corner, 'optionalAccess', _171 => _171.radius]), () => ( 0)), kind));
+          return this.commit("Corner Kind", drag.before);
+        }
+        const ref = drag.widget.ref;
+        const has = this.anchors.some((a) => sameRef(a, ref));
+        this.editingId = ref.nodeId;
+        this.anchors = drag.shift ? has ? this.anchors.filter((a) => !sameRef(a, ref)) : [...this.anchors, ref] : [ref];
+        this.notify();
+        return;
+      }
+      case "width": {
+        if (drag.moved) return this.commit(drag.mode === "move" ? "Move Width Point" : "Width Point", drag.before);
+        if (drag.created) {
+          this.doc = drag.before.doc;
+          this.widthPoint = null;
+          this.notify(true);
+        } else this.notify();
+        return;
+      }
       case "stroke": {
         this.notify();
         if (drag.tool === "knife") this.knife(drag.points);
@@ -4960,19 +6551,22 @@ var VectorEditorController = (_class3 = class {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _101 => _101.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _172 => _172.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);
+        for (const q of drag.lazy.finish()) {
+          drag.points.push(q);
+          _optionalChain([drag, 'access', _173 => _173.pressures, 'optionalAccess', _174 => _174.push, 'call', _175 => _175(drag.pressure)]);
+        }
         const shape = this.editing.recognizeShapes ? recognizeInkShape(drag.points, { minSize: 6 / this.viewport.zoom }) : null;
         if (shape) {
           this.replaceNode(drag.nodeId, { ...node, name: inkShapeLabel(shape), subpaths: [inkShapeSubpath(shape)] });
           this.selection = [drag.nodeId];
           return this.commit(`Draw ${inkShapeLabel(shape)}`, drag.before);
         }
-        const fitted = _chunkBGNPT5PEcjs.fitCubics.call(void 0, drag.points, 1.5 / this.viewport.zoom, { cornerAngleDeg: 60 });
+        const fitted = _chunkGVB7ZPLZcjs.fitCubics.call(void 0, drag.points, 1.5 / this.viewport.zoom, { cornerAngleDeg: 60 });
         const anchors = [];
         for (const c of fitted) {
           if (!anchors.length) anchors.push({ x: c.p0[0], y: c.p0[1] });
@@ -4980,7 +6574,8 @@ var VectorEditorController = (_class3 = class {
           anchors.push({ x: c.p3[0], y: c.p3[1], in: { x: c.p2[0], y: c.p2[1] } });
         }
         const subpaths = anchors.length > 1 ? bezierToSubpaths(subpathsToBezier([{ anchors, closed: false }])) : node.subpaths;
-        this.replaceNode(drag.nodeId, { ...node, subpaths });
+        const profile = drag.pressures ? pencilPressureProfile(drag.points, drag.pressures) : [];
+        this.replaceNode(drag.nodeId, { ...node, subpaths, ...profile.length ? { strokeWidthProfile: profile } : {} });
         this.selection = [drag.nodeId];
         return this.commit("Draw", drag.before);
       }
@@ -5034,7 +6629,7 @@ var VectorEditorController = (_class3 = class {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _102 => _102.hover, 'optionalAccess', _103 => _103.segment, 'optionalAccess', _104 => _104.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _176 => _176.hover, 'optionalAccess', _177 => _177.segment, 'optionalAccess', _178 => _178.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
         const seg = node ? nearestSegment(node, this.toLocal(id, p)) : null;
@@ -5102,7 +6697,10 @@ var VectorEditorController = (_class3 = class {
     switch (key) {
       case "Escape":
         if (this.drag) this.cancelDrag();
-        else if (this.pen) this.finishPath();
+        else if (this.tool === "width" && this.widthPoint) {
+          this.widthPoint = null;
+          this.notify();
+        } else if (this.pen) this.finishPath();
         else if (this.tool === "direct" && this.anchors.length) {
           this.anchors = [];
           this.notify();
@@ -5114,7 +6712,7 @@ var VectorEditorController = (_class3 = class {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _105 => _105.getNode, 'call', _106 => _106(this.selection[0]), 'optionalAccess', _107 => _107.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _179 => _179.getNode, 'call', _180 => _180(this.selection[0]), 'optionalAccess', _181 => _181.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -5123,6 +6721,7 @@ var VectorEditorController = (_class3 = class {
         return false;
       case "Delete":
       case "Backspace":
+        if (this.tool === "width" && this.widthPoint) return this.removeWidthPoint(this.widthPoint).ok;
         if (this.pen) {
           const node = this.getNode(this.pen.nodeId);
           const sp = node.subpaths[this.pen.subpath];
@@ -5179,9 +6778,9 @@ function inkShapeSubpath(shape) {
 function constrain45(origin, p) {
   const dx = p.x - origin.x;
   const dy = p.y - origin.y;
-  const len = Math.hypot(dx, dy);
+  const len2 = Math.hypot(dx, dy);
   const a = Math.round(Math.atan2(dy, dx) / (Math.PI / 4)) * (Math.PI / 4);
-  return { x: origin.x + Math.cos(a) * len, y: origin.y + Math.sin(a) * len };
+  return { x: origin.x + Math.cos(a) * len2, y: origin.y + Math.sin(a) * len2 };
 }
 function scaleFor(handle, b, p, mods = {}) {
   const west = handle.includes("w");
@@ -5204,6 +6803,31 @@ function scaleFor(handle, b, p, mods = {}) {
   }
   return { sx, sy, origin };
 }
+function withStyle(node, style) {
+  const next = { ...node, ...style };
+  if ("strokeWidthProfile" in style) {
+    const p = style.strokeWidthProfile ? sanitizeWidthProfile(style.strokeWidthProfile) : [];
+    if (p.length) next.strokeWidthProfile = p;
+    else delete next.strokeWidthProfile;
+  }
+  return next;
+}
+function hiddenOrLocked(nodes, id) {
+  const loc = locateVectorNode(nodes, id);
+  if (!loc) return false;
+  const n = loc.list[loc.index];
+  if (n.locked || n.visible === false) return true;
+  return loc.parent ? hiddenOrLocked(nodes, loc.parent.id) : false;
+}
+function pencilPressureProfile(points, pressures) {
+  const n = Math.min(points.length, pressures.length);
+  if (n < 2) return [];
+  const s = [0];
+  for (let i = 1; i < n; i++) s.push(s[i - 1] + Math.hypot(points[i][0] - points[i - 1][0], points[i][1] - points[i - 1][1]));
+  const total = s[n - 1];
+  if (!(total > 0)) return [];
+  return pressureWidthProfile(s.map((d, i) => ({ t: d / total, pressure: pressures[i] })));
+}
 
 // src/vector/render.ts
 var fmt = (n) => Math.round(n * 100) / 100;
@@ -5218,17 +6842,19 @@ function renderNode(node, defs, idPrefix) {
   const stroke = vectorPaintToSvg(node.stroke, `${idPrefix}stroke-${node.id}`);
   if (fill.gradient) defs.push(fill.gradient);
   if (stroke.gradient) defs.push(stroke.gradient);
+  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) } : {},
+    ...strokeParts ? { strokeParts } : {},
     d: vectorPathData(node),
     fill: fill.value,
     stroke: stroke.value,
     strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)),
     ...node.strokeLinecap ? { strokeLinecap: node.strokeLinecap } : {},
     ...node.strokeLinejoin ? { strokeLinejoin: node.strokeLinejoin } : {},
-    ..._optionalChain([node, 'access', _108 => _108.strokeDasharray, 'optionalAccess', _109 => _109.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
+    ..._optionalChain([node, 'access', _182 => _182.strokeDasharray, 'optionalAccess', _183 => _183.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1))
   };
@@ -5237,9 +6863,9 @@ function getVectorSceneRenderData(state, options = {}) {
   const defs = [];
   const prefix = _nullishCoalesce(options.idPrefix, () => ( "ve-"));
   const nodes = state.document.nodes.map((n) => renderNode(n, defs, prefix)).filter((n) => !!n);
-  const v = state.viewport;
+  const v2 = state.viewport;
   return {
-    transform: `translate(${fmt(v.x)} ${fmt(v.y)}) scale(${v.zoom})`,
+    transform: `translate(${fmt(v2.x)} ${fmt(v2.y)}) scale(${v2.zoom})`,
     width: state.document.width,
     height: state.document.height,
     ...state.document.background ? { background: state.document.background } : {},
@@ -5249,10 +6875,10 @@ function getVectorSceneRenderData(state, options = {}) {
 }
 var toScreen = (state, p) => ({ x: p.x * state.viewport.zoom + state.viewport.x, y: p.y * state.viewport.zoom + state.viewport.y });
 function screenOutline(state, node) {
-  const v = state.viewport;
-  const view = [v.zoom, 0, 0, v.zoom, v.x, v.y];
+  const v2 = state.viewport;
+  const view = [v2.zoom, 0, 0, v2.zoom, v2.x, v2.y];
   const parent = _nullishCoalesce(vectorParentMatrix(state.document.nodes, node.id), () => ( IDENTITY_MATRIX));
-  return collectWithMatrix(node, parent).map(({ path, parent: m }) => _chunkBGNPT5PEcjs.bezierPathToSvg.call(void 0, _chunkBGNPT5PEcjs.transformBezierPath.call(void 0, vectorPathWorldBezier(path, m), view), { precision: 2 })).join(" ");
+  return collectWithMatrix(node, parent).map(({ path, parent: m }) => _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, _chunkGVB7ZPLZcjs.transformBezierPath.call(void 0, vectorPathWorldBezier(path, m), view), { precision: 2 })).join(" ");
 }
 function collectWithMatrix(node, parent) {
   if (node.type === "path") return [{ path: node, parent }];
@@ -5277,9 +6903,9 @@ function getVectorOverlayRenderData(state) {
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _110 => _110.hover, 'optionalAccess', _111 => _111.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _184 => _184.hover, 'optionalAccess', _185 => _185.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _112 => _112.interaction, 'optionalAccess', _113 => _113.type]) !== "marquee") {
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _186 => _186.interaction, 'optionalAccess', _187 => _187.type]) !== "marquee") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
     selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
   }
@@ -5289,9 +6915,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', _114 => _114.hover, 'optionalAccess', _115 => _115.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', _188 => _188.hover, 'optionalAccess', _189 => _189.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _116 => _116.hover, 'optionalAccess', _117 => _117.anchor])) {
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _190 => _190.hover, 'optionalAccess', _191 => _191.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
@@ -5300,15 +6926,15 @@ function getVectorOverlayRenderData(state) {
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
     const a = getAnchorWorld(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _118 => _118[ref.handle]]);
+    const h = _optionalChain([a, 'optionalAccess', _192 => _192[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _119 => _119.hover, 'optionalAccess', _120 => _120.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _193 => _193.hover, 'optionalAccess', _194 => _194.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', _121 => _121.interaction, 'optionalAccess', _122 => _122.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _195 => _195.interaction, 'optionalAccess', _196 => _196.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 };
@@ -5316,7 +6942,7 @@ function getVectorOverlayRenderData(state) {
   let penPreview = null;
   if (state.tool === "pen" && state.pen && state.pointer && !state.interaction) {
     const node = findVectorNode(doc.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _123 => _123.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _197 => _197.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);
@@ -5329,9 +6955,9 @@ function getVectorOverlayRenderData(state) {
   const artboard = { x: origin.x, y: origin.y, width: doc.width * z, height: doc.height * z };
   let status = null;
   const it = state.interaction;
-  if (_optionalChain([it, 'optionalAccess', _124 => _124.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _125 => _125.type]) === "move" || _optionalChain([it, 'optionalAccess', _126 => _126.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _127 => _127.type]) === "scale" || _optionalChain([it, 'optionalAccess', _128 => _128.type]) === "draw") {
+  if (_optionalChain([it, 'optionalAccess', _198 => _198.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _199 => _199.type]) === "move" || _optionalChain([it, 'optionalAccess', _200 => _200.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _201 => _201.type]) === "scale" || _optionalChain([it, 'optionalAccess', _202 => _202.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)}`;
   }
@@ -5348,19 +6974,39 @@ function getVectorOverlayRenderData(state) {
     }
   }
   let toolStroke = null;
-  if (_optionalChain([it, 'optionalAccess', _129 => _129.type]) === "stroke") {
+  if (_optionalChain([it, 'optionalAccess', _203 => _203.type]) === "stroke") {
     const pts = it.points.map((q) => toScreen(state, q));
     const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt(q.x)} ${fmt(q.y)}`).join("") + (pts.length === 1 ? `L${fmt(pts[0].x)} ${fmt(pts[0].y)}` : "");
     toolStroke = { tool: it.tool, d, width: fmt(it.width * z) };
   }
   let pencilString = null;
-  if (_optionalChain([it, 'optionalAccess', _130 => _130.type]) === "draw" && it.string) {
+  if (_optionalChain([it, 'optionalAccess', _204 => _204.type]) === "draw" && it.string) {
     const a = toScreen(state, it.string[0]);
     const b = toScreen(state, it.string[1]);
     pencilString = { x1: fmt(a.x), y1: fmt(a.y), x2: fmt(b.x), y2: fmt(b.y) };
   }
-  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _131 => _131.hover, 'optionalAccess', _132 => _132.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
-  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint };
+  const dragged = _optionalChain([it, 'optionalAccess', _205 => _205.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', _206 => _206.hover, 'optionalAccess', _207 => _207.corner]), w.ref), active: !!dragged };
+  });
+  if (_optionalChain([it, 'optionalAccess', _208 => _208.type]) === "corner") status = `R ${fmt(it.radius)}`;
+  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _209 => _209.hover, 'optionalAccess', _210 => _210.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  const sc = (p) => {
+    const q = toScreen(state, p);
+    return { x: fmt(q.x), y: fmt(q.y) };
+  };
+  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', _211 => _211.hover, 'optionalAccess', _212 => _212.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', _213 => _213.type]) === "width" && sameWidth(it.ref, h.ref) };
+  });
+  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _214 => _214.hover, 'optionalAccess', _215 => _215.strokeSpot]) : null;
+  const widthSpot = spot ? { ...sc(spot.point), left: sc(spot.left), right: sc(spot.right) } : null;
+  if (_optionalChain([it, 'optionalAccess', _216 => _216.type]) === "width") status = it.mode === "move" ? "Move width point" : `W ${fmt(it.width)}`;
+  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot };
 }
 var VECTOR_OVERLAY_THEME = {
   accent: "#0ea5e9",
@@ -5372,13 +7018,25 @@ var VECTOR_OVERLAY_THEME = {
   eraserFill: "rgba(239, 68, 68, 0.25)",
   transformHandleSize: 8,
   anchorSize: 7,
-  handleRadius: 3.5
+  handleRadius: 3.5,
+  /** Radius of a live corner widget (a ring with a dot). */
+  cornerWidgetRadius: 4,
+  /** Half the diagonal of a width point's diamond. */
+  widthPointSize: 5
 };
+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`;
+}
 function toVectorModifiers(event) {
   return { shift: !!event.shiftKey, alt: !!event.altKey, mod: !!(event.metaKey || event.ctrlKey) };
 }
 function toVectorPointerInput(event) {
-  return { ...toVectorModifiers(event), button: event.button };
+  return {
+    ...toVectorModifiers(event),
+    button: event.button,
+    ...typeof event.pressure === "number" ? { pressure: event.pressure } : {},
+    ...event.pointerType ? { pointerType: event.pointerType } : {}
+  };
 }
 function toVectorKeyInput(event) {
   return { key: event.key, ...toVectorModifiers(event) };
@@ -5388,7 +7046,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', _133 => _133.getAttribute, 'optionalCall', _134 => _134("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _217 => _217.getAttribute, 'optionalCall', _218 => _218("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -5396,18 +7054,75 @@ function getVectorSelectionStyle(state) {
     const node = findVectorNode(state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
+  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _219 => _219.selectedAnchors, 'optionalAccess', _220 => _220.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', _221 => _221.type]) === "path") paths.push(node);
+    }
+  }
   if (!paths.length) return null;
   const first = paths[0];
   const same = (get) => paths.every((p) => JSON.stringify(_nullishCoalesce(get(p), () => ( null))) === JSON.stringify(_nullishCoalesce(get(first), () => ( null))));
+  const corners2 = [];
+  for (const p of paths) {
+    for (const c of vectorCorners(p.subpaths)) {
+      if (anchorMode && !state.selectedAnchors.some((r) => r.nodeId === p.id && r.subpath === c.subpath && r.index === c.index)) continue;
+      const corner = p.subpaths[c.subpath].anchors[c.index].corner;
+      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _222 => _222.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _223 => _223.kind]), () => ( "round")) });
+    }
+  }
+  const c0 = _nullishCoalesce(corners2[0], () => ( { radius: 0, kind: "round" }));
   return {
     fill: _nullishCoalesce(first.fill, () => ( null)),
     stroke: _nullishCoalesce(first.stroke, () => ( null)),
     strokeWidth: _nullishCoalesce(first.strokeWidth, () => ( 1)),
     opacity: _nullishCoalesce(first.opacity, () => ( 1)),
-    mixed: { fill: !same((p) => p.fill), stroke: !same((p) => p.stroke), strokeWidth: !same((p) => _nullishCoalesce(p.strokeWidth, () => ( 1))), opacity: !same((p) => _nullishCoalesce(p.opacity, () => ( 1))) },
+    strokeAlign: _nullishCoalesce(first.strokeAlign, () => ( "center")),
+    startArrow: _nullishCoalesce(first.startArrow, () => ( null)),
+    endArrow: _nullishCoalesce(first.endArrow, () => ( null)),
+    arrowAlign: _nullishCoalesce(first.arrowAlign, () => ( "extend")),
+    startArrowScale: _nullishCoalesce(first.startArrowScale, () => ( 1)),
+    endArrowScale: _nullishCoalesce(first.endArrowScale, () => ( 1)),
+    strokeWidthProfile: profileOf(first),
+    widthProfile: widthProfilePresetId(profileOf(first)),
+    cornerRadius: c0.radius,
+    cornerKind: c0.kind,
+    corners: corners2.length,
+    hasOpenPath: paths.some((p) => p.subpaths.some((sp) => !sp.closed && sp.anchors.length > 1)),
+    mixed: {
+      fill: !same((p) => p.fill),
+      stroke: !same((p) => p.stroke),
+      strokeWidth: !same((p) => _nullishCoalesce(p.strokeWidth, () => ( 1))),
+      opacity: !same((p) => _nullishCoalesce(p.opacity, () => ( 1))),
+      strokeAlign: !same((p) => _nullishCoalesce(p.strokeAlign, () => ( "center"))),
+      startArrow: !same((p) => _nullishCoalesce(p.startArrow, () => ( null))),
+      endArrow: !same((p) => _nullishCoalesce(p.endArrow, () => ( null))),
+      arrowAlign: !same((p) => _nullishCoalesce(p.arrowAlign, () => ( "extend"))),
+      startArrowScale: !same((p) => _nullishCoalesce(p.startArrowScale, () => ( 1))),
+      endArrowScale: !same((p) => _nullishCoalesce(p.endArrowScale, () => ( 1))),
+      widthProfile: !same(profileOf),
+      cornerRadius: corners2.some((c) => c.radius !== c0.radius),
+      cornerKind: corners2.some((c) => c.kind !== c0.kind)
+    },
     pathIds: paths.map((p) => p.id)
   };
 }
+function profileOf(p) {
+  const points = sanitizeWidthProfile(p.strokeWidthProfile);
+  return points.length && widthProfilePresetId(points) !== "uniform" ? points : null;
+}
+var VECTOR_STROKE_ALIGN_LABELS = { center: "Center", inside: "Inside", outside: "Outside" };
+var VECTOR_CORNER_KIND_LABELS = { round: "Round", inverted: "Inverted", chamfer: "Chamfer" };
+var VECTOR_ARROWHEAD_LABELS = {
+  triangle: "Triangle",
+  arrow: "Arrow",
+  open: "Open arrow",
+  circle: "Circle",
+  square: "Square",
+  bar: "Bar"
+};
 function vectorPaintToHex(paint) {
   if (typeof paint !== "string") return null;
   const m = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i.exec(paint.trim());
@@ -5420,7 +7135,8 @@ var VECTOR_PATH_ACTIONS = [
   { id: "average", label: "\u22B9", title: "Average Points", shortcut: "Alt+J", enabled: (_s, p) => p > 1, run: (c) => c.averageAnchors("both") },
   { id: "cut", label: "\u2702\xB7", title: "Cut at Points", enabled: (_s, p) => p > 0, run: (c) => c.cutAtAnchors() },
   { id: "clean", label: "\u2301", title: "Remove Redundant Points", enabled: (s, p) => s + p > 0, run: (c) => c.removeRedundantPoints() },
-  { id: "smooth", label: "\u223F", title: "Smooth", enabled: (s, p) => s + p > 0, run: (c) => c.smoothPaths() }
+  { id: "smooth", label: "\u223F", title: "Smooth", enabled: (s, p) => s + p > 0, run: (c) => c.smoothPaths() },
+  { id: "outline", label: "\u22A1", title: "Outline Stroke", enabled: (s) => s > 0, run: (c) => c.outlineStroke() }
 ];
 var VECTOR_EDIT_TOGGLES = [
   { key: "keepShapeOnDelete", label: "Keep", title: "Keep shape when deleting points" },
@@ -5448,6 +7164,19 @@ var POINTS = {
   minItems: 1,
   description: "Polyline [[x, y], \u2026] in document units."
 };
+var WIDTH_POINTS = {
+  type: ["array", "null"],
+  items: {
+    type: "object",
+    properties: {
+      t: { type: "number", minimum: 0, maximum: 1, description: "Position along each subpath by length (0 start, 1 end)." },
+      left: { type: "number", minimum: 0, description: "Left side as a multiple of half the stroke width (1 = uniform)." },
+      right: { type: "number", minimum: 0, description: "Right side (looking along the path, y down)." }
+    },
+    required: ["t", "left", "right"]
+  },
+  description: "Variable-width profile points, interpolated smoothly (monotone cubic); two points at one `t` make a step. `null` or `[]` strokes at a uniform width."
+};
 var PAINT = {
   description: 'A CSS colour, `null` for none, or a gradient `{ type: "linear", angle, stops: [{ offset, color }] }`.'
 };
@@ -5458,7 +7187,14 @@ var STYLE_PROPS = {
   strokeLinecap: { type: "string", enum: ["butt", "round", "square"] },
   strokeLinejoin: { type: "string", enum: ["miter", "round", "bevel"] },
   strokeDasharray: { type: "array", items: { type: "number" } },
-  fillRule: { type: "string", enum: ["nonzero", "evenodd"] }
+  fillRule: { type: "string", enum: ["nonzero", "evenodd"] },
+  strokeAlign: { type: "string", enum: ["center", "inside", "outside"], description: "Where the stroke sits on the outline (closed shapes only; open paths stroke centred)." },
+  startArrow: { type: ["string", "null"], enum: [...VECTOR_ARROWHEADS, null], description: "Head at the start of an open path, or null for none." },
+  endArrow: { type: ["string", "null"], enum: [...VECTOR_ARROWHEADS, null], description: "Head at the end of an open path, or null for none." },
+  arrowAlign: { type: "string", enum: ["extend", "tip"], description: "`extend`: the tip sits past the end point; `tip`: on it, the stroke shortened under the head." },
+  startArrowScale: { type: "number", exclusiveMinimum: 0, description: "Start head size as a multiple of the stroke width (default 1)." },
+  endArrowScale: { type: "number", exclusiveMinimum: 0, description: "End head size as a multiple of the stroke width (default 1)." },
+  strokeWidthProfile: WIDTH_POINTS
 };
 var pickStyle = (params) => {
   const out = {};
@@ -5474,17 +7210,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', _135 => _135.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _224 => _224.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', _136 => _136.ids, 'optionalAccess', _137 => _137.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _225 => _225.ids, 'optionalAccess', _226 => _226.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', _138 => _138.type]) !== "path" || !_optionalChain([node, 'access', _139 => _139.subpaths, 'access', _140 => _140[r.subpath], 'optionalAccess', _141 => _141.anchors, 'access', _142 => _142[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+      if (_optionalChain([node, 'optionalAccess', _227 => _227.type]) !== "path" || !_optionalChain([node, 'access', _228 => _228.subpaths, 'access', _229 => _229[r.subpath], 'optionalAccess', _230 => _230.anchors, 'access', _231 => _231[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
     }
     return refs;
   };
@@ -5551,7 +7287,8 @@ function createVectorCommands(controller, options = {}) {
           y: { type: "number" },
           width: { type: "number", description: "For a line: the x offset of its end." },
           height: { type: "number", description: "For a line: the y offset of its end." },
-          cornerRadius: { type: "number", minimum: 0 },
+          cornerRadius: { type: "number", minimum: 0, description: "Live corner radius of a rect, polygon or star." },
+          cornerKind: { type: "string", enum: VECTOR_CORNER_KINDS },
           sides: { type: "integer", minimum: 3 },
           points: { type: "integer", minimum: 3 },
           innerRatio: { type: "number", minimum: 0, maximum: 1 },
@@ -5574,7 +7311,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', _143 => _143.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _232 => _232.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -5597,6 +7334,76 @@ function createVectorCommands(controller, options = {}) {
         return { ok: true };
       }
     },
+    {
+      ...base,
+      id: `${prefix}setCorners`,
+      label: "Corner Radius\u2026",
+      keywords: ["round", "rounded", "corners", "radius", "fillet", "chamfer", "live corners"],
+      description: "Sets the live corner radius (and optionally `kind`: round, inverted or chamfer) of `anchors`, else the selected points (direct tool), else every corner of `ids` / the selection. Radius 0 makes corners sharp; radii shrink to fit short sides. The anchors stay editable.",
+      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', _233 => _233.anchors]) ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _234 => _234.ids]) ? ids(params) : void 0 };
+        if (_optionalChain([params, 'optionalAccess', _235 => _235.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
+        else if (_optionalChain([params, 'optionalAccess', _236 => _236.kind])) check(controller.setCornerKind(params.kind, target));
+        else fail("Pass `radius` and / or `kind`.");
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}setWidthProfile`,
+      label: "Width Profile\u2026",
+      keywords: ["variable width", "taper", "tapered", "pressure", "profile", "brush", "calligraphy", "bulge", "thick", "thin"],
+      description: "Gives the stroke of paths a variable width: a `preset` (`uniform` removes the profile), explicit `points` ({ t, left, right }: side scales along each subpath), or a parametric `taper` (startLength / endLength as fractions of the path, startWidth / endWidth 0\u20131, startEase / endEase 0\u20131) and / or `wave` (amount 0\u20131, cycles, phase in degrees). Profiled strokes draw as filled outlines; Outline Stroke bakes them.",
+      params: {
+        type: "object",
+        properties: {
+          ids: IDS,
+          preset: { type: "string", enum: VECTOR_WIDTH_PRESET_IDS },
+          points: WIDTH_POINTS,
+          taper: {
+            type: "object",
+            properties: {
+              startLength: { type: "number", minimum: 0, maximum: 1 },
+              endLength: { type: "number", minimum: 0, maximum: 1 },
+              startWidth: { type: "number", minimum: 0, maximum: 1 },
+              endWidth: { type: "number", minimum: 0, maximum: 1 },
+              startEase: { type: "number", minimum: 0, maximum: 1 },
+              endEase: { type: "number", minimum: 0, maximum: 1 }
+            }
+          },
+          wave: { type: "object", properties: { amount: { type: "number", minimum: 0, maximum: 1 }, cycles: { type: "number", exclusiveMinimum: 0 }, phase: { type: "number" } } }
+        }
+      },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        const target = { ids: ids(params) };
+        if (_optionalChain([params, 'optionalAccess', _237 => _237.preset])) check(controller.setWidthProfile(params.preset, target));
+        else if (_optionalChain([params, 'optionalAccess', _238 => _238.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
+        else if (_optionalChain([params, 'optionalAccess', _239 => _239.taper]) || _optionalChain([params, 'optionalAccess', _240 => _240.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', _241 => _241.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}outlineStroke`,
+      label: "Outline Stroke",
+      keywords: ["expand", "stroke to path", "outline", "convert stroke"],
+      description: "Turns the stroke of paths into filled shapes of the area it paints (alignment, caps, joins, dashes and arrowheads included). Returns the new ids.",
+      params: { type: "object", properties: { ids: IDS } },
+      enabled: enabledFor,
+      undoable: true,
+      run: (_ctx, params) => {
+        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _242 => _242.ids]) ? ids(params) : void 0 });
+        if (!created.length) fail("No selected path has a stroke.");
+        return { ids: created };
+      }
+    },
     {
       ...base,
       id: `${prefix}transform`,
@@ -5707,7 +7514,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _144 => _144.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _243 => _243.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -5735,7 +7542,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', _145 => _145.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _146 => _146.keepShape]) }));
+        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _244 => _244.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _245 => _245.keepShape]) }));
         return { ok: true };
       }
     },
@@ -5790,7 +7597,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', _147 => _147.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _148 => _148.tolerance]) }));
+        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _246 => _246.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _247 => _247.tolerance]) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -5804,7 +7611,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', _149 => _149.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _150 => _150.anchors]))));
+        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _248 => _248.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _249 => _249.anchors]))));
         return { ok: true };
       }
     },
@@ -5818,7 +7625,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _151 => _151.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _152 => _152.tolerance]) }));
+        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _250 => _250.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _251 => _251.tolerance]) }));
         return { ok: true };
       }
     },
@@ -5831,7 +7638,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', _153 => _153.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _154 => _154.amount]), refs: _optionalChain([params, 'optionalAccess', _155 => _155.anchors]) }));
+        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _252 => _252.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _253 => _253.amount]), refs: _optionalChain([params, 'optionalAccess', _254 => _254.anchors]) }));
         return { ok: true };
       }
     },
@@ -5844,14 +7651,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', _156 => _156.nodeId]) !== void 0) {
+        if (_optionalChain([params, 'optionalAccess', _255 => _255.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', _157 => _157.anchors]))));
+        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _256 => _256.anchors]))));
         return { ids: controller.getState().selection };
       }
     },
@@ -5888,7 +7695,7 @@ function createVectorCommands(controller, options = {}) {
       id: `${prefix}setEditing`,
       label: "Path Editing Options\u2026",
       keywords: ["settings", "curvature", "pencil", "smoothing", "lazy mouse", "shapes", "eraser"],
-      description: "Sets how editing behaves: `keepShapeOnDelete`, `curvatureMoves` (anchor drags bend like the Curvature tool), `pencilSmoothing` (lazy mouse, 0\u20131), `recognizeShapes` (pencil scribbles become lines, rectangles, ellipses, polygons) and `eraserSize`.",
+      description: "Sets how editing behaves: `keepShapeOnDelete`, `curvatureMoves` (anchor drags bend like the Curvature tool), `pencilSmoothing` (lazy mouse, 0\u20131), `recognizeShapes` (pencil scribbles become lines, rectangles, ellipses, polygons), `eraserSize` and `pencilPressure` (`pen`: record pen pressure on pencil strokes as a width profile, `all`: any pointer reporting pressure, `off`).",
       params: {
         type: "object",
         properties: {
@@ -5896,12 +7703,13 @@ function createVectorCommands(controller, options = {}) {
           curvatureMoves: { type: "boolean" },
           pencilSmoothing: { type: "number", minimum: 0, maximum: 1 },
           recognizeShapes: { type: "boolean" },
-          eraserSize: { type: "number", exclusiveMinimum: 0 }
+          eraserSize: { type: "number", exclusiveMinimum: 0 },
+          pencilPressure: { type: "string", enum: ["pen", "all", "off"] }
         }
       },
       run: (_ctx, params) => {
         const patch = {};
-        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize"]) if (_optionalChain([params, 'optionalAccess', _158 => _158[key]]) !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _257 => _257[key]]) !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -5926,7 +7734,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', _159 => _159.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _258 => _258.precision]) }) })
     },
     {
       ...base,
@@ -6058,5 +7866,71 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA; exports.LazyMouse = LazyMouse; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; 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.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.createVectorCommands = createVectorCommands; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.decomposeRigid = decomposeRigid; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.findVectorNode = findVectorNode; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasPaint = hasPaint; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.invertMatrix = invertMatrix; exports.isIdentityMatrix = isIdentityMatrix; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.reverseSubpath = reverseSubpath; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.starSubpath = starSubpath; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathsToBezier = subpathsToBezier; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.unionBounds = unionBounds; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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_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_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; 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.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.createVectorCommands = createVectorCommands; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertWidthPoint = insertWidthPoint; exports.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mirrorWidthProfile = mirrorWidthProfile; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeWidthPoints = removeWidthPoints; exports.reverseSubpath = reverseSubpath; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.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.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute;
 //# sourceMappingURL=index.cjs.map