@pixerate/editor 0.275.0 → 0.276.0

package/dist/{chunk-OLZXXAER.cjs → chunk-OY24XRYF.cjs}

@@ -8,7 +8,7 @@
 
 
 
-var _chunk6QNDGMK7cjs = require('./chunk-6QNDGMK7.cjs');
+var _chunkQ33V5PEFcjs = require('./chunk-Q33V5PEF.cjs');
 
 
 
@@ -74,13 +74,13 @@ var _chunkJBZRVLXVcjs = require('./chunk-JBZRVLXV.cjs');
 
 
 
-var _chunkDHC4E2DUcjs = require('./chunk-DHC4E2DU.cjs');
+var _chunkMITQGHN3cjs = require('./chunk-MITQGHN3.cjs');
 
 
 
 
 
-var _chunkSTLTOISWcjs = require('./chunk-STLTOISW.cjs');
+var _chunkNPPMKMCUcjs = require('./chunk-NPPMKMCU.cjs');
 
 
 
@@ -102,7 +102,10 @@ var _chunkSTLTOISWcjs = require('./chunk-STLTOISW.cjs');
 
 
 
-var _chunkNIBFKXMDcjs = require('./chunk-NIBFKXMD.cjs');
+
+
+
+var _chunkIFWLZZCWcjs = require('./chunk-IFWLZZCW.cjs');
 
 
 
@@ -2793,7 +2796,7 @@ function effectDabField(img, rect, cov, centre, mixed, field, steps = 0, dab = n
 var samplers = /* @__PURE__ */ new WeakMap();
 function stampSampler(ref, art, hardness = 1) {
   const sampler = baseSampler(ref, art);
-  if (!sampler || hardness >= 1 || !_chunk6QNDGMK7cjs.isBrushSourceRef.call(void 0, ref)) return sampler;
+  if (!sampler || hardness >= 1 || !_chunkQ33V5PEFcjs.isBrushSourceRef.call(void 0, ref)) return sampler;
   const h = Math.max(0, hardness);
   return (u, v2, seed) => {
     const r = Math.hypot(u, v2) / Math.SQRT2;
@@ -2868,7 +2871,7 @@ function rasterizeStampDab(d, sample, seed, rect, out) {
 }
 function brushStickerRefs(brush) {
   const refs = brush.engine === "sticker" ? [...brush.sticker.stamps] : brush.engine === "particle" ? [...brush.particle.dotTextures] : brush.engine === "dab" && brush.stamp ? [brush.stamp] : [];
-  return [...new Set(refs.filter((r) => r.includes(":") && !r.startsWith("editor:") && !_chunk6QNDGMK7cjs.isBrushSourceRef.call(void 0, r)))];
+  return [...new Set(refs.filter((r) => r.includes(":") && !r.startsWith("editor:") && !_chunkQ33V5PEFcjs.isBrushSourceRef.call(void 0, r)))];
 }
 function sprayDroplets(d, spray, seed) {
   const count = 1 + Math.round(spray.density * 31);
@@ -2950,7 +2953,7 @@ function normalizePaper(raw = {}, base) {
     preset: typeof r.preset === "string" && r.preset ? r.preset : b.preset,
     name: typeof r.name === "string" && r.name.trim() ? r.name.trim() : b.name,
     family: PAPER_FAMILIES.includes(r.family) ? r.family : b.family,
-    pattern: _chunkNIBFKXMDcjs.GRAIN_PATTERNS.includes(r.pattern) ? r.pattern : b.pattern,
+    pattern: _chunkIFWLZZCWcjs.GRAIN_PATTERNS.includes(r.pattern) ? r.pattern : b.pattern,
     seed: typeof r.seed === "number" && Number.isFinite(r.seed) ? Math.round(Math.abs(r.seed)) % 2147483647 : b.seed,
     color: typeof r.color === "string" && HEX.test(r.color) ? r.color.toLowerCase() : b.color,
     scale: clampNum(r.scale, 0.25, 8, b.scale),
@@ -2972,7 +2975,7 @@ function hexToRgb8(hex) {
   const n = parseInt(hex.slice(1, 7), 16);
   return [n >> 16 & 255, n >> 8 & 255, n & 255];
 }
-function renderPaper(paper, rect, grain = new (0, _chunkNIBFKXMDcjs.PaperGrain)(paper), light) {
+function renderPaper(paper, rect, grain = new (0, _chunkIFWLZZCWcjs.PaperGrain)(paper), light) {
   const [r, g, b] = hexToRgb8(paper.color);
   const out = new Uint8ClampedArray(rect.width * rect.height * 4);
   const shade = grain.flat ? 0 : paper.shading * 0.16;
@@ -3059,10 +3062,10 @@ var TipGrain = class _TipGrain {
    */
   static create(settings, art) {
     if (!settings || settings.depth <= 0) return null;
-    if (_chunkNIBFKXMDcjs.GRAIN_PATTERNS.includes(settings.source)) {
+    if (_chunkIFWLZZCWcjs.GRAIN_PATTERNS.includes(settings.source)) {
       if (settings.source === "smooth") return null;
       const tuning2 = { contrast: settings.contrast, invert: settings.invert };
-      const paper = new (0, _chunkNIBFKXMDcjs.PaperGrain)({ pattern: settings.source, seed: 0, scale: settings.scale, tiling: "repeat", dry: tuning2, wet: tuning2 });
+      const paper = new (0, _chunkIFWLZZCWcjs.PaperGrain)({ pattern: settings.source, seed: 0, scale: settings.scale, tiling: "repeat", dry: tuning2, wet: tuning2 });
       return new _TipGrain(paper, settings);
     }
     const a = _optionalChain([art, 'optionalCall', _62 => _62(settings.source)]);
@@ -3332,7 +3335,7 @@ var DryStroke = (_class3 = class {
   }
   
   
-  __init12() {this.coverage = new (0, _chunkNIBFKXMDcjs.CoverageMap)()}
+  __init12() {this.coverage = new (0, _chunkIFWLZZCWcjs.CoverageMap)()}
   __init13() {this.dabCount = 0}
   
   
@@ -3383,18 +3386,18 @@ var DryStroke = (_class3 = class {
   mark(m, d, rects) {
     const hardness = this.brush.tip.hardness;
     const grain = this.options.grain;
-    const rect = this.stamp ? stampDabRect(m) : _chunkNIBFKXMDcjs.dabRect.call(void 0, m, hardness);
+    const rect = this.stamp ? stampDabRect(m) : _chunkIFWLZZCWcjs.dabRect.call(void 0, m, hardness);
     const n = rect.width * rect.height;
     if (this.buf.length < n) this.buf = new Float32Array(n);
     const vals = this.buf.subarray(0, n);
     if (this.stamp) rasterizeStampDab(m, this.stamp, d.index, rect, vals);
-    else _chunkNIBFKXMDcjs.rasterizeDab.call(void 0, m, hardness, rect, vals);
+    else _chunkIFWLZZCWcjs.rasterizeDab.call(void 0, m, hardness, rect, vals);
     _optionalChain([this, 'access', _65 => _65.tipGrain, 'optionalAccess', _66 => _66.apply, 'call', _67 => _67(vals, rect, { x: m.x, y: m.y, angle: m.angle, travel: d.travel })]);
     if (this.depth > 0 && grain) {
       for (let yy = 0, k = 0; yy < rect.height; yy++) {
         const y = rect.y + yy + 0.5;
         for (let xx = 0; xx < rect.width; xx++, k++) {
-          if (vals[k] > 0) vals[k] *= _chunkNIBFKXMDcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure);
+          if (vals[k] > 0) vals[k] *= _chunkIFWLZZCWcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure);
         }
       }
     }
@@ -3476,21 +3479,21 @@ var PaintDabStroke = (_class4 = class {
     this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
     this.copies = _optionalChain([options, 'access', _68 => _68.copies, 'optionalAccess', _69 => _69.length]) ? options.copies : [IDENTITY_COPY];
     const exchanging = brush.engine === "mixer" || brush.engine === "dab";
-    const rates = brush.engine === "mixer" ? _chunkNIBFKXMDcjs.mixerRates.call(void 0, brush.mixer) : _chunkNIBFKXMDcjs.exchangeRates.call(void 0, brush.behavior.pickup, brush.behavior.mix, 1, brush.behavior.mixing);
+    const rates = brush.engine === "mixer" ? _chunkIFWLZZCWcjs.mixerRates.call(void 0, brush.mixer) : _chunkIFWLZZCWcjs.exchangeRates.call(void 0, brush.behavior.pickup, brush.behavior.mix, 1, brush.behavior.mixing);
     this.mixing = brush.engine === "mixer" ? brush.mixer.mixing : brush.behavior.mixing;
     this.states = this.copies.map((c, i) => ({
       walker: new PenDabWalker(brush, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear),
-      exchange: exchanging ? new (0, _chunkNIBFKXMDcjs.PaintExchange)(rates, options.load) : null,
-      smudge: brush.engine === "smudge" ? new (0, _chunkNIBFKXMDcjs.SmudgeTip)(brush.smudge, brush.tip.size * (1 + brush.dynamics.tiltSize * 1.5)) : null
+      exchange: exchanging ? new (0, _chunkIFWLZZCWcjs.PaintExchange)(rates, options.load) : null,
+      smudge: brush.engine === "smudge" ? new (0, _chunkIFWLZZCWcjs.SmudgeTip)(brush.smudge, brush.tip.size * (1 + brush.dynamics.tiltSize * 1.5)) : null
     }));
-    this.medium = new (0, _chunkNIBFKXMDcjs.TileMedium)(options.target, brush.engine === "dab" ? { blend: brush.tip.blend } : {});
+    this.medium = new (0, _chunkIFWLZZCWcjs.TileMedium)(options.target, brush.engine === "dab" ? { blend: brush.tip.blend } : {});
     this.depth = options.grain && !options.grain.flat ? Math.min(1, Math.max(0, options.paperDepth * brush.grain)) : 0;
-    this.coverage = brush.engine === "dab" ? new (0, _chunkNIBFKXMDcjs.CoverageMap)() : null;
-    this.sampler = exchanging && options.paint ? new (0, _chunkNIBFKXMDcjs.PaintGradientSampler)(options.paint, _nullishCoalesce(options.seed, () => ( 0))) : null;
+    this.coverage = brush.engine === "dab" ? new (0, _chunkIFWLZZCWcjs.CoverageMap)() : null;
+    this.sampler = exchanging && options.paint ? new (0, _chunkIFWLZZCWcjs.PaintGradientSampler)(options.paint, _nullishCoalesce(options.seed, () => ( 0))) : null;
     const table = _optionalChain([this, 'access', _70 => _70.sampler, 'optionalAccess', _71 => _71.acrossTip]) ? this.sampler.tipTable(GRADIENT_STEPS) : null;
     this.gradient = table ? table.map((e) => e.rgb) : null;
     this.gradientAlpha = table && table.some((e) => e.alpha < 1) ? table.map((e) => e.alpha) : null;
-    this.scratch = brush.engine === "blender" ? _chunkNIBFKXMDcjs.createBlenderScratch.call(void 0, ) : null;
+    this.scratch = brush.engine === "blender" ? _chunkIFWLZZCWcjs.createBlenderScratch.call(void 0, ) : null;
   }
   
   
@@ -3554,7 +3557,7 @@ var PaintDabStroke = (_class4 = class {
   paintDabs(copy, dabs, rects) {
     const spray = this.brush.engine === "dab" ? this.brush.spray : null;
     for (const d of spray ? dabs.flatMap((dab) => sprayDroplets(dab, spray, (_nullishCoalesce(this.options.seed, () => ( 0))) + copy * 7919)) : dabs) {
-      const rect = this.stamp ? stampDabRect(d) : _chunkNIBFKXMDcjs.dabRect.call(void 0, d, this.brush.tip.hardness);
+      const rect = this.stamp ? stampDabRect(d) : _chunkIFWLZZCWcjs.dabRect.call(void 0, d, this.brush.tip.hardness);
       if (rect.width <= 0 || rect.height <= 0) continue;
       this.dab(copy, d, rect);
       rects.push(rect);
@@ -3571,14 +3574,14 @@ var PaintDabStroke = (_class4 = class {
     const tip = this.tip.subarray(0, n);
     tip.fill(0);
     if (this.stamp) rasterizeStampDab({ ...d, alpha: 1 }, this.stamp, d.index, rect, tip);
-    else _chunkNIBFKXMDcjs.rasterizeDab.call(void 0, { ...d, alpha: 1 }, this.brush.tip.hardness, rect, tip);
+    else _chunkIFWLZZCWcjs.rasterizeDab.call(void 0, { ...d, alpha: 1 }, this.brush.tip.hardness, rect, tip);
     _optionalChain([this, 'access', _76 => _76.tipGrain, 'optionalAccess', _77 => _77.apply, 'call', _78 => _78(tip, rect, d)]);
     if (!(this.depth > 0 && this.options.grain)) return { tip, cov: tip };
     const cov = this.cov.subarray(0, n);
     const grain = this.options.grain;
     for (let yy = 0, k = 0; yy < rect.height; yy++) {
       const y = rect.y + yy + 0.5;
-      for (let xx = 0; xx < rect.width; xx++, k++) cov[k] = tip[k] > 0 ? tip[k] * _chunkNIBFKXMDcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure) : 0;
+      for (let xx = 0; xx < rect.width; xx++, k++) cov[k] = tip[k] > 0 ? tip[k] * _chunkIFWLZZCWcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, y), this.depth, d.pressure) : 0;
     }
     return { tip, cov };
   }
@@ -3587,7 +3590,7 @@ var PaintDabStroke = (_class4 = class {
     const { tip, cov } = this.rasterize(d, rect);
     const st = this.states[copy];
     if (brush.engine === "blender") {
-      _chunkNIBFKXMDcjs.blenderDab.call(void 0, this.medium, rect, cov, d.opacity * d.alpha * brush.tip.opacity, d.radius, brush.blender, this.scratch);
+      _chunkIFWLZZCWcjs.blenderDab.call(void 0, this.medium, rect, cov, d.opacity * d.alpha * brush.tip.opacity, d.radius, brush.blender, this.scratch);
       return;
     }
     if (brush.engine === "smudge") {
@@ -3703,7 +3706,7 @@ var PaintDabStroke = (_class4 = class {
 
 // src/paint-editor/wet.ts
 var STROKE_WATER = 0.9;
-var STROKE_MASS = _chunkDHC4E2DUcjs.PIGMENT_UNIT * 2.5;
+var STROKE_MASS = _chunkMITQGHN3cjs.PIGMENT_UNIT * 2.5;
 var STROKE_LIGHT = 1.5;
 var COVERAGE_STEPS = 4096;
 function union(a, b) {
@@ -3713,7 +3716,7 @@ function union(a, b) {
   return { x, y, width: Math.max(a.x + a.width, b.x + b.width) - x, height: Math.max(a.y + a.height, b.y + b.height) - y };
 }
 function wetPaperInput(paper) {
-  const grain = new (0, _chunkNIBFKXMDcjs.PaperGrain)(paper, "wet");
+  const grain = new (0, _chunkIFWLZZCWcjs.PaperGrain)(paper, "wet");
   const flat = grain.flat;
   return {
     absorption: paper.absorption,
@@ -3734,27 +3737,27 @@ var WetStrokeDriver = (_class5 = class {
     const perDab = Math.min(1, spacing * 1.2);
     const thin = wet.thinner;
     const body = wet.body * (1 - thin);
-    this.medium = new (0, _chunkDHC4E2DUcjs.WetMedium)(init.world, init.laneId, {
+    this.medium = new (0, _chunkMITQGHN3cjs.WetMedium)(init.world, init.laneId, {
       water: STROKE_WATER * Math.min(1, wet.water * (1 + thin)) * perDab,
       mass: STROKE_MASS * wet.pigment * (1 - 0.6 * thin) * perDab,
       body,
       light: 0
     });
     if (wet.tool === "paint" && brush.ghost && wet.pigment > 0) {
-      const one = _chunkDHC4E2DUcjs.pigmentOf.call(void 0, init.color, body);
+      const one = _chunkMITQGHN3cjs.pigmentOf.call(void 0, init.color, body);
       init.world.startGhost(init.laneId, [one[0], one[1], one[2], one[3]], brush.ghost.linger, _nullishCoalesce(init.speed, () => ( 120)), _nullishCoalesce(brush.ghost.trigger, () => ( "immediate")));
     }
     this.lightBase = wet.tool === "paint" ? STROKE_LIGHT * brush.light.amount * (1 - 0.6 * thin) * perDab : 0;
-    const rates = _chunkNIBFKXMDcjs.exchangeRates.call(void 0, brush.behavior.pickup, brush.behavior.mix, wet.load, brush.behavior.mixing);
+    const rates = _chunkIFWLZZCWcjs.exchangeRates.call(void 0, brush.behavior.pickup, brush.behavior.mix, wet.load, brush.behavior.mixing);
     this.states = copies.map((c, i) => ({
       walker: new PenDabWalker(brush, init.seed + i * 7919 | 0, c.linear),
-      exchange: wet.tool === "paint" ? new (0, _chunkNIBFKXMDcjs.PaintExchange)(rates, init.load) : null,
+      exchange: wet.tool === "paint" ? new (0, _chunkIFWLZZCWcjs.PaintExchange)(rates, init.load) : null,
       last: null
     }));
     this.copies = copies;
     this.depth = init.grain && !init.grain.flat ? Math.min(1, Math.max(0, init.paperDepth * brush.grain)) : 0;
     const g = _nullishCoalesce(init.paint, () => ( null));
-    this.sampler = g ? new (0, _chunkNIBFKXMDcjs.PaintGradientSampler)(g.map.by === "across-tip" ? { ...g, map: { by: "distance", length: 300, repeat: "mirror" } } : g, init.seed) : null;
+    this.sampler = g ? new (0, _chunkIFWLZZCWcjs.PaintGradientSampler)(g.map.by === "across-tip" ? { ...g, map: { by: "distance", length: 300, repeat: "mirror" } } : g, init.seed) : null;
   }
   
   __init28() {this.dabCount = 0}
@@ -3828,7 +3831,7 @@ var WetStrokeDriver = (_class5 = class {
   }
   applyDabs(copy, dabs, rects) {
     for (const d of dabs) {
-      const rect = _chunkNIBFKXMDcjs.dabRect.call(void 0, d, this.init.brush.tip.hardness);
+      const rect = _chunkIFWLZZCWcjs.dabRect.call(void 0, d, this.init.brush.tip.hardness);
       if (rect.width <= 0 || rect.height <= 0) continue;
       this.dab(copy, d, rect);
       rects.push(rect);
@@ -3845,7 +3848,7 @@ var WetStrokeDriver = (_class5 = class {
     const tip = this.tip.subarray(0, n);
     const cov = this.cov.subarray(0, n);
     tip.fill(0);
-    _chunkNIBFKXMDcjs.rasterizeDab.call(void 0, { ...d, alpha: 1 }, this.init.brush.tip.hardness, rect, tip);
+    _chunkIFWLZZCWcjs.rasterizeDab.call(void 0, { ...d, alpha: 1 }, this.init.brush.tip.hardness, rect, tip);
     const grain = this.depth > 0 ? this.init.grain : null;
     const mask = this.init.mask;
     for (let yy = 0, k = 0; yy < rect.height; yy++) {
@@ -3856,7 +3859,7 @@ var WetStrokeDriver = (_class5 = class {
           tip[k] *= mx >= 0 && my >= 0 && mx < mask.width && my < mask.height ? mask.data[my * mask.width + mx] / 255 : 0;
         }
         let v2 = tip[k];
-        if (v2 > 0 && grain) v2 *= _chunkNIBFKXMDcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, rect.y + yy + 0.5), this.depth, d.pressure);
+        if (v2 > 0 && grain) v2 *= _chunkIFWLZZCWcjs.grainCatch.call(void 0, grain.at(rect.x + xx + 0.5, rect.y + yy + 0.5), this.depth, d.pressure);
         tip[k] = Math.round(tip[k] * COVERAGE_STEPS) / COVERAGE_STEPS;
         cov[k] = Math.round(v2 * COVERAGE_STEPS) / COVERAGE_STEPS;
       }
@@ -3914,6 +3917,17 @@ var WetStrokeDriver = (_class5 = class {
         } else world.paint(laneId, rect, cov, this.medium.options.water * k, null);
         ex.drain();
         if (wet.rewet > 0) world.rewet(laneId, rect, cov, wet.rewet * k * 0.15, this.init.paperColor);
+        if (brush.livePatterns) {
+          world.seedLivePatterns(
+            laneId,
+            d.x,
+            d.y,
+            Math.max(2, d.radius),
+            this.init.seed + this.dabCount * 131 + copy * 997 | 0,
+            Math.max(0.65, d.pressure),
+            brush.livePatterns
+          );
+        }
         break;
       }
       case "water": {
@@ -3953,7 +3967,7 @@ var WET_GPU_MODES = ["auto", "off"];
 var GPU_LEAD = 16;
 var DISPLAY_TILES_PER_TICK = 24;
 var PaintWetLayers = (_class6 = class {
-  constructor(host, options = {}) {;_class6.prototype.__init41.call(this);_class6.prototype.__init42.call(this);_class6.prototype.__init43.call(this);_class6.prototype.__init44.call(this);_class6.prototype.__init45.call(this);_class6.prototype.__init46.call(this);_class6.prototype.__init47.call(this);_class6.prototype.__init48.call(this);_class6.prototype.__init49.call(this);_class6.prototype.__init50.call(this);_class6.prototype.__init51.call(this);_class6.prototype.__init52.call(this);_class6.prototype.__init53.call(this);_class6.prototype.__init54.call(this);_class6.prototype.__init55.call(this);_class6.prototype.__init56.call(this);
+  constructor(host, options = {}) {;_class6.prototype.__init41.call(this);_class6.prototype.__init42.call(this);_class6.prototype.__init43.call(this);_class6.prototype.__init44.call(this);_class6.prototype.__init45.call(this);_class6.prototype.__init46.call(this);_class6.prototype.__init47.call(this);_class6.prototype.__init48.call(this);_class6.prototype.__init49.call(this);_class6.prototype.__init50.call(this);_class6.prototype.__init51.call(this);_class6.prototype.__init52.call(this);_class6.prototype.__init53.call(this);_class6.prototype.__init54.call(this);_class6.prototype.__init55.call(this);_class6.prototype.__init56.call(this);_class6.prototype.__init57.call(this);
     this.host = host;
     this.options = options;
     this.speed = Math.max(1, Math.min(2e3, _nullishCoalesce(options.speed, () => ( 120))));
@@ -3964,32 +3978,33 @@ var PaintWetLayers = (_class6 = class {
   
   
   __init41() {this.world = null}
-  __init42() {this.tilt = { ..._chunkDHC4E2DUcjs.FLAT }}
+  __init42() {this.tilt = { ..._chunkMITQGHN3cjs.FLAT }}
   __init43() {this.settings = /* @__PURE__ */ new Map()}
-  __init44() {this.paused = false}
+  __init44() {this.patterns = /* @__PURE__ */ new Map()}
+  __init45() {this.paused = false}
   /** Wet strokes dry as soon as they end (one undo step with the stroke). */
-  __init45() {this.instantDry = false}
+  __init46() {this.instantDry = false}
   
-  __init46() {this.overlay = false}
+  __init47() {this.overlay = false}
   
   /** The live wet stroke, if any. */
-  __init47() {this.driver = null}
-  __init48() {this.lastTick = null}
-  __init49() {this.ticking = null}
-  __init50() {this.stepsOwed = 0}
-  __init51() {this.displaying = null}
-  __init52() {this.leadAt = 0}
+  __init48() {this.driver = null}
+  __init49() {this.lastTick = null}
+  __init50() {this.ticking = null}
+  __init51() {this.stepsOwed = 0}
+  __init52() {this.displaying = null}
+  __init53() {this.leadAt = 0}
   
   
-  __init53() {this.gpu = null}
-  __init54() {this.gpuSupport = null}
-  __init55() {this.gpuStarting = null}
+  __init54() {this.gpu = null}
+  __init55() {this.gpuSupport = null}
+  __init56() {this.gpuStarting = null}
   // --- Engine B ------------------------------------------------------------------
   /** Starts the GPU engine for the world (once; it may turn out unavailable). */
   startGpu() {
     if (this.gpuMode === "off" || this.gpu || this.gpuStarting || this.gpuSupport) return;
-    const provider = this.options.gpuProvider === void 0 ? _chunkDHC4E2DUcjs.findWebGpu.call(void 0, ) : this.options.gpuProvider;
-    this.gpuStarting = _chunkDHC4E2DUcjs.createWetGpuEngine.call(void 0, provider).then(({ engine, support }) => {
+    const provider = this.options.gpuProvider === void 0 ? _chunkMITQGHN3cjs.findWebGpu.call(void 0, ) : this.options.gpuProvider;
+    this.gpuStarting = _chunkMITQGHN3cjs.createWetGpuEngine.call(void 0, provider).then(({ engine, support }) => {
       this.gpuSupport = support;
       if (!engine) return;
       if (this.gpuMode === "off" || !this.world) {
@@ -4048,7 +4063,7 @@ var PaintWetLayers = (_class6 = class {
     return this.world;
   }
   makeWorld(width, height, paper) {
-    const world = new (0, _chunkDHC4E2DUcjs.WetWorld)(width, height, wetPaperInput(paper), { kernel: this.options.kernel, threads: this.options.threads });
+    const world = new (0, _chunkMITQGHN3cjs.WetWorld)(width, height, wetPaperInput(paper), { kernel: this.options.kernel, threads: this.options.threads });
     world.setTilt(this.tilt);
     world.gpuMinTiles = this.gpuMinTiles;
     if (this.gpu) world.attachGpu(this.gpu);
@@ -4060,7 +4075,7 @@ var PaintWetLayers = (_class6 = class {
    * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
    */
   canExtend(left2, top) {
-    return left2 % _chunkDHC4E2DUcjs.WET_TILE === 0 && top % _chunkDHC4E2DUcjs.WET_TILE === 0 && !this.driver;
+    return left2 % _chunkMITQGHN3cjs.WET_TILE === 0 && top % _chunkMITQGHN3cjs.WET_TILE === 0 && !this.driver;
   }
   /**
    * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
@@ -4072,22 +4087,31 @@ var PaintWetLayers = (_class6 = class {
   extend(width, height, left2, top, paper) {
     if (!this.canExtend(left2, top)) throw new Error("Wet paint only moves by whole 256 px tiles, between strokes.");
     for (const [id, s] of this.settings) if (s.flow.center) this.settings.set(id, { ...s, flow: { ...s.flow, center: { x: s.flow.center.x + left2, y: s.flow.center.y + top } } });
+    const tx0 = left2 / _chunkMITQGHN3cjs.WET_TILE;
+    const ty0 = top / _chunkMITQGHN3cjs.WET_TILE;
+    for (const [id, f] of this.patterns) {
+      const moved2 = _chunkIFWLZZCWcjs.moveLivePatternSnapshot.call(void 0, f.snapshot(), { width, height }, tx0, ty0);
+      const next = new (0, _chunkIFWLZZCWcjs.LivePatternField)(width, height);
+      next.restore(moved2);
+      this.patterns.set(id, next);
+    }
     const old = this.world;
     const snap = _optionalChain([old, 'optionalAccess', _101 => _101.laneIds, 'call', _102 => _102(), 'access', _103 => _103.length]) ? old.snapshot() : null;
     this.dropWorld();
     this.lastTick = null;
     this.stepsOwed = 0;
     if (!old || !snap) return;
-    const moved = _chunkDHC4E2DUcjs.moveWetSnapshot.call(void 0, snap, old, { width, height }, left2, top, (l) => {
+    const moved = _chunkMITQGHN3cjs.moveWetSnapshot.call(void 0, snap, old, { width, height }, left2, top, (l) => {
       const flow = _optionalChain([this, 'access', _104 => _104.settings, 'access', _105 => _105.get, 'call', _106 => _106(l.id), 'optionalAccess', _107 => _107.flow]);
       return {
         base: _chunk474IQG74cjs.translateSurface.call(void 0, l.base, left2, top),
         ...l.light ? { light: _chunk474IQG74cjs.translateSurface.call(void 0, l.light, left2, top) } : {},
-        flow: l.flow && flow && flow.kind !== "none" ? _chunkDHC4E2DUcjs.flowField.call(void 0, flow, width, height) : l.flow
+        flow: l.flow && flow && flow.kind !== "none" ? _chunkMITQGHN3cjs.flowField.call(void 0, flow, width, height) : l.flow
       };
     });
     this.world = this.makeWorld(width, height, paper);
     this.world.restore(moved);
+    for (const id of this.world.laneIds()) this.patterns.set(id, this.world.livePatternField(id));
   }
   /** Whether any layer (or `layerId`) has wet paint. */
   isWet(layerId) {
@@ -4111,73 +4135,152 @@ var PaintWetLayers = (_class6 = class {
   settingsOf(layerId, medium = "watercolor") {
     let s = this.settings.get(layerId);
     if (!s) {
-      s = { params: _chunkDHC4E2DUcjs.normalizeWetParams.call(void 0, WET_MEDIUM_PARAMS[medium], _chunkDHC4E2DUcjs.DEFAULT_WET_PARAMS), flow: { ..._chunkDHC4E2DUcjs.DEFAULT_FLOW } };
+      s = { params: _chunkMITQGHN3cjs.normalizeWetParams.call(void 0, WET_MEDIUM_PARAMS[medium], _chunkMITQGHN3cjs.DEFAULT_WET_PARAMS), flow: { ..._chunkMITQGHN3cjs.DEFAULT_FLOW }, livePatterns: null };
       this.settings.set(layerId, s);
     }
     return s;
   }
+  patternFieldOf(layerId) {
+    const { width, height } = this.host.canvas();
+    let f = this.patterns.get(layerId);
+    if (!f) {
+      f = new (0, _chunkIFWLZZCWcjs.LivePatternField)(width, height);
+      const s = _optionalChain([this, 'access', _113 => _113.settings, 'access', _114 => _114.get, 'call', _115 => _115(layerId), 'optionalAccess', _116 => _116.livePatterns]);
+      if (s) f.configure(s);
+      this.patterns.set(layerId, f);
+    } else if (f.width !== width || f.height !== height) {
+      f.resize(width, height);
+    }
+    return f;
+  }
   /** Puts a layer in the world (its current pixels become the base under the wet paint). */
   ensureLane(layerId, medium) {
     const w = this.ensureWorld();
+    const lp = this.patternFieldOf(layerId);
     if (!w.hasLane(layerId)) {
       const base = _nullishCoalesce(this.host.layerSurface(layerId), () => ( new (0, _chunk474IQG74cjs.TiledSurface)(4, /* @__PURE__ */ new Map(), 0)));
       const s = this.settingsOf(layerId, medium);
-      w.ensureLane(layerId, { params: s.params, base, light: this.host.layerLight(layerId), ghost: s.ghost });
+      w.ensureLane(layerId, { params: s.params, base, light: this.host.layerLight(layerId), ghost: s.ghost, livePatterns: lp });
       const { width, height } = this.host.canvas();
-      if (s.flow.kind !== "none") w.setFlow(layerId, _chunkDHC4E2DUcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
+      if (s.flow.kind !== "none") w.setFlow(layerId, _chunkMITQGHN3cjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
     }
     return w;
   }
   setParams(layerId, update) {
     const s = this.settingsOf(layerId);
-    s.params = _chunkDHC4E2DUcjs.normalizeWetParams.call(void 0, update, s.params);
-    if (_optionalChain([this, 'access', _113 => _113.world, 'optionalAccess', _114 => _114.hasLane, 'call', _115 => _115(layerId)])) this.world.setParams(layerId, s.params);
+    s.params = _chunkMITQGHN3cjs.normalizeWetParams.call(void 0, update, s.params);
+    if (_optionalChain([this, 'access', _117 => _117.world, 'optionalAccess', _118 => _118.hasLane, 'call', _119 => _119(layerId)])) this.world.setParams(layerId, s.params);
     return { ...s.params };
   }
   setFlow(layerId, update) {
     const s = this.settingsOf(layerId);
-    s.flow = _chunkDHC4E2DUcjs.normalizeFlow.call(void 0, update, s.flow);
-    if (_optionalChain([this, 'access', _116 => _116.world, 'optionalAccess', _117 => _117.hasLane, 'call', _118 => _118(layerId)])) {
+    s.flow = _chunkMITQGHN3cjs.normalizeFlow.call(void 0, update, s.flow);
+    if (_optionalChain([this, 'access', _120 => _120.world, 'optionalAccess', _121 => _121.hasLane, 'call', _122 => _122(layerId)])) {
       const { width, height } = this.host.canvas();
-      this.world.setFlow(layerId, _chunkDHC4E2DUcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
+      this.world.setFlow(layerId, _chunkMITQGHN3cjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
     }
     return { ...s.flow };
   }
+  setLivePatterns(layerId, update) {
+    const s = this.settingsOf(layerId);
+    const f = this.patternFieldOf(layerId);
+    if (update === null) {
+      f.clear();
+      s.livePatterns = null;
+      if (_optionalChain([this, 'access', _123 => _123.world, 'optionalAccess', _124 => _124.hasLane, 'call', _125 => _125(layerId)])) this.syncDisplays();
+      return null;
+    }
+    const next = _optionalChain([this, 'access', _126 => _126.world, 'optionalAccess', _127 => _127.hasLane, 'call', _128 => _128(layerId)]) ? this.world.setLivePatterns(layerId, update) : f.configure(update);
+    s.livePatterns = { ...next };
+    this.syncDisplays();
+    return { ...next };
+  }
+  seedLivePatterns(layerId, points, radius, seed = 1, settings) {
+    const s = this.settingsOf(layerId);
+    const f = this.patternFieldOf(layerId);
+    if (settings) {
+      const next = _optionalChain([this, 'access', _129 => _129.world, 'optionalAccess', _130 => _130.hasLane, 'call', _131 => _131(layerId)]) ? this.world.setLivePatterns(layerId, settings) : f.configure(settings);
+      s.livePatterns = { ...next };
+    } else if (!f.enabled) {
+      const next = _optionalChain([this, 'access', _132 => _132.world, 'optionalAccess', _133 => _133.hasLane, 'call', _134 => _134(layerId)]) ? this.world.setLivePatterns(layerId, _nullishCoalesce(s.livePatterns, () => ( {}))) : f.configure(_nullishCoalesce(s.livePatterns, () => ( {})));
+      s.livePatterns = { ...next };
+    }
+    let seededCells = 0;
+    const hasLane = Boolean(_optionalChain([this, 'access', _135 => _135.world, 'optionalAccess', _136 => _136.hasLane, 'call', _137 => _137(layerId)]));
+    for (let i = 0; i < points.length; i++) {
+      const p = points[i];
+      const str = _nullishCoalesce(p.strength, () => ( 1));
+      const ptSeed = seed + i * 7919 | 0;
+      if (hasLane) {
+        seededCells += this.world.seedLivePatterns(layerId, p.x, p.y, radius, ptSeed, str);
+      } else {
+        seededCells += f.seedDisc(p.x, p.y, radius, ptSeed, str);
+      }
+    }
+    this.syncDisplays();
+    return { seededCells, stats: this.livePatternStats(layerId) };
+  }
+  livePatternStats(layerId) {
+    const f = this.patterns.get(layerId);
+    if (_optionalChain([f, 'optionalAccess', _138 => _138.enabled])) {
+      const s = this.settingsOf(layerId);
+      if (!s.livePatterns) s.livePatterns = { ...f.settings };
+    }
+    if (_optionalChain([this, 'access', _139 => _139.world, 'optionalAccess', _140 => _140.hasLane, 'call', _141 => _141(layerId)])) return this.world.livePatternStats(layerId);
+    if (f) return f.stats(() => false);
+    const cfg = _nullishCoalesce(_optionalChain([this, 'access', _142 => _142.settings, 'access', _143 => _143.get, 'call', _144 => _144(layerId), 'optionalAccess', _145 => _145.livePatterns]), () => ( null));
+    return {
+      enabled: Boolean(cfg),
+      settings: _chunkIFWLZZCWcjs.normalizeLivePatterns.call(void 0, _nullishCoalesce(cfg, () => ( {}))),
+      activeTiles: 0,
+      patternCells: 0,
+      wetPatternCells: 0,
+      meanV: 0,
+      maxV: 0,
+      bounds: null
+    };
+  }
   setTilt(update) {
-    this.tilt = _chunkDHC4E2DUcjs.normalizeTilt.call(void 0, update, this.tilt);
-    _optionalChain([this, 'access', _119 => _119.world, 'optionalAccess', _120 => _120.setTilt, 'call', _121 => _121(this.tilt)]);
+    this.tilt = _chunkMITQGHN3cjs.normalizeTilt.call(void 0, update, this.tilt);
+    _optionalChain([this, 'access', _146 => _146.world, 'optionalAccess', _147 => _147.setTilt, 'call', _148 => _148(this.tilt)]);
     return { ...this.tilt };
   }
   /** The paper changed. */
   paperChanged() {
-    _optionalChain([this, 'access', _122 => _122.world, 'optionalAccess', _123 => _123.setPaper, 'call', _124 => _124(wetPaperInput(this.host.paper()))]);
+    _optionalChain([this, 'access', _149 => _149.world, 'optionalAccess', _150 => _150.setPaper, 'call', _151 => _151(wetPaperInput(this.host.paper()))]);
   }
   /** A layer as tools describe it. */
   info(layerId) {
     const s = this.settingsOf(layerId);
-    const st = _optionalChain([this, 'access', _125 => _125.world, 'optionalAccess', _126 => _126.hasLane, 'call', _127 => _127(layerId)]) ? this.world.stats(layerId) : null;
-    const g = _optionalChain([this, 'access', _128 => _128.world, 'optionalAccess', _129 => _129.hasLane, 'call', _130 => _130(layerId)]) ? this.world.getGhost(layerId) : _nullishCoalesce(s.ghost, () => ( null));
+    const f = this.patterns.get(layerId);
+    if (_optionalChain([f, 'optionalAccess', _152 => _152.enabled]) && !s.livePatterns) s.livePatterns = { ...f.settings };
+    const st = _optionalChain([this, 'access', _153 => _153.world, 'optionalAccess', _154 => _154.hasLane, 'call', _155 => _155(layerId)]) ? this.world.stats(layerId) : null;
+    const g = _optionalChain([this, 'access', _156 => _156.world, 'optionalAccess', _157 => _157.hasLane, 'call', _158 => _158(layerId)]) ? this.world.getGhost(layerId) : _nullishCoalesce(s.ghost, () => ( null));
     return {
       layerId,
       wet: Boolean(st && st.wetCells > 0),
-      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _131 => _131.wetCells]), () => ( 0)),
-      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _132 => _132.wetBounds]), () => ( null)),
-      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _133 => _133.activeTiles]), () => ( 0)),
+      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _159 => _159.wetCells]), () => ( 0)),
+      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _160 => _160.wetBounds]), () => ( null)),
+      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _161 => _161.activeTiles]), () => ( 0)),
       params: { ...s.params },
       flow: { ...s.flow },
-      ...g ? { ghost: { remaining: Math.round(g.remaining * _chunkDHC4E2DUcjs.FREE_INTERVAL / this.speed * 100) / 100 } } : {}
+      livePatterns: s.livePatterns ? { ...s.livePatterns } : null,
+      ...g ? { ghost: { remaining: Math.round(g.remaining * _chunkMITQGHN3cjs.FREE_INTERVAL / this.speed * 100) / 100 } } : {}
     };
   }
   backend() {
-    return _nullishCoalesce(_optionalChain([this, 'access', _134 => _134.world, 'optionalAccess', _135 => _135.backend, 'call', _136 => _136()]), () => ( null));
+    return _nullishCoalesce(_optionalChain([this, 'access', _162 => _162.world, 'optionalAccess', _163 => _163.backend, 'call', _164 => _164()]), () => ( null));
   }
   /** Shows the current wet pixels (at most `maxTiles` reshaded per layer). */
   syncDisplays(maxTiles = Infinity) {
     const w = this.world;
+    this.syncHeights();
     if (!w) return [];
     const surfaces = /* @__PURE__ */ new Map();
     const rects = [];
     for (const id of w.laneIds()) {
+      const f = this.patterns.get(id);
+      if (_optionalChain([f, 'optionalAccess', _165 => _165.enabled])) this.settingsOf(id).livePatterns = { ...f.settings };
       const d = w.display(id, maxTiles);
       if (this.host.layerSurface(id) !== d.surface) surfaces.set(id, d.surface);
       rects.push(...d.changed);
@@ -4189,10 +4292,13 @@ var PaintWetLayers = (_class6 = class {
   /** Like `syncDisplays`, shading on the GPU when Engine B is active (all stale tiles at once). */
   async syncDisplaysGpu(maxCpuTiles, lead = false) {
     const w = this.world;
+    this.syncHeights();
     if (!w) return [];
     const surfaces = /* @__PURE__ */ new Map();
     const rects = [];
     for (const id of w.laneIds()) {
+      const f = this.patterns.get(id);
+      if (_optionalChain([f, 'optionalAccess', _166 => _166.enabled])) this.settingsOf(id).livePatterns = { ...f.settings };
       const d = await w.displayGpu(id, maxCpuTiles, lead);
       if (!w.hasLane(id)) continue;
       if (this.host.layerSurface(id) !== d.surface) surfaces.set(id, d.surface);
@@ -4202,6 +4308,18 @@ var PaintWetLayers = (_class6 = class {
     if (surfaces.size) this.host.updateSurfaces(surfaces, rects);
     return rects;
   }
+  /** Updates thick height maps for any layers with live pattern relief (`relief > 0`). */
+  syncHeights() {
+    if (!this.host.layerHeight || !this.host.updateHeights) return;
+    const heights = /* @__PURE__ */ new Map();
+    for (const [id, f] of this.patterns) {
+      if (!f.enabled || !(f.settings.relief > 0) || f.tiles.size === 0) continue;
+      const cur = _nullishCoalesce(this.host.layerHeight(id), () => ( new (0, _chunk474IQG74cjs.TiledSurface)(1, /* @__PURE__ */ new Map(), 0)));
+      const next = f.applyReliefHeight(cur);
+      if (next !== cur) heights.set(id, next);
+    }
+    if (heights.size) this.host.updateHeights(heights);
+  }
   /** Shows each wet layer's live light paint (the light under it with the wet light shaded in). */
   syncLights() {
     const w = this.world;
@@ -4218,12 +4336,12 @@ var PaintWetLayers = (_class6 = class {
     const w = this.world;
     if (!w) return;
     for (const id of w.laneIds()) {
-      if (w.isActive(id) || _optionalChain([this, 'access', _137 => _137.driver, 'optionalAccess', _138 => _138.init, 'access', _139 => _139.laneId]) === id) continue;
+      if (w.isActive(id) || _optionalChain([this, 'access', _167 => _167.driver, 'optionalAccess', _168 => _168.init, 'access', _169 => _169.laneId]) === id) continue;
       const base = w.getBase(id);
       const light = w.isLit(id) ? w.getLight(id) : null;
       w.removeLane(id);
       const s = this.settings.get(id);
-      if (_optionalChain([s, 'optionalAccess', _140 => _140.ghost])) delete s.ghost;
+      if (_optionalChain([s, 'optionalAccess', _170 => _170.ghost])) delete s.ghost;
       if (light && this.host.layerLight(id) !== light) this.host.updateLights(/* @__PURE__ */ new Map([[id, light]]));
       this.host.updateSurfaces(/* @__PURE__ */ new Map([[id, base]]), []);
     }
@@ -4302,10 +4420,10 @@ var PaintWetLayers = (_class6 = class {
     if (!d || !this.world) return;
     const rects = d.flush();
     if (rects.length) this.syncDisplays(DISPLAY_TILES_PER_TICK);
-    if (d.done) _optionalChain([this, 'access', _141 => _141.onDriverDone, 'optionalCall', _142 => _142(d)]);
+    if (d.done) _optionalChain([this, 'access', _171 => _171.onDriverDone, 'optionalCall', _172 => _172(d)]);
   }
   /** Called when a live stroke that ended mid-batch has finished applying. */
-  __init56() {this.onDriverDone = null}
+  __init57() {this.onDriverDone = null}
   /** Steps `steps` times now (agents, tests). Returns the steps run. */
   async advance(steps) {
     await this.idle();
@@ -4346,61 +4464,101 @@ var PaintWetLayers = (_class6 = class {
   /** Starts the fade countdown of an agent-triggered ghost on `layerId`. */
   releaseGhost(layerId, linger) {
     const w = this.world;
-    if (_optionalChain([w, 'optionalAccess', _143 => _143.hasLane, 'call', _144 => _144(layerId)])) w.releaseGhost(layerId, linger, this.speed);
+    if (_optionalChain([w, 'optionalAccess', _173 => _173.hasLane, 'call', _174 => _174(layerId)])) w.releaseGhost(layerId, linger, this.speed);
     const s = this.settings.get(layerId);
-    if (_optionalChain([s, 'optionalAccess', _145 => _145.ghost, 'optionalAccess', _146 => _146.trigger]) === "agent") {
+    if (_optionalChain([s, 'optionalAccess', _175 => _175.ghost, 'optionalAccess', _176 => _176.trigger]) === "agent") {
       const sec = linger !== void 0 ? Math.max(0.5, Math.min(60, linger)) : s.ghost.linger;
-      const total = Math.max(1, Math.round(sec * this.speed / _chunkDHC4E2DUcjs.FREE_INTERVAL));
+      const total = Math.max(1, Math.round(sec * this.speed / _chunkMITQGHN3cjs.FREE_INTERVAL));
       s.ghost = { ...s.ghost, linger: sec, total, remaining: total, trigger: void 0 };
     }
   }
   /** Keeps an unclaimed agent-triggered ghost on `layerId` as ordinary wet paint. */
   keepGhost(layerId) {
     const w = this.world;
-    if (_optionalChain([w, 'optionalAccess', _147 => _147.hasLane, 'call', _148 => _148(layerId)])) w.keepGhost(layerId);
+    if (_optionalChain([w, 'optionalAccess', _177 => _177.hasLane, 'call', _178 => _178(layerId)])) w.keepGhost(layerId);
     const s = this.settings.get(layerId);
-    if (_optionalChain([s, 'optionalAccess', _149 => _149.ghost])) delete s.ghost;
+    if (_optionalChain([s, 'optionalAccess', _179 => _179.ghost])) delete s.ghost;
   }
   /** The layer's light paint with all its wet paint dried (`null` without a wet layer or light), without changing anything. */
   bakedLight(layerId) {
     const w = this.world;
-    if (!_optionalChain([w, 'optionalAccess', _150 => _150.hasLane, 'call', _151 => _151(layerId)]) || !w.isLit(layerId)) return null;
+    if (!_optionalChain([w, 'optionalAccess', _180 => _180.hasLane, 'call', _181 => _181(layerId)]) || !w.isLit(layerId)) return null;
     return w.bakedLight(layerId);
   }
   /** The layer's pixels with all its wet paint dried (deterministic), without changing anything. */
   bakedSurface(layerId) {
     const w = this.world;
-    if (!_optionalChain([w, 'optionalAccess', _152 => _152.hasLane, 'call', _153 => _153(layerId)])) return null;
+    if (!_optionalChain([w, 'optionalAccess', _182 => _182.hasLane, 'call', _183 => _183(layerId)])) return null;
     return w.bakedSurface(layerId);
   }
   /** A snapshot of the world for undo (`null` when there is none). */
   snapshot() {
     const w = this.world;
-    if (!w || !w.laneIds().length) return null;
-    return w.snapshot();
+    const patterns = /* @__PURE__ */ new Map();
+    let patternBytes = 0;
+    for (const [id, f] of this.patterns) {
+      if (!f.enabled && f.tiles.size === 0) continue;
+      const ps = f.snapshot();
+      patterns.set(id, ps);
+      patternBytes += ps.bytes;
+    }
+    if (!w || !w.laneIds().length) {
+      if (!patterns.size) return null;
+      return {
+        clock: _nullishCoalesce(_optionalChain([w, 'optionalAccess', _184 => _184.clock]), () => ( 0)),
+        tilt: { ...this.tilt },
+        lanes: [],
+        slots: /* @__PURE__ */ new Map(),
+        patterns,
+        bytes: patternBytes
+      };
+    }
+    const snap = w.snapshot();
+    return patterns.size ? { ...snap, patterns } : snap;
   }
   /** Puts a snapshot back (`null`: no wet layers). Returns the layer surfaces it implies. */
   restore(snap) {
+    this.patterns.clear();
+    for (const [, s] of this.settings) s.livePatterns = null;
     if (!snap) {
       if (this.world) for (const id of this.world.laneIds()) this.world.removeLane(id);
       return;
     }
     const { width, height } = this.host.canvas();
     if (this.world && (this.world.width !== width || this.world.height !== height)) this.dropWorld();
-    this.ensureWorld().restore(snap);
+    if (snap.patterns) {
+      for (const [id, ps] of snap.patterns) {
+        const f = new (0, _chunkIFWLZZCWcjs.LivePatternField)(width, height);
+        f.restore(ps);
+        this.patterns.set(id, f);
+        this.settingsOf(id).livePatterns = f.enabled ? { ...f.settings } : null;
+      }
+    }
+    if (snap.lanes.length) {
+      const w = this.ensureWorld();
+      w.restore(snap);
+      for (const id of w.laneIds()) {
+        const f = w.livePatternField(id);
+        this.patterns.set(id, f);
+        this.settingsOf(id).livePatterns = f.enabled ? { ...f.settings } : null;
+      }
+    } else if (this.world) {
+      for (const id of this.world.laneIds()) this.world.removeLane(id);
+    }
     this.syncDisplays();
   }
   dropWorld() {
-    _optionalChain([this, 'access', _154 => _154.world, 'optionalAccess', _155 => _155.destroy, 'call', _156 => _156()]);
+    _optionalChain([this, 'access', _185 => _185.world, 'optionalAccess', _186 => _186.destroy, 'call', _187 => _187()]);
     this.world = null;
     this.driver = null;
   }
   /** Forgets everything wet (a new canvas, a resize, opening a document). */
   reset() {
-    _optionalChain([this, 'access', _157 => _157.world, 'optionalAccess', _158 => _158.destroy, 'call', _159 => _159()]);
+    _optionalChain([this, 'access', _188 => _188.world, 'optionalAccess', _189 => _189.destroy, 'call', _190 => _190()]);
     this.world = null;
     this.driver = null;
     this.settings.clear();
+    this.patterns.clear();
     this.lastTick = null;
     this.stepsOwed = 0;
   }
@@ -4427,15 +4585,15 @@ var PaintWetLayers = (_class6 = class {
     return out;
   }
   destroy() {
-    _optionalChain([this, 'access', _160 => _160.world, 'optionalAccess', _161 => _161.destroy, 'call', _162 => _162()]);
+    _optionalChain([this, 'access', _191 => _191.world, 'optionalAccess', _192 => _192.destroy, 'call', _193 => _193()]);
     this.world = null;
-    _optionalChain([this, 'access', _163 => _163.gpu, 'optionalAccess', _164 => _164.destroy, 'call', _165 => _165()]);
+    _optionalChain([this, 'access', _194 => _194.gpu, 'optionalAccess', _195 => _195.destroy, 'call', _196 => _196()]);
     this.gpu = null;
   }
 }, _class6);
 function wetPigmentOf(hex, body) {
   const [r, g, b] = hexToRgb8(hex);
-  return Array.from(_chunkDHC4E2DUcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], body));
+  return Array.from(_chunkMITQGHN3cjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], body));
 }
 
 // src/vector/brushstrokeMedia.ts
@@ -4447,7 +4605,7 @@ function vectorMediaEngine(brush) {
 var usesVectorBackdrop = (engine) => engine === "mixer" || engine === "smudge" || engine === "blender";
 var finite2 = (v2) => typeof v2 === "number" && Number.isFinite(v2);
 function place(input, brush, options, pad = 0) {
-  const samples = _chunkSTLTOISWcjs.brushstrokeSamples.call(void 0, input);
+  const samples = _chunkNPPMKMCUcjs.brushstrokeSamples.call(void 0, input);
   if (!samples.length) return null;
   for (const s of samples) if (!finite2(s.x) || !finite2(s.y)) throw new Error("Brushstroke samples need finite x and y.");
   let scale3 = finite2(options.scale) && options.scale > 0 ? Math.min(_chunkYQGCPL5Xcjs.BRUSHSTROKE_MAX_SCALE, Math.max(_chunkYQGCPL5Xcjs.BRUSHSTROKE_MIN_SCALE, options.scale)) : 1;
@@ -4471,8 +4629,8 @@ function place(input, brush, options, pad = 0) {
   const [r, g, b, a] = options.color;
   const hex = "#" + [r, g, b].map((v2) => Math.round(Math.min(255, Math.max(0, v2))).toString(16).padStart(2, "0")).join("");
   const source = _nullishCoalesce(options.paint, () => ( null));
-  const paint = _optionalChain([source, 'optionalAccess', _166 => _166.type]) === "gradient" ? _chunkNIBFKXMDcjs.resolvePaintGradient.call(void 0, _chunkNIBFKXMDcjs.scalePaintGradient.call(void 0, source, scale3), { paint: hex, secondary: "#ffffff" }) : null;
-  const color2 = _optionalChain([source, 'optionalAccess', _167 => _167.type]) === "color" ? hexRgb(source.color) : [r / 255, g / 255, b / 255];
+  const paint = _optionalChain([source, 'optionalAccess', _197 => _197.type]) === "gradient" ? _chunkIFWLZZCWcjs.resolvePaintGradient.call(void 0, _chunkIFWLZZCWcjs.scalePaintGradient.call(void 0, source, scale3), { paint: hex, secondary: "#ffffff" }) : null;
+  const color2 = _optionalChain([source, 'optionalAccess', _198 => _198.type]) === "color" ? hexRgb(source.color) : [r / 255, g / 255, b / 255];
   return { points, brush: sized, rect, scale: scale3, color: color2, alpha: Math.min(1, Math.max(0, a / 255)), paint };
 }
 function hexRgb(hex) {
@@ -4512,7 +4670,7 @@ function cropped(data, placed, dabs, keep) {
   return { image: { width: cw, height: ch, data: out }, bounds: { x: (placed.rect.x + cx0) / s, y: (placed.rect.y + cy0) / s, width: cw / s, height: ch / s }, scale: s, dabs };
 }
 var WetBrushstrokeJob = (_class7 = class {
-  constructor(input, brush, options, steps = VECTOR_WET_STEPS) {;_class7.prototype.__init57.call(this);_class7.prototype.__init58.call(this);
+  constructor(input, brush, options, steps = VECTOR_WET_STEPS) {;_class7.prototype.__init58.call(this);_class7.prototype.__init59.call(this);
     this.steps = steps;
     if (vectorMediaEngine(brush) !== "wet") throw new Error(`'${brush.name}' is not a wet paint brush.`);
     this.placed = place(input, brush, options, brush.tip.size * 0.25);
@@ -4523,7 +4681,7 @@ var WetBrushstrokeJob = (_class7 = class {
       return;
     }
     const { rect, points } = this.placed;
-    this.world = new (0, _chunkDHC4E2DUcjs.WetWorld)(rect.width, rect.height, wetPaperInput(DEFAULT_PAPER), { kernel: "typescript", threads: 0 });
+    this.world = new (0, _chunkMITQGHN3cjs.WetWorld)(rect.width, rect.height, wetPaperInput(DEFAULT_PAPER), { kernel: "typescript", threads: 0 });
     const medium = _nullishCoalesce(this.placed.brush.wet.medium, () => ( "watercolor"));
     this.world.ensureLane("s", { params: _nullishCoalesce(WET_MEDIUM_PARAMS[medium], () => ( {})) });
     const color2 = this.placed.color;
@@ -4548,8 +4706,8 @@ var WetBrushstrokeJob = (_class7 = class {
   
   
   
-  __init57() {this.done = 0}
-  __init58() {this.final = null}
+  __init58() {this.done = 0}
+  __init59() {this.final = null}
   /** Steps run so far. */
   get progress() {
     return this.done;
@@ -4582,7 +4740,7 @@ var WetBrushstrokeJob = (_class7 = class {
     return this.final;
   }
   destroy() {
-    _optionalChain([this, 'access', _168 => _168.world, 'optionalAccess', _169 => _169.destroy, 'call', _170 => _170()]);
+    _optionalChain([this, 'access', _199 => _199.world, 'optionalAccess', _200 => _200.destroy, 'call', _201 => _201()]);
   }
   bake() {
     if (!this.world || !this.placed) return EMPTY;
@@ -4607,8 +4765,8 @@ function renderBackdropBrushstroke(input, brush, options) {
   const area = { x: 0, y: 0, width: rect.width, height: rect.height };
   const before = options.backdrop ? options.backdrop(rect, placed.scale) : new Uint8ClampedArray(rect.width * rect.height * 4);
   if (before.length !== rect.width * rect.height * 4) throw new Error(`The backdrop must be ${rect.width}\xD7${rect.height} RGBA pixels.`);
-  const cached = _optionalChain([options, 'access', _171 => _171.cache, 'optionalCall', _172 => _172(before)]);
-  const hit = _optionalChain([cached, 'optionalAccess', _173 => _173.get, 'call', _174 => _174()]);
+  const cached = _optionalChain([options, 'access', _202 => _202.cache, 'optionalCall', _203 => _203(before)]);
+  const hit = _optionalChain([cached, 'optionalAccess', _204 => _204.get, 'call', _205 => _205()]);
   if (hit) return hit;
   const base = _chunk474IQG74cjs.writeRegion.call(void 0, _chunk474IQG74cjs.emptySurface.call(void 0, 4), area, before);
   const live = /* @__PURE__ */ new Map();
@@ -4616,7 +4774,7 @@ function renderBackdropBrushstroke(input, brush, options) {
     offset: { x: 0, y: 0 },
     lockTransparency: false,
     selection: null,
-    readTile: (tx, ty) => _nullishCoalesce(_nullishCoalesce(live.get(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), () => ( _optionalChain([base, 'access', _175 => _175.tiles, 'access', _176 => _176.get, 'call', _177 => _177(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _178 => _178.data]))), () => ( null)),
+    readTile: (tx, ty) => _nullishCoalesce(_nullishCoalesce(live.get(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), () => ( _optionalChain([base, 'access', _206 => _206.tiles, 'access', _207 => _207.get, 'call', _208 => _208(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _209 => _209.data]))), () => ( null)),
     writeTile: (tx, ty) => {
       const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
       let t = live.get(key);
@@ -4625,7 +4783,7 @@ function renderBackdropBrushstroke(input, brush, options) {
     }
   };
   const color2 = placed.color;
-  const load = placed.brush.engine === "mixer" && placed.brush.loadsColor ? _chunkNIBFKXMDcjs.loadMixer.call(void 0, _chunkNIBFKXMDcjs.EMPTY_MIXER_LOAD, color2) : _chunkNIBFKXMDcjs.EMPTY_MIXER_LOAD;
+  const load = placed.brush.engine === "mixer" && placed.brush.loadsColor ? _chunkIFWLZZCWcjs.loadMixer.call(void 0, _chunkIFWLZZCWcjs.EMPTY_MIXER_LOAD, color2) : _chunkIFWLZZCWcjs.EMPTY_MIXER_LOAD;
   const stroke = new PaintDabStroke(placed.brush, { target, color: color2, secondary: [1, 1, 1], load, grain: null, paperDepth: 0, seed: _nullishCoalesce(options.seed, () => ( 0)), paint: placed.paint });
   stroke.push(placed.points);
   stroke.finish();
@@ -4634,29 +4792,29 @@ function renderBackdropBrushstroke(input, brush, options) {
   for (const [key, data] of live) tiles.set(key, { data, uniform: null });
   _chunk474IQG74cjs.readRegion.call(void 0, new (0, _chunk474IQG74cjs.TiledSurface)(4, tiles), area, after);
   const result = cropped(after, placed, stroke.dabCount, (i) => after[i] !== before[i] || after[i + 1] !== before[i + 1] || after[i + 2] !== before[i + 2] || after[i + 3] !== before[i + 3]);
-  _optionalChain([cached, 'optionalAccess', _179 => _179.set, 'call', _180 => _180(result)]);
+  _optionalChain([cached, 'optionalAccess', _210 => _210.set, 'call', _211 => _211(result)]);
   return result;
 }
 
 // src/vector/brushstroke.ts
 var VECTOR_BRUSHSTROKE_SCALE = 2;
-var PRESETS = _chunk6QNDGMK7cjs.listPresets.call(void 0, _chunk6QNDGMK7cjs.VECTOR_PROFILE).map((spec) => _chunk6QNDGMK7cjs.BUILTIN_BRUSHES.find((b) => b.id === spec.id));
+var PRESETS = _chunkQ33V5PEFcjs.listPresets.call(void 0, _chunkQ33V5PEFcjs.VECTOR_PROFILE).map((spec) => _chunkQ33V5PEFcjs.BUILTIN_BRUSHES.find((b) => b.id === spec.id));
 function admitted(spec) {
   try {
-    const brush = _chunk6QNDGMK7cjs.normalizeBrushSpec.call(void 0, spec);
-    return _chunk6QNDGMK7cjs.checkBrush.call(void 0, brush, _chunk6QNDGMK7cjs.VECTOR_PROFILE).ok && isVectorBrushstrokeEngine(_chunk6QNDGMK7cjs.resolveBrush.call(void 0, brush)) ? brush : null;
+    const brush = _chunkQ33V5PEFcjs.normalizeBrushSpec.call(void 0, spec);
+    return _chunkQ33V5PEFcjs.checkBrush.call(void 0, brush, _chunkQ33V5PEFcjs.VECTOR_PROFILE).ok && isVectorBrushstrokeEngine(_chunkQ33V5PEFcjs.resolveBrush.call(void 0, brush)) ? brush : null;
   } catch (e6) {
     return null;
   }
 }
 function isVectorBrushstrokeEngine(brush) {
-  return brush.engine === "dab" && _chunkSTLTOISWcjs.isBrushstrokeBrush.call(void 0, brush) || vectorMediaEngine(brush) !== null;
+  return brush.engine === "dab" && _chunkNPPMKMCUcjs.isBrushstrokeBrush.call(void 0, brush) || vectorMediaEngine(brush) !== null;
 }
 function vectorBrushstrokeBrushes(user = []) {
   const out = [...PRESETS];
   for (const raw of user) {
     const brush = admitted(raw);
-    if (brush && !out.some((b) => b.id === brush.id)) out.push(_chunk6QNDGMK7cjs.resolveBrush.call(void 0, brush));
+    if (brush && !out.some((b) => b.id === brush.id)) out.push(_chunkQ33V5PEFcjs.resolveBrush.call(void 0, brush));
   }
   return out;
 }
@@ -4666,7 +4824,7 @@ function vectorBrushstrokeBrush(id) {
 function vectorBrushstrokeBrushOf(brush) {
   if (brush.spec) {
     const saved = admitted(brush.spec);
-    return saved && saved.id === brush.brushId ? _chunk6QNDGMK7cjs.resolveBrush.call(void 0, saved) : null;
+    return saved && saved.id === brush.brushId ? _chunkQ33V5PEFcjs.resolveBrush.call(void 0, saved) : null;
   }
   return vectorBrushstrokeBrush(brush.brushId);
 }
@@ -4674,15 +4832,15 @@ function vectorBrushstrokeBrushError(id, user = []) {
   if (vectorBrushstrokeBrush(id)) return null;
   const saved = user.find((b) => b.id === id);
   const ids = vectorBrushstrokeBrushes(user).map((b) => b.id);
-  const reasons = (b) => _chunk6QNDGMK7cjs.checkBrush.call(void 0, b, _chunk6QNDGMK7cjs.VECTOR_PROFILE).issues.filter((i) => i.severity === "error").map((i) => `${i.reason} ${i.fix}`).join(" ") || "its engine does not paint brushstrokes.";
+  const reasons = (b) => _chunkQ33V5PEFcjs.checkBrush.call(void 0, b, _chunkQ33V5PEFcjs.VECTOR_PROFILE).issues.filter((i) => i.severity === "error").map((i) => `${i.reason} ${i.fix}`).join(" ") || "its engine does not paint brushstrokes.";
   if (saved) return admitted(saved) ? null : `Brush "${id}" (${saved.name}) can't paint a brushstroke: ${reasons(saved)} Use one of: ${ids.join(", ")}.`;
-  const preset2 = _chunk6QNDGMK7cjs.BRUSH_PRESETS.find((b) => b.id === id);
+  const preset2 = _chunkQ33V5PEFcjs.BRUSH_PRESETS.find((b) => b.id === id);
   if (preset2) return `Brush "${id}" (${preset2.name}) can't paint a brushstroke: ${reasons(preset2)} Use one of: ${ids.join(", ")}.`;
-  return `Unknown brush "${id}". ${_chunk6QNDGMK7cjs.closest.call(void 0, id, ids)}Use one of: ${ids.join(", ")} (vector.listBrushes lists them).`;
+  return `Unknown brush "${id}". ${_chunkQ33V5PEFcjs.closest.call(void 0, id, ids)}Use one of: ${ids.join(", ")} (vector.listBrushes lists them).`;
 }
 function vectorBrushstrokeDefaultColour(id, user = [], scheme = "light") {
-  const brush = _nullishCoalesce(_chunk6QNDGMK7cjs.BRUSH_PRESETS.find((b) => b.id === id), () => ( user.find((b) => b.id === id)));
-  return brush ? _chunkJBZRVLXVcjs.brushColourHex.call(void 0, _optionalChain([brush, 'access', _181 => _181.colour, 'optionalAccess', _182 => _182.default]), scheme) : null;
+  const brush = _nullishCoalesce(_chunkQ33V5PEFcjs.BRUSH_PRESETS.find((b) => b.id === id), () => ( user.find((b) => b.id === id)));
+  return brush ? _chunkJBZRVLXVcjs.brushColourHex.call(void 0, _optionalChain([brush, 'access', _212 => _212.colour, 'optionalAccess', _213 => _213.default]), scheme) : null;
 }
 function sanitizeVectorBrushstroke(value, user = []) {
   if (!value || typeof value !== "object") return null;
@@ -4714,7 +4872,7 @@ var TIMED_MAPPINGS = ["velocity", "time"];
 function vectorBrushstrokePaintError(paint) {
   let source;
   try {
-    source = _chunkNIBFKXMDcjs.parsePaintSource.call(void 0, paint, "paint");
+    source = _chunkIFWLZZCWcjs.parsePaintSource.call(void 0, paint, "paint");
   } catch (e) {
     return e.message;
   }
@@ -4723,7 +4881,7 @@ function vectorBrushstrokePaintError(paint) {
 }
 function readVectorBrushstrokePaint(value) {
   if (value === void 0 || value === null || vectorBrushstrokePaintError(value)) return null;
-  return _chunkNIBFKXMDcjs.readPaintSource.call(void 0, value);
+  return _chunkIFWLZZCWcjs.readPaintSource.call(void 0, value);
 }
 var VECTOR_BRUSHSTROKE_MAX_SEED = 2147483647;
 var finite3 = (v2) => typeof v2 === "number" && Number.isFinite(v2);
@@ -4732,7 +4890,7 @@ function sanitizeVectorBrushstrokePaper(value) {
   if (!value || typeof value !== "object") return null;
   const r = value;
   const out = {};
-  if (typeof r.pattern === "string" && _chunkNIBFKXMDcjs.GRAIN_PATTERNS.includes(r.pattern)) out.pattern = r.pattern;
+  if (typeof r.pattern === "string" && _chunkIFWLZZCWcjs.GRAIN_PATTERNS.includes(r.pattern)) out.pattern = r.pattern;
   const seed = sanitizeSeed(r.seed);
   if (seed !== void 0) out.seed = seed;
   if (finite3(r.scale) && r.scale > 0) out.scale = Math.min(8, Math.max(0.25, r.scale));
@@ -4747,7 +4905,7 @@ function vectorBrushstrokeCharacterError(brush) {
   const r = paper;
   const extra = Object.keys(r).filter((k) => !["pattern", "seed", "scale", "depth"].includes(k));
   if (extra.length) return `paper has unknown field ${extra.map((k) => `"${k}"`).join(", ")}: use pattern, seed, scale, depth.`;
-  if (r.pattern !== void 0 && !_chunkNIBFKXMDcjs.GRAIN_PATTERNS.includes(r.pattern)) return `Unknown paper pattern "${String(r.pattern)}": use one of ${_chunkNIBFKXMDcjs.GRAIN_PATTERNS.join(", ")}.`;
+  if (r.pattern !== void 0 && !_chunkIFWLZZCWcjs.GRAIN_PATTERNS.includes(r.pattern)) return `Unknown paper pattern "${String(r.pattern)}": use one of ${_chunkIFWLZZCWcjs.GRAIN_PATTERNS.join(", ")}.`;
   if (r.seed !== void 0 && !(Number.isInteger(r.seed) && r.seed >= 0 && r.seed <= VECTOR_BRUSHSTROKE_MAX_SEED)) return `paper.seed must be an integer from 0 to ${VECTOR_BRUSHSTROKE_MAX_SEED}.`;
   if (r.scale !== void 0 && !(finite3(r.scale) && r.scale >= 0.25 && r.scale <= 8)) return "paper.scale must be from 0.25 to 8 (1 is the pattern's natural size).";
   if (r.depth !== void 0 && !(finite3(r.depth) && r.depth >= 0 && r.depth <= 1)) return "paper.depth must be from 0 to 1.";
@@ -4806,7 +4964,7 @@ function strokePaintOf(node, layer, brush, length2) {
   const color2 = [c[0] * 255, c[1] * 255, c[2] * 255, c[3] * 255].map(Math.round);
   if (layer.brush.paint) return { color: color2, paint: layer.brush.paint, within: null };
   const g = layer.paint;
-  if (isVectorGradient(g) && _optionalChain([g, 'access', _183 => _183.stops, 'optionalAccess', _184 => _184.length])) {
+  if (isVectorGradient(g) && _optionalChain([g, 'access', _214 => _214.stops, 'optionalAccess', _215 => _215.length])) {
     const mode = _nullishCoalesce(g.strokeMode, () => ( "within"));
     if (mode === "along") return { color: [color2[0], color2[1], color2[2], 255], paint: gradientPaint(g, { by: "distance", length: Math.max(1, length2), repeat: REPEAT[_nullishCoalesce(g.spread, () => ( "pad"))], unit: "px" }), within: null };
     if (mode === "across") return { color: [color2[0], color2[1], color2[2], 255], paint: gradientPaint(g, { by: "across-tip" }), within: null };
@@ -4859,11 +5017,11 @@ function mediaKey(input, brush, options) {
   return `${hash(path).toString(16)}:${path.length}:${hash(JSON.stringify([brush, options])).toString(16)}`;
 }
 var Lru = (_class8 = class {
-  constructor(capacity) {;_class8.prototype.__init59.call(this);
+  constructor(capacity) {;_class8.prototype.__init60.call(this);
     this.capacity = capacity;
   }
   
-  __init59() {this.map = /* @__PURE__ */ new Map()}
+  __init60() {this.map = /* @__PURE__ */ new Map()}
   get(key) {
     const v2 = this.map.get(key);
     if (v2 !== void 0) {
@@ -4946,7 +5104,7 @@ function wetImage(input, brush, options, settle, pending) {
   pending.push(key);
   return _nullishCoalesce(wetInstant.get(key), () => ( job.image()));
 }
-var cache = new (0, _chunkSTLTOISWcjs.BrushstrokeCache)(256);
+var cache = new (0, _chunkNPPMKMCUcjs.BrushstrokeCache)(256);
 var backdropResults = new Lru(64);
 var urls = /* @__PURE__ */ new WeakMap();
 var layerCache = /* @__PURE__ */ new WeakMap();
@@ -4961,7 +5119,7 @@ function vectorBrushstrokeImages(node, layer, context = {}) {
   const source = usesVectorBackdrop(engine) && backdropSource ? backdropSource(document2, node, Math.max(0, index), settle) : null;
   const deps = source ? [...source.deps, wetGeneration] : null;
   let byLayer = layerCache.get(node);
-  const hit = _optionalChain([byLayer, 'optionalAccess', _185 => _185.get, 'call', _186 => _186(layer)]);
+  const hit = _optionalChain([byLayer, 'optionalAccess', _216 => _216.get, 'call', _217 => _217(layer)]);
   const stale = hit && (hit.pending.length && hit.pending.some((k) => wetSettled.has(k)) || settle === "now" && !hit.settled);
   if (hit && sameDeps(hit.deps, deps) && !stale) return hit.images;
   const brush = layer.brush.size ? { ...preset2, tip: { ...preset2.tip, size: layer.brush.size } } : preset2;
@@ -4986,7 +5144,7 @@ function vectorBrushstrokeImages(node, layer, context = {}) {
         const key = mediaKey(input, brush, options);
         stroke = renderBackdropBrushstroke(input, brush, {
           ...options,
-          backdrop: _nullishCoalesce(_optionalChain([source, 'optionalAccess', _187 => _187.backdrop]), () => ( null)),
+          backdrop: _nullishCoalesce(_optionalChain([source, 'optionalAccess', _218 => _218.backdrop]), () => ( null)),
           cache: (bytes) => {
             const k = `${key}:${hashBytes(bytes).toString(16)}`;
             return { get: () => backdropResults.get(k), set: (img) => backdropResults.set(k, img) };
@@ -4999,7 +5157,7 @@ function vectorBrushstrokeImages(node, layer, context = {}) {
       if (sp2.within) stroke = recoloured(stroke, sp2.within);
       if (!stroke.bounds) continue;
       let href = urls.get(stroke);
-      if (!href) urls.set(stroke, href = _chunkSTLTOISWcjs.brushstrokeDataUrl.call(void 0, stroke));
+      if (!href) urls.set(stroke, href = _chunkNPPMKMCUcjs.brushstrokeDataUrl.call(void 0, stroke));
       out.push({ href, ...stroke.bounds });
     }
   }
@@ -5090,7 +5248,7 @@ function withVectorFills(node, fills) {
   const next = { ...node };
   if (fills.length === 0 || fills.length === 1 && isPlainVectorPaintLayer(fills[0])) {
     delete next.fills;
-    next.fill = _nullishCoalesce(_optionalChain([fills, 'access', _188 => _188[0], 'optionalAccess', _189 => _189.paint]), () => ( null));
+    next.fill = _nullishCoalesce(_optionalChain([fills, 'access', _219 => _219[0], 'optionalAccess', _220 => _220.paint]), () => ( null));
     return next;
   }
   next.fills = fills.map((l) => ({ ...l }));
@@ -5115,8 +5273,8 @@ function withVectorStrokes(node, strokes) {
 var json = (v2) => JSON.stringify(_nullishCoalesce(v2, () => ( null)));
 function strokeShorthandDiff(node, top) {
   const out = [];
-  if (json(node.stroke) !== json(_optionalChain([top, 'optionalAccess', _190 => _190.paint]))) out.push("stroke");
-  for (const key of VECTOR_STROKE_SETTING_KEYS) if (json(node[key]) !== json(_optionalChain([top, 'optionalAccess', _191 => _191[key]]))) out.push(key);
+  if (json(node.stroke) !== json(_optionalChain([top, 'optionalAccess', _221 => _221.paint]))) out.push("stroke");
+  for (const key of VECTOR_STROKE_SETTING_KEYS) if (json(node[key]) !== json(_optionalChain([top, 'optionalAccess', _222 => _222[key]]))) out.push(key);
   return out;
 }
 var checked = /* @__PURE__ */ new WeakSet();
@@ -5133,7 +5291,7 @@ function normalizeVectorPaintStacks(node, prefer = "shorthand") {
   if (Array.isArray(node.fills)) {
     let fills = node.fills;
     const top = fills[fills.length - 1];
-    if (prefer === "shorthand" && json(node.fill) !== json(_optionalChain([top, 'optionalAccess', _192 => _192.paint]))) {
+    if (prefer === "shorthand" && json(node.fill) !== json(_optionalChain([top, 'optionalAccess', _223 => _223.paint]))) {
       if (!draws(node.fill)) fills = [];
       else fills = top ? [...fills.slice(0, -1), { ...top, paint: node.fill }] : [{ paint: node.fill }];
     }
@@ -5349,8 +5507,8 @@ var Measured = class {
   append(sa, sb, out) {
     for (const piece of _chunkGF2RBSDMcjs.trimSegments.call(void 0, this.segs, sa, sb, this.lens)) {
       if (degenerate(piece)) continue;
-      const last = _optionalChain([out, 'access', _193 => _193[out.length - 1], 'optionalAccess', _194 => _194.segs]);
-      const end = _optionalChain([last, 'optionalAccess', _195 => _195[last.length - 1], 'optionalAccess', _196 => _196.at, 'call', _197 => _197(-1)]);
+      const last = _optionalChain([out, 'access', _224 => _224[out.length - 1], 'optionalAccess', _225 => _225.segs]);
+      const end = _optionalChain([last, 'optionalAccess', _226 => _226[last.length - 1], 'optionalAccess', _227 => _227.at, 'call', _228 => _228(-1)]);
       if (!end || Math.hypot(end[0] - piece[0][0], end[1] - piece[0][1]) > 1e-6) out.push({ segs: [piece], closed: false });
       else last.push(piece);
     }
@@ -5662,9 +5820,9 @@ function vectorRepeaterCopies(r, pivot) {
   for (let i = 0; i < n; i++) {
     const k = i + offset;
     let m = translateMatrix(-pivot.x, -pivot.y);
-    m = multiplyMatrices(m, scaleMatrix(Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _198 => _198.scale, 'optionalAccess', _199 => _199.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _200 => _200.scale, 'optionalAccess', _201 => _201.y]), () => ( 100))) / 100, k)));
+    m = multiplyMatrices(m, scaleMatrix(Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _229 => _229.scale, 'optionalAccess', _230 => _230.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _231 => _231.scale, 'optionalAccess', _232 => _232.y]), () => ( 100))) / 100, k)));
     m = multiplyMatrices(m, rotateMatrix((_nullishCoalesce(r.rotation, () => ( 0))) * k));
-    m = multiplyMatrices(m, translateMatrix(pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _202 => _202.position, 'optionalAccess', _203 => _203.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _204 => _204.position, 'optionalAccess', _205 => _205.y]), () => ( 0))) * k));
+    m = multiplyMatrices(m, translateMatrix(pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _233 => _233.position, 'optionalAccess', _234 => _234.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _235 => _235.position, 'optionalAccess', _236 => _236.y]), () => ( 0))) * k));
     const t = n > 1 ? i / (n - 1) : 0;
     const partial = i + 1 === n && fract > 0 ? fract : 1;
     out.push({ index: i, matrix: m, opacity: Math.min(1, Math.max(0, (so + (eo - so) * t) * partial)) });
@@ -5828,7 +5986,7 @@ function mapBezierPath(path, f, tolerance = 0.1, options = {}) {
 
 // src/vector/frames.ts
 function isVectorFrame(node) {
-  return _optionalChain([node, 'optionalAccess', _206 => _206.type]) === "group" && !!node.frame && !node.blend && !node.liveBoolean && !node.mask;
+  return _optionalChain([node, 'optionalAccess', _237 => _237.type]) === "group" && !!node.frame && !node.blend && !node.liveBoolean && !node.mask;
 }
 function vectorFrameRectPath(frame) {
   const { x, y, width: w, height: h } = frame;
@@ -5873,8 +6031,8 @@ function placeSpan(rule, a0, a1, f0, f1, g0, g1) {
   }
 }
 function vectorFrameChildMatrix(resizing, box, from, to) {
-  const [x0, x1] = placeSpan(_nullishCoalesce(H[_nullishCoalesce(_optionalChain([resizing, 'optionalAccess', _207 => _207.horizontal]), () => ( "left"))], () => ( "start")), box.x, box.x + box.width, from.x, from.x + from.width, to.x, to.x + to.width);
-  const [y0, y1] = placeSpan(_nullishCoalesce(V[_nullishCoalesce(_optionalChain([resizing, 'optionalAccess', _208 => _208.vertical]), () => ( "top"))], () => ( "start")), box.y, box.y + box.height, from.y, from.y + from.height, to.y, to.y + to.height);
+  const [x0, x1] = placeSpan(_nullishCoalesce(H[_nullishCoalesce(_optionalChain([resizing, 'optionalAccess', _238 => _238.horizontal]), () => ( "left"))], () => ( "start")), box.x, box.x + box.width, from.x, from.x + from.width, to.x, to.x + to.width);
+  const [y0, y1] = placeSpan(_nullishCoalesce(V[_nullishCoalesce(_optionalChain([resizing, 'optionalAccess', _239 => _239.vertical]), () => ( "top"))], () => ( "start")), box.y, box.y + box.height, from.y, from.y + from.height, to.y, to.y + to.height);
   const sx = box.width > 1e-9 ? (x1 - x0) / box.width : 1;
   const sy = box.height > 1e-9 ? (y1 - y0) / box.height : 1;
   return [sx, 0, 0, sy, x0 - sx * box.x, y0 - sy * box.y];
@@ -5930,7 +6088,7 @@ function vectorFrameDocument(doc, id, find) {
     height,
     ...doc.background ? { background: doc.background } : {},
     nodes: [placed],
-    ..._optionalChain([doc, 'access', _209 => _209.symbols, 'optionalAccess', _210 => _210.length]) ? { symbols: doc.symbols } : {}
+    ..._optionalChain([doc, 'access', _240 => _240.symbols, 'optionalAccess', _241 => _241.length]) ? { symbols: doc.symbols } : {}
   };
 }
 function getVectorFramePanel(state) {
@@ -5950,7 +6108,7 @@ function getVectorFramePanel(state) {
   const one = (values) => values.every((v2) => v2 === values[0]) ? values[0] : "mixed";
   return {
     frame: f ? { id: f.id, name: _nullishCoalesce(f.name, () => ( "Frame")), artboard: parents.get(f.id) === null, frame: f.frame } : null,
-    resizing: children.length ? { ids: children.map((c) => c.id), horizontal: one(children.map((c) => _nullishCoalesce(_optionalChain([c, 'access', _211 => _211.resizing, 'optionalAccess', _212 => _212.horizontal]), () => ( "left")))), vertical: one(children.map((c) => _nullishCoalesce(_optionalChain([c, 'access', _213 => _213.resizing, 'optionalAccess', _214 => _214.vertical]), () => ( "top")))) } : null
+    resizing: children.length ? { ids: children.map((c) => c.id), horizontal: one(children.map((c) => _nullishCoalesce(_optionalChain([c, 'access', _242 => _242.resizing, 'optionalAccess', _243 => _243.horizontal]), () => ( "left")))), vertical: one(children.map((c) => _nullishCoalesce(_optionalChain([c, 'access', _244 => _244.resizing, 'optionalAccess', _245 => _245.vertical]), () => ( "top")))) } : null
   };
 }
 
@@ -6336,7 +6494,7 @@ function normalizeVectorFilterParams(type, params, base) {
   if (!isVectorFilterType(type)) return null;
   const out = { ...VECTOR_FILTER_DEFAULTS[type], ..._nullishCoalesce(base, () => ( {})) };
   for (const spec of VECTOR_FILTER_PARAM_SPECS[type]) {
-    const v2 = _optionalChain([params, 'optionalAccess', _215 => _215[spec.key]]);
+    const v2 = _optionalChain([params, 'optionalAccess', _246 => _246[spec.key]]);
     if (v2 === void 0) continue;
     if (spec.kind === "number" && typeof v2 === "number" && Number.isFinite(v2)) out[spec.key] = Math.min(_nullishCoalesce(spec.max, () => ( Infinity)), Math.max(_nullishCoalesce(spec.min, () => ( -Infinity)), v2));
     else if (spec.kind === "color" && typeof v2 === "string" && v2.trim()) out[spec.key] = v2.trim();
@@ -6468,7 +6626,7 @@ function vectorFilterSvg(filters, id, bounds) {
     primitives.push(fe("feGaussianBlur", { in: body, stdDeviation: round(f.params.radius / 2), result: name("body") }));
     body = name("body");
   }
-  const lastResult = _optionalChain([primitives, 'access', _216 => _216[primitives.length - 1], 'optionalAccess', _217 => _217.attrs, 'access', _218 => _218.result]);
+  const lastResult = _optionalChain([primitives, 'access', _247 => _247[primitives.length - 1], 'optionalAccess', _248 => _248.attrs, 'access', _249 => _249.result]);
   if (lastResult !== body) primitives.push(fe("feMerge", {}, [fe("feMergeNode", { in: body })]));
   const pad = vectorFilterReach(active) + 2;
   return {
@@ -6483,7 +6641,7 @@ function vectorFilterSvg(filters, id, bounds) {
 var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 function primitiveMarkup(p) {
   const attrs = Object.entries(p.attrs).map(([k, v2]) => ` ${k}="${escapeAttr(String(v2))}"`).join("");
-  return _optionalChain([p, 'access', _219 => _219.children, 'optionalAccess', _220 => _220.length]) ? `<${p.tag}${attrs}>${p.children.map(primitiveMarkup).join("")}</${p.tag}>` : `<${p.tag}${attrs}/>`;
+  return _optionalChain([p, 'access', _250 => _250.children, 'optionalAccess', _251 => _251.length]) ? `<${p.tag}${attrs}>${p.children.map(primitiveMarkup).join("")}</${p.tag}>` : `<${p.tag}${attrs}/>`;
 }
 function vectorFilterMarkup(filter, extra = "") {
   return `<filter id="${escapeAttr(filter.id)}" filterUnits="userSpaceOnUse" x="${filter.x}" y="${filter.y}" width="${filter.width}" height="${filter.height}" color-interpolation-filters="sRGB"${extra}>${filter.primitives.map(primitiveMarkup).join("")}</filter>`;
@@ -6501,7 +6659,7 @@ function sanitizeVectorMask(value) {
   return r.invert === true ? { type: r.type, invert: true } : { type: r.type };
 }
 function isVectorMaskGroup(node) {
-  return _optionalChain([node, 'optionalAccess', _221 => _221.type]) === "group" && !!node.mask && isVectorMaskType(node.mask.type) && !node.blend && !node.liveBoolean && node.children.length > 0;
+  return _optionalChain([node, 'optionalAccess', _252 => _252.type]) === "group" && !!node.mask && isVectorMaskType(node.mask.type) && !node.blend && !node.liveBoolean && node.children.length > 0;
 }
 function isVectorMaskActive(node) {
   return isVectorMaskGroup(node) && node.children[0].visible !== false;
@@ -6536,7 +6694,7 @@ function vectorMaskRegionShapes(node, type, parent = IDENTITY_MATRIX, self = tru
   if (!self && node.visible === false) return [];
   if (isVectorFrame(node)) node = vectorFrameDrawn(node);
   const m = multiplyMatrices(nodeMatrix(node), parent);
-  if (isVectorMaskActive(node) || node.type === "group" && _optionalChain([node, 'access', _222 => _222.effects, 'optionalAccess', _223 => _223.length])) {
+  if (isVectorMaskActive(node) || node.type === "group" && _optionalChain([node, 'access', _253 => _253.effects, 'optionalAccess', _254 => _254.length])) {
     return vectorAppearanceShapes(node).flatMap((s) => regionOfPath(s.path, s.source, type, m));
   }
   const drawn = expandVectorAppearance(node);
@@ -6741,7 +6899,7 @@ function fitRuns(runs, length2, fallback) {
   }
   if (left2 > 0) {
     if (out.length) out[out.length - 1] = { ...out[out.length - 1], length: out[out.length - 1].length + left2 };
-    else out.push({ length: left2, style: _nullishCoalesce(_optionalChain([runs, 'access', _224 => _224[runs.length - 1], 'optionalAccess', _225 => _225.style]), () => ( fallback)) });
+    else out.push({ length: left2, style: _nullishCoalesce(_optionalChain([runs, 'access', _255 => _255[runs.length - 1], 'optionalAccess', _256 => _256.style]), () => ( fallback)) });
   }
   return compact(out);
 }
@@ -6751,7 +6909,7 @@ function styleAt(runs, index, fallback) {
     if (index < at2 + r.length) return r.style;
     at2 += r.length;
   }
-  return _nullishCoalesce(_optionalChain([runs, 'access', _226 => _226[runs.length - 1], 'optionalAccess', _227 => _227.style]), () => ( fallback));
+  return _nullishCoalesce(_optionalChain([runs, 'access', _257 => _257[runs.length - 1], 'optionalAccess', _258 => _258.style]), () => ( fallback));
 }
 function restyleRange(runs, start, end, patch) {
   const out = [];
@@ -6807,7 +6965,7 @@ function paragraphRanges(text) {
   return out;
 }
 function fitParagraphRuns(runs, text) {
-  const fallback = _nullishCoalesce(_optionalChain([runs, 'access', _228 => _228[0], 'optionalAccess', _229 => _229.style]), () => ( {}));
+  const fallback = _nullishCoalesce(_optionalChain([runs, 'access', _259 => _259[0], 'optionalAccess', _260 => _260.style]), () => ( {}));
   const out = compact(paragraphRanges(text).map((p) => ({ length: p.end - p.start, style: styleAt(runs, p.start, fallback) })));
   return out.length ? out : [{ length: 0, style: fallback }];
 }
@@ -6857,7 +7015,7 @@ function textLineRect(l) {
 var layoutCache = /* @__PURE__ */ new WeakMap();
 function layoutText(layer, shaper) {
   let byShaper = layoutCache.get(layer);
-  const hit = _optionalChain([byShaper, 'optionalAccess', _230 => _230.get, 'call', _231 => _231(shaper.id)]);
+  const hit = _optionalChain([byShaper, 'optionalAccess', _261 => _261.get, 'call', _262 => _262(shaper.id)]);
   if (hit) return hit;
   const out = computeLayout(layer, shaper);
   if (!byShaper) {
@@ -6921,7 +7079,7 @@ function computeLayout(layer, shaper) {
         const code = seg.charCodeAt(k);
         if (isLow(code) && index > 0 && isHigh(text.charCodeAt(index - 1))) {
           const prev = chars[chars.length - 1];
-          if (_optionalChain([prev, 'optionalAccess', _232 => _232.up])) {
+          if (_optionalChain([prev, 'optionalAccess', _263 => _263.up])) {
             chars.push({ index, ch: seg[k], advance: 0, style, up: prev.up, low: true });
           } else chars.push({ index, ch: seg[k], advance, style, low: true });
           continue;
@@ -7249,7 +7407,7 @@ function createCanvasTextShaper(options = {}) {
     return null;
   })));
   const canvas = make(1, 1);
-  const ctx = _optionalChain([canvas, 'optionalAccess', _233 => _233.getContext, 'call', _234 => _234("2d")]);
+  const ctx = _optionalChain([canvas, 'optionalAccess', _264 => _264.getContext, 'call', _265 => _265("2d")]);
   if (!ctx || typeof ctx.measureText !== "function") return null;
   const fallback = _nullishCoalesce(options.fallbackFamily, () => ( "sans-serif"));
   const available = /* @__PURE__ */ new Map();
@@ -7322,10 +7480,10 @@ function createOutlineTextShaper(fonts, options = {}) {
   const entries = fonts.map((f) => {
     const e = "face" in f ? f : { face: f };
     const names = e.face.names;
-    const family = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(e.family, () => ( _optionalChain([names, 'optionalAccess', _235 => _235.fontFamily, 'optionalAccess', _236 => _236.en]))), () => ( Object.values(_nullishCoalesce(_optionalChain([names, 'optionalAccess', _237 => _237.fontFamily]), () => ( {})))[0])), () => ( "Font"));
-    const weight = _nullishCoalesce(_nullishCoalesce(e.weight, () => ( _optionalChain([e, 'access', _238 => _238.face, 'access', _239 => _239.tables, 'optionalAccess', _240 => _240.os2, 'optionalAccess', _241 => _241.usWeightClass]))), () => ( 400));
-    const italic = _nullishCoalesce(e.italic, () => ( Boolean((_nullishCoalesce(_optionalChain([e, 'access', _242 => _242.face, 'access', _243 => _243.tables, 'optionalAccess', _244 => _244.os2, 'optionalAccess', _245 => _245.fsSelection]), () => ( 0))) & 1)));
-    const postScript = _nullishCoalesce(_optionalChain([names, 'optionalAccess', _246 => _246.postScriptName, 'optionalAccess', _247 => _247.en]), () => ( Object.values(_nullishCoalesce(_optionalChain([names, 'optionalAccess', _248 => _248.postScriptName]), () => ( {})))[0]));
+    const family = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(e.family, () => ( _optionalChain([names, 'optionalAccess', _266 => _266.fontFamily, 'optionalAccess', _267 => _267.en]))), () => ( Object.values(_nullishCoalesce(_optionalChain([names, 'optionalAccess', _268 => _268.fontFamily]), () => ( {})))[0])), () => ( "Font"));
+    const weight = _nullishCoalesce(_nullishCoalesce(e.weight, () => ( _optionalChain([e, 'access', _269 => _269.face, 'access', _270 => _270.tables, 'optionalAccess', _271 => _271.os2, 'optionalAccess', _272 => _272.usWeightClass]))), () => ( 400));
+    const italic = _nullishCoalesce(e.italic, () => ( Boolean((_nullishCoalesce(_optionalChain([e, 'access', _273 => _273.face, 'access', _274 => _274.tables, 'optionalAccess', _275 => _275.os2, 'optionalAccess', _276 => _276.fsSelection]), () => ( 0))) & 1)));
+    const postScript = _nullishCoalesce(_optionalChain([names, 'optionalAccess', _277 => _277.postScriptName, 'optionalAccess', _278 => _278.en]), () => ( Object.values(_nullishCoalesce(_optionalChain([names, 'optionalAccess', _279 => _279.postScriptName]), () => ( {})))[0]));
     return { face: e.face, family, key: family.toLowerCase(), weight, italic, postScript };
   });
   const fallbackKey = (_nullishCoalesce(options.fallback, () => ( entries[0].family))).toLowerCase();
@@ -7372,12 +7530,12 @@ function createOutlineTextShaper(fonts, options = {}) {
       return out;
     },
     outline(text, font, x, y, opts) {
-      return toPath(pick(font).entry.face.getPath(text, x, y, font.size, _optionalChain([opts, 'optionalAccess', _249 => _249.vertical]) ? { kerning: true, vertical: true } : { kerning: true }).commands);
+      return toPath(pick(font).entry.face.getPath(text, x, y, font.size, _optionalChain([opts, 'optionalAccess', _280 => _280.vertical]) ? { kerning: true, vertical: true } : { kerning: true }).commands);
     },
     vertical(char, font) {
       const { face } = pick(font).entry;
       const k = font.size / face.unitsPerEm;
-      const v2 = _optionalChain([face, 'access', _250 => _250.getVerticalMetrics, 'optionalCall', _251 => _251(char)]);
+      const v2 = _optionalChain([face, 'access', _281 => _281.getVerticalMetrics, 'optionalCall', _282 => _282(char)]);
       if (v2) return { advance: v2.advance * k, originY: v2.originY * k, alternate: v2.alternate };
       return { advance: (face.ascender - face.descender) * k, originY: face.ascender * k, alternate: false };
     },
@@ -7438,7 +7596,7 @@ function vectorTextHasOutlines() {
   return typeof getVectorTextShaper().outline === "function";
 }
 function vectorTextFamilies() {
-  return _nullishCoalesce(_optionalChain([getVectorTextShaper, 'call', _252 => _252(), 'access', _253 => _253.families, 'optionalCall', _254 => _254()]), () => ( ["sans-serif", "serif", "monospace"]));
+  return _nullishCoalesce(_optionalChain([getVectorTextShaper, 'call', _283 => _283(), 'access', _284 => _284.families, 'optionalCall', _285 => _285()]), () => ( ["sans-serif", "serif", "monospace"]));
 }
 var DEFAULT_VECTOR_FONT = { fontFamily: "sans-serif", fontWeight: 400, fontSize: 24 };
 var VECTOR_CHARACTER_STYLE_KEYS = ["fontFamily", "fontWeight", "italic", "fontSize", "tracking", "leading", "baselineShift", "underline", "strikethrough", "upright"];
@@ -7614,7 +7772,7 @@ function computeLayout2(node, shaper) {
   const fragments = [];
   const lines = [];
   let overflow = false;
-  const fillOf = (f) => _optionalChain([runs, 'access', _255 => _255.find, 'call', _256 => _256((r) => f.start >= r.start && f.start < r.end), 'optionalAccess', _257 => _257.fill]);
+  const fillOf = (f) => _optionalChain([runs, 'access', _286 => _286.find, 'call', _287 => _287((r) => f.start >= r.start && f.start < r.end), 'optionalAccess', _288 => _288.fill]);
   const styleOf = (f) => {
     const { color: _c, opacity: _o, postScriptName: _p, ...style } = f.style;
     return style;
@@ -7653,11 +7811,11 @@ function computeLayout2(node, shaper) {
   } else {
     const line = text.lines[0];
     const measure = measureVectorPath(subpathPath(frame.path), !!frame.flip);
-    const align = _nullishCoalesce(_optionalChain([node, 'access', _258 => _258.paragraph, 'optionalAccess', _259 => _259.align]), () => ( "left"));
+    const align = _nullishCoalesce(_optionalChain([node, 'access', _289 => _289.paragraph, 'optionalAccess', _290 => _290.align]), () => ( "left"));
     const start = Math.max(0, _nullishCoalesce(frame.start, () => ( 0)));
     const end = Math.max(0, _nullishCoalesce(frame.end, () => ( 0)));
     const upright = frame.orientation === "upright";
-    const baselineOffset = pathBaselineOffset(_nullishCoalesce(frame.baseline, () => ( "baseline")), _nullishCoalesce(_optionalChain([line, 'optionalAccess', _260 => _260.ascent]), () => ( 0)), _nullishCoalesce(_optionalChain([line, 'optionalAccess', _261 => _261.descent]), () => ( 0)));
+    const baselineOffset = pathBaselineOffset(_nullishCoalesce(frame.baseline, () => ( "baseline")), _nullishCoalesce(_optionalChain([line, 'optionalAccess', _291 => _291.ascent]), () => ( 0)), _nullishCoalesce(_optionalChain([line, 'optionalAccess', _292 => _292.descent]), () => ( 0)));
     if (line) {
       const chars = line.chars.filter((c) => {
         const lo = block.text.charCodeAt(c.index);
@@ -7666,7 +7824,7 @@ function computeLayout2(node, shaper) {
       const advanceOf = (c) => {
         const pair = charAt(block.text, c.index).length === 2;
         const low = pair ? line.chars.find((d) => d.index === c.index + 1) : void 0;
-        return c.advance + (_nullishCoalesce(_optionalChain([low, 'optionalAccess', _262 => _262.advance]), () => ( 0)));
+        return c.advance + (_nullishCoalesce(_optionalChain([low, 'optionalAccess', _293 => _293.advance]), () => ( 0)));
       };
       const pivots = chars.map((c) => c.x + advanceOf(c) / 2);
       const positions = vectorPathTextPositions(pivots, [line.x, line.x + line.width], align, measure.length, start, end);
@@ -7721,7 +7879,7 @@ function computeLayout2(node, shaper) {
     if (x0 < Infinity) bounds = { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
     else if (frame.kind === "point") {
       const l = text.lines[0];
-      bounds = { x: frame.x, y: frame.y - (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _263 => _263.ascent]), () => ( 0))), width: 0, height: (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _264 => _264.ascent]), () => ( 0))) + (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _265 => _265.descent]), () => ( 0))) };
+      bounds = { x: frame.x, y: frame.y - (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _294 => _294.ascent]), () => ( 0))), width: 0, height: (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _295 => _295.ascent]), () => ( 0))) + (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _296 => _296.descent]), () => ( 0))) };
     }
   }
   return { shaper: shaper.id, glyphs, fragments, lines, origin, text, bounds, overflow, missingFonts: text.missingFonts };
@@ -7842,7 +8000,7 @@ function vectorTextCaret(node, index) {
     const t = { x: Math.cos(r), y: Math.sin(r) };
     const n2 = { x: -t.y, y: t.x };
     const o = { x: g2.x + t.x * u, y: g2.y + t.y * u };
-    return { top: { x: o.x - n2.x * g2.ascent, y: o.y - n2.y * g2.ascent }, bottom: { x: o.x + n2.x * g2.descent, y: o.y + n2.y * g2.descent }, line: _nullishCoalesce(_optionalChain([layout, 'access', _266 => _266.fragments, 'access', _267 => _267[g2.fragment], 'optionalAccess', _268 => _268.line]), () => ( 0)) };
+    return { top: { x: o.x - n2.x * g2.ascent, y: o.y - n2.y * g2.ascent }, bottom: { x: o.x + n2.x * g2.descent, y: o.y + n2.y * g2.descent }, line: _nullishCoalesce(_optionalChain([layout, 'access', _297 => _297.fragments, 'access', _298 => _298[g2.fragment], 'optionalAccess', _299 => _299.line]), () => ( 0)) };
   };
   if (node.frame.kind !== "path") {
     const c = caretAt(layout.text, index);
@@ -7982,7 +8140,7 @@ function sanitizeVectorTextFrame(value, path = "frame") {
     return { kind: "area", x: num2(f.x, `${path}.x`, -1e7, 1e7), y: num2(f.y, `${path}.y`, -1e7, 1e7), width: num2(f.width, `${path}.width`, 0, 1e7), height: num2(f.height, `${path}.height`, 0, 1e7) };
   if (f.kind === "path") {
     const sp = f.path;
-    if (!sp || !Array.isArray(sp.anchors) || sp.anchors.length < 2 || !sp.anchors.every((a) => isNum(_optionalChain([a, 'optionalAccess', _269 => _269.x])) && isNum(_optionalChain([a, 'optionalAccess', _270 => _270.y])))) fail(`${path}.path must be a subpath with at least two anchors.`);
+    if (!sp || !Array.isArray(sp.anchors) || sp.anchors.length < 2 || !sp.anchors.every((a) => isNum(_optionalChain([a, 'optionalAccess', _300 => _300.x])) && isNum(_optionalChain([a, 'optionalAccess', _301 => _301.y])))) fail(`${path}.path must be a subpath with at least two anchors.`);
     const out = { kind: "path", path: { closed: !!sp.closed, anchors: sp.anchors.map((a) => ({ ...a })) } };
     if (f.start !== void 0 && f.start !== 0) out.start = num2(f.start, `${path}.start`, 0, 1e7);
     if (f.end !== void 0 && f.end !== 0) out.end = num2(f.end, `${path}.end`, 0, 1e7);
@@ -8000,7 +8158,7 @@ function sanitizeVectorTextFrame(value, path = "frame") {
   return fail(`${path}.kind must be point, area or path, got ${JSON.stringify(f.kind)}.`);
 }
 function normalizeVectorTextRuns(text, runs) {
-  if (!_optionalChain([runs, 'optionalAccess', _271 => _271.length])) return null;
+  if (!_optionalChain([runs, 'optionalAccess', _302 => _302.length])) return null;
   const cleaned = fitVectorTextRuns(
     runs.map((r) => ({ length: r.length, style: stripUndefined(r.style) })),
     text.length
@@ -8040,7 +8198,7 @@ function replaceVectorText(node, start, end, insert) {
   const clean2 = insert.replace(/\r\n?/g, "\n");
   const text = node.text.slice(0, start) + clean2 + node.text.slice(end);
   let runs = null;
-  if (_optionalChain([node, 'access', _272 => _272.runs, 'optionalAccess', _273 => _273.length])) {
+  if (_optionalChain([node, 'access', _303 => _303.runs, 'optionalAccess', _304 => _304.length])) {
     const fitted = fitVectorTextRuns(node.runs, node.text.length);
     const style = styleAt(fitted, start > 0 ? start - 1 : start, {});
     runs = normalizeVectorTextRuns(text, spliceRuns(fitted, start, end, clean2.length, style));
@@ -8056,7 +8214,7 @@ function styleVectorText(node, start, end, patch) {
   if (whole) {
     let next2 = { ...node, font: patchVectorCharacterStyle(node.font, fields, "style") };
     const keys = Object.keys(fields).filter((k) => fields[k] !== void 0);
-    if (_optionalChain([next2, 'access', _274 => _274.runs, 'optionalAccess', _275 => _275.length]) && (keys.length || fill !== void 0)) {
+    if (_optionalChain([next2, 'access', _305 => _305.runs, 'optionalAccess', _306 => _306.length]) && (keys.length || fill !== void 0)) {
       const runs2 = normalizeVectorTextRuns(
         next2.text,
         next2.runs.map((r) => {
@@ -8101,7 +8259,7 @@ function bakeVectorTextGeometry(node, m) {
     ...s.baselineShift !== void 0 ? { baselineShift: s.baselineShift * k } : {}
   });
   const font = scaleStyle(node.font);
-  const runs = _optionalChain([node, 'access', _276 => _276.runs, 'optionalAccess', _277 => _277.map, 'call', _278 => _278((r) => ({ length: r.length, style: scaleStyle(r.style) }))]);
+  const runs = _optionalChain([node, 'access', _307 => _307.runs, 'optionalAccess', _308 => _308.map, 'call', _309 => _309((r) => ({ length: r.length, style: scaleStyle(r.style) }))]);
   const p = node.paragraph;
   const paragraph = p ? {
     ...p,
@@ -8390,7 +8548,7 @@ function vectorInstanceGroup(node, bake) {
   const m = _nullishCoalesce(node.transform, () => ( [1, 0, 0, 1, 0, 0]));
   const { rigid, residual } = decomposeRigid(m);
   const k = Math.sqrt(Math.abs(residual[0] * residual[3] - residual[1] * residual[2]));
-  const hidden = new Set(_nullishCoalesce(_optionalChain([node, 'access', _279 => _279.overrides, 'optionalAccess', _280 => _280.hidden]), () => ( [])));
+  const hidden = new Set(_nullishCoalesce(_optionalChain([node, 'access', _310 => _310.overrides, 'optionalAccess', _311 => _311.hidden]), () => ( [])));
   const keep = (list) => list.filter((n) => !hidden.has(n.id)).map((n) => n.type === "group" ? { ...n, children: keep(n.children) } : n);
   let children = prefixVectorIds(keep(_nullishCoalesce(node.art, () => ( []))), node.id);
   if (!isIdentityMatrix(residual)) children = children.map((c) => bake(c, residual));
@@ -8403,8 +8561,8 @@ function vectorInstanceGroup(node, bake) {
   if (node.locked) group.locked = true;
   if (node.opacity !== void 0) group.opacity = node.opacity;
   if (node.blendMode) group.blendMode = node.blendMode;
-  if (_optionalChain([node, 'access', _281 => _281.filters, 'optionalAccess', _282 => _282.length])) group.filters = node.filters;
-  if (_optionalChain([node, 'access', _283 => _283.effects, 'optionalAccess', _284 => _284.length])) group.effects = node.effects;
+  if (_optionalChain([node, 'access', _312 => _312.filters, 'optionalAccess', _313 => _313.length])) group.filters = node.filters;
+  if (_optionalChain([node, 'access', _314 => _314.effects, 'optionalAccess', _315 => _315.length])) group.effects = node.effects;
   if (node.booleanOperation) group.booleanOperation = node.booleanOperation;
   if (node.blendStep) group.blendStep = true;
   return group;
@@ -8657,8 +8815,8 @@ function vectorLensDrawn(node) {
         if (wire) {
           contents.push(shapePath(shape, id, changed, { fill: null, fills: void 0, stroke: wire, strokes: void 0, strokeWidth: 1, strokeAlign: void 0, strokeDasharray: void 0, strokeWidthProfile: void 0, opacity: Math.min(1, Math.max(0, lens.amount / 100)) }));
         } else if (recolour) {
-          const fills = _optionalChain([shape, 'access', _285 => _285.source, 'access', _286 => _286.fills, 'optionalAccess', _287 => _287.map, 'call', _288 => _288((l) => ({ ...l, paint: _nullishCoalesce(mapVectorPaintColors(l.paint, recolour), () => ( null)) }))]);
-          const strokes = _optionalChain([shape, 'access', _289 => _289.source, 'access', _290 => _290.strokes, 'optionalAccess', _291 => _291.map, 'call', _292 => _292((l) => ({ ...l, paint: _nullishCoalesce(mapVectorPaintColors(l.paint, recolour), () => ( null)) }))]);
+          const fills = _optionalChain([shape, 'access', _316 => _316.source, 'access', _317 => _317.fills, 'optionalAccess', _318 => _318.map, 'call', _319 => _319((l) => ({ ...l, paint: _nullishCoalesce(mapVectorPaintColors(l.paint, recolour), () => ( null)) }))]);
+          const strokes = _optionalChain([shape, 'access', _320 => _320.source, 'access', _321 => _321.strokes, 'optionalAccess', _322 => _322.map, 'call', _323 => _323((l) => ({ ...l, paint: _nullishCoalesce(mapVectorPaintColors(l.paint, recolour), () => ( null)) }))]);
           contents.push(shapePath(shape, id, changed, { fill: _nullishCoalesce(mapVectorPaintColors(shape.source.fill, recolour), () => ( null)), stroke: _nullishCoalesce(mapVectorPaintColors(shape.source.stroke, recolour), () => ( null)), ...fills ? { fills } : {}, ...strokes ? { strokes } : {} }));
         } else contents.push(shapePath(shape, id, changed));
       }
@@ -8671,7 +8829,7 @@ function vectorLensDrawn(node) {
   const { lens: _l, lensView: _v, transform: _t, opacity: _o, effects: _e, blendMode: _bm, filters: _f, ...style } = node;
   const fillOpacity = lens.type === "transparency" ? 1 - Math.min(100, Math.max(0, lens.amount)) / 100 : 0;
   children.push({ ...style, id: `${node.id}~lens-fill`, stroke: null, strokes: void 0, opacity: fillOpacity });
-  const stroked = (_nullishCoalesce(_optionalChain([node, 'access', _293 => _293.strokes, 'optionalAccess', _294 => _294.length]), () => ( 0))) > 0 || node.stroke != null && node.stroke !== "none";
+  const stroked = (_nullishCoalesce(_optionalChain([node, 'access', _324 => _324.strokes, 'optionalAccess', _325 => _325.length]), () => ( 0))) > 0 || node.stroke != null && node.stroke !== "none";
   if (stroked) children.push({ ...style, id: `${node.id}~lens-stroke`, fill: null, fills: void 0 });
   const out = {
     id: node.id,
@@ -8680,7 +8838,7 @@ function vectorLensDrawn(node) {
     ...node.transform ? { transform: node.transform } : {},
     ...node.opacity !== void 0 ? { opacity: node.opacity } : {},
     ...node.blendMode ? { blendMode: node.blendMode } : {},
-    ..._optionalChain([node, 'access', _295 => _295.filters, 'optionalAccess', _296 => _296.length]) ? { filters: node.filters } : {},
+    ..._optionalChain([node, 'access', _326 => _326.filters, 'optionalAccess', _327 => _327.length]) ? { filters: node.filters } : {},
     children
   };
   drawnCache2.set(node, out);
@@ -9681,7 +9839,7 @@ function normalizeVectorEffectParams(type, params, base) {
   if (!defaults) return null;
   const out = { ...defaults, ..._nullishCoalesce(base, () => ( {})) };
   for (const spec of VECTOR_EFFECT_PARAM_SPECS[type]) {
-    const v2 = _optionalChain([params, 'optionalAccess', _297 => _297[spec.key]]);
+    const v2 = _optionalChain([params, 'optionalAccess', _328 => _328[spec.key]]);
     if (v2 === void 0) continue;
     if (spec.kind === "number" && typeof v2 === "number" && Number.isFinite(v2)) out[spec.key] = Math.min(_nullishCoalesce(spec.max, () => ( Infinity)), Math.max(_nullishCoalesce(spec.min, () => ( -Infinity)), v2));
     else if (spec.kind === "boolean" && typeof v2 === "boolean") out[spec.key] = v2;
@@ -9693,7 +9851,7 @@ function normalizeVectorEffectParams(type, params, base) {
     const o = out;
     o.rows = Math.round(o.rows);
     o.columns = Math.round(o.columns);
-    const given = _optionalChain([params, 'optionalAccess', _298 => _298.mesh]);
+    const given = _optionalChain([params, 'optionalAccess', _329 => _329.mesh]);
     let mesh = given !== void 0 ? isValidWarpMesh(given) ? cloneMesh(given) : null : o.mesh;
     if (o.style !== "mesh") mesh = null;
     if (mesh && given !== void 0) {
@@ -9710,10 +9868,10 @@ function createVectorEffect(type, id, params) {
 }
 var isEnabled = (e) => e.enabled !== false && !!VECTOR_EFFECT_DEFAULTS[e.type];
 function activeVectorEffects(node) {
-  return _nullishCoalesce(_optionalChain([node, 'access', _299 => _299.effects, 'optionalAccess', _300 => _300.filter, 'call', _301 => _301(isEnabled)]), () => ( []));
+  return _nullishCoalesce(_optionalChain([node, 'access', _330 => _330.effects, 'optionalAccess', _331 => _331.filter, 'call', _332 => _332(isEnabled)]), () => ( []));
 }
 function hasOwnVectorAppearance(node) {
-  return node.type === "text" || node.type === "instance" || node.type === "group" && !!node.liveBoolean || isVectorFrame(node) || isVectorSymmetryGroup(node) || isVectorLens(node) || !!_optionalChain([node, 'access', _302 => _302.effects, 'optionalAccess', _303 => _303.some, 'call', _304 => _304(isEnabled)]);
+  return node.type === "text" || node.type === "instance" || node.type === "group" && !!node.liveBoolean || isVectorFrame(node) || isVectorSymmetryGroup(node) || isVectorLens(node) || !!_optionalChain([node, 'access', _333 => _333.effects, 'optionalAccess', _334 => _334.some, 'call', _335 => _335(isEnabled)]);
 }
 var liveCache = /* @__PURE__ */ new WeakMap();
 function hasVectorAppearance(node) {
@@ -9725,18 +9883,18 @@ function hasVectorAppearance(node) {
   return v2;
 }
 function isVectorLiveBoolean(node) {
-  return _optionalChain([node, 'optionalAccess', _305 => _305.type]) === "group" && !!node.liveBoolean;
+  return _optionalChain([node, 'optionalAccess', _336 => _336.type]) === "group" && !!node.liveBoolean;
 }
 function vectorOperandOperation(group, child) {
   return _nullishCoalesce(_nullishCoalesce(child.booleanOperation, () => ( group.liveBoolean)), () => ( "union"));
 }
 var PATH_OPS = { union: "union", subtract: "difference", intersect: "intersection", exclude: "xor" };
 var FoldCache = (_class9 = class {
-  constructor(cap) {;_class9.prototype.__init60.call(this);
+  constructor(cap) {;_class9.prototype.__init61.call(this);
     this.cap = cap;
   }
   
-  __init60() {this.map = /* @__PURE__ */ new Map()}
+  __init61() {this.map = /* @__PURE__ */ new Map()}
   get(key) {
     const hit = this.map.get(key);
     if (hit) {
@@ -9767,9 +9925,9 @@ function vectorLiveBooleanSteps() {
 function clearVectorLiveBooleanCache() {
   foldCache.clear();
 }
-var RollingHash = (_class10 = class _RollingHash {constructor() { _class10.prototype.__init61.call(this);_class10.prototype.__init62.call(this); }
-  __init61() {this.a = 2166136261}
-  __init62() {this.b = 16777619 ^ 1540483477}
+var RollingHash = (_class10 = class _RollingHash {constructor() { _class10.prototype.__init62.call(this);_class10.prototype.__init63.call(this); }
+  __init62() {this.a = 2166136261}
+  __init63() {this.b = 16777619 ^ 1540483477}
   static __initStatic() {this.view = new DataView(new ArrayBuffer(8))}
   byte(v2) {
     this.a = Math.imul(this.a ^ v2 & 255, 16777619);
@@ -9842,7 +10000,7 @@ var compareOrder = (a, b) => {
   for (let i = 0; i < n; i++) if (a[i] !== b[i]) return a[i] - b[i];
   return a.length - b.length;
 };
-var add3 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _306 => _306.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _307 => _307.y]), () => ( 0))) });
+var add3 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _337 => _337.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _338 => _338.y]), () => ( 0))) });
 var mapPaths = (shapes, fn) => {
   const out = fn(shapes.map((s) => s.path));
   return shapes.map((s, i) => ({ ...s, path: _nullishCoalesce(out[i], () => ( [])) }));
@@ -9870,7 +10028,7 @@ function contourShapes(shapes, c) {
     const power = 2 ** (Math.min(100, Math.max(-100, c.acceleration)) / 50);
     for (let k = 1; k <= n; k++) {
       const [path] = offsetPaths([s.path], (outside ? 1 : -1) * step * k, c.join, c.miterLimit, 1, 0);
-      if (!_optionalChain([path, 'optionalAccess', _308 => _308.length])) break;
+      if (!_optionalChain([path, 'optionalAccess', _339 => _339.length])) break;
       const t = (k / n) ** power;
       const source = { ...s.source, fill: _nullishCoalesce(blendPaint(s.source.fill, c.fillColor, t), () => ( null)), stroke: _nullishCoalesce(blendPaint(s.source.stroke, c.strokeColor, t), () => ( null)), fills: void 0, strokes: void 0 };
       out.push({ source, path, opacity: s.opacity, order: [outside ? n - k : k, ...s.order] });
@@ -9945,8 +10103,8 @@ function bevelShapes(shapes, b) {
       out.push({ source, path: f.path, opacity: s.opacity, order: [...s.order, 1, k] });
     });
     const [middle] = offsetPaths([s.path], -b.width, "miter", 4, 1, 0);
-    if (_optionalChain([middle, 'optionalAccess', _309 => _309.length])) out.push({ ...s, source: fillOnly, path: middle, order: [...s.order, 2] });
-    const hasStroke = _optionalChain([s, 'access', _310 => _310.source, 'access', _311 => _311.strokes, 'optionalAccess', _312 => _312.length]) || s.source.stroke != null && s.source.stroke !== "none";
+    if (_optionalChain([middle, 'optionalAccess', _340 => _340.length])) out.push({ ...s, source: fillOnly, path: middle, order: [...s.order, 2] });
+    const hasStroke = _optionalChain([s, 'access', _341 => _341.source, 'access', _342 => _342.strokes, 'optionalAccess', _343 => _343.length]) || s.source.stroke != null && s.source.stroke !== "none";
     if (hasStroke) out.push({ ...s, source: { ...s.source, fill: null, fills: void 0 }, order: [...s.order, 3] });
   }
   return out;
@@ -10079,10 +10237,10 @@ function vectorEffectInputBounds(node, effectId) {
   return paths ? pathsBounds(paths) : null;
 }
 function vectorNodeEnvelope(node) {
-  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _313 => _313.effects, 'optionalAccess', _314 => _314.find, 'call', _315 => _315((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
+  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _344 => _344.effects, 'optionalAccess', _345 => _345.find, 'call', _346 => _346((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
 }
 function vectorEnvelopeFrame(node, effectId) {
-  const e = effectId ? _optionalChain([node, 'access', _316 => _316.effects, 'optionalAccess', _317 => _317.find, 'call', _318 => _318((x) => x.id === effectId)]) : vectorNodeEnvelope(node);
+  const e = effectId ? _optionalChain([node, 'access', _347 => _347.effects, 'optionalAccess', _348 => _348.find, 'call', _349 => _349((x) => x.id === effectId)]) : vectorNodeEnvelope(node);
   if (!e || e.type !== "envelope") return null;
   const bounds = vectorEffectInputBounds(node, e.id);
   if (!bounds || !(bounds.width > 0 && bounds.height > 0)) return null;
@@ -10143,7 +10301,7 @@ function placement(node) {
     ...node.blendStep ? { blendStep: true } : {},
     ...node.booleanOperation ? { booleanOperation: node.booleanOperation } : {},
     ...node.blendMode ? { blendMode: node.blendMode } : {},
-    ..._optionalChain([node, 'access', _319 => _319.filters, 'optionalAccess', _320 => _320.length]) ? { filters: node.filters } : {}
+    ..._optionalChain([node, 'access', _350 => _350.filters, 'optionalAccess', _351 => _351.length]) ? { filters: node.filters } : {}
   };
 }
 function vectorAppearanceNodes(node) {
@@ -10275,7 +10433,7 @@ function vectorMasterPages(doc) {
 function fillTokens(node, page, pages) {
   const map = (s) => s.replace(/\{page\}/g, String(page)).replace(/\{pages\}/g, String(pages));
   if (!/\{pages?\}/.test(node.text)) return node;
-  if (!_optionalChain([node, 'access', _321 => _321.runs, 'optionalAccess', _322 => _322.length])) return { ...node, text: map(node.text) };
+  if (!_optionalChain([node, 'access', _352 => _352.runs, 'optionalAccess', _353 => _353.length])) return { ...node, text: map(node.text) };
   let at2 = 0;
   let text = "";
   const runs = [];
@@ -10298,7 +10456,7 @@ function vectorMasterArt(master, page, number, count) {
   const f = page.frame;
   const key = `${page.id}|${f.x}|${f.y}|${f.width}|${f.height}|${number}|${count}`;
   let byKey = artCache.get(master);
-  const hit = _optionalChain([byKey, 'optionalAccess', _323 => _323.get, 'call', _324 => _324(key)]);
+  const hit = _optionalChain([byKey, 'optionalAccess', _354 => _354.get, 'call', _355 => _355(key)]);
   if (hit) return hit;
   const art = master.children.filter((c) => c.visible !== false).map((c) => {
     const box = vectorNodeBounds(c);
@@ -10343,7 +10501,7 @@ function stripVectorMasterArt(doc) {
 // src/vector/connectors.ts
 var SIDES = ["top", "right", "bottom", "left", "center"];
 function isVectorConnector(node) {
-  return _optionalChain([node, 'optionalAccess', _325 => _325.type]) === "path" && !!node.connector;
+  return _optionalChain([node, 'optionalAccess', _356 => _356.type]) === "path" && !!node.connector;
 }
 function vectorConnectionSites(nodes, id) {
   const node = findVectorNode(nodes, id);
@@ -10400,7 +10558,7 @@ function facingSite(sites, toward) {
 }
 function storedEnds(node, world) {
   const sp = node.subpaths[0];
-  if (!_optionalChain([sp, 'optionalAccess', _326 => _326.anchors, 'access', _327 => _327.length])) return null;
+  if (!_optionalChain([sp, 'optionalAccess', _357 => _357.anchors, 'access', _358 => _358.length])) return null;
   const a = sp.anchors[0];
   const b = sp.anchors[sp.anchors.length - 1];
   return [applyMatrix(world, a), applyMatrix(world, b)];
@@ -10507,8 +10665,8 @@ function routeVectorConnector(nodes, id) {
   }));
   return {
     subpaths: [{ closed: false, anchors: local }],
-    startSide: _nullishCoalesce(_optionalChain([s, 'optionalAccess', _328 => _328.side]), () => ( null)),
-    endSide: _nullishCoalesce(_optionalChain([e, 'optionalAccess', _329 => _329.side]), () => ( null)),
+    startSide: _nullishCoalesce(_optionalChain([s, 'optionalAccess', _359 => _359.side]), () => ( null)),
+    endSide: _nullishCoalesce(_optionalChain([e, 'optionalAccess', _360 => _360.side]), () => ( null)),
     dropped: { start: !!startGlue && !s, end: !!endGlue && !e }
   };
 }
@@ -10520,7 +10678,7 @@ function sameSubpaths(a, b) {
     const o = b[i];
     return sp.closed === o.closed && sp.anchors.length === o.anchors.length && sp.anchors.every((p, k) => {
       const q = o.anchors[k];
-      return samePoint(p, q) && samePoint(p.in, q.in) && samePoint(p.out, q.out) && (_nullishCoalesce(_optionalChain([p, 'access', _330 => _330.corner, 'optionalAccess', _331 => _331.radius]), () => ( 0))) === (_nullishCoalesce(_optionalChain([q, 'access', _332 => _332.corner, 'optionalAccess', _333 => _333.radius]), () => ( 0)));
+      return samePoint(p, q) && samePoint(p.in, q.in) && samePoint(p.out, q.out) && (_nullishCoalesce(_optionalChain([p, 'access', _361 => _361.corner, 'optionalAccess', _362 => _362.radius]), () => ( 0))) === (_nullishCoalesce(_optionalChain([q, 'access', _363 => _363.corner, 'optionalAccess', _364 => _364.radius]), () => ( 0)));
     });
   });
 }
@@ -10799,7 +10957,7 @@ function applyVectorCornersAttribute(subpaths, value) {
   for (const item of value.trim().split(/\s+/)) {
     const m = /^(\d+)\.(\d+):([\d.eE+-]+)(?::([a-z]+))?$/.exec(item);
     if (!m) continue;
-    const a = _optionalChain([subpaths, 'access', _334 => _334[+m[1]], 'optionalAccess', _335 => _335.anchors, 'access', _336 => _336[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _365 => _365[+m[1]], 'optionalAccess', _366 => _366.anchors, 'access', _367 => _367[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -10824,7 +10982,7 @@ function vectorPaintToSvg(paint, gradientId, options = {}) {
     const area2 = bounds2 ? { x: bounds2.x - reach2, y: bounds2.y - reach2, width: bounds2.width + 2 * reach2, height: bounds2.height + 2 * reach2 } : null;
     const key2 = `${gradientId}|${_nullishCoalesce(options.role, () => ( "fill"))}|${_nullishCoalesce(options.precision, () => ( 3))}|${area2 ? [area2.x, area2.y, area2.width, area2.height].join(",") : ""}`;
     let byKey2 = paintCache.get(paint);
-    const hit = _optionalChain([byKey2, 'optionalAccess', _337 => _337.get, 'call', _338 => _338(key2)]);
+    const hit = _optionalChain([byKey2, 'optionalAccess', _368 => _368.get, 'call', _369 => _369(key2)]);
     if (hit) return { value: `url(#${gradientId})`, defs: hit };
     const defs2 = vectorShadedSvgDefs(paint, gradientId, { bounds: bounds2, area: area2, precision: _nullishCoalesce(options.precision, () => ( 3)) });
     if (!byKey2) paintCache.set(paint, byKey2 = /* @__PURE__ */ new Map());
@@ -10836,7 +10994,7 @@ function vectorPaintToSvg(paint, gradientId, options = {}) {
   const precision = _nullishCoalesce(options.precision, () => ( 3));
   const key = `${gradientId}|${role}|${precision}`;
   const owner = _nullishCoalesce(options.node, () => ( paint));
-  const cached = _optionalChain([paintCache, 'access', _339 => _339.get, 'call', _340 => _340(owner), 'optionalAccess', _341 => _341.get, 'call', _342 => _342(key)]);
+  const cached = _optionalChain([paintCache, 'access', _370 => _370.get, 'call', _371 => _371(owner), 'optionalAccess', _372 => _372.get, 'call', _373 => _373(key)]);
   if (cached && (!options.node || (role === "fill" ? options.node.fill : options.node.stroke) === paint)) return { value: `url(#${gradientId})`, defs: cached };
   const node = options.node;
   const bounds = node ? vectorPathLocalBounds(node) : null;
@@ -10890,7 +11048,7 @@ function vectorNodeLocalPaintBounds(node) {
 }
 var filterCache = /* @__PURE__ */ new WeakMap();
 function vectorNodeFilterSvg(node, id) {
-  if (!_optionalChain([node, 'access', _343 => _343.filters, 'optionalAccess', _344 => _344.length])) return null;
+  if (!_optionalChain([node, 'access', _374 => _374.filters, 'optionalAccess', _375 => _375.length])) return null;
   const hit = filterCache.get(node);
   if (hit && hit.id === id) return hit.filter;
   const active = activeVectorFilters(node);
@@ -10976,7 +11134,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (node.type === "path" && node.lens) out2 += ` data-vector-lens="${escapeAttr2(JSON.stringify(node.lens))}"`;
     const blend = vectorBlendModeCss(node.blendMode);
     if (blend) out2 += ` style="mix-blend-mode:${blend}"`;
-    if (_optionalChain([node, 'access', _345 => _345.filters, 'optionalAccess', _346 => _346.length])) {
+    if (_optionalChain([node, 'access', _376 => _376.filters, 'optionalAccess', _377 => _377.length])) {
       const filter = vectorNodeFilterSvg(node, `${prefix}filter-${node.id}`);
       const data = ` data-vector-filters="${escapeAttr2(JSON.stringify(node.filters))}"`;
       if (filter) {
@@ -11023,7 +11181,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     let out2 = ` stroke="${escapeAttr2(strokeValue)}" stroke-width="${num3(width)}"`;
     if (node.strokeLinecap && node.strokeLinecap !== "butt") out2 += ` stroke-linecap="${node.strokeLinecap}"`;
     if (node.strokeLinejoin && node.strokeLinejoin !== "miter") out2 += ` stroke-linejoin="${node.strokeLinejoin}"`;
-    if (_optionalChain([node, 'access', _347 => _347.strokeDasharray, 'optionalAccess', _348 => _348.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num3).join(" ")}"`;
+    if (_optionalChain([node, 'access', _378 => _378.strokeDasharray, 'optionalAccess', _379 => _379.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num3).join(" ")}"`;
     return out2;
   };
   const liveCorners = (node) => {
@@ -11072,7 +11230,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emit2 = (node, depth) => {
     if (node.visible === false && !options.includeHidden) return;
-    const wrappers = _nullishCoalesce(_optionalChain([options, 'access', _349 => _349.wrap, 'optionalAccess', _350 => _350[node.id]]), () => ( []));
+    const wrappers = _nullishCoalesce(_optionalChain([options, 'access', _380 => _380.wrap, 'optionalAccess', _381 => _381[node.id]]), () => ( []));
     wrappers.forEach((w2, i) => {
       let attrs = w2.id !== void 0 ? ` id="${escapeAttr2(w2.id)}"` : "";
       if (w2.transform) attrs += ` transform="${escapeAttr2(w2.transform)}"`;
@@ -11093,7 +11251,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emitMaskGroup = (node, depth) => {
     const [source, ...contents] = node.children;
-    const body = _optionalChain([node, 'access', _351 => _351.effects, 'optionalAccess', _352 => _352.length]) && contents.length ? [{ id: `${node.id}~content`, type: "group", effects: node.effects, children: contents }] : contents;
+    const body = _optionalChain([node, 'access', _382 => _382.effects, 'optionalAccess', _383 => _383.length]) && contents.length ? [{ id: `${node.id}~content`, type: "group", effects: node.effects, children: contents }] : contents;
     const settings = { type: node.mask.type, ...node.mask.invert ? { invert: true } : {} };
     lines.push(`${indent(depth)}<g${common(node)} data-vector-mask="${escapeAttr2(JSON.stringify(settings))}">`);
     const mask = vectorMaskRenderData(node, `${prefix}mask-${node.id}`, `${prefix}mask-filter-${node.id}`, precision);
@@ -11110,7 +11268,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       lines.push(`${indent(depth + 1)}<g data-vector-part="mask-source" display="none">`);
       emitNode(source, depth + 2);
       lines.push(`${indent(depth + 1)}</g>`);
-      if (_optionalChain([mask, 'optionalAccess', _353 => _353.clip])) {
+      if (_optionalChain([mask, 'optionalAccess', _384 => _384.clip])) {
         defs.push(`<clipPath id="${escapeAttr2(mask.id)}">${mask.clip.map((c) => `<path d="${c.d}" clip-rule="${c.clipRule}"/>`).join("")}</clipPath>`);
         ref = ` clip-path="url(#${escapeAttr2(mask.id)})"`;
       }
@@ -11122,7 +11280,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emitTextElement = (node, depth, attrs) => {
     const geometry = vectorTextGeometryNode(node);
-    const fields = { text: node.text, font: node.font, ..._optionalChain([node, 'access', _354 => _354.runs, 'optionalAccess', _355 => _355.length]) ? { runs: node.runs } : {}, ...node.paragraph ? { paragraph: node.paragraph } : {}, frame: node.frame, ...node.orientation ? { orientation: node.orientation } : {}, ..._optionalChain([node, 'access', _356 => _356.effects, 'optionalAccess', _357 => _357.length]) ? { effects: node.effects } : {} };
+    const fields = { text: node.text, font: node.font, ..._optionalChain([node, 'access', _385 => _385.runs, 'optionalAccess', _386 => _386.length]) ? { runs: node.runs } : {}, ...node.paragraph ? { paragraph: node.paragraph } : {}, frame: node.frame, ...node.orientation ? { orientation: node.orientation } : {}, ..._optionalChain([node, 'access', _387 => _387.effects, 'optionalAccess', _388 => _388.length]) ? { effects: node.effects } : {} };
     let data = ` data-vector-text="${escapeAttr2(JSON.stringify(fields))}"`;
     if (hasVectorPaintStacks(node)) data += ` data-vector-fills="${escapeAttr2(JSON.stringify(vectorFills(node)))}" data-vector-strokes="${escapeAttr2(JSON.stringify(vectorStrokes(node)))}"`;
     else {
@@ -11164,12 +11322,12 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emitText = (node, depth) => {
     const outlines = vectorTextPaths(node).outlines;
-    const effects = !!_optionalChain([node, 'access', _358 => _358.effects, 'optionalAccess', _359 => _359.some, 'call', _360 => _360((e) => e.enabled !== false)]);
+    const effects = !!_optionalChain([node, 'access', _389 => _389.effects, 'optionalAccess', _390 => _390.some, 'call', _391 => _391((e) => e.enabled !== false)]);
     if (!outlines || !effects && options.text !== "outlines") {
       emitTextElement(node, depth, common(node));
       return;
     }
-    lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr2(JSON.stringify({ kind: "text", ..._optionalChain([node, 'access', _361 => _361.effects, 'optionalAccess', _362 => _362.length]) ? { effects: node.effects } : {} }))}">`);
+    lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr2(JSON.stringify({ kind: "text", ..._optionalChain([node, 'access', _392 => _392.effects, 'optionalAccess', _393 => _393.length]) ? { effects: node.effects } : {} }))}">`);
     lines.push(`${indent(depth + 1)}<g data-vector-part="appearance">`);
     for (const shape of vectorAppearanceNodes(node)) emit2(shape, depth + 2);
     lines.push(`${indent(depth + 1)}</g>`);
@@ -11183,7 +11341,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   const symbolRef = (symbolId) => {
     const hit = symbolIds.get(symbolId);
     if (hit) return hit;
-    const sym2 = _optionalChain([doc, 'access', _363 => _363.symbols, 'optionalAccess', _364 => _364.find, 'call', _365 => _365((x) => x.id === symbolId)]);
+    const sym2 = _optionalChain([doc, 'access', _394 => _394.symbols, 'optionalAccess', _395 => _395.find, 'call', _396 => _396((x) => x.id === symbolId)]);
     if (!sym2) return null;
     const id = `${prefix}symbol-${symbolId}`;
     symbolIds.set(symbolId, id);
@@ -11193,20 +11351,20 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emitInstance = (node, depth) => {
     const data = { symbolId: node.symbolId, ...node.scaleStrokes === false ? { scaleStrokes: false } : {}, ...node.overrides ? { overrides: node.overrides } : {} };
-    const exact2 = !node.overrides && node.scaleStrokes !== false && !_optionalChain([node, 'access', _366 => _366.effects, 'optionalAccess', _367 => _367.length]) && !_optionalChain([node, 'access', _368 => _368.filters, 'optionalAccess', _369 => _369.length]);
+    const exact2 = !node.overrides && node.scaleStrokes !== false && !_optionalChain([node, 'access', _397 => _397.effects, 'optionalAccess', _398 => _398.length]) && !_optionalChain([node, 'access', _399 => _399.filters, 'optionalAccess', _400 => _400.length]);
     const ref = symbolRef(node.symbolId);
     if (exact2 && ref) {
       lines.push(`${indent(depth)}<use${common(node)} href="#${escapeAttr2(ref)}" data-vector-instance="${escapeAttr2(JSON.stringify(data))}"/>`);
       return;
     }
-    const full = { ...data, ...node.transform ? { transform: node.transform } : {}, ..._optionalChain([node, 'access', _370 => _370.effects, 'optionalAccess', _371 => _371.length]) ? { effects: node.effects } : {} };
+    const full = { ...data, ...node.transform ? { transform: node.transform } : {}, ..._optionalChain([node, 'access', _401 => _401.effects, 'optionalAccess', _402 => _402.length]) ? { effects: node.effects } : {} };
     lines.push(`${indent(depth)}<g data-vector-instance="${escapeAttr2(JSON.stringify(full))}">`);
     emitNode(vectorInstanceDrawn(node), depth + 1);
     lines.push(`${indent(depth)}</g>`);
   };
   const emitFrame = (node, depth) => {
     const f = node.frame;
-    const data = { ...f, ..._optionalChain([node, 'access', _372 => _372.effects, 'optionalAccess', _373 => _373.length]) ? { effects: node.effects } : {} };
+    const data = { ...f, ..._optionalChain([node, 'access', _403 => _403.effects, 'optionalAccess', _404 => _404.length]) ? { effects: node.effects } : {} };
     lines.push(`${indent(depth)}<g${common(node)} data-vector-frame="${escapeAttr2(JSON.stringify(data))}">`);
     const rect = vectorFrameRectPath(f);
     if (f.fill !== void 0 && f.fill !== null && f.fill !== "none") {
@@ -11221,7 +11379,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       ref = ` clip-path="url(#${escapeAttr2(id)})"`;
     }
     lines.push(`${indent(depth + 1)}<g data-vector-part="frame-contents"${ref}>`);
-    if (_optionalChain([node, 'access', _374 => _374.masterArt, 'optionalAccess', _375 => _375.length])) {
+    if (_optionalChain([node, 'access', _405 => _405.masterArt, 'optionalAccess', _406 => _406.length])) {
       lines.push(`${indent(depth + 2)}<g data-vector-part="frame-master">`);
       for (const child of node.masterArt) emit2(child, depth + 3);
       lines.push(`${indent(depth + 2)}</g>`);
@@ -11250,7 +11408,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (hasOwnVectorAppearance(node)) {
       const live2 = {
         kind: node.type,
-        ..._optionalChain([node, 'access', _376 => _376.effects, 'optionalAccess', _377 => _377.length]) ? { effects: node.effects } : {},
+        ..._optionalChain([node, 'access', _407 => _407.effects, 'optionalAccess', _408 => _408.length]) ? { effects: node.effects } : {},
         ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {},
         ...node.type === "group" && node.symmetry ? { symmetry: node.symmetry } : {}
       };
@@ -11301,7 +11459,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       data += ` data-vector-width-profile="${widthProfileToAttribute(profile)}"`;
       if (node.strokeLinecap && node.strokeLinecap !== "butt") data += ` data-vector-stroke-linecap="${node.strokeLinecap}"`;
       if (node.strokeLinejoin && node.strokeLinejoin !== "miter") data += ` data-vector-stroke-linejoin="${node.strokeLinejoin}"`;
-      if (_optionalChain([node, 'access', _378 => _378.strokeDasharray, 'optionalAccess', _379 => _379.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num3).join(" ")}"`;
+      if (_optionalChain([node, 'access', _409 => _409.strokeDasharray, 'optionalAccess', _410 => _410.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num3).join(" ")}"`;
     }
     lines.push(`${indent(depth)}<g${common(node)}${data}>`);
     lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}"${fillAttrs}${live}/>`);
@@ -11482,7 +11640,7 @@ function readStyle(el, parent, cssRules) {
   const { mixBlendMode: _m, filter: _f, ...inherited } = parent;
   const out = { ...inherited };
   for (const [attr, key] of Object.entries(STYLE_KEYS)) if (el.attrs[attr] !== void 0) out[key] = el.attrs[attr].trim();
-  if (_optionalChain([cssRules, 'optionalAccess', _380 => _380.length])) {
+  if (_optionalChain([cssRules, 'optionalAccess', _411 => _411.length])) {
     for (const rule of cssRules) {
       if (matchesSelector(el, rule.selector)) {
         for (const [prop, val] of Object.entries(rule.properties)) {
@@ -11538,7 +11696,7 @@ function attrOrStyle(el, name) {
   return el.attrs[name];
 }
 function urlId(value) {
-  return _nullishCoalesce(_optionalChain([/^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/, 'access', _381 => _381.exec, 'call', _382 => _382((_nullishCoalesce(value, () => ( ""))).trim()), 'optionalAccess', _383 => _383[1]]), () => ( null));
+  return _nullishCoalesce(_optionalChain([/^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/, 'access', _412 => _412.exec, 'call', _413 => _413((_nullishCoalesce(value, () => ( ""))).trim()), 'optionalAccess', _414 => _414[1]]), () => ( null));
 }
 function clipRulesAsFillRules(el) {
   const attrs = { ...el.attrs };
@@ -11603,9 +11761,9 @@ function resolveGradient(id, raw) {
   for (let el = first; el && !chain.includes(el) && chain.length < 32; ) {
     chain.push(el);
     const href = _nullishCoalesce(el.attrs.href, () => ( el.attrs["xlink:href"]));
-    el = _optionalChain([href, 'optionalAccess', _384 => _384.startsWith, 'call', _385 => _385("#")]) ? raw.get(href.slice(1)) : void 0;
+    el = _optionalChain([href, 'optionalAccess', _415 => _415.startsWith, 'call', _416 => _416("#")]) ? raw.get(href.slice(1)) : void 0;
   }
-  const attr = (name) => _optionalChain([chain, 'access', _386 => _386.find, 'call', _387 => _387((el) => el.attrs[name] !== void 0), 'optionalAccess', _388 => _388.attrs, 'access', _389 => _389[name]]);
+  const attr = (name) => _optionalChain([chain, 'access', _417 => _417.find, 'call', _418 => _418((el) => el.attrs[name] !== void 0), 'optionalAccess', _419 => _419.attrs, 'access', _420 => _420[name]]);
   const stops = _nullishCoalesce(chain.map(readStops).find((s) => s.length), () => ( []));
   if (!stops.length) return null;
   const user = attr("gradientUnits") === "userSpaceOnUse";
@@ -11777,7 +11935,7 @@ function parseVectorSvg(svg, options = {}) {
   const stackedPath = (g, _style, m, meta) => {
     const fillEl = g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === "fill");
     const subpaths = fillEl ? shapeOf(fillEl) : null;
-    if (!_optionalChain([subpaths, 'optionalAccess', _390 => _390.length])) return null;
+    if (!_optionalChain([subpaths, 'optionalAccess', _421 => _421.length])) return null;
     const parse = (v2) => {
       try {
         return v2 ? JSON.parse(v2) : [];
@@ -11796,7 +11954,7 @@ function parseVectorSvg(svg, options = {}) {
     const key = (n) => JSON.stringify([n.subpaths, _nullishCoalesce(n.transform, () => ( null)), _nullishCoalesce(n.opacity, () => ( 1)), n.visible !== false, _nullishCoalesce(n.filters, () => ( null)), _nullishCoalesce(n.blendMode, () => ( "normal")), _nullishCoalesce(n.fillRule, () => ( "nonzero")), _nullishCoalesce(n.booleanOperation, () => ( null))]);
     for (const n of nodes2) {
       const prev = out[out.length - 1];
-      if (_optionalChain([prev, 'optionalAccess', _391 => _391.type]) === "path" && n.type === "path" && key(prev) === key(n)) {
+      if (_optionalChain([prev, 'optionalAccess', _422 => _422.type]) === "path" && n.type === "path" && key(prev) === key(n)) {
         const fills = vectorFills(n);
         const strokesBefore = vectorStrokes(prev);
         if (!(fills.length && strokesBefore.length)) {
@@ -11814,7 +11972,7 @@ function parseVectorSvg(svg, options = {}) {
     const part = (name) => g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === name);
     const fillEl = part("fill");
     const subpaths = fillEl ? shapeOf(fillEl) : null;
-    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _392 => _392.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _423 => _423.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style, styleRules);
     const strokeEl = part("stroke");
@@ -11851,7 +12009,7 @@ function parseVectorSvg(svg, options = {}) {
       ...profile.length ? { strokeWidthProfile: profile } : {},
       ...keptCap ? { strokeLinecap: keptCap } : {},
       ...keptJoin ? { strokeLinejoin: keptJoin } : {},
-      ..._optionalChain([keptDash, 'optionalAccess', _393 => _393.length]) ? { strokeDasharray: keptDash } : {}
+      ..._optionalChain([keptDash, 'optionalAccess', _424 => _424.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
@@ -11916,8 +12074,8 @@ function parseVectorSvg(svg, options = {}) {
     } else {
       const fill = json2(g.attrs["data-vector-fill"]);
       const stroke = json2(g.attrs["data-vector-stroke"]);
-      node.fill = fill == null ? null : _nullishCoalesce(_optionalChain([sanitizeVectorFills, 'call', _394 => _394([{ paint: fill }]), 'access', _395 => _395[0], 'optionalAccess', _396 => _396.paint]), () => ( null));
-      node.stroke = stroke == null ? null : _nullishCoalesce(_optionalChain([sanitizeVectorFills, 'call', _397 => _397([{ paint: stroke }]), 'access', _398 => _398[0], 'optionalAccess', _399 => _399.paint]), () => ( null));
+      node.fill = fill == null ? null : _nullishCoalesce(_optionalChain([sanitizeVectorFills, 'call', _425 => _425([{ paint: fill }]), 'access', _426 => _426[0], 'optionalAccess', _427 => _427.paint]), () => ( null));
+      node.stroke = stroke == null ? null : _nullishCoalesce(_optionalChain([sanitizeVectorFills, 'call', _428 => _428([{ paint: stroke }]), 'access', _429 => _429[0], 'optionalAccess', _430 => _430.paint]), () => ( null));
       const settings = json2(g.attrs["data-vector-stroke-settings"]);
       if (settings && typeof settings === "object") {
         const strokes = sanitizeVectorStrokes([{ paint: _nullishCoalesce(node.stroke, () => ( "#000")), ...settings }]);
@@ -11953,8 +12111,8 @@ function parseVectorSvg(svg, options = {}) {
     const anchor = attrOrStyle(el, "text-anchor");
     const first0 = (v2) => _nullishCoalesce(numberList(v2)[0], () => ( 0));
     const tspan = el.children.find((c) => c.name === "tspan");
-    const x = el.attrs.x !== void 0 ? first0(el.attrs.x) : first0(_optionalChain([tspan, 'optionalAccess', _400 => _400.attrs, 'access', _401 => _401.x]));
-    const y = el.attrs.y !== void 0 ? first0(el.attrs.y) : first0(_optionalChain([tspan, 'optionalAccess', _402 => _402.attrs, 'access', _403 => _403.y]));
+    const x = el.attrs.x !== void 0 ? first0(el.attrs.x) : first0(_optionalChain([tspan, 'optionalAccess', _431 => _431.attrs, 'access', _432 => _432.x]));
+    const y = el.attrs.y !== void 0 ? first0(el.attrs.y) : first0(_optionalChain([tspan, 'optionalAccess', _433 => _433.attrs, 'access', _434 => _434.y]));
     const fillValue = _nullishCoalesce(attrOrStyle(el, "fill"), () => ( style.fill));
     let node = {
       id: idFor(el),
@@ -11985,12 +12143,12 @@ function parseVectorSvg(svg, options = {}) {
     if (symbolOfElement.has(el)) return symbolOfElement.get(el);
     symbolOfElement.set(el, null);
     const own = json2(el.attrs["data-vector-symbol"]);
-    let id = typeof _optionalChain([own, 'optionalAccess', _404 => _404.id]) === "string" && own.id ? own.id : _nullishCoalesce(el.attrs.id, () => ( createId()));
+    let id = typeof _optionalChain([own, 'optionalAccess', _435 => _435.id]) === "string" && own.id ? own.id : _nullishCoalesce(el.attrs.id, () => ( createId()));
     while (usedSymbolIds.has(id)) id = `${id}-${usedSymbolIds.size}`;
     usedSymbolIds.add(id);
     const style = readStyle(el, rootStyle, styleRules);
     const nodes2 = el.name === "symbol" ? visit2(el, style, IDENTITY_MATRIX) : visitOne({ ...el, attrs: { ...el.attrs, transform: "" } }, rootStyle, parseSvgTransform(el.attrs.transform));
-    symbols.push({ id, name: typeof _optionalChain([own, 'optionalAccess', _405 => _405.name]) === "string" && own.name ? own.name : _nullishCoalesce(el.attrs.id, () => ( "Symbol")), nodes: nodes2 });
+    symbols.push({ id, name: typeof _optionalChain([own, 'optionalAccess', _436 => _436.name]) === "string" && own.name ? own.name : _nullishCoalesce(el.attrs.id, () => ( "Symbol")), nodes: nodes2 });
     symbolOfElement.set(el, id);
     return id;
   };
@@ -12002,13 +12160,13 @@ function parseVectorSvg(svg, options = {}) {
     if (!symbolId) return null;
     const own = json2(el.attrs["data-vector-instance"]);
     const place3 = multiplyMatrices(translateMatrix(length(el.attrs.x), length(el.attrs.y)), m);
-    const node = { id: idFor(el), type: "instance", ...meta, symbolId, ..._optionalChain([own, 'optionalAccess', _406 => _406.scaleStrokes]) === false ? { scaleStrokes: false } : {}, ..._optionalChain([own, 'optionalAccess', _407 => _407.overrides]) ? { overrides: own.overrides } : {} };
+    const node = { id: idFor(el), type: "instance", ...meta, symbolId, ..._optionalChain([own, 'optionalAccess', _437 => _437.scaleStrokes]) === false ? { scaleStrokes: false } : {}, ..._optionalChain([own, 'optionalAccess', _438 => _438.overrides]) ? { overrides: own.overrides } : {} };
     return isIdentityMatrix(place3) ? node : { ...node, transform: place3 };
   };
   const ownInstance = (g, m, meta) => {
     const raw = json2(g.attrs["data-vector-instance"]);
     if (!raw || typeof raw.symbolId !== "string") return null;
-    const sym2 = [...byId.values()].find((e) => e.name === "symbol" && _optionalChain([json2, 'call', _408 => _408(e.attrs["data-vector-symbol"]), 'optionalAccess', _409 => _409.id]) === raw.symbolId);
+    const sym2 = [...byId.values()].find((e) => e.name === "symbol" && _optionalChain([json2, 'call', _439 => _439(e.attrs["data-vector-symbol"]), 'optionalAccess', _440 => _440.id]) === raw.symbolId);
     const symbolId = sym2 ? symbolFor(sym2) : raw.symbolId;
     if (!symbolId) return null;
     const t = Array.isArray(raw.transform) && raw.transform.length === 6 && raw.transform.every(Number.isFinite) ? raw.transform : IDENTITY_MATRIX;
@@ -12016,7 +12174,7 @@ function parseVectorSvg(svg, options = {}) {
     const drawn = g.children.find((c) => c.name === "g");
     const effects = sanitizeVectorEffects(raw.effects);
     const node = {
-      id: _nullishCoalesce(_optionalChain([drawn, 'optionalAccess', _410 => _410.attrs, 'access', _411 => _411.id]), () => ( idFor(g))),
+      id: _nullishCoalesce(_optionalChain([drawn, 'optionalAccess', _441 => _441.attrs, 'access', _442 => _442.id]), () => ( idFor(g))),
       type: "instance",
       ...meta,
       symbolId,
@@ -12073,12 +12231,12 @@ function parseVectorSvg(svg, options = {}) {
   const masked = (el, nodes2, m) => {
     let out = nodes2;
     const clipEl = rawMasks.get(_nullishCoalesce(urlId(attrOrStyle(el, "clip-path")), () => ( "")));
-    if (_optionalChain([clipEl, 'optionalAccess', _412 => _412.name]) === "clipPath") {
+    if (_optionalChain([clipEl, 'optionalAccess', _443 => _443.name]) === "clipPath") {
       const source = maskNode(clipEl, m, out, clipEl.attrs.clipPathUnits);
       if (source) out = [{ id: idFor({ name: "g", attrs: {}, children: [] }), type: "group", name: "Clip Group", mask: { type: "clip" }, children: [source, ...out] }];
     }
     const maskEl = rawMasks.get(_nullishCoalesce(urlId(attrOrStyle(el, "mask")), () => ( "")));
-    if (_optionalChain([maskEl, 'optionalAccess', _413 => _413.name]) === "mask") {
+    if (_optionalChain([maskEl, 'optionalAccess', _444 => _444.name]) === "mask") {
       const source = maskNode(maskEl, m, out, maskEl.attrs.maskContentUnits);
       const type = attrOrStyle(maskEl, "mask-type") === "alpha" ? "alpha" : "luminance";
       if (source) out = [{ id: idFor({ name: "g", attrs: {}, children: [] }), type: "group", name: "Opacity Mask", mask: { type }, children: [source, ...out] }];
@@ -12100,19 +12258,19 @@ function parseVectorSvg(svg, options = {}) {
     let sourceEl = part("mask-source");
     if (!sourceEl) {
       const el = rawMasks.get(_nullishCoalesce(urlId(maskedEl.attrs.mask), () => ( "")));
-      const invert2 = _optionalChain([el, 'optionalAccess', _414 => _414.children, 'access', _415 => _415.find, 'call', _416 => _416((c) => c.name === "g" && c.attrs["data-vector-part"] === "mask-invert")]);
+      const invert2 = _optionalChain([el, 'optionalAccess', _445 => _445.children, 'access', _446 => _446.find, 'call', _447 => _447((c) => c.name === "g" && c.attrs["data-vector-part"] === "mask-invert")]);
       sourceEl = _nullishCoalesce(invert2, () => ( el));
     }
     const source = sourceEl ? visit2(sourceEl, style, m)[0] : void 0;
     let contents = visit2(maskedEl, style, m);
     let effects;
     const wrapper = contents.length === 1 && contents[0].type === "group" && contents[0].id === `${id}~content` ? contents[0] : null;
-    if (_optionalChain([wrapper, 'optionalAccess', _417 => _417.type]) === "group") {
+    if (_optionalChain([wrapper, 'optionalAccess', _448 => _448.type]) === "group") {
       effects = _nullishCoalesce(wrapper.effects, () => ( void 0));
       contents = wrapper.children;
     }
     if (!source) return contents.length ? { id, type: "group", ...meta, children: contents } : null;
-    return { id, type: "group", ...meta, mask, ..._optionalChain([effects, 'optionalAccess', _418 => _418.length]) ? { effects } : {}, children: [source, ...contents] };
+    return { id, type: "group", ...meta, mask, ..._optionalChain([effects, 'optionalAccess', _449 => _449.length]) ? { effects } : {}, children: [source, ...contents] };
   };
   const frameGroup = (g, style, m, meta) => {
     const raw = parseJson(g.attrs["data-vector-frame"]);
@@ -12124,7 +12282,7 @@ function parseVectorSvg(svg, options = {}) {
     const { rigid, residual } = decomposeRigid(m);
     const r = _chunkGF2RBSDMcjs.bezierPathBounds.call(void 0, _chunkGF2RBSDMcjs.transformBezierPath.call(void 0, subpathsToBezier(vectorFrameRectPath(frame)), residual));
     const back = invertMatrix(rigid);
-    const effects = sanitizeVectorEffects(_optionalChain([raw, 'optionalAccess', _419 => _419.effects]));
+    const effects = sanitizeVectorEffects(_optionalChain([raw, 'optionalAccess', _450 => _450.effects]));
     return {
       id,
       type: "group",
@@ -12596,13 +12754,13 @@ function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX, opt
   }
   if (isVectorMaskGroup(node)) {
     const m = multiplyMatrices(nodeMatrix(node), parent);
-    const entered = !!_optionalChain([options, 'access', _420 => _420.entered, 'optionalAccess', _421 => _421.has, 'call', _422 => _422(node.id)]);
+    const entered = !!_optionalChain([options, 'access', _451 => _451.entered, 'optionalAccess', _452 => _452.has, 'call', _453 => _453(node.id)]);
     if (!entered && isVectorMaskActive(node) && !vectorMaskContains(node, applyMatrix(invertMatrix(m), p), tolerance)) return false;
     const shown = !entered && hasOwnVectorAppearance(node) ? expandVectorAppearance(node).children : node.children;
     for (let i = shown.length - 1; i >= 1; i--) if (hitTestVectorNode(shown[i], p, tolerance, m, options)) return true;
     return entered && hitTestVectorMaskSource(node, p, tolerance, m, options);
   }
-  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _423 => _423.entered, 'optionalAccess', _424 => _424.has, 'call', _425 => _425(node.id)])))) node = expandVectorAppearance(node);
+  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _454 => _454.entered, 'optionalAccess', _455 => _455.has, 'call', _456 => _456(node.id)])))) node = expandVectorAppearance(node);
   if (node.type === "group") {
     const m = multiplyMatrices(nodeMatrix(node), parent);
     return node.children.some((c) => hitTestVectorNode(c, p, tolerance, m, options));
@@ -12614,7 +12772,7 @@ function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX, opt
 function hitTestVectorMaskSource(group, p, tolerance, m, options) {
   const source = group.children[0];
   if (source.visible === false) return false;
-  if (_optionalChain([group, 'access', _426 => _426.mask, 'optionalAccess', _427 => _427.type]) !== "clip") return hitTestVectorNode(source, p, tolerance, m, options);
+  if (_optionalChain([group, 'access', _457 => _457.mask, 'optionalAccess', _458 => _458.type]) !== "clip") return hitTestVectorNode(source, p, tolerance, m, options);
   const paths = collectPathNodes(source).filter((n) => n.visible !== false);
   const pt2 = [p.x, p.y];
   return paths.some((n) => {
@@ -12663,24 +12821,24 @@ function mapAnchor(a, m) {
 }
 function bakeIntoGeometry(node, m) {
   if (isIdentityMatrix(m)) return node;
-  if (_optionalChain([node, 'access', _428 => _428.effects, 'optionalAccess', _429 => _429.length])) node = { ...node, effects: transformVectorEffects(node.effects, m, node) };
+  if (_optionalChain([node, 'access', _459 => _459.effects, 'optionalAccess', _460 => _460.length])) node = { ...node, effects: transformVectorEffects(node.effects, m, node) };
   if (isVectorFrame(node)) return bakeFrame(node, m);
   if (node.type === "group") {
     const group = node;
     const children = group.children.map((c) => transformVectorNode(c, m));
     const sym2 = group.symmetry ? { symmetry: transformVectorSymmetry(group.symmetry, m) } : {};
-    const spine = _optionalChain([group, 'access', _430 => _430.blend, 'optionalAccess', _431 => _431.spine]);
+    const spine = _optionalChain([group, 'access', _461 => _461.blend, 'optionalAccess', _462 => _462.spine]);
     if (!spine) return { ...group, ...sym2, children };
     const moved = { closed: spine.closed, anchors: spine.anchors.map((a) => mapAnchor(a, m)) };
     return { ...group, children, blend: { ...group.blend, spine: moved } };
   }
   const path = node.type === "text" ? bakeVectorTextGeometry(node, m) : node;
   const flips = m[0] * m[3] - m[1] * m[2] < 0;
-  const mirrored = flips && _optionalChain([path, 'access', _432 => _432.strokeWidthProfile, 'optionalAccess', _433 => _433.length]);
+  const mirrored = flips && _optionalChain([path, 'access', _463 => _463.strokeWidthProfile, 'optionalAccess', _464 => _464.length]);
   const layer = (l) => ({
     ...l,
     ...isVectorGradient(l.paint) || isVectorShadedPaint(l.paint) ? { paint: transformVectorPaint(l.paint, m) } : {},
-    ...flips && _optionalChain([l, 'access', _434 => _434.strokeWidthProfile, 'optionalAccess', _435 => _435.length]) ? { strokeWidthProfile: mirrorWidthProfile(l.strokeWidthProfile) } : {}
+    ...flips && _optionalChain([l, 'access', _465 => _465.strokeWidthProfile, 'optionalAccess', _466 => _466.length]) ? { strokeWidthProfile: mirrorWidthProfile(l.strokeWidthProfile) } : {}
   });
   return {
     ...path,
@@ -12915,7 +13073,7 @@ function roundSubpaths(subpaths, precision = 3) {
 
 // src/vector/symmetry.ts
 function isVectorSymmetryGroup(node) {
-  return _optionalChain([node, 'optionalAccess', _436 => _436.type]) === "group" && !!node.symmetry && !node.blend && !node.liveBoolean && !node.mask && !node.frame;
+  return _optionalChain([node, 'optionalAccess', _467 => _467.type]) === "group" && !!node.symmetry && !node.blend && !node.liveBoolean && !node.mask && !node.frame;
 }
 var rad = (deg) => deg * Math.PI / 180;
 var exact = (v2) => Math.abs(v2) < 1e-12 ? 0 : v2;