@pixerate/editor 0.117.0 → 0.118.0

package/dist/vector/index.cjs

@@ -2167,7 +2167,24 @@ function renderText(node, defs, filters, idPrefix) {
     spans
   };
 }
+var renderCache = /* @__PURE__ */ new WeakMap();
 function renderNode(stored, defs, filters, idPrefix) {
+  const gen = _chunkFODKPD44cjs.vectorTextShaperGeneration.call(void 0, );
+  let byPrefix = renderCache.get(stored);
+  const hit = _optionalChain([byPrefix, 'optionalAccess', _62 => _62.get, 'call', _63 => _63(idPrefix)]);
+  if (hit && hit.gen === gen) {
+    defs.push(...hit.defs);
+    filters.push(...hit.filters);
+    return hit.node;
+  }
+  const d0 = defs.length;
+  const f0 = filters.length;
+  const node = renderNodeFresh(stored, defs, filters, idPrefix);
+  if (!byPrefix) renderCache.set(stored, byPrefix = /* @__PURE__ */ new Map());
+  byPrefix.set(idPrefix, { gen, node, defs: defs.slice(d0), filters: filters.slice(f0) });
+  return node;
+}
+function renderNodeFresh(stored, defs, filters, idPrefix) {
   if (stored.visible === false) return null;
   if (stored.type === "text" && !_chunkFODKPD44cjs.vectorTextHasOutlines.call(void 0, )) return renderText(stored, defs, filters, idPrefix);
   const node = _chunkFODKPD44cjs.expandVectorAppearance.call(void 0, stored);
@@ -2202,13 +2219,13 @@ function renderNode(stored, defs, filters, idPrefix) {
     const stroke2 = layers.filter((l) => l.kind === "stroke").at(-1);
     return {
       ...common,
-      fill: _nullishCoalesce(_optionalChain([fill2, 'optionalAccess', _62 => _62.fill]), () => ( "none")),
-      stroke: _nullishCoalesce(_optionalChain([stroke2, 'optionalAccess', _63 => _63.stroke]), () => ( "none")),
-      strokeWidth: _nullishCoalesce(_nullishCoalesce(_optionalChain([stroke2, 'optionalAccess', _64 => _64.strokeWidth]), () => ( node.strokeWidth)), () => ( 1)),
-      ..._optionalChain([stroke2, 'optionalAccess', _65 => _65.strokeLinecap]) ? { strokeLinecap: stroke2.strokeLinecap } : {},
-      ..._optionalChain([stroke2, 'optionalAccess', _66 => _66.strokeLinejoin]) ? { strokeLinejoin: stroke2.strokeLinejoin } : {},
-      ..._optionalChain([stroke2, 'optionalAccess', _67 => _67.strokeDasharray]) ? { strokeDasharray: stroke2.strokeDasharray } : {},
-      ..._optionalChain([stroke2, 'optionalAccess', _68 => _68.strokeParts]) ? { strokeParts: stroke2.strokeParts } : {},
+      fill: _nullishCoalesce(_optionalChain([fill2, 'optionalAccess', _64 => _64.fill]), () => ( "none")),
+      stroke: _nullishCoalesce(_optionalChain([stroke2, 'optionalAccess', _65 => _65.stroke]), () => ( "none")),
+      strokeWidth: _nullishCoalesce(_nullishCoalesce(_optionalChain([stroke2, 'optionalAccess', _66 => _66.strokeWidth]), () => ( node.strokeWidth)), () => ( 1)),
+      ..._optionalChain([stroke2, 'optionalAccess', _67 => _67.strokeLinecap]) ? { strokeLinecap: stroke2.strokeLinecap } : {},
+      ..._optionalChain([stroke2, 'optionalAccess', _68 => _68.strokeLinejoin]) ? { strokeLinejoin: stroke2.strokeLinejoin } : {},
+      ..._optionalChain([stroke2, 'optionalAccess', _69 => _69.strokeDasharray]) ? { strokeDasharray: stroke2.strokeDasharray } : {},
+      ..._optionalChain([stroke2, 'optionalAccess', _70 => _70.strokeParts]) ? { strokeParts: stroke2.strokeParts } : {},
       layers
     };
   }
@@ -2234,13 +2251,64 @@ function renderMask(group, defs, filters, idPrefix) {
   const source = renderNode(group.children[0], defs, filters, idPrefix);
   return { ...mask, nodes: source ? [source] : [] };
 }
+var collapsedCache = /* @__PURE__ */ new WeakMap();
+function collapsedNode(node, box, prefix) {
+  let byPrefix = collapsedCache.get(node);
+  if (_optionalChain([byPrefix, 'optionalAccess', _71 => _71.has, 'call', _72 => _72(prefix)])) return byPrefix.get(prefix);
+  let fill = null;
+  const look = (n2) => {
+    if (fill || n2.visible === false) return;
+    if (n2.type === "path" || n2.type === "text") {
+      const f = n2.fill;
+      if (typeof f === "string" && f !== "none") fill = f;
+      else if (_chunkFODKPD44cjs.isVectorGradient.call(void 0, f)) fill = _nullishCoalesce(_optionalChain([f, 'access', _73 => _73.stops, 'access', _74 => _74[0], 'optionalAccess', _75 => _75.color]), () => ( null));
+    } else if (n2.type === "group") n2.children.forEach(look);
+    else if (n2.type === "instance") (_nullishCoalesce(n2.art, () => ( []))).forEach(look);
+  };
+  look(node);
+  const out = fill ? { kind: "path", id: node.id, d: `M${fmt2(box.minX)} ${fmt2(box.minY)}H${fmt2(box.maxX)}V${fmt2(box.maxY)}H${fmt2(box.minX)}Z`, fill, stroke: "none", strokeWidth: 0, fillRule: "nonzero", opacity: _nullishCoalesce(node.opacity, () => ( 1)) } : null;
+  if (!byPrefix) collapsedCache.set(node, byPrefix = /* @__PURE__ */ new Map());
+  byPrefix.set(prefix, out);
+  return out;
+}
 function getVectorSceneRenderData(state, options = {}) {
   const defs = [];
   const filters = [];
   const prefix = _nullishCoalesce(options.idPrefix, () => ( "ve-"));
-  const nodes = state.document.nodes.map((n2) => renderNode(n2, defs, filters, prefix)).filter((n2) => !!n2);
   const v = state.viewport;
+  const all = state.document.nodes;
+  const stats = { nodes: all.length, culled: 0, collapsed: 0 };
+  let nodes;
+  const size = options.viewportSize;
+  if (size && size.width > 0 && size.height > 0 && v.zoom > 0) {
+    const z = v.zoom;
+    const pad = 2 / z;
+    const view = { minX: -v.x / z - pad, minY: -v.y / z - pad, maxX: (size.width - v.x) / z + pad, maxY: (size.height - v.y) / z + pad };
+    const lod = _nullishCoalesce(options.lod, () => ( 2));
+    const near = _chunkFODKPD44cjs.vectorNodesNear.call(void 0, all, { x: view.minX, y: view.minY, width: view.maxX - view.minX, height: view.maxY - view.minY });
+    stats.culled = all.length - near.length;
+    nodes = [];
+    for (const i of near) {
+      const n2 = all[i];
+      const box = _chunkFODKPD44cjs.vectorNodePaintBox.call(void 0, n2);
+      if (box && (box.maxX < view.minX || box.minX > view.maxX || box.maxY < view.minY || box.minY > view.maxY)) {
+        stats.culled++;
+        continue;
+      }
+      if (box && lod > 0 && n2.type !== "path" && n2.visible !== false && Math.max(box.maxX - box.minX, box.maxY - box.minY) * z < lod) {
+        const c = collapsedNode(n2, box, prefix);
+        if (c) {
+          stats.collapsed++;
+          nodes.push(c);
+          continue;
+        }
+      }
+      const r = renderNode(n2, defs, filters, prefix);
+      if (r) nodes.push(r);
+    }
+  } else nodes = all.map((n2) => renderNode(n2, defs, filters, prefix)).filter((n2) => !!n2);
   return {
+    stats,
     transform: `translate(${fmt2(v.x)} ${fmt2(v.y)}) scale(${v.zoom})`,
     width: state.document.width,
     height: state.document.height,
@@ -2305,13 +2373,13 @@ function shadingOverlay(state) {
 }
 function connectorSiteOverlay(state) {
   if (state.tool !== "connector" || !state.pointer) return [];
-  const drawing = _optionalChain([state, 'access', _69 => _69.interaction, 'optionalAccess', _70 => _70.type]) === "draw" && state.interaction.tool === "connector" ? state.interaction.nodeId : void 0;
+  const drawing = _optionalChain([state, 'access', _76 => _76.interaction, 'optionalAccess', _77 => _77.type]) === "draw" && state.interaction.tool === "connector" ? state.interaction.nodeId : void 0;
   const nodes = state.document.nodes;
   const target = _chunkFODKPD44cjs.vectorConnectorTargetAt.call(void 0, nodes, state.pointer, 12 / state.viewport.zoom, drawing);
   if (!target) return [];
   return _chunkFODKPD44cjs.vectorConnectionSites.call(void 0, nodes, target.nodeId).map((site) => {
     const p = toScreen(state, site);
-    return { nodeId: target.nodeId, side: site.side, x: p.x, y: p.y, active: _optionalChain([target, 'access', _71 => _71.site, 'optionalAccess', _72 => _72.side]) === site.side };
+    return { nodeId: target.nodeId, side: site.side, x: p.x, y: p.y, active: _optionalChain([target, 'access', _78 => _78.site, 'optionalAccess', _79 => _79.side]) === site.side };
   });
 }
 function frameLabels(state) {
@@ -2325,14 +2393,14 @@ function frameLabels(state) {
   return out;
 }
 function constraintOverlay(state) {
-  if (!_optionalChain([state, 'access', _73 => _73.document, 'access', _74 => _74.constraints, 'optionalAccess', _75 => _75.length])) return [];
+  if (!_optionalChain([state, 'access', _80 => _80.document, 'access', _81 => _81.constraints, 'optionalAccess', _82 => _82.length])) return [];
   const ids = /* @__PURE__ */ new Set([...state.selection, ...state.editingId ? [state.editingId] : [], ...state.selectedAnchors.map((a) => a.nodeId)]);
   for (const id of [...ids]) {
     const n2 = _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id);
-    if (_optionalChain([n2, 'optionalAccess', _76 => _76.type]) === "group") _chunkFODKPD44cjs.walkVectorNodes.call(void 0, n2.children, (c) => ids.add(c.id));
+    if (_optionalChain([n2, 'optionalAccess', _83 => _83.type]) === "group") _chunkFODKPD44cjs.walkVectorNodes.call(void 0, n2.children, (c) => ids.add(c.id));
   }
   if (!ids.size) return [];
-  const conflicts = new Set(_nullishCoalesce(_optionalChain([state, 'access', _77 => _77.constraintIssues, 'optionalAccess', _78 => _78.conflicts]), () => ( [])));
+  const conflicts = new Set(_nullishCoalesce(_optionalChain([state, 'access', _84 => _84.constraintIssues, 'optionalAccess', _85 => _85.conflicts]), () => ( [])));
   return vectorConstraintGlyphs(state.document, ids).map((g) => {
     const at = toScreen(state, g.at);
     const d = g.dimension ? { a: toScreen(state, g.dimension.a), b: toScreen(state, g.dimension.b) } : null;
@@ -2341,10 +2409,10 @@ function constraintOverlay(state) {
 }
 function textOverlay(state) {
   const edit = state.textEdit;
-  const id = _nullishCoalesce(_optionalChain([edit, 'optionalAccess', _79 => _79.nodeId]), () => ( (state.tool === "type" || state.tool === "typePath" ? state.selection.find((s) => _optionalChain([_chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, s), 'optionalAccess', _80 => _80.type]) === "text") : void 0)));
+  const id = _nullishCoalesce(_optionalChain([edit, 'optionalAccess', _86 => _86.nodeId]), () => ( (state.tool === "type" || state.tool === "typePath" ? state.selection.find((s) => _optionalChain([_chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, s), 'optionalAccess', _87 => _87.type]) === "text") : void 0)));
   if (!id) return null;
   const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id);
-  if (_optionalChain([node, 'optionalAccess', _81 => _81.type]) !== "text") return null;
+  if (_optionalChain([node, 'optionalAccess', _88 => _88.type]) !== "text") return null;
   const world = _nullishCoalesce(_chunkFODKPD44cjs.vectorWorldMatrix.call(void 0, state.document.nodes, id), () => ( _chunkFODKPD44cjs.IDENTITY_MATRIX));
   const v = state.viewport;
   const m = _chunkFODKPD44cjs.multiplyMatrices.call(void 0, world, [v.zoom, 0, 0, v.zoom, v.x, v.y]);
@@ -2394,9 +2462,9 @@ function getVectorOverlayRenderData(state) {
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _82 => _82.hover, 'optionalAccess', _83 => _83.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _89 => _89.hover, 'optionalAccess', _90 => _90.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _84 => _84.interaction, 'optionalAccess', _85 => _85.type]) !== "marquee" && _optionalChain([state, 'access', _86 => _86.interaction, 'optionalAccess', _87 => _87.type]) !== "distort") {
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _91 => _91.interaction, 'optionalAccess', _92 => _92.type]) !== "marquee" && _optionalChain([state, 'access', _93 => _93.interaction, 'optionalAccess', _94 => _94.type]) !== "distort") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
     selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles, freeDistort: state.freeDistort };
   }
@@ -2406,9 +2474,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, () => ( _chunkFODKPD44cjs.inferAnchorType.call(void 0, a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _88 => _88.hover, 'optionalAccess', _89 => _89.anchor]), ref), closes };
+    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( _chunkFODKPD44cjs.inferAnchorType.call(void 0, a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _95 => _95.hover, 'optionalAccess', _96 => _96.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _90 => _90.hover, 'optionalAccess', _91 => _91.anchor])) {
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _97 => _97.hover, 'optionalAccess', _98 => _98.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
@@ -2417,15 +2485,15 @@ function getVectorOverlayRenderData(state) {
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
     const a = getAnchorWorld(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _92 => _92[ref.handle]]);
+    const h = _optionalChain([a, 'optionalAccess', _99 => _99[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _93 => _93.hover, 'optionalAccess', _94 => _94.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _100 => _100.hover, 'optionalAccess', _101 => _101.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', _95 => _95.interaction, 'optionalAccess', _96 => _96.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _102 => _102.interaction, 'optionalAccess', _103 => _103.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 };
@@ -2433,7 +2501,7 @@ function getVectorOverlayRenderData(state) {
   let penPreview = null;
   if (state.tool === "pen" && state.pen && state.pointer && !state.interaction) {
     const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _97 => _97.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _104 => _104.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);
@@ -2454,9 +2522,9 @@ function getVectorOverlayRenderData(state) {
   }
   let status = null;
   const it = state.interaction;
-  if (_optionalChain([it, 'optionalAccess', _98 => _98.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _99 => _99.type]) === "move" || _optionalChain([it, 'optionalAccess', _100 => _100.type]) === "anchors") status = `\u0394 ${fmt2(it.dx)}, ${fmt2(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _101 => _101.type]) === "scale" || _optionalChain([it, 'optionalAccess', _102 => _102.type]) === "draw") {
+  if (_optionalChain([it, 'optionalAccess', _105 => _105.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _106 => _106.type]) === "move" || _optionalChain([it, 'optionalAccess', _107 => _107.type]) === "anchors") status = `\u0394 ${fmt2(it.dx)}, ${fmt2(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _108 => _108.type]) === "scale" || _optionalChain([it, 'optionalAccess', _109 => _109.type]) === "draw") {
     const b = it.type === "draw" ? _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, it.nodeId) ? _chunkFODKPD44cjs.vectorNodeBounds.call(void 0, _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, it.nodeId)) : null : state.selectionFrame;
     if (b) status = `W ${fmt2(b.width)} \xD7 H ${fmt2(b.height)}`;
   }
@@ -2473,24 +2541,24 @@ function getVectorOverlayRenderData(state) {
     }
   }
   let toolStroke = null;
-  if (_optionalChain([it, 'optionalAccess', _103 => _103.type]) === "stroke") {
+  if (_optionalChain([it, 'optionalAccess', _110 => _110.type]) === "stroke") {
     const pts = it.points.map((q) => toScreen(state, q));
     const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt2(q.x)} ${fmt2(q.y)}`).join("") + (pts.length === 1 ? `L${fmt2(pts[0].x)} ${fmt2(pts[0].y)}` : "");
     toolStroke = { tool: it.tool, d, width: fmt2(it.width * z) };
   }
   let pencilString = null;
-  if (_optionalChain([it, 'optionalAccess', _104 => _104.type]) === "draw" && it.string) {
+  if (_optionalChain([it, 'optionalAccess', _111 => _111.type]) === "draw" && it.string) {
     const a = toScreen(state, it.string[0]);
     const b = toScreen(state, it.string[1]);
     pencilString = { x1: fmt2(a.x), y1: fmt2(a.y), x2: fmt2(b.x), y2: fmt2(b.y) };
   }
-  const dragged = _optionalChain([it, 'optionalAccess', _105 => _105.type]) === "corner" ? it.ref : null;
+  const dragged = _optionalChain([it, 'optionalAccess', _112 => _112.type]) === "corner" ? it.ref : null;
   const cornerWidgets = getVectorCornerWidgets(state).map((w) => {
     const s = toScreen(state, w);
-    return { ref: w.ref, x: fmt2(s.x), y: fmt2(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _106 => _106.hover, 'optionalAccess', _107 => _107.corner]), w.ref), active: !!dragged };
+    return { ref: w.ref, x: fmt2(s.x), y: fmt2(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _113 => _113.hover, 'optionalAccess', _114 => _114.corner]), w.ref), active: !!dragged };
   });
-  if (_optionalChain([it, 'optionalAccess', _108 => _108.type]) === "corner") status = `R ${fmt2(it.radius)}`;
-  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _109 => _109.hover, 'optionalAccess', _110 => _110.segment]) && !it ? (({ x, y }) => ({ x: fmt2(x), y: fmt2(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  if (_optionalChain([it, 'optionalAccess', _115 => _115.type]) === "corner") status = `R ${fmt2(it.radius)}`;
+  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _116 => _116.hover, 'optionalAccess', _117 => _117.segment]) && !it ? (({ x, y }) => ({ x: fmt2(x), y: fmt2(y) }))(toScreen(state, state.hover.segment.point)) : null;
   const sc = (p) => {
     const q = toScreen(state, p);
     return { x: fmt2(q.x), y: fmt2(q.y) };
@@ -2498,13 +2566,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', _111 => _111.hover, 'optionalAccess', _112 => _112.widthPoint]);
+    const hw = _optionalChain([state, 'access', _118 => _118.hover, 'optionalAccess', _119 => _119.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', _113 => _113.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', _120 => _120.type]) === "width" && sameWidth(it.ref, h.ref) };
   });
-  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _114 => _114.hover, 'optionalAccess', _115 => _115.strokeSpot]) : null;
+  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _121 => _121.hover, 'optionalAccess', _122 => _122.strokeSpot]) : null;
   const widthSpot = spot ? { ...sc(spot.point), left: sc(spot.left), right: sc(spot.right) } : null;
-  if (_optionalChain([it, 'optionalAccess', _116 => _116.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt2(it.width)}`;
+  if (_optionalChain([it, 'optionalAccess', _123 => _123.type]) === "width") status = it.mode === "move" ? "Move width point" : it.mode === "copy" ? "Copy width point" : `W ${fmt2(it.width)}`;
   let builder = null;
   if (state.builder) {
     const v = state.viewport;
@@ -2520,7 +2588,7 @@ function getVectorOverlayRenderData(state) {
       lines: state.builder.lines.map((l) => svg(_chunkXGD3FSNCcjs.transformBezierPath.call(void 0, l, view))),
       trail
     };
-    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _117 => _117.type]) === "builder") {
+    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _124 => _124.type]) === "builder") {
       const n2 = state.builder.faces.length;
       status = state.builder.mode === "erase" ? `Delete ${n2} ${n2 === 1 ? "face" : "faces"}` : `Merge ${n2} ${n2 === 1 ? "face" : "faces"}`;
     }
@@ -2531,10 +2599,10 @@ function getVectorOverlayRenderData(state) {
   if (state.tool === "gradient") {
     gradient = gradientOverlay(state);
     if (!gradient && !it) status = "Drag across a shape to set a gradient";
-    else if (_optionalChain([it, 'optionalAccess', _118 => _118.type]) === "gradient" && it.removing) status = "Release to delete the stop";
+    else if (_optionalChain([it, 'optionalAccess', _125 => _125.type]) === "gradient" && it.removing) status = "Release to delete the stop";
   }
   let distort = null;
-  if (_optionalChain([it, 'optionalAccess', _119 => _119.type]) === "distort") {
+  if (_optionalChain([it, 'optionalAccess', _126 => _126.type]) === "distort") {
     const corners2 = it.corners.map(sc);
     distort = { mode: it.mode, corners: corners2, d: corners2.map((c, i) => `${i ? "L" : "M"}${c.x} ${c.y}`).join("") + "Z" };
     status = it.mode === "skew" ? "Skew" : it.mode === "perspective" ? "Perspective" : "Distort";
@@ -2542,7 +2610,7 @@ function getVectorOverlayRenderData(state) {
   const envelope = state.tool === "envelope" ? envelopeOverlay(state) : null;
   if (state.tool === "envelope" && !envelope && !it) status = "Select an object with an envelope to edit its mesh";
   let textBox = null;
-  if (_optionalChain([state, 'access', _120 => _120.interaction, 'optionalAccess', _121 => _121.type]) === "textBox") {
+  if (_optionalChain([state, 'access', _127 => _127.interaction, 'optionalAccess', _128 => _128.type]) === "textBox") {
     const b = state.interaction.bounds;
     const tl = toScreen(state, b);
     textBox = { x: tl.x, y: tl.y, width: b.width * z, height: b.height * z };
@@ -2618,9 +2686,9 @@ function envelopeOverlay(state) {
     const [a, b, cc, d] = c.map(sc);
     return `M${a.x} ${a.y}C${b.x} ${b.y} ${cc.x} ${cc.y} ${d.x} ${d.y}`;
   }).join("");
-  const hover = _optionalChain([state, 'access', _122 => _122.hover, 'optionalAccess', _123 => _123.envelope, 'optionalAccess', _124 => _124.nodeId]) === target.node.id ? state.hover.envelope.index : void 0;
+  const hover = _optionalChain([state, 'access', _129 => _129.hover, 'optionalAccess', _130 => _130.envelope, 'optionalAccess', _131 => _131.nodeId]) === target.node.id ? state.hover.envelope.index : void 0;
   const it = state.interaction;
-  const active = _optionalChain([it, 'optionalAccess', _125 => _125.type]) === "envelope" && it.nodeId === target.node.id ? it.index : void 0;
+  const active = _optionalChain([it, 'optionalAccess', _132 => _132.type]) === "envelope" && it.nodeId === target.node.id ? it.index : void 0;
   const pts = _chunkFODKPD44cjs.warpMeshEditPoints.call(void 0, mesh);
   return {
     nodeId: target.node.id,
@@ -2640,27 +2708,27 @@ function getVectorEnvelopePanel(state) {
   const nodes = state.selection.map((id) => _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id)).filter((n2) => !!n2 && !n2.blendStep);
   if (!nodes.length) return null;
   const one = nodes.length === 1 ? nodes[0] : null;
-  const first = _optionalChain([one, 'optionalAccess', _126 => _126.effects, 'optionalAccess', _127 => _127.find, 'call', _128 => _128((e) => e.type === "envelope")]);
+  const first = _optionalChain([one, 'optionalAccess', _133 => _133.effects, 'optionalAccess', _134 => _134.find, 'call', _135 => _135((e) => e.type === "envelope")]);
   const order = /* @__PURE__ */ new Map();
   _chunkFODKPD44cjs.walkVectorNodes.call(void 0, state.document.nodes, (n2) => order.set(n2.id, order.size));
   const top = nodes.length > 1 ? nodes.slice().sort((a, b) => (_nullishCoalesce(order.get(a.id), () => ( 0))) - (_nullishCoalesce(order.get(b.id), () => ( 0))))[nodes.length - 1] : null;
   return {
-    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _129 => _129.id]), () => ( null)),
+    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _136 => _136.id]), () => ( null)),
     count: nodes.length,
-    envelope: _optionalChain([first, 'optionalAccess', _130 => _130.type]) === "envelope" ? { effectId: first.id, enabled: first.enabled !== false, params: first.params } : null,
+    envelope: _optionalChain([first, 'optionalAccess', _137 => _137.type]) === "envelope" ? { effectId: first.id, enabled: first.enabled !== false, params: first.params } : null,
     canMake: nodes.some((n2) => !n2.locked),
-    canMakeWithTopObject: _optionalChain([top, 'optionalAccess', _131 => _131.type]) === "path" && top.subpaths.some((sp) => sp.closed && sp.anchors.length > 1),
-    canRelease: nodes.some((n2) => !n2.locked && !!_optionalChain([n2, 'access', _132 => _132.effects, 'optionalAccess', _133 => _133.some, 'call', _134 => _134((e) => e.type === "envelope")]))
+    canMakeWithTopObject: _optionalChain([top, 'optionalAccess', _138 => _138.type]) === "path" && top.subpaths.some((sp) => sp.closed && sp.anchors.length > 1),
+    canRelease: nodes.some((n2) => !n2.locked && !!_optionalChain([n2, 'access', _139 => _139.effects, 'optionalAccess', _140 => _140.some, 'call', _141 => _141((e) => e.type === "envelope")]))
   };
 }
 function gradientOverlay(state) {
   const a = getVectorGradientAnnotator(state.document, state.selection, state.viewport, state.gradientEdit.target, _nullishCoalesce(state.gradientEdit.layer, () => ( null)));
   if (!a) return null;
-  const hover = state.interaction ? null : _optionalChain([state, 'access', _135 => _135.hover, 'optionalAccess', _136 => _136.gradient]);
-  const handleHovered = (h) => _optionalChain([hover, 'optionalAccess', _137 => _137.kind]) === "handle" && hover.handle === h;
+  const hover = state.interaction ? null : _optionalChain([state, 'access', _142 => _142.hover, 'optionalAccess', _143 => _143.gradient]);
+  const handleHovered = (h) => _optionalChain([hover, 'optionalAccess', _144 => _144.kind]) === "handle" && hover.handle === h;
   const pt2 = (p) => ({ x: fmt2(p.x), y: fmt2(p.y) });
   const centred = _chunkFODKPD44cjs.isCentredVectorGradient.call(void 0, a.gradient.type);
-  const removing = _optionalChain([state, 'access', _138 => _138.interaction, 'optionalAccess', _139 => _139.type]) === "gradient" && !!state.interaction.removing;
+  const removing = _optionalChain([state, 'access', _145 => _145.interaction, 'optionalAccess', _146 => _146.type]) === "gradient" && !!state.interaction.removing;
   return {
     nodeId: a.nodeId,
     type: a.gradient.type,
@@ -2676,9 +2744,9 @@ function gradientOverlay(state) {
       color: s.color,
       opacity: _nullishCoalesce(s.opacity, () => ( 1)),
       selected: state.gradientEdit.stop === s.index,
-      hovered: _optionalChain([hover, 'optionalAccess', _140 => _140.kind]) === "stop" && hover.index === s.index
+      hovered: _optionalChain([hover, 'optionalAccess', _147 => _147.kind]) === "stop" && hover.index === s.index
     })),
-    midpoints: a.midpoints.map((m) => ({ index: m.index, ...pt2(m), hovered: _optionalChain([hover, 'optionalAccess', _141 => _141.kind]) === "midpoint" && hover.index === m.index })),
+    midpoints: a.midpoints.map((m) => ({ index: m.index, ...pt2(m), hovered: _optionalChain([hover, 'optionalAccess', _148 => _148.kind]) === "midpoint" && hover.index === m.index })),
     extent: a.extent,
     removing
   };
@@ -2687,7 +2755,7 @@ function selectedBlends(state) {
   const out = /* @__PURE__ */ new Map();
   for (const id of state.selection) {
     const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id);
-    const group = isVectorBlendGroup(node) ? node : _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, state.document.nodes, id), 'optionalAccess', _142 => _142.parent]);
+    const group = isVectorBlendGroup(node) ? node : _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, state.document.nodes, id), 'optionalAccess', _149 => _149.parent]);
     if (isVectorBlendGroup(group)) out.set(group.id, group);
   }
   return [...out.values()];
@@ -2719,11 +2787,11 @@ function blendOverlay(state) {
       const a = state.blendStart.anchor === null ? void 0 : getAnchorWorld(doc, { nodeId: from.id, subpath: 0, index: state.blendStart.anchor });
       start = { d: screenOutline(state, from, /* @__PURE__ */ new Set()), anchor: a ? sc(a, view) : null };
     }
-    const hovered = _optionalChain([state, 'access', _143 => _143.hover, 'optionalAccess', _144 => _144.nodeId]) ? _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, state.hover.nodeId) : void 0;
-    if (_optionalChain([hovered, 'optionalAccess', _145 => _145.type]) === "path" && hovered.subpaths[0]) {
+    const hovered = _optionalChain([state, 'access', _150 => _150.hover, 'optionalAccess', _151 => _151.nodeId]) ? _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, state.hover.nodeId) : void 0;
+    if (_optionalChain([hovered, 'optionalAccess', _152 => _152.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', _146 => _146.hover, 'optionalAccess', _147 => _147.anchor, 'optionalAccess', _148 => _148.index]) === index });
+        if (a) anchors.push({ ...sc(a, view), hovered: _optionalChain([state, 'access', _153 => _153.hover, 'optionalAccess', _154 => _154.anchor, 'optionalAccess', _155 => _155.index]) === index });
       });
     }
   }
@@ -2734,17 +2802,17 @@ function getVectorBlendControls(state) {
   const doc = state.document;
   const roots = state.selection.filter((id) => {
     const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, id);
-    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _149 => _149.parent, 'optionalAccess', _150 => _150.id]), () => ( "")));
+    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _156 => _156.parent, 'optionalAccess', _157 => _157.id]), () => ( "")));
   });
-  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _151 => _151.parent, 'optionalAccess', _152 => _152.id]), () => ( null))));
-  const paths = roots.filter((id) => _optionalChain([_chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _153 => _153.type]) === "path" && !isVectorBlendGroup(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _154 => _154.parent])));
+  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _158 => _158.parent, 'optionalAccess', _159 => _159.id]), () => ( null))));
+  const paths = roots.filter((id) => _optionalChain([_chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _160 => _160.type]) === "path" && !isVectorBlendGroup(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _161 => _161.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', _155 => _155.blend, 'optionalAccess', _156 => _156.spine])
+    hasSpine: !!_optionalChain([first, 'optionalAccess', _162 => _162.blend, 'optionalAccess', _163 => _163.spine])
   };
 }
 function applyVectorBlendOptions(controller, patch) {
@@ -2800,7 +2868,7 @@ function isVectorTextTarget(target) {
   if (!el || typeof el !== "object") return false;
   const tag = (_nullishCoalesce(el.tagName, () => ( ""))).toUpperCase();
   if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
-  return !!el.isContentEditable || _optionalChain([el, 'access', _157 => _157.getAttribute, 'optionalCall', _158 => _158("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _164 => _164.getAttribute, 'optionalCall', _165 => _165("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -2808,12 +2876,12 @@ function getVectorSelectionStyle(state) {
     const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
-  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _159 => _159.selectedAnchors, 'optionalAccess', _160 => _160.length]);
+  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _166 => _166.selectedAnchors, 'optionalAccess', _167 => _167.length]);
   if (anchorMode) {
     for (const r of state.selectedAnchors) {
       if (paths.some((p) => p.id === r.nodeId)) continue;
       const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _161 => _161.type]) === "path") paths.push(node);
+      if (_optionalChain([node, 'optionalAccess', _168 => _168.type]) === "path") paths.push(node);
     }
   }
   if (!paths.length) return null;
@@ -2824,7 +2892,7 @@ function getVectorSelectionStyle(state) {
     for (const c of _chunkFODKPD44cjs.vectorCorners.call(void 0, p.subpaths)) {
       if (anchorMode && !state.selectedAnchors.some((r) => r.nodeId === p.id && r.subpath === c.subpath && r.index === c.index)) continue;
       const corner = p.subpaths[c.subpath].anchors[c.index].corner;
-      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _162 => _162.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _163 => _163.kind]), () => ( "round")), smoothing: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _164 => _164.smoothing]), () => ( 0)) });
+      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _169 => _169.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _170 => _170.kind]), () => ( "round")), smoothing: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _171 => _171.smoothing]), () => ( 0)) });
     }
   }
   const c0 = _nullishCoalesce(corners2[0], () => ( { radius: 0, kind: "round", smoothing: 0 }));
@@ -2905,7 +2973,7 @@ function getVectorGradientEditor(state) {
   const sel = stopIndex !== null && sorted[stopIndex] ? { ...sorted[stopIndex], index: stopIndex, last: stopIndex === sorted.length - 1 } : null;
   const preview = gradient ? `linear-gradient(to right, ${_chunkFODKPD44cjs.expandVectorGradientStops.call(void 0, gradient).map((s) => {
     const c = _chunkFODKPD44cjs.parseVectorColor.call(void 0, s.color);
-    const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _165 => _165[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
+    const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _172 => _172[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
     const color = c ? `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${Math.round(a * 1e3) / 1e3})` : s.color;
     return `${color} ${Math.round(s.offset * 1e4) / 100}%`;
   }).join(", ")})` : null;
@@ -2917,11 +2985,11 @@ function getVectorGradientEditor(state) {
     stops,
     selected: sel,
     preview,
-    type: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _166 => _166.type]), () => ( null)),
-    spread: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _167 => _167.spread]), () => ( "pad")),
-    interpolation: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _168 => _168.interpolation]), () => ( "srgb")),
-    smoothness: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _169 => _169.smoothness]), () => ( 0)),
-    strokeMode: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _170 => _170.strokeMode]), () => ( "within")),
+    type: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _173 => _173.type]), () => ( null)),
+    spread: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _174 => _174.spread]), () => ( "pad")),
+    interpolation: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _175 => _175.interpolation]), () => ( "srgb")),
+    smoothness: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _176 => _176.smoothness]), () => ( 0)),
+    strokeMode: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _177 => _177.strokeMode]), () => ( "within")),
     mixed: paths.some((p) => JSON.stringify(_nullishCoalesce(_chunkFODKPD44cjs.vectorTargetPaint.call(void 0, p, target, _nullishCoalesce(layer, () => ( null))), () => ( null))) !== JSON.stringify(_nullishCoalesce(paint, () => ( null))))
   };
 }
@@ -2952,9 +3020,9 @@ function getVectorEffectsPanel(state) {
   if (!nodes.length) return null;
   const one = nodes.length === 1 ? nodes[0] : null;
   return {
-    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _171 => _171.id]), () => ( null)),
+    nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _178 => _178.id]), () => ( null)),
     count: nodes.length,
-    effects: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _172 => _172.effects]), () => ( []))).map((e) => ({
+    effects: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _179 => _179.effects]), () => ( []))).map((e) => ({
       id: e.id,
       type: e.type,
       label: _nullishCoalesce(_chunkFODKPD44cjs.VECTOR_EFFECT_LABELS[e.type], () => ( e.type)),
@@ -2971,7 +3039,7 @@ function vectorPaintSwatch(paint) {
   if (_chunkFODKPD44cjs.isVectorGradient.call(void 0, paint)) {
     return `linear-gradient(to right, ${_chunkFODKPD44cjs.expandVectorGradientStops.call(void 0, paint).map((s) => {
       const c = _chunkFODKPD44cjs.parseVectorColor.call(void 0, s.color);
-      const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _173 => _173[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
+      const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _180 => _180[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
       const color = c ? `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${Math.round(a * 1e3) / 1e3})` : s.color;
       return `${color} ${Math.round(s.offset * 1e4) / 100}%`;
     }).join(", ")})`;
@@ -3014,8 +3082,8 @@ function getVectorAppearancePanel(state) {
       strokes: !!first && !same(_chunkFODKPD44cjs.vectorStrokes),
       blendMode: nodes.some((n2) => (_nullishCoalesce(n2.blendMode, () => ( "normal"))) !== (_nullishCoalesce(nodes[0].blendMode, () => ( "normal"))))
     },
-    filterNodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _174 => _174.id]), () => ( null)),
-    filters: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _175 => _175.filters]), () => ( []))).map((f) => ({
+    filterNodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _181 => _181.id]), () => ( null)),
+    filters: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _182 => _182.filters]), () => ( []))).map((f) => ({
       id: f.id,
       type: f.type,
       label: _nullishCoalesce(_chunkFODKPD44cjs.VECTOR_FILTER_LABELS[f.type], () => ( f.type)),
@@ -3040,11 +3108,11 @@ function getVectorMaskPanel(state) {
   if (state.selection.length < 2) makeHint = "Select two or more objects: the topmost becomes the mask.";
   else if (locs.some((l) => !l)) makeHint = "Select objects in the document.";
   else if (locs.some((l) => l.list[l.index].locked || l.list[l.index].blendStep)) makeHint = "Unlock the selected objects first.";
-  else if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _176 => _176.parent, 'optionalAccess', _177 => _177.id]), () => ( null))) !== (_nullishCoalesce(_optionalChain([locs, 'access', _178 => _178[0], 'access', _179 => _179.parent, 'optionalAccess', _180 => _180.id]), () => ( null))))) makeHint = "Select objects at one level (sharing a parent).";
+  else if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _183 => _183.parent, 'optionalAccess', _184 => _184.id]), () => ( null))) !== (_nullishCoalesce(_optionalChain([locs, 'access', _185 => _185[0], 'access', _186 => _186.parent, 'optionalAccess', _187 => _187.id]), () => ( null))))) makeHint = "Select objects at one level (sharing a parent).";
   let group = null;
   const first = locs[0];
   const node = first ? first.list[first.index] : null;
-  const owner = _chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, node) ? node : _chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, _optionalChain([first, 'optionalAccess', _181 => _181.parent])) ? first.parent : null;
+  const owner = _chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, node) ? node : _chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, _optionalChain([first, 'optionalAccess', _188 => _188.parent])) ? first.parent : null;
   if (owner && state.selection.every((id) => id === owner.id || owner.children.some((c) => c.id === id))) {
     const summary = _chunkFODKPD44cjs.vectorMaskSummary.call(void 0, owner);
     const editing = state.selection.includes(owner.id) ? "group" : state.selection.includes(summary.maskId) ? "mask" : "contents";
@@ -3246,8 +3314,8 @@ var Page = (_class3 = class {
     const { ops } = pathOps(d);
     this.content.push("q");
     let p = this.paint(paint, true);
-    if (_optionalChain([p, 'optionalAccess', _182 => _182.def])) {
-      const first = p.def.type === "pattern" ? _optionalChain([p, 'access', _183 => _183.def, 'access', _184 => _184.tiles, 'access', _185 => _185[0], 'optionalAccess', _186 => _186.fill]) : _optionalChain([p, 'access', _187 => _187.def, 'access', _188 => _188.stops, 'access', _189 => _189[0], 'optionalAccess', _190 => _190.stopColor]);
+    if (_optionalChain([p, 'optionalAccess', _189 => _189.def])) {
+      const first = p.def.type === "pattern" ? _optionalChain([p, 'access', _190 => _190.def, 'access', _191 => _191.tiles, 'access', _192 => _192[0], 'optionalAccess', _193 => _193.fill]) : _optionalChain([p, 'access', _194 => _194.def, 'access', _195 => _195.stops, 'access', _196 => _196[0], 'optionalAccess', _197 => _197.stopColor]);
       this.notes.add("Gradient strokes are drawn in their first colour.");
       p = first ? this.paint(first, true) : null;
     }
@@ -3289,7 +3357,7 @@ var Page = (_class3 = class {
       if (node.opacity < 1 && node.children.length > 1) this.notes.add("Group opacity is applied to each object in the group.");
       if (node.blendMode && node.blendMode !== "normal") this.notes.add("Group blend modes are applied to each object in the group.");
       if (node.mask) {
-        if (node.mask.type === "clip" && _optionalChain([node, 'access', _191 => _191.mask, 'access', _192 => _192.clip, 'optionalAccess', _193 => _193.length])) {
+        if (node.mask.type === "clip" && _optionalChain([node, 'access', _198 => _198.mask, 'access', _199 => _199.clip, 'optionalAccess', _200 => _200.length])) {
           const evenodd = node.mask.clip.some((c) => c.clipRule === "evenodd");
           this.content.push(node.mask.clip.map((c) => pathOps(c.d).ops).join("\n"), evenodd ? "W* n" : "W n");
         } else this.notes.add("Opacity masks are left out (the contents are drawn whole).");
@@ -3477,7 +3545,7 @@ function paintItem(kind, layer, node, notes) {
     base.lj = JOIN[_nullishCoalesce(_nullishCoalesce(s.strokeLinejoin, () => ( node.strokeLinejoin)), () => ( "miter"))];
     base.ml = 4;
     const dash = _nullishCoalesce(s.strokeDasharray, () => ( node.strokeDasharray));
-    if (_optionalChain([dash, 'optionalAccess', _194 => _194.length])) base.d = dash.map((v, k) => ({ n: k % 2 === 0 ? "d" : "g", nm: k % 2 === 0 ? "dash" : "gap", v: st(round(v)) }));
+    if (_optionalChain([dash, 'optionalAccess', _201 => _201.length])) base.d = dash.map((v, k) => ({ n: k % 2 === 0 ? "d" : "g", nm: k % 2 === 0 ? "dash" : "gap", v: st(round(v)) }));
   }
   const blend = layer.blendMode && layer.blendMode !== "normal" ? BLEND2[layer.blendMode] : void 0;
   if (layer.blendMode && layer.blendMode !== "normal" && blend === void 0) notes.push(`${label(node)}: blend mode ${layer.blendMode} has no Lottie equivalent (normal used).`);
@@ -3490,7 +3558,7 @@ function paintItem(kind, layer, node, notes) {
   }
   if (_chunkFODKPD44cjs.isVectorShadedPaint.call(void 0, paint)) {
     notes.push(`${label(node)}: mesh and freeform gradients have no Lottie equivalent (their first colour used).`);
-    const first = paint.type === "mesh" ? paint.colors[0] : _optionalChain([paint, 'access', _195 => _195.points, 'access', _196 => _196[0], 'optionalAccess', _197 => _197.color]);
+    const first = paint.type === "mesh" ? paint.colors[0] : _optionalChain([paint, 'access', _202 => _202.points, 'access', _203 => _203[0], 'optionalAccess', _204 => _204.color]);
     return first ? { ty: kind === "fill" ? "fl" : "st", ...base, c: st(colorOf(first)), o: st(round(100 * (_nullishCoalesce(layer.opacity, () => ( 1))))), r: 1, ...extra } : null;
   }
   if (!_chunkFODKPD44cjs.isVectorGradient.call(void 0, paint)) return null;
@@ -3592,15 +3660,15 @@ function pathItems(node, notes) {
 }
 function nodeGroup(node, notes) {
   if (node.visible === false) return null;
-  if (_optionalChain([node, 'access', _198 => _198.filters, 'optionalAccess', _199 => _199.length])) notes.push(`${label(node)}: filters (shadows, glows, blurs) are not part of Lottie (left out).`);
+  if (_optionalChain([node, 'access', _205 => _205.filters, 'optionalAccess', _206 => _206.length])) notes.push(`${label(node)}: filters (shadows, glows, blurs) are not part of Lottie (left out).`);
   const m = _chunkFODKPD44cjs.nodeMatrix.call(void 0, node);
   let items = [];
   const live = (_nullishCoalesce(node.effects, () => ( []))).some((e) => e.enabled !== false && (e.type === "wiggle" || e.type === "envelope"));
   if (node.type === "text" || node.type === "instance" || live || _chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, node) || _chunkFODKPD44cjs.isVectorFrame.call(void 0, node)) {
     if (live) notes.push(`${label(node)}: wiggle and envelope effects have no Lottie equivalent (exported as drawn).`);
-    if (_chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, node) && _optionalChain([node, 'access', _200 => _200.mask, 'optionalAccess', _201 => _201.type]) !== "clip") notes.push(`${label(node)}: opacity masks are not exported (the contents are drawn whole).`);
+    if (_chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, node) && _optionalChain([node, 'access', _207 => _207.mask, 'optionalAccess', _208 => _208.type]) !== "clip") notes.push(`${label(node)}: opacity masks are not exported (the contents are drawn whole).`);
     const drawn = _chunkFODKPD44cjs.isVectorFrame.call(void 0, node) ? _chunkFODKPD44cjs.vectorFrameDrawn.call(void 0, node) : node;
-    const shapes = _chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, drawn) && _optionalChain([drawn, 'access', _202 => _202.mask, 'optionalAccess', _203 => _203.type]) === "clip" ? _chunkFODKPD44cjs.vectorAppearanceShapes.call(void 0, { ...drawn, transform: void 0 }) : null;
+    const shapes = _chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, drawn) && _optionalChain([drawn, 'access', _209 => _209.mask, 'optionalAccess', _210 => _210.type]) === "clip" ? _chunkFODKPD44cjs.vectorAppearanceShapes.call(void 0, { ...drawn, transform: void 0 }) : null;
     if (shapes) {
       for (const s of [...shapes].reverse()) {
         const source = { ...s.source, subpaths: _chunkFODKPD44cjs.bezierToSubpaths.call(void 0, s.path), effects: null, opacity: s.opacity };
@@ -3700,7 +3768,7 @@ function lottieValueAt(prop, frame) {
     return from.map((v, d) => v + ((_nullishCoalesce(to[d], () => ( v))) - v) * y);
   }
   const last = keys[keys.length - 1];
-  return last.s !== void 0 ? nums(last.s) : nums(_optionalChain([keys, 'access', _204 => _204[keys.length - 2], 'optionalAccess', _205 => _205.e]));
+  return last.s !== void 0 ? nums(last.s) : nums(_optionalChain([keys, 'access', _211 => _211[keys.length - 2], 'optionalAccess', _212 => _212.e]));
 }
 function subpathOf(prop, frame) {
   const p = prop;
@@ -3893,8 +3961,8 @@ function painted(node, paints, s) {
   return {
     ...node,
     ...evenodd ? { fillRule: "evenodd" } : {},
-    fill: _nullishCoalesce(_optionalChain([fill, 'optionalAccess', _206 => _206.paint]), () => ( null)),
-    stroke: _nullishCoalesce(_optionalChain([stroke, 'optionalAccess', _207 => _207.paint]), () => ( null)),
+    fill: _nullishCoalesce(_optionalChain([fill, 'optionalAccess', _213 => _213.paint]), () => ( null)),
+    stroke: _nullishCoalesce(_optionalChain([stroke, 'optionalAccess', _214 => _214.paint]), () => ( null)),
     ...stroke ? { strokeWidth: stroke.strokeWidth, strokeLinecap: stroke.strokeLinecap, strokeLinejoin: stroke.strokeLinejoin, ...stroke.strokeDasharray ? { strokeDasharray: stroke.strokeDasharray } : {} } : {},
     ...fills.length > 1 || fill && (fill.opacity !== void 0 || fill.blendMode) ? { fills } : {},
     ...strokes.length > 1 || stroke && (stroke.opacity !== void 0 || stroke.blendMode) ? { strokes } : {}
@@ -4504,7 +4572,7 @@ function vectorSkewMatrix(ax, ay, origin = { x: 0, y: 0 }) {
   return _chunkFODKPD44cjs.skewMatrix.call(void 0, ax, ay, origin);
 }
 function mapEffects(node, f) {
-  if (!_optionalChain([node, 'access', _208 => _208.effects, 'optionalAccess', _209 => _209.length])) return void 0;
+  if (!_optionalChain([node, 'access', _215 => _215.effects, 'optionalAccess', _216 => _216.length])) return void 0;
   return node.effects.map((e) => {
     if (e.type !== "envelope") return e;
     if (e.params.style === "mesh") return e.params.mesh ? { ...e, params: { ...e.params, mesh: _chunkFODKPD44cjs.mapWarpMeshPoints.call(void 0, e.params.mesh, f) } } : e;
@@ -4521,7 +4589,7 @@ function distortVectorNode(node, parentToDoc, f, tolerance = VECTOR_DISTORT_TOLE
   if (node.type === "group") {
     const group = node;
     const children = group.children.map((c) => distortVectorNode(c, toDoc, f, tolerance));
-    const spine = _optionalChain([group, 'access', _210 => _210.blend, 'optionalAccess', _211 => _211.spine]);
+    const spine = _optionalChain([group, 'access', _217 => _217.blend, 'optionalAccess', _218 => _218.spine]);
     return {
       ...group,
       children,
@@ -4581,7 +4649,7 @@ function vectorTrackingPaths(points, angles = [0, 90, 180, 270]) {
 }
 var VECTOR_CONSTRUCTION_ANGLES = [0, 45, 90, 135];
 function constrainToLeave(leave, p) {
-  if (!_optionalChain([leave, 'optionalAccess', _212 => _212.constrain])) return p;
+  if (!_optionalChain([leave, 'optionalAccess', _219 => _219.constrain])) return p;
   const dx = p.x - leave.at.x;
   const dy = p.y - leave.at.y;
   switch (leave.constrain) {
@@ -4694,7 +4762,7 @@ var VectorSnapTargets = (_class5 = 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', _213 => _213.get, 'call', _214 => _214(id), 'optionalAccess', _215 => _215.has, 'call', _216 => _216(`${s}:${i}`)]), true);
+    t.pushPaths(doc, new Set(moving.keys()), (id, s, i) => !!_optionalChain([moving, 'access', _220 => _220.get, 'call', _221 => _221(id), 'optionalAccess', _222 => _222.has, 'call', _223 => _223(`${s}:${i}`)]), true);
     return t.index();
   }
   /**
@@ -4818,7 +4886,7 @@ var VectorSnapTargets = (_class5 = class _VectorSnapTargets {
         }
         const b = _chunkFODKPD44cjs.vectorNodeBounds.call(void 0, n2, parent);
         const f = nodeFrame(n2, parent, b);
-        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _217 => _217.centre]), () => ( null)));
+        if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _224 => _224.centre]), () => ( null)));
       }
     };
     visit(doc.nodes, _chunkFODKPD44cjs.IDENTITY_MATRIX);
@@ -4863,7 +4931,7 @@ var VectorSnapTargets = (_class5 = class _VectorSnapTargets {
       lines: lines2,
       labels: [this.label(q, kind)]
     });
-    if (_optionalChain([leave, 'optionalAccess', _218 => _218.constrain])) {
+    if (_optionalChain([leave, 'optionalAccess', _225 => _225.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);
@@ -4888,7 +4956,7 @@ var VectorSnapTargets = (_class5 = class _VectorSnapTargets {
     if (on) return at(on, "path");
     const slide = paths.filter((t) => t.path.kind !== "polar").sort((a, b) => a.d - b.d)[0];
     if (slide) return { ...at(slide.foot, "tracking", [line("construction", slide.path.origin, slide.foot)]), labels: [this.label(slide.foot, "tracking", slide.path.kind === "extension" ? "extension" : "tracking")] };
-    if (_optionalChain([leave, 'optionalAccess', _219 => _219.angles, 'optionalAccess', _220 => _220.length])) {
+    if (_optionalChain([leave, 'optionalAccess', _226 => _226.angles, 'optionalAccess', _227 => _227.length])) {
       const c = construction(leave, p, tol);
       if (c) {
         const hit = this.slide(leave.at, c.dir, c.point, tol, false);
@@ -5019,7 +5087,7 @@ var VectorSnapTargets = (_class5 = 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', _221 => _221.axes, 'optionalAccess', _222 => _222.x]) !== false, y: _optionalChain([options, 'access', _223 => _223.axes, 'optionalAccess', _224 => _224.y]) !== false };
+    const axes = { x: _optionalChain([options, 'access', _228 => _228.axes, 'optionalAccess', _229 => _229.x]) !== false, y: _optionalChain([options, 'access', _230 => _230.axes, 'optionalAccess', _231 => _231.y]) !== false };
     const nearest = (lines, values) => {
       let best = null;
       for (const v of values) for (const l of linesNear(lines, v, tol)) if (!best || Math.abs(l.v - v) < Math.abs(best.d)) best = { d: l.v - v, from: l.from };
@@ -5027,7 +5095,7 @@ var VectorSnapTargets = (_class5 = 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', _225 => _225.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _226 => _226.d]), () => ( 0)), x: !!bx, y: !!by, lines: [], labels: [] };
+    const out = { dx: _nullishCoalesce(_optionalChain([bx, 'optionalAccess', _232 => _232.d]), () => ( 0)), dy: _nullishCoalesce(_optionalChain([by, 'optionalAccess', _233 => _233.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;
@@ -5150,9 +5218,9 @@ var VectorSnapTargets = (_class5 = 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', _227 => _227.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _228 => _228.v]), () => ( null)), s: { hx, hy, on: null } });
-      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _229 => _229.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
-      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _230 => _230.v]), () => ( null)), s: { hx: null, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _234 => _234.v]), () => ( null)), ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _235 => _235.v]), () => ( null)), s: { hx, hy, on: null } });
+      tries.push({ tx: _nullishCoalesce(_optionalChain([hx, 'optionalAccess', _236 => _236.v]), () => ( null)), ty: null, s: { hx, hy: null, on: null } });
+      tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _237 => _237.v]), () => ( null)), s: { hx: null, hy, on: null } });
       for (const { tx, ty, s } of tries) {
         if (tx === null && ty === null) continue;
         const q = _chunkFODKPD44cjs.applyMatrix.call(void 0, toLocal, { x: _nullishCoalesce(tx, () => ( p.x)), y: _nullishCoalesce(ty, () => ( p.y)) });
@@ -5283,7 +5351,7 @@ function line(kind, a, b) {
   return { kind, x1: a.x, y1: a.y, x2: b.x, y2: b.y };
 }
 function polarPaths(leave) {
-  if (!_optionalChain([leave, 'optionalAccess', _231 => _231.angles, 'optionalAccess', _232 => _232.length]) || leave.constrain) return [];
+  if (!_optionalChain([leave, 'optionalAccess', _238 => _238.angles, 'optionalAccess', _239 => _239.length]) || leave.constrain) return [];
   const out = [];
   for (const a of leave.angles) {
     const dir = vectorAngleDirection(a);
@@ -6309,7 +6377,7 @@ function getEditablePathIds(state) {
       }
     }
   }
-  return [...ids].filter((id) => _optionalChain([_chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id), 'optionalAccess', _233 => _233.type]) === "path");
+  return [...ids].filter((id) => _optionalChain([_chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id), 'optionalAccess', _240 => _240.type]) === "path");
 }
 function getVisibleAnchors(state) {
   const out = [];
@@ -6324,7 +6392,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', _234 => _234.anchors, 'access', _235 => _235[i]]);
+    const a = _optionalChain([sp, 'optionalAccess', _241 => _241.anchors, 'access', _242 => _242[i]]);
     if (!a || !a[handle]) return;
     const key = `${node.id}:${s}:${i}:${handle}`;
     if (seen.has(key)) return;
@@ -6333,8 +6401,8 @@ function getVisibleHandles(state) {
   };
   if (state.tool === "pen" && state.pen) {
     const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _236 => _236.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
-    if (_optionalChain([node, 'optionalAccess', _237 => _237.type]) === "path" && sp) {
+    const sp = _optionalChain([node, 'optionalAccess', _243 => _243.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    if (_optionalChain([node, 'optionalAccess', _244 => _244.type]) === "path" && sp) {
       const last = sp.anchors.length - 1;
       push(node, state.pen.subpath, last, "in");
       push(node, state.pen.subpath, last, "out");
@@ -6372,11 +6440,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', _238 => _238.corner, 'optionalAccess', _239 => _239.radius]), () => ( 0));
+      const radius = _nullishCoalesce(_optionalChain([a, 'access', _245 => _245.corner, 'optionalAccess', _246 => _246.radius]), () => ( 0));
       const drawn = _chunkFODKPD44cjs.fitCornerRadius.call(void 0, 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 = _chunkFODKPD44cjs.applyMatrix.call(void 0, m, _chunkFODKPD44cjs.cornerBisectorPoint.call(void 0, 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', _240 => _240.corner, 'optionalAccess', _241 => _241.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', _247 => _247.corner, 'optionalAccess', _248 => _248.kind]), () => ( "round")), corner: c });
     }
   }
   return out;
@@ -6399,13 +6467,13 @@ function getVectorWidthHandles(state) {
     const n2 = _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id);
     if (n2) for (const p of _chunkFODKPD44cjs.collectPathNodes.call(void 0, n2)) ids.add(p.id);
   }
-  if (_optionalChain([state, 'access', _242 => _242.hover, 'optionalAccess', _243 => _243.nodeId])) ids.add(state.hover.nodeId);
-  if (_optionalChain([state, 'access', _244 => _244.interaction, 'optionalAccess', _245 => _245.type]) === "width") ids.add(state.interaction.ref.nodeId);
+  if (_optionalChain([state, 'access', _249 => _249.hover, 'optionalAccess', _250 => _250.nodeId])) ids.add(state.hover.nodeId);
+  if (_optionalChain([state, 'access', _251 => _251.interaction, 'optionalAccess', _252 => _252.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 = _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, id);
-    if (_optionalChain([node, 'optionalAccess', _246 => _246.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _247 => _247.strokeWidthProfile, 'optionalAccess', _248 => _248.length])) continue;
+    if (_optionalChain([node, 'optionalAccess', _253 => _253.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _254 => _254.strokeWidthProfile, 'optionalAccess', _255 => _255.length])) continue;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) continue;
     const profile = _chunkFODKPD44cjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
@@ -6438,7 +6506,7 @@ function getVectorWidthHandles(state) {
 }
 function getAnchor(doc, ref) {
   const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
-  return _optionalChain([node, 'optionalAccess', _249 => _249.type]) === "path" ? _optionalChain([node, 'access', _250 => _250.subpaths, 'access', _251 => _251[ref.subpath], 'optionalAccess', _252 => _252.anchors, 'access', _253 => _253[ref.index]]) : void 0;
+  return _optionalChain([node, 'optionalAccess', _256 => _256.type]) === "path" ? _optionalChain([node, 'access', _257 => _257.subpaths, 'access', _258 => _258[ref.subpath], 'optionalAccess', _259 => _259.anchors, 'access', _260 => _260[ref.index]]) : void 0;
 }
 function getAnchorWorld(doc, ref) {
   const a = getAnchor(doc, ref);
@@ -6632,7 +6700,7 @@ function normalizeVectorTree(nodes, prefer) {
 function loadedDocument(doc) {
   const copy = _chunkFODKPD44cjs.cloneVectorDocument.call(void 0, _chunkFODKPD44cjs.stripVectorSymbolArt.call(void 0, doc));
   const nodes = normalizeVectorTree(copy.nodes, "stack");
-  const symbols = _optionalChain([copy, 'access', _254 => _254.symbols, 'optionalAccess', _255 => _255.map, 'call', _256 => _256((s) => ({ ...s, nodes: normalizeVectorTree(s.nodes, "stack") }))]);
+  const symbols = _optionalChain([copy, 'access', _261 => _261.symbols, 'optionalAccess', _262 => _262.map, 'call', _263 => _263((s) => ({ ...s, nodes: normalizeVectorTree(s.nodes, "stack") }))]);
   return _chunkFODKPD44cjs.resolveVectorSymbols.call(void 0, { ...copy, nodes, ...symbols ? { symbols } : {} });
 }
 function mapTree(nodes, fn) {
@@ -6843,7 +6911,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     const nodes = refreshVectorBlends(normalizeVectorTree(doc.nodes, "shorthand"));
     let out = nodes === doc.nodes ? doc : { ...doc, nodes };
     const edit = this.symbolEdit;
-    if (edit && _optionalChain([out, 'access', _257 => _257.symbols, 'optionalAccess', _258 => _258.some, 'call', _259 => _259((s) => s.id === edit.symbolId && s.nodes !== out.nodes)])) {
+    if (edit && _optionalChain([out, 'access', _264 => _264.symbols, 'optionalAccess', _265 => _265.some, 'call', _266 => _266((s) => s.id === edit.symbolId && s.nodes !== out.nodes)])) {
       out = { ...out, symbols: out.symbols.map((s) => s.id === edit.symbolId ? { ...s, nodes: out.nodes } : s) };
     }
     out = _chunkFODKPD44cjs.resolveVectorSymbols.call(void 0, out);
@@ -6854,7 +6922,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    * constraints on deleted anchors removed; the same object when nothing changes.
    */
   solved(doc) {
-    if (!_optionalChain([doc, 'access', _260 => _260.constraints, 'optionalAccess', _261 => _261.length])) {
+    if (!_optionalChain([doc, 'access', _267 => _267.constraints, 'optionalAccess', _268 => _268.length])) {
       this.constraintIssues = null;
       this.lastSolved = doc;
       return doc;
@@ -6872,7 +6940,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     if (this.blendStart && !this.getNode(this.blendStart.nodeId)) this.blendStart = null;
     this.revision++;
     this.state = this.computeState();
-    if (docChanged) _optionalChain([this, 'access', _262 => _262.onChange, 'optionalCall', _263 => _263(this.storedDocument())]);
+    if (docChanged) _optionalChain([this, 'access', _269 => _269.onChange, 'optionalCall', _270 => _270(this.storedDocument())]);
     const state = this.state;
     this.listeners.forEach((listener) => {
       try {
@@ -6902,42 +6970,42 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     return _chunkFODKPD44cjs.applyMatrix.call(void 0, _chunkFODKPD44cjs.invertMatrix.call(void 0, this.worldOf(id, doc)), p);
   }
   cursorFor() {
-    if (_optionalChain([this, 'access', _264 => _264.drag, 'optionalAccess', _265 => _265.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
-    if (_optionalChain([this, 'access', _266 => _266.drag, 'optionalAccess', _267 => _267.kind]) === "rotate") return "grabbing";
-    if (_optionalChain([this, 'access', _268 => _268.drag, 'optionalAccess', _269 => _269.kind]) === "move") return "move";
+    if (_optionalChain([this, 'access', _271 => _271.drag, 'optionalAccess', _272 => _272.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
+    if (_optionalChain([this, 'access', _273 => _273.drag, 'optionalAccess', _274 => _274.kind]) === "rotate") return "grabbing";
+    if (_optionalChain([this, 'access', _275 => _275.drag, 'optionalAccess', _276 => _276.kind]) === "move") return "move";
     const h = this.hover;
     switch (this.tool) {
       case "select":
-        if (_optionalChain([h, 'optionalAccess', _270 => _270.transformHandle]) && this.freeDistort && h.transformHandle !== "rotate") return "crosshair";
-        if (_optionalChain([h, 'optionalAccess', _271 => _271.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _272 => _272.frameOf, 'call', _273 => _273(this.selectedRoots()), 'optionalAccess', _274 => _274.angle]), () => ( 0)));
-        return _optionalChain([h, 'optionalAccess', _275 => _275.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _277 => _277.transformHandle]) && this.freeDistort && h.transformHandle !== "rotate") return "crosshair";
+        if (_optionalChain([h, 'optionalAccess', _278 => _278.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _279 => _279.frameOf, 'call', _280 => _280(this.selectedRoots()), 'optionalAccess', _281 => _281.angle]), () => ( 0)));
+        return _optionalChain([h, 'optionalAccess', _282 => _282.nodeId]) ? "move" : "default";
       case "type":
         return "text";
       case "typePath":
-        return _optionalChain([h, 'optionalAccess', _276 => _276.nodeId]) ? "text" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _283 => _283.nodeId]) ? "text" : "crosshair";
       case "envelope":
-        if (_optionalChain([this, 'access', _277 => _277.drag, 'optionalAccess', _278 => _278.kind]) === "envelope") return "grabbing";
-        if (_optionalChain([h, 'optionalAccess', _279 => _279.envelope])) return h.envelope.index === null ? "grab" : "pointer";
-        return _optionalChain([h, 'optionalAccess', _280 => _280.nodeId]) ? "pointer" : "default";
+        if (_optionalChain([this, 'access', _284 => _284.drag, 'optionalAccess', _285 => _285.kind]) === "envelope") return "grabbing";
+        if (_optionalChain([h, 'optionalAccess', _286 => _286.envelope])) return h.envelope.index === null ? "grab" : "pointer";
+        return _optionalChain([h, 'optionalAccess', _287 => _287.nodeId]) ? "pointer" : "default";
       case "direct":
-        if (_optionalChain([h, 'optionalAccess', _281 => _281.anchor]) || _optionalChain([h, 'optionalAccess', _282 => _282.handle]) || _optionalChain([h, 'optionalAccess', _283 => _283.corner])) return "pointer";
-        if (_optionalChain([h, 'optionalAccess', _284 => _284.segment])) return "copy";
-        return _optionalChain([h, 'optionalAccess', _285 => _285.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _288 => _288.anchor]) || _optionalChain([h, 'optionalAccess', _289 => _289.handle]) || _optionalChain([h, 'optionalAccess', _290 => _290.corner])) return "pointer";
+        if (_optionalChain([h, 'optionalAccess', _291 => _291.segment])) return "copy";
+        return _optionalChain([h, 'optionalAccess', _292 => _292.nodeId]) ? "move" : "default";
       case "pen":
-        return _optionalChain([h, 'optionalAccess', _286 => _286.anchor]) ? "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _293 => _293.anchor]) ? "pointer" : "crosshair";
       case "width":
-        if (_optionalChain([this, 'access', _287 => _287.drag, 'optionalAccess', _288 => _288.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
-        if (_optionalChain([h, 'optionalAccess', _289 => _289.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
-        return _optionalChain([h, 'optionalAccess', _290 => _290.strokeSpot]) ? "copy" : "default";
+        if (_optionalChain([this, 'access', _294 => _294.drag, 'optionalAccess', _295 => _295.kind]) === "width") return this.drag.mode === "width" ? "ew-resize" : "grabbing";
+        if (_optionalChain([h, 'optionalAccess', _296 => _296.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
+        return _optionalChain([h, 'optionalAccess', _297 => _297.strokeSpot]) ? "copy" : "default";
       case "shapeBuilder":
-        if (!_optionalChain([this, 'access', _291 => _291.builderPreview, 'optionalAccess', _292 => _292.faces, 'access', _293 => _293.length]) && !_optionalChain([this, 'access', _294 => _294.builderPreview, 'optionalAccess', _295 => _295.lines, 'access', _296 => _296.length])) return "crosshair";
+        if (!_optionalChain([this, 'access', _298 => _298.builderPreview, 'optionalAccess', _299 => _299.faces, 'access', _300 => _300.length]) && !_optionalChain([this, 'access', _301 => _301.builderPreview, 'optionalAccess', _302 => _302.lines, 'access', _303 => _303.length])) return "crosshair";
         return this.builderPreview.mode === "erase" ? "not-allowed" : "cell";
       case "paintBucket":
         return this.builderPreview ? "cell" : "crosshair";
       case "blend":
-        return _optionalChain([h, 'optionalAccess', _297 => _297.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _304 => _304.nodeId]) ? this.blendStart && this.blendStart.nodeId !== h.nodeId ? "copy" : "pointer" : "crosshair";
       case "gradient": {
-        const part = _optionalChain([this, 'access', _298 => _298.drag, 'optionalAccess', _299 => _299.kind]) === "gradient" ? this.drag.part : _optionalChain([h, 'optionalAccess', _300 => _300.gradient]);
+        const part = _optionalChain([this, 'access', _305 => _305.drag, 'optionalAccess', _306 => _306.kind]) === "gradient" ? this.drag.part : _optionalChain([h, 'optionalAccess', _307 => _307.gradient]);
         if (!part) return "crosshair";
         if (part.kind === "bar") return this.drag ? "grabbing" : "copy";
         if (part.kind === "handle" && part.handle === "start") return this.drag ? "grabbing" : "move";
@@ -6963,16 +7031,16 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       const was = this.symbolEdit;
       this.symbolEdit = _nullishCoalesce(s.symbolEdit, () => ( null));
       if (was !== this.symbolEdit) {
-        if (_optionalChain([was, 'optionalAccess', _301 => _301.origin])) this.viewport = this.viewOutOf(was);
-        if (_optionalChain([this, 'access', _302 => _302.symbolEdit, 'optionalAccess', _303 => _303.origin])) this.viewport = this.viewInto(this.symbolEdit);
+        if (_optionalChain([was, 'optionalAccess', _308 => _308.origin])) this.viewport = this.viewOutOf(was);
+        if (_optionalChain([this, 'access', _309 => _309.symbolEdit, 'optionalAccess', _310 => _310.origin])) this.viewport = this.viewInto(this.symbolEdit);
       }
       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', _304 => _304.getNode, 'call', _305 => _305(s.pen.nodeId), 'optionalAccess', _306 => _306.subpaths, 'optionalAccess', _307 => _307[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _311 => _311.getNode, 'call', _312 => _312(s.pen.nodeId), 'optionalAccess', _313 => _313.subpaths, 'optionalAccess', _314 => _314[s.pen.subpath]]) ? s.pen : null;
       if (this.textEdit) {
         const t = this.getNode(this.textEdit.nodeId);
-        if (_optionalChain([t, 'optionalAccess', _308 => _308.type]) !== "text") this.textEdit = null;
+        if (_optionalChain([t, 'optionalAccess', _315 => _315.type]) !== "text") this.textEdit = null;
         else {
           const n2 = t.text.length;
           this.textEdit = { ...this.textEdit, anchor: Math.min(this.textEdit.anchor, n2), focus: Math.min(this.textEdit.focus, n2), before: null };
@@ -6981,7 +7049,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       if (this.widthPoints.length) {
         const kept = this.widthPoints.filter((r) => {
           const n2 = this.getNode(r.nodeId);
-          return _optionalChain([n2, 'optionalAccess', _309 => _309.type]) === "path" && !!_optionalChain([n2, 'access', _310 => _310.strokeWidthProfile, 'optionalAccess', _311 => _311[r.index]]);
+          return _optionalChain([n2, 'optionalAccess', _316 => _316.type]) === "path" && !!_optionalChain([n2, 'access', _317 => _317.strokeWidthProfile, 'optionalAccess', _318 => _318[r.index]]);
         });
         if (kept.length !== this.widthPoints.length) this.widthPoints = kept;
       }
@@ -7168,7 +7236,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       if (res.kind) {
         this.snappedToObject = true;
         this.setGuides(res);
-        return _optionalChain([leave, 'optionalAccess', _312 => _312.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', _319 => _319.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);
@@ -7186,14 +7254,14 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** 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', _313 => _313.getNode, 'call', _314 => _314(this.pen.nodeId), 'optionalAccess', _315 => _315.subpaths, 'access', _316 => _316[this.pen.subpath]]) : void 0;
-      if (this.pen && sp && _optionalChain([this, 'access', _317 => _317.hover, 'optionalAccess', _318 => _318.anchor])) {
+      const sp = this.pen ? _optionalChain([this, 'access', _320 => _320.getNode, 'call', _321 => _321(this.pen.nodeId), 'optionalAccess', _322 => _322.subpaths, 'access', _323 => _323[this.pen.subpath]]) : void 0;
+      if (this.pen && sp && _optionalChain([this, 'access', _324 => _324.hover, 'optionalAccess', _325 => _325.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, ...this.penAngles() } : null;
-      const q = this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _319 => _319.pen, 'optionalAccess', _320 => _320.nodeId]), () => ( null))));
+      const q = this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _326 => _326.pen, 'optionalAccess', _327 => _327.nodeId]), () => ( null))));
       this.dwell();
       return q;
     }
@@ -7348,7 +7416,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     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', _321 => _321.strokeWidthProfile, 'optionalAccess', _322 => _322.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
+    if (_optionalChain([d, 'access', _328 => _328.strokeWidthProfile, 'optionalAccess', _329 => _329.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     let styled = out;
     if (Array.isArray(d.fills)) styled = _chunkFODKPD44cjs.withVectorFills.call(void 0, styled, open ? [] : d.fills);
     if (Array.isArray(d.strokes)) styled = _chunkFODKPD44cjs.withVectorStrokes.call(void 0, styled, d.strokes);
@@ -7448,7 +7516,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       next.set(path.id, _chunkFODKPD44cjs.withVectorTargetPaint.call(void 0, path, target, layer, g));
     }
     this.change(_nullishCoalesce(options.label, () => ( "Gradient")), () => this.setDoc(mapTree(this.doc.nodes, (n2) => _nullishCoalesce(next.get(n2.id), () => ( n2)))), options.merge);
-    const stops = _nullishCoalesce(_optionalChain([first, 'optionalAccess', _323 => _323.stops, 'access', _324 => _324.length]), () => ( 0));
+    const stops = _nullishCoalesce(_optionalChain([first, 'optionalAccess', _330 => _330.stops, 'access', _331 => _331.length]), () => ( 0));
     if (this.gradientEdit.stop !== null && this.gradientEdit.stop >= stops) this.gradientEdit = { ...this.gradientEdit, stop: null };
     return { ok: true };
   }
@@ -7626,7 +7694,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   upGradient(drag) {
     const part = drag.part;
     if (!drag.moved) {
-      if (_optionalChain([part, 'optionalAccess', _325 => _325.kind]) === "bar") {
+      if (_optionalChain([part, 'optionalAccess', _332 => _332.kind]) === "bar") {
         this.addGradientStop(part.offset);
         return;
       }
@@ -7645,7 +7713,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     const byNode = /* @__PURE__ */ new Map();
     for (const r of refs) {
       const node = this.getNode(r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _326 => _326.type]) !== "path" || !_optionalChain([node, 'access', _327 => _327.strokeWidthProfile, 'optionalAccess', _328 => _328[r.index]])) continue;
+      if (_optionalChain([node, 'optionalAccess', _333 => _333.type]) !== "path" || !_optionalChain([node, 'access', _334 => _334.strokeWidthProfile, 'optionalAccess', _335 => _335[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." };
@@ -7663,12 +7731,12 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   }
   /** Selects width points (width tool); points on other paths than the first are dropped. */
   selectWidthPoints(refs) {
-    const first = _optionalChain([refs, 'access', _329 => _329[0], 'optionalAccess', _330 => _330.nodeId]);
+    const first = _optionalChain([refs, 'access', _336 => _336[0], 'optionalAccess', _337 => _337.nodeId]);
     const next = [];
     for (const r of refs) {
       if (r.nodeId !== first || next.some((q) => q.index === r.index)) continue;
       const n2 = this.getNode(r.nodeId);
-      if (_optionalChain([n2, 'optionalAccess', _331 => _331.type]) === "path" && _optionalChain([n2, 'access', _332 => _332.strokeWidthProfile, 'optionalAccess', _333 => _333[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
+      if (_optionalChain([n2, 'optionalAccess', _338 => _338.type]) === "path" && _optionalChain([n2, 'access', _339 => _339.strokeWidthProfile, 'optionalAccess', _340 => _340[r.index]])) next.push({ nodeId: r.nodeId, index: r.index, subpath: _nullishCoalesce(r.subpath, () => ( 0)) });
     }
     this.widthPoints = next;
     this.notify();
@@ -7683,7 +7751,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    */
   setWidthPoint(target, values) {
     const node = this.getNode(target.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _334 => _334.type]) !== "path") return { ok: false, message: "There is no such path." };
+    if (_optionalChain([node, 'optionalAccess', _341 => _341.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 = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
@@ -7716,11 +7784,11 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         }
       }
     }
-    const subpath = _optionalChain([this, 'access', _335 => _335.widthEdit, 'optionalAccess', _336 => _336.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _337 => _337.widthPoints, 'access', _338 => _338.find, 'call', _339 => _339((r) => r.nodeId === node.id), 'optionalAccess', _340 => _340.subpath]), () => ( 0));
+    const subpath = _optionalChain([this, 'access', _342 => _342.widthEdit, 'optionalAccess', _343 => _343.nodeId]) === node.id ? this.widthEdit.subpath : _nullishCoalesce(_optionalChain([this, 'access', _344 => _344.widthPoints, 'access', _345 => _345.find, 'call', _346 => _346((r) => r.nodeId === node.id), 'optionalAccess', _347 => _347.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', _341 => _341.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
+    if (_optionalChain([edit, 'optionalAccess', _348 => _348.nodeId]) === node.id && (edit.index === existing || existing === null)) this.widthEdit = this.widthEditFor(node.id, subpath, index, null);
     this.notify();
     return { ok: true };
   }
@@ -7754,7 +7822,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** 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', _342 => _342.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _349 => _349.type]) !== "path") return null;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) return null;
     const profile = _chunkFODKPD44cjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
@@ -7787,12 +7855,12 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** Sets corner smoothing (squircle, 0–1) of the same anchors as `setCornerRadius`, keeping their radii. */
   setCornerSmoothing(smoothing, options = {}) {
     if (!(smoothing >= 0 && smoothing <= 1)) return { ok: false, message: "Corner smoothing must be from 0 to 1." };
-    const refs = this.cornerTargets(options).filter((r) => (_nullishCoalesce(_optionalChain([getAnchor, 'call', _343 => _343(this.doc, r), 'optionalAccess', _344 => _344.corner, 'optionalAccess', _345 => _345.radius]), () => ( 0))) > 0);
+    const refs = this.cornerTargets(options).filter((r) => (_nullishCoalesce(_optionalChain([getAnchor, 'call', _350 => _350(this.doc, r), 'optionalAccess', _351 => _351.corner, 'optionalAccess', _352 => _352.radius]), () => ( 0))) > 0);
     if (!refs.length) return { ok: false, message: "Give the corners a radius first: smoothing shapes rounded corners." };
     this.change(
       "Corner Smoothing",
       () => {
-        this.doc = this.updateAnchors(this.doc, refs, (a) => _chunkFODKPD44cjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _346 => _346.corner, 'optionalAccess', _347 => _347.radius]), () => ( 0)), void 0, smoothing));
+        this.doc = this.updateAnchors(this.doc, refs, (a) => _chunkFODKPD44cjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _353 => _353.corner, 'optionalAccess', _354 => _354.radius]), () => ( 0)), void 0, smoothing));
       },
       options.merge
     );
@@ -7803,7 +7871,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     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) => _chunkFODKPD44cjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _348 => _348.corner, 'optionalAccess', _349 => _349.radius]), () => ( 0)), kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => _chunkFODKPD44cjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _355 => _355.corner, 'optionalAccess', _356 => _356.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
@@ -8063,7 +8131,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    */
   updateFilter(nodeId, filterId, patch, options = {}) {
     const merge = options.merge === true ? `filter:${nodeId}:${filterId}` : options.merge || void 0;
-    const current = _optionalChain([this, 'access', _350 => _350.getNode, 'call', _351 => _351(nodeId), 'optionalAccess', _352 => _352.filters, 'optionalAccess', _353 => _353.find, 'call', _354 => _354((f) => f.id === filterId)]);
+    const current = _optionalChain([this, 'access', _357 => _357.getNode, 'call', _358 => _358(nodeId), 'optionalAccess', _359 => _359.filters, 'optionalAccess', _360 => _360.find, 'call', _361 => _361((f) => f.id === filterId)]);
     return this.editFilters(
       nodeId,
       `Edit ${current ? _chunkFODKPD44cjs.VECTOR_FILTER_LABELS[current.type] : "Filter"}`,
@@ -8144,7 +8212,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   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', _355 => _355.effects, 'optionalAccess', _356 => _356.find, 'call', _357 => _357((e) => e.id === effectId)]);
+    const current = _optionalChain([node, 'optionalAccess', _362 => _362.effects, 'optionalAccess', _363 => _363.find, 'call', _364 => _364((e) => e.id === effectId)]);
     const label2 = current ? _nullishCoalesce(_chunkFODKPD44cjs.VECTOR_EFFECT_LABELS[current.type], () => ( "Effect")) : "Effect";
     return this.editEffects(
       nodeId,
@@ -8278,10 +8346,10 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     return this.selection.filter((id) => {
       let covered = false;
       const loc = _chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id);
-      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _358 => _358.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _365 => _365.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, parent.id), 'optionalAccess', _359 => _359.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, parent.id), 'optionalAccess', _366 => _366.parent]), () => ( null));
       }
       return !covered;
     });
@@ -8435,7 +8503,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         out.push({ nodeId: node.id, effectId: effect.id });
       }
     }
-    const made = out.some((o) => !_optionalChain([targets, 'access', _360 => _360.find, 'call', _361 => _361((n2) => n2.id === o.nodeId), 'optionalAccess', _362 => _362.effects, 'optionalAccess', _363 => _363.some, 'call', _364 => _364((e) => e.id === o.effectId)]));
+    const made = out.some((o) => !_optionalChain([targets, 'access', _367 => _367.find, 'call', _368 => _368((n2) => n2.id === o.nodeId), 'optionalAccess', _369 => _369.effects, 'optionalAccess', _370 => _370.some, 'call', _371 => _371((e) => e.id === o.effectId)]));
     const merge = options.merge ? `envelope:${out.map((o) => o.nodeId).join(",")}` : void 0;
     this.change(made ? params.style === "mesh" ? "Make Envelope with Mesh" : "Make Envelope with Warp" : "Edit Envelope", () => this.setDoc(mapTree(this.doc.nodes, (n2) => _nullishCoalesce(next.get(n2.id), () => ( n2)))), merge);
     return out;
@@ -8454,11 +8522,11 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     const sorted = ids.filter((id) => order.has(id)).sort((a, b) => order.get(a) - order.get(b));
     const topId = sorted[sorted.length - 1];
     const top = this.getNode(topId);
-    const outline = _optionalChain([top, 'optionalAccess', _365 => _365.type]) === "path" ? top.subpaths.find((sp) => sp.closed && sp.anchors.length > 1) : void 0;
+    const outline = _optionalChain([top, 'optionalAccess', _372 => _372.type]) === "path" ? top.subpaths.find((sp) => sp.closed && sp.anchors.length > 1) : void 0;
     if (!top || !outline) return { ok: false, message: "The top object must be a path with a closed outline." };
     const contents = sorted.slice(0, -1).map((id) => this.getNode(id));
     if (contents.some((n2) => n2.locked)) return { ok: false, message: "Locked objects cannot be enveloped." };
-    const parents = contents.map((n2) => _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, n2.id), 'optionalAccess', _366 => _366.parent, 'optionalAccess', _367 => _367.id]), () => ( null)));
+    const parents = contents.map((n2) => _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, n2.id), 'optionalAccess', _373 => _373.parent, 'optionalAccess', _374 => _374.id]), () => ( null)));
     if (parents.some((p) => p !== parents[0])) return { ok: false, message: "The objects to envelope must be in the same group." };
     const target = contents.length === 1 ? contents[0] : { id: this.newId(), type: "group", name: "Envelope", children: contents.map((n2) => n2) };
     const parentToDoc = parents[0] ? this.worldOf(parents[0]) : _chunkFODKPD44cjs.IDENTITY_MATRIX;
@@ -8499,7 +8567,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    * comes back as a path above each of them. One undo step; returns the new paths' ids.
    */
   releaseEnvelope(options = {}) {
-    const targets = this.envelopeTargets(options.ids).filter((n2) => _optionalChain([n2, 'access', _368 => _368.effects, 'optionalAccess', _369 => _369.some, 'call', _370 => _370((e) => e.type === "envelope")]));
+    const targets = this.envelopeTargets(options.ids).filter((n2) => _optionalChain([n2, 'access', _375 => _375.effects, 'optionalAccess', _376 => _376.some, 'call', _377 => _377((e) => e.type === "envelope")]));
     if (!targets.length) return [];
     const created = [];
     const replace = /* @__PURE__ */ new Map();
@@ -8776,8 +8844,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     if (!ids.length) return null;
     const locs = ids.map((id2) => _chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
     if (locs.some((l) => !l)) return null;
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _371 => _371[0], 'access', _372 => _372.parent, 'optionalAccess', _373 => _373.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _374 => _374.parent, 'optionalAccess', _375 => _375.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _378 => _378[0], 'access', _379 => _379.parent, 'optionalAccess', _380 => _380.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _381 => _381.parent, 'optionalAccess', _382 => _382.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -8800,7 +8868,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   }
   /** Replaces selected groups with their children. */
   ungroup(options = {}) {
-    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n2) => _optionalChain([n2, 'optionalAccess', _376 => _376.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n2) => _optionalChain([n2, 'optionalAccess', _383 => _383.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", () => {
@@ -8900,7 +8968,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       this.change(label2, () => this.replaceNode(lone.id, { ...lone, liveBoolean: op, children }));
       return lone.id;
     }
-    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id2), 'optionalAccess', _377 => _377.parent]), () => ( null)));
+    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id2), 'optionalAccess', _384 => _384.parent]), () => ( null)));
     if (parents.every((g) => _chunkFODKPD44cjs.isVectorLiveBoolean.call(void 0, g))) {
       const set = new Set(roots);
       this.change(
@@ -8921,8 +8989,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       return parents[0].id;
     }
     if (nodes.length < 2) return null;
-    const parent = _nullishCoalesce(_optionalChain([parents, 'access', _378 => _378[0], 'optionalAccess', _379 => _379.id]), () => ( null));
-    if (parents.some((g) => (_nullishCoalesce(_optionalChain([g, 'optionalAccess', _380 => _380.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([parents, 'access', _385 => _385[0], 'optionalAccess', _386 => _386.id]), () => ( null));
+    if (parents.some((g) => (_nullishCoalesce(_optionalChain([g, 'optionalAccess', _387 => _387.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change(label2, () => {
       const set = new Set(roots);
@@ -8970,7 +9038,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   }
   /** Splits selected compound paths into one path per subpath. */
   breakApart(options = {}) {
-    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n2) => _optionalChain([n2, 'optionalAccess', _381 => _381.type]) === "path" && n2.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n2) => _optionalChain([n2, 'optionalAccess', _388 => _388.type]) === "path" && n2.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));
@@ -9038,7 +9106,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     const out = /* @__PURE__ */ new Map();
     for (const id of _nullishCoalesce(ids, () => ( this.selection))) {
       const node = this.getNode(id);
-      const group = isVectorBlendGroup(node) ? node : _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _382 => _382.parent]);
+      const group = isVectorBlendGroup(node) ? node : _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _389 => _389.parent]);
       if (isVectorBlendGroup(group)) out.set(group.id, group);
     }
     return [...out.values()];
@@ -9056,8 +9124,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     });
     if (ids.length < 2) return null;
     const locs = ids.map((id2) => _chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _383 => _383[0], 'access', _384 => _384.parent, 'optionalAccess', _385 => _385.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _386 => _386.parent, 'optionalAccess', _387 => _387.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _390 => _390[0], 'access', _391 => _391.parent, 'optionalAccess', _392 => _392.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _393 => _393.parent, 'optionalAccess', _394 => _394.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) {
@@ -9105,8 +9173,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       if (n2.blendStep) return { ok: false, message: `"${id2}" is a blend step; select its blend instead.` };
     }
     const locs = ids.map((id2) => _chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _388 => _388[0], 'access', _389 => _389.parent, 'optionalAccess', _390 => _390.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _391 => _391.parent, 'optionalAccess', _392 => _392.id]), () => ( null))) !== parent)) return { ok: false, message: "The objects must share a parent (group them, or pick objects at one level)." };
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _395 => _395[0], 'access', _396 => _396.parent, 'optionalAccess', _397 => _397.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _398 => _398.parent, 'optionalAccess', _399 => _399.id]), () => ( null))) !== parent)) return { ok: false, message: "The objects must share a parent (group them, or pick objects at one level)." };
     const order = ids.slice().sort((a, b) => locs[ids.indexOf(a)].index - locs[ids.indexOf(b)].index);
     const maskId = _nullishCoalesce(options.maskId, () => ( order[order.length - 1]));
     if (!order.includes(maskId)) return { ok: false, message: `The mask "${maskId}" must be one of the objects (${order.map((id2) => `"${id2}"`).join(", ")}).` };
@@ -9280,7 +9348,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   getShadingSelection() {
     const sel = this.shadingSel;
     const node = sel ? this.getNode(sel.nodeId) : void 0;
-    if (!sel || _optionalChain([node, 'optionalAccess', _393 => _393.type]) !== "path" || !_chunkFODKPD44cjs.isVectorShadedPaint.call(void 0, node.fill) || sel.index >= node.fill.points.length) return null;
+    if (!sel || _optionalChain([node, 'optionalAccess', _400 => _400.type]) !== "path" || !_chunkFODKPD44cjs.isVectorShadedPaint.call(void 0, node.fill) || sel.index >= node.fill.points.length) return null;
     return { ...sel, kind: node.fill.type };
   }
   /** The path `id` (or a message why it cannot take a mesh or freeform fill). */
@@ -9346,17 +9414,17 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       const b = _chunkFODKPD44cjs.vectorPathLocalBounds.call(void 0, t);
       if (!b) return { ok: false, message: `"${id}" has no area to fill.` };
       let f;
-      if (_optionalChain([input, 'access', _394 => _394.points, 'optionalAccess', _395 => _395.length])) {
+      if (_optionalChain([input, 'access', _401 => _401.points, 'optionalAccess', _402 => _402.length])) {
         f = _chunkFODKPD44cjs.sanitizeVectorShadedPaint.call(void 0, { type: "freeform", points: input.points.map((q) => ({ ...q, ...this.toLocal(id, q) })), ...input.lines ? { lines: input.lines } : {} });
         if (!f) return { ok: false, message: "Each point needs x, y (numbers) and a colour." };
-        if (input.lines && (_nullishCoalesce(_optionalChain([f, 'access', _396 => _396.lines, 'optionalAccess', _397 => _397.length]), () => ( 0))) !== input.lines.length) return { ok: false, message: `Each line needs two or more point indices from 0 to ${input.points.length - 1}, none twice in a row.` };
+        if (input.lines && (_nullishCoalesce(_optionalChain([f, 'access', _403 => _403.lines, 'optionalAccess', _404 => _404.length]), () => ( 0))) !== input.lines.length) return { ok: false, message: `Each line needs two or more point indices from 0 to ${input.points.length - 1}, none twice in a row.` };
       } else {
         const bad = (_nullishCoalesce(input.colors, () => ( []))).find((c) => !_chunkFODKPD44cjs.parseVectorColor.call(void 0, c));
         if (bad !== void 0) return { ok: false, message: `"${bad}" is not a colour.` };
         const outline = _chunkFODKPD44cjs.subpathsToBezier.call(void 0, t.subpaths);
         const inside = (q) => _chunkXGD3FSNCcjs.pointInBezierPath.call(void 0, outline, [q.x, q.y], _nullishCoalesce(t.fillRule, () => ( "nonzero")));
         const base = typeof t.fill === "string" && _chunkFODKPD44cjs.parseVectorColor.call(void 0, t.fill) ? t.fill : "#000000";
-        f = _chunkFODKPD44cjs.autoVectorFreeformGradient.call(void 0, b, _optionalChain([input, 'access', _398 => _398.colors, 'optionalAccess', _399 => _399.length]) ? input.colors : [base, "#ffffff"], inside);
+        f = _chunkFODKPD44cjs.autoVectorFreeformGradient.call(void 0, b, _optionalChain([input, 'access', _405 => _405.colors, 'optionalAccess', _406 => _406.length]) ? input.colors : [base, "#ffffff"], inside);
       }
       fills.set(id, f);
     }
@@ -9366,7 +9434,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** The mesh or freeform fill of path `id` with its points in document units, or null. */
   getShading(id) {
     const n2 = this.getNode(id);
-    if (_optionalChain([n2, 'optionalAccess', _400 => _400.type]) !== "path" || !_chunkFODKPD44cjs.isVectorShadedPaint.call(void 0, n2.fill)) return null;
+    if (_optionalChain([n2, 'optionalAccess', _407 => _407.type]) !== "path" || !_chunkFODKPD44cjs.isVectorShadedPaint.call(void 0, n2.fill)) return null;
     const world = this.worldOf(id);
     return _chunkFODKPD44cjs.mapVectorShadedPaint.call(void 0, n2.fill, (q) => _chunkFODKPD44cjs.applyMatrix.call(void 0, world, q));
   }
@@ -9473,7 +9541,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     if (typeof t === "string") return { ok: false, message: t };
     if (!_chunkFODKPD44cjs.isVectorFreeformGradient.call(void 0, t.fill)) return { ok: false, message: `"${id}" has no freeform gradient fill (add one with vector.setFreeformGradient).` };
     const f = _chunkFODKPD44cjs.sanitizeVectorShadedPaint.call(void 0, { ...t.fill, lines });
-    if ((_nullishCoalesce(_optionalChain([f, 'access', _401 => _401.lines, 'optionalAccess', _402 => _402.length]), () => ( 0))) !== lines.length) return { ok: false, message: `Each line needs two or more point indices from 0 to ${t.fill.points.length - 1}, none twice in a row.` };
+    if ((_nullishCoalesce(_optionalChain([f, 'access', _408 => _408.lines, 'optionalAccess', _409 => _409.length]), () => ( 0))) !== lines.length) return { ok: false, message: `Each line needs two or more point indices from 0 to ${t.fill.points.length - 1}, none twice in a row.` };
     const { lines: _l, ...rest } = t.fill;
     this.setFills("Freeform Lines", /* @__PURE__ */ new Map([[id, lines.length ? { ...rest, lines: f.lines } : rest]]));
     return { ok: true };
@@ -9493,7 +9561,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   penAngles() {
     if (!this.snap.polarRelative || !this.pen) return {};
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _403 => _403.subpaths, 'access', _404 => _404[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _410 => _410.subpaths, 'access', _411 => _411[this.pen.subpath]]);
     if (!sp || sp.anchors.length < 2) return {};
     const n2 = sp.anchors.length;
     const a = getAnchorWorld(this.doc, { nodeId: this.pen.nodeId, subpath: this.pen.subpath, index: n2 - 2 });
@@ -9611,7 +9679,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     const pen = this.pen;
     const node = pen ? this.getNode(pen.nodeId) : void 0;
     const sp = pen && node ? node.subpaths[pen.subpath] : void 0;
-    if (!pen || !node || !_optionalChain([sp, 'optionalAccess', _405 => _405.anchors, 'access', _406 => _406.length])) return { ok: false, message: "Start a path with the pen first: typed entry places its next point." };
+    if (!pen || !node || !_optionalChain([sp, 'optionalAccess', _412 => _412.anchors, 'access', _413 => _413.length])) return { ok: false, message: "Start a path with the pen first: typed entry places its next point." };
     const last = getAnchorWorld(this.doc, { nodeId: pen.nodeId, subpath: pen.subpath, index: sp.anchors.length - 1 });
     const num = "(-?(?:\\d+\\.?\\d*|\\.\\d+))";
     const t = text.replace(/\s+/g, "");
@@ -9620,7 +9688,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     if (m = t.match(new RegExp(`^@${num},${num}$`))) target = { x: last.x + parseFloat(m[1]), y: last.y + parseFloat(m[2]) };
     else if (m = t.match(new RegExp(`^${num},${num}$`))) target = { x: parseFloat(m[1]), y: parseFloat(m[2]) };
     else if (m = t.match(new RegExp(`^${num}<${num}$`))) {
-      const base = this.snap.polarRelative ? (_nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _407 => _407.penAngles, 'call', _408 => _408(), 'access', _409 => _409.angles, 'optionalAccess', _410 => _410[0]]), () => ( this.snap.angles[0])), () => ( 0))) - (_nullishCoalesce(this.snap.angles[0], () => ( 0))) : 0;
+      const base = this.snap.polarRelative ? (_nullishCoalesce(_nullishCoalesce(_optionalChain([this, 'access', _414 => _414.penAngles, 'call', _415 => _415(), 'access', _416 => _416.angles, 'optionalAccess', _417 => _417[0]]), () => ( this.snap.angles[0])), () => ( 0))) - (_nullishCoalesce(this.snap.angles[0], () => ( 0))) : 0;
       const dir = vectorAngleDirection(parseFloat(m[2]) + base);
       const len2 = parseFloat(m[1]);
       target = { x: last.x + dir.x * len2, y: last.y + dir.y * len2 };
@@ -9648,7 +9716,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    */
   addPathByDimensions(input) {
     if (!input.start || !Number.isFinite(input.start.x) || !Number.isFinite(input.start.y)) return { ok: false, message: "start must be { x, y } in document units." };
-    if (!_optionalChain([input, 'access', _411 => _411.steps, 'optionalAccess', _412 => _412.length])) return { ok: false, message: "Give at least one step." };
+    if (!_optionalChain([input, 'access', _418 => _418.steps, 'optionalAccess', _419 => _419.length])) return { ok: false, message: "Give at least one step." };
     const pts = [{ x: input.start.x, y: input.start.y }];
     for (const [i, step] of input.steps.entries()) {
       const at = pts[pts.length - 1];
@@ -9682,7 +9750,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   downConnector(p) {
     const before = this.snapshot();
     const target = _chunkFODKPD44cjs.vectorConnectorTargetAt.call(void 0, this.doc.nodes, p, this.connectorRadius());
-    const at = _nullishCoalesce(_optionalChain([target, 'optionalAccess', _413 => _413.site]), () => ( p));
+    const at = _nullishCoalesce(_optionalChain([target, 'optionalAccess', _420 => _420.site]), () => ( p));
     const node = {
       id: this.newId(),
       type: "path",
@@ -9827,8 +9895,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       const r = _chunkFODKPD44cjs.routeVectorConnector.call(void 0, this.doc.nodes, n2.id);
       const world = _nullishCoalesce(_chunkFODKPD44cjs.vectorWorldMatrix.call(void 0, this.doc.nodes, n2.id), () => ( _chunkFODKPD44cjs.IDENTITY_MATRIX));
       const sp = n2.subpaths[0];
-      const first = _optionalChain([sp, 'optionalAccess', _414 => _414.anchors, 'access', _415 => _415[0]]);
-      const last = _optionalChain([sp, 'optionalAccess', _416 => _416.anchors, 'access', _417 => _417[sp.anchors.length - 1]]);
+      const first = _optionalChain([sp, 'optionalAccess', _421 => _421.anchors, 'access', _422 => _422[0]]);
+      const last = _optionalChain([sp, 'optionalAccess', _423 => _423.anchors, 'access', _424 => _424[sp.anchors.length - 1]]);
       const end = (e, side, a) => {
         const at = a ? _chunkFODKPD44cjs.applyMatrix.call(void 0, world, a) : null;
         return { ...e ? { nodeId: e.nodeId, side: _nullishCoalesce(e.side, () => ( "auto")), resolvedSide: side } : {}, ...at ? { x: at.x, y: at.y } : {} };
@@ -9838,8 +9906,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         ...n2.name ? { name: n2.name } : {},
         route: _nullishCoalesce(n2.connector.route, () => ( "straight")),
         ...n2.connector.radius ? { radius: n2.connector.radius } : {},
-        start: end(n2.connector.start, _nullishCoalesce(_optionalChain([r, 'optionalAccess', _418 => _418.startSide]), () => ( null)), first),
-        end: end(n2.connector.end, _nullishCoalesce(_optionalChain([r, 'optionalAccess', _419 => _419.endSide]), () => ( null)), last)
+        start: end(n2.connector.start, _nullishCoalesce(_optionalChain([r, 'optionalAccess', _425 => _425.startSide]), () => ( null)), first),
+        end: end(n2.connector.end, _nullishCoalesce(_optionalChain([r, 'optionalAccess', _426 => _426.endSide]), () => ( null)), last)
       });
     });
     return out;
@@ -9906,7 +9974,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     }
     const locs = ids.map((id2) => _chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
     const parent = _nullishCoalesce(locs[0].parent, () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _420 => _420.parent, 'optionalAccess', _421 => _421.id]), () => ( null))) !== (_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _422 => _422.id]), () => ( null))))) return { ok: false, message: "The objects must share a parent (pick objects at one level)." };
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _427 => _427.parent, 'optionalAccess', _428 => _428.id]), () => ( null))) !== (_nullishCoalesce(_optionalChain([parent, 'optionalAccess', _429 => _429.id]), () => ( null))))) return { ok: false, message: "The objects must share a parent (pick objects at one level)." };
     const b = _chunkFODKPD44cjs.unionBounds.call(void 0, ids.map((id2) => _chunkFODKPD44cjs.vectorNodeBounds.call(void 0, this.getNode(id2))));
     if (!b) return { ok: false, message: "The objects have no extent to frame." };
     const id = this.newId();
@@ -9946,7 +10014,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       const n2 = this.getNode(id);
       if (_chunkFODKPD44cjs.isVectorFrame.call(void 0, n2)) out.set(n2.id, n2);
       else if (!ids) {
-        const parent = _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _423 => _423.parent]);
+        const parent = _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _430 => _430.parent]);
         if (_chunkFODKPD44cjs.isVectorFrame.call(void 0, parent)) out.set(parent.id, parent);
       }
     }
@@ -10015,7 +10083,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     if (!ids.length) return { ok: false, message: "Select objects inside a frame first." };
     for (const id of ids) {
       if (!this.getNode(id)) return { ok: false, message: `There is no node "${id}".` };
-      if (!_chunkFODKPD44cjs.isVectorFrame.call(void 0, _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _424 => _424.parent]))) return { ok: false, message: `"${id}" is not directly inside a frame: resizing constraints only apply to a frame's children.` };
+      if (!_chunkFODKPD44cjs.isVectorFrame.call(void 0, _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _431 => _431.parent]))) return { ok: false, message: `"${id}" is not directly inside a frame: resizing constraints only apply to a frame's children.` };
     }
     const set = new Set(ids);
     this.change("Constraints", () => {
@@ -10036,7 +10104,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
             artboard: parent === null,
             frame: n2.frame,
             bounds: _chunkFODKPD44cjs.vectorNodeBounds.call(void 0, n2, _nullishCoalesce(_chunkFODKPD44cjs.vectorParentMatrix.call(void 0, this.doc.nodes, n2.id), () => ( _chunkFODKPD44cjs.IDENTITY_MATRIX))),
-            children: n2.children.map((c) => ({ id: c.id, type: c.type, ...c.name ? { name: c.name } : {}, horizontal: _nullishCoalesce(_optionalChain([c, 'access', _425 => _425.resizing, 'optionalAccess', _426 => _426.horizontal]), () => ( "left")), vertical: _nullishCoalesce(_optionalChain([c, 'access', _427 => _427.resizing, 'optionalAccess', _428 => _428.vertical]), () => ( "top")) }))
+            children: n2.children.map((c) => ({ id: c.id, type: c.type, ...c.name ? { name: c.name } : {}, horizontal: _nullishCoalesce(_optionalChain([c, 'access', _432 => _432.resizing, 'optionalAccess', _433 => _433.horizontal]), () => ( "left")), vertical: _nullishCoalesce(_optionalChain([c, 'access', _434 => _434.resizing, 'optionalAccess', _435 => _435.vertical]), () => ( "top")) }))
           });
         }
         if (n2.type === "group") visit(n2.children, n2.id);
@@ -10057,7 +10125,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       const n2 = this.getNode(id);
       if (_chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, n2)) out.set(n2.id, n2);
       else {
-        const parent = _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _429 => _429.parent]);
+        const parent = _optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _436 => _436.parent]);
         if (_chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, parent)) out.set(parent.id, parent);
       }
     }
@@ -10079,7 +10147,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         const children = [...contents, mask];
         released.push(...children.map((c) => c.id));
         const { mask: _m, ...rest } = g;
-        const keep = !!(_optionalChain([g, 'access', _430 => _430.filters, 'optionalAccess', _431 => _431.length]) || g.blendMode && g.blendMode !== "normal" || _optionalChain([g, 'access', _432 => _432.effects, 'optionalAccess', _433 => _433.length]));
+        const keep = !!(_optionalChain([g, 'access', _437 => _437.filters, 'optionalAccess', _438 => _438.length]) || g.blendMode && g.blendMode !== "normal" || _optionalChain([g, 'access', _439 => _439.effects, 'optionalAccess', _440 => _440.length]));
         if (keep) {
           this.replaceNode(g.id, { ...rest, children });
           continue;
@@ -10163,7 +10231,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     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([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _434 => _434.parent, 'optionalAccess', _435 => _435.id]), () => ( null));
+    const parentOf = (id) => _nullishCoalesce(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _441 => _441.parent, 'optionalAccess', _442 => _442.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", () => {
@@ -10233,7 +10301,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   replaceBlendSpine(options = {}) {
     const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
     const groups = this.blendTargets(roots);
-    const paths = roots.map((id) => this.getNode(id)).filter((n2) => _optionalChain([n2, 'optionalAccess', _436 => _436.type]) === "path" && !n2.blendStep && !isVectorBlendGroup(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, n2.id), 'optionalAccess', _437 => _437.parent])));
+    const paths = roots.map((id) => this.getNode(id)).filter((n2) => _optionalChain([n2, 'optionalAccess', _443 => _443.type]) === "path" && !n2.blendStep && !isVectorBlendGroup(_optionalChain([_chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, n2.id), 'optionalAccess', _444 => _444.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];
@@ -10264,7 +10332,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   shapeBuilderMap(ids) {
     const roots = _nullishCoalesce(ids, () => ( this.selectedRoots()));
     const key = roots.join("\0");
-    if (_optionalChain([this, 'access', _438 => _438.builderCache, 'optionalAccess', _439 => _439.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
+    if (_optionalChain([this, 'access', _445 => _445.builderCache, 'optionalAccess', _446 => _446.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 };
@@ -10324,9 +10392,9 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         const list = [];
         const r = plan.replace.get(i);
         if (r === void 0) list.push(node);
-        else if (_optionalChain([r, 'optionalAccess', _440 => _440.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: _chunkFODKPD44cjs.bezierToSubpaths.call(void 0, toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _441 => _441.kind]) === "outline") list.push({ ...node, subpaths: _chunkFODKPD44cjs.bezierToSubpaths.call(void 0, toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _442 => _442.kind]) === "pieces") {
+        else if (_optionalChain([r, 'optionalAccess', _447 => _447.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: _chunkFODKPD44cjs.bezierToSubpaths.call(void 0, toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _448 => _448.kind]) === "outline") list.push({ ...node, subpaths: _chunkFODKPD44cjs.bezierToSubpaths.call(void 0, toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _449 => _449.kind]) === "pieces") {
           r.paths.forEach(
             (path, k) => list.push({ ...node, id: k === 0 ? node.id : this.newId(), subpaths: _chunkFODKPD44cjs.bezierToSubpaths.call(void 0, toLocal(path)).map((sp) => ({ ...sp, closed: false })) })
           );
@@ -10360,7 +10428,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   }
   /** The paint bucket's map of the visible outlines, cached per document and gap. */
   fillMap(gap) {
-    if (_optionalChain([this, 'access', _443 => _443.fillCache, 'optionalAccess', _444 => _444.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
+    if (_optionalChain([this, 'access', _450 => _450.fillCache, 'optionalAccess', _451 => _451.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;
@@ -10374,8 +10442,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    */
   fillRegion(point, options = {}) {
     if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) return null;
-    const region = _optionalChain([this, 'access', _445 => _445.fillMap, 'call', _446 => _446(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _447 => _447.regionAt, 'call', _448 => _448([point.x, point.y])]);
-    if (!_optionalChain([region, 'optionalAccess', _449 => _449.length])) return null;
+    const region = _optionalChain([this, 'access', _452 => _452.fillMap, 'call', _453 => _453(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _454 => _454.regionAt, 'call', _455 => _455([point.x, point.y])]);
+    if (!_optionalChain([region, 'optionalAccess', _456 => _456.length])) return null;
     let below = null;
     const roots = new Set(this.selectedRoots());
     _chunkFODKPD44cjs.walkVectorNodes.call(void 0, this.doc.nodes, (n2) => {
@@ -10401,7 +10469,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** 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', _450 => _450.fillMap, 'call', _451 => _451(this.editing.fillGap), 'optionalAccess', _452 => _452.regionAt, 'call', _453 => _453([p.x, p.y])]), () => ( null));
+      const region = _nullishCoalesce(_optionalChain([this, 'access', _457 => _457.fillMap, 'call', _458 => _458(this.editing.fillGap), 'optionalAccess', _459 => _459.regionAt, 'call', _460 => _460([p.x, p.y])]), () => ( null));
       const key2 = region ? _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, region, { precision: 2 }) : null;
       if (key2 === this.builderHoverKey) return false;
       this.builderHoverKey = key2;
@@ -10509,7 +10577,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** `doc` with anchor `ref` moved to document point `to` by a Curvature-tool move. */
   curvatureMoved(doc, ref, to) {
     const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _454 => _454.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _461 => _461.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, (n2) => n2.id === ref.nodeId ? { ...node, subpaths } : n2);
@@ -10518,7 +10586,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** `doc` with segment `ref` bent through document point `p` at parameter `t`. */
   bent(doc, ref, t, p) {
     const node = _chunkFODKPD44cjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _455 => _455.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _462 => _462.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, (n2) => n2.id === ref.nodeId ? { ...node, subpaths } : n2) };
@@ -10529,7 +10597,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    */
   bendSegment(ref, to, t = 0.5) {
     const node = this.getNode(ref.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _456 => _456.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _463 => _463.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", () => {
@@ -10564,7 +10632,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** 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', _457 => _457.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _464 => _464.type]) !== "path") return null;
     const hit = _chunkFODKPD44cjs.nearestSegment.call(void 0, node, this.toLocal(nodeId, point));
     if (!hit) return null;
     const { subpath, index } = _chunkFODKPD44cjs.insertAnchor.call(void 0, node.subpaths[hit.subpath], hit.segment, hit.t);
@@ -10608,7 +10676,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n2 = this.getNode(nodeId);
-      return _optionalChain([n2, 'optionalAccess', _458 => _458.type]) === "path" ? n2.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n2, 'optionalAccess', _465 => _465.type]) === "path" ? n2.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", () => {
@@ -10629,7 +10697,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       this.setDoc(
         mapTree(
           this.doc.nodes,
-          (n2) => n2.type === "path" && set.has(n2.id) ? { ...n2, subpaths: n2.subpaths.map(_chunkFODKPD44cjs.reverseSubpath), ..._optionalChain([n2, 'access', _459 => _459.strokeWidthProfile, 'optionalAccess', _460 => _460.length]) ? { strokeWidthProfile: _chunkFODKPD44cjs.reverseWidthProfile.call(void 0, n2.strokeWidthProfile) } : {} } : n2
+          (n2) => n2.type === "path" && set.has(n2.id) ? { ...n2, subpaths: n2.subpaths.map(_chunkFODKPD44cjs.reverseSubpath), ..._optionalChain([n2, 'access', _466 => _466.strokeWidthProfile, 'optionalAccess', _467 => _467.length]) ? { strokeWidthProfile: _chunkFODKPD44cjs.reverseWidthProfile.call(void 0, n2.strokeWidthProfile) } : {} } : n2
         )
       );
       this.anchors = [];
@@ -10767,7 +10835,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    */
   cutPathAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _461 => _461.type]) !== "path" || node.locked) return null;
+    if (_optionalChain([node, 'optionalAccess', _468 => _468.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
     const hit = _chunkFODKPD44cjs.nearestSegment.call(void 0, node, local);
     if (!hit) return null;
@@ -10817,7 +10885,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       if (n2.visible === false || n2.locked || parent && blocked.has(parent.id)) blocked.add(n2.id);
     });
     const visible = (p) => !blocked.has(p.id);
-    if (_optionalChain([ids, 'optionalAccess', _462 => _462.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
+    if (_optionalChain([ids, 'optionalAccess', _469 => _469.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
     const box = _chunkFODKPD44cjs.polylineBounds.call(void 0, points.map(toPoint2), pad);
     if (!box) return [];
     const out = [];
@@ -10903,7 +10971,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _463 => _463.subpaths, 'access', _464 => _464[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _470 => _470.subpaths, 'access', _471 => _471[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -10947,7 +11015,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _465 => _465.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
+          if (_optionalChain([data, 'optionalAccess', _472 => _472.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
         } catch (e7) {
           nodes = null;
         }
@@ -10959,7 +11027,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         }
       }
     } else nodes = this.clipboard;
-    if (!_optionalChain([nodes, 'optionalAccess', _466 => _466.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _473 => _473.length])) return [];
     const offset = _nullishCoalesce(options.offset, () => ( (text && !text.trim().startsWith("{") ? { x: 0, y: 0 } : { x: 10, y: 10 })));
     const copies = nodes.map((n2) => _chunkFODKPD44cjs.transformVectorNode.call(void 0, this.freshIds(n2), _chunkFODKPD44cjs.translateMatrix.call(void 0, offset.x, offset.y)));
     this.change("Paste", () => {
@@ -11010,7 +11078,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
       const a = getAnchorWorld(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _467 => _467[ref.handle]]);
+      const h = _optionalChain([a, 'optionalAccess', _474 => _474[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;
@@ -11163,7 +11231,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     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', _468 => _468.hover, 'optionalAccess', _469 => _469.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
+    return spot && spot.nodeId !== _optionalChain([this, 'access', _475 => _475.hover, 'optionalAccess', _476 => _476.nodeId]) ? this.hitWidthHandleIn(screen, { ...this.widthView(), hover: { nodeId: spot.nodeId } }) : null;
   }
   hitWidthHandleIn(screen, view) {
     let best = null;
@@ -11218,9 +11286,9 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   downWidth(screen, p, input) {
     const hit = this.hitWidthHandle(screen);
     const spot = hit ? null : this.strokeSpotAt(p);
-    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _470 => _470.ref, 'access', _471 => _471.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _472 => _472.nodeId])));
+    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _477 => _477.ref, 'access', _478 => _478.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _479 => _479.nodeId])));
     const node = nodeId ? this.getNode(nodeId) : void 0;
-    const g = _optionalChain([node, 'optionalAccess', _473 => _473.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
+    const g = _optionalChain([node, 'optionalAccess', _480 => _480.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
     if (this.widthEdit) this.widthEdit = null;
     if (!node || node.type !== "path" || !g) {
       if (!input.shift) this.widthPoints = [];
@@ -11240,7 +11308,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     if (hit) {
       profile = _chunkFODKPD44cjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
       ref = { nodeId: node.id, index: hit.ref.index, subpath: hit.ref.subpath };
-      t = _nullishCoalesce(_optionalChain([profile, 'access', _474 => _474[ref.index], 'optionalAccess', _475 => _475.t]), () => ( 0));
+      t = _nullishCoalesce(_optionalChain([profile, 'access', _481 => _481[ref.index], 'optionalAccess', _482 => _482.t]), () => ( 0));
       subpath = hit.ref.subpath;
       if (hit.ref.part === "center") mode = input.alt && profile.length < _chunkFODKPD44cjs.VECTOR_WIDTH_PROFILE_MAX_POINTS ? "copy" : "move";
       else if (input.alt) side = hit.ref.part;
@@ -11405,7 +11473,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     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', _476 => _476.hitAnchor, 'call', _477 => _477(screen, refs), 'optionalAccess', _478 => _478.index]), () => ( null));
+      anchor = _nullishCoalesce(_optionalChain([this, 'access', _483 => _483.hitAnchor, 'call', _484 => _484(screen, refs), 'optionalAccess', _485 => _485.index]), () => ( null));
     }
     return { nodeId: node.id, anchor };
   }
@@ -11558,7 +11626,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _479 => _479.getNode, 'call', _480 => _480(this.pen.nodeId), 'optionalAccess', _481 => _481.subpaths, 'access', _482 => _482[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _486 => _486.getNode, 'call', _487 => _487(this.pen.nodeId), 'optionalAccess', _488 => _488.subpaths, 'access', _489 => _489[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -11683,7 +11751,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         return;
       case "textSelect": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _483 => _483.type]) === "text" && this.textEdit) {
+        if (_optionalChain([node, 'optionalAccess', _490 => _490.type]) === "text" && this.textEdit) {
           this.textEdit = { ...this.textEdit, focus: _chunkFODKPD44cjs.vectorTextIndexAt.call(void 0, node, this.toLocal(node.id, p)) };
           this.notify();
         }
@@ -11849,15 +11917,15 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         if (!_chunkFODKPD44cjs.isVectorConnector.call(void 0, node)) return;
         const target = _chunkFODKPD44cjs.vectorConnectorTargetAt.call(void 0, this.doc.nodes, p, this.connectorRadius(), drag.nodeId);
         const startGlue = node.connector.start;
-        const end = target && target.nodeId !== _optionalChain([startGlue, 'optionalAccess', _484 => _484.nodeId]) ? { nodeId: target.nodeId, ...target.side && target.side !== "auto" ? { side: target.side } : {} } : null;
-        const first = _nullishCoalesce(_optionalChain([node, 'access', _485 => _485.subpaths, 'access', _486 => _486[0], 'optionalAccess', _487 => _487.anchors, 'access', _488 => _488[0]]), () => ( drag.start));
+        const end = target && target.nodeId !== _optionalChain([startGlue, 'optionalAccess', _491 => _491.nodeId]) ? { nodeId: target.nodeId, ...target.side && target.side !== "auto" ? { side: target.side } : {} } : null;
+        const first = _nullishCoalesce(_optionalChain([node, 'access', _492 => _492.subpaths, 'access', _493 => _493[0], 'optionalAccess', _494 => _494.anchors, 'access', _495 => _495[0]]), () => ( drag.start));
         this.replaceNode(drag.nodeId, { ...node, connector: { ...node.connector, end }, subpaths: [{ closed: false, anchors: [{ x: first.x, y: first.y }, { x: p.x, y: p.y }] }] });
         this.notify(true);
         return;
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _489 => _489.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _496 => _496.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);
@@ -11931,14 +11999,14 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         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', _490 => _490.pressures, 'optionalAccess', _491 => _491.push, 'call', _492 => _492(drag.pressure)]);
+          _optionalChain([drag, 'access', _497 => _497.pressures, 'optionalAccess', _498 => _498.push, 'call', _499 => _499(drag.pressure)]);
           moved = true;
         }
         const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _493 => _493.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _500 => _500.type]) !== "path") return;
         if (!moved) {
-          if (string && _optionalChain([this, 'access', _494 => _494.interaction, 'optionalAccess', _495 => _495.type]) === "draw") {
+          if (string && _optionalChain([this, 'access', _501 => _501.interaction, 'optionalAccess', _502 => _502.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();
           }
@@ -11974,8 +12042,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     }
     this.setGuides(res);
     return {
-      dx: _optionalChain([res, 'optionalAccess', _496 => _496.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
-      dy: _optionalChain([res, 'optionalAccess', _497 => _497.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+      dx: _optionalChain([res, 'optionalAccess', _503 => _503.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: _optionalChain([res, 'optionalAccess', _504 => _504.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. */
@@ -12065,7 +12133,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         if (drag.moved) return this.commit("Corner Radius", drag.before);
         if (drag.alt) {
           const kind = _chunkFODKPD44cjs.nextVectorCornerKind.call(void 0, drag.widget.kind);
-          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => _chunkFODKPD44cjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _498 => _498.corner, 'optionalAccess', _499 => _499.radius]), () => ( 0)), kind));
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => _chunkFODKPD44cjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _505 => _505.corner, 'optionalAccess', _506 => _506.radius]), () => ( 0)), kind));
           return this.commit("Corner Kind", drag.before);
         }
         const ref = drag.widget.ref;
@@ -12080,7 +12148,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
           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', _500 => _500.renumber, 'optionalAccess', _501 => _501.get, 'call', _502 => _502(i)]), () => ( i)) }));
+            this.widthPoints = [drag.source, ...drag.group].map((i) => ({ ...drag.ref, index: _nullishCoalesce(_optionalChain([drag, 'access', _507 => _507.renumber, 'optionalAccess', _508 => _508.get, 'call', _509 => _509(i)]), () => ( i)) }));
           } else if (!several) this.widthPoints = [drag.ref];
           const label2 = drag.mode === "copy" ? "Copy Width Point" : drag.mode === "move" ? several ? "Move Width Points" : "Move Width Point" : several ? "Width Points" : "Width Point";
           return this.commit(label2, drag.before);
@@ -12147,14 +12215,14 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _503 => _503.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _510 => _510.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', _504 => _504.pressures, 'optionalAccess', _505 => _505.push, 'call', _506 => _506(drag.pressure)]);
+          _optionalChain([drag, 'access', _511 => _511.pressures, 'optionalAccess', _512 => _512.push, 'call', _513 => _513(drag.pressure)]);
         }
         const shape = this.editing.recognizeShapes ? recognizeInkShape(drag.points, { minSize: 6 / this.viewport.zoom }) : null;
         if (shape) {
@@ -12228,7 +12296,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       if (text) {
         if (this.tool === "select") this.setTool("type");
         const index = _chunkFODKPD44cjs.vectorTextIndexAt.call(void 0, text, this.toLocal(text.id, p));
-        if (_optionalChain([this, 'access', _507 => _507.textEdit, 'optionalAccess', _508 => _508.nodeId]) === text.id) {
+        if (_optionalChain([this, 'access', _514 => _514.textEdit, 'optionalAccess', _515 => _515.nodeId]) === text.id) {
           const [a, b] = wordAt(text.text, index);
           this.textEdit = { ...this.textEdit, anchor: a, focus: b };
           this.notify();
@@ -12253,7 +12321,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _509 => _509.hover, 'optionalAccess', _510 => _510.segment, 'optionalAccess', _511 => _511.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _516 => _516.hover, 'optionalAccess', _517 => _517.segment, 'optionalAccess', _518 => _518.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
         const seg = node ? _chunkFODKPD44cjs.nearestSegment.call(void 0, node, this.toLocal(id, p)) : null;
@@ -12357,7 +12425,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       return { ok: false, message: e instanceof Error ? e.message : String(e) };
     }
     if (next === node) return { ok: true };
-    const pending = _optionalChain([this, 'access', _512 => _512.textEdit, 'optionalAccess', _513 => _513.nodeId]) === id ? this.textEdit.before : null;
+    const pending = _optionalChain([this, 'access', _519 => _519.textEdit, 'optionalAccess', _520 => _520.nodeId]) === id ? this.textEdit.before : null;
     const before = _nullishCoalesce(pending, () => ( this.snapshot()));
     if (pending && this.textEdit) this.textEdit.before = null;
     this.replaceNode(id, next);
@@ -12457,10 +12525,10 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       let frame;
       if (kind === "point") {
         const first = layout.lines[0];
-        const x = _nullishCoalesce(patch.x, () => ( (cur.kind === "point" ? cur.x : _nullishCoalesce(_optionalChain([first, 'optionalAccess', _514 => _514.x]), () => ( box.x)))));
-        const y = _nullishCoalesce(patch.y, () => ( (cur.kind === "point" ? cur.y : _nullishCoalesce(_optionalChain([first, 'optionalAccess', _515 => _515.baseline]), () => ( box.y)))));
+        const x = _nullishCoalesce(patch.x, () => ( (cur.kind === "point" ? cur.x : _nullishCoalesce(_optionalChain([first, 'optionalAccess', _521 => _521.x]), () => ( box.x)))));
+        const y = _nullishCoalesce(patch.y, () => ( (cur.kind === "point" ? cur.y : _nullishCoalesce(_optionalChain([first, 'optionalAccess', _522 => _522.baseline]), () => ( box.y)))));
         frame = _chunkFODKPD44cjs.sanitizeVectorTextFrame.call(void 0, { kind: "point", x, y });
-        if (cur.kind !== "point" && first && _optionalChain([n2, 'access', _516 => _516.paragraph, 'optionalAccess', _517 => _517.align]) && n2.paragraph.align !== "left") frame = _chunkFODKPD44cjs.sanitizeVectorTextFrame.call(void 0, { kind: "point", x: box.x, y });
+        if (cur.kind !== "point" && first && _optionalChain([n2, 'access', _523 => _523.paragraph, 'optionalAccess', _524 => _524.align]) && n2.paragraph.align !== "left") frame = _chunkFODKPD44cjs.sanitizeVectorTextFrame.call(void 0, { kind: "point", x: box.x, y });
       } else if (kind === "area") {
         const base = cur.kind === "area" ? cur : { x: box.x, y: box.y, width: Math.max(box.width, n2.font.fontSize), height: Math.max(box.height, n2.font.fontSize * 1.2) };
         frame = _chunkFODKPD44cjs.sanitizeVectorTextFrame.call(void 0, { kind: "area", x: _nullishCoalesce(patch.x, () => ( base.x)), y: _nullishCoalesce(patch.y, () => ( base.y)), width: _nullishCoalesce(patch.width, () => ( base.width)), height: _nullishCoalesce(patch.height, () => ( base.height)) });
@@ -12532,15 +12600,15 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         ...t.locked ? { locked: true } : {},
         ...t.opacity !== void 0 ? { opacity: t.opacity } : {},
         ...t.blendMode ? { blendMode: t.blendMode } : {},
-        ..._optionalChain([t, 'access', _518 => _518.filters, 'optionalAccess', _519 => _519.length]) ? { filters: t.filters } : {},
-        ..._optionalChain([t, 'access', _520 => _520.effects, 'optionalAccess', _521 => _521.length]) ? { effects: t.effects } : {},
+        ..._optionalChain([t, 'access', _525 => _525.filters, 'optionalAccess', _526 => _526.length]) ? { filters: t.filters } : {},
+        ..._optionalChain([t, 'access', _527 => _527.effects, 'optionalAccess', _528 => _528.length]) ? { effects: t.effects } : {},
         ...t.booleanOperation ? { booleanOperation: t.booleanOperation } : {}
       };
       const pathOf = (fill, path, id) => {
         const { transform: _t, visible: _v, locked: _l, opacity: _o, blendMode: _b, filters: _f, effects: _e, booleanOperation: _bo, name: _n, ...style } = _chunkFODKPD44cjs.vectorTextPaintSource.call(void 0, t, fill, _chunkFODKPD44cjs.bezierToSubpaths.call(void 0, path));
         return { ...style, id };
       };
-      if (parts.length <= 1) replaced.set(t.id, { ...pathOf(_optionalChain([parts, 'access', _522 => _522[0], 'optionalAccess', _523 => _523.fill]), _nullishCoalesce(_optionalChain([parts, 'access', _524 => _524[0], 'optionalAccess', _525 => _525.path]), () => ( [])), t.id), ...keep });
+      if (parts.length <= 1) replaced.set(t.id, { ...pathOf(_optionalChain([parts, 'access', _529 => _529[0], 'optionalAccess', _530 => _530.fill]), _nullishCoalesce(_optionalChain([parts, 'access', _531 => _531[0], 'optionalAccess', _532 => _532.path]), () => ( [])), t.id), ...keep });
       else replaced.set(t.id, { id: t.id, type: "group", ...keep, children: parts.map((p) => ({ ...pathOf(p.fill, p.path, this.newId()), name: "Outlines" })) });
     }
     if (this.textEdit && replaced.has(this.textEdit.nodeId)) this.endTextEdit();
@@ -12550,7 +12618,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   /** The layout of text node `id` (lines, glyphs, bounds, overflow), or null. */
   getTextLayout(id) {
     const node = this.getNode(id);
-    return _optionalChain([node, 'optionalAccess', _526 => _526.type]) === "text" ? _chunkFODKPD44cjs.layoutVectorText.call(void 0, node) : null;
+    return _optionalChain([node, 'optionalAccess', _533 => _533.type]) === "text" ? _chunkFODKPD44cjs.layoutVectorText.call(void 0, node) : null;
   }
   // --- Editing on the canvas ------------------------------------------------
   /**
@@ -12560,12 +12628,12 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   editText(id, options = {}) {
     const node = this.textNode(id);
     if (typeof node === "string") return { ok: false, message: node };
-    if (_optionalChain([this, 'access', _527 => _527.textEdit, 'optionalAccess', _528 => _528.nodeId]) !== id) this.endTextEdit();
+    if (_optionalChain([this, 'access', _534 => _534.textEdit, 'optionalAccess', _535 => _535.nodeId]) !== id) this.endTextEdit();
     const n2 = node.text.length;
     const clamp = (v, d) => Math.max(0, Math.min(n2, _nullishCoalesce(v, () => ( d))));
     const focus = clamp(_nullishCoalesce(options.focus, () => ( options.index)), n2);
     const anchor = clamp(options.anchor, focus);
-    this.textEdit = { nodeId: id, anchor, focus, before: _optionalChain([this, 'access', _529 => _529.textEdit, 'optionalAccess', _530 => _530.nodeId]) === id ? this.textEdit.before : null, key: _optionalChain([this, 'access', _531 => _531.textEdit, 'optionalAccess', _532 => _532.nodeId]) === id ? this.textEdit.key : `text-edit:${id}:${++this.textEditCount}`, created: _optionalChain([this, 'access', _533 => _533.textEdit, 'optionalAccess', _534 => _534.nodeId]) === id ? this.textEdit.created : false };
+    this.textEdit = { nodeId: id, anchor, focus, before: _optionalChain([this, 'access', _536 => _536.textEdit, 'optionalAccess', _537 => _537.nodeId]) === id ? this.textEdit.before : null, key: _optionalChain([this, 'access', _538 => _538.textEdit, 'optionalAccess', _539 => _539.nodeId]) === id ? this.textEdit.key : `text-edit:${id}:${++this.textEditCount}`, created: _optionalChain([this, 'access', _540 => _540.textEdit, 'optionalAccess', _541 => _541.nodeId]) === id ? this.textEdit.created : false };
     this.selection = [id];
     this.anchors = [];
     this.notify();
@@ -12575,7 +12643,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   selectText(anchor, focus = anchor) {
     const t = this.textEdit;
     const node = t ? this.getNode(t.nodeId) : null;
-    if (!t || _optionalChain([node, 'optionalAccess', _535 => _535.type]) !== "text") return;
+    if (!t || _optionalChain([node, 'optionalAccess', _542 => _542.type]) !== "text") return;
     const n2 = node.text.length;
     this.textEdit = { ...t, anchor: Math.max(0, Math.min(n2, anchor)), focus: Math.max(0, Math.min(n2, focus)) };
     this.notify();
@@ -12590,7 +12658,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     this.textEdit = null;
     this.history.endGesture();
     const node = this.getNode(t.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _536 => _536.type]) === "text" && !node.text) {
+    if (_optionalChain([node, 'optionalAccess', _543 => _543.type]) === "text" && !node.text) {
       if (t.before) {
         this.doc = t.before.doc;
         this.selection = t.before.selection.filter((id) => this.getNode(id));
@@ -12625,7 +12693,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   textDelete(forward, word = false) {
     const t = this.textEdit;
     const node = t ? this.getNode(t.nodeId) : null;
-    if (!t || _optionalChain([node, 'optionalAccess', _537 => _537.type]) !== "text") return;
+    if (!t || _optionalChain([node, 'optionalAccess', _544 => _544.type]) !== "text") return;
     let a = Math.min(t.anchor, t.focus);
     let b = Math.max(t.anchor, t.focus);
     if (a === b) {
@@ -12642,7 +12710,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   textKey(input) {
     const t = this.textEdit;
     const node = this.getNode(t.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _538 => _538.type]) !== "text") {
+    if (_optionalChain([node, 'optionalAccess', _545 => _545.type]) !== "text") {
       this.textEdit = null;
       return false;
     }
@@ -12723,7 +12791,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   getSelectedText() {
     const t = this.textEdit;
     const node = t ? this.getNode(t.nodeId) : null;
-    if (!t || _optionalChain([node, 'optionalAccess', _539 => _539.type]) !== "text") return null;
+    if (!t || _optionalChain([node, 'optionalAccess', _546 => _546.type]) !== "text") return null;
     return node.text.slice(Math.min(t.anchor, t.focus), Math.max(t.anchor, t.focus));
   }
   /** Cut while editing text: returns the selected characters and deletes them (null when not editing). */
@@ -12797,7 +12865,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     const text = this.hitText(p);
     if (text) {
       const index = _chunkFODKPD44cjs.vectorTextIndexAt.call(void 0, text, this.toLocal(text.id, p));
-      if (_optionalChain([this, 'access', _540 => _540.textEdit, 'optionalAccess', _541 => _541.nodeId]) === text.id) {
+      if (_optionalChain([this, 'access', _547 => _547.textEdit, 'optionalAccess', _548 => _548.nodeId]) === text.id) {
         this.textEdit = { ...this.textEdit, focus: index, anchor: input.shift ? this.textEdit.anchor : index };
         this.notify();
       } else this.editText(text.id, { index });
@@ -12814,7 +12882,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     }
     if (this.tool === "typePath") {
       const path = this.hitPath(p);
-      if (!path || _optionalChain([path, 'access', _542 => _542.subpaths, 'access', _543 => _543[0], 'optionalAccess', _544 => _544.anchors, 'access', _545 => _545.length]) < 2 || hiddenOrLocked(this.doc.nodes, path.id)) return;
+      if (!path || _optionalChain([path, 'access', _549 => _549.subpaths, 'access', _550 => _550[0], 'optionalAccess', _551 => _551.anchors, 'access', _552 => _552.length]) < 2 || hiddenOrLocked(this.doc.nodes, path.id)) return;
       let node;
       try {
         node = this.createTextNode({ text: "", path: path.subpaths[0] });
@@ -12842,16 +12910,16 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
   storedDocument() {
     const edit = this.symbolEdit;
     if (!edit) return this.doc;
-    const symbols = (_nullishCoalesce(edit.host.symbols, () => ( []))).map((s) => s.id === edit.symbolId ? { ...s, nodes: this.doc.nodes } : _nullishCoalesce(_optionalChain([this, 'access', _546 => _546.doc, 'access', _547 => _547.symbols, 'optionalAccess', _548 => _548.find, 'call', _549 => _549((x) => x.id === s.id)]), () => ( s)));
+    const symbols = (_nullishCoalesce(edit.host.symbols, () => ( []))).map((s) => s.id === edit.symbolId ? { ...s, nodes: this.doc.nodes } : _nullishCoalesce(_optionalChain([this, 'access', _553 => _553.doc, 'access', _554 => _554.symbols, 'optionalAccess', _555 => _555.find, 'call', _556 => _556((x) => x.id === s.id)]), () => ( s)));
     return _chunkFODKPD44cjs.resolveVectorSymbols.call(void 0, { ...edit.host, symbols });
   }
   symbolEditState() {
     const edit = this.symbolEdit;
     if (!edit) return null;
     const host = this.storedDocument();
-    const sym = _optionalChain([host, 'access', _550 => _550.symbols, 'optionalAccess', _551 => _551.find, 'call', _552 => _552((s) => s.id === edit.symbolId)]);
+    const sym = _optionalChain([host, 'access', _557 => _557.symbols, 'optionalAccess', _558 => _558.find, 'call', _559 => _559((s) => s.id === edit.symbolId)]);
     const hostTransform = edit.origin ? [1 / edit.scale, 0, 0, 1 / edit.scale, -edit.origin.x / edit.scale + 0, -edit.origin.y / edit.scale + 0] : null;
-    return { symbolId: edit.symbolId, name: _nullishCoalesce(_optionalChain([sym, 'optionalAccess', _553 => _553.name]), () => ( edit.symbolId)), instanceId: edit.instanceId, host, hostTransform };
+    return { symbolId: edit.symbolId, name: _nullishCoalesce(_optionalChain([sym, 'optionalAccess', _560 => _560.name]), () => ( edit.symbolId)), instanceId: edit.instanceId, host, hostTransform };
   }
   /** The document's symbols (the stored ones, also while one is being edited). */
   getSymbols() {
@@ -12887,8 +12955,8 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     if (!ids.length) return { ok: false, message: "Select the objects to make a symbol from." };
     const locs = ids.map((id) => _chunkFODKPD44cjs.locateVectorNode.call(void 0, this.doc.nodes, id));
     if (locs.some((l) => !l)) return { ok: false, message: `There is no node "${ids[locs.findIndex((l) => !l)]}".` };
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _554 => _554[0], 'access', _555 => _555.parent, 'optionalAccess', _556 => _556.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _557 => _557.parent, 'optionalAccess', _558 => _558.id]), () => ( null))) !== parent)) return { ok: false, message: "The objects must share a parent (the same group) to make one symbol." };
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _561 => _561[0], 'access', _562 => _562.parent, 'optionalAccess', _563 => _563.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _564 => _564.parent, 'optionalAccess', _565 => _565.id]), () => ( null))) !== parent)) return { ok: false, message: "The objects must share a parent (the same group) to make one symbol." };
     if (ids.some((id) => hiddenOrLocked(this.doc.nodes, id))) return { ok: false, message: "Unlock and show the objects first." };
     const parentMatrix = parent ? this.worldOf(parent) : _chunkFODKPD44cjs.IDENTITY_MATRIX;
     const box = _chunkFODKPD44cjs.unionBounds.call(void 0, ids.map((id) => _chunkFODKPD44cjs.vectorNodeBounds.call(void 0, this.getNode(id), _chunkFODKPD44cjs.IDENTITY_MATRIX)));
@@ -12898,7 +12966,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     const cy = box.y + box.height / 2;
     const symbolId = this.newSymbolId();
     const instanceId = this.newId();
-    const name = _optionalChain([options, 'access', _559 => _559.name, 'optionalAccess', _560 => _560.trim, 'call', _561 => _561()]) || `Symbol ${this.getSymbols().length + 1}`;
+    const name = _optionalChain([options, 'access', _566 => _566.name, 'optionalAccess', _567 => _567.trim, 'call', _568 => _568()]) || `Symbol ${this.getSymbols().length + 1}`;
     const set = new Set(ids);
     this.change("Make Symbol", () => {
       const replace = (list) => {
@@ -12979,7 +13047,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         mapTree(this.doc.nodes, (n2) => {
           if (!set.has(n2.id) || n2.type !== "instance") return n2;
           const { art: _a, ...rest } = n2;
-          const hidden = _optionalChain([n2, 'access', _562 => _562.overrides, 'optionalAccess', _563 => _563.hidden]);
+          const hidden = _optionalChain([n2, 'access', _569 => _569.overrides, 'optionalAccess', _570 => _570.hidden]);
           const overrides = n2.overrides ? { ...n2.overrides } : null;
           if (overrides && hidden) delete overrides.hidden;
           return { ...rest, symbolId, ...overrides && Object.keys(overrides).length ? { overrides } : { overrides: void 0 } };
@@ -13010,7 +13078,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
         else o[key] = patch[key];
       }
       if (patch.hidden !== void 0) {
-        if (_optionalChain([patch, 'access', _564 => _564.hidden, 'optionalAccess', _565 => _565.length])) {
+        if (_optionalChain([patch, 'access', _571 => _571.hidden, 'optionalAccess', _572 => _572.length])) {
           const known = /* @__PURE__ */ new Set();
           _chunkFODKPD44cjs.walkVectorNodes.call(void 0, _nullishCoalesce(t.art, () => ( [])), (a) => known.add(a.id));
           const unknown = patch.hidden.filter((id) => !known.has(id));
@@ -13063,9 +13131,9 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
    */
   editSymbol(id) {
     const node = this.getNode(id);
-    const symbolId = _optionalChain([node, 'optionalAccess', _566 => _566.type]) === "instance" ? node.symbolId : id;
+    const symbolId = _optionalChain([node, 'optionalAccess', _573 => _573.type]) === "instance" ? node.symbolId : id;
     const host = this.storedDocument();
-    const sym = _optionalChain([host, 'access', _567 => _567.symbols, 'optionalAccess', _568 => _568.find, 'call', _569 => _569((s) => s.id === symbolId)]);
+    const sym = _optionalChain([host, 'access', _574 => _574.symbols, 'optionalAccess', _575 => _575.find, 'call', _576 => _576((s) => s.id === symbolId)]);
     if (!sym) return { ok: false, message: node ? `"${id}" is a ${node.type}, not a symbol instance.` : `There is no symbol or instance "${id}".` };
     if (this.symbolEdit) this.exitSymbolEdit();
     this.endTextEdit();
@@ -13073,7 +13141,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
     const fresh = this.storedDocument();
     let origin = null;
     let scale = 1;
-    const world = _optionalChain([node, 'optionalAccess', _570 => _570.type]) === "instance" ? _chunkFODKPD44cjs.vectorWorldMatrix.call(void 0, fresh.nodes, node.id) : null;
+    const world = _optionalChain([node, 'optionalAccess', _577 => _577.type]) === "instance" ? _chunkFODKPD44cjs.vectorWorldMatrix.call(void 0, fresh.nodes, node.id) : null;
     if (world) {
       const det = Math.abs(world[0] * world[3] - world[1] * world[2]);
       if (det > 1e-12) {
@@ -13147,7 +13215,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
       if (anchor === void 0) {
         if (r.subpath === void 0 || r.index === void 0) throw new VectorConstraintError(`refs[${i}]: give an anchor (subpath and index, or its id), or circle: true.`);
         const sp = node.subpaths[r.subpath];
-        if (!_optionalChain([sp, 'optionalAccess', _571 => _571.anchors, 'access', _572 => _572[r.index]])) throw new VectorConstraintError(`refs[${i}]: "${r.nodeId}" has no anchor ${r.index} on subpath ${r.subpath}.`);
+        if (!_optionalChain([sp, 'optionalAccess', _578 => _578.anchors, 'access', _579 => _579[r.index]])) throw new VectorConstraintError(`refs[${i}]: "${r.nodeId}" has no anchor ${r.index} on subpath ${r.subpath}.`);
         const withIds = withVectorAnchorIds(node);
         nodes.set(node.id, withIds);
         anchor = withIds.subpaths[r.subpath].anchors[r.index].id;
@@ -13361,7 +13429,7 @@ var VectorEditorController = (_class7 = class _VectorEditorController {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _573 => _573.getNode, 'call', _574 => _574(this.selection[0]), 'optionalAccess', _575 => _575.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _580 => _580.getNode, 'call', _581 => _581(this.selection[0]), 'optionalAccess', _582 => _582.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -13575,9 +13643,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', _576 => _576.spacing]) !== void 0 && !_chunkFODKPD44cjs.VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
-  if (_optionalChain([params, 'optionalAccess', _577 => _577.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
-  if (_optionalChain([params, 'optionalAccess', _578 => _578.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
+  if (_optionalChain([params, 'optionalAccess', _583 => _583.spacing]) !== void 0 && !_chunkFODKPD44cjs.VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
+  if (_optionalChain([params, 'optionalAccess', _584 => _584.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
+  if (_optionalChain([params, 'optionalAccess', _585 => _585.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
 };
 var POINT = { type: "object", properties: { x: { type: "number" }, y: { type: "number" } }, required: ["x", "y"] };
 var GRADIENT_PROPS = {
@@ -13680,17 +13748,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', _579 => _579.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _586 => _586.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', _580 => _580.ids, 'optionalAccess', _581 => _581.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _587 => _587.ids, 'optionalAccess', _588 => _588.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', _582 => _582.type]) !== "path" || !_optionalChain([node, 'access', _583 => _583.subpaths, 'access', _584 => _584[r.subpath], 'optionalAccess', _585 => _585.anchors, 'access', _586 => _586[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+      if (_optionalChain([node, 'optionalAccess', _589 => _589.type]) !== "path" || !_optionalChain([node, 'access', _590 => _590.subpaths, 'access', _591 => _591[r.subpath], 'optionalAccess', _592 => _592.anchors, 'access', _593 => _593[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
     }
     return refs;
   };
@@ -13714,13 +13782,13 @@ function createVectorCommands(controller, options = {}) {
           ...n2.type === "path" ? { fill: _nullishCoalesce(n2.fill, () => ( null)), stroke: _nullishCoalesce(n2.stroke, () => ( null)), strokeWidth: _nullishCoalesce(n2.strokeWidth, () => ( 1)), d: _chunkFODKPD44cjs.vectorPathData.call(void 0, n2, 2) } : n2.type === "text" ? { fill: _nullishCoalesce(n2.fill, () => ( null)), stroke: _nullishCoalesce(n2.stroke, () => ( null)), strokeWidth: _nullishCoalesce(n2.strokeWidth, () => ( 1)), text: n2.text, frame: n2.frame.kind } : n2.type === "instance" ? { symbolId: n2.symbolId, ...n2.transform ? { transform: [...n2.transform] } : {}, ...n2.overrides ? { overrides: n2.overrides } : {} } : { children: n2.children.length },
           ...n2.type === "group" && n2.blend ? { blend: { ...resolveVectorBlendOptions(n2.blend), spine: !!n2.blend.spine, keys: vectorBlendKeys(n2).map((k) => k.id) } } : {},
           ...n2.blendStep ? { blendStep: true } : {},
-          ..._optionalChain([n2, 'access', _587 => _587.effects, 'optionalAccess', _588 => _588.length]) ? { effects: n2.effects } : {},
+          ..._optionalChain([n2, 'access', _594 => _594.effects, 'optionalAccess', _595 => _595.length]) ? { effects: n2.effects } : {},
           ...n2.type === "group" && n2.liveBoolean ? { liveBoolean: n2.liveBoolean } : {},
           ...n2.booleanOperation ? { booleanOperation: n2.booleanOperation } : {},
           ...(n2.type === "path" || n2.type === "text") && Array.isArray(n2.fills) ? { fills: n2.fills } : {},
           ...(n2.type === "path" || n2.type === "text") && Array.isArray(n2.strokes) ? { strokes: n2.strokes } : {},
           ...n2.blendMode && n2.blendMode !== "normal" ? { blendMode: n2.blendMode } : {},
-          ..._optionalChain([n2, 'access', _589 => _589.filters, 'optionalAccess', _590 => _590.length]) ? { filters: n2.filters } : {},
+          ..._optionalChain([n2, 'access', _596 => _596.filters, 'optionalAccess', _597 => _597.length]) ? { filters: n2.filters } : {},
           ..._chunkFODKPD44cjs.isVectorMaskGroup.call(void 0, n2) ? { mask: _chunkFODKPD44cjs.vectorMaskSummary.call(void 0, n2) } : {},
           ..._chunkFODKPD44cjs.isVectorFrame.call(void 0, n2) ? { frameRect: n2.frame } : {},
           ...n2.resizing ? { resizing: n2.resizing } : {},
@@ -13794,7 +13862,7 @@ function createVectorCommands(controller, options = {}) {
         enabled: enabledFor,
         run: (_ctx, params) => {
           const targets = ids(params);
-          check(controller.addPaintLayer(kind, layerPatchOf(_nullishCoalesce(params, () => ( {})), keys), { ids: targets, index: _optionalChain([params, 'optionalAccess', _591 => _591.index]) }));
+          check(controller.addPaintLayer(kind, layerPatchOf(_nullishCoalesce(params, () => ( {})), keys), { ids: targets, index: _optionalChain([params, 'optionalAccess', _598 => _598.index]) }));
           return { nodes: pathsUnder(targets).map((id) => stackResult(id, kind)) };
         }
       },
@@ -13867,17 +13935,17 @@ function createVectorCommands(controller, options = {}) {
     const allowed = _chunkFODKPD44cjs.vectorFilterParamKeys.call(void 0, type);
     for (const key of Object.keys(_nullishCoalesce(params, () => ( {})))) if (!allowed.includes(key)) fail(`${type} has no parameter "${key}"; it takes ${allowed.join(", ")}.`);
   };
-  const filtersResult = (id) => ({ id, filters: _nullishCoalesce(_optionalChain([controller, 'access', _592 => _592.getNode, 'call', _593 => _593(id), 'optionalAccess', _594 => _594.filters]), () => ( [])) });
+  const filtersResult = (id) => ({ id, filters: _nullishCoalesce(_optionalChain([controller, 'access', _599 => _599.getNode, 'call', _600 => _600(id), 'optionalAccess', _601 => _601.filters]), () => ( [])) });
   const filterOf = (nodeId, filterId) => {
     const node = _nullishCoalesce(controller.getNode(nodeId), () => ( fail(`There is no node "${nodeId}".`)));
-    return _nullishCoalesce(_optionalChain([node, 'access', _595 => _595.filters, 'optionalAccess', _596 => _596.find, 'call', _597 => _597((f) => f.id === filterId)]), () => ( fail(`Node "${nodeId}" has no filter "${filterId}"; it has ${(_nullishCoalesce(node.filters, () => ( []))).map((f) => `"${f.id}" (${f.type})`).join(", ") || "none"}.`)));
+    return _nullishCoalesce(_optionalChain([node, 'access', _602 => _602.filters, 'optionalAccess', _603 => _603.find, 'call', _604 => _604((f) => f.id === filterId)]), () => ( fail(`Node "${nodeId}" has no filter "${filterId}"; it has ${(_nullishCoalesce(node.filters, () => ( []))).map((f) => `"${f.id}" (${f.type})`).join(", ") || "none"}.`)));
   };
   const maskResult = (id) => ({ id, mask: _nullishCoalesce(_chunkFODKPD44cjs.vectorMaskSummary.call(void 0, controller.getNode(id)), () => ( fail(`"${id}" is not a mask group.`))) });
   const maskInputs = (params) => {
     const list2 = [...new Set(ids(params))];
     if (list2.length < 2) fail(`Masking needs at least two objects (the mask and what it masks); got ${list2.length}. Pass ids, or select more.`);
     for (const id of list2) if (controller.getNode(id).locked) fail(`"${id}" is locked; ask the user to unlock it, or leave it out of ids.`);
-    if (_optionalChain([params, 'optionalAccess', _598 => _598.maskId]) !== void 0 && !list2.includes(params.maskId)) fail(`maskId "${params.maskId}" must be one of ids (${list2.map((id) => `"${id}"`).join(", ")}).`);
+    if (_optionalChain([params, 'optionalAccess', _605 => _605.maskId]) !== void 0 && !list2.includes(params.maskId)) fail(`maskId "${params.maskId}" must be one of ids (${list2.map((id) => `"${id}"`).join(", ")}).`);
     return list2;
   };
   const maskTargets = (params) => {
@@ -13904,7 +13972,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const list2 = maskInputs(params);
-        const r = controller.makeMask("clip", { ids: list2, ..._optionalChain([params, 'optionalAccess', _599 => _599.maskId]) ? { maskId: params.maskId } : {}, invert: _optionalChain([params, 'optionalAccess', _600 => _600.invert]) });
+        const r = controller.makeMask("clip", { ids: list2, ..._optionalChain([params, 'optionalAccess', _606 => _606.maskId]) ? { maskId: params.maskId } : {}, invert: _optionalChain([params, 'optionalAccess', _607 => _607.invert]) });
         if (!r.ok) fail(r.message);
         return maskResult(r.id);
       }
@@ -13924,7 +13992,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const list2 = maskInputs(params);
-        const r = controller.makeMask(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _601 => _601.type]), () => ( "luminance")), { ids: list2, ..._optionalChain([params, 'optionalAccess', _602 => _602.maskId]) ? { maskId: params.maskId } : {}, invert: _optionalChain([params, 'optionalAccess', _603 => _603.invert]) });
+        const r = controller.makeMask(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _608 => _608.type]), () => ( "luminance")), { ids: list2, ..._optionalChain([params, 'optionalAccess', _609 => _609.maskId]) ? { maskId: params.maskId } : {}, invert: _optionalChain([params, 'optionalAccess', _610 => _610.invert]) });
         if (!r.ok) fail(r.message);
         return maskResult(r.id);
       }
@@ -13948,9 +14016,9 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       enabled: enabledFor,
       run: (_ctx, params) => {
-        if (_optionalChain([params, 'optionalAccess', _604 => _604.type]) === void 0 && _optionalChain([params, 'optionalAccess', _605 => _605.invert]) === void 0 && _optionalChain([params, 'optionalAccess', _606 => _606.enabled]) === void 0) fail("Pass at least one of type, invert, enabled.");
+        if (_optionalChain([params, 'optionalAccess', _611 => _611.type]) === void 0 && _optionalChain([params, 'optionalAccess', _612 => _612.invert]) === void 0 && _optionalChain([params, 'optionalAccess', _613 => _613.enabled]) === void 0) fail("Pass at least one of type, invert, enabled.");
         const groups = maskTargets(params);
-        const patch = { ..._optionalChain([params, 'optionalAccess', _607 => _607.type]) ? { type: params.type } : {}, ..._optionalChain([params, 'optionalAccess', _608 => _608.invert]) !== void 0 ? { invert: params.invert } : {}, ..._optionalChain([params, 'optionalAccess', _609 => _609.enabled]) !== void 0 ? { enabled: params.enabled } : {} };
+        const patch = { ..._optionalChain([params, 'optionalAccess', _614 => _614.type]) ? { type: params.type } : {}, ..._optionalChain([params, 'optionalAccess', _615 => _615.invert]) !== void 0 ? { invert: params.invert } : {}, ..._optionalChain([params, 'optionalAccess', _616 => _616.enabled]) !== void 0 ? { enabled: params.enabled } : {} };
         check(controller.setMaskOptions(patch, { ids: groups }));
         return { groups: groups.map(maskResult) };
       }
@@ -14001,7 +14069,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const targets = ids(params);
         check(controller.setBlendMode(params.blendMode, { ids: targets }));
-        return { nodes: targets.map((id) => ({ id, blendMode: _nullishCoalesce(_optionalChain([controller, 'access', _610 => _610.getNode, 'call', _611 => _611(id), 'optionalAccess', _612 => _612.blendMode]), () => ( "normal")) })) };
+        return { nodes: targets.map((id) => ({ id, blendMode: _nullishCoalesce(_optionalChain([controller, 'access', _617 => _617.getNode, 'call', _618 => _618(id), 'optionalAccess', _619 => _619.blendMode]), () => ( "normal")) })) };
       }
     },
     {
@@ -14407,7 +14475,7 @@ function createVectorCommands(controller, options = {}) {
       keywords: ["symbol", "symbols", "library", "component", "reuse", "instance"],
       description: "Lists the document's symbols: id, name, the art's nodes (ids, types, names; use them for hidden overrides), its bounds in symbol space (around the registration point at 0, 0) and the ids of its instances. Also says which symbol is being edited in isolation, if any.",
       params: { type: "object", properties: {}, additionalProperties: false },
-      run: () => ({ symbols: controller.getSymbols().map((x) => symbolSummary(x.id)), editing: _nullishCoalesce(_optionalChain([controller, 'access', _613 => _613.getState, 'call', _614 => _614(), 'access', _615 => _615.symbolEdit, 'optionalAccess', _616 => _616.symbolId]), () => ( null)) })
+      run: () => ({ symbols: controller.getSymbols().map((x) => symbolSummary(x.id)), editing: _nullishCoalesce(_optionalChain([controller, 'access', _620 => _620.getState, 'call', _621 => _621(), 'access', _622 => _622.symbolEdit, 'optionalAccess', _623 => _623.symbolId]), () => ( null)) })
     },
     {
       ...base,
@@ -14420,7 +14488,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       enabled: enabledFor,
       run: (_ctx, params) => {
-        const r = controller.makeSymbol({ ids: ids(params), ..._optionalChain([params, 'optionalAccess', _617 => _617.name]) ? { name: params.name } : {} });
+        const r = controller.makeSymbol({ ids: ids(params), ..._optionalChain([params, 'optionalAccess', _624 => _624.name]) ? { name: params.name } : {} });
         check(r);
         return { symbolId: r.symbolId, instanceId: r.instanceId, symbol: symbolSummary(r.symbolId) };
       }
@@ -14477,10 +14545,10 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const patch = {
-          ..._optionalChain([params, 'optionalAccess', _618 => _618.scaleStrokes]) !== void 0 ? { scaleStrokes: params.scaleStrokes } : {},
-          ..._optionalChain([params, 'optionalAccess', _619 => _619.fill]) !== void 0 ? { fill: params.fill === null ? null : checkPaint(params.fill, "fill") } : {},
-          ..._optionalChain([params, 'optionalAccess', _620 => _620.stroke]) !== void 0 ? { stroke: params.stroke === null ? null : checkPaint(params.stroke, "stroke") } : {},
-          ..._optionalChain([params, 'optionalAccess', _621 => _621.hidden]) !== void 0 ? { hidden: params.hidden } : {}
+          ..._optionalChain([params, 'optionalAccess', _625 => _625.scaleStrokes]) !== void 0 ? { scaleStrokes: params.scaleStrokes } : {},
+          ..._optionalChain([params, 'optionalAccess', _626 => _626.fill]) !== void 0 ? { fill: params.fill === null ? null : checkPaint(params.fill, "fill") } : {},
+          ..._optionalChain([params, 'optionalAccess', _627 => _627.stroke]) !== void 0 ? { stroke: params.stroke === null ? null : checkPaint(params.stroke, "stroke") } : {},
+          ..._optionalChain([params, 'optionalAccess', _628 => _628.hidden]) !== void 0 ? { hidden: params.hidden } : {}
         };
         if (!Object.keys(patch).length) fail("Pass at least one of scaleStrokes, fill, stroke, hidden.");
         const targetIds = ids(params);
@@ -14565,7 +14633,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: {}, additionalProperties: false },
       enabled: () => controller.getState().symbolEdit ? true : "No symbol is being edited.",
       run: () => {
-        const id = _nullishCoalesce(_optionalChain([controller, 'access', _622 => _622.getState, 'call', _623 => _623(), 'access', _624 => _624.symbolEdit, 'optionalAccess', _625 => _625.symbolId]), () => ( null));
+        const id = _nullishCoalesce(_optionalChain([controller, 'access', _629 => _629.getState, 'call', _630 => _630(), 'access', _631 => _631.symbolEdit, 'optionalAccess', _632 => _632.symbolId]), () => ( null));
         controller.exitSymbolEdit();
         return { symbolId: id };
       }
@@ -14648,7 +14716,7 @@ function createVectorCommands(controller, options = {}) {
         additionalProperties: false
       },
       run: (_ctx, params) => {
-        if (_optionalChain([params, 'optionalAccess', _626 => _626.ids])) {
+        if (_optionalChain([params, 'optionalAccess', _633 => _633.ids])) {
           for (const id of params.ids) if (!controller.getNode(id)) fail(`There is no node "${id}".`);
         }
         return controller.toLottie(_nullishCoalesce(params, () => ( {})));
@@ -14947,7 +15015,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const { polarIncrement, additionalAngles, ...rest } = _nullishCoalesce(params, () => ( {}));
         if (!Object.keys(_nullishCoalesce(params, () => ( {}))).length) fail("Pass at least one option.");
-        if (_optionalChain([rest, 'access', _627 => _627.angles, 'optionalAccess', _628 => _628.some, 'call', _629 => _629((a) => !Number.isFinite(a))])) fail("angles must be numbers (degrees).");
+        if (_optionalChain([rest, 'access', _634 => _634.angles, 'optionalAccess', _635 => _635.some, 'call', _636 => _636((a) => !Number.isFinite(a))])) fail("angles must be numbers (degrees).");
         if (additionalAngles && polarIncrement === void 0) fail("additionalAngles go with polarIncrement.");
         const angles = _nullishCoalesce(rest.angles, () => ( (polarIncrement !== void 0 ? vectorPolarAngles(polarIncrement, additionalAngles) : void 0)));
         controller.setSnap({ ...rest, ...angles ? { angles } : {} });
@@ -15198,8 +15266,8 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       run: (_ctx, params) => {
         const list2 = ids(params);
-        check(controller.setResizing({ ..._optionalChain([params, 'optionalAccess', _630 => _630.horizontal]) ? { horizontal: params.horizontal } : {}, ..._optionalChain([params, 'optionalAccess', _631 => _631.vertical]) ? { vertical: params.vertical } : {} }, { ids: list2 }));
-        return { nodes: list2.map((id) => ({ id, horizontal: _nullishCoalesce(_optionalChain([controller, 'access', _632 => _632.getNode, 'call', _633 => _633(id), 'optionalAccess', _634 => _634.resizing, 'optionalAccess', _635 => _635.horizontal]), () => ( "left")), vertical: _nullishCoalesce(_optionalChain([controller, 'access', _636 => _636.getNode, 'call', _637 => _637(id), 'optionalAccess', _638 => _638.resizing, 'optionalAccess', _639 => _639.vertical]), () => ( "top")) })) };
+        check(controller.setResizing({ ..._optionalChain([params, 'optionalAccess', _637 => _637.horizontal]) ? { horizontal: params.horizontal } : {}, ..._optionalChain([params, 'optionalAccess', _638 => _638.vertical]) ? { vertical: params.vertical } : {} }, { ids: list2 }));
+        return { nodes: list2.map((id) => ({ id, horizontal: _nullishCoalesce(_optionalChain([controller, 'access', _639 => _639.getNode, 'call', _640 => _640(id), 'optionalAccess', _641 => _641.resizing, 'optionalAccess', _642 => _642.horizontal]), () => ( "left")), vertical: _nullishCoalesce(_optionalChain([controller, 'access', _643 => _643.getNode, 'call', _644 => _644(id), 'optionalAccess', _645 => _645.resizing, 'optionalAccess', _646 => _646.vertical]), () => ( "top")) })) };
       }
     },
     {
@@ -15381,7 +15449,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', _640 => _640.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _647 => _647.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -15420,7 +15488,7 @@ function createVectorCommands(controller, options = {}) {
         check(controller.setGradient(patch, { ids: ids(params), target: _nullishCoalesce(target, () => ( "fill")) }));
         const id = ids(params)[0];
         const node = id ? controller.getNode(id) : void 0;
-        const path = _optionalChain([node, 'optionalAccess', _641 => _641.type]) === "path" ? node : void 0;
+        const path = _optionalChain([node, 'optionalAccess', _648 => _648.type]) === "path" ? node : void 0;
         return { ok: true, ...path ? { gradient: path[_nullishCoalesce(target, () => ( "fill"))] } : {} };
       }
     },
@@ -15454,12 +15522,12 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        const refs = _optionalChain([params, 'optionalAccess', _642 => _642.anchors]) ? anchorsOf(params.anchors) : void 0;
-        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _643 => _643.ids]) ? ids(params) : void 0 };
-        if (_optionalChain([params, 'optionalAccess', _644 => _644.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind, ...params.smoothing !== void 0 ? { smoothing: params.smoothing } : {} }));
-        else if (_optionalChain([params, 'optionalAccess', _645 => _645.kind])) check(controller.setCornerKind(params.kind, target));
-        if (_optionalChain([params, 'optionalAccess', _646 => _646.radius]) === void 0 && _optionalChain([params, 'optionalAccess', _647 => _647.smoothing]) !== void 0) check(controller.setCornerSmoothing(params.smoothing, target));
-        if (_optionalChain([params, 'optionalAccess', _648 => _648.radius]) === void 0 && !_optionalChain([params, 'optionalAccess', _649 => _649.kind]) && _optionalChain([params, 'optionalAccess', _650 => _650.smoothing]) === void 0) fail("Pass `radius`, `kind` and / or `smoothing`.");
+        const refs = _optionalChain([params, 'optionalAccess', _649 => _649.anchors]) ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _650 => _650.ids]) ? ids(params) : void 0 };
+        if (_optionalChain([params, 'optionalAccess', _651 => _651.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind, ...params.smoothing !== void 0 ? { smoothing: params.smoothing } : {} }));
+        else if (_optionalChain([params, 'optionalAccess', _652 => _652.kind])) check(controller.setCornerKind(params.kind, target));
+        if (_optionalChain([params, 'optionalAccess', _653 => _653.radius]) === void 0 && _optionalChain([params, 'optionalAccess', _654 => _654.smoothing]) !== void 0) check(controller.setCornerSmoothing(params.smoothing, target));
+        if (_optionalChain([params, 'optionalAccess', _655 => _655.radius]) === void 0 && !_optionalChain([params, 'optionalAccess', _656 => _656.kind]) && _optionalChain([params, 'optionalAccess', _657 => _657.smoothing]) === void 0) fail("Pass `radius`, `kind` and / or `smoothing`.");
         return { ok: true };
       }
     },
@@ -15493,12 +15561,12 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const target = { ids: ids(params) };
-        if (_optionalChain([params, 'optionalAccess', _651 => _651.preset])) check(controller.setWidthProfile(params.preset, target));
-        else if (_optionalChain([params, 'optionalAccess', _652 => _652.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
-        else if (_optionalChain([params, 'optionalAccess', _653 => _653.taper]) || _optionalChain([params, 'optionalAccess', _654 => _654.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
+        if (_optionalChain([params, 'optionalAccess', _658 => _658.preset])) check(controller.setWidthProfile(params.preset, target));
+        else if (_optionalChain([params, 'optionalAccess', _659 => _659.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
+        else if (_optionalChain([params, 'optionalAccess', _660 => _660.taper]) || _optionalChain([params, 'optionalAccess', _661 => _661.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', _655 => _655.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _662 => _662.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -15520,10 +15588,10 @@ function createVectorCommands(controller, options = {}) {
       },
       undoable: true,
       run: (_ctx, params) => {
-        if (!_optionalChain([params, 'optionalAccess', _656 => _656.id])) fail("Pass the path `id`.");
+        if (!_optionalChain([params, 'optionalAccess', _663 => _663.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', _657 => _657.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _664 => _664.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -15536,7 +15604,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _658 => _658.ids]) ? ids(params) : void 0 });
+        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _665 => _665.ids]) ? ids(params) : void 0 });
         if (!created.length) fail("No selected path has a stroke.");
         return { ids: created };
       }
@@ -15621,7 +15689,7 @@ function createVectorCommands(controller, options = {}) {
         if (params.release) return { released: target, shapes: controller.releaseEnvelope({ ids: target }) };
         if (params.expand) return { expanded: controller.expandAppearance({ ids: target }) };
         if (params.topObject) {
-          const r = controller.makeEnvelopeWithTopObject({ ids: target, rows: _optionalChain([params, 'access', _659 => _659.mesh, 'optionalAccess', _660 => _660.rows]), columns: _optionalChain([params, 'access', _661 => _661.mesh, 'optionalAccess', _662 => _662.columns]) });
+          const r = controller.makeEnvelopeWithTopObject({ ids: target, rows: _optionalChain([params, 'access', _666 => _666.mesh, 'optionalAccess', _667 => _667.rows]), columns: _optionalChain([params, 'access', _668 => _668.mesh, 'optionalAccess', _669 => _669.columns]) });
           check(r);
           return { nodeId: r.nodeId };
         }
@@ -15761,7 +15829,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         if (params.params !== void 0 || params.enabled !== void 0) check(controller.updateEffect(params.nodeId, params.effectId, { params: params.params, enabled: params.enabled }));
         if (params.index !== void 0) check(controller.moveEffect(params.nodeId, params.effectId, params.index));
-        return { effects: _nullishCoalesce(_optionalChain([controller, 'access', _663 => _663.getNode, 'call', _664 => _664(params.nodeId), 'optionalAccess', _665 => _665.effects]), () => ( [])) };
+        return { effects: _nullishCoalesce(_optionalChain([controller, 'access', _670 => _670.getNode, 'call', _671 => _671(params.nodeId), 'optionalAccess', _672 => _672.effects]), () => ( [])) };
       }
     },
     {
@@ -15825,7 +15893,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         checkBlendOptions(params);
-        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _666 => _666.ids]) });
+        const r = controller.setBlendOptions(_nullishCoalesce(params, () => ( {})), { ids: _optionalChain([params, 'optionalAccess', _673 => _673.ids]) });
         if (!r.ok) fail(r.message);
         return { ok: true };
       }
@@ -15839,7 +15907,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _667 => _667.ids]) });
+        const groups = controller.expandBlend({ ids: _optionalChain([params, 'optionalAccess', _674 => _674.ids]) });
         if (!groups.length) fail("Select a blend to expand.");
         return { ids: groups };
       }
@@ -15853,7 +15921,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _668 => _668.ids]) });
+        const released = controller.releaseBlend({ ids: _optionalChain([params, 'optionalAccess', _675 => _675.ids]) });
         if (!released.length) fail("Select a blend to release.");
         return { ids: released };
       }
@@ -15867,7 +15935,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS } },
       undoable: true,
       run: (_ctx, params) => {
-        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _669 => _669.ids]) });
+        const r = controller.replaceBlendSpine({ ids: _optionalChain([params, 'optionalAccess', _676 => _676.ids]) });
         if (!r.ok) fail(r.message);
         return { ok: true };
       }
@@ -15981,7 +16049,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _670 => _670.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _677 => _677.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -16009,7 +16077,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', _671 => _671.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _672 => _672.keepShape]) }));
+        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _678 => _678.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _679 => _679.keepShape]) }));
         return { ok: true };
       }
     },
@@ -16064,7 +16132,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', _673 => _673.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _674 => _674.tolerance]) }));
+        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _680 => _680.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _681 => _681.tolerance]) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -16078,7 +16146,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', _675 => _675.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _676 => _676.anchors]))));
+        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _682 => _682.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _683 => _683.anchors]))));
         return { ok: true };
       }
     },
@@ -16092,7 +16160,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _677 => _677.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _678 => _678.tolerance]) }));
+        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _684 => _684.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _685 => _685.tolerance]) }));
         return { ok: true };
       }
     },
@@ -16105,7 +16173,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', _679 => _679.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _680 => _680.amount]), refs: _optionalChain([params, 'optionalAccess', _681 => _681.anchors]) }));
+        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _686 => _686.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _687 => _687.amount]), refs: _optionalChain([params, 'optionalAccess', _688 => _688.anchors]) }));
         return { ok: true };
       }
     },
@@ -16118,14 +16186,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', _682 => _682.nodeId]) !== void 0) {
+        if (_optionalChain([params, 'optionalAccess', _689 => _689.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', _683 => _683.anchors]))));
+        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _690 => _690.anchors]))));
         return { ids: controller.getState().selection };
       }
     },
@@ -16176,7 +16244,7 @@ function createVectorCommands(controller, options = {}) {
       },
       run: (_ctx, params) => {
         const patch = {};
-        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _684 => _684[key]]) !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _691 => _691[key]]) !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -16201,7 +16269,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', _685 => _685.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _692 => _692.precision]) }) })
     },
     {
       ...base,
@@ -16243,7 +16311,7 @@ function getVectorTextPanel(state) {
   }
   const typing = state.tool === "type" || state.tool === "typePath";
   const one = state.selection.length === 1 ? _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, state.selection[0]) : void 0;
-  const pathId = _optionalChain([one, 'optionalAccess', _686 => _686.type]) === "path" ? one.id : null;
+  const pathId = _optionalChain([one, 'optionalAccess', _693 => _693.type]) === "path" ? one.id : null;
   if (!nodes.length && !typing && !state.textEdit) return null;
   const styles = [];
   let target = "defaults";
@@ -16266,11 +16334,11 @@ function getVectorTextPanel(state) {
     return values.every((v) => v === values[0]) ? _nullishCoalesce(values[0], () => ( null)) : null;
   };
   const font = Object.fromEntries(FIELDS.map((k) => [k, same(k)]));
-  const alignSource = target === "defaults" ? [_nullishCoalesce(state.textDefaults.align, () => ( "left"))] : (target === "range" ? [edited] : nodes).map((n2) => _nullishCoalesce(_optionalChain([n2, 'access', _687 => _687.paragraph, 'optionalAccess', _688 => _688.align]), () => ( "left")));
+  const alignSource = target === "defaults" ? [_nullishCoalesce(state.textDefaults.align, () => ( "left"))] : (target === "range" ? [edited] : nodes).map((n2) => _nullishCoalesce(_optionalChain([n2, 'access', _694 => _694.paragraph, 'optionalAccess', _695 => _695.align]), () => ( "left")));
   const align = alignSource.every((a) => a === alignSource[0]) ? alignSource[0] : null;
   const ids = target === "range" ? [edited.id] : nodes.map((n2) => n2.id);
   const frameNode = target === "range" ? edited : nodes.length === 1 ? nodes[0] : void 0;
-  return { target, ids, font, align, frame: _nullishCoalesce(_optionalChain([frameNode, 'optionalAccess', _689 => _689.frame, 'access', _690 => _690.kind]), () => ( null)), families: _chunkFODKPD44cjs.vectorTextFamilies.call(void 0, ), outlines: _chunkFODKPD44cjs.vectorTextHasOutlines.call(void 0, ), pathId };
+  return { target, ids, font, align, frame: _nullishCoalesce(_optionalChain([frameNode, 'optionalAccess', _696 => _696.frame, 'access', _697 => _697.kind]), () => ( null)), families: _chunkFODKPD44cjs.vectorTextFamilies.call(void 0, ), outlines: _chunkFODKPD44cjs.vectorTextHasOutlines.call(void 0, ), pathId };
 }
 function applyVectorTextStyle(controller, patch, options = {}) {
   const state = controller.getState();
@@ -16300,7 +16368,7 @@ function applyVectorParagraphStyle(controller, patch, options = {}) {
 // src/vector/symbolsPanel.ts
 var fmt3 = (n2) => Math.round(n2 * 100) / 100;
 function getVectorSymbolsPanel(state, options = {}) {
-  const host = _nullishCoalesce(_optionalChain([state, 'access', _691 => _691.symbolEdit, 'optionalAccess', _692 => _692.host]), () => ( state.document));
+  const host = _nullishCoalesce(_optionalChain([state, 'access', _698 => _698.symbolEdit, 'optionalAccess', _699 => _699.host]), () => ( state.document));
   const counts = /* @__PURE__ */ new Map();
   const count = (list) => {
     for (const n2 of list) {
@@ -16321,15 +16389,15 @@ function getVectorSymbolsPanel(state, options = {}) {
       instances: _nullishCoalesce(counts.get(s.id), () => ( 0)),
       viewBox: `${fmt3(b.x - pad)} ${fmt3(b.y - pad)} ${fmt3(b.width + 2 * pad)} ${fmt3(b.height + 2 * pad)}`,
       scene,
-      editing: _optionalChain([state, 'access', _693 => _693.symbolEdit, 'optionalAccess', _694 => _694.symbolId]) === s.id
+      editing: _optionalChain([state, 'access', _700 => _700.symbolEdit, 'optionalAccess', _701 => _701.symbolId]) === s.id
     };
   });
   const one = state.selection.length === 1 ? _chunkFODKPD44cjs.findVectorNode.call(void 0, state.document.nodes, state.selection[0]) : void 0;
-  const inst = _optionalChain([one, 'optionalAccess', _695 => _695.type]) === "instance" ? one : null;
+  const inst = _optionalChain([one, 'optionalAccess', _702 => _702.type]) === "instance" ? one : null;
   return {
     symbols,
     canMake: state.selection.length > 0 && !(state.selection.length === 1 && inst),
-    instance: inst ? { id: inst.id, symbolId: inst.symbolId, scaleStrokes: inst.scaleStrokes !== false, fill: _nullishCoalesce(_optionalChain([inst, 'access', _696 => _696.overrides, 'optionalAccess', _697 => _697.fill]), () => ( null)), stroke: _nullishCoalesce(_optionalChain([inst, 'access', _698 => _698.overrides, 'optionalAccess', _699 => _699.stroke]), () => ( null)), hidden: _nullishCoalesce(_optionalChain([inst, 'access', _700 => _700.overrides, 'optionalAccess', _701 => _701.hidden, 'optionalAccess', _702 => _702.length]), () => ( 0)) } : null,
+    instance: inst ? { id: inst.id, symbolId: inst.symbolId, scaleStrokes: inst.scaleStrokes !== false, fill: _nullishCoalesce(_optionalChain([inst, 'access', _703 => _703.overrides, 'optionalAccess', _704 => _704.fill]), () => ( null)), stroke: _nullishCoalesce(_optionalChain([inst, 'access', _705 => _705.overrides, 'optionalAccess', _706 => _706.stroke]), () => ( null)), hidden: _nullishCoalesce(_optionalChain([inst, 'access', _707 => _707.overrides, 'optionalAccess', _708 => _708.hidden, 'optionalAccess', _709 => _709.length]), () => ( 0)) } : null,
     editing: state.symbolEdit ? { symbolId: state.symbolEdit.symbolId, name: state.symbolEdit.name } : null
   };
 }