@pixerate/editor 0.41.0 → 0.42.0

package/dist/vector/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5;
 
 var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 
@@ -36,6 +36,7 @@ var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 
 
 
+
 
 
 var _chunkVNYRI265cjs = require('../chunk-VNYRI265.cjs');
@@ -73,6 +74,8 @@ var VECTOR_TOOLS = [
 ];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
+var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater"];
+var VECTOR_MERGE_MODES = ["merge", "add", "subtract", "intersect", "exclude"];
 
 // src/vector/corners.ts
 var EPS = 1e-9;
@@ -735,7 +738,7 @@ function variableStrokeOutline(path, options) {
   let polygons;
   try {
     polygons = _chunkVNYRI265cjs.polygonBoolean.call(void 0, "union", [{ rings: pieces, fillRule: "nonzero" }]);
-  } catch (e2) {
+  } catch (e3) {
     return [];
   }
   const out = [];
@@ -1042,8 +1045,872 @@ function vectorStrokeReach(style) {
   return reach;
 }
 
-// src/vector/geometry.ts
+// src/vector/pathEffects.ts
 var EPS2 = 1e-9;
+var degenerate = (s) => s.every((p) => Math.abs(p[0] - s[0][0]) < EPS2 && Math.abs(p[1] - s[0][1]) < EPS2);
+function raise(seg) {
+  if (seg.length !== 3) return seg.map((p) => [p[0], p[1]]);
+  const [p0, p1, p2] = seg;
+  return [p0, [p0[0] + 2 / 3 * (p1[0] - p0[0]), p0[1] + 2 / 3 * (p1[1] - p0[1])], [p2[0] + 2 / 3 * (p1[0] - p2[0]), p2[1] + 2 / 3 * (p1[1] - p2[1])], p2];
+}
+function subsOf(path) {
+  return _chunkVNYRI265cjs.pathToContours.call(void 0, path).map((c) => ({ segs: _chunkVNYRI265cjs.closeContour.call(void 0, c).filter((s) => !degenerate(s)).map(raise), closed: c.closed })).filter((s) => s.segs.length > 0);
+}
+var subsToPath = (subs) => _chunkVNYRI265cjs.contoursToPath.call(void 0, subs.map((s) => ({ segments: s.segs, closed: s.closed })));
+var unit2 = (x, y) => {
+  const l = Math.hypot(x, y);
+  return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
+};
+function startTangent(s) {
+  for (let i = 1; i < s.length; i++) {
+    const u = unit2(s[i][0] - s[0][0], s[i][1] - s[0][1]);
+    if (u) return u;
+  }
+  return [1, 0];
+}
+function endTangent(s) {
+  const end = s[s.length - 1];
+  for (let i = s.length - 2; i >= 0; i--) {
+    const u = unit2(end[0] - s[i][0], end[1] - s[i][1]);
+    if (u) return u;
+  }
+  return [1, 0];
+}
+function tangentAt(s, t) {
+  if (t <= 1e-9) return startTangent(s);
+  if (t >= 1 - 1e-9) return endTangent(s);
+  const d = _chunkVNYRI265cjs.segmentDerivative.call(void 0, s, t);
+  return _nullishCoalesce(unit2(d[0], d[1]), () => ( startTangent(s)));
+}
+var perp = (v2) => [-v2[1], v2[0]];
+function effectPathLength(path) {
+  let total = 0;
+  for (const s of subsOf(path)) for (const seg of s.segs) total += _chunkVNYRI265cjs.segmentLength.call(void 0, seg);
+  return total;
+}
+function effectPathVertexCount(path) {
+  return subsOf(path).reduce((n, s) => n + s.segs.length + (s.closed ? 0 : 1), 0);
+}
+var Measured = class {
+  
+  
+  
+  constructor(path) {
+    this.segs = subsOf(path).flatMap((s) => s.segs);
+    this.lens = this.segs.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
+    this.total = this.lens.reduce((a, b) => a + b, 0);
+  }
+  /**
+   * Appends the part between lengths `sa` and `sb`, continuing the last piece when this one
+   * starts where it ends (across the start of a closed path).
+   */
+  append(sa, sb, out) {
+    for (const piece of _chunkVNYRI265cjs.trimSegments.call(void 0, this.segs, sa, sb, this.lens)) {
+      if (degenerate(piece)) continue;
+      const last = _optionalChain([out, 'access', _28 => _28[out.length - 1], 'optionalAccess', _29 => _29.segs]);
+      const end = _optionalChain([last, 'optionalAccess', _30 => _30[last.length - 1], 'optionalAccess', _31 => _31.at, 'call', _32 => _32(-1)]);
+      if (!end || Math.hypot(end[0] - piece[0][0], end[1] - piece[0][1]) > 1e-6) out.push({ segs: [piece], closed: false });
+      else last.push(piece);
+    }
+  }
+};
+function trimIntervals(start, end, offsetDegrees) {
+  let s = start / 100;
+  let e = end / 100;
+  if (!Number.isFinite(s) || !Number.isFinite(e)) return null;
+  if (s > e) [s, e] = [e, s];
+  s = Math.min(1, Math.max(0, s));
+  e = Math.min(1, Math.max(0, e));
+  if (e - s >= 1 - 1e-9) return null;
+  if (e - s <= 1e-9) return [];
+  const off = Number.isFinite(offsetDegrees) ? (offsetDegrees / 360 % 1 + 1) % 1 : 0;
+  s += off;
+  e += off;
+  if (e <= 1) return [[s, e]];
+  if (s >= 1) return [[s - 1, e - 1]];
+  return [
+    [s, 1],
+    [0, e - 1]
+  ];
+}
+function trimPaths(paths, start, end, offsetDegrees = 0) {
+  const iv = trimIntervals(start, end, offsetDegrees);
+  if (!iv) return paths.slice();
+  return paths.map((p) => {
+    const m = new Measured(p);
+    const out = [];
+    if (m.total > 0) for (const [a, b] of iv) m.append(a * m.total, b * m.total, out);
+    return subsToPath(out);
+  });
+}
+function trimPathsIndividually(paths, start, end, offsetDegrees = 0) {
+  const iv = trimIntervals(start, end, offsetDegrees);
+  if (!iv) return paths.slice();
+  const ms = paths.map((p) => new Measured(p));
+  const total = ms.reduce((n, m) => n + m.total, 0);
+  let base = 0;
+  return ms.map((m) => {
+    const out = [];
+    for (const [a, b] of iv) {
+      const la = Math.max(0, a * total - base);
+      const lb = Math.min(m.total, b * total - base);
+      if (lb > la) m.append(la, lb, out);
+    }
+    base += m.total;
+    return subsToPath(out);
+  });
+}
+function puckerBloatPaths(paths, amount) {
+  const a = amount / 100;
+  if (!a || !Number.isFinite(a)) return paths.slice();
+  return paths.map((p) => {
+    const verts = p.filter((c) => c.type !== "Z");
+    if (!verts.length) return p;
+    const cx = verts.reduce((s, c) => s + c.x, 0) / verts.length;
+    const cy = verts.reduce((s, c) => s + c.y, 0) / verts.length;
+    const mv = (x, y) => ({ x: x + (cx - x) * a, y: y + (cy - y) * a });
+    const mvh = (x, y) => ({ x: x + (x - cx) * a, y: y + (y - cy) * a });
+    const out = [];
+    let prev = { x: 0, y: 0 };
+    let start = { x: 0, y: 0 };
+    const curve = (c1, c2, q) => {
+      const h1 = mvh(c1.x, c1.y);
+      const h2 = mvh(c2.x, c2.y);
+      const e = mv(q.x, q.y);
+      out.push({ type: "C", x1: h1.x, y1: h1.y, x2: h2.x, y2: h2.y, x: e.x, y: e.y });
+    };
+    for (const c of p) {
+      switch (c.type) {
+        case "M": {
+          const e = mv(c.x, c.y);
+          out.push({ type: "M", x: e.x, y: e.y });
+          prev = start = { x: c.x, y: c.y };
+          break;
+        }
+        case "L":
+          curve(prev, c, c);
+          prev = { x: c.x, y: c.y };
+          break;
+        case "Q": {
+          const c1 = { x: prev.x + 2 / 3 * (c.x1 - prev.x), y: prev.y + 2 / 3 * (c.y1 - prev.y) };
+          const c2 = { x: c.x + 2 / 3 * (c.x1 - c.x), y: c.y + 2 / 3 * (c.y1 - c.y) };
+          curve(c1, c2, c);
+          prev = { x: c.x, y: c.y };
+          break;
+        }
+        case "C":
+          curve({ x: c.x1, y: c.y1 }, { x: c.x2, y: c.y2 }, c);
+          prev = { x: c.x, y: c.y };
+          break;
+        case "Z":
+          if (Math.hypot(prev.x - start.x, prev.y - start.y) > EPS2) curve(prev, start, start);
+          out.push({ type: "Z" });
+          prev = start;
+          break;
+      }
+    }
+    return out;
+  });
+}
+function roundCornerPaths(paths, radius) {
+  if (!(radius > 0) || !Number.isFinite(radius)) return paths.slice();
+  return paths.map((p) => subpathsToBezier(bezierToSubpaths(p).map((sp) => setSubpathCorners(sp, radius))));
+}
+function offsetPaths(paths, amount, join = "miter", miterLimit = 4, copies = 1, copyOffset = 0) {
+  const n = Math.min(1e3, Math.max(1, Math.round(Number.isFinite(copies) ? copies : 1)));
+  return paths.map((p) => {
+    const out = [];
+    for (let i = 0; i < n; i++) out.push(..._chunkVNYRI265cjs.offsetPath.call(void 0, p, amount * (i + 1 + copyOffset), { join, miterLimit }));
+    return out;
+  });
+}
+function twistPaths(paths, angle, center) {
+  let rmax = 0;
+  for (const p of paths) for (const c of p) if (c.type !== "Z") rmax = Math.max(rmax, Math.hypot(c.x - center.x, c.y - center.y));
+  const a = angle * Math.PI / 180;
+  if (!a || rmax <= 1e-9 || !Number.isFinite(a)) return paths.slice();
+  const k = a / rmax;
+  const rot = (v2, th) => {
+    const s = Math.sin(th);
+    const co = Math.cos(th);
+    return [v2[0] * co - v2[1] * s, v2[0] * s + v2[1] * co];
+  };
+  const map = (p) => {
+    const v2 = [p[0] - center.x, p[1] - center.y];
+    const r = rot(v2, k * Math.hypot(v2[0], v2[1]));
+    return [center.x + r[0], center.y + r[1]];
+  };
+  const jac = (p, dv) => {
+    const v2 = [p[0] - center.x, p[1] - center.y];
+    const r = Math.hypot(v2[0], v2[1]);
+    let w = dv;
+    if (r > 1e-12) {
+      const f = k * (v2[0] * dv[0] + v2[1] * dv[1]) / r;
+      w = [dv[0] - v2[1] * f, dv[1] + v2[0] * f];
+    }
+    return rot(w, k * r);
+  };
+  return paths.map((p) => {
+    const out = [];
+    for (const sub3 of subsOf(p)) {
+      const segs = [];
+      for (const seg of sub3.segs) {
+        const cubic = seg.length === 2 ? [seg[0], seg[0], seg[1], seg[1]] : seg;
+        const len2 = _chunkVNYRI265cjs.segmentLength.call(void 0, seg);
+        const m = Math.min(64, Math.max(1, Math.ceil(Math.abs(a) * len2 / rmax / 0.15 + len2 / 50)));
+        for (let i = 0; i < m; i++) {
+          const q = _chunkVNYRI265cjs.subSegment.call(void 0, cubic, i / m, (i + 1) / m);
+          const p0 = map(q[0]);
+          const p3 = map(q[3]);
+          const h1 = jac(q[0], [q[1][0] - q[0][0], q[1][1] - q[0][1]]);
+          const h2 = jac(q[3], [q[2][0] - q[3][0], q[2][1] - q[3][1]]);
+          segs.push([p0, [p0[0] + h1[0], p0[1] + h1[1]], [p3[0] + h2[0], p3[1] + h2[1]], p3]);
+        }
+      }
+      out.push({ segs, closed: sub3.closed });
+    }
+    return subsToPath(out);
+  });
+}
+function resample(sub3, m) {
+  const segs = sub3.segs;
+  const n = segs.length;
+  const lens = segs.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
+  const out = [];
+  for (let j = 0; j < n; j++) {
+    const piece = lens[j] / m;
+    for (let k = 0; k < m; k++) {
+      if (k === 0) {
+        const tout = startTangent(segs[j]);
+        const prev = sub3.closed || j > 0 ? (j + n - 1) % n : null;
+        let tan = tout;
+        if (prev !== null) {
+          const tin = endTangent(segs[prev]);
+          tan = _nullishCoalesce(unit2(tin[0] + tout[0], tin[1] + tout[1]), () => ( tout));
+        }
+        out.push({ p: segs[j][0], tan, lenPrev: prev === null ? 0 : lens[prev] / m, lenNext: piece });
+      } else {
+        const t = _chunkVNYRI265cjs.segmentParamAtLength.call(void 0, segs[j], piece * k, lens[j]);
+        out.push({ p: _chunkVNYRI265cjs.segmentPoint.call(void 0, segs[j], t), tan: tangentAt(segs[j], t), lenPrev: piece, lenNext: piece });
+      }
+    }
+  }
+  if (!sub3.closed) {
+    const last = segs[n - 1];
+    out.push({ p: last[last.length - 1], tan: endTangent(last), lenPrev: lens[n - 1] / m, lenNext: 0 });
+  }
+  return out;
+}
+function emit(samples, disp, closed, smooth, handle) {
+  const n = samples.length;
+  if (!n) return null;
+  const pt2 = (i) => [samples[i].p[0] + disp[i][0], samples[i].p[1] + disp[i][1]];
+  const segs = [];
+  const count = closed ? n : n - 1;
+  for (let i = 0; i < count; i++) {
+    const j = (i + 1) % n;
+    const a = samples[i];
+    const b = samples[j];
+    const p = pt2(i);
+    const q = pt2(j);
+    if (smooth) segs.push([p, [p[0] + a.tan[0] * a.lenNext * handle, p[1] + a.tan[1] * a.lenNext * handle], [q[0] - b.tan[0] * b.lenPrev * handle, q[1] - b.tan[1] * b.lenPrev * handle], q]);
+    else segs.push([p, q]);
+  }
+  if (!segs.length) return null;
+  return { segs, closed };
+}
+function zigzagPaths(paths, size, ridges, smooth = false) {
+  const m = Math.min(1e3, Math.max(0, Math.round(Number.isFinite(ridges) ? ridges : 0))) + 1;
+  return paths.map((p) => {
+    const out = [];
+    for (const sub3 of subsOf(p)) {
+      const s = resample(sub3, m);
+      const disp = s.map((x, i) => {
+        const n = perp(x.tan);
+        const d = i % 2 === 0 ? size : -size;
+        return [n[0] * d, n[1] * d];
+      });
+      const e = emit(s, disp, sub3.closed, smooth, 0.36);
+      if (e) out.push(e);
+    }
+    return subsToPath(out);
+  });
+}
+var MASK64 = (1n << 64n) - 1n;
+function splitmix(x) {
+  x = x + 0x9e3779b97f4a7c15n & MASK64;
+  let z = x;
+  z = (z ^ z >> 30n) * 0xbf58476d1ce4e5b9n & MASK64;
+  z = (z ^ z >> 27n) * 0x94d049bb133111ebn & MASK64;
+  return z ^ z >> 31n;
+}
+function hash(seed, idx, t) {
+  const h = splitmix(splitmix(splitmix(seed) ^ idx) ^ BigInt.asUintN(64, BigInt(t)));
+  return Number(h >> 11n) / 2 ** 53 * 2 - 1;
+}
+function noise(seed, idx, t) {
+  const i = Math.floor(t);
+  const f = t - i;
+  const p0 = hash(seed, idx, i - 1);
+  const p1 = hash(seed, idx, i);
+  const p2 = hash(seed, idx, i + 1);
+  const p3 = hash(seed, idx, i + 2);
+  const v2 = 0.5 * (2 * p1 + (-p0 + p2) * f + (2 * p0 - 5 * p1 + 4 * p2 - p3) * f * f + (-p0 + 3 * p1 - 3 * p2 + p3) * f * f * f);
+  return Math.min(1, Math.max(-1, v2));
+}
+function wigglePaths(paths, w) {
+  if (!w.size || !Number.isFinite(w.size)) return paths.slice();
+  const m = Math.min(1e3, Math.max(0, Math.round(Number.isFinite(w.detail) ? w.detail : 0))) + 1;
+  const seed = BigInt.asUintN(64, BigInt(Math.round(Number.isFinite(w.seed) ? w.seed : 0)));
+  const t = (Number.isFinite(w.time) ? w.time : 0) * (Number.isFinite(w.speed) ? w.speed : 0) + (Number.isFinite(w.phase) ? w.phase : 0) / 360;
+  const corr = Math.min(1, Math.max(0, (Number.isFinite(w.correlation) ? w.correlation : 0) / 100));
+  const sx = noise(seed, MASK64, t);
+  const sy = noise(seed, MASK64 - 1n, t);
+  let idx = 0;
+  return paths.map((p) => {
+    const out = [];
+    for (const sub3 of subsOf(p)) {
+      const s = resample(sub3, m);
+      const disp = s.map(() => {
+        const i = BigInt(idx);
+        const ox = noise(seed, i * 2n, t + idx * 0.37);
+        const oy = noise(seed, i * 2n + 1n, t + idx * 0.61);
+        idx++;
+        return [(sx * corr + ox * (1 - corr)) * w.size, (sy * corr + oy * (1 - corr)) * w.size];
+      });
+      const e = emit(s, disp, sub3.closed, w.smooth, 1 / 3);
+      if (e) out.push(e);
+    }
+    return subsToPath(out);
+  });
+}
+var MERGE_OPS = { add: "union", subtract: "difference", intersect: "intersection", exclude: "xor" };
+function mergePaths(paths, mode = "merge") {
+  if (mode === "merge" || !(mode in MERGE_OPS)) return paths.flat();
+  const inputs = paths.filter((p) => p.length > 0).map((path) => ({ path, fillRule: "nonzero" }));
+  if (!inputs.length) return [];
+  return _chunkVNYRI265cjs.pathBoolean.call(void 0, MERGE_OPS[mode], inputs).path;
+}
+function vectorRepeaterCopies(r, pivot) {
+  const copies = Math.max(0, Number.isFinite(r.copies) ? Math.min(r.copies, 1e3) : 0);
+  const n = Math.ceil(copies);
+  const offset = Number.isFinite(r.offset) ? r.offset : 0;
+  const so = (_nullishCoalesce(r.startOpacity, () => ( 100))) / 100;
+  const eo = (_nullishCoalesce(r.endOpacity, () => ( 100))) / 100;
+  const fract = copies - Math.floor(copies);
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const k = i + offset;
+    let m = translateMatrix(-pivot.x, -pivot.y);
+    m = multiplyMatrices(m, scaleMatrix(Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _33 => _33.scale, 'optionalAccess', _34 => _34.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _35 => _35.scale, 'optionalAccess', _36 => _36.y]), () => ( 100))) / 100, k)));
+    m = multiplyMatrices(m, rotateMatrix((_nullishCoalesce(r.rotation, () => ( 0))) * k));
+    m = multiplyMatrices(m, translateMatrix(pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _37 => _37.position, 'optionalAccess', _38 => _38.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _39 => _39.position, 'optionalAccess', _40 => _40.y]), () => ( 0))) * k));
+    const t = n > 1 ? i / (n - 1) : 0;
+    const partial = i + 1 === n && fract > 0 ? fract : 1;
+    out.push({ index: i, matrix: m, opacity: Math.min(1, Math.max(0, (so + (eo - so) * t) * partial)) });
+  }
+  return out;
+}
+function repeatPaths(paths, r, pivot) {
+  return vectorRepeaterCopies(r, pivot).map((copy) => ({ copy, paths: paths.map((p) => _chunkVNYRI265cjs.transformBezierPath.call(void 0, p, copy.matrix)) }));
+}
+function pathsCenter(paths) {
+  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, paths.flat());
+  return b ? { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 } : { x: 0, y: 0 };
+}
+
+// src/vector/appearance.ts
+var VECTOR_EFFECT_DEFAULTS = {
+  trim: { start: 0, end: 50, offset: 0, mode: "simultaneous" },
+  roundCorners: { radius: 10 },
+  puckerBloat: { amount: 30 },
+  twist: { angle: 45, center: { x: 0, y: 0 } },
+  zigzag: { size: 5, ridges: 4, smooth: false },
+  wiggle: { size: 5, detail: 6, smooth: true, speed: 2, correlation: 50, phase: 0, seed: 1, time: 0 },
+  offset: { amount: 5, join: "miter", miterLimit: 4, copies: 1, copyOffset: 0 },
+  merge: { mode: "add" },
+  repeater: {
+    copies: 3,
+    offset: 0,
+    position: { x: 100, y: 0 },
+    anchor: { x: 0, y: 0 },
+    rotation: 0,
+    scale: { x: 100, y: 100 },
+    startOpacity: 100,
+    endOpacity: 100,
+    composite: "below"
+  }
+};
+var VECTOR_EFFECT_LABELS = {
+  trim: "Trim Paths",
+  roundCorners: "Round Corners",
+  puckerBloat: "Pucker & Bloat",
+  twist: "Twist",
+  zigzag: "Zig Zag",
+  wiggle: "Wiggle Paths",
+  offset: "Offset Paths",
+  merge: "Merge Paths",
+  repeater: "Repeater"
+};
+var VECTOR_EFFECT_PARAM_SPECS = {
+  trim: [
+    { key: "start", label: "Start %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "end", label: "End %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "offset", label: "Offset \xB0", kind: "number", min: -360, max: 360, step: 1, slider: true },
+    {
+      key: "mode",
+      label: "Paths",
+      kind: "select",
+      options: [
+        { value: "simultaneous", label: "Simultaneously" },
+        { value: "individual", label: "Individually" }
+      ]
+    }
+  ],
+  roundCorners: [{ key: "radius", label: "Radius", kind: "number", min: 0, max: 200, step: 1, slider: true }],
+  puckerBloat: [{ key: "amount", label: "Amount %", kind: "number", min: -100, max: 100, step: 1, slider: true }],
+  twist: [
+    { key: "angle", label: "Angle \xB0", kind: "number", min: -720, max: 720, step: 1, slider: true },
+    { key: "center", label: "Centre", kind: "vec2", step: 1 }
+  ],
+  zigzag: [
+    { key: "size", label: "Size", kind: "number", min: 0, max: 100, step: 0.5, slider: true },
+    { key: "ridges", label: "Ridges", kind: "number", min: 0, max: 50, step: 1, slider: true },
+    { key: "smooth", label: "Smooth", kind: "boolean" }
+  ],
+  wiggle: [
+    { key: "size", label: "Size", kind: "number", min: 0, max: 100, step: 0.5, slider: true },
+    { key: "detail", label: "Detail", kind: "number", min: 0, max: 50, step: 1, slider: true },
+    { key: "smooth", label: "Smooth", kind: "boolean" },
+    { key: "correlation", label: "Correlation %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "speed", label: "Speed", kind: "number", min: 0, step: 0.1 },
+    { key: "phase", label: "Phase \xB0", kind: "number", step: 1 },
+    { key: "time", label: "Time (s)", kind: "number", min: 0, max: 10, step: 0.05, slider: true },
+    { key: "seed", label: "Seed", kind: "number", step: 1 }
+  ],
+  offset: [
+    { key: "amount", label: "Amount", kind: "number", min: -100, max: 100, step: 0.5, slider: true },
+    {
+      key: "join",
+      label: "Join",
+      kind: "select",
+      options: [
+        { value: "miter", label: "Miter" },
+        { value: "round", label: "Round" },
+        { value: "bevel", label: "Bevel" }
+      ]
+    },
+    { key: "miterLimit", label: "Miter limit", kind: "number", min: 1, step: 0.5 },
+    { key: "copies", label: "Copies", kind: "number", min: 1, max: 20, step: 1 },
+    { key: "copyOffset", label: "Copy offset", kind: "number", step: 0.5 }
+  ],
+  merge: [
+    {
+      key: "mode",
+      label: "Mode",
+      kind: "select",
+      options: [
+        { value: "merge", label: "Merge" },
+        { value: "add", label: "Add" },
+        { value: "subtract", label: "Subtract" },
+        { value: "intersect", label: "Intersect" },
+        { value: "exclude", label: "Exclude" }
+      ]
+    }
+  ],
+  repeater: [
+    { key: "copies", label: "Copies", kind: "number", min: 0, max: 50, step: 0.1, slider: true },
+    { key: "offset", label: "Offset", kind: "number", min: -10, max: 10, step: 0.1, slider: true },
+    { key: "position", label: "Position", kind: "vec2", step: 1 },
+    { key: "anchor", label: "Anchor", kind: "vec2", step: 1 },
+    { key: "rotation", label: "Rotation \xB0", kind: "number", min: -360, max: 360, step: 1, slider: true },
+    { key: "scale", label: "Scale %", kind: "vec2", step: 1 },
+    { key: "startOpacity", label: "Start opacity %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "endOpacity", label: "End opacity %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    {
+      key: "composite",
+      label: "Copies",
+      kind: "select",
+      options: [
+        { value: "below", label: "Below" },
+        { value: "above", label: "Above" }
+      ]
+    }
+  ]
+};
+var isVec2 = (v2) => !!v2 && typeof v2 === "object" && Number.isFinite(v2.x) && Number.isFinite(v2.y);
+function normalizeVectorEffectParams(type, params, base) {
+  const defaults = VECTOR_EFFECT_DEFAULTS[type];
+  if (!defaults) return null;
+  const out = { ...defaults, ..._nullishCoalesce(base, () => ( {})) };
+  for (const spec of VECTOR_EFFECT_PARAM_SPECS[type]) {
+    const v2 = _optionalChain([params, 'optionalAccess', _41 => _41[spec.key]]);
+    if (v2 === void 0) continue;
+    if (spec.kind === "number" && typeof v2 === "number" && Number.isFinite(v2)) out[spec.key] = Math.min(_nullishCoalesce(spec.max, () => ( Infinity)), Math.max(_nullishCoalesce(spec.min, () => ( -Infinity)), v2));
+    else if (spec.kind === "boolean" && typeof v2 === "boolean") out[spec.key] = v2;
+    else if (spec.kind === "vec2" && isVec2(v2)) out[spec.key] = { x: v2.x, y: v2.y };
+    else if (spec.kind === "select" && spec.options.some((o) => o.value === v2)) out[spec.key] = v2;
+  }
+  return out;
+}
+function createVectorEffect(type, id, params) {
+  const p = normalizeVectorEffectParams(type, params);
+  return p ? { id, type, params: p } : null;
+}
+var isEnabled = (e) => e.enabled !== false && !!VECTOR_EFFECT_DEFAULTS[e.type];
+function activeVectorEffects(node) {
+  return _nullishCoalesce(_optionalChain([node, 'access', _42 => _42.effects, 'optionalAccess', _43 => _43.filter, 'call', _44 => _44(isEnabled)]), () => ( []));
+}
+function hasOwnVectorAppearance(node) {
+  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _45 => _45.effects, 'optionalAccess', _46 => _46.some, 'call', _47 => _47(isEnabled)]);
+}
+var liveCache = /* @__PURE__ */ new WeakMap();
+function hasVectorAppearance(node) {
+  let v2 = liveCache.get(node);
+  if (v2 === void 0) {
+    v2 = hasOwnVectorAppearance(node) || node.type === "group" && node.children.some(hasVectorAppearance);
+    liveCache.set(node, v2);
+  }
+  return v2;
+}
+function isVectorLiveBoolean(node) {
+  return _optionalChain([node, 'optionalAccess', _48 => _48.type]) === "group" && !!node.liveBoolean;
+}
+function vectorOperandOperation(group, child) {
+  return _nullishCoalesce(_nullishCoalesce(child.booleanOperation, () => ( group.liveBoolean)), () => ( "union"));
+}
+var PATH_OPS = { union: "union", subtract: "difference", intersect: "intersection", exclude: "xor" };
+var FoldCache = (_class = class {
+  constructor(cap) {;_class.prototype.__init.call(this);
+    this.cap = cap;
+  }
+  
+  __init() {this.map = /* @__PURE__ */ new Map()}
+  get(key) {
+    const hit = this.map.get(key);
+    if (hit) {
+      this.map.delete(key);
+      this.map.set(key, hit);
+    }
+    return hit;
+  }
+  set(key, path) {
+    if (this.map.size >= this.cap) {
+      let drop = Math.floor(this.map.size / 2);
+      for (const k of this.map.keys()) {
+        if (drop-- <= 0) break;
+        this.map.delete(k);
+      }
+    }
+    this.map.set(key, path);
+  }
+  clear() {
+    this.map.clear();
+  }
+}, _class);
+var foldCache = new FoldCache(4096);
+var foldSteps = 0;
+function vectorLiveBooleanSteps() {
+  return foldSteps;
+}
+function clearVectorLiveBooleanCache() {
+  foldCache.clear();
+}
+var RollingHash = (_class2 = class _RollingHash {constructor() { _class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this); }
+  __init2() {this.a = 2166136261}
+  __init3() {this.b = 16777619 ^ 1540483477}
+  static __initStatic() {this.view = new DataView(new ArrayBuffer(8))}
+  byte(v2) {
+    this.a = Math.imul(this.a ^ v2 & 255, 16777619);
+    this.b = Math.imul(this.b ^ v2 & 255, 1540483477) ^ this.b >>> 15;
+  }
+  num(n) {
+    _RollingHash.view.setFloat64(0, n);
+    for (let i = 0; i < 8; i++) this.byte(_RollingHash.view.getUint8(i));
+  }
+  path(p) {
+    for (const c of p) {
+      this.byte(c.type.charCodeAt(0));
+      if (c.type === "Z") continue;
+      if (c.type === "C") {
+        this.num(c.x1);
+        this.num(c.y1);
+        this.num(c.x2);
+        this.num(c.y2);
+      } else if (c.type === "Q") {
+        this.num(c.x1);
+        this.num(c.y1);
+      }
+      this.num(c.x);
+      this.num(c.y);
+    }
+  }
+  key() {
+    return `${(this.a >>> 0).toString(36)}.${(this.b >>> 0).toString(36)}`;
+  }
+}, _class2.__initStatic(), _class2);
+function foldVectorBooleanOperands(operands) {
+  if (!operands.length) return [];
+  if (operands.length === 1) return operands[0].path;
+  const h = new RollingHash();
+  const keys = operands.map((o, i) => {
+    if (i > 0) h.byte(o.operation.charCodeAt(0) + o.operation.length);
+    h.byte(o.fillRule === "evenodd" ? 1 : 0);
+    h.path(o.path);
+    h.byte(9);
+    return h.key();
+  });
+  let start = 0;
+  let acc = operands[0].path;
+  for (let i = keys.length - 1; i >= 1; i--) {
+    const hit = foldCache.get(keys[i]);
+    if (hit) {
+      if (i === keys.length - 1) return hit;
+      start = i;
+      acc = hit;
+      break;
+    }
+  }
+  let accRule = start === 0 ? operands[0].fillRule : "nonzero";
+  for (let i = start + 1; i < operands.length; i++) {
+    const o = operands[i];
+    foldSteps++;
+    const r = _chunkVNYRI265cjs.pathBoolean.call(void 0, _nullishCoalesce(PATH_OPS[o.operation], () => ( "union")), [
+      { path: acc, fillRule: accRule },
+      { path: o.path, fillRule: o.fillRule }
+    ]);
+    if (r.error) return [];
+    acc = r.path;
+    accRule = "nonzero";
+    foldCache.set(keys[i], acc);
+  }
+  return acc;
+}
+var compareOrder = (a, b) => {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return a.length - b.length;
+};
+var add2 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _49 => _49.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _50 => _50.y]), () => ( 0))) });
+var mapPaths = (shapes, fn) => {
+  const out = fn(shapes.map((s) => s.path));
+  return shapes.map((s, i) => ({ ...s, path: _nullishCoalesce(out[i], () => ( [])) }));
+};
+function applyVectorEffects(shapes, effects) {
+  let list = shapes.slice();
+  for (const e of _nullishCoalesce(effects, () => ( []))) {
+    if (!isEnabled(e) || !list.length) continue;
+    switch (e.type) {
+      case "trim": {
+        const { start, end, offset, mode } = e.params;
+        list = mapPaths(list, (p) => mode === "individual" ? trimPathsIndividually(p, start, end, offset) : trimPaths(p, start, end, offset));
+        break;
+      }
+      case "roundCorners":
+        list = mapPaths(list, (p) => roundCornerPaths(p, e.params.radius));
+        break;
+      case "puckerBloat":
+        list = mapPaths(list, (p) => puckerBloatPaths(p, e.params.amount));
+        break;
+      case "twist":
+        list = mapPaths(list, (p) => twistPaths(p, e.params.angle, add2(pathsCenter(p), e.params.center)));
+        break;
+      case "zigzag":
+        list = mapPaths(list, (p) => zigzagPaths(p, e.params.size, e.params.ridges, e.params.smooth));
+        break;
+      case "wiggle":
+        list = mapPaths(list, (p) => wigglePaths(p, e.params));
+        break;
+      case "offset": {
+        const o = e.params;
+        list = mapPaths(list, (p) => offsetPaths(p, o.amount, o.join, o.miterLimit, o.copies, o.copyOffset));
+        break;
+      }
+      case "merge": {
+        const first = list[0];
+        list = [{ ...first, path: mergePaths(list.map((s) => s.path), e.params.mode) }];
+        break;
+      }
+      case "repeater": {
+        const r = e.params;
+        const copies = repeatPaths(
+          list.map((s) => s.path),
+          r,
+          add2(pathsCenter(list.map((s) => s.path)), r.anchor)
+        );
+        const n = copies.length;
+        const next = [];
+        for (const { copy, paths } of copies) {
+          const rank = r.composite === "above" ? copy.index : n - 1 - copy.index;
+          list.forEach((s, i) => next.push({ source: s.source, path: paths[i], opacity: s.opacity * copy.opacity, order: [rank, ...s.order] }));
+        }
+        list = next;
+        break;
+      }
+    }
+  }
+  return list;
+}
+function childShapes(child, index) {
+  if (child.visible === false) return [];
+  const m = child.transform;
+  const k = _nullishCoalesce(child.opacity, () => ( 1));
+  return vectorAppearanceShapes(child).map((s) => ({
+    source: s.source,
+    path: m && !isIdentityMatrix(m) ? _chunkVNYRI265cjs.transformBezierPath.call(void 0, s.path, m) : s.path,
+    opacity: s.opacity * k,
+    order: [index, ...s.order]
+  }));
+}
+function liveBooleanShapes(group) {
+  const operands = [];
+  let source = null;
+  group.children.forEach((child, i) => {
+    const shapes = childShapes(child, i);
+    if (!shapes.length) return;
+    source ??= shapes[0].source;
+    const path = shapes.length === 1 ? shapes[0].path : _chunkVNYRI265cjs.pathBoolean.call(void 0, "union", shapes.map((s) => ({ path: s.path, fillRule: _nullishCoalesce(s.source.fillRule, () => ( "nonzero")) }))).path;
+    const fillRule = shapes.length === 1 ? _nullishCoalesce(shapes[0].source.fillRule, () => ( "nonzero")) : "nonzero";
+    operands.push({ path, fillRule, operation: vectorOperandOperation(group, child) });
+  });
+  if (!source) return [];
+  return [{ source, path: foldVectorBooleanOperands(operands), opacity: 1, order: [0] }];
+}
+var shapeCache = /* @__PURE__ */ new WeakMap();
+function vectorAppearanceShapes(node) {
+  const hit = shapeCache.get(node);
+  if (hit) return hit;
+  let base;
+  if (node.type === "path") base = [{ source: node, path: subpathsToBezier(node.subpaths), opacity: 1, order: [] }];
+  else if (node.liveBoolean) base = liveBooleanShapes(node);
+  else base = node.children.flatMap((c, i) => childShapes(c, i));
+  const out = applyVectorEffects(base, node.effects).sort((a, b) => compareOrder(a.order, b.order));
+  shapeCache.set(node, out);
+  return out;
+}
+var outlineCache = /* @__PURE__ */ new WeakMap();
+function vectorAppearanceOutline(node) {
+  let hit = outlineCache.get(node);
+  if (!hit) {
+    hit = node.type === "path" && !hasOwnVectorAppearance(node) ? subpathsToBezier(node.subpaths) : vectorAppearanceShapes(node).flatMap((s) => s.path);
+    outlineCache.set(node, hit);
+  }
+  return hit;
+}
+function shapeNode(shape, id) {
+  const {
+    id: _id,
+    type: _type,
+    subpaths: _s,
+    transform: _t,
+    effects: _e,
+    booleanOperation: _b,
+    blendStep: _bs,
+    locked: _l,
+    visible: _v,
+    opacity: _o,
+    ...style
+  } = shape.source;
+  return { ...style, id, type: "path", subpaths: bezierToSubpaths(shape.path), ...shape.opacity < 1 ? { opacity: shape.opacity } : {} };
+}
+function placement(node) {
+  return {
+    ...node.name !== void 0 ? { name: node.name } : {},
+    ...node.transform ? { transform: node.transform } : {},
+    ...node.visible === false ? { visible: false } : {},
+    ...node.locked ? { locked: true } : {},
+    ...node.blendStep ? { blendStep: true } : {},
+    ...node.booleanOperation ? { booleanOperation: node.booleanOperation } : {}
+  };
+}
+function vectorAppearanceNodes(node) {
+  return vectorAppearanceShapes(node).map((s, k) => shapeNode(s, `${node.id}~fx${k}`));
+}
+var expandCache = /* @__PURE__ */ new WeakMap();
+function expandVectorAppearance(node) {
+  if (!hasVectorAppearance(node)) return node;
+  const hit = expandCache.get(node);
+  if (hit) return hit;
+  let out;
+  if (!hasOwnVectorAppearance(node)) {
+    const group = node;
+    out = { ...group, children: group.children.map(expandVectorAppearance) };
+  } else {
+    const shapes = vectorAppearanceShapes(node);
+    if (node.type === "path" && shapes.length === 1) {
+      const one = shapes[0];
+      const { effects: _e, opacity: _o, ...rest } = node;
+      const opacity = (_nullishCoalesce(node.opacity, () => ( 1))) * one.opacity;
+      out = { ...rest, subpaths: bezierToSubpaths(one.path), ...opacity < 1 ? { opacity } : {} };
+    } else {
+      out = {
+        id: node.id,
+        type: "group",
+        ...placement(node),
+        ...node.opacity !== void 0 ? { opacity: node.opacity } : {},
+        children: vectorAppearanceNodes(node)
+      };
+    }
+  }
+  expandCache.set(node, out);
+  return out;
+}
+function expandVectorAppearances(nodes) {
+  let changed = false;
+  const out = nodes.map((n) => {
+    const e = expandVectorAppearance(n);
+    if (e !== n) changed = true;
+    return e;
+  });
+  return changed ? out : nodes;
+}
+function sanitizeVectorEffects(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object") continue;
+    const r = raw;
+    const type = r.type;
+    if (typeof type !== "string" || !VECTOR_EFFECT_DEFAULTS[type]) continue;
+    let id = typeof r.id === "string" && r.id && !used.has(r.id) ? r.id : "";
+    for (let k = out.length + 1; !id; k++) if (!used.has(`fx${k}`)) id = `fx${k}`;
+    used.add(id);
+    const effect = createVectorEffect(type, id, _nullishCoalesce(r.params, () => ( {})));
+    out.push(r.enabled === false ? { ...effect, enabled: false } : effect);
+  }
+  return out;
+}
+function transformVectorEffects(effects, m) {
+  const lin = (v2) => ({ x: m[0] * v2.x + m[2] * v2.y, y: m[1] * v2.x + m[3] * v2.y });
+  const mirror = m[0] * m[3] - m[1] * m[2] < 0 ? -1 : 1;
+  return effects.map((e) => {
+    if (e.type === "twist") return { ...e, params: { ...e.params, center: lin(e.params.center), angle: e.params.angle * mirror } };
+    if (e.type === "repeater")
+      return { ...e, params: { ...e.params, position: lin(e.params.position), anchor: lin(e.params.anchor), rotation: e.params.rotation * mirror } };
+    return e;
+  });
+}
+function vectorEnteredGroups(nodes, ids) {
+  const out = /* @__PURE__ */ new Set();
+  if (!ids.length) return out;
+  const want = new Set(ids);
+  const visit = (list, live) => {
+    for (const n of list) {
+      const own = n.type === "group" && hasOwnVectorAppearance(n);
+      if (want.has(n.id)) {
+        for (const id of live) out.add(id);
+        if (own) out.add(n.id);
+      }
+      if (n.type === "group") visit(n.children, own ? [...live, n.id] : live);
+    }
+  };
+  visit(nodes, []);
+  return out;
+}
+
+// src/vector/geometry.ts
+var EPS3 = 1e-9;
 var cloneAnchor = (a) => ({
   x: a.x,
   y: a.y,
@@ -1068,7 +1935,7 @@ function hasPaint(paint) {
   return true;
 }
 var handleOf = (a, side) => _nullishCoalesce(a[side], () => ( { x: a.x, y: a.y }));
-var isOnAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS2 && Math.abs(h.y - a.y) < EPS2;
+var isOnAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS3 && Math.abs(h.y - a.y) < EPS3;
 function subpathSegmentCount(sp) {
   const n = sp.anchors.length;
   if (n < 2) return 0;
@@ -1100,7 +1967,7 @@ function subpathsToBezier(subpaths, options = {}) {
   return out;
 }
 function vectorNodeToBezier(node) {
-  return node.type === "path" ? subpathsToBezier(node.subpaths) : [];
+  return node.type === "path" ? vectorAppearanceOutline(node) : [];
 }
 function vectorPathData(input, precision = 3) {
   const subpaths = Array.isArray(input) ? input : input.subpaths;
@@ -1214,12 +2081,13 @@ function collectPathNodes(node) {
 function nodeMatrix(node) {
   return _nullishCoalesce(node.transform, () => ( IDENTITY_MATRIX));
 }
-function vectorPathWorldBezier(node, parent = IDENTITY_MATRIX) {
+function vectorPathWorldBezier(node, parent = IDENTITY_MATRIX, options = {}) {
   const m = multiplyMatrices(nodeMatrix(node), parent);
-  const path = subpathsToBezier(node.subpaths);
+  const path = options.effects === false || !hasOwnVectorAppearance(node) ? subpathsToBezier(node.subpaths) : vectorAppearanceOutline(node);
   return isIdentityMatrix(m) ? path : _chunkVNYRI265cjs.transformBezierPath.call(void 0, path, m);
 }
 function vectorNodeBounds(node, parent = IDENTITY_MATRIX) {
+  node = expandVectorAppearance(node);
   if (node.type === "group") {
     const m = multiplyMatrices(nodeMatrix(node), parent);
     return unionBounds(node.children.map((c) => vectorNodeBounds(c, m)));
@@ -1249,11 +2117,12 @@ function boundsIntersect(a, b) {
 function boundsFromPoints(a, b) {
   return { x: Math.min(a.x, b.x), y: Math.min(a.y, b.y), width: Math.abs(b.x - a.x), height: Math.abs(b.y - a.y) };
 }
-function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX) {
+function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX, options = {}) {
   if (node.visible === false) return false;
+  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _51 => _51.entered, 'optionalAccess', _52 => _52.has, 'call', _53 => _53(node.id)])))) node = expandVectorAppearance(node);
   if (node.type === "group") {
     const m = multiplyMatrices(nodeMatrix(node), parent);
-    return node.children.some((c) => hitTestVectorNode(c, p, tolerance, m));
+    return node.children.some((c) => hitTestVectorNode(c, p, tolerance, m, options));
   }
   const path = vectorPathWorldBezier(node, parent);
   if (path.length === 0) return false;
@@ -1266,11 +2135,11 @@ function vectorStrokeOutline(node, parent = IDENTITY_MATRIX) {
   if (!hasPaint(node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return [];
   return vectorStrokeOutlinePath(vectorPathWorldBezier(node, parent), node);
 }
-function hitTestVectorNodes(nodes, p, tolerance = 0) {
+function hitTestVectorNodes(nodes, p, tolerance = 0, options = {}) {
   for (let i = nodes.length - 1; i >= 0; i--) {
     const node = nodes[i];
     if (node.visible === false || node.locked) continue;
-    if (hitTestVectorNode(node, p, tolerance)) return node;
+    if (hitTestVectorNode(node, p, tolerance, IDENTITY_MATRIX, options)) return node;
   }
   return null;
 }
@@ -1349,16 +2218,17 @@ function mapAnchor(a, m) {
 }
 function bakeIntoGeometry(node, m) {
   if (isIdentityMatrix(m)) return node;
+  if (_optionalChain([node, 'access', _54 => _54.effects, 'optionalAccess', _55 => _55.length])) node = { ...node, effects: transformVectorEffects(node.effects, m) };
   if (node.type === "group") {
     const group = node;
     const children = group.children.map((c) => transformVectorNode(c, m));
-    const spine = _optionalChain([group, 'access', _28 => _28.blend, 'optionalAccess', _29 => _29.spine]);
+    const spine = _optionalChain([group, 'access', _56 => _56.blend, 'optionalAccess', _57 => _57.spine]);
     if (!spine) return { ...group, children };
     const moved = { closed: spine.closed, anchors: spine.anchors.map((a) => mapAnchor(a, m)) };
     return { ...group, children, blend: { ...group.blend, spine: moved } };
   }
   const path = node;
-  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _30 => _30.strokeWidthProfile, 'optionalAccess', _31 => _31.length]);
+  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _58 => _58.strokeWidthProfile, 'optionalAccess', _59 => _59.length]);
   return {
     ...path,
     ...mirrored ? { strokeWidthProfile: mirrorWidthProfile(path.strokeWidthProfile) } : {},
@@ -1416,7 +2286,7 @@ function moveAnchorHandle(a, side, pos, breakHandles = false) {
   const dy = pos.y - a.y;
   const len2 = Math.hypot(dx, dy);
   if (type === "symmetric") next[other] = { x: a.x - dx, y: a.y - dy };
-  else if (type === "smooth" && len2 > EPS2) {
+  else if (type === "smooth" && len2 > EPS3) {
     const o = a[other];
     const olen = o ? Math.hypot(o.x - a.x, o.y - a.y) : len2;
     next[other] = { x: a.x - dx / len2 * olen, y: a.y - dy / len2 * olen };
@@ -1446,15 +2316,15 @@ function convertAnchor(sp, index, type) {
   else if (prev && next) dir = { x: next.x - prev.x, y: next.y - prev.y };
   else if (next) dir = { x: next.x - a.x, y: next.y - a.y };
   else if (prev) dir = { x: a.x - prev.x, y: a.y - prev.y };
-  if (!dir || Math.hypot(dir.x, dir.y) < EPS2) return { anchors, closed: sp.closed };
+  if (!dir || Math.hypot(dir.x, dir.y) < EPS3) return { anchors, closed: sp.closed };
   const dl = Math.hypot(dir.x, dir.y);
   const ux = dir.x / dl;
   const uy = dir.y / dl;
   lenIn = a.in && !isOnAnchor(a, a.in) ? Math.hypot(a.in.x - a.x, a.in.y - a.y) : prev ? Math.hypot(prev.x - a.x, prev.y - a.y) / 3 : 0;
   lenOut = a.out && !isOnAnchor(a, a.out) ? Math.hypot(a.out.x - a.x, a.out.y - a.y) : next ? Math.hypot(next.x - a.x, next.y - a.y) / 3 : 0;
   if (type === "symmetric") lenIn = lenOut = (lenIn + lenOut) / 2 || Math.max(lenIn, lenOut);
-  if (lenIn > EPS2) a.in = { x: a.x - ux * lenIn, y: a.y - uy * lenIn };
-  if (lenOut > EPS2) a.out = { x: a.x + ux * lenOut, y: a.y + uy * lenOut };
+  if (lenIn > EPS3) a.in = { x: a.x - ux * lenIn, y: a.y - uy * lenIn };
+  if (lenOut > EPS3) a.out = { x: a.x + ux * lenOut, y: a.y + uy * lenOut };
   a.type = type;
   return { anchors, closed: sp.closed };
 }
@@ -1569,7 +2439,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', _32 => _32[+m[1]], 'optionalAccess', _33 => _33.anchors, 'access', _34 => _34[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _60 => _60[+m[1]], 'optionalAccess', _61 => _61.anchors, 'access', _62 => _62[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -1637,7 +2507,7 @@ function blendFromAttribute(value, m) {
   let raw;
   try {
     raw = JSON.parse(value);
-  } catch (e3) {
+  } catch (e4) {
     return null;
   }
   if (!raw || typeof raw !== "object") return null;
@@ -1674,13 +2544,33 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (node.visible === false) out2 += ` display="none"`;
     if (node.blendStep) out2 += ` data-vector-blend-step=""`;
     if (node.type === "group" && node.blend) out2 += ` data-vector-blend="${escapeAttr(JSON.stringify(node.blend))}"`;
+    if (node.booleanOperation) out2 += ` data-vector-boolean-operation="${node.booleanOperation}"`;
     return out2;
   };
-  const emit = (node, depth) => {
+  const emit2 = (node, depth) => {
     if (node.visible === false && !options.includeHidden) return;
+    if (hasOwnVectorAppearance(node)) {
+      const live2 = {
+        kind: node.type,
+        ..._optionalChain([node, 'access', _63 => _63.effects, 'optionalAccess', _64 => _64.length]) ? { effects: node.effects } : {},
+        ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {}
+      };
+      lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr(JSON.stringify(live2))}">`);
+      lines.push(`${indent(depth + 1)}<g data-vector-part="appearance">`);
+      for (const shape of vectorAppearanceNodes(node)) emit2(shape, depth + 2);
+      lines.push(`${indent(depth + 1)}</g>`);
+      lines.push(`${indent(depth + 1)}<g data-vector-part="source" display="none">`);
+      if (node.type === "path") {
+        const { effects: _e, transform: _t, opacity: _o, visible: _v, booleanOperation: _b, blendStep: _s, ...source } = node;
+        emit2({ ...source, id: `${node.id}~src` }, depth + 2);
+      } else for (const child of node.children) emit2(child, depth + 2);
+      lines.push(`${indent(depth + 1)}</g>`);
+      lines.push(`${indent(depth)}</g>`);
+      return;
+    }
     if (node.type === "group") {
       lines.push(`${indent(depth)}<g${common(node)}>`);
-      for (const child of node.children) emit(child, depth + 1);
+      for (const child of node.children) emit2(child, depth + 1);
       lines.push(`${indent(depth)}</g>`);
       return;
     }
@@ -1696,7 +2586,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       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', _35 => _35.strokeDasharray, 'optionalAccess', _36 => _36.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      if (_optionalChain([node, 'access', _65 => _65.strokeDasharray, 'optionalAccess', _66 => _66.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;
@@ -1716,7 +2606,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       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', _37 => _37.strokeDasharray, 'optionalAccess', _38 => _38.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num).join(" ")}"`;
+      if (_optionalChain([node, 'access', _67 => _67.strokeDasharray, 'optionalAccess', _68 => _68.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}/>`);
@@ -1744,7 +2634,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     }
     lines.push(`${indent(depth)}</g>`);
   };
-  for (const node of doc.nodes) emit(node, 1);
+  for (const node of doc.nodes) emit2(node, 1);
   const w = num(doc.width);
   const h = num(doc.height);
   const nl = pretty ? "\n" : "";
@@ -1756,6 +2646,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   out.push(...lines, "</svg>");
   return out.join(nl);
 }
+var BOOLEAN_OPERATIONS = ["union", "subtract", "intersect", "exclude"];
 function parseXml(source) {
   const text = source.replace(/<!--[\s\S]*?-->/g, "").replace(/<\?[\s\S]*?\?>/g, "").replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, "").replace(/<!DOCTYPE[^>[]*(\[[\s\S]*?\])?\s*>/gi, "");
   const root = { name: "#root", attrs: {}, children: [] };
@@ -1885,7 +2776,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', _39 => _39.startsWith, 'call', _40 => _40("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _41 => _41(href.slice(1), raw, seen), 'optionalAccess', _42 => _42.stops]), () => ( []));
+  if (!stops.length && _optionalChain([href, 'optionalAccess', _69 => _69.startsWith, 'call', _70 => _70("#")])) stops = _nullishCoalesce(_optionalChain([resolveGradient, 'call', _71 => _71(href.slice(1), raw, seen), 'optionalAccess', _72 => _72.stops]), () => ( []));
   if (!stops.length) return null;
   if (el.name === "radialGradient") {
     return { type: "radial", cx: fraction(el.attrs.cx, 0.5), cy: fraction(el.attrs.cy, 0.5), r: fraction(el.attrs.r, 0.5), stops };
@@ -1989,7 +2880,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', _43 => _43.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _73 => _73.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style);
     const strokeEl = part("stroke");
@@ -2026,10 +2917,38 @@ function parseVectorSvg(svg, options = {}) {
       ...profile.length ? { strokeWidthProfile: profile } : {},
       ...keptCap ? { strokeLinecap: keptCap } : {},
       ...keptJoin ? { strokeLinejoin: keptJoin } : {},
-      ..._optionalChain([keptDash, 'optionalAccess', _44 => _44.length]) ? { strokeDasharray: keptDash } : {}
+      ..._optionalChain([keptDash, 'optionalAccess', _74 => _74.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
+  const liveNode = (g, style, m, meta) => {
+    let raw = {};
+    try {
+      raw = _nullishCoalesce(JSON.parse(g.attrs["data-vector-live"]), () => ( {}));
+    } catch (e5) {
+      raw = {};
+    }
+    const sourceEl = g.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === "source");
+    if (!sourceEl) return null;
+    const inner = visit(sourceEl, style, m);
+    const effects = sanitizeVectorEffects(raw.effects);
+    const liveBoolean = BOOLEAN_OPERATIONS.includes(raw.liveBoolean) ? raw.liveBoolean : null;
+    const id = idFor(g);
+    if (raw.kind === "path") {
+      const path = inner.find((n) => n.type === "path");
+      if (!path) return null;
+      const { residual } = decomposeRigid(m);
+      const { visible: _v, ...rest } = path;
+      return { ...rest, id, ...meta, ...effects.length ? { effects: transformVectorEffects(effects, residual) } : {} };
+    }
+    if (!inner.length) return null;
+    const group = { id, type: "group", ...meta, children: inner };
+    if (effects.length) group.effects = transformVectorEffects(effects, m);
+    if (liveBoolean) group.liveBoolean = liveBoolean;
+    const blend = blendFromAttribute(g.attrs["data-vector-blend"], m);
+    if (blend) group.blend = blend;
+    return group;
+  };
   const visit = (el, style, matrix) => {
     const out = [];
     for (const child of el.children) {
@@ -2044,6 +2963,13 @@ function parseVectorSvg(svg, options = {}) {
         ...hidden ? { visible: false } : {}
       };
       if (child.attrs["data-vector-blend-step"] !== void 0) continue;
+      const operation = child.attrs["data-vector-boolean-operation"];
+      if (BOOLEAN_OPERATIONS.includes(operation)) meta.booleanOperation = operation;
+      if (child.name === "g" && child.attrs["data-vector-live"] !== void 0) {
+        const node2 = liveNode(child, s, m, meta);
+        if (node2) out.push(node2);
+        continue;
+      }
       if (child.name === "g" && child.attrs["data-vector-path"] !== void 0) {
         const node2 = mergedPath(child, s, m, meta);
         if (node2) out.push(node2);
@@ -2572,7 +3498,7 @@ function interpolateVectorPaint(a, b, t) {
   return t < 0.5 ? a : b;
 }
 function interpolateWidthProfiles(a, b, t) {
-  if (!_optionalChain([a, 'optionalAccess', _45 => _45.length]) && !_optionalChain([b, 'optionalAccess', _46 => _46.length])) return null;
+  if (!_optionalChain([a, 'optionalAccess', _75 => _75.length]) && !_optionalChain([b, 'optionalAccess', _76 => _76.length])) return null;
   const at2 = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at2.filter((v2, i) => i === 0 || v2 - at2[i - 1] > 1e-6);
   return ts.map((pos) => {
@@ -2582,7 +3508,7 @@ function interpolateWidthProfiles(a, b, t) {
   });
 }
 function lerpDashes(a, b, t) {
-  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _47 => _47.length]) && d.some((v2) => v2 > 0);
+  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _77 => _77.length]) && d.some((v2) => v2 > 0);
   if (!dashed(a) && !dashed(b)) return t < 0.5 ? a : b;
   const even = (p) => p.length % 2 ? [...p, ...p] : p;
   const solid = (p) => {
@@ -2609,7 +3535,7 @@ function interpolateVectorStyle(a, b, t) {
   for (const key of ["startArrowScale", "endArrowScale"])
     if (a[key] !== void 0 || b[key] !== void 0) out[key] = lerpN(_nullishCoalesce(a[key], () => ( 1)), _nullishCoalesce(b[key], () => ( 1)), t);
   const dash = lerpDashes(a.strokeDasharray, b.strokeDasharray, t);
-  if (_optionalChain([dash, 'optionalAccess', _48 => _48.length])) out.strokeDasharray = dash;
+  if (_optionalChain([dash, 'optionalAccess', _78 => _78.length])) out.strokeDasharray = dash;
   const profile = interpolateWidthProfiles(a.strokeWidthProfile, b.strokeWidthProfile, t);
   if (profile) out.strokeWidthProfile = profile;
   return out;
@@ -2620,7 +3546,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _49 => _49.strokeWidthProfile, 'optionalAccess', _50 => _50.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _79 => _79.strokeWidthProfile, 'optionalAccess', _80 => _80.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -2766,11 +3692,11 @@ function vectorBlendKeys(group) {
 }
 function resolveVectorBlendOptions(options) {
   return {
-    spacing: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _51 => _51.spacing]), () => ( "steps")),
-    steps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _52 => _52.steps]), () => ( DEFAULT_VECTOR_BLEND_STEPS)),
-    distance: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _53 => _53.distance]), () => ( DEFAULT_VECTOR_BLEND_DISTANCE)),
-    orientToSpine: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _54 => _54.orientToSpine]), () => ( false)),
-    linear: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _55 => _55.linear]), () => ( false))
+    spacing: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _81 => _81.spacing]), () => ( "steps")),
+    steps: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _82 => _82.steps]), () => ( DEFAULT_VECTOR_BLEND_STEPS)),
+    distance: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _83 => _83.distance]), () => ( DEFAULT_VECTOR_BLEND_DISTANCE)),
+    orientToSpine: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _84 => _84.orientToSpine]), () => ( false)),
+    linear: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _85 => _85.linear]), () => ( false))
   };
 }
 function paintColors(p) {
@@ -2858,7 +3784,7 @@ function vectorBlendRailAt(rail, s) {
 function vectorBlendSpine(group) {
   const keys = vectorBlendKeys(group);
   if (keys.length < 2) return null;
-  const stored = _optionalChain([group, 'access', _56 => _56.blend, 'optionalAccess', _57 => _57.spine]);
+  const stored = _optionalChain([group, 'access', _86 => _86.blend, 'optionalAccess', _87 => _87.spine]);
   if (stored && stored.anchors.length >= 2) {
     const rail2 = vectorBlendRail(stored);
     if (rail2) {
@@ -2879,7 +3805,7 @@ function vectorBlendKeyTargets(group) {
 }
 var morphCache = /* @__PURE__ */ new WeakMap();
 function morphFor(a, b, blend) {
-  const starts = [_nullishCoalesce(_optionalChain([blend, 'access', _58 => _58.starts, 'optionalAccess', _59 => _59[a.id]]), () => ( null)), _nullishCoalesce(_optionalChain([blend, 'access', _60 => _60.starts, 'optionalAccess', _61 => _61[b.id]]), () => ( null))];
+  const starts = [_nullishCoalesce(_optionalChain([blend, 'access', _88 => _88.starts, 'optionalAccess', _89 => _89[a.id]]), () => ( null)), _nullishCoalesce(_optionalChain([blend, 'access', _90 => _90.starts, 'optionalAccess', _91 => _91[b.id]]), () => ( null))];
   const key = JSON.stringify([!!blend.linear, starts]);
   let inner = morphCache.get(a);
   if (!inner) morphCache.set(a, inner = /* @__PURE__ */ new WeakMap());
@@ -2978,7 +3904,7 @@ function releaseVectorBlend(group, newId) {
   const m = nodeMatrix(group);
   const opacity = group.opacity;
   const keys = vectorBlendKeys(group).map((c) => group.transform ? transformVectorNode(c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c);
-  const spine = _optionalChain([group, 'access', _62 => _62.blend, 'optionalAccess', _63 => _63.spine]);
+  const spine = _optionalChain([group, 'access', _92 => _92.blend, 'optionalAccess', _93 => _93.spine]);
   if (!spine || spine.anchors.length < 2) return keys;
   const path = { id: newId(), type: "path", name: "Spine", fill: null, stroke: null, subpaths: [{ closed: spine.closed, anchors: spine.anchors.map((a) => ({ ...a })) }] };
   return [...keys, group.transform ? transformVectorNode(path, m) : path];
@@ -2987,7 +3913,7 @@ function releaseVectorBlend(group, newId) {
 // src/vector/snap.ts
 var VECTOR_CONSTRUCTION_ANGLES = [0, 45, 90, 135];
 function constrainToLeave(leave, p) {
-  if (!_optionalChain([leave, 'optionalAccess', _64 => _64.constrain])) return p;
+  if (!_optionalChain([leave, 'optionalAccess', _94 => _94.constrain])) return p;
   const dx = p.x - leave.at.x;
   const dy = p.y - leave.at.y;
   switch (leave.constrain) {
@@ -3051,16 +3977,16 @@ function contains(node, ids) {
   if (ids.has(node.id)) return true;
   return node.type === "group" && node.children.some((c) => contains(c, ids));
 }
-var VectorSnapTargets = (_class = class _VectorSnapTargets {
-  __init() {this.points = []}
-  __init2() {this.xs = []}
-  __init3() {this.ys = []}
-  __init4() {this.segments = []}
+var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
+  __init4() {this.points = []}
+  __init5() {this.xs = []}
+  __init6() {this.ys = []}
+  __init7() {this.segments = []}
   /** Bounds of the objects a moved box spaces itself evenly with. */
-  __init5() {this.boxes = []}
+  __init8() {this.boxes = []}
   /** Side lengths of the other objects (in their own frames), which a resize may match. */
-  __init6() {this.sizes = []}
-  constructor() {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);
+  __init9() {this.sizes = []}
+  constructor() {;_class3.prototype.__init4.call(this);_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);
   }
   /** How many targets of each sort were gathered. */
   get counts() {
@@ -3098,7 +4024,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', _65 => _65.get, 'call', _66 => _66(id), 'optionalAccess', _67 => _67.has, 'call', _68 => _68(`${s}:${i}`)]), true);
+    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _95 => _95.get, 'call', _96 => _96(id), 'optionalAccess', _97 => _97.has, 'call', _98 => _98(`${s}:${i}`)]), true);
     return t.index();
   }
   /**
@@ -3197,8 +4123,9 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     let anchors = BUDGET;
     let segments = BUDGET;
     const visit = (list, parent) => {
-      for (const n of list) {
-        if (exclude.has(n.id) || n.visible === false) continue;
+      for (const stored of list) {
+        if (exclude.has(stored.id) || stored.visible === false) continue;
+        const n = contains(stored, exclude) ? stored : expandVectorAppearance(stored);
         const m = multiplyMatrices(nodeMatrix(n), parent);
         if (n.type === "group") {
           visit(n.children, m);
@@ -3216,7 +4143,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', _69 => _69.centre]), () => ( null)));
+        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _99 => _99.centre]), () => ( null)));
       }
     };
     visit(doc.nodes, IDENTITY_MATRIX);
@@ -3261,7 +4188,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       lines: lines2,
       labels: [this.label(q, kind)]
     });
-    if (_optionalChain([leave, 'optionalAccess', _70 => _70.constrain])) {
+    if (_optionalChain([leave, 'optionalAccess', _100 => _100.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);
@@ -3277,7 +4204,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     }
     const on = this.onSegment(near2);
     if (on) return at2(on, "path");
-    if (_optionalChain([leave, 'optionalAccess', _71 => _71.angles, 'optionalAccess', _72 => _72.length])) {
+    if (_optionalChain([leave, 'optionalAccess', _101 => _101.angles, 'optionalAccess', _102 => _102.length])) {
       const c = construction(leave, p, tol);
       if (c) {
         const hit = this.slide(leave.at, c.dir, c.point, tol, false);
@@ -3407,7 +4334,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', _73 => _73.axes, 'optionalAccess', _74 => _74.x]) !== false, y: _optionalChain([options, 'access', _75 => _75.axes, 'optionalAccess', _76 => _76.y]) !== false };
+    const axes = { x: _optionalChain([options, 'access', _103 => _103.axes, 'optionalAccess', _104 => _104.x]) !== false, y: _optionalChain([options, 'access', _105 => _105.axes, 'optionalAccess', _106 => _106.y]) !== false };
     const 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 };
@@ -3415,7 +4342,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', _77 => _77.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _78 => _78.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
+    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _107 => _107.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _108 => _108.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
     const done = { ...r, x: r.x + out.dx, y: r.y + out.dy };
     if (bx) {
       const x = bx.from.x;
@@ -3538,9 +4465,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', _79 => _79.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _80 => _80.v]), () => ( null)), s: { hx, hy, on: null } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _81 => _81.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
-      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _82 => _82.v]), () => ( null)), s: { hx: null, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _109 => _109.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _110 => _110.v]), () => ( null)), s: { hx, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _111 => _111.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
+      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _112 => _112.v]), () => ( null)), s: { hx: null, hy, on: null } });
       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)) });
@@ -3657,7 +4584,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     }
     return out;
   }
-}, _class);
+}, _class3);
 var RING = ["nw", "n", "ne", "e", "se", "s", "sw", "w"];
 function opposite(h) {
   return RING[(RING.indexOf(h) + 4) % 8];
@@ -3736,8 +4663,8 @@ function solveOnSegment(seg, base, cond) {
 }
 
 // src/vector/pathEdit.ts
-var EPS3 = 1e-9;
-var unit2 = (x, y) => {
+var EPS4 = 1e-9;
+var unit3 = (x, y) => {
   const l = Math.hypot(x, y);
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
 };
@@ -3748,16 +4675,16 @@ function cubicOf(sp, i) {
   return [a, [a[0] + (b[0] - a[0]) / 3, a[1] + (b[1] - a[1]) / 3], [a[0] + 2 * (b[0] - a[0]) / 3, a[1] + 2 * (b[1] - a[1]) / 3], b];
 }
 var isLine = (sp, i) => subpathSegment(sp, i).length === 2;
-function startTangent(c) {
+function startTangent2(c) {
   for (let k = 1; k < 4; k++) {
-    const u = unit2(c[k][0] - c[0][0], c[k][1] - c[0][1]);
+    const u = unit3(c[k][0] - c[0][0], c[k][1] - c[0][1]);
     if (u) return u;
   }
   return [1, 0];
 }
-function endTangent(c) {
+function endTangent2(c) {
   for (let k = 2; k >= 0; k--) {
-    const u = unit2(c[3][0] - c[k][0], c[3][1] - c[k][1]);
+    const u = unit3(c[3][0] - c[k][0], c[3][1] - c[k][1]);
     if (u) return u;
   }
   return [1, 0];
@@ -3765,7 +4692,7 @@ function endTangent(c) {
 function sample(c, n, out, withStart) {
   for (let i = withStart ? 0 : 1; i <= n; i++) out.push(_chunkVNYRI265cjs.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;
+var onAnchor2 = (a, h) => !h || Math.abs(h.x - a.x) < EPS4 && Math.abs(h.y - a.y) < EPS4;
 function tidy(a, keepType = true) {
   const next = cloneAnchor(a);
   if (onAnchor2(next, next.in)) delete next.in;
@@ -3827,8 +4754,8 @@ function removeAnchorKeepingShape(sp, index) {
       const pts = [];
       sample(left, N, pts, true);
       sample(right, N, pts, false);
-      const t0 = startTangent(left);
-      const t1 = endTangent(right);
+      const t0 = startTangent2(left);
+      const t1 = endTangent2(right);
       const { curve } = fitAcross(pts, N, t0, t1);
       if ([curve.p1, curve.p2].every((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]))) {
         anchors[pi] = tidy({ ...anchors[pi], out: { x: curve.p1[0], y: curve.p1[1] } });
@@ -4029,7 +4956,7 @@ function smoothSubpath(sp, amount = 1, only) {
     const prev = orig[(i + n - 1) % n];
     const next = orig[(i + 1) % n];
     const p = orig[i];
-    const dir = unit2(next.x - prev.x, next.y - prev.y);
+    const dir = unit3(next.x - prev.x, next.y - prev.y);
     if (!dir) continue;
     const li = dist2(p, prev) / 3;
     const lo = dist2(p, next) / 3;
@@ -4095,13 +5022,13 @@ function mergePair(a, b, tol) {
   }
   const ca = a.line ? [a0, a0, a3, a3] : a.c;
   const cb = b.line ? [a3, a3, b3, b3] : b.c;
-  const ta = endTangent(ca);
-  const tb = startTangent(cb);
+  const ta = endTangent2(ca);
+  const tb = startTangent2(cb);
   if (ta[0] * tb[0] + ta[1] * tb[1] < 0.99) return null;
   const pts = [];
   sample(ca, 16, pts, true);
   sample(cb, 16, pts, false);
-  const { curve, error } = fitAcross(pts, 16, startTangent(ca), endTangent(cb));
+  const { curve, error } = fitAcross(pts, 16, startTangent2(ca), endTangent2(cb));
   return error <= tol ? { c: [curve.p0, curve.p1, curve.p2, curve.p3], line: false } : null;
 }
 function removeRedundantPoints(sp, tolerance) {
@@ -4233,14 +5160,14 @@ function lineHits(p, q, seg) {
   return out;
 }
 var near = (a, b, eps) => Math.abs(a[0] - b[0]) <= eps && Math.abs(a[1] - b[1]) <= eps;
-var degenerate = (seg, eps) => seg.every((p) => near(p, seg[0], eps));
+var degenerate2 = (seg, eps) => seg.every((p) => near(p, seg[0], eps));
 function arc(l, a, b, eps) {
   const n = l.segs.length;
   const segs = [];
   const chord = [];
   const push = (k, t0, t1) => {
     const piece = t0 <= 0 && t1 >= 1 ? l.segs[k].slice() : _chunkVNYRI265cjs.subSegment.call(void 0, l.segs[k], t0, t1);
-    if (!degenerate(piece, eps)) {
+    if (!degenerate2(piece, eps)) {
       segs.push(piece);
       chord.push(l.chord[k]);
     }
@@ -4470,14 +5397,14 @@ function simplifyPolyline(points, tolerance) {
 }
 
 // src/vector/ink.ts
-var LazyMouse = (_class2 = class {
+var LazyMouse = (_class4 = class {
   /** `length` is the string length in the units of the points (0 turns smoothing off). */
-  constructor(length2) {;_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);
+  constructor(length2) {;_class4.prototype.__init10.call(this);_class4.prototype.__init11.call(this);
     this.length = length2;
   }
   
-  __init7() {this.pos = null}
-  __init8() {this.last = null}
+  __init10() {this.pos = null}
+  __init11() {this.last = null}
   push(p) {
     this.last = p;
     if (!(this.length > 0)) return [p];
@@ -4508,7 +5435,7 @@ var LazyMouse = (_class2 = class {
     this.pos = last;
     return [last];
   }
-}, _class2);
+}, _class4);
 var VECTOR_INK_MAX_CORNERS = 8;
 var MAX_POINTS = 1e5;
 function vectorInkShapeName(shape) {
@@ -4698,8 +5625,9 @@ function recognizeInkShape(points, options = {}) {
 // 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 visit = (stored, parent, inside) => {
+    if (stored.visible === false || stored.locked && !options.locked) return;
+    const node = options.expand === false ? stored : expandVectorAppearance(stored);
     const picked = inside || roots === null || roots.includes(node.id);
     if (node.type === "group") {
       const m = multiplyMatrices(nodeMatrix(node), parent);
@@ -4753,7 +5681,7 @@ var STROKE_KEYS = [
   "strokeWidthProfile"
 ];
 function vectorResultStyle(node, paint, edge = false) {
-  const { id: _id, subpaths: _s, transform: _t, ...rest } = node;
+  const { id: _id, subpaths: _s, transform: _t, effects: _e, booleanOperation: _b, ...rest } = node;
   const base = { ...rest, fillRule: "nonzero" };
   if (edge) {
     for (const k of STROKE_KEYS) delete base[k];
@@ -4969,7 +5897,7 @@ function getEditablePathIds(state) {
       }
     }
   }
-  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _83 => _83(state.document.nodes, id), 'optionalAccess', _84 => _84.type]) === "path");
+  return [...ids].filter((id) => _optionalChain([findVectorNode, 'call', _113 => _113(state.document.nodes, id), 'optionalAccess', _114 => _114.type]) === "path");
 }
 function getVisibleAnchors(state) {
   const out = [];
@@ -4984,7 +5912,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', _85 => _85.anchors, 'access', _86 => _86[i]]);
+    const a = _optionalChain([sp, 'optionalAccess', _115 => _115.anchors, 'access', _116 => _116[i]]);
     if (!a || !a[handle]) return;
     const key = `${node.id}:${s}:${i}:${handle}`;
     if (seen.has(key)) return;
@@ -4993,8 +5921,8 @@ function getVisibleHandles(state) {
   };
   if (state.tool === "pen" && state.pen) {
     const node = findVectorNode(state.document.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _87 => _87.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
-    if (_optionalChain([node, 'optionalAccess', _88 => _88.type]) === "path" && sp) {
+    const sp = _optionalChain([node, 'optionalAccess', _117 => _117.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    if (_optionalChain([node, 'optionalAccess', _118 => _118.type]) === "path" && sp) {
       const last = sp.anchors.length - 1;
       push(node, state.pen.subpath, last, "in");
       push(node, state.pen.subpath, last, "out");
@@ -5032,11 +5960,11 @@ function getVectorCornerWidgets(state) {
       const side = Math.min(c.lu, c.lv);
       if (side * zoom < 3 * VECTOR_CORNER_WIDGET_INSET) continue;
       const a = node.subpaths[c.subpath].anchors[c.index];
-      const radius = _nullishCoalesce(_optionalChain([a, 'access', _89 => _89.corner, 'optionalAccess', _90 => _90.radius]), () => ( 0));
+      const radius = _nullishCoalesce(_optionalChain([a, 'access', _119 => _119.corner, 'optionalAccess', _120 => _120.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', _91 => _91.corner, 'optionalAccess', _92 => _92.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', _121 => _121.corner, 'optionalAccess', _122 => _122.kind]), () => ( "round")), corner: c });
     }
   }
   return out;
@@ -5059,13 +5987,13 @@ function getVectorWidthHandles(state) {
     const n = findVectorNode(state.document.nodes, id);
     if (n) for (const p of collectPathNodes(n)) ids.add(p.id);
   }
-  if (_optionalChain([state, 'access', _93 => _93.hover, 'optionalAccess', _94 => _94.nodeId])) ids.add(state.hover.nodeId);
-  if (_optionalChain([state, 'access', _95 => _95.interaction, 'optionalAccess', _96 => _96.type]) === "width") ids.add(state.interaction.ref.nodeId);
+  if (_optionalChain([state, 'access', _123 => _123.hover, 'optionalAccess', _124 => _124.nodeId])) ids.add(state.hover.nodeId);
+  if (_optionalChain([state, 'access', _125 => _125.interaction, 'optionalAccess', _126 => _126.type]) === "width") ids.add(state.interaction.ref.nodeId);
   for (const r of state.selectedWidthPoints) ids.add(r.nodeId);
   const out = [];
   for (const id of ids) {
     const node = findVectorNode(state.document.nodes, id);
-    if (_optionalChain([node, 'optionalAccess', _97 => _97.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _98 => _98.strokeWidthProfile, 'optionalAccess', _99 => _99.length])) continue;
+    if (_optionalChain([node, 'optionalAccess', _127 => _127.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _128 => _128.strokeWidthProfile, 'optionalAccess', _129 => _129.length])) continue;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) continue;
     const profile = sanitizeWidthProfile(node.strokeWidthProfile);
@@ -5098,7 +6026,7 @@ function getVectorWidthHandles(state) {
 }
 function getAnchor(doc, ref) {
   const node = findVectorNode(doc.nodes, ref.nodeId);
-  return _optionalChain([node, 'optionalAccess', _100 => _100.type]) === "path" ? _optionalChain([node, 'access', _101 => _101.subpaths, 'access', _102 => _102[ref.subpath], 'optionalAccess', _103 => _103.anchors, 'access', _104 => _104[ref.index]]) : void 0;
+  return _optionalChain([node, 'optionalAccess', _130 => _130.type]) === "path" ? _optionalChain([node, 'access', _131 => _131.subpaths, 'access', _132 => _132[ref.subpath], 'optionalAccess', _133 => _133.anchors, 'access', _134 => _134[ref.index]]) : void 0;
 }
 function getAnchorWorld(doc, ref) {
   const a = getAnchor(doc, ref);
@@ -5281,55 +6209,61 @@ function spliceTree(nodes, id, replacements) {
   return changed ? out : nodes;
 }
 var toPoint2 = (p) => [p.x, p.y];
+var placementOf = (n) => ({
+  ...n.transform ? { transform: n.transform } : {},
+  ...n.visible === false ? { visible: false } : {},
+  ...n.locked ? { locked: true } : {},
+  ...n.booleanOperation ? { booleanOperation: n.booleanOperation } : {}
+});
 var isRoot = (m) => m === IDENTITY_MATRIX || m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0;
 var idCounter = 0;
 var defaultCreateId = () => `vn-${Date.now().toString(36)}${(++idCounter).toString(36)}`;
-var VectorEditorController = (_class3 = class {
+var VectorEditorController = (_class5 = class {
   
   
-  __init9() {this.selection = []}
-  __init10() {this.anchors = []}
-  __init11() {this.widthPoints = []}
-  __init12() {this.widthEdit = null}
-  __init13() {this.editingId = null}
-  __init14() {this.pen = null}
+  __init12() {this.selection = []}
+  __init13() {this.anchors = []}
+  __init14() {this.widthPoints = []}
+  __init15() {this.widthEdit = null}
+  __init16() {this.editingId = null}
+  __init17() {this.pen = null}
   
   
   
   
   
   
-  __init15() {this.hover = null}
-  __init16() {this.pointer = null}
-  __init17() {this.drag = null}
-  __init18() {this.interaction = null}
-  __init19() {this.guides = null}
+  __init18() {this.hover = null}
+  __init19() {this.pointer = null}
+  __init20() {this.drag = null}
+  __init21() {this.interaction = null}
+  __init22() {this.guides = null}
   /** Whether the last `snapDrawn` landed on an object (guides may be hidden). */
-  __init20() {this.snappedToObject = false}
+  __init23() {this.snappedToObject = false}
   /** Drawing targets for hovering the pen and shape tools, kept while the document and the excluded path stay the same. */
-  __init21() {this.hoverTargets = null}
-  __init22() {this.spaceHeld = false}
-  __init23() {this.clipboard = null}
+  __init24() {this.hoverTargets = null}
+  __init25() {this.spaceHeld = false}
+  __init26() {this.clipboard = null}
   /** Shape Builder map of the selection, kept while the document and the selection stay the same. */
-  __init24() {this.builderCache = null}
+  __init27() {this.builderCache = null}
   /** Paint bucket map of the visible outlines. */
-  __init25() {this.fillCache = null}
-  __init26() {this.builderPreview = null}
-  __init27() {this.blendStart = null}
+  __init28() {this.fillCache = null}
+  __init29() {this.builderPreview = null}
+  __init30() {this.blendStart = null}
   /** Options new blends get (the toolbars edit them along with the selected blend's). */
-  __init28() {this.blendDefaults = {}}
+  __init31() {this.blendDefaults = {}}
   /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
-  __init29() {this.builderHoverKey = null}
+  __init32() {this.builderHoverKey = null}
   
   
-  __init30() {this.listeners = /* @__PURE__ */ new Set()}
-  __init31() {this.cleanups = []}
-  __init32() {this.applying = false}
+  __init33() {this.listeners = /* @__PURE__ */ new Set()}
+  __init34() {this.cleanups = []}
+  __init35() {this.applying = false}
   /** Set while a commit records a change that was already applied, so `restore` still reports it. */
-  __init33() {this.committing = false}
-  __init34() {this.revision = 0}
+  __init36() {this.committing = false}
+  __init37() {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);_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);_class3.prototype.__init34.call(this);_class3.prototype.__init35.call(this);_class3.prototype.__init36.call(this);
+  constructor(options = {}) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);_class5.prototype.__init21.call(this);_class5.prototype.__init22.call(this);_class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this);_class5.prototype.__init25.call(this);_class5.prototype.__init26.call(this);_class5.prototype.__init27.call(this);_class5.prototype.__init28.call(this);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);_class5.prototype.__init32.call(this);_class5.prototype.__init33.call(this);_class5.prototype.__init34.call(this);_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);
     this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.HistoryManager)()));
     this.doc = options.document ? cloneVectorDocument(options.document) : { width: 800, height: 600, nodes: [] };
     this.doc = this.refreshed(this.doc);
@@ -5359,9 +6293,9 @@ var VectorEditorController = (_class3 = class {
   // State
   // -------------------------------------------------------------------------
   /** The current snapshot (stable until the next change). */
-  __init35() {this.getState = () => this.state}
+  __init38() {this.getState = () => this.state}
   /** Calls `listener` after every change. Returns an unsubscribe function. */
-  __init36() {this.subscribe = (listener) => {
+  __init39() {this.subscribe = (listener) => {
     this.listeners.add(listener);
     return () => {
       this.listeners.delete(listener);
@@ -5417,7 +6351,7 @@ var VectorEditorController = (_class3 = class {
     if (this.blendStart && !this.getNode(this.blendStart.nodeId)) this.blendStart = null;
     this.revision++;
     this.state = this.computeState();
-    if (docChanged) _optionalChain([this, 'access', _105 => _105.onChange, 'optionalCall', _106 => _106(this.doc)]);
+    if (docChanged) _optionalChain([this, 'access', _135 => _135.onChange, 'optionalCall', _136 => _136(this.doc)]);
     const state = this.state;
     this.listeners.forEach((listener) => {
       try {
@@ -5447,31 +6381,31 @@ var VectorEditorController = (_class3 = class {
     return applyMatrix(invertMatrix(this.worldOf(id, doc)), p);
   }
   cursorFor() {
-    if (_optionalChain([this, 'access', _107 => _107.drag, 'optionalAccess', _108 => _108.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
-    if (_optionalChain([this, 'access', _109 => _109.drag, 'optionalAccess', _110 => _110.kind]) === "rotate") return "grabbing";
-    if (_optionalChain([this, 'access', _111 => _111.drag, 'optionalAccess', _112 => _112.kind]) === "move") return "move";
+    if (_optionalChain([this, 'access', _137 => _137.drag, 'optionalAccess', _138 => _138.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
+    if (_optionalChain([this, 'access', _139 => _139.drag, 'optionalAccess', _140 => _140.kind]) === "rotate") return "grabbing";
+    if (_optionalChain([this, 'access', _141 => _141.drag, 'optionalAccess', _142 => _142.kind]) === "move") return "move";
     const h = this.hover;
     switch (this.tool) {
       case "select":
-        if (_optionalChain([h, 'optionalAccess', _113 => _113.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _114 => _114.frameOf, 'call', _115 => _115(this.selectedRoots()), 'optionalAccess', _116 => _116.angle]), () => ( 0)));
-        return _optionalChain([h, 'optionalAccess', _117 => _117.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _143 => _143.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _144 => _144.frameOf, 'call', _145 => _145(this.selectedRoots()), 'optionalAccess', _146 => _146.angle]), () => ( 0)));
+        return _optionalChain([h, 'optionalAccess', _147 => _147.nodeId]) ? "move" : "default";
       case "direct":
-        if (_optionalChain([h, 'optionalAccess', _118 => _118.anchor]) || _optionalChain([h, 'optionalAccess', _119 => _119.handle]) || _optionalChain([h, 'optionalAccess', _120 => _120.corner])) return "pointer";
-        if (_optionalChain([h, 'optionalAccess', _121 => _121.segment])) return "copy";
-        return _optionalChain([h, 'optionalAccess', _122 => _122.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _148 => _148.anchor]) || _optionalChain([h, 'optionalAccess', _149 => _149.handle]) || _optionalChain([h, 'optionalAccess', _150 => _150.corner])) return "pointer";
+        if (_optionalChain([h, 'optionalAccess', _151 => _151.segment])) return "copy";
+        return _optionalChain([h, 'optionalAccess', _152 => _152.nodeId]) ? "move" : "default";
       case "pen":
-        return _optionalChain([h, 'optionalAccess', _123 => _123.anchor]) ? "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _153 => _153.anchor]) ? "pointer" : "crosshair";
       case "width":
-        if (_optionalChain([this, 'access', _124 => _124.drag, 'optionalAccess', _125 => _125.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
-        if (_optionalChain([h, 'optionalAccess', _126 => _126.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
-        return _optionalChain([h, 'optionalAccess', _127 => _127.strokeSpot]) ? "copy" : "default";
+        if (_optionalChain([this, 'access', _154 => _154.drag, 'optionalAccess', _155 => _155.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
+        if (_optionalChain([h, 'optionalAccess', _156 => _156.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
+        return _optionalChain([h, 'optionalAccess', _157 => _157.strokeSpot]) ? "copy" : "default";
       case "shapeBuilder":
-        if (!_optionalChain([this, 'access', _128 => _128.builderPreview, 'optionalAccess', _129 => _129.faces, 'access', _130 => _130.length]) && !_optionalChain([this, 'access', _131 => _131.builderPreview, 'optionalAccess', _132 => _132.lines, 'access', _133 => _133.length])) return "crosshair";
+        if (!_optionalChain([this, 'access', _158 => _158.builderPreview, 'optionalAccess', _159 => _159.faces, 'access', _160 => _160.length]) && !_optionalChain([this, 'access', _161 => _161.builderPreview, 'optionalAccess', _162 => _162.lines, 'access', _163 => _163.length])) return "crosshair";
         return this.builderPreview.mode === "erase" ? "not-allowed" : "cell";
       case "paintBucket":
         return this.builderPreview ? "cell" : "crosshair";
       case "blend":
-        return _optionalChain([h, 'optionalAccess', _134 => _134.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _164 => _164.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
       default:
         return "crosshair";
     }
@@ -5492,11 +6426,11 @@ 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', _135 => _135.getNode, 'call', _136 => _136(s.pen.nodeId), 'optionalAccess', _137 => _137.subpaths, 'optionalAccess', _138 => _138[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _165 => _165.getNode, 'call', _166 => _166(s.pen.nodeId), 'optionalAccess', _167 => _167.subpaths, 'optionalAccess', _168 => _168[s.pen.subpath]]) ? s.pen : null;
       if (this.widthPoints.length) {
         const kept = this.widthPoints.filter((r) => {
           const n = this.getNode(r.nodeId);
-          return _optionalChain([n, 'optionalAccess', _139 => _139.type]) === "path" && !!_optionalChain([n, 'access', _140 => _140.strokeWidthProfile, 'optionalAccess', _141 => _141[r.index]]);
+          return _optionalChain([n, 'optionalAccess', _169 => _169.type]) === "path" && !!_optionalChain([n, 'access', _170 => _170.strokeWidthProfile, 'optionalAccess', _171 => _171[r.index]]);
         });
         if (kept.length !== this.widthPoints.length) this.widthPoints = kept;
       }
@@ -5505,8 +6439,11 @@ var VectorEditorController = (_class3 = class {
     }
     this.notify(docChanged);
   }
-  /** Records the change from `before` to the current state as one undo step. */
-  commit(name, before) {
+  /**
+   * Records the change from `before` to the current state as one undo step. Consecutive
+   * changes with the same `merge` key (a slider drag) fold into one step.
+   */
+  commit(name, before, merge) {
     this.doc = this.refreshed(this.doc);
     const after = this.snapshot();
     if (before.doc === after.doc) {
@@ -5517,17 +6454,23 @@ var VectorEditorController = (_class3 = class {
       name,
       execute: () => this.restore(after),
       undo: () => this.restore(before),
-      redo: () => this.restore(after)
+      redo: () => this.restore(after),
+      ...merge ? { tag: merge } : {}
     };
     this.committing = true;
-    this.history.execute(command);
+    if (merge) this.history.executeMerged(command, { key: merge });
+    else this.history.execute(command);
     this.committing = false;
   }
-  /** Runs `fn` (which updates fields) and records it as one undo step. */
-  change(name, fn) {
+  /** Runs `fn` (which updates fields) and records it as one undo step (merged by `merge` key). */
+  change(name, fn, merge) {
     const before = this.snapshot();
     fn();
-    this.commit(name, before);
+    this.commit(name, before, merge);
+  }
+  /** Ends a merged edit (a slider released): the next change starts a new undo step. */
+  endMergedEdit() {
+    this.history.endGesture();
   }
   setDoc(nodes) {
     if (nodes !== this.doc.nodes) this.doc = { ...this.doc, nodes };
@@ -5669,7 +6612,7 @@ var VectorEditorController = (_class3 = class {
       if (res.kind) {
         this.snappedToObject = true;
         this.setGuides(res);
-        return _optionalChain([leave, 'optionalAccess', _142 => _142.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', _172 => _172.constrain]) ? res.point : { x: res.x ? res.point.x : this.gridValue(res.point.x), y: res.y ? res.point.y : this.gridValue(res.point.y) };
       }
     }
     this.setGuides(null);
@@ -5687,14 +6630,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', _143 => _143.getNode, 'call', _144 => _144(this.pen.nodeId), 'optionalAccess', _145 => _145.subpaths, 'access', _146 => _146[this.pen.subpath]]) : void 0;
-      if (this.pen && sp && _optionalChain([this, 'access', _147 => _147.hover, 'optionalAccess', _148 => _148.anchor])) {
+      const sp = this.pen ? _optionalChain([this, 'access', _173 => _173.getNode, 'call', _174 => _174(this.pen.nodeId), 'optionalAccess', _175 => _175.subpaths, 'access', _176 => _176[this.pen.subpath]]) : void 0;
+      if (this.pen && sp && _optionalChain([this, 'access', _177 => _177.hover, 'optionalAccess', _178 => _178.anchor])) {
         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', _149 => _149.pen, 'optionalAccess', _150 => _150.nodeId]), () => ( null))));
+      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _179 => _179.pen, 'optionalAccess', _180 => _180.nodeId]), () => ( null))));
     }
     if (SHAPE_TOOLS.has(this.tool)) return this.snapDrawn(p, null, input, () => this.drawingTargets(null));
     this.setGuides(null);
@@ -5842,7 +6785,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', _151 => _151.strokeWidthProfile, 'optionalAccess', _152 => _152.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
+    if (_optionalChain([d, 'access', _181 => _181.strokeWidthProfile, 'optionalAccess', _182 => _182.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     return out;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -5897,7 +6840,7 @@ var VectorEditorController = (_class3 = class {
     const byNode = /* @__PURE__ */ new Map();
     for (const r of refs) {
       const node = this.getNode(r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _153 => _153.type]) !== "path" || !_optionalChain([node, 'access', _154 => _154.strokeWidthProfile, 'optionalAccess', _155 => _155[r.index]])) continue;
+      if (_optionalChain([node, 'optionalAccess', _183 => _183.type]) !== "path" || !_optionalChain([node, 'access', _184 => _184.strokeWidthProfile, 'optionalAccess', _185 => _185[r.index]])) continue;
       byNode.set(r.nodeId, [..._nullishCoalesce(byNode.get(r.nodeId), () => ( [])), r.index]);
     }
     if (!byNode.size) return { ok: false, message: "There is no such width point." };
@@ -5915,12 +6858,12 @@ var VectorEditorController = (_class3 = class {
   }
   /** Selects width points (width tool); points on other paths than the first are dropped. */
   selectWidthPoints(refs) {
-    const first = _optionalChain([refs, 'access', _156 => _156[0], 'optionalAccess', _157 => _157.nodeId]);
+    const first = _optionalChain([refs, 'access', _186 => _186[0], 'optionalAccess', _187 => _187.nodeId]);
     const next = [];
     for (const r of refs) {
       if (r.nodeId !== first || next.some((q) => q.index === r.index)) continue;
       const n = this.getNode(r.nodeId);
-      if (_optionalChain([n, 'optionalAccess', _158 => _158.type]) === "path" && _optionalChain([n, 'access', _159 => _159.strokeWidthProfile, 'optionalAccess', _160 => _160[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
+      if (_optionalChain([n, 'optionalAccess', _188 => _188.type]) === "path" && _optionalChain([n, 'access', _189 => _189.strokeWidthProfile, 'optionalAccess', _190 => _190[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
     }
     this.widthPoints = next;
     this.notify();
@@ -5935,7 +6878,7 @@ var VectorEditorController = (_class3 = class {
    */
   setWidthPoint(target, values) {
     const node = this.getNode(target.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _161 => _161.type]) !== "path") return { ok: false, message: "There is no such path." };
+    if (_optionalChain([node, 'optionalAccess', _191 => _191.type]) !== "path") return { ok: false, message: "There is no such path." };
     const g = vectorStrokeWidthGeometry(node);
     if (!g || !(g.unit > 0)) return { ok: false, message: "The path has no visible stroke." };
     const num = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? v2 : void 0;
@@ -5968,11 +6911,11 @@ var VectorEditorController = (_class3 = class {
         }
       }
     }
-    const subpath = _optionalChain([this, 'access', _162 => _162.widthEdit, 'optionalAccess', _163 => _163.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _164 => _164.widthPoints, 'access', _165 => _165.find, 'call', _166 => _166((r) => r.nodeId === node.id), 'optionalAccess', _167 => _167.subpath]), () => ( 0));
+    const subpath = _optionalChain([this, 'access', _192 => _192.widthEdit, 'optionalAccess', _193 => _193.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _194 => _194.widthPoints, 'access', _195 => _195.find, 'call', _196 => _196((r) => r.nodeId === node.id), 'optionalAccess', _197 => _197.subpath]), () => ( 0));
     const edit = this.widthEdit;
     this.change("Width Point", () => this.replaceNode(node.id, withStyle(node, { strokeWidthProfile: points })));
     this.widthPoints = [{ nodeId: node.id, index, subpath }];
-    if (_optionalChain([edit, 'optionalAccess', _168 => _168.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
+    if (_optionalChain([edit, 'optionalAccess', _198 => _198.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
     this.notify();
     return { ok: true };
   }
@@ -6006,7 +6949,7 @@ var VectorEditorController = (_class3 = class {
   /** The editor's view of point `index` (or of the stroke at `t` when index is null) of `nodeId`. */
   widthEditFor(nodeId, subpath, index, t) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _169 => _169.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _199 => _199.type]) !== "path") return null;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) return null;
     const profile = sanitizeWidthProfile(node.strokeWidthProfile);
@@ -6040,7 +6983,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', _170 => _170.corner, 'optionalAccess', _171 => _171.radius]), () => ( 0)), kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _200 => _200.corner, 'optionalAccess', _201 => _201.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
@@ -6077,7 +7020,7 @@ var VectorEditorController = (_class3 = class {
     const created = [];
     const replace = /* @__PURE__ */ new Map();
     for (const p of paths) {
-      const outline = bezierToSubpaths(vectorStrokeOutlinePath(subpathsToBezier(p.subpaths), p));
+      const outline = bezierToSubpaths(vectorStrokeOutlinePath(vectorAppearanceOutline(p), p));
       if (!outline.length) continue;
       const {
         stroke,
@@ -6092,11 +7035,12 @@ var VectorEditorController = (_class3 = class {
         startArrowScale: _ss,
         endArrowScale: _es,
         strokeWidthProfile: _wp,
+        effects,
         ...rest
       } = cloneVectorNode(p);
       const id = this.newId();
       const strokeNode = { ...rest, id, name: `${_nullishCoalesce(p.name, () => ( "Path"))} Stroke`, subpaths: outline, fill: _nullishCoalesce(stroke, () => ( null)), stroke: null, fillRule: "nonzero" };
-      const list = hasPaint(p.fill) ? [{ ...rest, stroke: null }, strokeNode] : [strokeNode];
+      const list = hasPaint(p.fill) ? [{ ...rest, ...effects ? { effects } : {}, stroke: null }, strokeNode] : [strokeNode];
       created.push(id);
       replace.set(p.id, list);
     }
@@ -6111,6 +7055,121 @@ var VectorEditorController = (_class3 = class {
     });
     return created;
   }
+  // -------------------------------------------------------------------------
+  // Path effects
+  // -------------------------------------------------------------------------
+  /** Selected (or given) nodes that can carry effects: the roots of the selection. */
+  effectTargets(ids) {
+    return (_nullishCoalesce(ids, () => ( this.selectedRoots()))).map((id) => this.getNode(id)).filter((n) => !!n && !n.blendStep);
+  }
+  /**
+   * Adds an effect of `type` to the selected (or given) nodes, at the bottom of each stack (or
+   * at `index`), with default parameters merged with `params`. A repeater's copies start one
+   * shape width apart. One undo step; returns the new effect ids (one per node, in order).
+   */
+  addEffect(type, options = {}) {
+    const targets = this.effectTargets(options.ids);
+    if (!targets.length || !createVectorEffect(type, "")) return [];
+    const created = [];
+    const next = /* @__PURE__ */ new Map();
+    for (const node of targets) {
+      const list = _nullishCoalesce(node.effects, () => ( []));
+      let k = list.length + 1;
+      while (list.some((e) => e.id === `fx${k}`)) k++;
+      const params = { ..._nullishCoalesce(options.params, () => ( {})) };
+      if (type === "repeater" && params.position === void 0) {
+        const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, vectorAppearanceOutline(node));
+        if (b && b.maxX - b.minX > 0) params.position = { x: Math.round((b.maxX - b.minX) * 1.25 * 100) / 100, y: 0 };
+      }
+      const effect = createVectorEffect(type, `fx${k}`, params);
+      const at2 = options.index === void 0 ? list.length : Math.min(list.length, Math.max(0, Math.round(options.index)));
+      next.set(node.id, { ...node, effects: [...list.slice(0, at2), effect, ...list.slice(at2)] });
+      created.push(effect.id);
+    }
+    this.change(`Add ${VECTOR_EFFECT_LABELS[type]}`, () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))));
+    return created;
+  }
+  editEffects(nodeId, label, fn, merge) {
+    const node = this.getNode(nodeId);
+    if (!node) return { ok: false, message: `There is no node "${nodeId}".` };
+    const result = fn(_nullishCoalesce(node.effects, () => ( [])));
+    if (typeof result === "string") return { ok: false, message: result };
+    this.change(label, () => this.replaceNode(nodeId, result.length ? { ...node, effects: result } : (({ effects: _e, ...rest }) => rest)(node)), merge);
+    return { ok: true };
+  }
+  /**
+   * Turns an effect on or off and changes its parameters (unknown or invalid values are
+   * ignored). With `merge` (true, or a key of your own), consecutive updates of the same effect
+   * fold into one undo step, as a slider drag should; call `endMergedEdit` when it ends.
+   */
+  updateEffect(nodeId, effectId, patch, options = {}) {
+    const merge = options.merge === true ? `effect:${nodeId}:${effectId}` : options.merge || void 0;
+    const node = this.getNode(nodeId);
+    const current = _optionalChain([node, 'optionalAccess', _202 => _202.effects, 'optionalAccess', _203 => _203.find, 'call', _204 => _204((e) => e.id === effectId)]);
+    const label = current ? _nullishCoalesce(VECTOR_EFFECT_LABELS[current.type], () => ( "Effect")) : "Effect";
+    return this.editEffects(
+      nodeId,
+      `Edit ${label}`,
+      (list) => {
+        const i = list.findIndex((e2) => e2.id === effectId);
+        if (i < 0) return `Node "${nodeId}" has no effect "${effectId}".`;
+        const e = list[i];
+        const params = patch.params ? normalizeVectorEffectParams(e.type, patch.params, e.params) : e.params;
+        const next = { ...e, params, ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {} };
+        if (next.enabled !== false) delete next.enabled;
+        return list.map((x, j) => j === i ? next : x);
+      },
+      merge
+    );
+  }
+  /** Removes an effect from a node's stack. */
+  removeEffect(nodeId, effectId) {
+    return this.editEffects(nodeId, "Remove Effect", (list) => list.some((e) => e.id === effectId) ? list.filter((e) => e.id !== effectId) : `Node "${nodeId}" has no effect "${effectId}".`);
+  }
+  /** Moves an effect to position `index` of its stack (0 is applied first). */
+  moveEffect(nodeId, effectId, index) {
+    return this.editEffects(nodeId, "Reorder Effects", (list) => {
+      const i = list.findIndex((e2) => e2.id === effectId);
+      if (i < 0) return `Node "${nodeId}" has no effect "${effectId}".`;
+      const to = Math.min(list.length - 1, Math.max(0, Math.round(index)));
+      const out = list.slice();
+      const [e] = out.splice(i, 1);
+      out.splice(to, 0, e);
+      return out;
+    });
+  }
+  /**
+   * Expand Appearance: bakes the path effects and live booleans of the selected (or given)
+   * nodes, and of everything inside them, into plain paths. A node keeps its id (a group when
+   * it draws as several shapes); the shapes it made get new ids. Returns the ids of the expanded
+   * nodes (empty when none was live).
+   */
+  expandAppearance(options = {}) {
+    const roots = (_nullishCoalesce(options.ids, () => ( this.selectedRoots()))).map((id) => this.getNode(id)).filter((n) => !!n && hasVectorAppearance(n));
+    if (!roots.length) return [];
+    const fresh = (n) => {
+      const id = n.id.includes("~fx") ? this.newId() : n.id;
+      return n.type === "group" ? { ...n, id, children: n.children.map(fresh) } : { ...n, id };
+    };
+    const bake = (n) => {
+      if (!hasVectorAppearance(n)) return n;
+      if (!hasOwnVectorAppearance(n)) return { ...n, children: n.children.map(bake) };
+      let e = expandVectorAppearance(n);
+      if (e.type === "group" && e.children.length === 1 && e.children[0].type === "path") {
+        const { id: _id, opacity, name, ...child } = e.children[0];
+        const k = (_nullishCoalesce(e.opacity, () => ( 1))) * (_nullishCoalesce(opacity, () => ( 1)));
+        e = { ...child, id: e.id, name: _nullishCoalesce(e.name, () => ( name)), ...placementOf(e), ...k < 1 ? { opacity: k } : {} };
+      }
+      return fresh(e);
+    };
+    const next = new Map(roots.map((n) => [n.id, bake(n)]));
+    this.change("Expand Appearance", () => {
+      this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n))));
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return roots.map((n) => n.id);
+  }
   rename(id, name) {
     return this.updateNode(id, { name }, { label: "Rename" });
   }
@@ -6179,10 +7238,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', _172 => _172.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _205 => _205.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _173 => _173(this.doc.nodes, parent.id), 'optionalAccess', _174 => _174.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _206 => _206(this.doc.nodes, parent.id), 'optionalAccess', _207 => _207.parent]), () => ( null));
       }
       return !covered;
     });
@@ -6365,8 +7424,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', _175 => _175[0], 'access', _176 => _176.parent, 'optionalAccess', _177 => _177.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _178 => _178.parent, 'optionalAccess', _179 => _179.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _208 => _208[0], 'access', _209 => _209.parent, 'optionalAccess', _210 => _210.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _211 => _211.parent, 'optionalAccess', _212 => _212.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -6389,7 +7448,7 @@ 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', _180 => _180.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _213 => _213.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", () => {
@@ -6402,7 +7461,7 @@ var VectorEditorController = (_class3 = class {
             const opacity = n.opacity;
             const m = nodeMatrix(n);
             out.push(
-              ...n.children.map((c) => c.blendStep ? (({ blendStep: _s, locked: _l, ...rest }) => rest)(c) : c).map((c) => n.transform ? transformVectorNode(c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c)
+              ...n.children.map((c) => c.blendStep ? (({ blendStep: _s, locked: _l, ...rest }) => rest)(c) : c).map((c) => c.booleanOperation ? (({ booleanOperation: _b, ...rest }) => rest)(c) : c).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 = flatten2(n.children);
@@ -6439,34 +7498,33 @@ var VectorEditorController = (_class3 = class {
   /**
    * Combines the selected paths (two or more) into one with a boolean operation. `subtract`
    * removes the upper shapes from the lowest one. The result takes the lowest shape's style
-   * and place.
+   * and place. Shapes take part as drawn (path effects and live booleans applied).
+   *
+   * With `live`, the operands stay editable instead: a lone live boolean group gets the
+   * operation (its operands follow it again), operands of live boolean groups get it as their
+   * own, and anything else (two or more nodes with one parent) is wrapped in a new live boolean
+   * group. Returns the result's (or the live group's) id, or null.
    */
   booleanOp(op, options = {}) {
     const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
-    const order = [];
-    walkVectorNodes(this.doc.nodes, (n) => {
-      if (roots.includes(n.id)) for (const p of collectPathNodes(n)) order.push(p.id);
-    });
-    const paths = [...new Set(order)].map((id2) => this.getNode(id2));
-    if (paths.length < 2) return null;
+    if (options.live) return this.liveBooleanOp(op, roots);
+    const entries = vectorPathEntries(this.doc, roots, { locked: true });
+    if (entries.length < 2) return null;
     const result = _chunkVNYRI265cjs.pathBoolean.call(void 0, 
       BOOLEAN_OPS[op],
-      paths.map((p) => ({
-        path: vectorPathWorldBezier(
-          { ...p, subpaths: p.subpaths.filter((s) => s.anchors.length > 1).map((s) => ({ ...s, closed: true })) },
-          _nullishCoalesce(vectorParentMatrix(this.doc.nodes, p.id), () => ( IDENTITY_MATRIX))
-        ),
-        fillRule: _nullishCoalesce(p.fillRule, () => ( "nonzero"))
+      entries.map((e) => ({
+        path: vectorPathWorldBezier({ ...e.node, subpaths: e.node.subpaths.filter((s) => s.anchors.length > 1).map((s) => ({ ...s, closed: true })) }, e.parent),
+        fillRule: _nullishCoalesce(e.node.fillRule, () => ( "nonzero"))
       }))
     );
-    const base = paths[0];
-    const anchorRoot = _nullishCoalesce(roots.find((r) => findVectorNode([this.getNode(r)], base.id)), () => ( base.id));
+    const base = entries[0].node;
+    const anchorRoot = _nullishCoalesce(roots.find((r) => this.holds(r, base.id)), () => ( base.id));
     const subpaths = bezierToSubpaths(this.intoParentSpace(anchorRoot, result.path));
     if (result.error || !subpaths.length) return null;
     const id = this.newId();
-    const { transform: _t, ...baseRest } = cloneVectorNode(base);
+    const { transform: _t, effects: _e, booleanOperation: _b, ...baseRest } = cloneVectorNode(base);
     const node = { ...baseRest, id, name: BOOLEAN_LABELS[op], subpaths };
-    const drop = /* @__PURE__ */ new Set([...paths.map((p) => p.id), ...roots]);
+    const drop = /* @__PURE__ */ new Set([...entries.map((e) => e.node.id), ...roots]);
     this.change(BOOLEAN_LABELS[op], () => {
       this.setDoc(mapTree(this.doc.nodes, (n) => n.id === anchorRoot ? node : drop.has(n.id) ? null : n));
       this.selection = [id];
@@ -6475,18 +7533,75 @@ var VectorEditorController = (_class3 = class {
     });
     return id;
   }
+  /** Whether stored node `rootId` holds `id` as drawn (`id` may be an expanded path inside it). */
+  holds(rootId, id) {
+    const n = this.getNode(rootId);
+    return !!n && (!!findVectorNode([n], id) || !!findVectorNode([expandVectorAppearance(n)], id));
+  }
+  liveBooleanOp(op, roots) {
+    const nodes = roots.map((id2) => this.getNode(id2));
+    if (!nodes.length || nodes.some((n) => !n)) return null;
+    const label = `Live ${BOOLEAN_LABELS[op]}`;
+    const lone = nodes.length === 1 ? nodes[0] : null;
+    if (isVectorLiveBoolean(lone)) {
+      const children = lone.children.map((c) => c.booleanOperation ? (({ booleanOperation: _b, ...rest }) => rest)(c) : c);
+      this.change(label, () => this.replaceNode(lone.id, { ...lone, liveBoolean: op, children }));
+      return lone.id;
+    }
+    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _214 => _214(this.doc.nodes, id2), 'optionalAccess', _215 => _215.parent]), () => ( null)));
+    if (parents.every((g) => isVectorLiveBoolean(g))) {
+      const set = new Set(roots);
+      this.change(
+        label,
+        () => this.setDoc(
+          mapTree(this.doc.nodes, (n) => {
+            if (n.type !== "group" || !n.liveBoolean || !n.children.some((c) => set.has(c.id))) return n;
+            const group = n;
+            const children = group.children.map((c) => {
+              if (!set.has(c.id)) return c;
+              const { booleanOperation: _b, ...rest } = c;
+              return op === group.liveBoolean ? rest : { ...rest, booleanOperation: op };
+            });
+            return { ...group, children };
+          })
+        )
+      );
+      return parents[0].id;
+    }
+    if (nodes.length < 2) return null;
+    const parent = _nullishCoalesce(_optionalChain([parents, 'access', _216 => _216[0], 'optionalAccess', _217 => _217.id]), () => ( null));
+    if (parents.some((g) => (_nullishCoalesce(_optionalChain([g, 'optionalAccess', _218 => _218.id]), () => ( null))) !== parent)) return null;
+    const id = this.newId();
+    this.change(label, () => {
+      const set = new Set(roots);
+      const wrap = (list) => {
+        const members = list.filter((n) => set.has(n.id)).map((c) => c.booleanOperation ? (({ booleanOperation: _b, ...rest }) => rest)(c) : c);
+        const top = Math.max(...list.map((n, i) => set.has(n.id) ? i : -1));
+        const out = [];
+        list.forEach((n, i) => {
+          if (i === top) out.push({ id, type: "group", name: BOOLEAN_LABELS[op], liveBoolean: op, children: members });
+          if (!set.has(n.id)) out.push(n);
+        });
+        return out;
+      };
+      if (parent === null) this.setDoc(wrap(this.doc.nodes));
+      else this.setDoc(mapTree(this.doc.nodes, (n) => n.id === parent && n.type === "group" ? { ...n, children: wrap(n.children) } : n));
+      this.selection = [id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return id;
+  }
   /** Joins the selected paths into one compound path (subpaths kept, lowest style). */
   combine(options = {}) {
     const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
-    const paths = [];
-    walkVectorNodes(this.doc.nodes, (n) => {
-      if (roots.includes(n.id)) paths.push(...collectPathNodes(n));
-    });
-    if (paths.length < 2) return null;
+    const entries = vectorPathEntries(this.doc, roots, { locked: true });
+    if (entries.length < 2) return null;
+    const paths = entries.map((e) => e.node);
     const id = this.newId();
-    const first = _nullishCoalesce(roots.find((r) => findVectorNode([this.getNode(r)], paths[0].id)), () => ( paths[0].id));
-    const subpaths = paths.flatMap((p) => bezierToSubpaths(this.intoParentSpace(first, vectorPathWorldBezier(p, _nullishCoalesce(vectorParentMatrix(this.doc.nodes, p.id), () => ( IDENTITY_MATRIX))))));
-    const { transform: _t, ...baseRest } = cloneVectorNode(paths[0]);
+    const first = _nullishCoalesce(roots.find((r) => this.holds(r, paths[0].id)), () => ( paths[0].id));
+    const subpaths = entries.flatMap((e) => bezierToSubpaths(this.intoParentSpace(first, vectorPathWorldBezier(e.node, e.parent))));
+    const { transform: _t, effects: _e, booleanOperation: _b, ...baseRest } = cloneVectorNode(paths[0]);
     const node = { ...baseRest, id, name: "Compound Path", subpaths };
     const drop = /* @__PURE__ */ new Set([...paths.map((p) => p.id), ...roots]);
     this.change("Combine", () => {
@@ -6503,7 +7618,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** Splits selected compound paths into one path per subpath. */
   breakApart(options = {}) {
-    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _181 => _181.type]) === "path" && n.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _219 => _219.type]) === "path" && n.subpaths.length > 1);
     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));
@@ -6541,10 +7656,7 @@ var VectorEditorController = (_class3 = class {
     const result = _chunkVNYRI265cjs.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 topRoot = _nullishCoalesce([...roots].reverse().find((r) => this.holds(r, 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);
@@ -6574,7 +7686,7 @@ var VectorEditorController = (_class3 = class {
     const out = /* @__PURE__ */ new Map();
     for (const id of _nullishCoalesce(ids, () => ( this.selection))) {
       const node = this.getNode(id);
-      const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _182 => _182(this.doc.nodes, id), 'optionalAccess', _183 => _183.parent]);
+      const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _220 => _220(this.doc.nodes, id), 'optionalAccess', _221 => _221.parent]);
       if (isVectorBlendGroup(group)) out.set(group.id, group);
     }
     return [...out.values()];
@@ -6592,8 +7704,8 @@ var VectorEditorController = (_class3 = class {
     });
     if (ids.length < 2) return null;
     const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _184 => _184[0], 'access', _185 => _185.parent, 'optionalAccess', _186 => _186.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _187 => _187.parent, 'optionalAccess', _188 => _188.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _222 => _222[0], 'access', _223 => _223.parent, 'optionalAccess', _224 => _224.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _225 => _225.parent, 'optionalAccess', _226 => _226.id]), () => ( null))) !== parent)) return null;
     const order = input.keepOrder ? ids : ids.slice().sort((a, b) => locs[ids.indexOf(a)].index - locs[ids.indexOf(b)].index);
     const blend = blendOptionsOf({ ...this.blendDefaults, ...input });
     if (input.starts) {
@@ -6635,7 +7747,7 @@ var VectorEditorController = (_class3 = class {
     const node = this.getNode(nodeId);
     if (!isVectorBlendGroup(group)) return { ok: false, message: `"${blendId}" is not a blend.` };
     if (!node || node.blendStep || node.locked || node.id === blendId) return { ok: false, message: `"${nodeId}" cannot be a key.` };
-    const parentOf = (id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _189 => _189(this.doc.nodes, id), 'optionalAccess', _190 => _190.parent, 'optionalAccess', _191 => _191.id]), () => ( null));
+    const parentOf = (id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _227 => _227(this.doc.nodes, id), 'optionalAccess', _228 => _228.parent, 'optionalAccess', _229 => _229.id]), () => ( null));
     if (parentOf(blendId) !== parentOf(nodeId)) return { ok: false, message: "The new key must sit beside the blend (same parent)." };
     const start = options.start;
     this.change("Blend", () => {
@@ -6705,7 +7817,7 @@ var VectorEditorController = (_class3 = class {
   replaceBlendSpine(options = {}) {
     const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
     const groups = this.blendTargets(roots);
-    const paths = roots.map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _192 => _192.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _193 => _193(this.doc.nodes, n.id), 'optionalAccess', _194 => _194.parent])));
+    const paths = roots.map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _230 => _230.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _231 => _231(this.doc.nodes, n.id), 'optionalAccess', _232 => _232.parent])));
     if (groups.length !== 1 || paths.length !== 1) return { ok: false, message: "Select one blend and one path to be its spine." };
     const group = groups[0];
     const path = paths[0];
@@ -6736,8 +7848,8 @@ var VectorEditorController = (_class3 = class {
   shapeBuilderMap(ids) {
     const roots = _nullishCoalesce(ids, () => ( this.selectedRoots()));
     const key = roots.join("\0");
-    if (_optionalChain([this, 'access', _195 => _195.builderCache, 'optionalAccess', _196 => _196.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
-    const entries = roots.length ? vectorPathEntries(this.doc, roots) : [];
+    if (_optionalChain([this, 'access', _233 => _233.builderCache, 'optionalAccess', _234 => _234.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
+    const entries = roots.length ? vectorPathEntries(this.doc, roots, { expand: false }) : [];
     const map = entries.length ? vectorShapeBuilderMap(entries) : null;
     this.builderCache = { doc: this.doc, key, map };
     return map;
@@ -6796,9 +7908,9 @@ var VectorEditorController = (_class3 = class {
         const list = [];
         const r = plan.replace.get(i);
         if (r === void 0) list.push(node);
-        else if (_optionalChain([r, 'optionalAccess', _197 => _197.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _198 => _198.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _199 => _199.kind]) === "pieces") {
+        else if (_optionalChain([r, 'optionalAccess', _235 => _235.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _236 => _236.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _237 => _237.kind]) === "pieces") {
           r.paths.forEach(
             (path, k) => list.push({ ...node, id: k === 0 ? node.id : this.newId(), subpaths: bezierToSubpaths(toLocal(path)).map((sp) => ({ ...sp, closed: false })) })
           );
@@ -6832,7 +7944,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** The paint bucket's map of the visible outlines, cached per document and gap. */
   fillMap(gap) {
-    if (_optionalChain([this, 'access', _200 => _200.fillCache, 'optionalAccess', _201 => _201.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
+    if (_optionalChain([this, 'access', _238 => _238.fillCache, 'optionalAccess', _239 => _239.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;
@@ -6846,8 +7958,8 @@ var VectorEditorController = (_class3 = class {
    */
   fillRegion(point, options = {}) {
     if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) return null;
-    const region = _optionalChain([this, 'access', _202 => _202.fillMap, 'call', _203 => _203(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _204 => _204.regionAt, 'call', _205 => _205([point.x, point.y])]);
-    if (!_optionalChain([region, 'optionalAccess', _206 => _206.length])) return null;
+    const region = _optionalChain([this, 'access', _240 => _240.fillMap, 'call', _241 => _241(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _242 => _242.regionAt, 'call', _243 => _243([point.x, point.y])]);
+    if (!_optionalChain([region, 'optionalAccess', _244 => _244.length])) return null;
     let below = null;
     const roots = new Set(this.selectedRoots());
     walkVectorNodes(this.doc.nodes, (n) => {
@@ -6873,7 +7985,7 @@ var VectorEditorController = (_class3 = class {
   /** Updates the Shape Builder / paint bucket highlight for the pointer at `p`; true when it changed. */
   hoverBuilder(p, alt) {
     if (this.tool === "paintBucket") {
-      const region = _nullishCoalesce(_optionalChain([this, 'access', _207 => _207.fillMap, 'call', _208 => _208(this.editing.fillGap), 'optionalAccess', _209 => _209.regionAt, 'call', _210 => _210([p.x, p.y])]), () => ( null));
+      const region = _nullishCoalesce(_optionalChain([this, 'access', _245 => _245.fillMap, 'call', _246 => _246(this.editing.fillGap), 'optionalAccess', _247 => _247.regionAt, 'call', _248 => _248([p.x, p.y])]), () => ( null));
       const key2 = region ? _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, region, { precision: 2 }) : null;
       if (key2 === this.builderHoverKey) return false;
       this.builderHoverKey = key2;
@@ -6981,7 +8093,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', _211 => _211.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _249 => _249.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);
@@ -6990,7 +8102,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', _212 => _212.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _250 => _250.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) };
@@ -7001,7 +8113,7 @@ var VectorEditorController = (_class3 = class {
    */
   bendSegment(ref, to, t = 0.5) {
     const node = this.getNode(ref.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _213 => _213.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _251 => _251.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", () => {
@@ -7036,7 +8148,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', _214 => _214.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _252 => _252.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);
@@ -7080,7 +8192,7 @@ var VectorEditorController = (_class3 = class {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n = this.getNode(nodeId);
-      return _optionalChain([n, 'optionalAccess', _215 => _215.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n, 'optionalAccess', _253 => _253.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", () => {
@@ -7101,7 +8213,7 @@ var VectorEditorController = (_class3 = class {
       this.setDoc(
         mapTree(
           this.doc.nodes,
-          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _216 => _216.strokeWidthProfile, 'optionalAccess', _217 => _217.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
+          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _254 => _254.strokeWidthProfile, 'optionalAccess', _255 => _255.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
         )
       );
       this.anchors = [];
@@ -7239,7 +8351,7 @@ var VectorEditorController = (_class3 = class {
    */
   cutPathAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _218 => _218.type]) !== "path" || node.locked) return null;
+    if (_optionalChain([node, 'optionalAccess', _256 => _256.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
     const hit = nearestSegment(node, local);
     if (!hit) return null;
@@ -7289,7 +8401,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', _219 => _219.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
+    if (_optionalChain([ids, 'optionalAccess', _257 => _257.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 = [];
@@ -7375,7 +8487,7 @@ var VectorEditorController = (_class3 = class {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _220 => _220.subpaths, 'access', _221 => _221[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _258 => _258.subpaths, 'access', _259 => _259[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -7419,19 +8531,19 @@ var VectorEditorController = (_class3 = class {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _222 => _222.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
-        } catch (e4) {
+          if (_optionalChain([data, 'optionalAccess', _260 => _260.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
+        } catch (e6) {
           nodes = null;
         }
       } else if (/<svg[\s>]/i.test(trimmed)) {
         try {
           nodes = parseVectorSvg(trimmed).nodes;
-        } catch (e5) {
+        } catch (e7) {
           nodes = null;
         }
       }
     } else nodes = this.clipboard;
-    if (!_optionalChain([nodes, 'optionalAccess', _223 => _223.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _261 => _261.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", () => {
@@ -7482,7 +8594,7 @@ var VectorEditorController = (_class3 = class {
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
       const a = getAnchorWorld(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _224 => _224[ref.handle]]);
+      const h = _optionalChain([a, 'optionalAccess', _262 => _262[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;
@@ -7521,16 +8633,22 @@ var VectorEditorController = (_class3 = class {
     return best;
   }
   /** Deepest unlocked visible path under `p`. */
+  /** Live groups being edited (selected, or holding the selection or the edited path): their children are hit as stored. */
+  enteredGroups() {
+    return vectorEnteredGroups(this.doc.nodes, this.editingId ? [...this.selection, this.editingId] : this.selection);
+  }
   hitPath(p) {
     const tol = this.tolerance();
+    const entered = this.enteredGroups();
     const search = (list, parent) => {
       for (let i = list.length - 1; i >= 0; i--) {
         const n = list[i];
         if (n.visible === false || n.locked) continue;
         if (n.type === "group") {
+          if (hasOwnVectorAppearance(n) && !entered.has(n.id) && !hitTestVectorNode(n, p, tol, parent, { entered })) continue;
           const found = search(n.children, multiplyMatrices(nodeMatrix(n), parent));
           if (found) return found;
-        } else if (hitTestVectorNode(n, p, tol, parent)) return n;
+        } else if (hitTestVectorNode(n, p, tol, parent, { entered })) return n;
       }
       return null;
     };
@@ -7555,7 +8673,7 @@ var VectorEditorController = (_class3 = class {
       case "select": {
         const handle = this.hitTransformHandle(screen);
         if (handle) return { nodeId: null, transformHandle: handle };
-        const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance());
+        const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
         return node ? { nodeId: node.id } : null;
       }
       case "direct": {
@@ -7608,7 +8726,7 @@ var VectorEditorController = (_class3 = class {
     const shown = this.hitWidthHandleIn(screen, this.widthView());
     if (shown) return shown;
     const spot = this.strokeSpotAt(this.screenToDocument(screen));
-    return spot && spot.nodeId !== _optionalChain([this, 'access', _225 => _225.hover, 'optionalAccess', _226 => _226.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
+    return spot && spot.nodeId !== _optionalChain([this, 'access', _263 => _263.hover, 'optionalAccess', _264 => _264.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
   }
   hitWidthHandleIn(screen, view) {
     let best = null;
@@ -7663,9 +8781,9 @@ var VectorEditorController = (_class3 = class {
   downWidth(screen, p, input) {
     const hit = this.hitWidthHandle(screen);
     const spot = hit ? null : this.strokeSpotAt(p);
-    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _227 => _227.ref, 'access', _228 => _228.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _229 => _229.nodeId])));
+    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _265 => _265.ref, 'access', _266 => _266.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _267 => _267.nodeId])));
     const node = nodeId ? this.getNode(nodeId) : void 0;
-    const g = _optionalChain([node, 'optionalAccess', _230 => _230.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
+    const g = _optionalChain([node, 'optionalAccess', _268 => _268.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
     if (this.widthEdit) this.widthEdit = null;
     if (!node || node.type !== "path" || !g) {
       if (!input.shift) this.widthPoints = [];
@@ -7685,7 +8803,7 @@ var VectorEditorController = (_class3 = class {
     if (hit) {
       profile = sanitizeWidthProfile(node.strokeWidthProfile);
       ref = { nodeId: node.id, index: hit.ref.index, subpath: hit.ref.subpath };
-      t = _nullishCoalesce(_optionalChain([profile, 'access', _231 => _231[ref.index], 'optionalAccess', _232 => _232.t]), () => ( 0));
+      t = _nullishCoalesce(_optionalChain([profile, 'access', _269 => _269[ref.index], 'optionalAccess', _270 => _270.t]), () => ( 0));
       subpath = hit.ref.subpath;
       if (hit.ref.part === "center") mode = input.alt && profile.length < VECTOR_WIDTH_PROFILE_MAX_POINTS ? "copy" : "move";
       else if (input.alt) side = hit.ref.part;
@@ -7840,7 +8958,7 @@ var VectorEditorController = (_class3 = class {
     let anchor = null;
     if (node.type === "path" && node.subpaths[0]) {
       const refs = node.subpaths[0].anchors.map((_, index) => ({ nodeId: node.id, subpath: 0, index }));
-      anchor = _nullishCoalesce(_optionalChain([this, 'access', _233 => _233.hitAnchor, 'call', _234 => _234(screen, refs), 'optionalAccess', _235 => _235.index]), () => ( null));
+      anchor = _nullishCoalesce(_optionalChain([this, 'access', _271 => _271.hitAnchor, 'call', _272 => _272(screen, refs), 'optionalAccess', _273 => _273.index]), () => ( null));
     }
     return { nodeId: node.id, anchor };
   }
@@ -7884,7 +9002,7 @@ var VectorEditorController = (_class3 = class {
       this.notify();
       return;
     }
-    const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance());
+    const node = hitTestVectorNodes(this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
     if (node) {
       const selected = this.selection.includes(node.id);
       if (input.shift) {
@@ -7993,7 +9111,7 @@ var VectorEditorController = (_class3 = class {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _236 => _236.getNode, 'call', _237 => _237(this.pen.nodeId), 'optionalAccess', _238 => _238.subpaths, 'access', _239 => _239[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _274 => _274.getNode, 'call', _275 => _275(this.pen.nodeId), 'optionalAccess', _276 => _276.subpaths, 'access', _277 => _277[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -8255,7 +9373,7 @@ var VectorEditorController = (_class3 = class {
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _240 => _240.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _278 => _278.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);
@@ -8329,14 +9447,14 @@ var VectorEditorController = (_class3 = class {
         for (const q of drag.lazy.push([p.x, p.y])) {
           if (Math.hypot(q[0] - last[0], q[1] - last[1]) * this.viewport.zoom < 1.5) continue;
           drag.points.push(q);
-          _optionalChain([drag, 'access', _241 => _241.pressures, 'optionalAccess', _242 => _242.push, 'call', _243 => _243(drag.pressure)]);
+          _optionalChain([drag, 'access', _279 => _279.pressures, 'optionalAccess', _280 => _280.push, 'call', _281 => _281(drag.pressure)]);
           moved = true;
         }
         const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _244 => _244.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _282 => _282.type]) !== "path") return;
         if (!moved) {
-          if (string && _optionalChain([this, 'access', _245 => _245.interaction, 'optionalAccess', _246 => _246.type]) === "draw") {
+          if (string && _optionalChain([this, 'access', _283 => _283.interaction, 'optionalAccess', _284 => _284.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();
           }
@@ -8372,8 +9490,8 @@ var VectorEditorController = (_class3 = class {
     }
     this.setGuides(res);
     return {
-      dx: _optionalChain([res, 'optionalAccess', _247 => _247.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
-      dy: _optionalChain([res, 'optionalAccess', _248 => _248.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+      dx: _optionalChain([res, 'optionalAccess', _285 => _285.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: _optionalChain([res, 'optionalAccess', _286 => _286.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
     };
   }
   /** The anchor a point drag snaps by, where it started: the grabbed one, else the moving one nearest the press. */
@@ -8452,7 +9570,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', _249 => _249.corner, 'optionalAccess', _250 => _250.radius]), () => ( 0)), kind));
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _287 => _287.corner, 'optionalAccess', _288 => _288.radius]), () => ( 0)), kind));
           return this.commit("Corner Kind", drag.before);
         }
         const ref = drag.widget.ref;
@@ -8467,7 +9585,7 @@ var VectorEditorController = (_class3 = class {
           const several = drag.group.length > 0;
           if (drag.mode === "copy") this.widthPoints = [drag.ref];
           else if (drag.mode === "move" && several) {
-            this.widthPoints = [drag.source, ...drag.group].map((i) => ({ ...drag.ref, index: _nullishCoalesce(_optionalChain([drag, 'access', _251 => _251.renumber, 'optionalAccess', _252 => _252.get, 'call', _253 => _253(i)]), () => ( i)) }));
+            this.widthPoints = [drag.source, ...drag.group].map((i) => ({ ...drag.ref, index: _nullishCoalesce(_optionalChain([drag, 'access', _289 => _289.renumber, 'optionalAccess', _290 => _290.get, 'call', _291 => _291(i)]), () => ( i)) }));
           } else if (!several) this.widthPoints = [drag.ref];
           const label = drag.mode === "copy" ? "Copy Width Point" : drag.mode === "move" ? several ? "Move Width Points" : "Move Width Point" : several ? "Width Points" : "Width Point";
           return this.commit(label, drag.before);
@@ -8509,14 +9627,14 @@ var VectorEditorController = (_class3 = class {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _254 => _254.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _292 => _292.type]) !== "path" || drag.points.length < 2) {
           this.doc = drag.before.doc;
           this.notify(true);
           return;
         }
         for (const q of drag.lazy.finish()) {
           drag.points.push(q);
-          _optionalChain([drag, 'access', _255 => _255.pressures, 'optionalAccess', _256 => _256.push, 'call', _257 => _257(drag.pressure)]);
+          _optionalChain([drag, 'access', _293 => _293.pressures, 'optionalAccess', _294 => _294.push, 'call', _295 => _295(drag.pressure)]);
         }
         const shape = this.editing.recognizeShapes ? recognizeInkShape(drag.points, { minSize: 6 / this.viewport.zoom }) : null;
         if (shape) {
@@ -8591,7 +9709,7 @@ var VectorEditorController = (_class3 = class {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _258 => _258.hover, 'optionalAccess', _259 => _259.segment, 'optionalAccess', _260 => _260.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _296 => _296.hover, 'optionalAccess', _297 => _297.segment, 'optionalAccess', _298 => _298.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
         const seg = node ? nearestSegment(node, this.toLocal(id, p)) : null;
@@ -8688,7 +9806,7 @@ var VectorEditorController = (_class3 = class {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _261 => _261.getNode, 'call', _262 => _262(this.selection[0]), 'optionalAccess', _263 => _263.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _299 => _299.getNode, 'call', _300 => _300(this.selection[0]), 'optionalAccess', _301 => _301.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -8734,7 +9852,7 @@ var VectorEditorController = (_class3 = class {
       this.notify();
     }
   }
-}, _class3);
+}, _class5);
 function inkShapeLabel(shape) {
   const name = vectorInkShapeName(shape);
   return name[0].toUpperCase() + name.slice(1);
@@ -8809,8 +9927,9 @@ function pencilPressureProfile(points, pressures) {
 var fmt = (n) => Math.round(n * 100) / 100;
 var fmtMatrix = (m) => `matrix(${m.map((n) => Math.round(n * 1e6) / 1e6).join(" ")})`;
 var VECTOR_BUILDER_HATCH_GAP = 6;
-function renderNode(node, defs, idPrefix) {
-  if (node.visible === false) return null;
+function renderNode(stored, defs, idPrefix) {
+  if (stored.visible === false) return null;
+  const node = expandVectorAppearance(stored);
   if (node.type === "group") {
     const children = node.children.map((c) => renderNode(c, defs, idPrefix)).filter((c) => !!c);
     return { kind: "group", id: node.id, ...node.transform ? { transform: fmtMatrix(node.transform) } : {}, opacity: _nullishCoalesce(node.opacity, () => ( 1)), children };
@@ -8831,7 +9950,7 @@ function renderNode(node, defs, idPrefix) {
     strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)),
     ...node.strokeLinecap ? { strokeLinecap: node.strokeLinecap } : {},
     ...node.strokeLinejoin ? { strokeLinejoin: node.strokeLinejoin } : {},
-    ..._optionalChain([node, 'access', _264 => _264.strokeDasharray, 'optionalAccess', _265 => _265.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
+    ..._optionalChain([node, 'access', _302 => _302.strokeDasharray, 'optionalAccess', _303 => _303.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1))
   };
@@ -8851,16 +9970,20 @@ function getVectorSceneRenderData(state, options = {}) {
   };
 }
 var toScreen = (state, p) => ({ x: p.x * state.viewport.zoom + state.viewport.x, y: p.y * state.viewport.zoom + state.viewport.y });
-function screenOutline(state, node) {
+function screenOutline(state, node, entered) {
   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 }) => _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, _chunkVNYRI265cjs.transformBezierPath.call(void 0, vectorPathWorldBezier(path, m), view), { precision: 2 })).join(" ");
+  return outlinePaths(node, parent, entered).map((path) => _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, _chunkVNYRI265cjs.transformBezierPath.call(void 0, path, view), { precision: 2 })).join(" ");
 }
-function collectWithMatrix(node, parent) {
-  if (node.type === "path") return [{ path: node, parent }];
+function outlinePaths(node, parent, entered) {
+  if (node.type === "path") return [vectorPathWorldBezier(node, parent, { effects: false })];
   const m = multiplyMatrices(nodeMatrix(node), parent);
-  return node.children.flatMap((c) => collectWithMatrix(c, m));
+  if (hasOwnVectorAppearance(node) && !entered.has(node.id)) return [_chunkVNYRI265cjs.transformBezierPath.call(void 0, vectorAppearanceOutline(node), m)];
+  return node.children.filter((c) => c.visible !== false).flatMap((c) => outlinePaths(c, m, entered));
+}
+function getVectorEnteredGroups(state) {
+  return vectorEnteredGroups(state.document.nodes, state.editingId ? [...state.selection, state.editingId] : state.selection);
 }
 function collect(node) {
   if (node.type === "path") return [node];
@@ -8870,19 +9993,20 @@ function getVectorOverlayRenderData(state) {
   const doc = state.document;
   const z = state.viewport.zoom;
   const outlines = [];
+  const entered = getVectorEnteredGroups(state);
   const seen = /* @__PURE__ */ new Set();
   const outline = (id, selected2) => {
     if (seen.has(id)) return;
     const node = findVectorNode(doc.nodes, id);
     if (!node || node.visible === false) return;
     seen.add(id);
-    outlines.push({ id, d: screenOutline(state, node), selected: selected2 });
+    outlines.push({ id, d: screenOutline(state, node, entered), selected: selected2 });
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _266 => _266.hover, 'optionalAccess', _267 => _267.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _304 => _304.hover, 'optionalAccess', _305 => _305.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _268 => _268.interaction, 'optionalAccess', _269 => _269.type]) !== "marquee") {
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _306 => _306.interaction, 'optionalAccess', _307 => _307.type]) !== "marquee") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
     selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
   }
@@ -8892,9 +10016,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', _270 => _270.hover, 'optionalAccess', _271 => _271.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', _308 => _308.hover, 'optionalAccess', _309 => _309.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _272 => _272.hover, 'optionalAccess', _273 => _273.anchor])) {
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _310 => _310.hover, 'optionalAccess', _311 => _311.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
@@ -8903,15 +10027,15 @@ function getVectorOverlayRenderData(state) {
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
     const a = getAnchorWorld(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _274 => _274[ref.handle]]);
+    const h = _optionalChain([a, 'optionalAccess', _312 => _312[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _275 => _275.hover, 'optionalAccess', _276 => _276.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _313 => _313.hover, 'optionalAccess', _314 => _314.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', _277 => _277.interaction, 'optionalAccess', _278 => _278.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _315 => _315.interaction, 'optionalAccess', _316 => _316.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 };
@@ -8919,7 +10043,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', _279 => _279.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _317 => _317.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);
@@ -8932,9 +10056,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', _280 => _280.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _281 => _281.type]) === "move" || _optionalChain([it, 'optionalAccess', _282 => _282.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _283 => _283.type]) === "scale" || _optionalChain([it, 'optionalAccess', _284 => _284.type]) === "draw") {
+  if (_optionalChain([it, 'optionalAccess', _318 => _318.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _319 => _319.type]) === "move" || _optionalChain([it, 'optionalAccess', _320 => _320.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _321 => _321.type]) === "scale" || _optionalChain([it, 'optionalAccess', _322 => _322.type]) === "draw") {
     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)}`;
   }
@@ -8951,24 +10075,24 @@ function getVectorOverlayRenderData(state) {
     }
   }
   let toolStroke = null;
-  if (_optionalChain([it, 'optionalAccess', _285 => _285.type]) === "stroke") {
+  if (_optionalChain([it, 'optionalAccess', _323 => _323.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', _286 => _286.type]) === "draw" && it.string) {
+  if (_optionalChain([it, 'optionalAccess', _324 => _324.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', _287 => _287.type]) === "corner" ? it.ref : null;
+  const dragged = _optionalChain([it, 'optionalAccess', _325 => _325.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', _288 => _288.hover, 'optionalAccess', _289 => _289.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', _326 => _326.hover, 'optionalAccess', _327 => _327.corner]), w.ref), active: !!dragged };
   });
-  if (_optionalChain([it, 'optionalAccess', _290 => _290.type]) === "corner") status = `R ${fmt(it.radius)}`;
-  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _291 => _291.hover, 'optionalAccess', _292 => _292.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  if (_optionalChain([it, 'optionalAccess', _328 => _328.type]) === "corner") status = `R ${fmt(it.radius)}`;
+  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _329 => _329.hover, 'optionalAccess', _330 => _330.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
   const sc = (p) => {
     const q = toScreen(state, p);
     return { x: fmt(q.x), y: fmt(q.y) };
@@ -8976,13 +10100,13 @@ function getVectorOverlayRenderData(state) {
   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', _293 => _293.hover, 'optionalAccess', _294 => _294.widthPoint]);
+    const hw = _optionalChain([state, 'access', _331 => _331.hover, 'optionalAccess', _332 => _332.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', _295 => _295.type]) === "width" && sameWidth(it.ref, h.ref) };
+    return { ref: h.ref, x: c.x, y: c.y, left: sc(h.left), right: sc(h.right), selected: h.selected, hovered, active: _optionalChain([it, 'optionalAccess', _333 => _333.type]) === "width" && sameWidth(it.ref, h.ref) };
   });
-  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _296 => _296.hover, 'optionalAccess', _297 => _297.strokeSpot]) : null;
+  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _334 => _334.hover, 'optionalAccess', _335 => _335.strokeSpot]) : null;
   const widthSpot = spot ? { ...sc(spot.point), left: sc(spot.left), right: sc(spot.right) } : null;
-  if (_optionalChain([it, 'optionalAccess', _298 => _298.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt(it.width)}`;
+  if (_optionalChain([it, 'optionalAccess', _336 => _336.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt(it.width)}`;
   let builder = null;
   if (state.builder) {
     const v2 = state.viewport;
@@ -8998,7 +10122,7 @@ function getVectorOverlayRenderData(state) {
       lines: state.builder.lines.map((l) => svg(_chunkVNYRI265cjs.transformBezierPath.call(void 0, l, view))),
       trail
     };
-    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _299 => _299.type]) === "builder") {
+    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _337 => _337.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"}`;
     }
@@ -9011,7 +10135,7 @@ function selectedBlends(state) {
   const out = /* @__PURE__ */ new Map();
   for (const id of state.selection) {
     const node = findVectorNode(state.document.nodes, id);
-    const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _300 => _300(state.document.nodes, id), 'optionalAccess', _301 => _301.parent]);
+    const group = isVectorBlendGroup(node) ? node : _optionalChain([locateVectorNode, 'call', _338 => _338(state.document.nodes, id), 'optionalAccess', _339 => _339.parent]);
     if (isVectorBlendGroup(group)) out.set(group.id, group);
   }
   return [...out.values()];
@@ -9041,13 +10165,13 @@ function blendOverlay(state) {
     const from = state.blendStart ? findVectorNode(doc.nodes, state.blendStart.nodeId) : void 0;
     if (from && state.blendStart) {
       const a = state.blendStart.anchor === null ? void 0 : getAnchorWorld(doc, { nodeId: from.id, subpath: 0, index: state.blendStart.anchor });
-      start = { d: screenOutline(state, from), anchor: a ? sc(a, view) : null };
+      start = { d: screenOutline(state, from, /* @__PURE__ */ new Set()), anchor: a ? sc(a, view) : null };
     }
-    const hovered = _optionalChain([state, 'access', _302 => _302.hover, 'optionalAccess', _303 => _303.nodeId]) ? findVectorNode(doc.nodes, state.hover.nodeId) : void 0;
-    if (_optionalChain([hovered, 'optionalAccess', _304 => _304.type]) === "path" && hovered.subpaths[0]) {
+    const hovered = _optionalChain([state, 'access', _340 => _340.hover, 'optionalAccess', _341 => _341.nodeId]) ? findVectorNode(doc.nodes, state.hover.nodeId) : void 0;
+    if (_optionalChain([hovered, 'optionalAccess', _342 => _342.type]) === "path" && hovered.subpaths[0]) {
       hovered.subpaths[0].anchors.forEach((_, index) => {
         const a = getAnchorWorld(doc, { nodeId: hovered.id, subpath: 0, index });
-        if (a) anchors.push({ ...sc(a, view), hovered: _optionalChain([state, 'access', _305 => _305.hover, 'optionalAccess', _306 => _306.anchor, 'optionalAccess', _307 => _307.index]) === index });
+        if (a) anchors.push({ ...sc(a, view), hovered: _optionalChain([state, 'access', _343 => _343.hover, 'optionalAccess', _344 => _344.anchor, 'optionalAccess', _345 => _345.index]) === index });
       });
     }
   }
@@ -9058,17 +10182,17 @@ function getVectorBlendControls(state) {
   const doc = state.document;
   const roots = state.selection.filter((id) => {
     const node = findVectorNode(doc.nodes, id);
-    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([locateVectorNode, 'call', _308 => _308(doc.nodes, id), 'optionalAccess', _309 => _309.parent, 'optionalAccess', _310 => _310.id]), () => ( "")));
+    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([locateVectorNode, 'call', _346 => _346(doc.nodes, id), 'optionalAccess', _347 => _347.parent, 'optionalAccess', _348 => _348.id]), () => ( "")));
   });
-  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _311 => _311(doc.nodes, id), 'optionalAccess', _312 => _312.parent, 'optionalAccess', _313 => _313.id]), () => ( null))));
-  const paths = roots.filter((id) => _optionalChain([findVectorNode, 'call', _314 => _314(doc.nodes, id), 'optionalAccess', _315 => _315.type]) === "path" && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _316 => _316(doc.nodes, id), 'optionalAccess', _317 => _317.parent])));
+  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _349 => _349(doc.nodes, id), 'optionalAccess', _350 => _350.parent, 'optionalAccess', _351 => _351.id]), () => ( null))));
+  const paths = roots.filter((id) => _optionalChain([findVectorNode, 'call', _352 => _352(doc.nodes, id), 'optionalAccess', _353 => _353.type]) === "path" && !isVectorBlendGroup(_optionalChain([locateVectorNode, 'call', _354 => _354(doc.nodes, id), 'optionalAccess', _355 => _355.parent])));
   const first = blends[0];
   return {
     ids: blends.map((g) => g.id),
     options: resolveVectorBlendOptions(first ? first.blend : state.blendDefaults),
     canBlend: roots.length >= 2 && parents.size === 1,
     canReplaceSpine: blends.length === 1 && paths.length === 1,
-    hasSpine: !!_optionalChain([first, 'optionalAccess', _318 => _318.blend, 'optionalAccess', _319 => _319.spine])
+    hasSpine: !!_optionalChain([first, 'optionalAccess', _356 => _356.blend, 'optionalAccess', _357 => _357.spine])
   };
 }
 function applyVectorBlendOptions(controller, patch) {
@@ -9121,7 +10245,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', _320 => _320.getAttribute, 'optionalCall', _321 => _321("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _358 => _358.getAttribute, 'optionalCall', _359 => _359("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -9129,12 +10253,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', _322 => _322.selectedAnchors, 'optionalAccess', _323 => _323.length]);
+  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _360 => _360.selectedAnchors, 'optionalAccess', _361 => _361.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', _324 => _324.type]) === "path") paths.push(node);
+      if (_optionalChain([node, 'optionalAccess', _362 => _362.type]) === "path") paths.push(node);
     }
   }
   if (!paths.length) return null;
@@ -9145,7 +10269,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', _325 => _325.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _326 => _326.kind]), () => ( "round")) });
+      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _363 => _363.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _364 => _364.kind]), () => ( "round")) });
     }
   }
   const c0 = _nullishCoalesce(corners2[0], () => ( { radius: 0, kind: "round" }));
@@ -9226,8 +10350,28 @@ var VECTOR_EDIT_TOGGLES = [
   { key: "curvatureMoves", label: "Curv", title: "Curvature point moves (Alt flips while dragging)" },
   { key: "recognizeShapes", label: "Shapes", title: "Turn pencil scribbles into shapes" }
 ];
+var VECTOR_EFFECT_MENU = VECTOR_EFFECT_TYPES.map((type) => ({ type, label: VECTOR_EFFECT_LABELS[type] }));
+function getVectorEffectsPanel(state) {
+  const nodes = state.selection.map((id) => findVectorNode(state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
+  if (!nodes.length) return null;
+  const one = nodes.length === 1 ? nodes[0] : null;
+  return {
+    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _365 => _365.id]), () => ( null)),
+    count: nodes.length,
+    effects: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _366 => _366.effects]), () => ( []))).map((e) => ({
+      id: e.id,
+      type: e.type,
+      label: _nullishCoalesce(VECTOR_EFFECT_LABELS[e.type], () => ( e.type)),
+      enabled: e.enabled !== false,
+      params: e.params,
+      specs: _nullishCoalesce(VECTOR_EFFECT_PARAM_SPECS[e.type], () => ( []))
+    })),
+    expandable: nodes.some(hasVectorAppearance)
+  };
+}
 
 // src/vector/commands.ts
+var EFFECT_PARAMS_DESCRIPTION = "Effect parameters (missing ones keep their value or default). trim: start, end (percent), offset (degrees), mode simultaneous|individual. roundCorners: radius. puckerBloat: amount (\u2212100\u2026100). twist: angle, center {x, y} (offset from the middle). zigzag: size, ridges, smooth. wiggle: size, detail, smooth, speed, correlation, phase, seed, time (seconds). offset: amount, join miter|round|bevel, miterLimit, copies, copyOffset. merge: mode merge|add|subtract|intersect|exclude. repeater: copies (fractions fade the last), offset, position {x, y}, anchor {x, y} (offset from the middle), rotation, scale {x, y} (percent), startOpacity, endOpacity (percent), composite below|above.";
 var fail = (message) => {
   throw new Error(message);
 };
@@ -9268,9 +10412,9 @@ var BLEND_PROPS = {
   linear: { type: "boolean", description: "Move anchors in straight lines instead of the rotation-aware morph." }
 };
 var checkBlendOptions = (params) => {
-  if (_optionalChain([params, 'optionalAccess', _327 => _327.spacing]) !== void 0 && !VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
-  if (_optionalChain([params, 'optionalAccess', _328 => _328.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
-  if (_optionalChain([params, 'optionalAccess', _329 => _329.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
+  if (_optionalChain([params, 'optionalAccess', _367 => _367.spacing]) !== void 0 && !VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
+  if (_optionalChain([params, 'optionalAccess', _368 => _368.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
+  if (_optionalChain([params, 'optionalAccess', _369 => _369.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
 };
 var PAINT = {
   description: 'A CSS colour, `null` for none, or a gradient `{ type: "linear", angle, stops: [{ offset, color }] }`.'
@@ -9305,17 +10449,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', _330 => _330.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _370 => _370.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', _331 => _331.ids, 'optionalAccess', _332 => _332.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _371 => _371.ids, 'optionalAccess', _372 => _372.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', _333 => _333.type]) !== "path" || !_optionalChain([node, 'access', _334 => _334.subpaths, 'access', _335 => _335[r.subpath], 'optionalAccess', _336 => _336.anchors, 'access', _337 => _337[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+      if (_optionalChain([node, 'optionalAccess', _373 => _373.type]) !== "path" || !_optionalChain([node, 'access', _374 => _374.subpaths, 'access', _375 => _375[r.subpath], 'optionalAccess', _376 => _376.anchors, 'access', _377 => _377[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
     }
     return refs;
   };
@@ -9338,7 +10482,10 @@ function createVectorCommands(controller, options = {}) {
           selected: state.selection.includes(n.id),
           ...n.type === "path" ? { fill: _nullishCoalesce(n.fill, () => ( null)), stroke: _nullishCoalesce(n.stroke, () => ( null)), strokeWidth: _nullishCoalesce(n.strokeWidth, () => ( 1)), d: vectorPathData(n, 2) } : { children: n.children.length },
           ...n.type === "group" && n.blend ? { blend: { ...resolveVectorBlendOptions(n.blend), spine: !!n.blend.spine, keys: vectorBlendKeys(n).map((k) => k.id) } } : {},
-          ...n.blendStep ? { blendStep: true } : {}
+          ...n.blendStep ? { blendStep: true } : {},
+          ..._optionalChain([n, 'access', _378 => _378.effects, 'optionalAccess', _379 => _379.length]) ? { effects: n.effects } : {},
+          ...n.type === "group" && n.liveBoolean ? { liveBoolean: n.liveBoolean } : {},
+          ...n.booleanOperation ? { booleanOperation: n.booleanOperation } : {}
         });
         if (n.type === "group") visit(n.children, depth + 1);
       }
@@ -9408,7 +10555,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', _338 => _338.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _380 => _380.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -9440,10 +10587,10 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { radius: { type: "number", minimum: 0 }, kind: { type: "string", enum: VECTOR_CORNER_KINDS }, ids: IDS, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        const refs = _optionalChain([params, 'optionalAccess', _339 => _339.anchors]) ? anchorsOf(params.anchors) : void 0;
-        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _340 => _340.ids]) ? ids(params) : void 0 };
-        if (_optionalChain([params, 'optionalAccess', _341 => _341.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
-        else if (_optionalChain([params, 'optionalAccess', _342 => _342.kind])) check(controller.setCornerKind(params.kind, target));
+        const refs = _optionalChain([params, 'optionalAccess', _381 => _381.anchors]) ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _382 => _382.ids]) ? ids(params) : void 0 };
+        if (_optionalChain([params, 'optionalAccess', _383 => _383.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
+        else if (_optionalChain([params, 'optionalAccess', _384 => _384.kind])) check(controller.setCornerKind(params.kind, target));
         else fail("Pass `radius` and / or `kind`.");
         return { ok: true };
       }
@@ -9478,12 +10625,12 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const target = { ids: ids(params) };
-        if (_optionalChain([params, 'optionalAccess', _343 => _343.preset])) check(controller.setWidthProfile(params.preset, target));
-        else if (_optionalChain([params, 'optionalAccess', _344 => _344.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
-        else if (_optionalChain([params, 'optionalAccess', _345 => _345.taper]) || _optionalChain([params, 'optionalAccess', _346 => _346.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
+        if (_optionalChain([params, 'optionalAccess', _385 => _385.preset])) check(controller.setWidthProfile(params.preset, target));
+        else if (_optionalChain([params, 'optionalAccess', _386 => _386.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
+        else if (_optionalChain([params, 'optionalAccess', _387 => _387.taper]) || _optionalChain([params, 'optionalAccess', _388 => _388.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
         else fail("Pass `preset`, `points`, `taper` or `wave`.");
         const node = controller.getNode(target.ids[0]);
-        return { ok: true, points: _optionalChain([node, 'optionalAccess', _347 => _347.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _389 => _389.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -9505,10 +10652,10 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        if (!_optionalChain([params, 'optionalAccess', _348 => _348.id])) fail("Pass the path `id`.");
+        if (!_optionalChain([params, 'optionalAccess', _390 => _390.id])) fail("Pass the path `id`.");
         check(controller.setWidthPoint({ nodeId: params.id, index: _nullishCoalesce(params.index, () => ( null)) }, { t: params.t, left: params.left, right: params.right }));
         const node = controller.getNode(params.id);
-        return { ok: true, points: _optionalChain([node, 'optionalAccess', _349 => _349.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _391 => _391.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -9521,7 +10668,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _350 => _350.ids]) ? ids(params) : void 0 });
+        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _392 => _392.ids]) ? ids(params) : void 0 });
         if (!created.length) fail("No selected path has a stroke.");
         return { ids: created };
       }
@@ -9574,15 +10721,101 @@ function createVectorCommands(controller, options = {}) {
       id: `${prefix}boolean`,
       label: "Boolean Operation\u2026",
       keywords: ["union", "unite", "subtract", "intersect", "exclude", "combine", "pathfinder"],
-      description: "Combines two or more paths with union, subtract (upper shapes from the lowest), intersect or exclude.",
-      params: { type: "object", properties: { operation: { type: "string", enum: ["union", "subtract", "intersect", "exclude"] }, ids: IDS }, required: ["operation"] },
+      description: "Combines two or more paths with union, subtract (upper shapes from the lowest), intersect or exclude. With `live`, the shapes stay editable operands of a live boolean group instead (a lone live group gets the operation; its operands get their own).",
+      params: {
+        type: "object",
+        properties: {
+          operation: { type: "string", enum: ["union", "subtract", "intersect", "exclude"] },
+          ids: IDS,
+          live: { type: "boolean", description: "Keep the operands editable in a live boolean group (default false: one new path)." }
+        },
+        required: ["operation"]
+      },
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.booleanOp(params.operation, { ids: ids(params) });
-        if (!id) fail("Select at least two overlapping paths (the result was empty).");
+        const id = controller.booleanOp(params.operation, { ids: ids(params), live: params.live });
+        if (!id) fail(params.live ? "Select two or more nodes with one parent, a live boolean group or its operands." : "Select at least two overlapping paths (the result was empty).");
         return { id };
       }
     },
+    {
+      ...base,
+      id: `${prefix}addEffect`,
+      label: "Add Path Effect\u2026",
+      keywords: ["effect", "trim", "round corners", "pucker", "bloat", "twist", "zig zag", "wiggle", "offset", "merge", "repeater", "appearance", "live"],
+      description: "Adds a live path effect to the bottom of the effect stack of nodes (paths or groups). Effects apply top to bottom; effects after a repeater act on its copies. Returns the new effect ids.",
+      params: {
+        type: "object",
+        properties: {
+          type: { type: "string", enum: VECTOR_EFFECT_TYPES },
+          params: { type: "object", description: EFFECT_PARAMS_DESCRIPTION },
+          index: { type: "integer", minimum: 0, description: "Position in the stack (default: last)." },
+          ids: IDS
+        },
+        required: ["type"]
+      },
+      undoable: true,
+      enabled: enabledFor,
+      run: (_ctx, params) => {
+        if (!VECTOR_EFFECT_TYPES.includes(params.type)) fail(`Unknown effect type "${params.type}".`);
+        const targets = ids(params);
+        const created = controller.addEffect(params.type, { ids: targets, params: params.params, index: params.index });
+        if (!created.length) fail("Nothing to add the effect to.");
+        return { effects: targets.map((id, i) => ({ nodeId: id, effectId: created[i] })) };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}updateEffect`,
+      label: "Edit Path Effect\u2026",
+      keywords: ["effect", "parameters", "enable", "disable", "reorder"],
+      description: "Changes a path effect: its parameters, whether it is enabled, and its position in the stack.",
+      params: {
+        type: "object",
+        properties: {
+          nodeId: { type: "string" },
+          effectId: { type: "string" },
+          params: { type: "object", description: EFFECT_PARAMS_DESCRIPTION },
+          enabled: { type: "boolean" },
+          index: { type: "integer", minimum: 0, description: "Move it to this position in the stack (0 applies first)." }
+        },
+        required: ["nodeId", "effectId"]
+      },
+      undoable: true,
+      run: (_ctx, params) => {
+        if (params.params !== void 0 || params.enabled !== void 0) check(controller.updateEffect(params.nodeId, params.effectId, { params: params.params, enabled: params.enabled }));
+        if (params.index !== void 0) check(controller.moveEffect(params.nodeId, params.effectId, params.index));
+        return { effects: _nullishCoalesce(_optionalChain([controller, 'access', _393 => _393.getNode, 'call', _394 => _394(params.nodeId), 'optionalAccess', _395 => _395.effects]), () => ( [])) };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}removeEffect`,
+      label: "Remove Path Effect",
+      keywords: ["effect", "delete"],
+      description: "Removes a path effect from a node.",
+      params: { type: "object", properties: { nodeId: { type: "string" }, effectId: { type: "string" } }, required: ["nodeId", "effectId"] },
+      undoable: true,
+      run: (_ctx, params) => {
+        check(controller.removeEffect(params.nodeId, params.effectId));
+        return { ok: true };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}expandAppearance`,
+      label: "Expand Appearance",
+      keywords: ["effects", "bake", "flatten", "live boolean", "expand"],
+      description: "Bakes the path effects and live booleans of nodes (and everything inside them) into plain paths.",
+      params: { type: "object", properties: { ids: IDS } },
+      undoable: true,
+      enabled: enabledFor,
+      run: (_ctx, params) => {
+        const expanded = controller.expandAppearance({ ids: ids(params) });
+        if (!expanded.length) fail("Nothing selected has path effects or a live boolean.");
+        return { ids: expanded };
+      }
+    },
     {
       ...base,
       id: `${prefix}blend`,
@@ -9616,7 +10849,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         checkBlendOptions(params);
-        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _351 => _351.ids]) });
+        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _396 => _396.ids]) });
         if (!r.ok) fail(r.message);
         return { ok: true };
       }
@@ -9630,7 +10863,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _352 => _352.ids]) });
+        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _397 => _397.ids]) });
         if (!groups.length) fail("Select a blend to expand.");
         return { ids: groups };
       }
@@ -9644,7 +10877,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _353 => _353.ids]) });
+        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _398 => _398.ids]) });
         if (!released.length) fail("Select a blend to release.");
         return { ids: released };
       }
@@ -9658,7 +10891,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _354 => _354.ids]) });
+        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _399 => _399.ids]) });
         if (!r.ok) fail(r.message);
         return { ok: true };
       }
@@ -9772,7 +11005,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _355 => _355.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _400 => _400.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -9800,7 +11033,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', _356 => _356.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _357 => _357.keepShape]) }));
+        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _401 => _401.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _402 => _402.keepShape]) }));
         return { ok: true };
       }
     },
@@ -9855,7 +11088,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', _358 => _358.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _359 => _359.tolerance]) }));
+        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _403 => _403.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _404 => _404.tolerance]) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -9869,7 +11102,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', _360 => _360.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _361 => _361.anchors]))));
+        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _405 => _405.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _406 => _406.anchors]))));
         return { ok: true };
       }
     },
@@ -9883,7 +11116,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _362 => _362.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _363 => _363.tolerance]) }));
+        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _407 => _407.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _408 => _408.tolerance]) }));
         return { ok: true };
       }
     },
@@ -9896,7 +11129,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', _364 => _364.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _365 => _365.amount]), refs: _optionalChain([params, 'optionalAccess', _366 => _366.anchors]) }));
+        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _409 => _409.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _410 => _410.amount]), refs: _optionalChain([params, 'optionalAccess', _411 => _411.anchors]) }));
         return { ok: true };
       }
     },
@@ -9909,14 +11142,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', _367 => _367.nodeId]) !== void 0) {
+        if (_optionalChain([params, 'optionalAccess', _412 => _412.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', _368 => _368.anchors]))));
+        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _413 => _413.anchors]))));
         return { ids: controller.getState().selection };
       }
     },
@@ -9967,7 +11200,7 @@ function createVectorCommands(controller, options = {}) {
       },
       run: (_ctx, params) => {
         const patch = {};
-        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _369 => _369[key]]) !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _414 => _414[key]]) !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -9992,7 +11225,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', _370 => _370.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _415 => _415.precision]) }) })
     },
     {
       ...base,
@@ -10244,5 +11477,47 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-exports.DEFAULT_VECTOR_BLEND_DISTANCE = DEFAULT_VECTOR_BLEND_DISTANCE; exports.DEFAULT_VECTOR_BLEND_STEPS = DEFAULT_VECTOR_BLEND_STEPS; exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BLEND_MAX_SMOOTH_STEPS = VECTOR_BLEND_MAX_SMOOTH_STEPS; exports.VECTOR_BLEND_MAX_STEPS = VECTOR_BLEND_MAX_STEPS; exports.VECTOR_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; exports.VECTOR_BLEND_SPACING_LABELS = VECTOR_BLEND_SPACING_LABELS; exports.VECTOR_BUILDER_HATCH_GAP = VECTOR_BUILDER_HATCH_GAP; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_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.applyVectorBlendOptions = applyVectorBlendOptions; 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.correspondMorphContours = correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorMorph = createVectorMorph; 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.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.generateVectorBlendChildren = generateVectorBlendChildren; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorBlendControls = getVectorBlendControls; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.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.interpolateMorphContours = interpolateMorphContours; exports.interpolateRigidMatrix = interpolateRigidMatrix; exports.interpolateVectorColor = interpolateVectorColor; exports.interpolateVectorPaint = interpolateVectorPaint; exports.interpolateVectorPaths = interpolateVectorPaths; exports.interpolateVectorStyle = interpolateVectorStyle; exports.interpolateWidthProfiles = interpolateWidthProfiles; exports.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mirrorWidthProfile = mirrorWidthProfile; exports.morphContourToSubpath = morphContourToSubpath; exports.morphPathsCross = morphPathsCross; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.refineMorphContour = refineMorphContour; exports.refreshVectorBlends = refreshVectorBlends; exports.releaseVectorBlend = releaseVectorBlend; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeWidthPoints = removeWidthPoints; exports.resampleGradientStops = resampleGradientStops; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = reverseMorphContour; 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.subpathToMorphContour = subpathToMorphContour; 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.turnMorphContour = turnMorphContour; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.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;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_VECTOR_BLEND_DISTANCE = DEFAULT_VECTOR_BLEND_DISTANCE; exports.DEFAULT_VECTOR_BLEND_STEPS = DEFAULT_VECTOR_BLEND_STEPS; exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BLEND_MAX_SMOOTH_STEPS = VECTOR_BLEND_MAX_SMOOTH_STEPS; exports.VECTOR_BLEND_MAX_STEPS = VECTOR_BLEND_MAX_STEPS; exports.VECTOR_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; exports.VECTOR_BLEND_SPACING_LABELS = VECTOR_BLEND_SPACING_LABELS; exports.VECTOR_BUILDER_HATCH_GAP = VECTOR_BUILDER_HATCH_GAP; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_EFFECT_DEFAULTS = VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_MENU = VECTOR_EFFECT_MENU; exports.VECTOR_EFFECT_PARAM_SPECS = VECTOR_EFFECT_PARAM_SPECS; exports.VECTOR_EFFECT_TYPES = VECTOR_EFFECT_TYPES; exports.VECTOR_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_MERGE_MODES = VECTOR_MERGE_MODES; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATHFINDER_ACTIONS = VECTOR_PATHFINDER_ACTIONS; exports.VECTOR_PATHFINDER_LABELS = VECTOR_PATHFINDER_LABELS; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.activeVectorEffects = activeVectorEffects; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorBlendOptions = applyVectorBlendOptions; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.applyVectorEffects = applyVectorEffects; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.clearVectorLiveBooleanCache = clearVectorLiveBooleanCache; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.correspondMorphContours = correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorEffect = createVectorEffect; exports.createVectorMorph = createVectorMorph; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.effectPathLength = effectPathLength; exports.effectPathVertexCount = effectPathVertexCount; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; exports.expandVectorAppearance = expandVectorAppearance; exports.expandVectorAppearances = expandVectorAppearances; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.foldVectorBooleanOperands = foldVectorBooleanOperands; exports.generateVectorBlendChildren = generateVectorBlendChildren; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorBlendControls = getVectorBlendControls; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorEffectsPanel = getVectorEffectsPanel; exports.getVectorEnteredGroups = getVectorEnteredGroups; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasOwnVectorAppearance = hasOwnVectorAppearance; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorAppearance = hasVectorAppearance; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertWidthPoint = insertWidthPoint; exports.interpolateMorphContours = interpolateMorphContours; exports.interpolateRigidMatrix = interpolateRigidMatrix; exports.interpolateVectorColor = interpolateVectorColor; exports.interpolateVectorPaint = interpolateVectorPaint; exports.interpolateVectorPaths = interpolateVectorPaths; exports.interpolateVectorStyle = interpolateVectorStyle; exports.interpolateWidthProfiles = interpolateWidthProfiles; exports.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorLiveBoolean = isVectorLiveBoolean; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mergePaths = mergePaths; exports.mirrorWidthProfile = mirrorWidthProfile; exports.morphContourToSubpath = morphContourToSubpath; exports.morphPathsCross = morphPathsCross; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.normalizeVectorEffectParams = normalizeVectorEffectParams; exports.offsetPaths = offsetPaths; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.pathsCenter = pathsCenter; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.puckerBloatPaths = puckerBloatPaths; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.refineMorphContour = refineMorphContour; exports.refreshVectorBlends = refreshVectorBlends; exports.releaseVectorBlend = releaseVectorBlend; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeWidthPoints = removeWidthPoints; exports.repeatPaths = repeatPaths; exports.resampleGradientStops = resampleGradientStops; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = reverseMorphContour; exports.reverseSubpath = reverseSubpath; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundCornerPaths = roundCornerPaths; exports.roundSubpaths = roundSubpaths; exports.samplePolyline = samplePolyline; exports.sanitizeVectorEffects = sanitizeVectorEffects; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.starSubpath = starSubpath; exports.strokePositionPoint = strokePositionPoint; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathToMorphContour = subpathToMorphContour; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorEffects = transformVectorEffects; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.trimIntervals = trimIntervals; exports.trimPaths = trimPaths; exports.trimPathsIndividually = trimPathsIndividually; exports.turnMorphContour = turnMorphContour; exports.twistPaths = twistPaths; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorAppearanceNodes = vectorAppearanceNodes; exports.vectorAppearanceOutline = vectorAppearanceOutline; exports.vectorAppearanceShapes = vectorAppearanceShapes; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorEnteredGroups = vectorEnteredGroups; exports.vectorFillMap = vectorFillMap; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorLiveBooleanSteps = vectorLiveBooleanSteps; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorOperandOperation = vectorOperandOperation; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorRepeaterCopies = vectorRepeaterCopies; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute; exports.wigglePaths = wigglePaths; exports.zigzagPaths = zigzagPaths;
 //# sourceMappingURL=index.cjs.map