@pixerate/editor 0.36.0 → 0.38.0

package/dist/vector/index.cjs

@@ -31,13 +31,35 @@ var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 
 
 
-var _chunkBGNPT5PEcjs = require('../chunk-BGNPT5PE.cjs');
+
+
+
+
+
+var _chunk7EDLVBOOcjs = require('../chunk-7EDLVBOO.cjs');
 
 // src/vector/types.ts
 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"];
+var VECTOR_TOOLS = [
+  "select",
+  "direct",
+  "pen",
+  "pencil",
+  "rect",
+  "ellipse",
+  "polygon",
+  "star",
+  "line",
+  "scissors",
+  "knife",
+  "eraser",
+  "width",
+  "shapeBuilder",
+  "paintBucket"
+];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
+var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
 
 // src/vector/corners.ts
 var EPS = 1e-9;
@@ -58,7 +80,7 @@ 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) : _chunkBGNPT5PEcjs.segmentLength.call(void 0, this.curve);
+    this.length = this.straight ? Math.hypot(b.x - a.x, b.y - a.y) : _chunk7EDLVBOOcjs.segmentLength.call(void 0, this.curve);
   }
   /** Unit direction the side leaves the corner in (towards its first control point off the corner). */
   direction() {
@@ -76,10 +98,10 @@ var Side = class {
       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 = _chunkBGNPT5PEcjs.segmentParamAtLength.call(void 0, this.curve, s, this.length);
-    const d = vec(_chunkBGNPT5PEcjs.segmentDerivative.call(void 0, this.curve, t));
+    const t = _chunk7EDLVBOOcjs.segmentParamAtLength.call(void 0, this.curve, s, this.length);
+    const d = vec(_chunk7EDLVBOOcjs.segmentDerivative.call(void 0, this.curve, t));
     const l = len(d);
-    return { t, p: vec(_chunkBGNPT5PEcjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul(d, 1 / l) : u };
+    return { t, p: vec(_chunk7EDLVBOOcjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul(d, 1 / l) : u };
   }
 };
 function cornerOf(sp, s, i) {
@@ -152,7 +174,7 @@ function cutCorner(c, radius, kind) {
   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]);
+  const r = _optionalChain([a, 'access', _3 => _3.corner, 'optionalAccess', _4 => _4.radius]);
   return typeof r === "number" && r > 0 && Number.isFinite(r) ? r : 0;
 };
 function hasVectorCorners(subpaths) {
@@ -166,7 +188,7 @@ function expandVectorCornersOf(sp, subpath = 0) {
     const c = cornerOf(sp, subpath, i);
     if (!c) return null;
     const fitted = fitCornerRadius(c, r);
-    return fitted > EPS ? cutCorner(c, fitted, _nullishCoalesce(_optionalChain([a, 'access', _4 => _4.corner, 'optionalAccess', _5 => _5.kind]), () => ( "round"))) : null;
+    return fitted > EPS ? cutCorner(c, fitted, _nullishCoalesce(_optionalChain([a, 'access', _5 => _5.corner, 'optionalAccess', _6 => _6.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) => {
@@ -180,7 +202,7 @@ function expandVectorCornersOf(sp, subpath = 0) {
     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 = _chunkBGNPT5PEcjs.subSegment.call(void 0, seg, s0, Math.max(s0, s1));
+    const part = _chunk7EDLVBOOcjs.subSegment.call(void 0, seg, s0, Math.max(s0, s1));
     return { out: vec(part[1]), in: vec(part[2]) };
   });
   const anchors = [];
@@ -234,7 +256,7 @@ function expandVectorCorners(subpaths) {
 function setAnchorCorner(a, radius, kind) {
   const { corner, ...rest } = a;
   const r = Number.isFinite(radius) ? Math.max(0, radius) : 0;
-  const k = _nullishCoalesce(kind, () => ( _optionalChain([corner, 'optionalAccess', _6 => _6.kind])));
+  const k = _nullishCoalesce(kind, () => ( _optionalChain([corner, 'optionalAccess', _7 => _7.kind])));
   if (r <= 0 && !kind) return rest;
   return { ...rest, corner: { radius: r, ...k && k !== "round" ? { kind: k } : {} } };
 }
@@ -245,19 +267,561 @@ 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', _8 => _8.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', _9 => _9.length])) return { left: 1, right: 1 };
+  return { left: interp(points, t, "left"), right: interp(points, t, "right") };
+}
+function widthProfileMaxScale(points) {
+  if (!_optionalChain([points, 'optionalAccess', _10 => _10.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', _11 => _11.find, 'call', _12 => _12((p) => p.points.length && same(points, p.points)), 'optionalAccess', _13 => _13.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', _14 => _14.length]) ? points.map((p) => ({ ...p })) : [sym(0, 1), sym(1, 1)];
+}
+function insertWidthPoint(points, t, sides2 = {}, options = {}) {
+  const pts = editable(points);
+  const tt = Math.min(Math.max(Number.isFinite(t) ? t : 0, 0), 1);
+  const here = widthProfileAt(_optionalChain([points, 'optionalAccess', _15 => _15.length]) ? points : null, tt);
+  const p = {
+    t: tt,
+    left: _nullishCoalesce(clean(sides2.left, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.left)),
+    right: _nullishCoalesce(clean(sides2.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', _16 => _16.taper, 'optionalAccess', _17 => _17.startLength]), _optionalChain([options, 'access', _18 => _18.taper, 'optionalAccess', _19 => _19.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 = _chunk7EDLVBOOcjs.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 _chunk7EDLVBOOcjs.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 sides2 = (s) => {
+      const w = widthProfileAt(options.profile, s / len2);
+      return [w.left * half, w.right * half];
+    };
+    const intervals = _optionalChain([options, 'access', _20 => _20.dash, 'optionalAccess', _21 => _21.some, 'call', _22 => _22((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] = sides2(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) => sides2(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 = _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.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 (_chunk7EDLVBOOcjs.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;
+  _chunk7EDLVBOOcjs.pathToContours.call(void 0, path).forEach((c, ci) => {
+    if (!c.segments.length || only !== void 0 && ci !== only) return;
+    const lengths = c.segments.map((s) => _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.segmentNearest.call(void 0, seg, p);
+      if (!best || near2.distance < best.distance) {
+        const s = acc + _chunk7EDLVBOOcjs.segmentLength.call(void 0, seg, 0, near2.t);
+        const tan = _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.pathToContours.call(void 0, path)[index];
+  if (!_optionalChain([c, 'optionalAccess', _23 => _23.segments, 'access', _24 => _24.length])) return null;
+  const lengths = c.segments.map((s) => _chunk7EDLVBOOcjs.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 (_chunk7EDLVBOOcjs.segmentLength.call(void 0, seg, 0, mid) < target) lo = mid;
+        else hi = mid;
+      }
+      const u = (lo + hi) / 2;
+      const tan = _chunk7EDLVBOOcjs.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 = _chunkBGNPT5PEcjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
+  const contours = _chunk7EDLVBOOcjs.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', _25 => _25.strokeWidthProfile, 'optionalAccess', _26 => _26.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;
+  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', _27 => _27.strokeDasharray, 'optionalAccess', _28 => _28.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 _chunk7EDLVBOOcjs.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) {
@@ -334,27 +898,27 @@ function arrowheadPath(kind, tip, dir, hw) {
   }
 }
 var toVec = (p) => ({ x: p[0], y: p[1] });
-var segLen = (s) => _chunkBGNPT5PEcjs.segmentLength.call(void 0, s);
+var segLen = (s) => _chunk7EDLVBOOcjs.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 = _chunkBGNPT5PEcjs.segmentTangent.call(void 0, s2, 0);
+    const t2 = _chunk7EDLVBOOcjs.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 = _chunkBGNPT5PEcjs.segmentTangent.call(void 0, s, 1);
+  const t = _chunk7EDLVBOOcjs.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, dist3) {
+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 >= dist3) {
-      const want = fromStart ? dist3 - acc : l - (dist3 - acc);
-      const pts = _chunkBGNPT5PEcjs.trimSegments.call(void 0, [s], 0, want);
+    if (acc + l >= dist4) {
+      const want = fromStart ? dist4 - acc : l - (dist4 - acc);
+      const pts = _chunk7EDLVBOOcjs.trimSegments.call(void 0, [s], 0, want);
       const p = pts.length ? pts[0][pts[0].length - 1] : s[0];
       return toVec(p);
     }
@@ -364,7 +928,7 @@ function pointAlong(segs, fromStart, dist3) {
 }
 function vectorStrokeParts(path, style) {
   const width = _nullishCoalesce(style.strokeWidth, () => ( 1));
-  const contours = _chunkBGNPT5PEcjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
+  const contours = _chunk7EDLVBOOcjs.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;
@@ -404,42 +968,54 @@ function vectorStrokeParts(path, style) {
     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 ? _chunkBGNPT5PEcjs.trimSegments.call(void 0, c.segments, s0, total - s1, lengths) : [] };
+    return { closed: false, segments: total - s1 > s0 ? _chunk7EDLVBOOcjs.trimSegments.call(void 0, c.segments, s0, total - s1, lengths) : [] };
   });
-  return { align, line: _chunkBGNPT5PEcjs.contoursToPath.call(void 0, trimmed), drawWidth, heads };
+  return { align, line: _chunk7EDLVBOOcjs.contoursToPath.call(void 0, trimmed), drawWidth, heads };
 }
 function vectorStrokeOutlinePath(path, style) {
   const parts = vectorStrokeParts(path, style);
-  const stroke = _chunkBGNPT5PEcjs.outlineStroke.call(void 0, parts.line, {
-    width: parts.drawWidth,
-    join: _nullishCoalesce(style.strokeLinejoin, () => ( "miter")),
-    cap: _nullishCoalesce(style.strokeLinecap, () => ( "butt")),
-    ..._optionalChain([style, 'access', _7 => _7.strokeDasharray, 'optionalAccess', _8 => _8.length]) ? { dash: style.strokeDasharray } : {}
-  });
+  const stroke = vectorStrokeLineArea(parts, style);
   const fill = { path, fillRule: _nullishCoalesce(style.fillRule, () => ( "nonzero")) };
   let area = stroke;
-  if (parts.align === "inside") area = _chunkBGNPT5PEcjs.pathBoolean.call(void 0, "intersection", [stroke, fill]).path;
-  else if (parts.align === "outside") area = _chunkBGNPT5PEcjs.pathBoolean.call(void 0, "difference", [stroke, fill]).path;
+  if (parts.align === "inside") area = _chunk7EDLVBOOcjs.pathBoolean.call(void 0, "intersection", [stroke, fill]).path;
+  else if (parts.align === "outside") area = _chunk7EDLVBOOcjs.pathBoolean.call(void 0, "difference", [stroke, fill]).path;
   if (!parts.heads.length) return area;
-  return _chunkBGNPT5PEcjs.pathBoolean.call(void 0, "union", [area, ...parts.heads.map((h) => h.path)]).path;
+  return _chunk7EDLVBOOcjs.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 (_chunkBGNPT5PEcjs.pointInBezierPath.call(void 0, h.path, point) || tolerance > 0 && _chunkBGNPT5PEcjs.distanceToBezierPath.call(void 0, h.path, point) <= tolerance) return true;
+    if (_chunk7EDLVBOOcjs.pointInBezierPath.call(void 0, h.path, point) || tolerance > 0 && _chunk7EDLVBOOcjs.distanceToBezierPath.call(void 0, h.path, point) <= tolerance) return true;
   }
   if (!parts.line.length) return false;
-  const d = _chunkBGNPT5PEcjs.distanceToBezierPath.call(void 0, parts.line, point);
-  if (parts.align === "center") return d <= width / 2 + tolerance;
-  if (d > width + tolerance) 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 = _chunk7EDLVBOOcjs.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 = _chunkBGNPT5PEcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(style.fillRule, () => ( "nonzero")));
+  const inside = _chunk7EDLVBOOcjs.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));
+  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;
@@ -511,7 +1087,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 _chunk7EDLVBOOcjs.bezierPathToSvg.call(void 0, subpathsToBezier(subpaths), { precision });
 }
 function inferAnchorType(a) {
   if (isOnAnchor(a, a.in) || isOnAnchor(a, a.out)) return "corner";
@@ -527,7 +1103,7 @@ function inferAnchorType(a) {
   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 = _chunk7EDLVBOOcjs.toBezierPath.call(void 0, input);
   const out = [];
   let current = null;
   const last = () => current.anchors[current.anchors.length - 1];
@@ -624,14 +1200,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 : _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.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 };
 }
@@ -665,9 +1241,9 @@ 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;
+  if (hasPaint(node.fill) && _chunk7EDLVBOOcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
   if (hasPaint(node.stroke)) return hitTestVectorStroke(path, p, node, tolerance);
-  return _chunkBGNPT5PEcjs.distanceToBezierPath.call(void 0, path, point) <= tolerance;
+  return _chunk7EDLVBOOcjs.distanceToBezierPath.call(void 0, path, point) <= tolerance;
 }
 function vectorStrokeOutline(node, parent = IDENTITY_MATRIX) {
   if (!hasPaint(node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return [];
@@ -687,9 +1263,9 @@ 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 = _chunk7EDLVBOOcjs.segmentNearest.call(void 0, seg, [p.x, p.y]);
       if (!best || hit.distance < best.distance) {
-        const pt2 = _chunkBGNPT5PEcjs.segmentPoint.call(void 0, seg, hit.t);
+        const pt2 = _chunk7EDLVBOOcjs.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 };
       }
     }
@@ -749,8 +1325,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', _29 => _29.strokeWidthProfile, 'optionalAccess', _30 => _30.length]);
   return {
     ...path,
+    ...mirrored ? { strokeWidthProfile: mirrorWidthProfile(path.strokeWidthProfile) } : {},
     subpaths: path.subpaths.map((sp) => ({
       closed: sp.closed,
       anchors: sp.anchors.map((a) => {
@@ -861,7 +1439,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] = _chunk7EDLVBOOcjs.splitSegment.call(void 0, seg, t);
   const mid = left[left.length - 1];
   const anchor = { x: mid[0], y: mid[1] };
   if (seg.length === 4) {
@@ -915,8 +1493,8 @@ function ellipseSubpath(b) {
     ]
   };
 }
-function polygonSubpath(b, sides = 6) {
-  const n = Math.max(3, Math.round(sides));
+function polygonSubpath(b, sides2 = 6) {
+  const n = Math.max(3, Math.round(sides2));
   const cx = b.x + b.width / 2;
   const cy = b.y + b.height / 2;
   const anchors = [];
@@ -957,7 +1535,7 @@ function vectorCornersAttribute(subpaths, precision = 3) {
   subpaths.forEach(
     (sp, s) => sp.anchors.forEach((a, i) => {
       if (!a.corner || !(a.corner.radius > 0)) return;
-      out.push(`${s}.${i}:${_chunkBGNPT5PEcjs.formatNumber.call(void 0, a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
+      out.push(`${s}.${i}:${_chunk7EDLVBOOcjs.formatNumber.call(void 0, a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
     })
   );
   return out.join(" ");
@@ -966,7 +1544,7 @@ function applyVectorCornersAttribute(subpaths, value) {
   for (const item of value.trim().split(/\s+/)) {
     const m = /^(\d+)\.(\d+):([\d.eE+-]+)(?::([a-z]+))?$/.exec(item);
     if (!m) continue;
-    const a = _optionalChain([subpaths, 'access', _9 => _9[+m[1]], 'optionalAccess', _10 => _10.anchors, 'access', _11 => _11[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _31 => _31[+m[1]], 'optionalAccess', _32 => _32.anchors, 'access', _33 => _33[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -978,21 +1556,49 @@ var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;")
 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: _chunk7EDLVBOOcjs.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);
-  if (parts.align === "center" && !parts.heads.length) return void 0;
+  const profiled = !!strokeWidthProfileOf(node);
+  if (parts.align === "center" && !parts.heads.length && !profiled) return void 0;
   let clip = null;
   if (parts.align !== "center") {
-    const b = _chunkBGNPT5PEcjs.bezierPathBounds.call(void 0, path);
+    const b = _chunk7EDLVBOOcjs.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: _chunkBGNPT5PEcjs.bezierPathToSvg.call(void 0, parts.line, { precision }), width: parts.drawWidth, clip, heads: parts.heads.map((h) => _chunkBGNPT5PEcjs.bezierPathToSvg.call(void 0, h.path, { precision })) };
+  return {
+    align: parts.align,
+    d: _chunk7EDLVBOOcjs.bezierPathToSvg.call(void 0, parts.line, { precision }),
+    width: parts.drawWidth,
+    ...profiled && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0 ? { outline: _chunk7EDLVBOOcjs.bezierPathToSvg.call(void 0, vectorStrokeLineArea(parts, node), { precision }) } : {},
+    clip,
+    heads: parts.heads.map((h) => _chunk7EDLVBOOcjs.bezierPathToSvg.call(void 0, h.path, { precision }))
+  };
+}
+function widthProfileToAttribute(points, precision = 4) {
+  return points.map((p) => [p.t, p.left, p.right].map((n) => _chunk7EDLVBOOcjs.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) {
@@ -1007,11 +1613,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) => _chunk7EDLVBOOcjs.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) => _chunk7EDLVBOOcjs.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;
@@ -1030,13 +1636,13 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (stroke.gradient) defs.push(gradientMarkup(stroke.gradient));
     const d = vectorPathData(node, precision);
     const corners2 = vectorCornersAttribute(node.subpaths, precision);
-    const live = corners2 ? ` data-vector-d="${_chunkBGNPT5PEcjs.bezierPathToSvg.call(void 0, subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners2}"` : "";
+    const live = corners2 ? ` data-vector-d="${_chunk7EDLVBOOcjs.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', _12 => _12.strokeDasharray, 'optionalAccess', _13 => _13.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      if (_optionalChain([node, 'access', _34 => _34.strokeDasharray, 'optionalAccess', _35 => _35.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;
@@ -1051,10 +1657,17 @@ function vectorDocumentToSvg(doc, options = {}) {
     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', _36 => _36.strokeDasharray, 'optionalAccess', _37 => _37.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 = _chunkBGNPT5PEcjs.bezierPathToSvg.call(void 0, vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
+      const area = _chunk7EDLVBOOcjs.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 = "";
@@ -1071,7 +1684,8 @@ function vectorDocumentToSvg(doc, options = {}) {
           clip = ` mask="url(#${id})"`;
         }
       }
-      lines.push(`${indent(depth + 1)}<path data-vector-part="stroke" d="${parts.d}" fill="none"${lineAttrs(parts.width)}${clip}/>`);
+      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>`);
@@ -1217,7 +1831,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', _14 => _14.startsWith, 'call', _15 => _15("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _16 => _16(href.slice(1), raw, seen), 'optionalAccess', _17 => _17.stops]), () => ( []));
+  if (!stops.length && _optionalChain([href, 'optionalAccess', _38 => _38.startsWith, 'call', _39 => _39("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _40 => _40(href.slice(1), raw, seen), 'optionalAccess', _41 => _41.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 };
@@ -1321,7 +1935,7 @@ function parseVectorSvg(svg, options = {}) {
     const part = (name) => g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === name);
     const fillEl = part("fill");
     const subpaths = fillEl ? shapeOf(fillEl) : null;
-    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _18 => _18.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _42 => _42.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style);
     const strokeEl = part("stroke");
@@ -1334,6 +1948,11 @@ function parseVectorSvg(svg, options = {}) {
       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",
@@ -1349,7 +1968,11 @@ function parseVectorSvg(svg, options = {}) {
       ...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"]) } : {}
+      ...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', _43 => _43.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
@@ -1403,7 +2026,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', _19 => _19.constrain])) return p;
+  if (!_optionalChain([leave, 'optionalAccess', _44 => _44.constrain])) return p;
   const dx = p.x - leave.at.x;
   const dy = p.y - leave.at.y;
   switch (leave.constrain) {
@@ -1514,7 +2137,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', _20 => _20.get, 'call', _21 => _21(id), 'optionalAccess', _22 => _22.has, 'call', _23 => _23(`${s}:${i}`)]), true);
+    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _45 => _45.get, 'call', _46 => _46(id), 'optionalAccess', _47 => _47.has, 'call', _48 => _48(`${s}:${i}`)]), true);
     return t.index();
   }
   /**
@@ -1632,7 +2255,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', _24 => _24.centre]), () => ( null)));
+        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _49 => _49.centre]), () => ( null)));
       }
     };
     visit(doc.nodes, IDENTITY_MATRIX);
@@ -1669,7 +2292,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,
@@ -1677,23 +2300,23 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       lines: lines2,
       labels: [this.label(q, kind)]
     });
-    if (_optionalChain([leave, 'optionalAccess', _25 => _25.constrain])) {
+    if (_optionalChain([leave, 'optionalAccess', _50 => _50.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', _26 => _26.angles, 'optionalAccess', _27 => _27.length])) {
+    if (on) return at2(on, "path");
+    if (_optionalChain([leave, 'optionalAccess', _51 => _51.angles, 'optionalAccess', _52 => _52.length])) {
       const c = construction(leave, p, tol);
       if (c) {
         const hit = this.slide(leave.at, c.dir, c.point, tol, false);
@@ -1739,7 +2362,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;
@@ -1747,10 +2370,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 };
       }
@@ -1769,13 +2392,13 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     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, pt2);
+      const hit = _chunk7EDLVBOOcjs.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 ? toVec2(_chunkBGNPT5PEcjs.segmentPoint.call(void 0, near2[0].seg, near2[0].t)) : null;
+    return near2.length ? toVec2(_chunk7EDLVBOOcjs.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) {
@@ -1784,7 +2407,7 @@ 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)) {
+        for (const hit of _chunk7EDLVBOOcjs.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) {
@@ -1823,7 +2446,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
    * with nothing spaces the box evenly in its row or column. Returns the correction and guides.
    */
   snapRect(r, tol, options = {}) {
-    const axes = { x: _optionalChain([options, 'access', _28 => _28.axes, 'optionalAccess', _29 => _29.x]) !== false, y: _optionalChain([options, 'access', _30 => _30.axes, 'optionalAccess', _31 => _31.y]) !== false };
+    const axes = { x: _optionalChain([options, 'access', _53 => _53.axes, 'optionalAccess', _54 => _54.x]) !== false, y: _optionalChain([options, 'access', _55 => _55.axes, 'optionalAccess', _56 => _56.y]) !== false };
     const nearest = (lines, values) => {
       let best = null;
       for (const v2 of values) for (const l of linesNear(lines, v2, tol)) if (!best || Math.abs(l.v - v2) < Math.abs(best.d)) best = { d: l.v - v2, from: l.from };
@@ -1831,7 +2454,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     };
     const bx = axes.x ? nearest(this.xs, [r.x, r.x + r.width / 2, r.x + r.width]) : null;
     const by = axes.y ? nearest(this.ys, [r.y, r.y + r.height / 2, r.y + r.height]) : null;
-    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _32 => _32.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _33 => _33.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
+    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _57 => _57.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _58 => _58.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;
@@ -1898,11 +2521,11 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     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 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);
     }
@@ -1954,9 +2577,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', _34 => _34.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _35 => _35.v]), () => ( null)), s: { hx, hy, on: null } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _36 => _36.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
-      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _37 => _37.v]), () => ( null)), s: { hx: null, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _59 => _59.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _60 => _60.v]), () => ( null)), s: { hx, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _61 => _61.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
+      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _62 => _62.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)) });
@@ -2106,15 +2729,15 @@ 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 = _chunk7EDLVBOOcjs.segmentPoint.call(void 0, seg, t);
+    return cond([p[0] - b[0], p[1] - b[1]], _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.segmentPoint.call(void 0, seg, t);
+    const d = _chunk7EDLVBOOcjs.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]));
@@ -2141,8 +2764,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 = _chunk7EDLVBOOcjs.segmentPoint.call(void 0, seg, t);
+    const dv = _chunk7EDLVBOOcjs.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;
@@ -2179,7 +2802,7 @@ function endTangent(c) {
   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(_chunk7EDLVBOOcjs.segmentPoint.call(void 0, c, i / n));
 }
 var onAnchor2 = (a, h) => !h || Math.abs(h.x - a.x) < EPS3 && Math.abs(h.y - a.y) < EPS3;
 function tidy(a, keepType = true) {
@@ -2225,7 +2848,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 _chunk7EDLVBOOcjs.fitCubicWithTangents.call(void 0, pts, u, t0, t1);
   };
   return goldenMin(fit, 0, 1);
 }
@@ -2285,7 +2908,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] = _chunk7EDLVBOOcjs.segmentPoint.call(void 0, subpathSegment(sp, segment), t);
   return { x, y };
 }
 function curvatureMoveAnchor(sp, index, q) {
@@ -2331,9 +2954,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;
@@ -2364,7 +2987,7 @@ function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
   return cutSubpathAt(subpath, [index]);
 }
 var endOf2 = (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 dist2 = (a, b) => Math.hypot(a.x - b.x, a.y - b.y);
 function reverse(sp) {
   return {
     closed: sp.closed,
@@ -2391,7 +3014,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 {
@@ -2407,7 +3030,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(endOf2(open[i], ei), endOf2(open[j], ej));
+            const d = dist2(endOf2(open[i], ei), endOf2(open[j], ej));
             if (d < best.d) best = { d, i, j, ei, ej };
           }
         }
@@ -2447,8 +3070,8 @@ function smoothSubpath(sp, amount = 1, only) {
     const p = orig[i];
     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 });
@@ -2475,12 +3098,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);
   }
@@ -2506,8 +3129,8 @@ function mergePair(a, b, tol) {
     if (len2 < 1e-12) return null;
     const mx = a3[0] - a0[0];
     const my = a3[1] - a0[1];
-    const along = (mx * cx + my * cy) / len2;
-    return Math.abs((mx * cy - my * cx) / len2) <= tol && along >= 0 && along <= len2 ? { 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;
@@ -2546,20 +3169,20 @@ function removeRedundantPoints(sp, tolerance) {
 }
 
 // src/vector/pathCut.ts
-var loopArea = (l) => _chunkBGNPT5PEcjs.contourSignedArea.call(void 0, l.segs);
+var loopArea = (l) => _chunk7EDLVBOOcjs.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 _chunk7EDLVBOOcjs.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) => _chunk7EDLVBOOcjs.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 [];
-  const largest = usable.reduce((a, b) => Math.abs(loopArea(b)) > Math.abs(loopArea(a)) ? b : a);
+  const usable2 = loops.filter((l) => l.segs.length && Math.abs(loopArea(l)) > 1e-12);
+  if (!usable2.length) return [];
+  const largest = usable2.reduce((a, b) => Math.abs(loopArea(b)) > Math.abs(loopArea(a)) ? b : a);
   const sign = Math.sign(loopArea(largest));
-  const outers = usable.filter((l) => Math.sign(loopArea(l)) === sign).sort((a, b) => Math.abs(loopArea(a)) - Math.abs(loopArea(b)));
+  const outers = usable2.filter((l) => Math.sign(loopArea(l)) === sign).sort((a, b) => Math.abs(loopArea(a)) - Math.abs(loopArea(b)));
   const faces = new Map(outers.map((o) => [o, { loops: [o] }]));
-  for (const hole of usable.filter((l) => Math.sign(loopArea(l)) !== sign)) {
+  for (const hole of usable2.filter((l) => Math.sign(loopArea(l)) !== sign)) {
     const p = loopSample(hole);
     const parent = outers.find((o) => Math.abs(loopArea(o)) > Math.abs(loopArea(hole)) && contains2(o, p));
     if (parent) faces.get(parent).loops.push(hole);
@@ -2567,12 +3190,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 _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.normalizeBezierPath.call(void 0, path, fillRule);
+  const loops = _chunk7EDLVBOOcjs.pathToContours.call(void 0, normalized).map((c) => {
+    const segs = _chunk7EDLVBOOcjs.closeContour.call(void 0, c, true).map((s) => s.slice());
     return { segs, chord: segs.map(() => false) };
   });
   return groupFaces(loops);
@@ -2642,7 +3265,7 @@ function lineHits(p, q, seg) {
   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 = _chunk7EDLVBOOcjs.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 });
   }
@@ -2655,7 +3278,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() : _chunk7EDLVBOOcjs.subSegment.call(void 0, l.segs[k], t0, t1);
     if (!degenerate(piece, eps)) {
       segs.push(piece);
       chord.push(l.chord[k]);
@@ -2680,7 +3303,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 = _chunk7EDLVBOOcjs.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;
@@ -2694,7 +3317,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 = _chunk7EDLVBOOcjs.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;
@@ -2709,7 +3332,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 _chunk7EDLVBOOcjs.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];
@@ -2769,33 +3392,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 _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.pathBoolean.call(void 0, "intersection", [{ path, fillRule }, { path: region }]).path;
+  if (!_chunk7EDLVBOOcjs.pathToContours.call(void 0, overlap).some((c) => Math.abs(_chunk7EDLVBOOcjs.contourSignedArea.call(void 0, _chunk7EDLVBOOcjs.closeContour.call(void 0, c, true))) > 1e-9)) return null;
+  const rest = _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.pathToContours.call(void 0, region).flatMap((c) => _chunk7EDLVBOOcjs.closeContour.call(void 0, c, true));
   if (!regionSegs.length) return null;
-  const rb = _chunkBGNPT5PEcjs.bezierPathBounds.call(void 0, region);
+  const rb = _chunk7EDLVBOOcjs.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) => _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.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 _chunk7EDLVBOOcjs.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);
@@ -2803,7 +3426,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(_chunk7EDLVBOOcjs.segmentPoint.call(void 0, seg, (t0 + t1) / 2))) {
         any = true;
         if (cur.length) runs.push(cur);
         cur = [];
@@ -2822,7 +3445,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 = _chunk7EDLVBOOcjs.subSegment.call(void 0, subpathSegment(sp, seg), t0, t1);
       const line2 = c.length === 2;
       const start = c[0];
       const end = c[c.length - 1];
@@ -2939,7 +3562,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];
@@ -2957,7 +3580,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;
@@ -3019,7 +3642,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;
@@ -3046,7 +3669,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;
       }
@@ -3086,8 +3709,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 };
@@ -3111,9 +3734,188 @@ function recognizeInkShape(points, options = {}) {
   return roundish && rms < 0.1 ? ellipse() : null;
 }
 
+// src/vector/builder.ts
+function vectorPathEntries(doc, roots, options = {}) {
+  const out = [];
+  const visit = (node, parent, inside) => {
+    if (node.visible === false || node.locked && !options.locked) return;
+    const picked = inside || roots === null || roots.includes(node.id);
+    if (node.type === "group") {
+      const m = multiplyMatrices(nodeMatrix(node), parent);
+      for (const c of node.children) visit(c, m, picked);
+    } else if (picked) out.push({ node, parent });
+  };
+  for (const n of doc.nodes) visit(n, IDENTITY_MATRIX, false);
+  return out;
+}
+var usable = (sp) => sp.anchors.length > 1;
+function worldOf(entry, subpaths) {
+  return vectorPathWorldBezier({ ...entry.node, subpaths }, entry.parent);
+}
+function subpathEnclosesArea(sp) {
+  const contour = _chunk7EDLVBOOcjs.pathToContours.call(void 0, subpathsToBezier([{ ...sp, closed: true }]))[0];
+  if (!contour) return false;
+  const segs = _chunk7EDLVBOOcjs.closeContour.call(void 0, contour, true);
+  const b = _chunk7EDLVBOOcjs.bezierPathBounds.call(void 0, _chunk7EDLVBOOcjs.contoursToPath.call(void 0, [{ segments: segs, closed: true }]));
+  if (!b) return false;
+  const w = b.maxX - b.minX;
+  const h = b.maxY - b.minY;
+  return Math.abs(_chunk7EDLVBOOcjs.contourSignedArea.call(void 0, segs)) > 1e-9 * (w * w + h * h);
+}
+var paintKey = (paint) => typeof paint === "string" ? paint.trim().toLowerCase() : JSON.stringify(_nullishCoalesce(paint, () => ( null)));
+function vectorPathfinderShape(entry, op) {
+  const { node } = entry;
+  const subpaths = node.subpaths.filter(usable);
+  const closed = subpaths.map((s) => ({ ...s, closed: true }));
+  const fillRule = _nullishCoalesce(node.fillRule, () => ( "nonzero"));
+  if (hasPaint(node.fill)) return { path: worldOf(entry, closed), fillRule, key: `fill:${paintKey(node.fill)}`, paint: "fill" };
+  const open = subpaths.length > 0 && subpaths.every((s) => !s.closed);
+  if (op === "divide" && open) return { path: worldOf(entry, subpaths), line: true, paint: "line" };
+  if (hasPaint(node.stroke) && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0) {
+    const path = vectorStrokeOutline({ ...node, subpaths }, entry.parent);
+    return { path, fillRule: "nonzero", key: `fill:${paintKey(node.stroke)}`, paint: "stroke" };
+  }
+  return { path: worldOf(entry, closed), fillRule, key: "none", paint: "outline" };
+}
+var STROKE_KEYS = [
+  "stroke",
+  "strokeWidth",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeDasharray",
+  "strokeAlign",
+  "startArrow",
+  "endArrow",
+  "arrowAlign",
+  "startArrowScale",
+  "endArrowScale",
+  "strokeWidthProfile"
+];
+function vectorResultStyle(node, paint, edge = false) {
+  const { id: _id, subpaths: _s, transform: _t, ...rest } = node;
+  const base = { ...rest, fillRule: "nonzero" };
+  if (edge) {
+    for (const k of STROKE_KEYS) delete base[k];
+    const stroke = paint === "stroke" || !hasPaint(node.fill) ? node.stroke : node.fill;
+    return { ...base, fill: null, stroke: _nullishCoalesce(stroke, () => ( "#000000")), strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)) };
+  }
+  if (paint === "stroke") {
+    for (const k of STROKE_KEYS) delete base[k];
+    return { ...base, fill: _nullishCoalesce(node.stroke, () => ( null)), stroke: null };
+  }
+  return base;
+}
+function vectorShapeBuilderMap(entries) {
+  const lines = [];
+  const inputs = entries.map((entry) => {
+    const filled = hasPaint(entry.node.fill);
+    const subpaths = entry.node.subpaths.filter(usable).map((sp) => !sp.closed && filled && subpathEnclosesArea(sp) ? { ...sp, closed: true } : sp);
+    lines.push(!subpaths.some((s) => s.closed));
+    return { path: worldOf(entry, subpaths), fillRule: _nullishCoalesce(entry.node.fillRule, () => ( "nonzero")) };
+  });
+  const map = _chunk7EDLVBOOcjs.PlanarMap.build(inputs);
+  if (!map) return null;
+  const pieces = map.chains().filter((c) => lines[c.source] && !c.closed).map((c) => {
+    const path = _chunk7EDLVBOOcjs.contoursToPath.call(void 0, [{ segments: c.segments, closed: false }]);
+    return { path, segments: c.segments, source: c.source, bounds: _chunk7EDLVBOOcjs.bezierPathBounds.call(void 0, path) };
+  });
+  return { entries: [...entries], map, lines, pieces };
+}
+function vectorShapeBuilderHit(m, p, lineTolerance = null) {
+  const point = [p.x, p.y];
+  if (lineTolerance !== null && lineTolerance > 0) {
+    let best = -1;
+    let bestD = lineTolerance;
+    m.pieces.forEach((piece, i) => {
+      const b = piece.bounds;
+      if (p.x < b.minX - bestD || p.x > b.maxX + bestD || p.y < b.minY - bestD || p.y > b.maxY + bestD) return;
+      const d = _chunk7EDLVBOOcjs.distanceToBezierPath.call(void 0, piece.path, point);
+      if (d <= bestD) {
+        best = i;
+        bestD = d;
+      }
+    });
+    if (best >= 0) return { line: best };
+  }
+  const face = m.map.faceAt(point);
+  return face >= 0 ? { face } : null;
+}
+function samplePolyline(points, step) {
+  const out = [];
+  const s = Math.max(step, 1e-3);
+  points.forEach((p, i) => {
+    if (i > 0) {
+      const a = points[i - 1];
+      const n = Math.min(4e3, Math.ceil(Math.hypot(p.x - a.x, p.y - a.y) / s));
+      for (let k = 1; k < n; k++) out.push({ x: a.x + (p.x - a.x) * k / n, y: a.y + (p.y - a.y) * k / n });
+    }
+    out.push(p);
+  });
+  return out;
+}
+function addBuilderHit(touched, hit) {
+  if (!hit) return false;
+  const [list, i] = "face" in hit ? [touched.faces, hit.face] : [touched.lines, hit.line];
+  if (list.includes(i)) return false;
+  list.push(i);
+  return true;
+}
+function sides(m, piece) {
+  const seg = piece.segments[Math.floor(piece.segments.length / 2)];
+  const mid = _chunk7EDLVBOOcjs.segmentPoint.call(void 0, seg, 0.5);
+  const t = _chunk7EDLVBOOcjs.segmentTangent.call(void 0, seg, 0.5);
+  const chord = Math.hypot(seg[seg.length - 1][0] - seg[0][0], seg[seg.length - 1][1] - seg[0][1]);
+  const off = Math.max(1e-6, Math.min(0.05, 0.05 * chord));
+  return [m.map.faceAt([mid[0] - t[1] * off, mid[1] + t[0] * off]), m.map.faceAt([mid[0] + t[1] * off, mid[1] - t[0] * off])];
+}
+function planShapeBuilder(m, touched, erase) {
+  const replace = /* @__PURE__ */ new Map();
+  const picked = new Set(touched.faces);
+  const faces = m.map.faces;
+  const sourcesOf = faces.map((_, i) => m.map.faceSources(i));
+  m.entries.forEach((_, i) => {
+    if (m.lines[i]) {
+      const own = m.pieces.flatMap((piece, k) => piece.source === i ? [k] : []);
+      const keep = own.filter((k) => !touched.lines.includes(k) && !sides(m, m.pieces[k]).every((f) => f >= 0 && picked.has(f)));
+      if (keep.length === own.length) return;
+      replace.set(i, keep.length ? { kind: "pieces", paths: keep.map((k) => m.pieces[k].path) } : null);
+      return;
+    }
+    if (!touched.faces.some((f) => sourcesOf[f].includes(i))) return;
+    const kept = faces.flatMap((_2, f) => sourcesOf[f].includes(i) && !picked.has(f) ? [f] : []);
+    const rest = kept.length ? m.map.merge(kept) : [];
+    replace.set(i, rest.length ? { kind: "fill", path: rest } : null);
+  });
+  let merged = null;
+  if (!erase && touched.faces.length) {
+    const path = m.map.merge(touched.faces);
+    const covered = touched.faces.map((f) => sourcesOf[f]).find((s) => s.length);
+    const lastShape = m.lines.lastIndexOf(false);
+    const style = covered ? covered[covered.length - 1] : lastShape >= 0 ? lastShape : m.entries.length - 1;
+    if (path.length) merged = { path, style, currentFill: !covered };
+  }
+  return { replace, merged };
+}
+function vectorFillMap(doc, gap = 0) {
+  const entries = vectorPathEntries(doc, null, { locked: true });
+  return _chunk7EDLVBOOcjs.PlanarMap.build(
+    entries.map((e) => ({ path: worldOf(e, e.node.subpaths.filter(usable)), fills: false })),
+    { gap, maxSegments: 2e4 }
+  );
+}
+
 // 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 VECTOR_FILL_GAP = 6;
+var DEFAULT_VECTOR_PATH_EDIT = {
+  keepShapeOnDelete: true,
+  curvatureMoves: false,
+  pencilSmoothing: 0,
+  recognizeShapes: false,
+  eraserSize: 10,
+  pencilPressure: "pen",
+  fillGap: 0
+};
 var VECTOR_PENCIL_STRING_PX = 100;
 var VECTOR_STYLE_KEYS = [
   "fill",
@@ -3128,7 +3930,8 @@ var VECTOR_STYLE_KEYS = [
   "endArrow",
   "arrowAlign",
   "startArrowScale",
-  "endArrowScale"
+  "endArrowScale",
+  "strokeWidthProfile"
 ];
 var VECTOR_CLIPBOARD_TYPE = "pixerate/vector";
 var DEFAULT_DEFAULTS = {
@@ -3157,7 +3960,7 @@ function getEditablePathIds(state) {
       }
     }
   }
-  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _38 => _38(state.document.nodes, id), 'optionalAccess', _39 => _39.type]) === "path");
+  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _63 => _63(state.document.nodes, id), 'optionalAccess', _64 => _64.type]) === "path");
 }
 function getVisibleAnchors(state) {
   const out = [];
@@ -3172,7 +3975,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', _40 => _40.anchors, 'access', _41 => _41[i]]);
+    const a = _optionalChain([sp, 'optionalAccess', _65 => _65.anchors, 'access', _66 => _66[i]]);
     if (!a || !a[handle]) return;
     const key = `${node.id}:${s}:${i}:${handle}`;
     if (seen.has(key)) return;
@@ -3181,8 +3984,8 @@ function getVisibleHandles(state) {
   };
   if (state.tool === "pen" && state.pen) {
     const node = findVectorNode(state.document.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _42 => _42.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
-    if (_optionalChain([node, 'optionalAccess', _43 => _43.type]) === "path" && sp) {
+    const sp = _optionalChain([node, 'optionalAccess', _67 => _67.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    if (_optionalChain([node, 'optionalAccess', _68 => _68.type]) === "path" && sp) {
       const last = sp.anchors.length - 1;
       push(node, state.pen.subpath, last, "in");
       push(node, state.pen.subpath, last, "out");
@@ -3190,9 +3993,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;
@@ -3220,18 +4023,68 @@ function getVectorCornerWidgets(state) {
       const side = Math.min(c.lu, c.lv);
       if (side * zoom < 3 * VECTOR_CORNER_WIDGET_INSET) continue;
       const a = node.subpaths[c.subpath].anchors[c.index];
-      const radius = _nullishCoalesce(_optionalChain([a, 'access', _44 => _44.corner, 'optionalAccess', _45 => _45.radius]), () => ( 0));
+      const radius = _nullishCoalesce(_optionalChain([a, 'access', _69 => _69.corner, 'optionalAccess', _70 => _70.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', _46 => _46.corner, 'optionalAccess', _47 => _47.kind]), () => ( "round")), corner: c });
+      out.push({ ref: { nodeId: id, subpath: c.subpath, index: c.index }, x: p.x, y: p.y, radius, drawnRadius: drawn, kind: _nullishCoalesce(_optionalChain([a, 'access', _71 => _71.corner, 'optionalAccess', _72 => _72.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', _73 => _73.hover, 'optionalAccess', _74 => _74.nodeId])) ids.add(state.hover.nodeId);
+  if (_optionalChain([state, 'access', _75 => _75.interaction, 'optionalAccess', _76 => _76.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', _77 => _77.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _78 => _78.strokeWidthProfile, 'optionalAccess', _79 => _79.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', _48 => _48.type]) === "path" ? _optionalChain([node, 'access', _49 => _49.subpaths, 'access', _50 => _50[ref.subpath], 'optionalAccess', _51 => _51.anchors, 'access', _52 => _52[ref.index]]) : void 0;
+  return _optionalChain([node, 'optionalAccess', _80 => _80.type]) === "path" ? _optionalChain([node, 'access', _81 => _81.subpaths, 'access', _82 => _82[ref.subpath], 'optionalAccess', _83 => _83.anchors, 'access', _84 => _84[ref.index]]) : void 0;
 }
 function getAnchorWorld(doc, ref) {
   const a = getAnchor(doc, ref);
@@ -3299,9 +4152,28 @@ var TOOL_LABELS = {
   line: "Line",
   scissors: "Scissors",
   knife: "Knife",
-  eraser: "Eraser"
+  eraser: "Eraser",
+  width: "Width",
+  shapeBuilder: "Shape Builder",
+  paintBucket: "Paint Bucket"
+};
+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",
+  m: "shapeBuilder",
+  b: "paintBucket"
 };
-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" };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
 }
@@ -3317,7 +4189,10 @@ var VECTOR_TOOL_SHORTCUTS = {
   line: "L",
   scissors: "C",
   knife: "K",
-  eraser: "E"
+  eraser: "E",
+  width: "W",
+  shapeBuilder: "M",
+  paintBucket: "B"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -3331,7 +4206,10 @@ var VECTOR_TOOL_GLYPHS = {
   line: "\u2571",
   scissors: "\u2702",
   knife: "\u27CB",
-  eraser: "\u232B"
+  eraser: "\u232B",
+  width: "\u21F9",
+  shapeBuilder: "\u2295",
+  paintBucket: "\u25CD"
 };
 var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line"]);
 var BOOLEAN_OPS = {
@@ -3341,6 +4219,14 @@ var BOOLEAN_OPS = {
   exclude: "xor"
 };
 var BOOLEAN_LABELS = { union: "Union", subtract: "Subtract", intersect: "Intersect", exclude: "Exclude" };
+var VECTOR_PATHFINDER_LABELS = {
+  divide: "Divide",
+  trim: "Trim",
+  merge: "Merge",
+  crop: "Crop",
+  outline: "Outline",
+  minusBack: "Minus Back"
+};
 function mapTree(nodes, fn) {
   let changed = false;
   const out = [];
@@ -3385,35 +4271,43 @@ 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}
+  /** Shape Builder map of the selection, kept while the document and the selection stay the same. */
+  __init23() {this.builderCache = null}
+  /** Paint bucket map of the visible outlines. */
+  __init24() {this.fillCache = null}
+  __init25() {this.builderPreview = null}
+  /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
+  __init26() {this.builderHoverKey = null}
   
   
-  __init22() {this.listeners = /* @__PURE__ */ new Set()}
-  __init23() {this.cleanups = []}
-  __init24() {this.applying = false}
+  __init27() {this.listeners = /* @__PURE__ */ new Set()}
+  __init28() {this.cleanups = []}
+  __init29() {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}
+  __init30() {this.committing = false}
+  __init31() {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);_class3.prototype.__init30.call(this);_class3.prototype.__init31.call(this);_class3.prototype.__init32.call(this);_class3.prototype.__init33.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"));
@@ -3442,9 +4336,9 @@ var VectorEditorController = (_class3 = class {
   // State
   // -------------------------------------------------------------------------
   /** The current snapshot (stable until the next change). */
-  __init27() {this.getState = () => this.state}
+  __init32() {this.getState = () => this.state}
   /** Calls `listener` after every change. Returns an unsubscribe function. */
-  __init28() {this.subscribe = (listener) => {
+  __init33() {this.subscribe = (listener) => {
     this.listeners.add(listener);
     return () => {
       this.listeners.delete(listener);
@@ -3463,6 +4357,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()),
@@ -3477,6 +4372,7 @@ var VectorEditorController = (_class3 = class {
       interaction: this.interaction,
       pen: this.pen,
       pointer: this.pointer,
+      builder: this.builderPreview,
       canUndo: h.canUndo,
       canRedo: h.canRedo,
       undoLabel: h.undoName,
@@ -3487,7 +4383,7 @@ var VectorEditorController = (_class3 = class {
   notify(docChanged = false) {
     this.revision++;
     this.state = this.computeState();
-    if (docChanged) _optionalChain([this, 'access', _53 => _53.onChange, 'optionalCall', _54 => _54(this.doc)]);
+    if (docChanged) _optionalChain([this, 'access', _85 => _85.onChange, 'optionalCall', _86 => _86(this.doc)]);
     const state = this.state;
     this.listeners.forEach((listener) => {
       try {
@@ -3517,20 +4413,29 @@ var VectorEditorController = (_class3 = class {
     return applyMatrix(invertMatrix(this.worldOf(id, doc)), p);
   }
   cursorFor() {
-    if (_optionalChain([this, 'access', _55 => _55.drag, 'optionalAccess', _56 => _56.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
-    if (_optionalChain([this, 'access', _57 => _57.drag, 'optionalAccess', _58 => _58.kind]) === "rotate") return "grabbing";
-    if (_optionalChain([this, 'access', _59 => _59.drag, 'optionalAccess', _60 => _60.kind]) === "move") return "move";
+    if (_optionalChain([this, 'access', _87 => _87.drag, 'optionalAccess', _88 => _88.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
+    if (_optionalChain([this, 'access', _89 => _89.drag, 'optionalAccess', _90 => _90.kind]) === "rotate") return "grabbing";
+    if (_optionalChain([this, 'access', _91 => _91.drag, 'optionalAccess', _92 => _92.kind]) === "move") return "move";
     const h = this.hover;
     switch (this.tool) {
       case "select":
-        if (_optionalChain([h, 'optionalAccess', _61 => _61.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _62 => _62.frameOf, 'call', _63 => _63(this.selectedRoots()), 'optionalAccess', _64 => _64.angle]), () => ( 0)));
-        return _optionalChain([h, 'optionalAccess', _65 => _65.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _93 => _93.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _94 => _94.frameOf, 'call', _95 => _95(this.selectedRoots()), 'optionalAccess', _96 => _96.angle]), () => ( 0)));
+        return _optionalChain([h, 'optionalAccess', _97 => _97.nodeId]) ? "move" : "default";
       case "direct":
-        if (_optionalChain([h, 'optionalAccess', _66 => _66.anchor]) || _optionalChain([h, 'optionalAccess', _67 => _67.handle]) || _optionalChain([h, 'optionalAccess', _68 => _68.corner])) return "pointer";
-        if (_optionalChain([h, 'optionalAccess', _69 => _69.segment])) return "copy";
-        return _optionalChain([h, 'optionalAccess', _70 => _70.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _98 => _98.anchor]) || _optionalChain([h, 'optionalAccess', _99 => _99.handle]) || _optionalChain([h, 'optionalAccess', _100 => _100.corner])) return "pointer";
+        if (_optionalChain([h, 'optionalAccess', _101 => _101.segment])) return "copy";
+        return _optionalChain([h, 'optionalAccess', _102 => _102.nodeId]) ? "move" : "default";
       case "pen":
-        return _optionalChain([h, 'optionalAccess', _71 => _71.anchor]) ? "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _103 => _103.anchor]) ? "pointer" : "crosshair";
+      case "width":
+        if (_optionalChain([this, 'access', _104 => _104.drag, 'optionalAccess', _105 => _105.kind]) === "width") return this.drag.mode === "move" ? "grabbing" : "ew-resize";
+        if (_optionalChain([h, 'optionalAccess', _106 => _106.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
+        return _optionalChain([h, 'optionalAccess', _107 => _107.strokeSpot]) ? "copy" : "default";
+      case "shapeBuilder":
+        if (!_optionalChain([this, 'access', _108 => _108.builderPreview, 'optionalAccess', _109 => _109.faces, 'access', _110 => _110.length]) && !_optionalChain([this, 'access', _111 => _111.builderPreview, 'optionalAccess', _112 => _112.lines, 'access', _113 => _113.length])) return "crosshair";
+        return this.builderPreview.mode === "erase" ? "not-allowed" : "cell";
+      case "paintBucket":
+        return this.builderPreview ? "cell" : "crosshair";
       default:
         return "crosshair";
     }
@@ -3550,7 +4455,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', _72 => _72.getNode, 'call', _73 => _73(s.pen.nodeId), 'optionalAccess', _74 => _74.subpaths, 'optionalAccess', _75 => _75[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _114 => _114.getNode, 'call', _115 => _115(s.pen.nodeId), 'optionalAccess', _116 => _116.subpaths, 'optionalAccess', _117 => _117[s.pen.subpath]]) ? s.pen : null;
     } finally {
       this.applying = false;
     }
@@ -3656,6 +4561,9 @@ var VectorEditorController = (_class3 = class {
     this.tool = tool;
     this.hover = null;
     this.guides = null;
+    this.widthPoint = null;
+    this.builderPreview = null;
+    this.builderHoverKey = null;
     if (tool !== "direct") {
       this.anchors = [];
       this.editingId = null;
@@ -3714,7 +4622,7 @@ var VectorEditorController = (_class3 = class {
       if (res.kind) {
         this.snappedToObject = true;
         this.setGuides(res);
-        return _optionalChain([leave, 'optionalAccess', _76 => _76.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', _118 => _118.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);
@@ -3732,14 +4640,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', _77 => _77.getNode, 'call', _78 => _78(this.pen.nodeId), 'optionalAccess', _79 => _79.subpaths, 'access', _80 => _80[this.pen.subpath]]) : void 0;
-      if (this.pen && sp && _optionalChain([this, 'access', _81 => _81.hover, 'optionalAccess', _82 => _82.anchor])) {
+      const sp = this.pen ? _optionalChain([this, 'access', _119 => _119.getNode, 'call', _120 => _120(this.pen.nodeId), 'optionalAccess', _121 => _121.subpaths, 'access', _122 => _122[this.pen.subpath]]) : void 0;
+      if (this.pen && sp && _optionalChain([this, 'access', _123 => _123.hover, 'optionalAccess', _124 => _124.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', _83 => _83.pen, 'optionalAccess', _84 => _84.nodeId]), () => ( null))));
+      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _125 => _125.pen, 'optionalAccess', _126 => _126.nodeId]), () => ( null))));
     }
     if (SHAPE_TOOLS.has(this.tool)) return this.snapDrawn(p, null, input, () => this.drawingTargets(null));
     this.setGuides(null);
@@ -3887,6 +4795,7 @@ var VectorEditorController = (_class3 = class {
     if (d.fillRule) out.fillRule = d.fillRule;
     if (d.strokeAlign && d.strokeAlign !== "center") out.strokeAlign = d.strokeAlign;
     for (const key of ["startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale"]) if (d[key]) out[key] = d[key];
+    if (_optionalChain([d, 'access', _127 => _127.strokeWidthProfile, 'optionalAccess', _128 => _128.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     return out;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -3907,10 +4816,39 @@ 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', _129 => _129.type]) !== "path" || !_optionalChain([node, 'access', _130 => _130.strokeWidthProfile, 'optionalAccess', _131 => _131[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
@@ -3930,7 +4868,7 @@ var VectorEditorController = (_class3 = class {
     const refs = this.cornerTargets(options);
     if (!refs.length) return { ok: false, message: "Nothing is selected." };
     this.change("Corner Kind", () => {
-      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _85 => _85.corner, 'optionalAccess', _86 => _86.radius]), () => ( 0)), kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _132 => _132.corner, 'optionalAccess', _133 => _133.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
@@ -3981,6 +4919,7 @@ var VectorEditorController = (_class3 = class {
         arrowAlign: _al,
         startArrowScale: _ss,
         endArrowScale: _es,
+        strokeWidthProfile: _wp,
         ...rest
       } = cloneVectorNode(p);
       const id = this.newId();
@@ -4068,10 +5007,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', _87 => _87.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _134 => _134.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _88 => _88(this.doc.nodes, parent.id), 'optionalAccess', _89 => _89.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _135 => _135(this.doc.nodes, parent.id), 'optionalAccess', _136 => _136.parent]), () => ( null));
       }
       return !covered;
     });
@@ -4254,8 +5193,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', _90 => _90[0], 'access', _91 => _91.parent, 'optionalAccess', _92 => _92.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _93 => _93.parent, 'optionalAccess', _94 => _94.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _137 => _137[0], 'access', _138 => _138.parent, 'optionalAccess', _139 => _139.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _140 => _140.parent, 'optionalAccess', _141 => _141.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -4278,11 +5217,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', _95 => _95.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _142 => _142.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) {
@@ -4294,14 +5233,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 };
@@ -4338,7 +5277,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 = _chunk7EDLVBOOcjs.pathBoolean.call(void 0, 
       BOOLEAN_OPS[op],
       paths.map((p) => ({
         path: vectorPathWorldBezier(
@@ -4388,11 +5327,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 : _chunk7EDLVBOOcjs.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', _96 => _96.type]) === "path" && n.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _143 => _143.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));
@@ -4412,6 +5351,248 @@ var VectorEditorController = (_class3 = class {
     return { ok: true };
   }
   // -------------------------------------------------------------------------
+  // Pathfinder, Shape Builder and paint bucket
+  // -------------------------------------------------------------------------
+  /**
+   * Pathfinder: Divide, Trim, Merge, Crop, Outline or Minus Back over the selected (or given)
+   * paths, in document space (rotated nodes and groups included, live corners cut). Unfilled
+   * stroked paths take part as the area their stroke paints (Divide: open ones cut instead).
+   * The results replace the operands at the place of the top-most one, grouped when there are
+   * several; each keeps the style of the operand whose area it is. Returns the new path ids,
+   * or an empty list when nothing came out.
+   */
+  pathfinder(op, options = {}) {
+    const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
+    const entries = vectorPathEntries(this.doc, roots);
+    if (entries.length < (op === "divide" || op === "outline" ? 1 : 2)) return [];
+    const shapes = entries.map((e) => vectorPathfinderShape(e, op));
+    const result = _chunk7EDLVBOOcjs.pathfinder.call(void 0, op, shapes);
+    if (result.error || !result.pieces.length) return [];
+    const last = entries[entries.length - 1].node.id;
+    const topRoot = _nullishCoalesce([...roots].reverse().find((r) => {
+      const n = this.getNode(r);
+      return !!n && !!findVectorNode([n], last);
+    }), () => ( last));
+    const nodes = [];
+    for (const piece of result.pieces) {
+      const subpaths = bezierToSubpaths(this.intoParentSpace(topRoot, piece.path)).map((sp) => piece.open ? { ...sp, closed: false } : sp);
+      if (!subpaths.length) continue;
+      const source = entries[piece.source].node;
+      const style = vectorResultStyle(source, shapes[piece.source].paint, op === "outline");
+      nodes.push({ ...style, type: "path", id: this.newId(), name: _nullishCoalesce(source.name, () => ( "Path")), subpaths });
+    }
+    if (!nodes.length) return [];
+    const label = VECTOR_PATHFINDER_LABELS[op];
+    const container = nodes.length > 1 ? { id: this.newId(), type: "group", name: label, children: nodes } : nodes[0];
+    const drop = /* @__PURE__ */ new Set([...entries.map((e) => e.node.id), ...roots]);
+    this.change(label, () => {
+      this.setDoc(mapTree(this.doc.nodes, (n) => n.id === topRoot ? container : drop.has(n.id) ? null : n));
+      this.selection = [container.id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return nodes.map((n) => n.id);
+  }
+  /** The Shape Builder map of the selected (or given) paths, cached per document and selection. */
+  shapeBuilderMap(ids) {
+    const roots = _nullishCoalesce(ids, () => ( this.selectedRoots()));
+    const key = roots.join("\0");
+    if (_optionalChain([this, 'access', _144 => _144.builderCache, 'optionalAccess', _145 => _145.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
+    const entries = roots.length ? vectorPathEntries(this.doc, roots) : [];
+    const map = entries.length ? vectorShapeBuilderMap(entries) : null;
+    this.builderCache = { doc: this.doc, key, map };
+    return map;
+  }
+  /** The faces the Shape Builder offers for the selected (or given) paths (document units). */
+  getShapeBuilderFaces(options = {}) {
+    const m = this.shapeBuilderMap(options.ids);
+    if (!m) return [];
+    return m.map.faces.map((f, index) => {
+      const p = m.map.faceInterior(index);
+      return {
+        index,
+        d: _chunk7EDLVBOOcjs.bezierPathToSvg.call(void 0, f.path, { precision: 3 }),
+        area: f.area,
+        sources: m.map.faceSources(index).map((i) => m.entries[i].node.id),
+        point: p ? { x: p[0], y: p[1] } : null
+      };
+    });
+  }
+  /** Pick distance of the Shape Builder's erase for line pieces (document units). */
+  builderLineTolerance() {
+    return Math.max(this.hitRadius, 4) / this.viewport.zoom;
+  }
+  /**
+   * Shape Builder gesture along `points` (document units; one point is a click) over the faces
+   * the selected (or given) paths make. Merges the faces touched into one shape styled like the
+   * top-most shape over the first face (the current fill for a face only outlines enclose);
+   * with `erase` deletes them, and the pieces of unfilled open paths within `tolerance`. Every
+   * shape covering a touched face loses that area. One undo step.
+   */
+  shapeBuilder(points, options = {}) {
+    const none = (message) => ({ ok: false, message, merged: null, faces: 0, lines: 0 });
+    if (!points.length || !points.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) return none("Give the points of the gesture.");
+    const m = this.shapeBuilderMap(options.ids);
+    if (!m) return none("Select paths that make faces.");
+    const erase = !!options.erase;
+    const tol = erase ? _nullishCoalesce(options.tolerance, () => ( this.builderLineTolerance())) : null;
+    const touched = { faces: [], lines: [] };
+    const size = m.map.faces.reduce((s, f) => Math.max(s, f.bounds.maxX - f.bounds.minX, f.bounds.maxY - f.bounds.minY), 1);
+    for (const p of samplePolyline(points, Math.max(size / 2e3, 0.25 / this.viewport.zoom))) addBuilderHit(touched, vectorShapeBuilderHit(m, p, tol));
+    if (!touched.faces.length && !touched.lines.length) return none("There is no face under the pointer.");
+    return this.applyShapeBuilder(m, touched, erase);
+  }
+  applyShapeBuilder(m, touched, erase) {
+    const plan = planShapeBuilder(m, touched, erase);
+    let mergedId = null;
+    const created = /* @__PURE__ */ new Map();
+    this.change(erase ? "Shape Builder Delete" : "Shape Builder", () => {
+      let nodes = this.doc.nodes;
+      m.entries.forEach((entry, i) => {
+        const node = entry.node;
+        const toLocal = (path) => _chunk7EDLVBOOcjs.transformBezierPath.call(void 0, path, invertMatrix(multiplyMatrices(nodeMatrix(node), entry.parent)));
+        const list = [];
+        const r = plan.replace.get(i);
+        if (r === void 0) list.push(node);
+        else if (_optionalChain([r, 'optionalAccess', _146 => _146.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _147 => _147.kind]) === "pieces") {
+          r.paths.forEach(
+            (path, k) => list.push({ ...node, id: k === 0 ? node.id : this.newId(), subpaths: bezierToSubpaths(toLocal(path)).map((sp) => ({ ...sp, closed: false })) })
+          );
+        }
+        if (plan.merged && plan.merged.style === i) {
+          mergedId = this.newId();
+          const merged = {
+            ...vectorResultStyle(node, "fill"),
+            type: "path",
+            id: mergedId,
+            name: "Shape",
+            ...node.transform ? { transform: node.transform } : {},
+            subpaths: bezierToSubpaths(toLocal(plan.merged.path))
+          };
+          if (plan.merged.currentFill || !hasPaint(merged.fill)) merged.fill = hasPaint(this.defaults.fill) ? this.defaults.fill : "#808080";
+          list.push(merged);
+        }
+        if (r === void 0 && list.length === 1) return;
+        created.set(node.id, list.map((n) => n.id));
+        nodes = spliceTree(nodes, node.id, list);
+      });
+      this.setDoc(nodes);
+      const selection = this.selection.flatMap((id) => _nullishCoalesce(created.get(id), () => ( [id])));
+      if (mergedId && !selection.includes(mergedId)) selection.push(mergedId);
+      this.selection = selection.filter((id, k) => !!this.getNode(id) && selection.indexOf(id) === k);
+      this.anchors = [];
+      this.editingId = null;
+    });
+    this.builderCache = null;
+    return { ok: true, merged: mergedId, faces: touched.faces.length, lines: touched.lines.length };
+  }
+  /** The paint bucket's map of the visible outlines, cached per document and gap. */
+  fillMap(gap) {
+    if (_optionalChain([this, 'access', _148 => _148.fillCache, 'optionalAccess', _149 => _149.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
+    const map = vectorFillMap(this.doc, gap);
+    this.fillCache = { doc: this.doc, gap, map };
+    return map;
+  }
+  /**
+   * Paint bucket: the region the visible outlines enclose around `point` (document units),
+   * crossings split and islands left as holes, becomes a new path filled with the current fill
+   * default, placed just below the selection (or on top when nothing is selected). `gap`
+   * (default `editing.fillGap`) closes gaps up to that size between loose ends. Returns the new
+   * path's id, or null when nothing encloses the point.
+   */
+  fillRegion(point, options = {}) {
+    if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) return null;
+    const region = _optionalChain([this, 'access', _150 => _150.fillMap, 'call', _151 => _151(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _152 => _152.regionAt, 'call', _153 => _153([point.x, point.y])]);
+    if (!_optionalChain([region, 'optionalAccess', _154 => _154.length])) return null;
+    let below = null;
+    const roots = new Set(this.selectedRoots());
+    walkVectorNodes(this.doc.nodes, (n) => {
+      if (!below && roots.has(n.id)) below = n.id;
+    });
+    const subpaths = bezierToSubpaths(below ? this.intoParentSpace(below, region) : region);
+    if (!subpaths.length) return null;
+    const id = this.newId();
+    const node = { id, type: "path", name: "Fill", ...this.styleFor(false), stroke: null, fillRule: "nonzero", subpaths };
+    if (!hasPaint(node.fill)) node.fill = "#808080";
+    const target = below;
+    this.change("Fill Region", () => {
+      if (target) {
+        const current = this.getNode(target);
+        this.setDoc(spliceTree(this.doc.nodes, target, [node, current]));
+      } else this.setDoc([...this.doc.nodes, node]);
+      if (!target) this.selection = [id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return id;
+  }
+  /** Updates the Shape Builder / paint bucket highlight for the pointer at `p`; true when it changed. */
+  hoverBuilder(p, alt) {
+    if (this.tool === "paintBucket") {
+      const region = _nullishCoalesce(_optionalChain([this, 'access', _155 => _155.fillMap, 'call', _156 => _156(this.editing.fillGap), 'optionalAccess', _157 => _157.regionAt, 'call', _158 => _158([p.x, p.y])]), () => ( null));
+      const key2 = region ? _chunk7EDLVBOOcjs.bezierPathToSvg.call(void 0, region, { precision: 2 }) : null;
+      if (key2 === this.builderHoverKey) return false;
+      this.builderHoverKey = key2;
+      this.builderPreview = region ? { mode: "fill", faces: [region], lines: [], trail: null } : null;
+      return true;
+    }
+    const m = this.selectedRoots().length ? this.shapeBuilderMap() : null;
+    const hit = m ? vectorShapeBuilderHit(m, p, alt ? this.builderLineTolerance() : null) : null;
+    const key = hit ? `${alt ? "erase" : "merge"}:${JSON.stringify(hit)}` : null;
+    if (key === this.builderHoverKey) return false;
+    this.builderHoverKey = key;
+    this.builderPreview = hit && m ? this.builderPreviewOf(m, "face" in hit ? { faces: [hit.face], lines: [] } : { faces: [], lines: [hit.line] }, alt, null) : null;
+    return true;
+  }
+  builderPreviewOf(m, touched, erase, trail) {
+    const faces = m.map.faces;
+    return {
+      mode: erase ? "erase" : "merge",
+      faces: touched.faces.map((f) => faces[f].path),
+      lines: touched.lines.map((k) => m.pieces[k].path),
+      trail
+    };
+  }
+  downBuilder(p, input) {
+    this.builderHoverKey = null;
+    if (this.tool === "paintBucket") {
+      this.fillRegion(p);
+      this.builderPreview = null;
+      this.hoverBuilder(p, false);
+      this.notify();
+      return;
+    }
+    const m = this.selectedRoots().length ? this.shapeBuilderMap() : null;
+    if (!m) return;
+    const erase = !!input.alt;
+    const touched = { faces: [], lines: [] };
+    addBuilderHit(touched, vectorShapeBuilderHit(m, p, erase ? this.builderLineTolerance() : null));
+    this.drag = { kind: "builder", erase, points: [p], touched, map: m };
+    this.interaction = { type: "builder", mode: erase ? "erase" : "merge", points: [p] };
+    this.builderPreview = this.builderPreviewOf(m, touched, erase, [p]);
+    this.notify();
+  }
+  moveBuilder(drag, p) {
+    const last = drag.points[drag.points.length - 1];
+    if (Math.hypot(p.x - last.x, p.y - last.y) * this.viewport.zoom < 1) return;
+    const tol = drag.erase ? this.builderLineTolerance() : null;
+    for (const q of samplePolyline([last, p], 2 / this.viewport.zoom)) addBuilderHit(drag.touched, vectorShapeBuilderHit(drag.map, q, tol));
+    drag.points.push(p);
+    this.interaction = { type: "builder", mode: drag.erase ? "erase" : "merge", points: drag.points.slice() };
+    this.builderPreview = this.builderPreviewOf(drag.map, drag.touched, drag.erase, drag.points.slice());
+    this.notify();
+  }
+  upBuilder(drag) {
+    this.builderPreview = null;
+    this.builderHoverKey = null;
+    if (!drag.touched.faces.length && !drag.touched.lines.length) {
+      this.notify();
+      return;
+    }
+    this.applyShapeBuilder(drag.map, drag.touched, drag.erase);
+  }
+  // -------------------------------------------------------------------------
   // Anchor editing
   // -------------------------------------------------------------------------
   updateAnchors(doc, refs, fn) {
@@ -4454,7 +5635,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', _97 => _97.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _159 => _159.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);
@@ -4463,7 +5644,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', _98 => _98.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _160 => _160.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) };
@@ -4474,7 +5655,7 @@ var VectorEditorController = (_class3 = class {
    */
   bendSegment(ref, to, t = 0.5) {
     const node = this.getNode(ref.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _99 => _99.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _161 => _161.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", () => {
@@ -4509,7 +5690,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', _100 => _100.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _162 => _162.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);
@@ -4553,7 +5734,7 @@ var VectorEditorController = (_class3 = class {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n = this.getNode(nodeId);
-      return _optionalChain([n, 'optionalAccess', _101 => _101.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n, 'optionalAccess', _163 => _163.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", () => {
@@ -4571,7 +5752,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', _164 => _164.strokeWidthProfile, 'optionalAccess', _165 => _165.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
+        )
+      );
       this.anchors = [];
     });
     return { ok: true };
@@ -4652,9 +5838,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);
       }
     });
@@ -4707,7 +5893,7 @@ var VectorEditorController = (_class3 = class {
    */
   cutPathAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _102 => _102.type]) !== "path" || node.locked) return null;
+    if (_optionalChain([node, 'optionalAccess', _166 => _166.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
     const hit = nearestSegment(node, local);
     if (!hit) return null;
@@ -4738,8 +5924,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);
@@ -4757,7 +5943,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', _103 => _103.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
+    if (_optionalChain([ids, 'optionalAccess', _167 => _167.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 = [];
@@ -4813,10 +5999,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 = _chunk7EDLVBOOcjs.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 = _chunk7EDLVBOOcjs.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)) {
@@ -4843,7 +6029,7 @@ var VectorEditorController = (_class3 = class {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _104 => _104.subpaths, 'access', _105 => _105[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _168 => _168.subpaths, 'access', _169 => _169[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -4887,19 +6073,19 @@ var VectorEditorController = (_class3 = class {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _106 => _106.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
-        } catch (e2) {
+          if (_optionalChain([data, 'optionalAccess', _170 => _170.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', _107 => _107.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _171 => _171.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", () => {
@@ -4943,14 +6129,14 @@ var VectorEditorController = (_class3 = class {
     if (!frame) return null;
     const { box, handles } = getVectorSelectionBoxGeometry(frame, this.viewport);
     const r = this.hitRadius + 2;
-    const usable = box.width < 2 * r || box.height < 2 * r ? handles.filter((h) => h.handle.length === 2 || h.handle === "rotate") : handles;
-    for (const h of usable) if (Math.hypot(h.screen.x - screen.x, h.screen.y - screen.y) <= r * Math.SQRT2) return h.handle;
+    const usable2 = box.width < 2 * r || box.height < 2 * r ? handles.filter((h) => h.handle.length === 2 || h.handle === "rotate") : handles;
+    for (const h of usable2) if (Math.hypot(h.screen.x - screen.x, h.screen.y - screen.y) <= r * Math.SQRT2) return h.handle;
     return null;
   }
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
       const a = getAnchorWorld(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _108 => _108[ref.handle]]);
+      const h = _optionalChain([a, 'optionalAccess', _172 => _172[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;
@@ -5053,10 +6239,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', _173 => _173.ref, 'access', _174 => _174.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _175 => _175.nodeId])));
+    const node = nodeId ? this.getNode(nodeId) : void 0;
+    const g = _optionalChain([node, 'optionalAccess', _176 => _176.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', _177 => _177[ref.index], 'optionalAccess', _178 => _178.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;
@@ -5104,7 +6411,12 @@ 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 "shapeBuilder":
+      case "paintBucket":
+        return this.downBuilder(p, input);
       case "scissors": {
         const seg = this.nearestOutline(p);
         if (seg) this.cutPathAt(seg.nodeId, seg.point);
@@ -5240,7 +6552,7 @@ var VectorEditorController = (_class3 = class {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _109 => _109.getNode, 'call', _110 => _110(this.pen.nodeId), 'optionalAccess', _111 => _111.subpaths, 'access', _112 => _112[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _179 => _179.getNode, 'call', _180 => _180(this.pen.nodeId), 'optionalAccess', _181 => _181.subpaths, 'access', _182 => _182[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -5297,7 +6609,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(),
@@ -5311,7 +6623,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);
   }
@@ -5330,6 +6646,11 @@ var VectorEditorController = (_class3 = class {
   pointerMove(screen, input = {}) {
     const p = this.screenToDocument(screen);
     const drag = this.drag;
+    if (!drag && (this.tool === "shapeBuilder" || this.tool === "paintBucket")) {
+      this.pointer = p;
+      if (this.hoverBuilder(p, !!input.alt)) this.notify();
+      return;
+    }
     if (!drag) {
       const hover = this.computeHover(screen);
       const pointerMatters = this.tool === "pen" && !!this.pen;
@@ -5461,6 +6782,8 @@ var VectorEditorController = (_class3 = class {
         this.notify(true);
         return;
       }
+      case "builder":
+        return this.moveBuilder(drag, p);
       case "stroke": {
         const last = drag.points[drag.points.length - 1];
         if (Math.hypot(p.x - last.x, p.y - last.y) * this.viewport.zoom < 1.5) return;
@@ -5491,7 +6814,7 @@ var VectorEditorController = (_class3 = class {
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _113 => _113.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _183 => _183.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);
@@ -5520,19 +6843,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', _184 => _184.pressures, 'optionalAccess', _185 => _185.push, 'call', _186 => _186(drag.pressure)]);
           moved = true;
         }
         const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _114 => _114.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _187 => _187.type]) !== "path") return;
         if (!moved) {
-          if (string && _optionalChain([this, 'access', _115 => _115.interaction, 'optionalAccess', _116 => _116.type]) === "draw") {
+          if (string && _optionalChain([this, 'access', _188 => _188.interaction, 'optionalAccess', _189 => _189.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();
           }
@@ -5568,8 +6915,8 @@ var VectorEditorController = (_class3 = class {
     }
     this.setGuides(res);
     return {
-      dx: _optionalChain([res, 'optionalAccess', _117 => _117.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
-      dy: _optionalChain([res, 'optionalAccess', _118 => _118.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+      dx: _optionalChain([res, 'optionalAccess', _190 => _190.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: _optionalChain([res, 'optionalAccess', _191 => _191.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
     };
   }
   /** The anchor a point drag snaps by, where it started: the grabbed one, else the moving one nearest the press. */
@@ -5606,7 +6953,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** 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;
@@ -5648,7 +6995,7 @@ var VectorEditorController = (_class3 = class {
         if (drag.moved) return this.commit("Corner Radius", drag.before);
         if (drag.alt) {
           const kind = nextVectorCornerKind(drag.widget.kind);
-          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _119 => _119.corner, 'optionalAccess', _120 => _120.radius]), () => ( 0)), kind));
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _192 => _192.corner, 'optionalAccess', _193 => _193.radius]), () => ( 0)), kind));
           return this.commit("Corner Kind", drag.before);
         }
         const ref = drag.widget.ref;
@@ -5658,6 +7005,17 @@ var VectorEditorController = (_class3 = class {
         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 "builder":
+        return this.upBuilder(drag);
       case "stroke": {
         this.notify();
         if (drag.tool === "knife") this.knife(drag.points);
@@ -5683,19 +7041,22 @@ var VectorEditorController = (_class3 = class {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _121 => _121.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _194 => _194.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', _195 => _195.pressures, 'optionalAccess', _196 => _196.push, 'call', _197 => _197(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 = _chunk7EDLVBOOcjs.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] });
@@ -5703,7 +7064,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);
       }
@@ -5725,7 +7087,8 @@ var VectorEditorController = (_class3 = class {
     this.drag = null;
     this.interaction = null;
     this.guides = null;
-    if (drag.kind === "pan") {
+    if (drag.kind === "pan" || drag.kind === "builder") {
+      if (drag.kind === "builder") this.builderPreview = null;
       this.notify();
       return;
     }
@@ -5757,7 +7120,7 @@ var VectorEditorController = (_class3 = class {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _122 => _122.hover, 'optionalAccess', _123 => _123.segment, 'optionalAccess', _124 => _124.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _198 => _198.hover, 'optionalAccess', _199 => _199.segment, 'optionalAccess', _200 => _200.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
         const seg = node ? nearestSegment(node, this.toLocal(id, p)) : null;
@@ -5825,7 +7188,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();
@@ -5837,7 +7203,7 @@ var VectorEditorController = (_class3 = class {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _125 => _125.getNode, 'call', _126 => _126(this.selection[0]), 'optionalAccess', _127 => _127.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _201 => _201.getNode, 'call', _202 => _202(this.selection[0]), 'optionalAccess', _203 => _203.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -5846,6 +7212,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];
@@ -5927,6 +7294,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;
@@ -5953,7 +7345,7 @@ function renderNode(node, defs, idPrefix) {
     strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)),
     ...node.strokeLinecap ? { strokeLinecap: node.strokeLinecap } : {},
     ...node.strokeLinejoin ? { strokeLinejoin: node.strokeLinejoin } : {},
-    ..._optionalChain([node, 'access', _128 => _128.strokeDasharray, 'optionalAccess', _129 => _129.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
+    ..._optionalChain([node, 'access', _204 => _204.strokeDasharray, 'optionalAccess', _205 => _205.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1))
   };
@@ -5977,7 +7369,7 @@ function screenOutline(state, node) {
   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 }) => _chunk7EDLVBOOcjs.bezierPathToSvg.call(void 0, _chunk7EDLVBOOcjs.transformBezierPath.call(void 0, vectorPathWorldBezier(path, m), view), { precision: 2 })).join(" ");
 }
 function collectWithMatrix(node, parent) {
   if (node.type === "path") return [{ path: node, parent }];
@@ -6002,9 +7394,9 @@ function getVectorOverlayRenderData(state) {
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _130 => _130.hover, 'optionalAccess', _131 => _131.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _206 => _206.hover, 'optionalAccess', _207 => _207.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _132 => _132.interaction, 'optionalAccess', _133 => _133.type]) !== "marquee") {
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _208 => _208.interaction, 'optionalAccess', _209 => _209.type]) !== "marquee") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
     selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
   }
@@ -6014,9 +7406,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', _134 => _134.hover, 'optionalAccess', _135 => _135.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', _210 => _210.hover, 'optionalAccess', _211 => _211.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _136 => _136.hover, 'optionalAccess', _137 => _137.anchor])) {
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _212 => _212.hover, 'optionalAccess', _213 => _213.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
@@ -6025,15 +7417,15 @@ function getVectorOverlayRenderData(state) {
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
     const a = getAnchorWorld(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _138 => _138[ref.handle]]);
+    const h = _optionalChain([a, 'optionalAccess', _214 => _214[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _139 => _139.hover, 'optionalAccess', _140 => _140.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _215 => _215.hover, 'optionalAccess', _216 => _216.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', _141 => _141.interaction, 'optionalAccess', _142 => _142.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _217 => _217.interaction, 'optionalAccess', _218 => _218.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 };
@@ -6041,7 +7433,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', _143 => _143.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _219 => _219.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);
@@ -6054,9 +7446,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', _144 => _144.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _145 => _145.type]) === "move" || _optionalChain([it, 'optionalAccess', _146 => _146.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _147 => _147.type]) === "scale" || _optionalChain([it, 'optionalAccess', _148 => _148.type]) === "draw") {
+  if (_optionalChain([it, 'optionalAccess', _220 => _220.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _221 => _221.type]) === "move" || _optionalChain([it, 'optionalAccess', _222 => _222.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _223 => _223.type]) === "scale" || _optionalChain([it, 'optionalAccess', _224 => _224.type]) === "draw") {
     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)}`;
   }
@@ -6073,25 +7465,51 @@ function getVectorOverlayRenderData(state) {
     }
   }
   let toolStroke = null;
-  if (_optionalChain([it, 'optionalAccess', _149 => _149.type]) === "stroke") {
+  if (_optionalChain([it, 'optionalAccess', _225 => _225.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', _150 => _150.type]) === "draw" && it.string) {
+  if (_optionalChain([it, 'optionalAccess', _226 => _226.type]) === "draw" && it.string) {
     const a = toScreen(state, it.string[0]);
     const b = toScreen(state, it.string[1]);
     pencilString = { x1: fmt(a.x), y1: fmt(a.y), x2: fmt(b.x), y2: fmt(b.y) };
   }
-  const dragged = _optionalChain([it, 'optionalAccess', _151 => _151.type]) === "corner" ? it.ref : null;
+  const dragged = _optionalChain([it, 'optionalAccess', _227 => _227.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', _152 => _152.hover, 'optionalAccess', _153 => _153.corner]), w.ref), active: !!dragged };
+    return { ref: w.ref, x: fmt(s.x), y: fmt(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _228 => _228.hover, 'optionalAccess', _229 => _229.corner]), w.ref), active: !!dragged };
+  });
+  if (_optionalChain([it, 'optionalAccess', _230 => _230.type]) === "corner") status = `R ${fmt(it.radius)}`;
+  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _231 => _231.hover, 'optionalAccess', _232 => _232.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  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', _233 => _233.hover, 'optionalAccess', _234 => _234.widthPoint]);
+    const hovered = hw && sameWidth(hw, h.ref) && hw.subpath === h.ref.subpath ? hw.part : null;
+    return { ref: h.ref, x: c.x, y: c.y, left: sc(h.left), right: sc(h.right), selected: h.selected, hovered, active: _optionalChain([it, 'optionalAccess', _235 => _235.type]) === "width" && sameWidth(it.ref, h.ref) };
   });
-  if (_optionalChain([it, 'optionalAccess', _154 => _154.type]) === "corner") status = `R ${fmt(it.radius)}`;
-  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _155 => _155.hover, 'optionalAccess', _156 => _156.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, cornerWidgets };
+  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _236 => _236.hover, 'optionalAccess', _237 => _237.strokeSpot]) : null;
+  const widthSpot = spot ? { ...sc(spot.point), left: sc(spot.left), right: sc(spot.right) } : null;
+  if (_optionalChain([it, 'optionalAccess', _238 => _238.type]) === "width") status = it.mode === "move" ? "Move width point" : `W ${fmt(it.width)}`;
+  let builder = null;
+  if (state.builder) {
+    const v2 = state.viewport;
+    const view = [v2.zoom, 0, 0, v2.zoom, v2.x, v2.y];
+    const d = (path) => _chunk7EDLVBOOcjs.bezierPathToSvg.call(void 0, _chunk7EDLVBOOcjs.transformBezierPath.call(void 0, path, view), { precision: 2 });
+    const trail = state.builder.trail && state.builder.trail.length > 1 ? state.builder.trail.map((q, i) => `${i ? "L" : "M"}${sc(q).x} ${sc(q).y}`).join("") : null;
+    builder = { mode: state.builder.mode, faces: state.builder.faces.map(d), lines: state.builder.lines.map(d), trail };
+    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _239 => _239.type]) === "builder") {
+      const n = state.builder.faces.length;
+      status = state.builder.mode === "erase" ? `Delete ${n} ${n === 1 ? "face" : "faces"}` : `Merge ${n} ${n === 1 ? "face" : "faces"}`;
+    }
+  }
+  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder };
 }
 var VECTOR_OVERLAY_THEME = {
   accent: "#0ea5e9",
@@ -6105,13 +7523,28 @@ var VECTOR_OVERLAY_THEME = {
   anchorSize: 7,
   handleRadius: 3.5,
   /** Radius of a live corner widget (a ring with a dot). */
-  cornerWidgetRadius: 4
+  cornerWidgetRadius: 4,
+  /** Half the diagonal of a width point's diamond. */
+  widthPointSize: 5,
+  /** Shape Builder faces to merge and paint bucket regions. */
+  builderFill: "rgba(14, 165, 233, 0.22)",
+  /** Shape Builder faces and line pieces an Alt gesture deletes. */
+  builderErase: "#ef4444",
+  builderEraseFill: "rgba(239, 68, 68, 0.22)"
 };
+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) };
@@ -6121,7 +7554,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', _157 => _157.getAttribute, 'optionalCall', _158 => _158("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _240 => _240.getAttribute, 'optionalCall', _241 => _241("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -6129,12 +7562,12 @@ function getVectorSelectionStyle(state) {
     const node = findVectorNode(state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
-  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _159 => _159.selectedAnchors, 'optionalAccess', _160 => _160.length]);
+  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _242 => _242.selectedAnchors, 'optionalAccess', _243 => _243.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', _161 => _161.type]) === "path") paths.push(node);
+      if (_optionalChain([node, 'optionalAccess', _244 => _244.type]) === "path") paths.push(node);
     }
   }
   if (!paths.length) return null;
@@ -6145,7 +7578,7 @@ function getVectorSelectionStyle(state) {
     for (const c of vectorCorners(p.subpaths)) {
       if (anchorMode && !state.selectedAnchors.some((r) => r.nodeId === p.id && r.subpath === c.subpath && r.index === c.index)) continue;
       const corner = p.subpaths[c.subpath].anchors[c.index].corner;
-      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _162 => _162.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _163 => _163.kind]), () => ( "round")) });
+      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _245 => _245.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _246 => _246.kind]), () => ( "round")) });
     }
   }
   const c0 = _nullishCoalesce(corners2[0], () => ( { radius: 0, kind: "round" }));
@@ -6160,6 +7593,8 @@ function getVectorSelectionStyle(state) {
     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,
@@ -6175,12 +7610,17 @@ function getVectorSelectionStyle(state) {
       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 = {
@@ -6206,6 +7646,14 @@ var VECTOR_PATH_ACTIONS = [
   { 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_PATHFINDER_ACTIONS = [
+  { id: "divide", label: "\u229E", title: "Divide", min: 1 },
+  { id: "trim", label: "\u29C9", title: "Trim", min: 2 },
+  { id: "merge", label: "\u29C8", title: "Merge", min: 2 },
+  { id: "crop", label: "\u2317", title: "Crop", min: 2 },
+  { id: "outline", label: "\u2B1A", title: "Outline", min: 1 },
+  { id: "minusBack", label: "\u2296", title: "Minus Back", min: 2 }
+];
 var VECTOR_EDIT_TOGGLES = [
   { key: "keepShapeOnDelete", label: "Keep", title: "Keep shape when deleting points" },
   { key: "curvatureMoves", label: "Curv", title: "Curvature point moves (Alt flips while dragging)" },
@@ -6232,6 +7680,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 }] }`.'
 };
@@ -6248,7 +7709,8 @@ var STYLE_PROPS = {
   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)." }
+  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 = {};
@@ -6264,17 +7726,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', _164 => _164.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _247 => _247.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', _165 => _165.ids, 'optionalAccess', _166 => _166.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _248 => _248.ids, 'optionalAccess', _249 => _249.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', _167 => _167.type]) !== "path" || !_optionalChain([node, 'access', _168 => _168.subpaths, 'access', _169 => _169[r.subpath], 'optionalAccess', _170 => _170.anchors, 'access', _171 => _171[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+      if (_optionalChain([node, 'optionalAccess', _250 => _250.type]) !== "path" || !_optionalChain([node, 'access', _251 => _251.subpaths, 'access', _252 => _252[r.subpath], 'optionalAccess', _253 => _253.anchors, 'access', _254 => _254[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
     }
     return refs;
   };
@@ -6365,7 +7827,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', _172 => _172.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _255 => _255.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -6397,14 +7859,52 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { radius: { type: "number", minimum: 0 }, kind: { type: "string", enum: VECTOR_CORNER_KINDS }, ids: IDS, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        const refs = _optionalChain([params, 'optionalAccess', _173 => _173.anchors]) ? anchorsOf(params.anchors) : void 0;
-        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _174 => _174.ids]) ? ids(params) : void 0 };
-        if (_optionalChain([params, 'optionalAccess', _175 => _175.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
-        else if (_optionalChain([params, 'optionalAccess', _176 => _176.kind])) check(controller.setCornerKind(params.kind, target));
+        const refs = _optionalChain([params, 'optionalAccess', _256 => _256.anchors]) ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _257 => _257.ids]) ? ids(params) : void 0 };
+        if (_optionalChain([params, 'optionalAccess', _258 => _258.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
+        else if (_optionalChain([params, 'optionalAccess', _259 => _259.kind])) check(controller.setCornerKind(params.kind, target));
         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', _260 => _260.preset])) check(controller.setWidthProfile(params.preset, target));
+        else if (_optionalChain([params, 'optionalAccess', _261 => _261.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
+        else if (_optionalChain([params, 'optionalAccess', _262 => _262.taper]) || _optionalChain([params, 'optionalAccess', _263 => _263.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
+        else fail("Pass `preset`, `points`, `taper` or `wave`.");
+        const node = controller.getNode(target.ids[0]);
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _264 => _264.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+      }
+    },
     {
       ...base,
       id: `${prefix}outlineStroke`,
@@ -6415,7 +7915,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _177 => _177.ids]) ? ids(params) : void 0 });
+        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _265 => _265.ids]) ? ids(params) : void 0 });
         if (!created.length) fail("No selected path has a stroke.");
         return { ids: created };
       }
@@ -6477,6 +7977,62 @@ function createVectorCommands(controller, options = {}) {
         return { id };
       }
     },
+    {
+      ...base,
+      id: `${prefix}pathfinder`,
+      label: "Pathfinder\u2026",
+      keywords: ["divide", "trim", "merge", "crop", "outline", "minus back", "split", "faces"],
+      description: "Pathfinder over the given paths (bottom to top): divide (every face its own shape, painted like the top-most shape over it; open unfilled paths cut), trim (hidden parts removed), merge (trim, then touching parts of one fill joined), crop (the top shape crops the others), outline (outlines cut into open strokes where they meet) or minusBack (the top shape minus everything below). Results replace the paths, grouped when there are several.",
+      params: { type: "object", properties: { operation: { type: "string", enum: [...VECTOR_PATHFINDER_OPERATIONS] }, ids: IDS }, required: ["operation"] },
+      undoable: true,
+      run: (_ctx, params) => {
+        if (!VECTOR_PATHFINDER_OPERATIONS.includes(params.operation)) fail(`Unknown Pathfinder operation "${params.operation}".`);
+        const created = controller.pathfinder(params.operation, { ids: ids(params) });
+        if (!created.length) fail("Nothing came out: select paths that overlap (two or more, except for divide and outline).");
+        return { ids: created, selection: [...controller.getState().selection] };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}shapeBuilderFaces`,
+      label: "List Shape Builder Faces",
+      keywords: ["shape builder", "regions", "faces", "planar"],
+      description: "Lists the faces the given paths divide the plane into: path data, area, a point inside and the ids of the paths filling each (empty when only outlines enclose it).",
+      params: { type: "object", properties: { ids: IDS } },
+      run: (_ctx, params) => ({ faces: controller.getShapeBuilderFaces({ ids: ids(params) }) })
+    },
+    {
+      ...base,
+      id: `${prefix}shapeBuilder`,
+      label: "Shape Builder",
+      keywords: ["merge faces", "build shape", "combine regions", "delete region"],
+      description: "Shape Builder gesture over the faces of the given paths: `points` is the pointer path in document units (one point is a click; [[x, y], \u2026]; use the points from shapeBuilderFaces). Merges the faces it touches into one shape, or with `erase: true` deletes them and the pieces of unfilled open paths within `tolerance`. Shapes covering those faces lose that area.",
+      params: {
+        type: "object",
+        properties: { points: POINTS, erase: { type: "boolean" }, tolerance: { type: "number", minimum: 0 }, ids: IDS },
+        required: ["points"]
+      },
+      undoable: true,
+      run: (_ctx, params) => {
+        const result = controller.shapeBuilder(params.points.map(([x, y]) => ({ x, y })), { ids: ids(params), erase: params.erase, tolerance: params.tolerance });
+        check(result);
+        return { merged: result.merged, faces: result.faces, lines: result.lines };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}fillRegion`,
+      label: "Fill Region",
+      keywords: ["paint bucket", "live paint", "fill area", "enclosed"],
+      description: "Paint bucket: fills the area the visible outlines enclose around `point` (crossings split, nested shapes left as holes) with a new path in the current fill, below the selection or on top. `gap` closes gaps up to that size between loose ends.",
+      params: { type: "object", properties: { point: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2, description: "[x, y] in document units." }, gap: { type: "number", minimum: 0 } }, required: ["point"] },
+      undoable: true,
+      run: (_ctx, params) => {
+        const id = controller.fillRegion({ x: params.point[0], y: params.point[1] }, { gap: params.gap });
+        if (!id) fail("No closed region surrounds that point.");
+        return { id };
+      }
+    },
     {
       ...base,
       id: `${prefix}align`,
@@ -6530,7 +8086,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _178 => _178.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _266 => _266.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -6558,7 +8114,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', _179 => _179.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _180 => _180.keepShape]) }));
+        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _267 => _267.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _268 => _268.keepShape]) }));
         return { ok: true };
       }
     },
@@ -6613,7 +8169,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', _181 => _181.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _182 => _182.tolerance]) }));
+        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _269 => _269.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _270 => _270.tolerance]) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -6627,7 +8183,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', _183 => _183.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _184 => _184.anchors]))));
+        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _271 => _271.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _272 => _272.anchors]))));
         return { ok: true };
       }
     },
@@ -6641,7 +8197,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _185 => _185.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _186 => _186.tolerance]) }));
+        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _273 => _273.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _274 => _274.tolerance]) }));
         return { ok: true };
       }
     },
@@ -6654,7 +8210,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', _187 => _187.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _188 => _188.amount]), refs: _optionalChain([params, 'optionalAccess', _189 => _189.anchors]) }));
+        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _275 => _275.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _276 => _276.amount]), refs: _optionalChain([params, 'optionalAccess', _277 => _277.anchors]) }));
         return { ok: true };
       }
     },
@@ -6667,14 +8223,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', _190 => _190.nodeId]) !== void 0) {
+        if (_optionalChain([params, 'optionalAccess', _278 => _278.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', _191 => _191.anchors]))));
+        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _279 => _279.anchors]))));
         return { ids: controller.getState().selection };
       }
     },
@@ -6711,7 +8267,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: {
@@ -6719,12 +8275,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', _192 => _192[key]]) !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _280 => _280[key]]) !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -6749,7 +8306,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', _193 => _193.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _281 => _281.precision]) }) })
     },
     {
       ...base,
@@ -6915,5 +8472,51 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_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_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.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.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.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.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.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; 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.nextVectorCornerKind = nextVectorCornerKind; 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.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; 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.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; 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.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; 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_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATHFINDER_ACTIONS = VECTOR_PATHFINDER_ACTIONS; exports.VECTOR_PATHFINDER_LABELS = VECTOR_PATHFINDER_LABELS; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.createVectorCommands = createVectorCommands; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertWidthPoint = insertWidthPoint; exports.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mirrorWidthProfile = mirrorWidthProfile; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeWidthPoints = removeWidthPoints; exports.reverseSubpath = reverseSubpath; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.samplePolyline = samplePolyline; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.starSubpath = starSubpath; exports.strokePositionPoint = strokePositionPoint; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorFillMap = vectorFillMap; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute;
 //# sourceMappingURL=index.cjs.map