@pixerate/editor 0.266.2 → 0.268.0

package/dist/{chunk-XRXFVRGY.cjs → chunk-JBB3GDBB.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9; var _class10;
 
 
 
@@ -7,7 +7,12 @@
 
 
 
-var _chunkRFJZGTHAcjs = require('./chunk-RFJZGTHA.cjs');
+
+var _chunkEU2ZZA6Lcjs = require('./chunk-EU2ZZA6L.cjs');
+
+
+
+var _chunkRDFHWAHLcjs = require('./chunk-RDFHWAHL.cjs');
 
 
 var _chunkCVFAAZXEcjs = require('./chunk-CVFAAZXE.cjs');
@@ -57,7 +62,66 @@ var _chunkJBZRVLXVcjs = require('./chunk-JBZRVLXV.cjs');
 
 
 
-var _chunkPXDIAYB6cjs = require('./chunk-PXDIAYB6.cjs');
+
+
+
+
+
+
+
+
+
+
+
+var _chunkJ5VQYK7Tcjs = require('./chunk-J5VQYK7T.cjs');
+
+
+
+
+
+var _chunkSTLTOISWcjs = require('./chunk-STLTOISW.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkNIBFKXMDcjs = require('./chunk-NIBFKXMD.cjs');
+
+
+
+var _chunk3K6HWEXZcjs = require('./chunk-3K6HWEXZ.cjs');
+
+
+
+var _chunkYQGCPL5Xcjs = require('./chunk-YQGCPL5X.cjs');
+
+
+var _chunk2VX55NFMcjs = require('./chunk-2VX55NFM.cjs');
+
+
+
+
+
+
+
+
+var _chunk474IQG74cjs = require('./chunk-474IQG74.cjs');
 
 
 
@@ -2320,7 +2384,7 @@ function vectorStrokeParts(path, style) {
   const cap = capExtent(style, width);
   const tipMode = style.arrowAlign === "tip";
   const trims = contours.map(() => [0, 0]);
-  const place2 = (end, contour, ci) => {
+  const place3 = (end, contour, ci) => {
     const kind = end === "start" ? style.startArrow : style.endArrow;
     if (!kind || contour.closed) return;
     const hw = arrowheadWeight(style, end);
@@ -2341,8 +2405,8 @@ function vectorStrokeParts(path, style) {
     }
     heads.push({ end, kind, tip, dir, inset, path: arrowheadPath(kind, tip, dir, hw) });
   };
-  place2("start", first, 0);
-  place2("end", last, contours.length - 1);
+  place3("start", first, 0);
+  place3("end", last, contours.length - 1);
   if (!tipMode || !heads.length) return { align, line: path, drawWidth, heads };
   const trimmed = contours.map((c, i) => {
     const [s0, s1] = trims[i];
@@ -2534,22 +2598,1951 @@ function vectorExtrudeFaces(path, params) {
   return order.map((i) => faces[i].face);
 }
 
+// src/paint-editor/effect-paint.ts
+var EFFECT_STRIP_HEIGHT = 256;
+var EFFECT_MAP_REPEATS = ["repeat", "mirror", "clamp"];
+function effectPaintSize(p, canvas) {
+  return p.map ? { width: p.map.length, height: EFFECT_STRIP_HEIGHT } : { width: canvas.width, height: canvas.height };
+}
+function readEffectStrokeMap(raw) {
+  if (raw === void 0 || raw === null || raw.by === "canvas") return void 0;
+  const r = raw;
+  if (r.by !== "stroke") throw new Error(`map.by ${JSON.stringify(r.by)} is not a mapping; use "canvas" (fixed to the canvas) or "stroke" (along each stroke).`);
+  const length2 = r.length === void 0 ? 300 : Number(r.length);
+  if (!(Number.isFinite(length2) && length2 >= 16 && length2 <= 4096)) throw new Error(`map.length ${JSON.stringify(r.length)} is out of range; use 16..4096 px of stroke per repeat.`);
+  const repeat = r.repeat === void 0 ? "repeat" : r.repeat;
+  if (!EFFECT_MAP_REPEATS.includes(repeat)) throw new Error(`map.repeat ${JSON.stringify(r.repeat)} is not a repeat mode; use ${EFFECT_MAP_REPEATS.join(", ")}.`);
+  return { by: "stroke", length: Math.round(length2), repeat };
+}
+function stripIndex(img, map, dab, x, y) {
+  const ca = Math.cos(dab.direction);
+  const sa = Math.sin(dab.direction);
+  const dx = x - dab.x;
+  const dy = y - dab.y;
+  let u = (dab.travel + dx * ca - dy * sa) / map.length;
+  if (map.repeat === "clamp") u = Math.min(1, Math.max(0, u));
+  else if (map.repeat === "mirror") {
+    const m = (u % 2 + 2) % 2;
+    u = m > 1 ? 2 - m : m;
+  } else u = (u % 1 + 1) % 1;
+  const v2 = Math.min(1, Math.max(0, ((dx * sa + dy * ca) / Math.max(0.5, dab.radius) + 1) / 2));
+  const px = Math.min(img.width - 1, Math.floor(u * img.width));
+  const py = Math.min(img.height - 1, Math.floor(v2 * img.height));
+  return (py * img.width + px) * 4;
+}
+function effectPaintKey(p) {
+  return JSON.stringify({ type: "effect", effect: p.effect, provider: p.provider, values: p.values, time: p.time, ...p.map ? { map: p.map } : {} });
+}
+function isPaintEffectPaint(raw) {
+  return Boolean(raw) && typeof raw === "object" && raw.type === "effect";
+}
+function readMapLeniently(raw) {
+  try {
+    return readEffectStrokeMap(raw);
+  } catch (e4) {
+    return void 0;
+  }
+}
+function readPaintEffectPaint(raw) {
+  if (!isPaintEffectPaint(raw)) return null;
+  const r = raw;
+  if (typeof r.effect !== "string" || !r.effect || !r.values || typeof r.values !== "object" || Array.isArray(r.values)) return null;
+  return {
+    type: "effect",
+    effect: r.effect,
+    provider: typeof r.provider === "string" ? r.provider : "",
+    values: JSON.parse(JSON.stringify(r.values)),
+    time: typeof r.time === "number" && Number.isFinite(r.time) && r.time > 0 ? r.time : 0,
+    ...readMapLeniently(r.map) ? { map: readMapLeniently(r.map) } : {},
+    ...r.live === true ? { live: true } : {}
+  };
+}
+function sampleEffectField(img, rect, vals, field, dab) {
+  const { width, height, data } = img;
+  if (img.map && dab) {
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        const i = stripIndex(img, img.map, dab, rect.x + xx + 0.5, rect.y + yy + 0.5);
+        const f = k * 3;
+        const a = data[i + 3];
+        if (a < 255) vals[k] *= a / 255;
+        field[f] = data[i] / 255;
+        field[f + 1] = data[i + 1] / 255;
+        field[f + 2] = data[i + 2] / 255;
+      }
+    }
+    return;
+  }
+  for (let yy = 0, k = 0; yy < rect.height; yy++) {
+    const y = rect.y + yy;
+    const inY = y >= 0 && y < height;
+    for (let xx = 0; xx < rect.width; xx++, k++) {
+      const x = rect.x + xx;
+      const f = k * 3;
+      if (!inY || x < 0 || x >= width) {
+        vals[k] = 0;
+        field[f] = field[f + 1] = field[f + 2] = 0;
+        continue;
+      }
+      const i = (y * width + x) * 4;
+      const a = data[i + 3];
+      if (a < 255) vals[k] *= a / 255;
+      field[f] = data[i] / 255;
+      field[f + 1] = data[i + 1] / 255;
+      field[f + 2] = data[i + 2] / 255;
+    }
+  }
+}
+function sampleEffectAt(img, x, y, out, dab) {
+  if (img.map && dab) {
+    const i2 = stripIndex(img, img.map, dab, x, y);
+    out[0] = img.data[i2] / 255;
+    out[1] = img.data[i2 + 1] / 255;
+    out[2] = img.data[i2 + 2] / 255;
+    return img.data[i2 + 3] / 255;
+  }
+  const px = Math.floor(x);
+  const py = Math.floor(y);
+  if (px < 0 || py < 0 || px >= img.width || py >= img.height) return 0;
+  const i = (py * img.width + px) * 4;
+  out[0] = img.data[i] / 255;
+  out[1] = img.data[i + 1] / 255;
+  out[2] = img.data[i + 2] / 255;
+  return img.data[i + 3] / 255;
+}
+function effectDabField(img, rect, cov, centre, mixed, field, steps = 0, dab = null) {
+  sampleEffectField(img, rect, cov, field, dab);
+  const d0 = mixed[0] - centre[0];
+  const d1 = mixed[1] - centre[1];
+  const d2 = mixed[2] - centre[2];
+  const n = rect.width * rect.height;
+  for (let k = 0; k < n; k++) {
+    if (steps) cov[k] = Math.round(cov[k] * steps) / steps;
+    const f = k * 3;
+    field[f] = Math.min(1, Math.max(0, field[f] + d0));
+    field[f + 1] = Math.min(1, Math.max(0, field[f + 1] + d1));
+    field[f + 2] = Math.min(1, Math.max(0, field[f + 2] + d2));
+  }
+}
+
+// src/paint-editor/stamp-tip.ts
+var samplers = /* @__PURE__ */ new WeakMap();
+function stampSampler(ref, art, hardness = 1) {
+  const sampler = baseSampler(ref, art);
+  if (!sampler || hardness >= 1 || !_chunkEU2ZZA6Lcjs.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;
+    if (r <= h) return sampler(u, v2, seed);
+    const t = Math.min(1, (r - h) / (1 - h));
+    return sampler(u, v2, seed) * (1 - t * t * (3 - 2 * t));
+  };
+}
+function baseSampler(ref, art) {
+  let kind = null;
+  try {
+    kind = _chunkRDFHWAHLcjs.editorStampOf.call(void 0, ref.includes(":") ? ref : `editor:${ref}`);
+  } catch (e5) {
+    return null;
+  }
+  if (kind) {
+    const k = kind;
+    return (u, v2, seed) => _chunkRDFHWAHLcjs.stampCoverage.call(void 0, k, u, v2, seed);
+  }
+  const a = _optionalChain([art, 'optionalCall', _55 => _55(ref)]);
+  if (!a || !(a.width > 0 && a.height > 0)) return null;
+  const hit = samplers.get(a);
+  if (hit) return hit;
+  const { width: w, height: h, data } = a;
+  const scale3 = Math.max(w, h) / 2;
+  const alpha = (x, y) => x < 0 || y < 0 || x >= w || y >= h ? 0 : data[(y * w + x) * 4 + 3] / 255;
+  const sampler = (u, v2) => {
+    const x = u * scale3 + w / 2 - 0.5;
+    const y = v2 * scale3 + h / 2 - 0.5;
+    const x0 = Math.floor(x);
+    const y0 = Math.floor(y);
+    const fx = x - x0;
+    const fy = y - y0;
+    return (alpha(x0, y0) * (1 - fx) + alpha(x0 + 1, y0) * fx) * (1 - fy) + (alpha(x0, y0 + 1) * (1 - fx) + alpha(x0 + 1, y0 + 1) * fx) * fy;
+  };
+  samplers.set(a, sampler);
+  return sampler;
+}
+function stampDabRect(d) {
+  const r = Math.max(0.5, d.radius) * Math.SQRT2 + 1.5;
+  const x0 = Math.floor(d.x - r);
+  const y0 = Math.floor(d.y - r);
+  return { x: x0, y: y0, width: Math.ceil(d.x + r) - x0, height: Math.ceil(d.y + r) - y0 };
+}
+function rasterizeStampDab(d, sample, seed, rect, out) {
+  const w = rect.width;
+  const h = rect.height;
+  out.fill(0, 0, w * h);
+  const r = Math.max(0.5, d.radius);
+  const ro = Math.min(1, Math.max(0.05, d.roundness));
+  const sn = Math.sin(d.angle);
+  const cs = Math.cos(d.angle);
+  const ss = r < 6 ? 3 : 1;
+  const fu = d.flip && d.flip & 1 ? -1 : 1;
+  const fv = d.flip && d.flip & 2 ? -1 : 1;
+  for (let yy = 0; yy < h; yy++) {
+    for (let xx = 0; xx < w; xx++) {
+      let sum = 0;
+      for (let sy = 0; sy < ss; sy++) {
+        for (let sx = 0; sx < ss; sx++) {
+          const dx = rect.x + xx + (sx + 0.5) / ss - d.x;
+          const dy = rect.y + yy + (sy + 0.5) / ss - d.y;
+          const u = (dx * cs - dy * sn) / r * fu;
+          const v2 = (dx * sn + dy * cs) / (r * ro) * fv;
+          if (u > -1.05 && u < 1.05 && v2 > -1.05 && v2 < 1.05) sum += sample(u, v2, seed);
+        }
+      }
+      const val = sum / (ss * ss);
+      if (val > 0) out[yy * w + xx] = Math.min(1, val) * d.alpha;
+    }
+  }
+}
+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:") && !_chunkEU2ZZA6Lcjs.isBrushSourceRef.call(void 0, r)))];
+}
+function sprayDroplets(d, spray, seed) {
+  const count = 1 + Math.round(spray.density * 31);
+  const key = d.index * 131 + Math.round(d.travel * 8);
+  const out = [];
+  for (let i = 0; i < count; i++) {
+    const n = key * 64 + i;
+    const a = _chunk3K6HWEXZcjs.rand01.call(void 0, seed, n, 61) * Math.PI * 2;
+    const rr = Math.sqrt(_chunk3K6HWEXZcjs.rand01.call(void 0, seed, n, 67)) * d.radius;
+    out.push({ ...d, x: d.x + Math.cos(a) * rr, y: d.y + Math.sin(a) * rr, radius: Math.max(0.5, d.radius * spray.size * (0.6 + 0.8 * _chunk3K6HWEXZcjs.rand01.call(void 0, seed, n, 71))), roundness: 1, angle: _chunk3K6HWEXZcjs.rand01.call(void 0, seed, n, 73) * Math.PI * 2 });
+  }
+  return out;
+}
+
+// src/paint-editor/paper.ts
+var PAPER_FAMILIES = ["watercolor", "drawing", "pastel", "canvas", "panel", "smooth"];
+var unit2 = (v2, d) => typeof v2 === "number" && Number.isFinite(v2) ? Math.min(1, Math.max(0, v2)) : d;
+var clampNum = (v2, lo, hi, d) => typeof v2 === "number" && Number.isFinite(v2) ? Math.min(hi, Math.max(lo, v2)) : d;
+var HEX = /^#[0-9a-f]{6}$/i;
+var tuning = (contrast = 1, invert2 = false) => ({ contrast, invert: invert2 });
+function preset(id, name, family, pattern, color2, o) {
+  return {
+    preset: id,
+    name,
+    family,
+    pattern,
+    seed: _nullishCoalesce(o.seed, () => ( 1)),
+    color: color2,
+    scale: _nullishCoalesce(o.scale, () => ( 1)),
+    tiling: "mirror",
+    depth: o.depth,
+    shading: _nullishCoalesce(o.shading, () => ( 0.5)),
+    dry: tuning(_nullishCoalesce(o.contrast, () => ( 1))),
+    wet: tuning(1),
+    absorption: o.absorption,
+    permeability: o.permeability,
+    roughness: o.roughness,
+    ...o.backlight ? { backlight: o.backlight, backlightColor: _nullishCoalesce(o.backlightColor, () => ( "#fff1d6")) } : {}
+  };
+}
+var PAPER_LIBRARY = [
+  preset("cold-pressed", "Cold pressed watercolour", "watercolor", "cold-pressed", "#f7f3ea", { depth: 0.5, absorption: 0.7, permeability: 0.5, roughness: 0.6 }),
+  preset("hot-pressed", "Hot pressed watercolour", "watercolor", "hot-pressed", "#f8f6ef", { depth: 0.25, absorption: 0.55, permeability: 0.4, roughness: 0.25 }),
+  preset("rough-watercolor", "Rough watercolour", "watercolor", "rough", "#f5f0e4", { depth: 0.75, absorption: 0.8, permeability: 0.6, roughness: 0.85 }),
+  preset("cartridge", "Cartridge", "drawing", "vellum", "#fbfaf6", { depth: 0.3, absorption: 0.4, permeability: 0.3, roughness: 0.35 }),
+  preset("laid", "Laid paper", "drawing", "laid", "#f3ecdc", { depth: 0.45, absorption: 0.45, permeability: 0.35, roughness: 0.45 }),
+  preset("ingres", "Charcoal paper", "drawing", "ingres", "#ede6d6", { depth: 0.6, absorption: 0.4, permeability: 0.3, roughness: 0.65 }),
+  preset("sanded-pastel", "Sanded pastel paper", "pastel", "sanded", "#d8cfc0", { depth: 0.7, absorption: 0.3, permeability: 0.2, roughness: 0.9, shading: 0.35 }),
+  preset("pastel-card", "Grey pastel card", "pastel", "sanded", "#9c978e", { depth: 0.55, absorption: 0.3, permeability: 0.2, roughness: 0.75, scale: 1.5, shading: 0.3 }),
+  preset("cotton-canvas", "Cotton canvas", "canvas", "canvas", "#efe9dc", { depth: 0.55, absorption: 0.35, permeability: 0.25, roughness: 0.6 }),
+  preset("fine-linen", "Fine linen", "canvas", "linen", "#e9e2d2", { depth: 0.45, absorption: 0.3, permeability: 0.25, roughness: 0.5 }),
+  preset("gesso", "Gesso panel", "panel", "gesso", "#f6f4ef", { depth: 0.35, absorption: 0.2, permeability: 0.15, roughness: 0.4 }),
+  preset("smooth", "Smooth bristol", "smooth", "smooth", "#ffffff", { depth: 0, absorption: 0.3, permeability: 0.2, roughness: 0.05, shading: 0 }),
+  // Backlit: smooth paper on a lightbox, for glazes that glow like stained glass.
+  preset("stained-glass", "Stained glass (backlit)", "smooth", "smooth", "#ffffff", { depth: 0, absorption: 0.35, permeability: 0.25, roughness: 0.05, shading: 0, backlight: 0.8, backlightColor: "#fff1d6" })
+];
+var DEFAULT_PAPER = PAPER_LIBRARY[0];
+function paperPreset(id) {
+  const p = PAPER_LIBRARY.find((x) => x.preset === id);
+  return p ? clonePaper(p) : void 0;
+}
+function clonePaper(p) {
+  return { ...p, dry: { ...p.dry }, wet: { ...p.wet }, ...p.offset ? { offset: { ...p.offset } } : {} };
+}
+function readOffset(raw, d) {
+  const o = raw && typeof raw === "object" ? raw : null;
+  const x = o && typeof o.x === "number" && Number.isFinite(o.x) ? Math.round(o.x) : _nullishCoalesce(_optionalChain([d, 'optionalAccess', _56 => _56.x]), () => ( 0));
+  const y = o && typeof o.y === "number" && Number.isFinite(o.y) ? Math.round(o.y) : _nullishCoalesce(_optionalChain([d, 'optionalAccess', _57 => _57.y]), () => ( 0));
+  return x || y ? { offset: { x, y } } : {};
+}
+function readTuning(raw, d) {
+  const r = raw && typeof raw === "object" ? raw : {};
+  return { contrast: clampNum(r.contrast, 0, 3, d.contrast), invert: typeof r.invert === "boolean" ? r.invert : d.invert };
+}
+function normalizePaper(raw = {}, base) {
+  const r = raw;
+  const b = _nullishCoalesce(_nullishCoalesce(base, () => ( (typeof r.preset === "string" ? paperPreset(r.preset) : void 0))), () => ( clonePaper(DEFAULT_PAPER)));
+  return {
+    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,
+    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),
+    tiling: r.tiling === "repeat" || r.tiling === "mirror" ? r.tiling : b.tiling,
+    depth: unit2(r.depth, b.depth),
+    shading: unit2(r.shading, b.shading),
+    dry: readTuning(r.dry, b.dry),
+    wet: readTuning(r.wet, b.wet),
+    absorption: unit2(r.absorption, b.absorption),
+    permeability: unit2(r.permeability, b.permeability),
+    roughness: unit2(r.roughness, b.roughness),
+    ...unit2(r.metallic, _nullishCoalesce(b.metallic, () => ( 0))) > 0 ? { metallic: unit2(r.metallic, _nullishCoalesce(b.metallic, () => ( 0))) } : {},
+    ...unit2(r.backlight, _nullishCoalesce(b.backlight, () => ( 0))) > 0 ? { backlight: unit2(r.backlight, _nullishCoalesce(b.backlight, () => ( 0))) } : {},
+    ...typeof r.backlightColor === "string" && HEX.test(r.backlightColor) ? { backlightColor: r.backlightColor.toLowerCase() } : b.backlightColor ? { backlightColor: b.backlightColor } : {},
+    ...readOffset(r.offset, b.offset)
+  };
+}
+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) {
+  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;
+  const metal = light ? _nullishCoalesce(paper.metallic, () => ( 0)) : 0;
+  let hx = 0;
+  let hy = 0;
+  let hz = 1;
+  if (metal > 0 && light) {
+    const az = light.azimuth * Math.PI / 180;
+    const el = light.elevation * Math.PI / 180;
+    const lx = Math.cos(el) * Math.sin(az);
+    const ly = -Math.cos(el) * Math.cos(az);
+    const lz = Math.sin(el) + 1;
+    const n = Math.hypot(lx, ly, lz);
+    hx = lx / n;
+    hy = ly / n;
+    hz = lz / n;
+  }
+  for (let y = 0; y < rect.height; y++) {
+    for (let x = 0; x < rect.width; x++) {
+      const i = (y * rect.width + x) * 4;
+      const px = rect.x + x + 0.5;
+      const py = rect.y + y + 0.5;
+      const k = shade ? 1 - shade * (1 - grain.at(px, py)) : 1;
+      let spec = 0;
+      if (metal > 0) {
+        const gx = (grain.at(px + 1, py) - grain.at(px - 1, py)) * 4;
+        const gy = (grain.at(px, py + 1) - grain.at(px, py - 1)) * 4;
+        const nl = Math.hypot(gx, gy, 1);
+        const nh = Math.max(0, (-gx * hx - gy * hy + hz) / nl);
+        spec = metal * Math.pow(nh, 24) * 0.9;
+      }
+      out[i] = Math.min(255, r * k * (1 - 0.25 * metal) + spec * (r * 0.6 + 102));
+      out[i + 1] = Math.min(255, g * k * (1 - 0.25 * metal) + spec * (g * 0.6 + 102));
+      out[i + 2] = Math.min(255, b * k * (1 - 0.25 * metal) + spec * (b * 0.6 + 102));
+      out[i + 3] = 255;
+    }
+  }
+  return out;
+}
+
+// src/paint-editor/tip-grain.ts
+var ImageGrain = class {
+  constructor(w, h, alpha, contrast, invert2, scale3) {
+    this.w = w;
+    this.h = h;
+    this.scale = scale3;
+    this.heights = new Float32Array(w * h);
+    for (let i = 0; i < w * h; i++) {
+      const v2 = Math.min(1, Math.max(0, (alpha[i * 4 + 3] / 255 - 0.5) * contrast + 0.5));
+      this.heights[i] = invert2 ? 1 - v2 : v2;
+    }
+  }
+  
+  
+  
+  
+  at(x, y) {
+    const { w, h } = this;
+    const u = x / this.scale - 0.5;
+    const v2 = y / this.scale - 0.5;
+    const x0 = Math.floor(u);
+    const y0 = Math.floor(v2);
+    const fx = u - x0;
+    const fy = v2 - y0;
+    const xa = (x0 % w + w) % w;
+    const ya = (y0 % h + h) % h;
+    const xb = (xa + 1) % w;
+    const yb = (ya + 1) % h;
+    const hs = this.heights;
+    return (hs[ya * w + xa] * (1 - fx) + hs[ya * w + xb] * fx) * (1 - fy) + (hs[yb * w + xa] * (1 - fx) + hs[yb * w + xb] * fx) * fy;
+  }
+};
+var TipGrain = class _TipGrain {
+  constructor(field, settings) {
+    this.field = field;
+    this.settings = settings;
+  }
+  
+  
+  /**
+   * The grain for `settings`, or `null` when there is none to apply: no depth, or an image source
+   * whose art is not loaded (the dabs then paint without it).
+   */
+  static create(settings, art) {
+    if (!settings || settings.depth <= 0) return null;
+    if (_chunkNIBFKXMDcjs.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 });
+      return new _TipGrain(paper, settings);
+    }
+    const a = _optionalChain([art, 'optionalCall', _58 => _58(settings.source)]);
+    if (!a || !(a.width > 0 && a.height > 0)) return null;
+    return new _TipGrain(new ImageGrain(a.width, a.height, a.data, settings.contrast, settings.invert, settings.scale), settings);
+  }
+  /** Multiplies the dab's coverage `vals` (over `rect`) by the grain. */
+  apply(vals, rect, d) {
+    const depth = this.settings.depth;
+    const moving = this.settings.mode === "moving";
+    const cs = Math.cos(d.angle);
+    const sn = Math.sin(d.angle);
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const py = rect.y + yy + 0.5;
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        if (!(vals[k] > 0)) continue;
+        const px = rect.x + xx + 0.5;
+        let gx = px;
+        let gy = py;
+        if (moving) {
+          const dx = px - d.x;
+          const dy = py - d.y;
+          gx = dx * cs - dy * sn + d.travel;
+          gy = dx * sn + dy * cs;
+        }
+        vals[k] *= 1 - depth * (1 - this.field.at(gx, gy));
+      }
+    }
+  }
+};
+
+// src/paint-editor/engine.ts
+function penOrientation(p) {
+  if (typeof p.altitude === "number" && Number.isFinite(p.altitude)) {
+    const altitude = Math.min(Math.PI / 2, Math.max(0, p.altitude));
+    const azimuth = typeof p.azimuth === "number" && Number.isFinite(p.azimuth) ? p.azimuth : 0;
+    return { altitude, azimuth };
+  }
+  const hasX = typeof p.tiltX === "number" && Number.isFinite(p.tiltX);
+  const hasY = typeof p.tiltY === "number" && Number.isFinite(p.tiltY);
+  if (!hasX && !hasY) return null;
+  return tiltToOrientation(hasX ? p.tiltX : 0, hasY ? p.tiltY : 0);
+}
+function tiltToOrientation(tiltX, tiltY) {
+  const clampT = (v2) => Math.min(89.999, Math.max(-89.999, v2));
+  const tx = Math.tan(clampT(tiltX) * Math.PI / 180);
+  const ty = Math.tan(clampT(tiltY) * Math.PI / 180);
+  const r = Math.hypot(tx, ty);
+  if (r < 1e-9) return { altitude: Math.PI / 2, azimuth: 0 };
+  let azimuth = Math.atan2(ty, tx);
+  if (azimuth < 0) azimuth += 2 * Math.PI;
+  return { altitude: Math.atan(1 / r), azimuth };
+}
+var pressureOf = (p) => typeof p.pressure === "number" && Number.isFinite(p.pressure) ? Math.min(1, Math.max(0, p.pressure)) : 1;
+var PenSmoother = (_class = class {
+  __init() {this.pos = null}
+  __init2() {this.pressure = null}
+  
+  
+  constructor(position, pressure) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.a = 1 - Math.min(0.95, Math.max(0, position));
+    this.ap = 1 - Math.min(0.95, Math.max(0, pressure));
+  }
+  push(p) {
+    const pr = pressureOf(p);
+    if (!this.pos) {
+      this.pos = { x: p.x, y: p.y };
+      this.pressure = pr;
+      return p;
+    }
+    this.pos = { x: this.pos.x + (p.x - this.pos.x) * this.a, y: this.pos.y + (p.y - this.pos.y) * this.a };
+    this.pressure = this.pressure + (pr - this.pressure) * this.ap;
+    return { ...p, x: this.pos.x, y: this.pos.y, pressure: this.pressure };
+  }
+  /** Where the smoothed position is now (or `null` before the first sample). */
+  get position() {
+    return this.pos;
+  }
+}, _class);
+var IDENTITY_COPY = { map: (p) => p, linear: [1, 0, 0, 1] };
+var FULL_SPEED = 2.5;
+var PenDabWalker = (_class2 = class {
+  constructor(brush, seed = 0, linear = [1, 0, 0, 1]) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);
+    this.brush = brush;
+    this.seed = seed;
+    this.linear = linear;
+  }
+  
+  
+  
+  __init3() {this.last = null}
+  __init4() {this.nextAt = 0}
+  __init5() {this.pendingFirst = null}
+  __init6() {this.index = 0}
+  __init7() {this.dir = 0}
+  __init8() {this.lastT = null}
+  __init9() {this.firstT = null}
+  __init10() {this.speed = null}
+  __init11() {this.travelled = 0}
+  sample(p) {
+    const o = penOrientation(p);
+    let speed = null;
+    let time = null;
+    if (this.last) this.travelled += Math.hypot(p.x - this.last.x, p.y - this.last.y);
+    if (typeof p.t === "number" && Number.isFinite(p.t)) {
+      if (this.firstT === null) this.firstT = p.t;
+      time = p.t - this.firstT;
+      if (this.last && this.lastT !== null && p.t > this.lastT) {
+        const v2 = Math.hypot(p.x - this.last.x, p.y - this.last.y) / (p.t - this.lastT);
+        this.speed = this.speed === null ? v2 : this.speed + (v2 - this.speed) * 0.35;
+      }
+      this.lastT = p.t;
+      speed = _nullishCoalesce(this.speed, () => ( 0));
+    }
+    return {
+      x: p.x,
+      y: p.y,
+      pressure: pressureOf(p),
+      lean: o ? 1 - o.altitude / (Math.PI / 2) : 0,
+      azimuth: o ? o.azimuth : 0,
+      twist: typeof p.twist === "number" && Number.isFinite(p.twist) ? p.twist : null,
+      speed,
+      travel: this.travelled,
+      time
+    };
+  }
+  diameter(s) {
+    const tip = this.brush.tip;
+    const dyn = this.brush.dynamics;
+    let d = tip.size;
+    if (tip.pressureSize) d *= dyn.minSize + (1 - dyn.minSize) * s.pressure;
+    d *= 1 + dyn.tiltSize * s.lean * 1.5;
+    if (s.speed !== null && dyn.velocitySize) d *= Math.max(0.05, 1 + dyn.velocitySize * Math.min(1, s.speed / FULL_SPEED) * (dyn.velocitySize < 0 ? 0.85 : 1));
+    return d;
+  }
+  stepLen(s) {
+    return Math.max(0.5, Math.max(1, this.diameter(s)) * Math.max(0.01, this.brush.tip.spacing));
+  }
+  /** A rasterizer angle (CCW, y up) mapped through this copy's linear part. */
+  mapAngle(theta) {
+    const [a, b, c, d] = this.linear;
+    if (a === 1 && b === 0 && c === 0 && d === 1) return theta;
+    const vx = Math.cos(theta);
+    const vy = -Math.sin(theta);
+    return Math.atan2(-(c * vx + d * vy), a * vx + b * vy);
+  }
+  dab(s) {
+    const { tip, dynamics: dyn, rotation } = this.brush;
+    const i = this.index++;
+    const seed = this.seed;
+    let diameter = this.diameter(s);
+    if (dyn.sizeJitter) diameter *= Math.max(0.05, 1 + dyn.sizeJitter * _chunk3K6HWEXZcjs.randSigned.call(void 0, seed, i, 1 /* Size */));
+    const base = tip.angle * Math.PI / 180;
+    let angle;
+    if (rotation === "stroke") angle = this.dir + base;
+    else if (rotation === "barrel" && s.twist !== null) angle = this.mapAngle(base - s.twist * Math.PI / 180);
+    else if (dyn.tiltRoundness > 0 && s.lean > 0.02) angle = this.mapAngle(base - s.azimuth);
+    else angle = this.mapAngle(base);
+    if (dyn.angleJitter) angle += dyn.angleJitter * Math.PI * _chunk3K6HWEXZcjs.randSigned.call(void 0, seed, i, 2 /* Angle */);
+    let opacity = tip.pressureOpacity ? s.pressure : 1;
+    opacity *= 1 - dyn.tiltOpacity * s.lean * 0.8;
+    if (s.speed !== null && dyn.velocityOpacity) opacity *= Math.max(0, 1 + dyn.velocityOpacity * (Math.min(1, s.speed / FULL_SPEED) - 0.5));
+    if (dyn.opacityJitter) opacity *= 1 - dyn.opacityJitter * (_chunk3K6HWEXZcjs.randSigned.call(void 0, seed, i, 3 /* Opacity */) * 0.5 + 0.5);
+    const flow = tip.flow * (1 - dyn.pressureFlow + dyn.pressureFlow * s.pressure);
+    let { x, y } = s;
+    if (dyn.scatter) {
+      const off = dyn.scatter * diameter * _chunk3K6HWEXZcjs.randSigned.call(void 0, seed, i, 4 /* Scatter */);
+      x += Math.sin(this.dir) * off;
+      y += Math.cos(this.dir) * off;
+    }
+    let flip = 0;
+    if (dyn.flip && dyn.flip !== "none") {
+      if (dyn.flip !== "y" && _chunk3K6HWEXZcjs.rand01.call(void 0, seed, i, 5 /* FlipX */) < 0.5) flip |= 1;
+      if (dyn.flip !== "x" && _chunk3K6HWEXZcjs.rand01.call(void 0, seed, i, 6 /* FlipY */) < 0.5) flip |= 2;
+    }
+    return {
+      ...flip ? { flip } : {},
+      x,
+      y,
+      radius: Math.max(0.5, diameter / 2),
+      alpha: Math.min(1, Math.max(0, flow)),
+      opacity: Math.min(1, Math.max(0, opacity)),
+      angle,
+      roundness: Math.min(1, Math.max(0.01, tip.roundness * (1 - dyn.tiltRoundness * s.lean * 0.8))),
+      pressure: s.pressure,
+      direction: this.dir,
+      index: i,
+      travel: s.travel,
+      time: s.time,
+      lean: s.lean,
+      speed: s.speed
+    };
+  }
+  push(p, out) {
+    const a = this.last;
+    const s = this.sample(p);
+    if (!a) {
+      this.last = s;
+      this.pendingFirst = s;
+      this.nextAt = this.stepLen(s);
+      return;
+    }
+    const dx = s.x - a.x;
+    const dy = s.y - a.y;
+    const len2 = Math.hypot(dx, dy);
+    if (len2 > 1e-9) this.dir = Math.atan2(-dy, dx);
+    if (this.pendingFirst) {
+      this.lay(this.pendingFirst, out);
+      this.pendingFirst = null;
+    }
+    if (len2 > 1e-9) {
+      while (this.nextAt <= len2 + 1e-9) {
+        const f = Math.min(1, this.nextAt / len2);
+        const lerp4 = (u, v2) => u + (v2 - u) * f;
+        const q = {
+          x: a.x + dx * f,
+          y: a.y + dy * f,
+          pressure: lerp4(a.pressure, s.pressure),
+          lean: lerp4(a.lean, s.lean),
+          azimuth: lerpAngle(a.azimuth, s.azimuth, f),
+          twist: a.twist !== null && s.twist !== null ? lerpDegrees(a.twist, s.twist, f) : s.twist,
+          speed: a.speed !== null && s.speed !== null ? lerp4(a.speed, s.speed) : s.speed,
+          travel: a.travel + this.nextAt,
+          time: a.time !== null && s.time !== null ? lerp4(a.time, s.time) : s.time
+        };
+        this.lay(q, out);
+        this.nextAt += this.stepLen(q);
+      }
+      this.nextAt -= len2;
+    }
+    this.last = s;
+  }
+  finish(out) {
+    if (this.pendingFirst) {
+      this.lay(this.pendingFirst, out);
+      this.pendingFirst = null;
+    }
+  }
+  /** The dabs of one spacing step: `dynamics.count` of them, each with its own index and so its own jitter. */
+  lay(s, out) {
+    const n = _nullishCoalesce(this.brush.dynamics.count, () => ( 1));
+    for (let k = 0; k < n; k++) out.push(this.dab(s));
+  }
+}, _class2);
+function lerpAngle(a, b, t) {
+  let d = b - a;
+  while (d > Math.PI) d -= 2 * Math.PI;
+  while (d < -Math.PI) d += 2 * Math.PI;
+  return a + d * t;
+}
+function lerpDegrees(a, b, t) {
+  let d = b - a;
+  while (d > 180) d -= 360;
+  while (d < -180) d += 360;
+  return a + d * t;
+}
+var DryStroke = (_class3 = class {
+  constructor(brush, options) {;_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);
+    this.brush = brush;
+    this.options = options;
+    this.stamp = brush.stamp ? stampSampler(brush.stamp, options.stampArt, brush.tip.hardness) : null;
+    this.tipGrain = TipGrain.create(brush.tipGrain, options.stampArt);
+    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+    this.copies = _optionalChain([options, 'access', _59 => _59.copies, 'optionalAccess', _60 => _60.length]) ? options.copies : [IDENTITY_COPY];
+    this.walkers = this.copies.map((c, i) => new PenDabWalker(brush, (_nullishCoalesce(options.seed, () => ( 0))) + i * 7919 | 0, c.linear));
+    this.depth = options.grain && !options.grain.flat ? Math.min(1, Math.max(0, options.paperDepth * brush.grain)) : 0;
+  }
+  
+  
+  __init12() {this.coverage = new (0, _chunkNIBFKXMDcjs.CoverageMap)()}
+  __init13() {this.dabCount = 0}
+  
+  
+  
+  
+  __init14() {this.buf = new Float32Array(0)}
+  __init15() {this.field = new Float32Array(0)}
+  __init16() {this.lastRaw = null}
+  __init17() {this.lastFed = null}
+  /** The stamp tip's shape, or `null` for the round computed tip. */
+  
+  /** The tip's own grain, or `null`. */
+  
+  /** Feeds raw pen samples; returns the document rectangles the new dabs touched. */
+  push(points) {
+    const dabs = [];
+    for (const raw of points) {
+      this.lastRaw = raw;
+      const p = this.smoother.push(raw);
+      this.lastFed = p;
+      this.copies.forEach((c, i) => this.walkers[i].push(c.map(p), dabs));
+    }
+    return this.paint(dabs);
+  }
+  /** Ends the stroke: the smoothed path catches up with the last raw sample; a single tap paints one dab. */
+  finish() {
+    const dabs = [];
+    const raw = this.lastRaw;
+    const fed = this.lastFed;
+    if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.copies.forEach((c, i) => this.walkers[i].push(c.map({ ...raw, pressure: fed.pressure }), dabs));
+    for (const w of this.walkers) w.finish(dabs);
+    return this.paint(dabs);
+  }
+  paint(dabs) {
+    const rects = [];
+    const spray = this.brush.spray;
+    const seed = _nullishCoalesce(this.options.seed, () => ( 0));
+    for (const d of dabs) {
+      if (!spray) {
+        this.mark(d, d, rects);
+        continue;
+      }
+      for (const drop of sprayDroplets(d, spray, seed)) this.mark(drop, d, rects);
+    }
+    return rects;
+  }
+  /** Lays one mark (a dab, or a spray droplet of dab `d`): the round tip or the stamp, the tip grain, the paper grain, effect paint. */
+  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 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);
+    _optionalChain([this, 'access', _61 => _61.tipGrain, 'optionalAccess', _62 => _62.apply, 'call', _63 => _63(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);
+        }
+      }
+    }
+    let field = null;
+    if (this.options.effect) {
+      if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
+      field = this.field.subarray(0, n * 3);
+      sampleEffectField(this.options.effect, rect, vals, field, d);
+    }
+    this.coverage.accumulate(rect, vals, m.opacity, null, field);
+    rects.push(rect);
+    this.dabCount++;
+  }
+}, _class3);
+function mixerTip(brush) {
+  return { ...brush.tip, smoothing: 0, pressureSize: brush.tip.pressureSize };
+}
+function toStrokePoint(p) {
+  return { x: p.x, y: p.y, pressure: pressureOf(p), ...typeof p.t === "number" ? { t: p.t } : {} };
+}
+
+// src/paint-editor/dab-stroke.ts
+var GRADIENT_STEPS = 32;
+function multiColorPalette(mc, color2, secondary) {
+  if (mc.colors.length >= 2) {
+    return mc.colors.map((h) => {
+      const n = parseInt(h.slice(1), 16);
+      return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+    });
+  }
+  return [[...color2], [...secondary]];
+}
+function soften(f, softness) {
+  if (softness >= 1) return f;
+  const w = Math.max(1e-3, softness);
+  return Math.min(1, Math.max(0, (f - 0.5) / w + 0.5));
+}
+function mixRgb(a, b, t, mixing) {
+  if (t <= 0) return [...a];
+  if (t >= 1) return [...b];
+  if (mixing === "pigment") {
+    const o = [0, 0, 0];
+    const q = (v2) => Math.round(Math.min(1, Math.max(0, v2)) * 255);
+    _chunk2VX55NFMcjs.mixPigment8.call(void 0, q(a[0]), q(a[1]), q(a[2]), q(b[0]), q(b[1]), q(b[2]), t, o);
+    return [o[0], o[1], o[2]];
+  }
+  return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
+}
+function multiColorGradient(palette, softness, mixing) {
+  const n = palette.length;
+  const out = [];
+  for (let j = 0; j < GRADIENT_STEPS; j++) {
+    const f = j / (GRADIENT_STEPS - 1) * (n - 1);
+    const i = Math.min(n - 2, Math.floor(f));
+    out.push(mixRgb(palette[i], palette[i + 1], soften(f - i, softness), mixing));
+  }
+  return out;
+}
+function multiColorForDab(mc, palette, index, seed, mixing) {
+  const n = palette.length;
+  if (mc.order === "random") {
+    const run = Math.floor(index / mc.length);
+    return [...palette[Math.min(n - 1, Math.floor(_chunk3K6HWEXZcjs.rand01.call(void 0, seed, run, 11) * n))]];
+  }
+  const f = index / mc.length % n;
+  const i = Math.floor(f);
+  return mixRgb(palette[i], palette[(i + 1) % n], soften(f - i, mc.softness), mixing);
+}
+var PaintDabStroke = (_class4 = class {
+  constructor(brush, options) {;_class4.prototype.__init18.call(this);_class4.prototype.__init19.call(this);_class4.prototype.__init20.call(this);_class4.prototype.__init21.call(this);_class4.prototype.__init22.call(this);_class4.prototype.__init23.call(this);_class4.prototype.__init24.call(this);_class4.prototype.__init25.call(this);_class4.prototype.__init26.call(this);_class4.prototype.__init27.call(this);
+    this.brush = brush;
+    this.options = options;
+    this.stamp = brush.engine === "dab" && brush.stamp ? stampSampler(brush.stamp, options.stampArt, brush.tip.hardness) : null;
+    this.tipGrain = TipGrain.create(brush.tipGrain, options.stampArt);
+    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+    this.copies = _optionalChain([options, 'access', _64 => _64.copies, 'optionalAccess', _65 => _65.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);
+    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
+    }));
+    this.medium = new (0, _chunkNIBFKXMDcjs.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;
+    const table = _optionalChain([this, 'access', _66 => _66.sampler, 'optionalAccess', _67 => _67.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;
+  }
+  
+  
+  __init18() {this.dabCount = 0}
+  
+  
+  
+  
+  
+  
+  
+  __init19() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
+  
+  /** Opacity across the tip (`across-tip` gradients with opacity stops), or `null`. */
+  
+  __init20() {this.alphaCov = new Float32Array(0)}
+  __init21() {this.fieldLut = []}
+  
+  
+  __init22() {this.tip = new Float32Array(0)}
+  __init23() {this.cov = new Float32Array(0)}
+  __init24() {this.field = new Float32Array(0)}
+  __init25() {this.paint = [0, 0, 0]}
+  __init26() {this.lastRaw = null}
+  __init27() {this.lastFed = null}
+  /** The stamp tip's shape (dab brushes), or `null` for the round computed tip. */
+  
+  /** The tip's own grain, or `null`. */
+  
+  /** What copy 0's brush carries after the dabs so far (mixer and wet-capable dab brushes). */
+  get load() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _68 => _68.states, 'access', _69 => _69[0], 'access', _70 => _70.exchange, 'optionalAccess', _71 => _71.load]), () => ( null));
+  }
+  push(points) {
+    const rects = [];
+    for (const raw of points) {
+      this.lastRaw = raw;
+      const p = this.smoother.push(raw);
+      this.lastFed = p;
+      this.copies.forEach((c, i) => {
+        const dabs = [];
+        this.states[i].walker.push(c.map(p), dabs);
+        this.paintDabs(i, dabs, rects);
+      });
+    }
+    return rects;
+  }
+  /** Ends the stroke: the smoothed path catches up with the last raw sample; a tap paints one dab. */
+  finish() {
+    const rects = [];
+    const raw = this.lastRaw;
+    const fed = this.lastFed;
+    this.copies.forEach((c, i) => {
+      const dabs = [];
+      if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.states[i].walker.push(c.map({ ...raw, pressure: fed.pressure }), dabs);
+      this.states[i].walker.finish(dabs);
+      this.paintDabs(i, dabs, rects);
+    });
+    return rects;
+  }
+  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);
+      if (rect.width <= 0 || rect.height <= 0) continue;
+      this.dab(copy, d, rect);
+      rects.push(rect);
+      this.dabCount++;
+    }
+  }
+  /** The tip's pure coverage (`tip`) and, with grain, what the paper catches of it (`cov`). */
+  rasterize(d, rect) {
+    const n = rect.width * rect.height;
+    if (this.tip.length < n) {
+      this.tip = new Float32Array(n);
+      this.cov = new Float32Array(n);
+    }
+    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);
+    _optionalChain([this, 'access', _72 => _72.tipGrain, 'optionalAccess', _73 => _73.apply, 'call', _74 => _74(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;
+    }
+    return { tip, cov };
+  }
+  dab(copy, d, rect) {
+    const brush = this.brush;
+    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);
+      return;
+    }
+    if (brush.engine === "smudge") {
+      st.smudge.dab(this.medium, { x: d.x, y: d.y, radius: d.radius, opacity: d.opacity * d.alpha * brush.tip.opacity }, rect, cov);
+      return;
+    }
+    const ex = st.exchange;
+    ex.pickUp(this.medium.sample(rect, tip));
+    let flow = 1;
+    if (this.options.effect) {
+      const rgb = [0, 0, 0];
+      flow = sampleEffectAt(this.options.effect, d.x, d.y, rgb, d);
+      ex.setReservoirColor(rgb[0], rgb[1], rgb[2]);
+    } else if (this.sampler && !this.gradient) {
+      const g = this.sampler.dab(d, this.sample);
+      ex.setReservoirColor(g.rgb[0], g.rgb[1], g.rgb[2]);
+      flow = g.alpha;
+    }
+    let field = null;
+    let total;
+    let laid = cov;
+    if (this.gradient) {
+      total = this.tipField(ex, d, rect);
+      field = this.field;
+      if (this.gradientAlpha) laid = this.tipAlpha(d, rect, cov);
+    } else total = ex.paint(this.paint);
+    if (total > 0 && flow > 0) {
+      if (this.coverage) this.depositWithCeiling(d, rect, laid, field, ex, flow);
+      else {
+        const dep = Math.min(1, total) * d.alpha * brush.tip.opacity * d.opacity * flow;
+        if (dep > 0) this.medium.deposit(rect, laid, dep, this.paint, ex.paintPigment, field);
+      }
+    }
+    ex.drain();
+  }
+  /** Fills `this.field` with the tip gradient (mixed with the carried paint) per pixel; returns the paint weight. */
+  tipField(ex, d, rect) {
+    const g = this.gradient;
+    const lut = this.fieldLut;
+    let total = 0;
+    for (let j = 0; j < g.length; j++) {
+      ex.setReservoirColor(g[j][0], g[j][1], g[j][2]);
+      const out = _nullishCoalesce(lut[j], () => ( [0, 0, 0]));
+      total = ex.paint(out);
+      lut[j] = out;
+    }
+    const n = rect.width * rect.height;
+    if (this.field.length < n * 3) this.field = new Float32Array(n * 3);
+    const f = this.field;
+    const nx = Math.sin(d.direction);
+    const ny = Math.cos(d.direction);
+    const r = Math.max(0.5, d.radius);
+    const last = g.length - 1;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const py = rect.y + yy + 0.5 - d.y;
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        const u = ((rect.x + xx + 0.5 - d.x) * nx + py * ny) / r;
+        const j = Math.min(last, Math.max(0, Math.round((u + 1) / 2 * last)));
+        f[k * 3] = lut[j][0];
+        f[k * 3 + 1] = lut[j][1];
+        f[k * 3 + 2] = lut[j][2];
+      }
+    }
+    return total;
+  }
+  /** `cov` scaled by the gradient's opacity across the tip. */
+  tipAlpha(d, rect, cov) {
+    const a = this.gradientAlpha;
+    const n = rect.width * rect.height;
+    if (this.alphaCov.length < n) this.alphaCov = new Float32Array(n);
+    const out = this.alphaCov.subarray(0, n);
+    const nx = Math.sin(d.direction);
+    const ny = Math.cos(d.direction);
+    const r = Math.max(0.5, d.radius);
+    const last = a.length - 1;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      const py = rect.y + yy + 0.5 - d.y;
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        const u = ((rect.x + xx + 0.5 - d.x) * nx + py * ny) / r;
+        out[k] = cov[k] * a[Math.min(last, Math.max(0, Math.round((u + 1) / 2 * last)))];
+      }
+    }
+    return out;
+  }
+  /** A dab brush's deposit: only what this dab adds to the stroke's coverage, under its opacity ceiling. */
+  depositWithCeiling(d, rect, cov, field, ex, flow = 1) {
+    const map = this.coverage;
+    const n = rect.width * rect.height;
+    const before = new Float32Array(n);
+    const vals = new Float32Array(n);
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        if (cov[k] <= 0) continue;
+        before[k] = map.get(rect.x + xx, rect.y + yy);
+        vals[k] = cov[k] * d.alpha * flow;
+      }
+    }
+    map.accumulate(rect, vals, d.opacity);
+    const o = this.brush.tip.opacity;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        if (cov[k] <= 0) {
+          vals[k] = 0;
+          continue;
+        }
+        const c0 = before[k] * o;
+        const c1 = map.get(rect.x + xx, rect.y + yy) * o;
+        vals[k] = c1 > c0 && c0 < 1 ? (c1 - c0) / (1 - c0) : 0;
+      }
+    }
+    this.medium.deposit(rect, vals, 1, this.paint, ex.paintPigment, field);
+  }
+}, _class4);
+
+// src/paint-editor/wet.ts
+var STROKE_WATER = 0.9;
+var STROKE_MASS = _chunkJ5VQYK7Tcjs.PIGMENT_UNIT * 2.5;
+var STROKE_LIGHT = 1.5;
+var COVERAGE_STEPS = 4096;
+function union(a, b) {
+  if (!a) return { ...b };
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  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 flat = grain.flat;
+  return {
+    absorption: paper.absorption,
+    permeability: paper.permeability,
+    roughness: flat ? 0 : paper.roughness,
+    color: hexToRgb8(paper.color),
+    heightAt: flat ? () => 0.5 : (x, y) => grain.at(x, y)
+  };
+}
+var WetStrokeDriver = (_class5 = class {
+  constructor(init) {;_class5.prototype.__init28.call(this);_class5.prototype.__init29.call(this);_class5.prototype.__init30.call(this);_class5.prototype.__init31.call(this);_class5.prototype.__init32.call(this);_class5.prototype.__init33.call(this);_class5.prototype.__init34.call(this);_class5.prototype.__init35.call(this);_class5.prototype.__init36.call(this);_class5.prototype.__init37.call(this);_class5.prototype.__init38.call(this);_class5.prototype.__init39.call(this);_class5.prototype.__init40.call(this);
+    this.init = init;
+    const brush = init.brush;
+    this.smoother = new PenSmoother(brush.tip.smoothing, brush.pressureSmoothing);
+    const copies = init.copies.length ? init.copies : [IDENTITY_COPY];
+    const wet = brush.wet;
+    const spacing = Math.max(0.02, brush.tip.spacing);
+    const perDab = Math.min(1, spacing * 1.2);
+    const thin = wet.thinner;
+    this.medium = new (0, _chunkJ5VQYK7Tcjs.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: wet.body * (1 - thin),
+      light: 0
+    });
+    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);
+    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,
+      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;
+  }
+  
+  __init28() {this.dabCount = 0}
+  __init29() {this.bounds = null}
+  /** The world's clock at which each raw point was applied (recorded with the stroke). */
+  __init30() {this.steps = []}
+  
+  
+  
+  __init31() {this.queue = []}
+  __init32() {this.finishing = false}
+  __init33() {this.finished = false}
+  __init34() {this.lastRaw = null}
+  __init35() {this.lastFed = null}
+  __init36() {this.tip = new Float32Array(0)}
+  __init37() {this.cov = new Float32Array(0)}
+  __init38() {this.paint = [0, 0, 0]}
+  __init39() {this.centre = [0, 0, 0]}
+  
+  
+  
+  __init40() {this.sample = { rgb: [0, 0, 0], alpha: 1 }}
+  
+  /** What copy 0's brush carries after the dabs so far. */
+  get load() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _75 => _75.states, 'access', _76 => _76[0], 'access', _77 => _77.exchange, 'optionalAccess', _78 => _78.load]), () => ( null));
+  }
+  /** Whether every point (and the end) has been applied. */
+  get done() {
+    return this.finished;
+  }
+  /** Adds raw points; applies them now unless a batch is running. Returns where pixels changed. */
+  push(points) {
+    for (const p of points) this.queue.push(p);
+    return this.flush();
+  }
+  /** Asks for the end; it happens now unless a batch is running (then at the next `flush`). */
+  finish() {
+    this.finishing = true;
+    return this.flush();
+  }
+  /** Applies waiting points (and the end, when asked) if the world is between batches. */
+  flush() {
+    const rects = [];
+    if (this.init.world.busy || this.finished) return rects;
+    while (this.queue.length) {
+      const raw = this.queue.shift();
+      this.steps.push(this.init.world.clock);
+      this.lastRaw = raw;
+      const p = this.smoother.push(raw);
+      this.lastFed = p;
+      this.copies.forEach((c, i) => {
+        const dabs = [];
+        this.states[i].walker.push(c.map(p), dabs);
+        this.applyDabs(i, dabs, rects);
+      });
+    }
+    if (this.finishing) {
+      const raw = this.lastRaw;
+      const fed = this.lastFed;
+      this.copies.forEach((c, i) => {
+        const dabs = [];
+        if (raw && fed && (raw.x !== fed.x || raw.y !== fed.y)) this.states[i].walker.push(c.map({ ...raw, pressure: fed.pressure }), dabs);
+        this.states[i].walker.finish(dabs);
+        this.applyDabs(i, dabs, rects);
+      });
+      this.finished = true;
+    }
+    for (const r of rects) this.bounds = union(this.bounds, r);
+    return rects;
+  }
+  applyDabs(copy, dabs, rects) {
+    for (const d of dabs) {
+      const rect = _chunkNIBFKXMDcjs.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);
+      this.dabCount++;
+    }
+  }
+  /** The tip's coverage over `rect`, with the grain, quantised. */
+  coverage(d, rect) {
+    const n = rect.width * rect.height;
+    if (this.tip.length < n) {
+      this.tip = new Float32Array(n);
+      this.cov = new Float32Array(n);
+    }
+    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);
+    const grain = this.depth > 0 ? this.init.grain : null;
+    const mask = this.init.mask;
+    for (let yy = 0, k = 0; yy < rect.height; yy++) {
+      for (let xx = 0; xx < rect.width; xx++, k++) {
+        if (mask && tip[k] > 0) {
+          const mx = rect.x + xx;
+          const my = rect.y + yy;
+          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);
+        tip[k] = Math.round(tip[k] * COVERAGE_STEPS) / COVERAGE_STEPS;
+        cov[k] = Math.round(v2 * COVERAGE_STEPS) / COVERAGE_STEPS;
+      }
+    }
+    return { tip, cov };
+  }
+  dab(copy, d, rect) {
+    const { world, laneId, brush } = this.init;
+    const wet = brush.wet;
+    const st = this.states[copy];
+    const { tip, cov } = this.coverage(d, rect);
+    const k = Math.round(Math.min(1, d.alpha * d.opacity * brush.tip.opacity) * COVERAGE_STEPS) / COVERAGE_STEPS;
+    if (!(k > 0)) return;
+    switch (wet.tool) {
+      case "paint": {
+        const ex = st.exchange;
+        this.medium.options.light = this.lightBase * (brush.light.pressure ? d.pressure : 1);
+        let flow = 1;
+        const effect = this.init.effect;
+        if (effect) {
+          sampleEffectAt(effect, d.x, d.y, this.centre, d);
+          ex.setReservoirColor(this.centre[0], this.centre[1], this.centre[2]);
+        } else if (this.sampler) {
+          const g = this.sampler.dab(d, this.sample);
+          ex.setReservoirColor(g.rgb[0], g.rgb[1], g.rgb[2]);
+          flow = g.alpha;
+        }
+        ex.pickUp(this.medium.sample(rect, tip));
+        const total = ex.paint(this.paint);
+        if (total > 0 && flow > 0 && effect) {
+          const ec = cov.slice();
+          const field = new Float32Array(ec.length * 3);
+          effectDabField(effect, rect, ec, this.centre, this.paint, field, COVERAGE_STEPS, d);
+          this.medium.deposit(rect, ec, Math.min(1, total) * k, this.paint, null, field);
+        } else if (total > 0 && flow > 0) this.medium.deposit(rect, cov, Math.min(1, total) * k * flow, this.paint, null);
+        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);
+        break;
+      }
+      case "water": {
+        world.paint(laneId, rect, cov, this.medium.options.water * k * (wet.water > 0 ? 1 : 0), null);
+        if (wet.rewet > 0) world.rewet(laneId, rect, cov, wet.rewet * k * 0.15, this.init.paperColor);
+        break;
+      }
+      case "dry":
+        world.remove(laneId, rect, cov, wet.strength * 0.35 * k, 0, 0, wet.strength * 0.35 * k);
+        break;
+      case "blow": {
+        const s = wet.strength * 0.08 * k;
+        world.push(laneId, rect, cov, Math.cos(d.direction) * s, -Math.sin(d.direction) * s);
+        break;
+      }
+      case "blend":
+        world.blend(laneId, rect, cov, wet.strength * k);
+        break;
+      case "smudge": {
+        if (st.last) world.drag(laneId, rect, cov, d.x - st.last.x, d.y - st.last.y, wet.strength * k);
+        break;
+      }
+      case "blot":
+        world.remove(laneId, rect, cov, wet.strength * 0.8 * k, wet.strength * 0.6 * k, wet.strength * 0.15 * k, wet.strength * 0.5 * k);
+        break;
+    }
+    st.last = d;
+  }
+}, _class5);
+var WET_MEDIUM_PARAMS = {
+  watercolor: {},
+  gouache: { viscosity: 0.45, evaporation: 0.1, edgeDarkening: 0.15, granulation: 0.1, bloom: 0.1, bleed: 0.15, pickup: 0.5, pigmentWeight: 0.5 },
+  oil: { viscosity: 0.95, evaporation: 0.03, edgeDarkening: 0, granulation: 0, bloom: 0, bleed: 0.08, pickup: 0.6, fixture: 0.02, pigmentWeight: 0.8 }
+};
+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);
+    this.host = host;
+    this.options = options;
+    this.speed = Math.max(1, Math.min(2e3, _nullishCoalesce(options.speed, () => ( 120))));
+    this.undoMemory = Math.max(0, _nullishCoalesce(options.undoMemory, () => ( 512 * 1024 * 1024)));
+    this.gpuMode = options.gpu === "off" ? "off" : "auto";
+    this.gpuMinTiles = Math.max(1, Math.floor(_nullishCoalesce(options.gpuMinTiles, () => ( 16))));
+  }
+  
+  
+  __init41() {this.world = null}
+  __init42() {this.tilt = { ..._chunkJ5VQYK7Tcjs.FLAT }}
+  __init43() {this.settings = /* @__PURE__ */ new Map()}
+  __init44() {this.paused = false}
+  /** Wet strokes dry as soon as they end (one undo step with the stroke). */
+  __init45() {this.instantDry = false}
+  
+  __init46() {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}
+  
+  
+  __init53() {this.gpu = null}
+  __init54() {this.gpuSupport = null}
+  __init55() {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 ? _chunkJ5VQYK7Tcjs.findWebGpu.call(void 0, ) : this.options.gpuProvider;
+    this.gpuStarting = _chunkJ5VQYK7Tcjs.createWetGpuEngine.call(void 0, provider).then(({ engine, support }) => {
+      this.gpuSupport = support;
+      if (!engine) return;
+      if (this.gpuMode === "off" || !this.world) {
+        engine.destroy();
+        this.gpuSupport = null;
+        return;
+      }
+      this.gpu = engine;
+      this.world.gpuMinTiles = this.gpuMinTiles;
+      this.world.attachGpu(engine);
+    }).finally(() => {
+      this.gpuStarting = null;
+      this.host.changed();
+    });
+  }
+  /** Resolves once the GPU engine has started or turned out unavailable. */
+  async gpuReady() {
+    if (this.gpuStarting) await this.gpuStarting;
+    return this.engineInfo();
+  }
+  /** `auto`: use the GPU for large wet areas when there is one; `off`: the CPU only. */
+  setGpu(mode, minTiles) {
+    if (minTiles !== void 0) {
+      this.gpuMinTiles = Math.max(1, Math.floor(minTiles));
+      if (this.world) this.world.gpuMinTiles = this.gpuMinTiles;
+    }
+    if (mode === this.gpuMode) return this.engineInfo();
+    this.gpuMode = mode;
+    if (mode === "off") {
+      _optionalChain([this, 'access', _79 => _79.world, 'optionalAccess', _80 => _80.attachGpu, 'call', _81 => _81(null)]);
+      _optionalChain([this, 'access', _82 => _82.gpu, 'optionalAccess', _83 => _83.destroy, 'call', _84 => _84()]);
+      this.gpu = null;
+      this.gpuSupport = null;
+    } else if (this.world) this.startGpu();
+    return this.engineInfo();
+  }
+  engineInfo() {
+    const w = this.world;
+    const base = { mode: this.gpuMode, adapter: _nullishCoalesce(_optionalChain([this, 'access', _85 => _85.gpuSupport, 'optionalAccess', _86 => _86.adapter]), () => ( null)), maxTiles: _nullishCoalesce(_optionalChain([this, 'access', _87 => _87.gpuSupport, 'optionalAccess', _88 => _88.maxSlots]), () => ( 0)), minTiles: this.gpuMinTiles, activeTiles: _nullishCoalesce(_optionalChain([w, 'optionalAccess', _89 => _89.activeTiles, 'call', _90 => _90()]), () => ( 0)), cpu: this.backend() };
+    if (this.gpuMode === "off") return { ...base, state: "off", reason: "Forced to the CPU." };
+    if (this.gpuStarting) return { ...base, state: "starting", reason: null };
+    if (_optionalChain([w, 'optionalAccess', _91 => _91.gpuError])) return { ...base, state: "failed", reason: w.gpuError };
+    if (this.gpuSupport && !this.gpuSupport.supported) return { ...base, state: "unavailable", reason: this.gpuSupport.reason };
+    if (!this.gpu) return { ...base, state: "not-started", reason: "Starts with the first wet stroke." };
+    if (_optionalChain([w, 'optionalAccess', _92 => _92.gpuActive])) return { ...base, state: "active", reason: null };
+    return { ...base, state: "standby", reason: `The GPU takes over at ${this.gpuMinTiles} wet tiles (256 px).` };
+  }
+  /** The world (made on first use, at the canvas size). */
+  ensureWorld() {
+    const { width, height } = this.host.canvas();
+    if (this.world && (this.world.width !== width || this.world.height !== height)) {
+      if (this.world.laneIds().length) throw new Error("The wet world is the wrong size; dry the paint before resizing the canvas.");
+      this.dropWorld();
+    }
+    if (!this.world) this.world = this.makeWorld(width, height, this.host.paper());
+    return this.world;
+  }
+  makeWorld(width, height, paper) {
+    const world = new (0, _chunkJ5VQYK7Tcjs.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);
+    else this.startGpu();
+    return world;
+  }
+  /**
+   * Whether `extend` can keep the wet paint when the canvas grows by `left` / `top` on those
+   * sides: the shift has to be whole wet tiles (256 px), and no wet stroke may be live.
+   */
+  canExtend(left2, top) {
+    return left2 % _chunkJ5VQYK7Tcjs.WET_TILE === 0 && top % _chunkJ5VQYK7Tcjs.WET_TILE === 0 && !this.driver;
+  }
+  /**
+   * Keeps the wet paint while the canvas grows to `width`×`height` by `left` / `top` on those
+   * sides (`canExtend` must hold): the world is made again at the new size with every wet layer
+   * moved by (left, top), still wet, its base and flow map with it; `paper` is the new
+   * document's paper (its grain moved with the paint). Wet settings' flow centres move too. The
+   * caller shows the layers again (`syncDisplays`) once the document is the new size.
+   */
+  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 old = this.world;
+    const snap = _optionalChain([old, 'optionalAccess', _93 => _93.laneIds, 'call', _94 => _94(), 'access', _95 => _95.length]) ? old.snapshot() : null;
+    this.dropWorld();
+    this.lastTick = null;
+    this.stepsOwed = 0;
+    if (!old || !snap) return;
+    const moved = _chunkJ5VQYK7Tcjs.moveWetSnapshot.call(void 0, snap, old, { width, height }, left2, top, (l) => {
+      const flow = _optionalChain([this, 'access', _96 => _96.settings, 'access', _97 => _97.get, 'call', _98 => _98(l.id), 'optionalAccess', _99 => _99.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" ? _chunkJ5VQYK7Tcjs.flowField.call(void 0, flow, width, height) : l.flow
+      };
+    });
+    this.world = this.makeWorld(width, height, paper);
+    this.world.restore(moved);
+  }
+  /** Whether any layer (or `layerId`) has wet paint. */
+  isWet(layerId) {
+    const w = this.world;
+    if (!w) return false;
+    if (layerId !== void 0) return w.hasLane(layerId) && w.isActive(layerId);
+    return w.laneIds().some((id) => w.isActive(id));
+  }
+  /** Layers holding a wet layer (wet or drying). */
+  wetLayerIds() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _100 => _100.world, 'optionalAccess', _101 => _101.laneIds, 'call', _102 => _102()]), () => ( []));
+  }
+  /** Whether a batch is running (edits wait). */
+  get busy() {
+    return Boolean(_optionalChain([this, 'access', _103 => _103.world, 'optionalAccess', _104 => _104.busy]));
+  }
+  /** Resolves when no batch is running. */
+  async idle() {
+    while (this.ticking) await this.ticking;
+  }
+  settingsOf(layerId, medium = "watercolor") {
+    let s = this.settings.get(layerId);
+    if (!s) {
+      s = { params: _chunkJ5VQYK7Tcjs.normalizeWetParams.call(void 0, WET_MEDIUM_PARAMS[medium], _chunkJ5VQYK7Tcjs.DEFAULT_WET_PARAMS), flow: { ..._chunkJ5VQYK7Tcjs.DEFAULT_FLOW } };
+      this.settings.set(layerId, s);
+    }
+    return s;
+  }
+  /** Puts a layer in the world (its current pixels become the base under the wet paint). */
+  ensureLane(layerId, medium) {
+    const w = this.ensureWorld();
+    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) });
+      const { width, height } = this.host.canvas();
+      if (s.flow.kind !== "none") w.setFlow(layerId, _chunkJ5VQYK7Tcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
+    }
+    return w;
+  }
+  setParams(layerId, update) {
+    const s = this.settingsOf(layerId);
+    s.params = _chunkJ5VQYK7Tcjs.normalizeWetParams.call(void 0, update, s.params);
+    if (_optionalChain([this, 'access', _105 => _105.world, 'optionalAccess', _106 => _106.hasLane, 'call', _107 => _107(layerId)])) this.world.setParams(layerId, s.params);
+    return { ...s.params };
+  }
+  setFlow(layerId, update) {
+    const s = this.settingsOf(layerId);
+    s.flow = _chunkJ5VQYK7Tcjs.normalizeFlow.call(void 0, update, s.flow);
+    if (_optionalChain([this, 'access', _108 => _108.world, 'optionalAccess', _109 => _109.hasLane, 'call', _110 => _110(layerId)])) {
+      const { width, height } = this.host.canvas();
+      this.world.setFlow(layerId, _chunkJ5VQYK7Tcjs.flowField.call(void 0, s.flow, width, height), s.flow.strength);
+    }
+    return { ...s.flow };
+  }
+  setTilt(update) {
+    this.tilt = _chunkJ5VQYK7Tcjs.normalizeTilt.call(void 0, update, this.tilt);
+    _optionalChain([this, 'access', _111 => _111.world, 'optionalAccess', _112 => _112.setTilt, 'call', _113 => _113(this.tilt)]);
+    return { ...this.tilt };
+  }
+  /** The paper changed. */
+  paperChanged() {
+    _optionalChain([this, 'access', _114 => _114.world, 'optionalAccess', _115 => _115.setPaper, 'call', _116 => _116(wetPaperInput(this.host.paper()))]);
+  }
+  /** A layer as tools describe it. */
+  info(layerId) {
+    const s = this.settingsOf(layerId);
+    const st = _optionalChain([this, 'access', _117 => _117.world, 'optionalAccess', _118 => _118.hasLane, 'call', _119 => _119(layerId)]) ? this.world.stats(layerId) : null;
+    return {
+      layerId,
+      wet: Boolean(st && st.wetCells > 0),
+      wetCells: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _120 => _120.wetCells]), () => ( 0)),
+      wetBounds: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _121 => _121.wetBounds]), () => ( null)),
+      activeTiles: _nullishCoalesce(_optionalChain([st, 'optionalAccess', _122 => _122.activeTiles]), () => ( 0)),
+      params: { ...s.params },
+      flow: { ...s.flow }
+    };
+  }
+  backend() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _123 => _123.world, 'optionalAccess', _124 => _124.backend, 'call', _125 => _125()]), () => ( null));
+  }
+  /** Shows the current wet pixels (at most `maxTiles` reshaded per layer). */
+  syncDisplays(maxTiles = Infinity) {
+    const w = this.world;
+    if (!w) return [];
+    const surfaces = /* @__PURE__ */ new Map();
+    const rects = [];
+    for (const id of w.laneIds()) {
+      const d = w.display(id, maxTiles);
+      if (this.host.layerSurface(id) !== d.surface) surfaces.set(id, d.surface);
+      rects.push(...d.changed);
+    }
+    this.syncLights();
+    if (surfaces.size) this.host.updateSurfaces(surfaces, rects);
+    return rects;
+  }
+  /** 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;
+    if (!w) return [];
+    const surfaces = /* @__PURE__ */ new Map();
+    const rects = [];
+    for (const id of w.laneIds()) {
+      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);
+      rects.push(...d.changed);
+    }
+    this.syncLights();
+    if (surfaces.size) this.host.updateSurfaces(surfaces, rects);
+    return rects;
+  }
+  /** Shows each wet layer's live light paint (the light under it with the wet light shaded in). */
+  syncLights() {
+    const w = this.world;
+    if (!w) return;
+    const lights = /* @__PURE__ */ new Map();
+    for (const id of w.laneIds()) {
+      const l = w.lightDisplay(id);
+      if (l && this.host.layerLight(id) !== l) lights.set(id, l);
+    }
+    if (lights.size) this.host.updateLights(lights);
+  }
+  /** Drops the wet layers whose paint has all dried (they become ordinary pixel layers). */
+  retireDry() {
+    const w = this.world;
+    if (!w) return;
+    for (const id of w.laneIds()) {
+      if (w.isActive(id) || _optionalChain([this, 'access', _126 => _126.driver, 'optionalAccess', _127 => _127.init, 'access', _128 => _128.laneId]) === id) continue;
+      const base = w.getBase(id);
+      const light = w.isLit(id) ? w.getLight(id) : null;
+      w.removeLane(id);
+      if (light && this.host.layerLight(id) !== light) this.host.updateLights(/* @__PURE__ */ new Map([[id, light]]));
+      this.host.updateSurfaces(/* @__PURE__ */ new Map([[id, base]]), []);
+    }
+  }
+  /**
+   * Advances time by the wall clock (`now` in ms, e.g. `performance.now()`): `speed` steps per
+   * second, at most `maxSteps` per call. Call it every frame; it does nothing while paused or dry.
+   * Resolves when the steps are done and the display is up to date.
+   */
+  tick(now, maxSteps = 8) {
+    if (this.ticking) {
+      this.leadFrame(now);
+      return this.ticking;
+    }
+    if (this.displaying) return this.displaying;
+    const last = this.lastTick;
+    this.lastTick = now;
+    const w = this.world;
+    if (!w || this.paused || last === null) {
+      this.flushDriver();
+      return Promise.resolve();
+    }
+    if (!w.isActive()) {
+      this.flushDriver();
+      this.retireDry();
+      return Promise.resolve();
+    }
+    const lead = w.gpuActive && !this.driver;
+    w.gpuLeadMode = lead;
+    const most = lead ? Math.max(maxSteps, GPU_LEAD) : maxSteps;
+    this.stepsOwed = Math.min(most * 4, this.stepsOwed + (now - last) / 1e3 * this.speed);
+    const n = Math.min(most, Math.floor(this.stepsOwed));
+    this.leadAt = now;
+    if (n < 1) {
+      this.flushDriver();
+      return Promise.resolve();
+    }
+    this.stepsOwed -= n;
+    const run = (async () => {
+      try {
+        await w.step(n);
+      } finally {
+        this.ticking = null;
+      }
+      this.flushDriver();
+      if (w.gpuActive) {
+        const shading = this.syncDisplaysGpu(DISPLAY_TILES_PER_TICK).then(() => void 0);
+        this.displaying = shading;
+        try {
+          await shading;
+        } finally {
+          this.displaying = null;
+        }
+      } else this.syncDisplays(DISPLAY_TILES_PER_TICK);
+      this.retireDry();
+      this.host.changed();
+    })();
+    this.ticking = run;
+    return run;
+  }
+  /** Lead mode: steps the GPU on by the time since the last frame (within the running batch) and shows it. */
+  leadFrame(now) {
+    const w = this.world;
+    if (!w || this.displaying || this.driver || !w.gpuLeading) return;
+    const k = Math.max(1, Math.round((now - this.leadAt) / 1e3 * this.speed));
+    if (!w.gpuLead(k)) return;
+    this.leadAt = now;
+    const shading = this.syncDisplaysGpu(0, true).then(() => this.host.changed());
+    this.displaying = shading;
+    void shading.finally(() => {
+      if (this.displaying === shading) this.displaying = null;
+    });
+  }
+  flushDriver() {
+    const d = this.driver;
+    if (!d || !this.world) return;
+    const rects = d.flush();
+    if (rects.length) this.syncDisplays(DISPLAY_TILES_PER_TICK);
+    if (d.done) _optionalChain([this, 'access', _129 => _129.onDriverDone, 'optionalCall', _130 => _130(d)]);
+  }
+  /** Called when a live stroke that ended mid-batch has finished applying. */
+  __init56() {this.onDriverDone = null}
+  /** Steps `steps` times now (agents, tests). Returns the steps run. */
+  async advance(steps) {
+    await this.idle();
+    const w = this.world;
+    if (!w) return 0;
+    await w.ready;
+    await this.idle();
+    const start = w.clock;
+    const n = Math.max(0, Math.floor(steps));
+    const job = (async () => {
+      try {
+        await w.step(n);
+      } finally {
+        this.ticking = null;
+      }
+    })();
+    this.ticking = job;
+    await job;
+    if (w.gpuActive) await this.syncDisplaysGpu(Infinity);
+    else this.syncDisplays();
+    this.retireDry();
+    return w.clock - start;
+  }
+  /**
+   * Dries at once (everything settles where it is), on one layer or all, optionally only in a
+   * rectangle. Returns the layers and rectangles that dried.
+   */
+  dry(layerId, rect) {
+    const w = this.world;
+    if (!w) return [];
+    const ids = layerId !== void 0 ? w.hasLane(layerId) ? [layerId] : [] : w.laneIds();
+    const out = [];
+    for (const id of ids) out.push({ layerId: id, bounds: w.dry(id, rect) });
+    this.syncDisplays();
+    this.retireDry();
+    return out;
+  }
+  /** 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', _131 => _131.hasLane, 'call', _132 => _132(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', _133 => _133.hasLane, 'call', _134 => _134(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();
+  }
+  /** Puts a snapshot back (`null`: no wet layers). Returns the layer surfaces it implies. */
+  restore(snap) {
+    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);
+    this.syncDisplays();
+  }
+  dropWorld() {
+    _optionalChain([this, 'access', _135 => _135.world, 'optionalAccess', _136 => _136.destroy, 'call', _137 => _137()]);
+    this.world = null;
+    this.driver = null;
+  }
+  /** Forgets everything wet (a new canvas, a resize, opening a document). */
+  reset() {
+    _optionalChain([this, 'access', _138 => _138.world, 'optionalAccess', _139 => _139.destroy, 'call', _140 => _140()]);
+    this.world = null;
+    this.driver = null;
+    this.settings.clear();
+    this.lastTick = null;
+    this.stepsOwed = 0;
+  }
+  /** Water overlay tiles (RGBA) over a document rectangle, for the view. */
+  waterOverlay(rect) {
+    const w = this.world;
+    if (!w) return [];
+    const out = [];
+    const tx0 = Math.max(0, Math.floor(rect.x / _chunk474IQG74cjs.TILE));
+    const ty0 = Math.max(0, Math.floor(rect.y / _chunk474IQG74cjs.TILE));
+    const tx1 = Math.floor((rect.x + rect.width - 1) / _chunk474IQG74cjs.TILE);
+    const ty1 = Math.floor((rect.y + rect.height - 1) / _chunk474IQG74cjs.TILE);
+    for (let ty = ty0; ty <= ty1; ty++)
+      for (let tx = tx0; tx <= tx1; tx++) {
+        let merged = null;
+        for (const id of w.laneIds()) {
+          const t = w.waterOverlay(id, tx, ty);
+          if (!t) continue;
+          if (!merged) merged = t;
+          else for (let i = 3; i < t.length; i += 4) merged[i] = Math.max(merged[i], t[i]);
+        }
+        if (merged) out.push({ tx, ty, data: merged });
+      }
+    return out;
+  }
+  destroy() {
+    _optionalChain([this, 'access', _141 => _141.world, 'optionalAccess', _142 => _142.destroy, 'call', _143 => _143()]);
+    this.world = null;
+    _optionalChain([this, 'access', _144 => _144.gpu, 'optionalAccess', _145 => _145.destroy, 'call', _146 => _146()]);
+    this.gpu = null;
+  }
+}, _class6);
+function wetPigmentOf(hex, body) {
+  const [r, g, b] = hexToRgb8(hex);
+  return Array.from(_chunkJ5VQYK7Tcjs.pigmentOf.call(void 0, [r / 255, g / 255, b / 255], body));
+}
+
+// src/vector/brushstrokeMedia.ts
+var VECTOR_WET_STEPS = 120;
+function vectorMediaEngine(brush) {
+  if (brush.engine === "wet") return brush.wet.tool === "paint" ? "wet" : null;
+  return brush.engine === "mixer" || brush.engine === "smudge" || brush.engine === "blender" ? brush.engine : null;
+}
+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);
+  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;
+  let x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  for (const s of samples) {
+    x0 = Math.min(x0, s.x);
+    y0 = Math.min(y0, s.y);
+    x1 = Math.max(x1, s.x);
+    y1 = Math.max(y1, s.y);
+  }
+  const reach = brush.tip.size * (1 + 1.5 * brush.dynamics.tiltSize) / 2 + 2 + pad;
+  const maxPixels = finite2(options.maxPixels) && options.maxPixels > 0 ? options.maxPixels : 4096 * 4096;
+  const area = (x1 - x0 + 2 * reach) * (y1 - y0 + 2 * reach);
+  if (area * scale3 * scale3 > maxPixels) scale3 = Math.max(_chunkYQGCPL5Xcjs.BRUSHSTROKE_MIN_SCALE, Math.sqrt(maxPixels / area));
+  const rect = { x: Math.floor((x0 - reach) * scale3), y: Math.floor((y0 - reach) * scale3), width: 0, height: 0 };
+  rect.width = Math.max(1, Math.ceil((x1 + reach) * scale3) - rect.x);
+  rect.height = Math.max(1, Math.ceil((y1 + reach) * scale3) - rect.y);
+  const points = samples.map((s) => ({ ...s, x: s.x * scale3 - rect.x, y: s.y * scale3 - rect.y }));
+  if (options.closed && points.length > 2) points.push({ ...points[0] });
+  const sized = { ...brush, pressureSmoothing: 0, tip: { ...brush.tip, size: brush.tip.size * scale3, smoothing: 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', _147 => _147.type]) === "gradient" ? _chunkNIBFKXMDcjs.resolvePaintGradient.call(void 0, _chunkNIBFKXMDcjs.scalePaintGradient.call(void 0, source, scale3), { paint: hex, secondary: "#ffffff" }) : null;
+  const color2 = _optionalChain([source, 'optionalAccess', _148 => _148.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) {
+  const n = parseInt(hex.slice(1), 16);
+  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+}
+var EMPTY = { image: { width: 0, height: 0, data: new Uint8ClampedArray(0) }, bounds: null, scale: 1, dabs: 0 };
+function cropped(data, placed, dabs, keep) {
+  const { width: w, height: h } = placed.rect;
+  let cx0 = w, cy0 = h, cx1 = -1, cy1 = -1;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const i = (y * w + x) * 4;
+      if (keep ? !keep(i) : data[i + 3] === 0) continue;
+      if (x < cx0) cx0 = x;
+      if (x > cx1) cx1 = x;
+      if (y < cy0) cy0 = y;
+      if (y > cy1) cy1 = y;
+    }
+  }
+  if (cx1 < 0) return { ...EMPTY, scale: placed.scale, dabs };
+  const cw = cx1 - cx0 + 1;
+  const ch = cy1 - cy0 + 1;
+  const out = new Uint8ClampedArray(cw * ch * 4);
+  for (let y = 0; y < ch; y++) {
+    for (let x = 0; x < cw; x++) {
+      const i = ((y + cy0) * w + x + cx0) * 4;
+      if (keep && !keep(i)) continue;
+      const o = (y * cw + x) * 4;
+      out[o] = data[i];
+      out[o + 1] = data[i + 1];
+      out[o + 2] = data[i + 2];
+      out[o + 3] = placed.alpha < 1 ? Math.round(data[i + 3] * placed.alpha) : data[i + 3];
+    }
+  }
+  const s = placed.scale;
+  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);
+    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);
+    if (!this.placed) {
+      this.world = null;
+      this.dabs = 0;
+      this.final = EMPTY;
+      return;
+    }
+    const { rect, points } = this.placed;
+    this.world = new (0, _chunkJ5VQYK7Tcjs.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;
+    const driver = new WetStrokeDriver({
+      world: this.world,
+      laneId: "s",
+      brush: this.placed.brush,
+      color: color2,
+      load: { reservoir: [...color2], amount: 1, pickup: null },
+      grain: null,
+      paperDepth: 0,
+      paperColor: [255, 255, 255],
+      seed: _nullishCoalesce(options.seed, () => ( 0)),
+      copies: [],
+      paint: this.placed.paint
+    });
+    driver.push(points);
+    driver.finish();
+    this.dabs = driver.dabCount;
+  }
+  
+  
+  
+  
+  __init57() {this.done = 0}
+  __init58() {this.final = null}
+  /** Steps run so far. */
+  get progress() {
+    return this.done;
+  }
+  get finished() {
+    return this.final !== null;
+  }
+  /** Runs steps until `budgetMs` has passed (at least one) or all have run. Returns whether it is finished. */
+  run(budgetMs = Infinity) {
+    if (this.final || !this.world) return true;
+    const start = Date.now();
+    while (this.done < this.steps) {
+      this.world.stepSync(1);
+      this.done++;
+      if (Date.now() - start >= budgetMs) break;
+    }
+    if (this.done >= this.steps) {
+      this.final = this.bake();
+      this.destroy();
+    }
+    return this.final !== null;
+  }
+  /** The paint dried where it is now (step 0: as laid). */
+  image() {
+    return _nullishCoalesce(this.final, () => ( this.bake()));
+  }
+  /** The settled image: runs the remaining steps now. */
+  settled() {
+    this.run();
+    return this.final;
+  }
+  destroy() {
+    _optionalChain([this, 'access', _149 => _149.world, 'optionalAccess', _150 => _150.destroy, 'call', _151 => _151()]);
+  }
+  bake() {
+    if (!this.world || !this.placed) return EMPTY;
+    const { width, height } = this.placed.rect;
+    const data = _chunk474IQG74cjs.readRegion.call(void 0, this.world.bakedSurface("s"), { x: 0, y: 0, width, height });
+    return cropped(data, this.placed, this.dabs);
+  }
+}, _class7);
+function renderWetBrushstroke(input, brush, options) {
+  return new WetBrushstrokeJob(input, brush, options).settled();
+}
+function vectorBackdropRect(input, brush, options) {
+  const placed = place(input, brush, options);
+  return placed ? { rect: placed.rect, scale: placed.scale } : null;
+}
+function renderBackdropBrushstroke(input, brush, options) {
+  const engine = vectorMediaEngine(brush);
+  if (!usesVectorBackdrop(engine)) throw new Error(`'${brush.name}' is not a Mixer Brush, smudge or blender.`);
+  const placed = place(input, brush, options);
+  if (!placed) return EMPTY;
+  const { rect } = placed;
+  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', _152 => _152.cache, 'optionalCall', _153 => _153(before)]);
+  const hit = _optionalChain([cached, 'optionalAccess', _154 => _154.get, 'call', _155 => _155()]);
+  if (hit) return hit;
+  const base = _chunk474IQG74cjs.writeRegion.call(void 0, _chunk474IQG74cjs.emptySurface.call(void 0, 4), area, before);
+  const live = /* @__PURE__ */ new Map();
+  const target = {
+    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', _156 => _156.tiles, 'access', _157 => _157.get, 'call', _158 => _158(_chunk474IQG74cjs.tileKey.call(void 0, tx, ty)), 'optionalAccess', _159 => _159.data]))), () => ( null)),
+    writeTile: (tx, ty) => {
+      const key = _chunk474IQG74cjs.tileKey.call(void 0, tx, ty);
+      let t = live.get(key);
+      if (!t) live.set(key, t = base.tiles.get(key) ? new Uint8ClampedArray(base.tiles.get(key).data) : new Uint8ClampedArray(_chunk474IQG74cjs.TILE * _chunk474IQG74cjs.TILE * 4));
+      return t;
+    }
+  };
+  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 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();
+  const after = new Uint8ClampedArray(rect.width * rect.height * 4);
+  const tiles = new Map(base.tiles);
+  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', _160 => _160.set, 'call', _161 => _161(result)]);
+  return result;
+}
+
 // src/vector/brushstroke.ts
 var VECTOR_BRUSHSTROKE_SCALE = 2;
-var PRESETS = _chunkRFJZGTHAcjs.listPresets.call(void 0, _chunkRFJZGTHAcjs.VECTOR_PROFILE).map((spec) => _chunkRFJZGTHAcjs.BUILTIN_BRUSHES.find((b) => b.id === spec.id));
+var PRESETS = _chunkEU2ZZA6Lcjs.listPresets.call(void 0, _chunkEU2ZZA6Lcjs.VECTOR_PROFILE).map((spec) => _chunkEU2ZZA6Lcjs.BUILTIN_BRUSHES.find((b) => b.id === spec.id));
 function admitted(spec) {
   try {
-    const brush = _chunkRFJZGTHAcjs.normalizeBrushSpec.call(void 0, spec);
-    return _chunkRFJZGTHAcjs.checkBrush.call(void 0, brush, _chunkRFJZGTHAcjs.VECTOR_PROFILE).ok && _chunkPXDIAYB6cjs.isBrushstrokeBrush.call(void 0, _chunkRFJZGTHAcjs.resolveBrush.call(void 0, brush)) ? brush : null;
-  } catch (e4) {
+    const brush = _chunkEU2ZZA6Lcjs.normalizeBrushSpec.call(void 0, spec);
+    return _chunkEU2ZZA6Lcjs.checkBrush.call(void 0, brush, _chunkEU2ZZA6Lcjs.VECTOR_PROFILE).ok && isVectorBrushstrokeEngine(_chunkEU2ZZA6Lcjs.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;
+}
 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(_chunkRFJZGTHAcjs.resolveBrush.call(void 0, brush));
+    if (brush && !out.some((b) => b.id === brush.id)) out.push(_chunkEU2ZZA6Lcjs.resolveBrush.call(void 0, brush));
   }
   return out;
 }
@@ -2559,7 +4552,7 @@ function vectorBrushstrokeBrush(id) {
 function vectorBrushstrokeBrushOf(brush) {
   if (brush.spec) {
     const saved = admitted(brush.spec);
-    return saved && saved.id === brush.brushId ? _chunkRFJZGTHAcjs.resolveBrush.call(void 0, saved) : null;
+    return saved && saved.id === brush.brushId ? _chunkEU2ZZA6Lcjs.resolveBrush.call(void 0, saved) : null;
   }
   return vectorBrushstrokeBrush(brush.brushId);
 }
@@ -2567,15 +4560,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) => _chunkRFJZGTHAcjs.checkBrush.call(void 0, b, _chunkRFJZGTHAcjs.VECTOR_PROFILE).issues.filter((i) => i.severity === "error").map((i) => `${i.reason} ${i.fix}`).join(" ") || "it is not a dry dab brush.";
+  const reasons = (b) => _chunkEU2ZZA6Lcjs.checkBrush.call(void 0, b, _chunkEU2ZZA6Lcjs.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 preset = _chunkRFJZGTHAcjs.BRUSH_PRESETS.find((b) => b.id === id);
-  if (preset) return `Brush "${id}" (${preset.name}) can't paint a brushstroke: ${reasons(preset)} Use one of: ${ids.join(", ")}.`;
-  return `Unknown brush "${id}". ${_chunkRFJZGTHAcjs.closest.call(void 0, id, ids)}Use one of: ${ids.join(", ")} (vector.listBrushes lists them).`;
+  const preset2 = _chunkEU2ZZA6Lcjs.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}". ${_chunkEU2ZZA6Lcjs.closest.call(void 0, id, ids)}Use one of: ${ids.join(", ")} (vector.listBrushes lists them).`;
 }
 function vectorBrushstrokeDefaultColour(id, user = [], scheme = "light") {
-  const brush = _nullishCoalesce(_chunkRFJZGTHAcjs.BRUSH_PRESETS.find((b) => b.id === id), () => ( user.find((b) => b.id === id)));
-  return brush ? _chunkJBZRVLXVcjs.brushColourHex.call(void 0, _optionalChain([brush, 'access', _55 => _55.colour, 'optionalAccess', _56 => _56.default]), scheme) : null;
+  const brush = _nullishCoalesce(_chunkEU2ZZA6Lcjs.BRUSH_PRESETS.find((b) => b.id === id), () => ( user.find((b) => b.id === id)));
+  return brush ? _chunkJBZRVLXVcjs.brushColourHex.call(void 0, _optionalChain([brush, 'access', _162 => _162.colour, 'optionalAccess', _163 => _163.default]), scheme) : null;
 }
 function sanitizeVectorBrushstroke(value, user = []) {
   if (!value || typeof value !== "object") return null;
@@ -2594,6 +4587,8 @@ function sanitizeVectorBrushstroke(value, user = []) {
   }
   const seed = sanitizeSeed(r.seed);
   if (seed !== void 0) out.seed = seed;
+  const paint = readVectorBrushstrokePaint(r.paint);
+  if (paint) out.paint = paint;
   if (r.paper === null) out.paper = null;
   else {
     const paper = sanitizeVectorBrushstrokePaper(r.paper);
@@ -2601,18 +4596,33 @@ function sanitizeVectorBrushstroke(value, user = []) {
   }
   return out;
 }
+var TIMED_MAPPINGS = ["velocity", "time"];
+function vectorBrushstrokePaintError(paint) {
+  let source;
+  try {
+    source = _chunkNIBFKXMDcjs.parsePaintSource.call(void 0, paint, "paint");
+  } catch (e) {
+    return e.message;
+  }
+  if (source.type === "gradient" && TIMED_MAPPINGS.includes(source.map.by)) return `paint.map.by "${source.map.by}" needs timed samples, which vector paths do not have; use distance, pressure, tilt, direction, across-tip or random.`;
+  return null;
+}
+function readVectorBrushstrokePaint(value) {
+  if (value === void 0 || value === null || vectorBrushstrokePaintError(value)) return null;
+  return _chunkNIBFKXMDcjs.readPaintSource.call(void 0, value);
+}
 var VECTOR_BRUSHSTROKE_MAX_SEED = 2147483647;
-var finite2 = (v2) => typeof v2 === "number" && Number.isFinite(v2);
-var sanitizeSeed = (v2) => finite2(v2) ? Math.min(VECTOR_BRUSHSTROKE_MAX_SEED, Math.max(0, Math.round(v2))) : void 0;
+var finite3 = (v2) => typeof v2 === "number" && Number.isFinite(v2);
+var sanitizeSeed = (v2) => finite3(v2) ? Math.min(VECTOR_BRUSHSTROKE_MAX_SEED, Math.max(0, Math.round(v2))) : void 0;
 function sanitizeVectorBrushstrokePaper(value) {
   if (!value || typeof value !== "object") return null;
   const r = value;
   const out = {};
-  if (typeof r.pattern === "string" && _chunkPXDIAYB6cjs.GRAIN_PATTERNS.includes(r.pattern)) out.pattern = r.pattern;
+  if (typeof r.pattern === "string" && _chunkNIBFKXMDcjs.GRAIN_PATTERNS.includes(r.pattern)) out.pattern = r.pattern;
   const seed = sanitizeSeed(r.seed);
   if (seed !== void 0) out.seed = seed;
-  if (finite2(r.scale) && r.scale > 0) out.scale = Math.min(8, Math.max(0.25, r.scale));
-  if (finite2(r.depth)) out.depth = Math.min(1, Math.max(0, r.depth));
+  if (finite3(r.scale) && r.scale > 0) out.scale = Math.min(8, Math.max(0.25, r.scale));
+  if (finite3(r.depth)) out.depth = Math.min(1, Math.max(0, r.depth));
   return Object.keys(out).length ? out : null;
 }
 function vectorBrushstrokeCharacterError(brush) {
@@ -2623,10 +4633,10 @@ 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 && !_chunkPXDIAYB6cjs.GRAIN_PATTERNS.includes(r.pattern)) return `Unknown paper pattern "${String(r.pattern)}": use one of ${_chunkPXDIAYB6cjs.GRAIN_PATTERNS.join(", ")}.`;
+  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.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 && !(finite2(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 && !(finite2(r.depth) && r.depth >= 0 && r.depth <= 1)) return "paper.depth must be from 0 to 1.";
+  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.";
   return null;
 }
 function randomVectorBrushstrokeSeed() {
@@ -2639,37 +4649,248 @@ function vectorBrushstrokeReach(layer) {
   if (!isVectorBrushstrokeLayer(layer)) return 0;
   return (_nullishCoalesce(layer.brush.size, () => ( vectorBrushstrokeBrushOf(layer.brush).tip.size))) / 2;
 }
-var cache = new (0, _chunkPXDIAYB6cjs.BrushstrokeCache)(256);
+var backdropSource = null;
+function setVectorBackdropSource(source) {
+  backdropSource = source;
+}
+var hex22 = (v2) => Math.round(Math.min(1, Math.max(0, v2)) * 255).toString(16).padStart(2, "0");
+function gradientPaint(g, map) {
+  const stops = sortedVectorGradientStops(g);
+  const exact2 = stops.length >= 2 && stops.length <= 16 && !g.smoothness && (_nullishCoalesce(g.interpolation, () => ( "srgb"))) === "srgb" && stops.every((s) => parseVectorColor(s.color));
+  if (exact2) {
+    return {
+      type: "gradient",
+      space: "srgb",
+      map,
+      stops: stops.map((s) => {
+        const c = parseVectorColor(s.color);
+        const opacity = Math.min(1, Math.max(0, (_nullishCoalesce(s.opacity, () => ( 1))) * c[3]));
+        const midpoint = s.midpoint !== void 0 && s.midpoint !== 0.5 ? Math.min(0.95, Math.max(0.05, s.midpoint)) : void 0;
+        return { offset: Math.min(1, Math.max(0, s.offset)), color: `#${hex22(c[0])}${hex22(c[1])}${hex22(c[2])}`, ...opacity < 1 ? { opacity } : {}, ...midpoint !== void 0 ? { midpoint } : {} };
+      })
+    };
+  }
+  const ramp = vectorGradientRamp(g);
+  const n = 16;
+  return {
+    type: "gradient",
+    space: "srgb",
+    map,
+    stops: Array.from({ length: n }, (_, i) => {
+      const t = i / (n - 1);
+      const c = ramp ? ramp.sample(t) : [0, 0, 0, 1];
+      return { offset: t, color: `#${hex22(c[0])}${hex22(c[1])}${hex22(c[2])}`, ...c[3] < 1 ? { opacity: Math.max(0, c[3]) } : {} };
+    })
+  };
+}
+var REPEAT = { pad: "clamp", repeat: "repeat", reflect: "mirror" };
+function strokePaintOf(node, layer, brush, length2) {
+  const engine = vectorMediaEngine(brush);
+  if (engine === "smudge" || engine === "blender") return { color: [0, 0, 0, 255], paint: null, within: null };
+  const solid = _nullishCoalesce(vectorPaintSolid(layer.paint), () => ( "#000000"));
+  const c = _nullishCoalesce(parseVectorColor(solid), () => ( [0, 0, 0, 1]));
+  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', _164 => _164.stops, 'optionalAccess', _165 => _165.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 };
+    if (engine === "mixer") 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"))] }), within: null };
+    const b = _chunkGF2RBSDMcjs.bezierPathBounds.call(void 0, subpathsToBezier(node.subpaths));
+    return { color: [255, 255, 255, 255], paint: null, within: { gradient: g, bounds: b ? { x: b.minX, y: b.minY, width: b.maxX - b.minX, height: b.maxY - b.minY } : null } };
+  }
+  if (brush.paint && !TIMED_MAPPINGS.includes(brush.paint.map.by)) return { color: color2, paint: brush.paint, within: null };
+  return { color: color2, paint: null, within: null };
+}
+function recoloured(stroke, within) {
+  if (!stroke.bounds) return stroke;
+  const ramp = vectorGradientRamp(within.gradient);
+  if (!ramp) return stroke;
+  const lut = Array.from({ length: 256 }, (_, i) => ramp.sample(i / 255));
+  const { width, height, data } = stroke.image;
+  const out = new Uint8ClampedArray(data);
+  const { x: bx, y: by } = stroke.bounds;
+  const s = stroke.scale;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const i = (y * width + x) * 4;
+      if (!out[i + 3]) continue;
+      const t = vectorGradientTAt(within.gradient, within.bounds, { x: bx + (x + 0.5) / s, y: by + (y + 0.5) / s });
+      const col = lut[Math.round(Math.min(1, Math.max(0, t)) * 255)];
+      out[i] = Math.round(out[i] * col[0]);
+      out[i + 1] = Math.round(out[i + 1] * col[1]);
+      out[i + 2] = Math.round(out[i + 2] * col[2]);
+      out[i + 3] = Math.round(out[i + 3] * col[3]);
+    }
+  }
+  return { ...stroke, image: { width, height, data: out } };
+}
+function hash(s, h = 2166136261) {
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h;
+}
+function hashBytes(b, h = 2166136261) {
+  for (let i = 0; i < b.length; i++) {
+    h ^= b[i];
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h;
+}
+function mediaKey(input, brush, options) {
+  const path = JSON.stringify(input);
+  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);
+    this.capacity = capacity;
+  }
+  
+  __init59() {this.map = /* @__PURE__ */ new Map()}
+  get(key) {
+    const v2 = this.map.get(key);
+    if (v2 !== void 0) {
+      this.map.delete(key);
+      this.map.set(key, v2);
+    }
+    return v2;
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  set(key, value) {
+    this.map.delete(key);
+    this.map.set(key, value);
+    while (this.map.size > this.capacity) this.map.delete(this.map.keys().next().value);
+  }
+}, _class8);
+var WET_SLICE_MS = 12;
+var wetSettled = new Lru(128);
+var wetInstant = /* @__PURE__ */ new Map();
+var wetJobs = /* @__PURE__ */ new Map();
+var settleListeners = /* @__PURE__ */ new Set();
+var wetTimer = null;
+var wetGeneration = 0;
+function wetFinished(key, job) {
+  wetGeneration++;
+  wetSettled.set(key, job.image());
+  wetJobs.delete(key);
+  wetInstant.delete(key);
+}
+function notifySettled() {
+  for (const fn of [...settleListeners]) fn();
+}
+function scheduleWet() {
+  if (wetTimer || !wetJobs.size) return;
+  wetTimer = setTimeout(() => {
+    wetTimer = null;
+    const first = wetJobs.entries().next().value;
+    if (first && first[1].run(WET_SLICE_MS)) {
+      wetFinished(first[0], first[1]);
+      notifySettled();
+    }
+    scheduleWet();
+  }, 0);
+}
+function onVectorBrushstrokesSettled(listener) {
+  settleListeners.add(listener);
+  return () => settleListeners.delete(listener);
+}
+function vectorBrushstrokesSettling() {
+  return wetJobs.size;
+}
+function settleVectorBrushstrokes() {
+  const n = wetJobs.size;
+  if (!n) return 0;
+  for (const [key, job] of [...wetJobs]) {
+    job.run();
+    wetFinished(key, job);
+  }
+  notifySettled();
+  return n;
+}
+function wetImage(input, brush, options, settle, pending) {
+  const key = mediaKey(input, brush, options);
+  const done = wetSettled.get(key);
+  if (done) return done;
+  let job = wetJobs.get(key);
+  if (settle === "now") {
+    job ??= new WetBrushstrokeJob(input, brush, options);
+    job.run();
+    wetFinished(key, job);
+    return wetSettled.get(key);
+  }
+  if (!job) {
+    job = new WetBrushstrokeJob(input, brush, options);
+    wetJobs.set(key, job);
+    wetInstant.set(key, job.image());
+    scheduleWet();
+  }
+  pending.push(key);
+  return _nullishCoalesce(wetInstant.get(key), () => ( job.image()));
+}
+var cache = new (0, _chunkSTLTOISWcjs.BrushstrokeCache)(256);
+var backdropResults = new Lru(64);
 var urls = /* @__PURE__ */ new WeakMap();
 var layerCache = /* @__PURE__ */ new WeakMap();
-function vectorBrushstrokeImages(node, layer) {
+var sameDeps = (a, b) => a === b || !!a && !!b && a.length === b.length && a.every((v2, i) => v2 === b[i]);
+function vectorBrushstrokeImages(node, layer, context = {}) {
   if (!isVectorBrushstrokeLayer(layer)) return [];
+  const preset2 = vectorBrushstrokeBrushOf(layer.brush);
+  const engine = vectorMediaEngine(preset2);
+  const settle = _nullishCoalesce(context.settle, () => ( "async"));
+  const document2 = _nullishCoalesce(context.document, () => ( null));
+  const index = (_nullishCoalesce(node.strokes, () => ( []))).indexOf(layer);
+  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', _57 => _57.get, 'call', _58 => _58(layer)]);
-  if (hit) return hit;
-  const preset = vectorBrushstrokeBrushOf(layer.brush);
-  const brush = layer.brush.size ? { ...preset, tip: { ...preset.tip, size: layer.brush.size } } : preset;
-  const solid = _nullishCoalesce(vectorPaintSolid(layer.paint), () => ( "#000000"));
-  const c = _nullishCoalesce(parseVectorColor(solid), () => ( [0, 0, 0, 1]));
-  const color2 = [c[0] * 255, c[1] * 255, c[2] * 255, c[3] * 255].map(Math.round);
+  const hit = _optionalChain([byLayer, 'optionalAccess', _166 => _166.get, 'call', _167 => _167(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;
   const { seed, paper } = layer.brush;
   const character = seed !== void 0 ? { character: { seed, origin: { x: 0, y: 0 }, unit: 1, ...paper !== void 0 ? { paper } : {} } } : {};
   const out = [];
+  const pending = [];
   for (const sp of node.subpaths) {
     if (sp.anchors.length < 2) continue;
     for (const contour of _chunkGF2RBSDMcjs.pathToContours.call(void 0, subpathsToBezier([sp]))) {
       const ring = _chunkGF2RBSDMcjs.flattenChain.call(void 0, _chunkGF2RBSDMcjs.closeContour.call(void 0, contour, contour.closed), 0.25);
       if (contour.closed && ring.length > 2) ring.push(ring[0]);
       if (ring.length < 2) continue;
-      const stroke = cache.render({ points: ring.map(([x, y]) => ({ x, y })), ...layer.brush.pressure ? { pressure: layer.brush.pressure } : {} }, brush, { scale: VECTOR_BRUSHSTROKE_SCALE, color: color2, maxPixels: 2048 * 2048, ...character });
+      let length2 = 0;
+      for (let i = 1; i < ring.length; i++) length2 += Math.hypot(ring[i][0] - ring[i - 1][0], ring[i][1] - ring[i - 1][1]);
+      const input = { points: ring.map(([x, y]) => ({ x, y })), ...layer.brush.pressure ? { pressure: layer.brush.pressure } : {} };
+      const sp2 = strokePaintOf(node, layer, brush, length2);
+      const options = { scale: VECTOR_BRUSHSTROKE_SCALE, color: sp2.color, paint: sp2.paint, seed: _nullishCoalesce(seed, () => ( 0)), maxPixels: 2048 * 2048 };
+      let stroke;
+      if (engine === "wet") stroke = wetImage(input, brush, { ...options, maxPixels: 1024 * 1024 }, settle, pending);
+      else if (engine) {
+        const key = mediaKey(input, brush, options);
+        stroke = renderBackdropBrushstroke(input, brush, {
+          ...options,
+          backdrop: _nullishCoalesce(_optionalChain([source, 'optionalAccess', _168 => _168.backdrop]), () => ( null)),
+          cache: (bytes) => {
+            const k = `${key}:${hashBytes(bytes).toString(16)}`;
+            return { get: () => backdropResults.get(k), set: (img) => backdropResults.set(k, img) };
+          }
+        });
+      } else {
+        const { paint, ...rest } = options;
+        stroke = cache.render(input, brush, { ...rest, ...paint ? { paint } : {}, ...character });
+      }
+      if (sp2.within) stroke = recoloured(stroke, sp2.within);
       if (!stroke.bounds) continue;
       let href = urls.get(stroke);
-      if (!href) urls.set(stroke, href = _chunkPXDIAYB6cjs.brushstrokeDataUrl.call(void 0, stroke));
+      if (!href) urls.set(stroke, href = _chunkSTLTOISWcjs.brushstrokeDataUrl.call(void 0, stroke));
       out.push({ href, ...stroke.bounds });
     }
   }
   if (!byLayer) layerCache.set(node, byLayer = /* @__PURE__ */ new Map());
-  byLayer.set(layer, out);
+  byLayer.set(layer, { images: out, deps, pending, settled: settle === "now" || !pending.length && !deps });
   return out;
 }
 
@@ -2755,7 +4976,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', _59 => _59[0], 'optionalAccess', _60 => _60.paint]), () => ( null));
+    next.fill = _nullishCoalesce(_optionalChain([fills, 'access', _169 => _169[0], 'optionalAccess', _170 => _170.paint]), () => ( null));
     return next;
   }
   next.fills = fills.map((l) => ({ ...l }));
@@ -2780,8 +5001,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', _61 => _61.paint]))) out.push("stroke");
-  for (const key of VECTOR_STROKE_SETTING_KEYS) if (json(node[key]) !== json(_optionalChain([top, 'optionalAccess', _62 => _62[key]]))) out.push(key);
+  if (json(node.stroke) !== json(_optionalChain([top, 'optionalAccess', _171 => _171.paint]))) out.push("stroke");
+  for (const key of VECTOR_STROKE_SETTING_KEYS) if (json(node[key]) !== json(_optionalChain([top, 'optionalAccess', _172 => _172[key]]))) out.push(key);
   return out;
 }
 var checked = /* @__PURE__ */ new WeakSet();
@@ -2798,7 +5019,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', _63 => _63.paint]))) {
+    if (prefer === "shorthand" && json(node.fill) !== json(_optionalChain([top, 'optionalAccess', _173 => _173.paint]))) {
       if (!draws(node.fill)) fills = [];
       else fills = top ? [...fills.slice(0, -1), { ...top, paint: node.fill }] : [{ paint: node.fill }];
     }
@@ -2964,13 +5185,13 @@ function subsOf(path) {
   return _chunkGF2RBSDMcjs.pathToContours.call(void 0, path).map((c) => ({ segs: _chunkGF2RBSDMcjs.closeContour.call(void 0, c).filter((s) => !degenerate(s)).map(raise), closed: c.closed })).filter((s) => s.segs.length > 0);
 }
 var subsToPath = (subs) => _chunkGF2RBSDMcjs.contoursToPath.call(void 0, subs.map((s) => ({ segments: s.segs, closed: s.closed })));
-var unit2 = (x, y) => {
+var unit3 = (x, y) => {
   const l = Math.hypot(x, y);
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
 };
 function startTangent(s) {
   for (let i = 1; i < s.length; i++) {
-    const u = unit2(s[i][0] - s[0][0], s[i][1] - s[0][1]);
+    const u = unit3(s[i][0] - s[0][0], s[i][1] - s[0][1]);
     if (u) return u;
   }
   return [1, 0];
@@ -2978,7 +5199,7 @@ function startTangent(s) {
 function endTangent(s) {
   const end = s[s.length - 1];
   for (let i = s.length - 2; i >= 0; i--) {
-    const u = unit2(end[0] - s[i][0], end[1] - s[i][1]);
+    const u = unit3(end[0] - s[i][0], end[1] - s[i][1]);
     if (u) return u;
   }
   return [1, 0];
@@ -2987,7 +5208,7 @@ function tangentAt(s, t) {
   if (t <= 1e-9) return startTangent(s);
   if (t >= 1 - 1e-9) return endTangent(s);
   const d = _chunkGF2RBSDMcjs.segmentDerivative.call(void 0, s, t);
-  return _nullishCoalesce(unit2(d[0], d[1]), () => ( startTangent(s)));
+  return _nullishCoalesce(unit3(d[0], d[1]), () => ( startTangent(s)));
 }
 var perp2 = (v2) => [-v2[1], v2[0]];
 function effectPathLength(path) {
@@ -3014,8 +5235,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', _64 => _64[out.length - 1], 'optionalAccess', _65 => _65.segs]);
-      const end = _optionalChain([last, 'optionalAccess', _66 => _66[last.length - 1], 'optionalAccess', _67 => _67.at, 'call', _68 => _68(-1)]);
+      const last = _optionalChain([out, 'access', _174 => _174[out.length - 1], 'optionalAccess', _175 => _175.segs]);
+      const end = _optionalChain([last, 'optionalAccess', _176 => _176[last.length - 1], 'optionalAccess', _177 => _177.at, 'call', _178 => _178(-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);
     }
@@ -3211,7 +5432,7 @@ function resample(sub5, m) {
         let tan = tout;
         if (prev !== null) {
           const tin = endTangent(segs[prev]);
-          tan = _nullishCoalesce(unit2(tin[0] + tout[0], tin[1] + tout[1]), () => ( tout));
+          tan = _nullishCoalesce(unit3(tin[0] + tout[0], tin[1] + tout[1]), () => ( tout));
         }
         out.push({ p: segs[j][0], tan, lenPrev: prev === null ? 0 : lens[prev] / m, lenNext: piece });
       } else {
@@ -3269,17 +5490,17 @@ function splitmix(x) {
   z = (z ^ z >> 27n) * 0x94d049bb133111ebn & MASK64;
   return z ^ z >> 31n;
 }
-function hash(seed, idx, t) {
+function hash3(seed, idx, t) {
   const h = splitmix(splitmix(splitmix(seed) ^ idx) ^ BigInt.asUintN(64, BigInt(t)));
   return Number(h >> 11n) / 2 ** 53 * 2 - 1;
 }
 function noise(seed, idx, t) {
   const i = Math.floor(t);
   const f = t - i;
-  const p0 = hash(seed, idx, i - 1);
-  const p1 = hash(seed, idx, i);
-  const p2 = hash(seed, idx, i + 1);
-  const p3 = hash(seed, idx, i + 2);
+  const p0 = hash3(seed, idx, i - 1);
+  const p1 = hash3(seed, idx, i);
+  const p2 = hash3(seed, idx, i + 1);
+  const p3 = hash3(seed, idx, i + 2);
   const v2 = 0.5 * (2 * p1 + (-p0 + p2) * f + (2 * p0 - 5 * p1 + 4 * p2 - p3) * f * f + (-p0 + 3 * p1 - 3 * p2 + p3) * f * f * f);
   return Math.min(1, Math.max(-1, v2));
 }
@@ -3327,9 +5548,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', _69 => _69.scale, 'optionalAccess', _70 => _70.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _71 => _71.scale, 'optionalAccess', _72 => _72.y]), () => ( 100))) / 100, k)));
+    m = multiplyMatrices(m, scaleMatrix(Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _179 => _179.scale, 'optionalAccess', _180 => _180.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _181 => _181.scale, 'optionalAccess', _182 => _182.y]), () => ( 100))) / 100, k)));
     m = multiplyMatrices(m, rotateMatrix((_nullishCoalesce(r.rotation, () => ( 0))) * k));
-    m = multiplyMatrices(m, translateMatrix(pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _73 => _73.position, 'optionalAccess', _74 => _74.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _75 => _75.position, 'optionalAccess', _76 => _76.y]), () => ( 0))) * k));
+    m = multiplyMatrices(m, translateMatrix(pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _183 => _183.position, 'optionalAccess', _184 => _184.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _185 => _185.position, 'optionalAccess', _186 => _186.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)) });
@@ -3493,7 +5714,7 @@ function mapBezierPath(path, f, tolerance = 0.1, options = {}) {
 
 // src/vector/frames.ts
 function isVectorFrame(node) {
-  return _optionalChain([node, 'optionalAccess', _77 => _77.type]) === "group" && !!node.frame && !node.blend && !node.liveBoolean && !node.mask;
+  return _optionalChain([node, 'optionalAccess', _187 => _187.type]) === "group" && !!node.frame && !node.blend && !node.liveBoolean && !node.mask;
 }
 function vectorFrameRectPath(frame) {
   const { x, y, width: w, height: h } = frame;
@@ -3538,17 +5759,17 @@ 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', _78 => _78.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', _79 => _79.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', _188 => _188.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', _189 => _189.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];
 }
-var finite3 = (v2) => typeof v2 === "number" && Number.isFinite(v2);
+var finite4 = (v2) => typeof v2 === "number" && Number.isFinite(v2);
 function sanitizeVectorFrame(value) {
   if (!value || typeof value !== "object") return null;
   const r = value;
-  if (!finite3(r.x) || !finite3(r.y) || !finite3(r.width) || !finite3(r.height) || r.width < 0 || r.height < 0) return null;
+  if (!finite4(r.x) || !finite4(r.y) || !finite4(r.width) || !finite4(r.height) || r.width < 0 || r.height < 0) return null;
   const out = { x: r.x, y: r.y, width: r.width, height: r.height };
   if (typeof r.fill === "string" || r.fill && typeof r.fill === "object") out.fill = r.fill;
   if (r.clip === false) out.clip = false;
@@ -3595,7 +5816,7 @@ function vectorFrameDocument(doc, id, find) {
     height,
     ...doc.background ? { background: doc.background } : {},
     nodes: [placed],
-    ..._optionalChain([doc, 'access', _80 => _80.symbols, 'optionalAccess', _81 => _81.length]) ? { symbols: doc.symbols } : {}
+    ..._optionalChain([doc, 'access', _190 => _190.symbols, 'optionalAccess', _191 => _191.length]) ? { symbols: doc.symbols } : {}
   };
 }
 function getVectorFramePanel(state) {
@@ -3615,7 +5836,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', _82 => _82.resizing, 'optionalAccess', _83 => _83.horizontal]), () => ( "left")))), vertical: one(children.map((c) => _nullishCoalesce(_optionalChain([c, 'access', _84 => _84.resizing, 'optionalAccess', _85 => _85.vertical]), () => ( "top")))) } : null
+    resizing: children.length ? { ids: children.map((c) => c.id), horizontal: one(children.map((c) => _nullishCoalesce(_optionalChain([c, 'access', _192 => _192.resizing, 'optionalAccess', _193 => _193.horizontal]), () => ( "left")))), vertical: one(children.map((c) => _nullishCoalesce(_optionalChain([c, 'access', _194 => _194.resizing, 'optionalAccess', _195 => _195.vertical]), () => ( "top")))) } : null
   };
 }
 
@@ -4001,7 +6222,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', _86 => _86[spec.key]]);
+    const v2 = _optionalChain([params, 'optionalAccess', _196 => _196[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();
@@ -4133,7 +6354,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', _87 => _87[primitives.length - 1], 'optionalAccess', _88 => _88.attrs, 'access', _89 => _89.result]);
+  const lastResult = _optionalChain([primitives, 'access', _197 => _197[primitives.length - 1], 'optionalAccess', _198 => _198.attrs, 'access', _199 => _199.result]);
   if (lastResult !== body) primitives.push(fe("feMerge", {}, [fe("feMergeNode", { in: body })]));
   const pad = vectorFilterReach(active) + 2;
   return {
@@ -4148,7 +6369,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', _90 => _90.children, 'optionalAccess', _91 => _91.length]) ? `<${p.tag}${attrs}>${p.children.map(primitiveMarkup).join("")}</${p.tag}>` : `<${p.tag}${attrs}/>`;
+  return _optionalChain([p, 'access', _200 => _200.children, 'optionalAccess', _201 => _201.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>`;
@@ -4166,7 +6387,7 @@ function sanitizeVectorMask(value) {
   return r.invert === true ? { type: r.type, invert: true } : { type: r.type };
 }
 function isVectorMaskGroup(node) {
-  return _optionalChain([node, 'optionalAccess', _92 => _92.type]) === "group" && !!node.mask && isVectorMaskType(node.mask.type) && !node.blend && !node.liveBoolean && node.children.length > 0;
+  return _optionalChain([node, 'optionalAccess', _202 => _202.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;
@@ -4196,12 +6417,12 @@ function vectorMaskSummary(node) {
     enabled: node.children[0].visible !== false
   };
 }
-var place = (path, m) => isIdentityMatrix(m) ? path : _chunkGF2RBSDMcjs.transformBezierPath.call(void 0, path, m);
+var place2 = (path, m) => isIdentityMatrix(m) ? path : _chunkGF2RBSDMcjs.transformBezierPath.call(void 0, path, m);
 function vectorMaskRegionShapes(node, type, parent = IDENTITY_MATRIX, self = true) {
   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', _93 => _93.effects, 'optionalAccess', _94 => _94.length])) {
+  if (isVectorMaskActive(node) || node.type === "group" && _optionalChain([node, 'access', _203 => _203.effects, 'optionalAccess', _204 => _204.length])) {
     return vectorAppearanceShapes(node).flatMap((s) => regionOfPath(s.path, s.source, type, m));
   }
   const drawn = expandVectorAppearance(node);
@@ -4214,17 +6435,17 @@ function vectorMaskRegionShapes(node, type, parent = IDENTITY_MATRIX, self = tru
 function regionOfPath(path, style, type, m) {
   if (!path.length) return [];
   const fillRule = _nullishCoalesce(style.fillRule, () => ( "nonzero"));
-  if (type === "clip") return [{ path: place(path, m), fillRule }];
+  if (type === "clip") return [{ path: place2(path, m), fillRule }];
   const out = [];
   let filled = false;
   for (const l of vectorPaintLayerNodes(style)) {
     if (!l.drawn) continue;
     if (l.kind === "fill") {
-      if (!filled) out.push({ path: place(path, m), fillRule });
+      if (!filled) out.push({ path: place2(path, m), fillRule });
       filled = true;
     } else if ((_nullishCoalesce(l.node.strokeWidth, () => ( 1))) > 0) {
       const area = vectorStrokeOutlinePath(path, l.node);
-      if (area.length) out.push({ path: place(area, m), fillRule: "nonzero" });
+      if (area.length) out.push({ path: place2(area, m), fillRule: "nonzero" });
     }
   }
   return out;
@@ -4406,7 +6627,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', _95 => _95[runs.length - 1], 'optionalAccess', _96 => _96.style]), () => ( fallback)) });
+    else out.push({ length: left2, style: _nullishCoalesce(_optionalChain([runs, 'access', _205 => _205[runs.length - 1], 'optionalAccess', _206 => _206.style]), () => ( fallback)) });
   }
   return compact(out);
 }
@@ -4416,7 +6637,7 @@ function styleAt(runs, index, fallback) {
     if (index < at2 + r.length) return r.style;
     at2 += r.length;
   }
-  return _nullishCoalesce(_optionalChain([runs, 'access', _97 => _97[runs.length - 1], 'optionalAccess', _98 => _98.style]), () => ( fallback));
+  return _nullishCoalesce(_optionalChain([runs, 'access', _207 => _207[runs.length - 1], 'optionalAccess', _208 => _208.style]), () => ( fallback));
 }
 function restyleRange(runs, start, end, patch) {
   const out = [];
@@ -4472,7 +6693,7 @@ function paragraphRanges(text) {
   return out;
 }
 function fitParagraphRuns(runs, text) {
-  const fallback = _nullishCoalesce(_optionalChain([runs, 'access', _99 => _99[0], 'optionalAccess', _100 => _100.style]), () => ( {}));
+  const fallback = _nullishCoalesce(_optionalChain([runs, 'access', _209 => _209[0], 'optionalAccess', _210 => _210.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 }];
 }
@@ -4522,7 +6743,7 @@ function textLineRect(l) {
 var layoutCache = /* @__PURE__ */ new WeakMap();
 function layoutText(layer, shaper) {
   let byShaper = layoutCache.get(layer);
-  const hit = _optionalChain([byShaper, 'optionalAccess', _101 => _101.get, 'call', _102 => _102(shaper.id)]);
+  const hit = _optionalChain([byShaper, 'optionalAccess', _211 => _211.get, 'call', _212 => _212(shaper.id)]);
   if (hit) return hit;
   const out = computeLayout(layer, shaper);
   if (!byShaper) {
@@ -4586,7 +6807,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', _103 => _103.up])) {
+          if (_optionalChain([prev, 'optionalAccess', _213 => _213.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;
@@ -4914,7 +7135,7 @@ function createCanvasTextShaper(options = {}) {
     return null;
   })));
   const canvas = make(1, 1);
-  const ctx = _optionalChain([canvas, 'optionalAccess', _104 => _104.getContext, 'call', _105 => _105("2d")]);
+  const ctx = _optionalChain([canvas, 'optionalAccess', _214 => _214.getContext, 'call', _215 => _215("2d")]);
   if (!ctx || typeof ctx.measureText !== "function") return null;
   const fallback = _nullishCoalesce(options.fallbackFamily, () => ( "sans-serif"));
   const available = /* @__PURE__ */ new Map();
@@ -4987,10 +7208,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', _106 => _106.fontFamily, 'optionalAccess', _107 => _107.en]))), () => ( Object.values(_nullishCoalesce(_optionalChain([names, 'optionalAccess', _108 => _108.fontFamily]), () => ( {})))[0])), () => ( "Font"));
-    const weight = _nullishCoalesce(_nullishCoalesce(e.weight, () => ( _optionalChain([e, 'access', _109 => _109.face, 'access', _110 => _110.tables, 'optionalAccess', _111 => _111.os2, 'optionalAccess', _112 => _112.usWeightClass]))), () => ( 400));
-    const italic = _nullishCoalesce(e.italic, () => ( Boolean((_nullishCoalesce(_optionalChain([e, 'access', _113 => _113.face, 'access', _114 => _114.tables, 'optionalAccess', _115 => _115.os2, 'optionalAccess', _116 => _116.fsSelection]), () => ( 0))) & 1)));
-    const postScript = _nullishCoalesce(_optionalChain([names, 'optionalAccess', _117 => _117.postScriptName, 'optionalAccess', _118 => _118.en]), () => ( Object.values(_nullishCoalesce(_optionalChain([names, 'optionalAccess', _119 => _119.postScriptName]), () => ( {})))[0]));
+    const family = _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(e.family, () => ( _optionalChain([names, 'optionalAccess', _216 => _216.fontFamily, 'optionalAccess', _217 => _217.en]))), () => ( Object.values(_nullishCoalesce(_optionalChain([names, 'optionalAccess', _218 => _218.fontFamily]), () => ( {})))[0])), () => ( "Font"));
+    const weight = _nullishCoalesce(_nullishCoalesce(e.weight, () => ( _optionalChain([e, 'access', _219 => _219.face, 'access', _220 => _220.tables, 'optionalAccess', _221 => _221.os2, 'optionalAccess', _222 => _222.usWeightClass]))), () => ( 400));
+    const italic = _nullishCoalesce(e.italic, () => ( Boolean((_nullishCoalesce(_optionalChain([e, 'access', _223 => _223.face, 'access', _224 => _224.tables, 'optionalAccess', _225 => _225.os2, 'optionalAccess', _226 => _226.fsSelection]), () => ( 0))) & 1)));
+    const postScript = _nullishCoalesce(_optionalChain([names, 'optionalAccess', _227 => _227.postScriptName, 'optionalAccess', _228 => _228.en]), () => ( Object.values(_nullishCoalesce(_optionalChain([names, 'optionalAccess', _229 => _229.postScriptName]), () => ( {})))[0]));
     return { face: e.face, family, key: family.toLowerCase(), weight, italic, postScript };
   });
   const fallbackKey = (_nullishCoalesce(options.fallback, () => ( entries[0].family))).toLowerCase();
@@ -5037,12 +7258,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', _120 => _120.vertical]) ? { kerning: true, vertical: true } : { kerning: true }).commands);
+      return toPath(pick(font).entry.face.getPath(text, x, y, font.size, _optionalChain([opts, 'optionalAccess', _230 => _230.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', _121 => _121.getVerticalMetrics, 'optionalCall', _122 => _122(char)]);
+      const v2 = _optionalChain([face, 'access', _231 => _231.getVerticalMetrics, 'optionalCall', _232 => _232(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 };
     },
@@ -5103,7 +7324,7 @@ function vectorTextHasOutlines() {
   return typeof getVectorTextShaper().outline === "function";
 }
 function vectorTextFamilies() {
-  return _nullishCoalesce(_optionalChain([getVectorTextShaper, 'call', _123 => _123(), 'access', _124 => _124.families, 'optionalCall', _125 => _125()]), () => ( ["sans-serif", "serif", "monospace"]));
+  return _nullishCoalesce(_optionalChain([getVectorTextShaper, 'call', _233 => _233(), 'access', _234 => _234.families, 'optionalCall', _235 => _235()]), () => ( ["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"];
@@ -5279,7 +7500,7 @@ function computeLayout2(node, shaper) {
   const fragments = [];
   const lines = [];
   let overflow = false;
-  const fillOf = (f) => _optionalChain([runs, 'access', _126 => _126.find, 'call', _127 => _127((r) => f.start >= r.start && f.start < r.end), 'optionalAccess', _128 => _128.fill]);
+  const fillOf = (f) => _optionalChain([runs, 'access', _236 => _236.find, 'call', _237 => _237((r) => f.start >= r.start && f.start < r.end), 'optionalAccess', _238 => _238.fill]);
   const styleOf = (f) => {
     const { color: _c, opacity: _o, postScriptName: _p, ...style } = f.style;
     return style;
@@ -5318,11 +7539,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', _129 => _129.paragraph, 'optionalAccess', _130 => _130.align]), () => ( "left"));
+    const align = _nullishCoalesce(_optionalChain([node, 'access', _239 => _239.paragraph, 'optionalAccess', _240 => _240.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', _131 => _131.ascent]), () => ( 0)), _nullishCoalesce(_optionalChain([line, 'optionalAccess', _132 => _132.descent]), () => ( 0)));
+    const baselineOffset = pathBaselineOffset(_nullishCoalesce(frame.baseline, () => ( "baseline")), _nullishCoalesce(_optionalChain([line, 'optionalAccess', _241 => _241.ascent]), () => ( 0)), _nullishCoalesce(_optionalChain([line, 'optionalAccess', _242 => _242.descent]), () => ( 0)));
     if (line) {
       const chars = line.chars.filter((c) => {
         const lo = block.text.charCodeAt(c.index);
@@ -5331,7 +7552,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', _133 => _133.advance]), () => ( 0)));
+        return c.advance + (_nullishCoalesce(_optionalChain([low, 'optionalAccess', _243 => _243.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);
@@ -5386,7 +7607,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', _134 => _134.ascent]), () => ( 0))), width: 0, height: (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _135 => _135.ascent]), () => ( 0))) + (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _136 => _136.descent]), () => ( 0))) };
+      bounds = { x: frame.x, y: frame.y - (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _244 => _244.ascent]), () => ( 0))), width: 0, height: (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _245 => _245.ascent]), () => ( 0))) + (_nullishCoalesce(_optionalChain([l, 'optionalAccess', _246 => _246.descent]), () => ( 0))) };
     }
   }
   return { shaper: shaper.id, glyphs, fragments, lines, origin, text, bounds, overflow, missingFonts: text.missingFonts };
@@ -5507,7 +7728,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', _137 => _137.fragments, 'access', _138 => _138[g2.fragment], 'optionalAccess', _139 => _139.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', _247 => _247.fragments, 'access', _248 => _248[g2.fragment], 'optionalAccess', _249 => _249.line]), () => ( 0)) };
   };
   if (node.frame.kind !== "path") {
     const c = caretAt(layout.text, index);
@@ -5647,7 +7868,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', _140 => _140.x])) && isNum(_optionalChain([a, 'optionalAccess', _141 => _141.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', _250 => _250.x])) && isNum(_optionalChain([a, 'optionalAccess', _251 => _251.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);
@@ -5665,7 +7886,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', _142 => _142.length])) return null;
+  if (!_optionalChain([runs, 'optionalAccess', _252 => _252.length])) return null;
   const cleaned = fitVectorTextRuns(
     runs.map((r) => ({ length: r.length, style: stripUndefined(r.style) })),
     text.length
@@ -5705,7 +7926,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', _143 => _143.runs, 'optionalAccess', _144 => _144.length])) {
+  if (_optionalChain([node, 'access', _253 => _253.runs, 'optionalAccess', _254 => _254.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));
@@ -5721,7 +7942,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', _145 => _145.runs, 'optionalAccess', _146 => _146.length]) && (keys.length || fill !== void 0)) {
+    if (_optionalChain([next2, 'access', _255 => _255.runs, 'optionalAccess', _256 => _256.length]) && (keys.length || fill !== void 0)) {
       const runs2 = normalizeVectorTextRuns(
         next2.text,
         next2.runs.map((r) => {
@@ -5766,7 +7987,7 @@ function bakeVectorTextGeometry(node, m) {
     ...s.baselineShift !== void 0 ? { baselineShift: s.baselineShift * k } : {}
   });
   const font = scaleStyle(node.font);
-  const runs = _optionalChain([node, 'access', _147 => _147.runs, 'optionalAccess', _148 => _148.map, 'call', _149 => _149((r) => ({ length: r.length, style: scaleStyle(r.style) }))]);
+  const runs = _optionalChain([node, 'access', _257 => _257.runs, 'optionalAccess', _258 => _258.map, 'call', _259 => _259((r) => ({ length: r.length, style: scaleStyle(r.style) }))]);
   const p = node.paragraph;
   const paragraph = p ? {
     ...p,
@@ -6055,7 +8276,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', _150 => _150.overrides, 'optionalAccess', _151 => _151.hidden]), () => ( [])));
+  const hidden = new Set(_nullishCoalesce(_optionalChain([node, 'access', _260 => _260.overrides, 'optionalAccess', _261 => _261.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));
@@ -6068,8 +8289,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', _152 => _152.filters, 'optionalAccess', _153 => _153.length])) group.filters = node.filters;
-  if (_optionalChain([node, 'access', _154 => _154.effects, 'optionalAccess', _155 => _155.length])) group.effects = node.effects;
+  if (_optionalChain([node, 'access', _262 => _262.filters, 'optionalAccess', _263 => _263.length])) group.filters = node.filters;
+  if (_optionalChain([node, 'access', _264 => _264.effects, 'optionalAccess', _265 => _265.length])) group.effects = node.effects;
   if (node.booleanOperation) group.booleanOperation = node.booleanOperation;
   if (node.blendStep) group.blendStep = true;
   return group;
@@ -6208,8 +8429,8 @@ function sanitizeVectorLens(value) {
   if (spec.color !== null) out.color = typeof r.color === "string" && parseVectorColor(r.color) ? r.color : spec.color;
   return out;
 }
-var hex22 = (v2) => Math.round(Math.min(1, Math.max(0, v2)) * 255).toString(16).padStart(2, "0");
-var formatRgba = (c) => c[3] >= 1 ? `#${hex22(c[0])}${hex22(c[1])}${hex22(c[2])}` : `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${Math.round(c[3] * 1e3) / 1e3})`;
+var hex23 = (v2) => Math.round(Math.min(1, Math.max(0, v2)) * 255).toString(16).padStart(2, "0");
+var formatRgba = (c) => c[3] >= 1 ? `#${hex23(c[0])}${hex23(c[1])}${hex23(c[2])}` : `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${Math.round(c[3] * 1e3) / 1e3})`;
 var luma = (c) => 0.2126 * c[0] + 0.7152 * c[1] + 0.0722 * c[2];
 var mix = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t, a[3]];
 var HEAT = [
@@ -6322,8 +8543,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', _156 => _156.source, 'access', _157 => _157.fills, 'optionalAccess', _158 => _158.map, 'call', _159 => _159((l) => ({ ...l, paint: _nullishCoalesce(mapVectorPaintColors(l.paint, recolour), () => ( null)) }))]);
-          const strokes = _optionalChain([shape, 'access', _160 => _160.source, 'access', _161 => _161.strokes, 'optionalAccess', _162 => _162.map, 'call', _163 => _163((l) => ({ ...l, paint: _nullishCoalesce(mapVectorPaintColors(l.paint, recolour), () => ( null)) }))]);
+          const fills = _optionalChain([shape, 'access', _266 => _266.source, 'access', _267 => _267.fills, 'optionalAccess', _268 => _268.map, 'call', _269 => _269((l) => ({ ...l, paint: _nullishCoalesce(mapVectorPaintColors(l.paint, recolour), () => ( null)) }))]);
+          const strokes = _optionalChain([shape, 'access', _270 => _270.source, 'access', _271 => _271.strokes, 'optionalAccess', _272 => _272.map, 'call', _273 => _273((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));
       }
@@ -6336,7 +8557,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', _164 => _164.strokes, 'optionalAccess', _165 => _165.length]), () => ( 0))) > 0 || node.stroke != null && node.stroke !== "none";
+  const stroked = (_nullishCoalesce(_optionalChain([node, 'access', _274 => _274.strokes, 'optionalAccess', _275 => _275.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,
@@ -6345,7 +8566,7 @@ function vectorLensDrawn(node) {
     ...node.transform ? { transform: node.transform } : {},
     ...node.opacity !== void 0 ? { opacity: node.opacity } : {},
     ...node.blendMode ? { blendMode: node.blendMode } : {},
-    ..._optionalChain([node, 'access', _166 => _166.filters, 'optionalAccess', _167 => _167.length]) ? { filters: node.filters } : {},
+    ..._optionalChain([node, 'access', _276 => _276.filters, 'optionalAccess', _277 => _277.length]) ? { filters: node.filters } : {},
     children
   };
   drawnCache2.set(node, out);
@@ -6631,15 +8852,15 @@ var BERN_INV = [
   [0, 0, 0, 1]
 ];
 var pct = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? Math.min(1, Math.max(-1, v2 / 100)) : 0;
-function warpPresetMesh(preset, bounds) {
-  if (!WARP_STYLES.includes(preset.style)) return null;
+function warpPresetMesh(preset2, bounds) {
+  if (!WARP_STYLES.includes(preset2.style)) return null;
   const { x, y, width: w, height: h } = bounds;
   if (!(w > 0 && h > 0)) return null;
-  const b = pct(preset.bend);
-  const hd = pct(preset.horizontal);
-  const vd = pct(preset.vertical);
+  const b = pct(preset2.bend);
+  const hd = pct(preset2.horizontal);
+  const vd = pct(preset2.vertical);
   if (b === 0 && hd === 0 && vd === 0) return null;
-  const grid = warpPresetGrid(preset.style, b, hd, vd, preset.orientation === "vertical", h / w);
+  const grid = warpPresetGrid(preset2.style, b, hd, vd, preset2.orientation === "vertical", h / w);
   return { us: [0, 1], vs: [0, 1], points: grid.flat().map((p) => ({ x: x + p[0] * w, y: y + p[1] * h })) };
 }
 var warpMeshColumns = (m) => 3 * (m.us.length - 1) + 1;
@@ -7308,8 +9529,8 @@ var VECTOR_EFFECT_PARAM_SPECS = {
 var cloneMesh = (m) => ({ us: m.us.slice(), vs: m.vs.slice(), points: m.points.map((p) => ({ x: p.x, y: p.y })) });
 function vectorEnvelopeMesh(params, bounds) {
   if (params.style === "mesh") return _nullishCoalesce(params.mesh, () => ( identityWarpMesh(bounds, params.columns, params.rows)));
-  const preset = warpPresetMesh({ style: params.style, bend: params.bend, horizontal: params.horizontal, vertical: params.vertical, orientation: params.orientation }, bounds);
-  return preset ? resizeWarpMesh(preset, params.columns, params.rows) : identityWarpMesh(bounds, params.columns, params.rows);
+  const preset2 = warpPresetMesh({ style: params.style, bend: params.bend, horizontal: params.horizontal, vertical: params.vertical, orientation: params.orientation }, bounds);
+  return preset2 ? resizeWarpMesh(preset2, params.columns, params.rows) : identityWarpMesh(bounds, params.columns, params.rows);
 }
 function vectorEnvelopeMap(params, bounds) {
   if (!bounds || !(bounds.width > 0 && bounds.height > 0)) return null;
@@ -7346,7 +9567,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', _168 => _168[spec.key]]);
+    const v2 = _optionalChain([params, 'optionalAccess', _278 => _278[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;
@@ -7358,7 +9579,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', _169 => _169.mesh]);
+    const given = _optionalChain([params, 'optionalAccess', _279 => _279.mesh]);
     let mesh = given !== void 0 ? isValidWarpMesh(given) ? cloneMesh(given) : null : o.mesh;
     if (o.style !== "mesh") mesh = null;
     if (mesh && given !== void 0) {
@@ -7375,10 +9596,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', _170 => _170.effects, 'optionalAccess', _171 => _171.filter, 'call', _172 => _172(isEnabled)]), () => ( []));
+  return _nullishCoalesce(_optionalChain([node, 'access', _280 => _280.effects, 'optionalAccess', _281 => _281.filter, 'call', _282 => _282(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', _173 => _173.effects, 'optionalAccess', _174 => _174.some, 'call', _175 => _175(isEnabled)]);
+  return node.type === "text" || node.type === "instance" || node.type === "group" && !!node.liveBoolean || isVectorFrame(node) || isVectorSymmetryGroup(node) || isVectorLens(node) || !!_optionalChain([node, 'access', _283 => _283.effects, 'optionalAccess', _284 => _284.some, 'call', _285 => _285(isEnabled)]);
 }
 var liveCache = /* @__PURE__ */ new WeakMap();
 function hasVectorAppearance(node) {
@@ -7390,18 +9611,18 @@ function hasVectorAppearance(node) {
   return v2;
 }
 function isVectorLiveBoolean(node) {
-  return _optionalChain([node, 'optionalAccess', _176 => _176.type]) === "group" && !!node.liveBoolean;
+  return _optionalChain([node, 'optionalAccess', _286 => _286.type]) === "group" && !!node.liveBoolean;
 }
 function vectorOperandOperation(group, child) {
   return _nullishCoalesce(_nullishCoalesce(child.booleanOperation, () => ( group.liveBoolean)), () => ( "union"));
 }
 var PATH_OPS = { union: "union", subtract: "difference", intersect: "intersection", exclude: "xor" };
-var FoldCache = (_class = class {
-  constructor(cap) {;_class.prototype.__init.call(this);
+var FoldCache = (_class9 = class {
+  constructor(cap) {;_class9.prototype.__init60.call(this);
     this.cap = cap;
   }
   
-  __init() {this.map = /* @__PURE__ */ new Map()}
+  __init60() {this.map = /* @__PURE__ */ new Map()}
   get(key) {
     const hit = this.map.get(key);
     if (hit) {
@@ -7423,7 +9644,7 @@ var FoldCache = (_class = class {
   clear() {
     this.map.clear();
   }
-}, _class);
+}, _class9);
 var foldCache = new FoldCache(4096);
 var foldSteps = 0;
 function vectorLiveBooleanSteps() {
@@ -7432,9 +9653,9 @@ function vectorLiveBooleanSteps() {
 function clearVectorLiveBooleanCache() {
   foldCache.clear();
 }
-var RollingHash = (_class2 = class _RollingHash {constructor() { _class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this); }
-  __init2() {this.a = 2166136261}
-  __init3() {this.b = 16777619 ^ 1540483477}
+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}
   static __initStatic() {this.view = new DataView(new ArrayBuffer(8))}
   byte(v2) {
     this.a = Math.imul(this.a ^ v2 & 255, 16777619);
@@ -7464,7 +9685,7 @@ var RollingHash = (_class2 = class _RollingHash {constructor() { _class2.prototy
   key() {
     return `${(this.a >>> 0).toString(36)}.${(this.b >>> 0).toString(36)}`;
   }
-}, _class2.__initStatic(), _class2);
+}, _class10.__initStatic(), _class10);
 function foldVectorBooleanOperands(operands) {
   if (!operands.length) return [];
   if (operands.length === 1) return operands[0].path;
@@ -7507,7 +9728,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', _177 => _177.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _178 => _178.y]), () => ( 0))) });
+var add3 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _287 => _287.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _288 => _288.y]), () => ( 0))) });
 var mapPaths = (shapes, fn) => {
   const out = fn(shapes.map((s) => s.path));
   return shapes.map((s, i) => ({ ...s, path: _nullishCoalesce(out[i], () => ( [])) }));
@@ -7535,7 +9756,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', _179 => _179.length])) break;
+      if (!_optionalChain([path, 'optionalAccess', _289 => _289.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] });
@@ -7610,8 +9831,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', _180 => _180.length])) out.push({ ...s, source: fillOnly, path: middle, order: [...s.order, 2] });
-    const hasStroke = _optionalChain([s, 'access', _181 => _181.source, 'access', _182 => _182.strokes, 'optionalAccess', _183 => _183.length]) || s.source.stroke != null && s.source.stroke !== "none";
+    if (_optionalChain([middle, 'optionalAccess', _290 => _290.length])) out.push({ ...s, source: fillOnly, path: middle, order: [...s.order, 2] });
+    const hasStroke = _optionalChain([s, 'access', _291 => _291.source, 'access', _292 => _292.strokes, 'optionalAccess', _293 => _293.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;
@@ -7744,10 +9965,10 @@ function vectorEffectInputBounds(node, effectId) {
   return paths ? pathsBounds(paths) : null;
 }
 function vectorNodeEnvelope(node) {
-  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _184 => _184.effects, 'optionalAccess', _185 => _185.find, 'call', _186 => _186((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
+  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _294 => _294.effects, 'optionalAccess', _295 => _295.find, 'call', _296 => _296((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
 }
 function vectorEnvelopeFrame(node, effectId) {
-  const e = effectId ? _optionalChain([node, 'access', _187 => _187.effects, 'optionalAccess', _188 => _188.find, 'call', _189 => _189((x) => x.id === effectId)]) : vectorNodeEnvelope(node);
+  const e = effectId ? _optionalChain([node, 'access', _297 => _297.effects, 'optionalAccess', _298 => _298.find, 'call', _299 => _299((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;
@@ -7808,7 +10029,7 @@ function placement(node) {
     ...node.blendStep ? { blendStep: true } : {},
     ...node.booleanOperation ? { booleanOperation: node.booleanOperation } : {},
     ...node.blendMode ? { blendMode: node.blendMode } : {},
-    ..._optionalChain([node, 'access', _190 => _190.filters, 'optionalAccess', _191 => _191.length]) ? { filters: node.filters } : {}
+    ..._optionalChain([node, 'access', _300 => _300.filters, 'optionalAccess', _301 => _301.length]) ? { filters: node.filters } : {}
   };
 }
 function vectorAppearanceNodes(node) {
@@ -7940,7 +10161,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', _192 => _192.runs, 'optionalAccess', _193 => _193.length])) return { ...node, text: map(node.text) };
+  if (!_optionalChain([node, 'access', _302 => _302.runs, 'optionalAccess', _303 => _303.length])) return { ...node, text: map(node.text) };
   let at2 = 0;
   let text = "";
   const runs = [];
@@ -7963,7 +10184,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', _194 => _194.get, 'call', _195 => _195(key)]);
+  const hit = _optionalChain([byKey, 'optionalAccess', _304 => _304.get, 'call', _305 => _305(key)]);
   if (hit) return hit;
   const art = master.children.filter((c) => c.visible !== false).map((c) => {
     const box = vectorNodeBounds(c);
@@ -8008,7 +10229,7 @@ function stripVectorMasterArt(doc) {
 // src/vector/connectors.ts
 var SIDES = ["top", "right", "bottom", "left", "center"];
 function isVectorConnector(node) {
-  return _optionalChain([node, 'optionalAccess', _196 => _196.type]) === "path" && !!node.connector;
+  return _optionalChain([node, 'optionalAccess', _306 => _306.type]) === "path" && !!node.connector;
 }
 function vectorConnectionSites(nodes, id) {
   const node = findVectorNode(nodes, id);
@@ -8065,7 +10286,7 @@ function facingSite(sites, toward) {
 }
 function storedEnds(node, world) {
   const sp = node.subpaths[0];
-  if (!_optionalChain([sp, 'optionalAccess', _197 => _197.anchors, 'access', _198 => _198.length])) return null;
+  if (!_optionalChain([sp, 'optionalAccess', _307 => _307.anchors, 'access', _308 => _308.length])) return null;
   const a = sp.anchors[0];
   const b = sp.anchors[sp.anchors.length - 1];
   return [applyMatrix(world, a), applyMatrix(world, b)];
@@ -8172,8 +10393,8 @@ function routeVectorConnector(nodes, id) {
   }));
   return {
     subpaths: [{ closed: false, anchors: local }],
-    startSide: _nullishCoalesce(_optionalChain([s, 'optionalAccess', _199 => _199.side]), () => ( null)),
-    endSide: _nullishCoalesce(_optionalChain([e, 'optionalAccess', _200 => _200.side]), () => ( null)),
+    startSide: _nullishCoalesce(_optionalChain([s, 'optionalAccess', _309 => _309.side]), () => ( null)),
+    endSide: _nullishCoalesce(_optionalChain([e, 'optionalAccess', _310 => _310.side]), () => ( null)),
     dropped: { start: !!startGlue && !s, end: !!endGlue && !e }
   };
 }
@@ -8185,7 +10406,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', _201 => _201.corner, 'optionalAccess', _202 => _202.radius]), () => ( 0))) === (_nullishCoalesce(_optionalChain([q, 'access', _203 => _203.corner, 'optionalAccess', _204 => _204.radius]), () => ( 0)));
+      return samePoint(p, q) && samePoint(p.in, q.in) && samePoint(p.out, q.out) && (_nullishCoalesce(_optionalChain([p, 'access', _311 => _311.corner, 'optionalAccess', _312 => _312.radius]), () => ( 0))) === (_nullishCoalesce(_optionalChain([q, 'access', _313 => _313.corner, 'optionalAccess', _314 => _314.radius]), () => ( 0)));
     });
   });
 }
@@ -8295,7 +10516,7 @@ var add4 = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
 var sub4 = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
 var scale2 = (a, k) => ({ x: a.x * k, y: a.y * k });
 var left = (d) => ({ x: d.y, y: -d.x });
-var unit3 = (v2) => {
+var unit4 = (v2) => {
   const l = Math.hypot(v2.x, v2.y);
   return l > 1e-12 ? { x: v2.x / l, y: v2.y / l } : { x: 1, y: 0 };
 };
@@ -8352,7 +10573,7 @@ function vectorStrokeGradientDefs(g, id, node, options = {}) {
     for (let i = 0; i < segCount; i++) {
       const a = pts[i];
       const b = pts[(i + 1) % n];
-      dirs.push(unit3(sub4(b, a)));
+      dirs.push(unit4(sub4(b, a)));
       lengths.push(lengths[i] + Math.hypot(b.x - a.x, b.y - a.y));
     }
     const total = lengths[segCount];
@@ -8446,7 +10667,7 @@ var parseJson = (text) => {
   if (text === void 0) return null;
   try {
     return JSON.parse(text);
-  } catch (e5) {
+  } catch (e7) {
     return null;
   }
 };
@@ -8464,7 +10685,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', _205 => _205[+m[1]], 'optionalAccess', _206 => _206.anchors, 'access', _207 => _207[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _315 => _315[+m[1]], 'optionalAccess', _316 => _316.anchors, 'access', _317 => _317[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -8489,7 +10710,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', _208 => _208.get, 'call', _209 => _209(key2)]);
+    const hit = _optionalChain([byKey2, 'optionalAccess', _318 => _318.get, 'call', _319 => _319(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());
@@ -8501,7 +10722,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', _210 => _210.get, 'call', _211 => _211(owner), 'optionalAccess', _212 => _212.get, 'call', _213 => _213(key)]);
+  const cached = _optionalChain([paintCache, 'access', _320 => _320.get, 'call', _321 => _321(owner), 'optionalAccess', _322 => _322.get, 'call', _323 => _323(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;
@@ -8555,7 +10776,7 @@ function vectorNodeLocalPaintBounds(node) {
 }
 var filterCache = /* @__PURE__ */ new WeakMap();
 function vectorNodeFilterSvg(node, id) {
-  if (!_optionalChain([node, 'access', _214 => _214.filters, 'optionalAccess', _215 => _215.length])) return null;
+  if (!_optionalChain([node, 'access', _324 => _324.filters, 'optionalAccess', _325 => _325.length])) return null;
   const hit = filterCache.get(node);
   if (hit && hit.id === id) return hit.filter;
   const active = activeVectorFilters(node);
@@ -8595,7 +10816,7 @@ function blendFromAttribute(value, m) {
   let raw;
   try {
     raw = JSON.parse(value);
-  } catch (e6) {
+  } catch (e8) {
     return null;
   }
   if (!raw || typeof raw !== "object") return null;
@@ -8641,7 +10862,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', _216 => _216.filters, 'optionalAccess', _217 => _217.length])) {
+    if (_optionalChain([node, 'access', _326 => _326.filters, 'optionalAccess', _327 => _327.length])) {
       const filter = vectorNodeFilterSvg(node, `${prefix}filter-${node.id}`);
       const data = ` data-vector-filters="${escapeAttr2(JSON.stringify(node.filters))}"`;
       if (filter) {
@@ -8688,7 +10909,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', _218 => _218.strokeDasharray, 'optionalAccess', _219 => _219.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num3).join(" ")}"`;
+    if (_optionalChain([node, 'access', _328 => _328.strokeDasharray, 'optionalAccess', _329 => _329.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num3).join(" ")}"`;
     return out2;
   };
   const liveCorners = (node) => {
@@ -8710,7 +10931,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     for (const l of layers) {
       if (l.kind === "stroke" && isVectorBrushstrokeLayer(l.layer)) {
         lines.push(`${indent(depth + 1)}<g data-vector-part="brushstroke" data-vector-layer="${l.index}"${layerAttrs(l.layer)}>`);
-        for (const im of vectorBrushstrokeImages(node, l.layer)) lines.push(`${indent(depth + 2)}<image href="${im.href}" x="${num3(im.x)}" y="${num3(im.y)}" width="${num3(im.width)}" height="${num3(im.height)}" preserveAspectRatio="none"/>`);
+        for (const im of vectorBrushstrokeImages(node, l.layer, { document: doc, settle: "now" })) lines.push(`${indent(depth + 2)}<image href="${im.href}" x="${num3(im.x)}" y="${num3(im.y)}" width="${num3(im.width)}" height="${num3(im.height)}" preserveAspectRatio="none"/>`);
         lines.push(`${indent(depth + 1)}</g>`);
         continue;
       }
@@ -8737,7 +10958,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emit2 = (node, depth) => {
     if (node.visible === false && !options.includeHidden) return;
-    const wrappers = _nullishCoalesce(_optionalChain([options, 'access', _220 => _220.wrap, 'optionalAccess', _221 => _221[node.id]]), () => ( []));
+    const wrappers = _nullishCoalesce(_optionalChain([options, 'access', _330 => _330.wrap, 'optionalAccess', _331 => _331[node.id]]), () => ( []));
     wrappers.forEach((w2, i) => {
       let attrs = w2.id !== void 0 ? ` id="${escapeAttr2(w2.id)}"` : "";
       if (w2.transform) attrs += ` transform="${escapeAttr2(w2.transform)}"`;
@@ -8758,7 +10979,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emitMaskGroup = (node, depth) => {
     const [source, ...contents] = node.children;
-    const body = _optionalChain([node, 'access', _222 => _222.effects, 'optionalAccess', _223 => _223.length]) && contents.length ? [{ id: `${node.id}~content`, type: "group", effects: node.effects, children: contents }] : contents;
+    const body = _optionalChain([node, 'access', _332 => _332.effects, 'optionalAccess', _333 => _333.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);
@@ -8775,7 +10996,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', _224 => _224.clip])) {
+      if (_optionalChain([mask, 'optionalAccess', _334 => _334.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)})"`;
       }
@@ -8787,7 +11008,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', _225 => _225.runs, 'optionalAccess', _226 => _226.length]) ? { runs: node.runs } : {}, ...node.paragraph ? { paragraph: node.paragraph } : {}, frame: node.frame, ...node.orientation ? { orientation: node.orientation } : {}, ..._optionalChain([node, 'access', _227 => _227.effects, 'optionalAccess', _228 => _228.length]) ? { effects: node.effects } : {} };
+    const fields = { text: node.text, font: node.font, ..._optionalChain([node, 'access', _335 => _335.runs, 'optionalAccess', _336 => _336.length]) ? { runs: node.runs } : {}, ...node.paragraph ? { paragraph: node.paragraph } : {}, frame: node.frame, ...node.orientation ? { orientation: node.orientation } : {}, ..._optionalChain([node, 'access', _337 => _337.effects, 'optionalAccess', _338 => _338.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 {
@@ -8829,12 +11050,12 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emitText = (node, depth) => {
     const outlines = vectorTextPaths(node).outlines;
-    const effects = !!_optionalChain([node, 'access', _229 => _229.effects, 'optionalAccess', _230 => _230.some, 'call', _231 => _231((e) => e.enabled !== false)]);
+    const effects = !!_optionalChain([node, 'access', _339 => _339.effects, 'optionalAccess', _340 => _340.some, 'call', _341 => _341((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', _232 => _232.effects, 'optionalAccess', _233 => _233.length]) ? { effects: node.effects } : {} }))}">`);
+    lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr2(JSON.stringify({ kind: "text", ..._optionalChain([node, 'access', _342 => _342.effects, 'optionalAccess', _343 => _343.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>`);
@@ -8848,7 +11069,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   const symbolRef = (symbolId) => {
     const hit = symbolIds.get(symbolId);
     if (hit) return hit;
-    const sym2 = _optionalChain([doc, 'access', _234 => _234.symbols, 'optionalAccess', _235 => _235.find, 'call', _236 => _236((x) => x.id === symbolId)]);
+    const sym2 = _optionalChain([doc, 'access', _344 => _344.symbols, 'optionalAccess', _345 => _345.find, 'call', _346 => _346((x) => x.id === symbolId)]);
     if (!sym2) return null;
     const id = `${prefix}symbol-${symbolId}`;
     symbolIds.set(symbolId, id);
@@ -8858,20 +11079,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', _237 => _237.effects, 'optionalAccess', _238 => _238.length]) && !_optionalChain([node, 'access', _239 => _239.filters, 'optionalAccess', _240 => _240.length]);
+    const exact2 = !node.overrides && node.scaleStrokes !== false && !_optionalChain([node, 'access', _347 => _347.effects, 'optionalAccess', _348 => _348.length]) && !_optionalChain([node, 'access', _349 => _349.filters, 'optionalAccess', _350 => _350.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', _241 => _241.effects, 'optionalAccess', _242 => _242.length]) ? { effects: node.effects } : {} };
+    const full = { ...data, ...node.transform ? { transform: node.transform } : {}, ..._optionalChain([node, 'access', _351 => _351.effects, 'optionalAccess', _352 => _352.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', _243 => _243.effects, 'optionalAccess', _244 => _244.length]) ? { effects: node.effects } : {} };
+    const data = { ...f, ..._optionalChain([node, 'access', _353 => _353.effects, 'optionalAccess', _354 => _354.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") {
@@ -8886,7 +11107,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', _245 => _245.masterArt, 'optionalAccess', _246 => _246.length])) {
+    if (_optionalChain([node, 'access', _355 => _355.masterArt, 'optionalAccess', _356 => _356.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>`);
@@ -8915,7 +11136,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (hasOwnVectorAppearance(node)) {
       const live2 = {
         kind: node.type,
-        ..._optionalChain([node, 'access', _247 => _247.effects, 'optionalAccess', _248 => _248.length]) ? { effects: node.effects } : {},
+        ..._optionalChain([node, 'access', _357 => _357.effects, 'optionalAccess', _358 => _358.length]) ? { effects: node.effects } : {},
         ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {},
         ...node.type === "group" && node.symmetry ? { symmetry: node.symmetry } : {}
       };
@@ -8966,7 +11187,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', _249 => _249.strokeDasharray, 'optionalAccess', _250 => _250.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num3).join(" ")}"`;
+      if (_optionalChain([node, 'access', _359 => _359.strokeDasharray, 'optionalAccess', _360 => _360.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}/>`);
@@ -9147,7 +11368,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', _251 => _251.length])) {
+  if (_optionalChain([cssRules, 'optionalAccess', _361 => _361.length])) {
     for (const rule of cssRules) {
       if (matchesSelector(el, rule.selector)) {
         for (const [prop, val] of Object.entries(rule.properties)) {
@@ -9203,7 +11424,7 @@ function attrOrStyle(el, name) {
   return el.attrs[name];
 }
 function urlId(value) {
-  return _nullishCoalesce(_optionalChain([/^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/, 'access', _252 => _252.exec, 'call', _253 => _253((_nullishCoalesce(value, () => ( ""))).trim()), 'optionalAccess', _254 => _254[1]]), () => ( null));
+  return _nullishCoalesce(_optionalChain([/^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/, 'access', _362 => _362.exec, 'call', _363 => _363((_nullishCoalesce(value, () => ( ""))).trim()), 'optionalAccess', _364 => _364[1]]), () => ( null));
 }
 function clipRulesAsFillRules(el) {
   const attrs = { ...el.attrs };
@@ -9220,7 +11441,7 @@ function filtersFromElement(el) {
   if (own !== void 0) {
     try {
       return sanitizeVectorFilters(JSON.parse(own));
-    } catch (e7) {
+    } catch (e9) {
       return [];
     }
   }
@@ -9254,7 +11475,7 @@ function gradientFromAttribute(value) {
   if (!value) return null;
   try {
     return sanitizeVectorGradient(JSON.parse(value));
-  } catch (e8) {
+  } catch (e10) {
     return null;
   }
 }
@@ -9268,9 +11489,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', _255 => _255.startsWith, 'call', _256 => _256("#")]) ? raw.get(href.slice(1)) : void 0;
+    el = _optionalChain([href, 'optionalAccess', _365 => _365.startsWith, 'call', _366 => _366("#")]) ? raw.get(href.slice(1)) : void 0;
   }
-  const attr = (name) => _optionalChain([chain, 'access', _257 => _257.find, 'call', _258 => _258((el) => el.attrs[name] !== void 0), 'optionalAccess', _259 => _259.attrs, 'access', _260 => _260[name]]);
+  const attr = (name) => _optionalChain([chain, 'access', _367 => _367.find, 'call', _368 => _368((el) => el.attrs[name] !== void 0), 'optionalAccess', _369 => _369.attrs, 'access', _370 => _370[name]]);
   const stops = _nullishCoalesce(chain.map(readStops).find((s) => s.length), () => ( []));
   if (!stops.length) return null;
   const user = attr("gradientUnits") === "userSpaceOnUse";
@@ -9442,11 +11663,11 @@ 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', _261 => _261.length])) return null;
+    if (!_optionalChain([subpaths, 'optionalAccess', _371 => _371.length])) return null;
     const parse = (v2) => {
       try {
         return v2 ? JSON.parse(v2) : [];
-      } catch (e9) {
+      } catch (e11) {
         return [];
       }
     };
@@ -9461,7 +11682,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', _262 => _262.type]) === "path" && n.type === "path" && key(prev) === key(n)) {
+      if (_optionalChain([prev, 'optionalAccess', _372 => _372.type]) === "path" && n.type === "path" && key(prev) === key(n)) {
         const fills = vectorFills(n);
         const strokesBefore = vectorStrokes(prev);
         if (!(fills.length && strokesBefore.length)) {
@@ -9479,7 +11700,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', _263 => _263.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _373 => _373.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style, styleRules);
     const strokeEl = part("stroke");
@@ -9516,7 +11737,7 @@ function parseVectorSvg(svg, options = {}) {
       ...profile.length ? { strokeWidthProfile: profile } : {},
       ...keptCap ? { strokeLinecap: keptCap } : {},
       ...keptJoin ? { strokeLinejoin: keptJoin } : {},
-      ..._optionalChain([keptDash, 'optionalAccess', _264 => _264.length]) ? { strokeDasharray: keptDash } : {}
+      ..._optionalChain([keptDash, 'optionalAccess', _374 => _374.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
@@ -9524,7 +11745,7 @@ function parseVectorSvg(svg, options = {}) {
     let raw = {};
     try {
       raw = _nullishCoalesce(JSON.parse(g.attrs["data-vector-live"]), () => ( {}));
-    } catch (e10) {
+    } catch (e12) {
       raw = {};
     }
     const sourceEl = g.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === "source");
@@ -9560,7 +11781,7 @@ function parseVectorSvg(svg, options = {}) {
   const json2 = (v2) => {
     try {
       return v2 === void 0 ? void 0 : JSON.parse(v2);
-    } catch (e11) {
+    } catch (e13) {
       return void 0;
     }
   };
@@ -9570,7 +11791,7 @@ function parseVectorSvg(svg, options = {}) {
     let fields;
     try {
       fields = sanitizeVectorTextFields(raw);
-    } catch (e12) {
+    } catch (e14) {
       return null;
     }
     const effects = sanitizeVectorEffects(raw.effects);
@@ -9581,8 +11802,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', _265 => _265([{ paint: fill }]), 'access', _266 => _266[0], 'optionalAccess', _267 => _267.paint]), () => ( null));
-      node.stroke = stroke == null ? null : _nullishCoalesce(_optionalChain([sanitizeVectorFills, 'call', _268 => _268([{ paint: stroke }]), 'access', _269 => _269[0], 'optionalAccess', _270 => _270.paint]), () => ( null));
+      node.fill = fill == null ? null : _nullishCoalesce(_optionalChain([sanitizeVectorFills, 'call', _375 => _375([{ paint: fill }]), 'access', _376 => _376[0], 'optionalAccess', _377 => _377.paint]), () => ( null));
+      node.stroke = stroke == null ? null : _nullishCoalesce(_optionalChain([sanitizeVectorFills, 'call', _378 => _378([{ paint: stroke }]), 'access', _379 => _379[0], 'optionalAccess', _380 => _380.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 }]);
@@ -9618,8 +11839,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', _271 => _271.attrs, 'access', _272 => _272.x]));
-    const y = el.attrs.y !== void 0 ? first0(el.attrs.y) : first0(_optionalChain([tspan, 'optionalAccess', _273 => _273.attrs, 'access', _274 => _274.y]));
+    const x = el.attrs.x !== void 0 ? first0(el.attrs.x) : first0(_optionalChain([tspan, 'optionalAccess', _381 => _381.attrs, 'access', _382 => _382.x]));
+    const y = el.attrs.y !== void 0 ? first0(el.attrs.y) : first0(_optionalChain([tspan, 'optionalAccess', _383 => _383.attrs, 'access', _384 => _384.y]));
     const fillValue = _nullishCoalesce(attrOrStyle(el, "fill"), () => ( style.fill));
     let node = {
       id: idFor(el),
@@ -9650,12 +11871,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', _275 => _275.id]) === "string" && own.id ? own.id : _nullishCoalesce(el.attrs.id, () => ( createId()));
+    let id = typeof _optionalChain([own, 'optionalAccess', _385 => _385.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', _276 => _276.name]) === "string" && own.name ? own.name : _nullishCoalesce(el.attrs.id, () => ( "Symbol")), nodes: nodes2 });
+    symbols.push({ id, name: typeof _optionalChain([own, 'optionalAccess', _386 => _386.name]) === "string" && own.name ? own.name : _nullishCoalesce(el.attrs.id, () => ( "Symbol")), nodes: nodes2 });
     symbolOfElement.set(el, id);
     return id;
   };
@@ -9666,22 +11887,22 @@ function parseVectorSvg(svg, options = {}) {
     const symbolId = symbolFor(target);
     if (!symbolId) return null;
     const own = json2(el.attrs["data-vector-instance"]);
-    const place2 = multiplyMatrices(translateMatrix(length(el.attrs.x), length(el.attrs.y)), m);
-    const node = { id: idFor(el), type: "instance", ...meta, symbolId, ..._optionalChain([own, 'optionalAccess', _277 => _277.scaleStrokes]) === false ? { scaleStrokes: false } : {}, ..._optionalChain([own, 'optionalAccess', _278 => _278.overrides]) ? { overrides: own.overrides } : {} };
-    return isIdentityMatrix(place2) ? node : { ...node, transform: place2 };
+    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', _387 => _387.scaleStrokes]) === false ? { scaleStrokes: false } : {}, ..._optionalChain([own, 'optionalAccess', _388 => _388.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', _279 => _279(e.attrs["data-vector-symbol"]), 'optionalAccess', _280 => _280.id]) === raw.symbolId);
+    const sym2 = [...byId.values()].find((e) => e.name === "symbol" && _optionalChain([json2, 'call', _389 => _389(e.attrs["data-vector-symbol"]), 'optionalAccess', _390 => _390.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;
-    const place2 = multiplyMatrices(t, m);
+    const place3 = multiplyMatrices(t, m);
     const drawn = g.children.find((c) => c.name === "g");
     const effects = sanitizeVectorEffects(raw.effects);
     const node = {
-      id: _nullishCoalesce(_optionalChain([drawn, 'optionalAccess', _281 => _281.attrs, 'access', _282 => _282.id]), () => ( idFor(g))),
+      id: _nullishCoalesce(_optionalChain([drawn, 'optionalAccess', _391 => _391.attrs, 'access', _392 => _392.id]), () => ( idFor(g))),
       type: "instance",
       ...meta,
       symbolId,
@@ -9700,7 +11921,7 @@ function parseVectorSvg(svg, options = {}) {
       if (drawn.attrs.display === "none") node.visible = false;
       usedIds.add(node.id);
     }
-    return isIdentityMatrix(place2) ? node : { ...node, transform: place2 };
+    return isIdentityMatrix(place3) ? node : { ...node, transform: place3 };
   };
   const visit2 = (el, style, matrix) => {
     const out = [];
@@ -9738,12 +11959,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', _283 => _283.name]) === "clipPath") {
+    if (_optionalChain([clipEl, 'optionalAccess', _393 => _393.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', _284 => _284.name]) === "mask") {
+    if (_optionalChain([maskEl, 'optionalAccess', _394 => _394.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] }];
@@ -9754,7 +11975,7 @@ function parseVectorSvg(svg, options = {}) {
     let raw = null;
     try {
       raw = JSON.parse(g.attrs["data-vector-mask"]);
-    } catch (e13) {
+    } catch (e15) {
       raw = null;
     }
     const mask = sanitizeVectorMask(raw);
@@ -9765,19 +11986,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', _285 => _285.children, 'access', _286 => _286.find, 'call', _287 => _287((c) => c.name === "g" && c.attrs["data-vector-part"] === "mask-invert")]);
+      const invert2 = _optionalChain([el, 'optionalAccess', _395 => _395.children, 'access', _396 => _396.find, 'call', _397 => _397((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', _288 => _288.type]) === "group") {
+    if (_optionalChain([wrapper, 'optionalAccess', _398 => _398.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', _289 => _289.length]) ? { effects } : {}, children: [source, ...contents] };
+    return { id, type: "group", ...meta, mask, ..._optionalChain([effects, 'optionalAccess', _399 => _399.length]) ? { effects } : {}, children: [source, ...contents] };
   };
   const frameGroup = (g, style, m, meta) => {
     const raw = parseJson(g.attrs["data-vector-frame"]);
@@ -9789,7 +12010,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', _290 => _290.effects]));
+    const effects = sanitizeVectorEffects(_optionalChain([raw, 'optionalAccess', _400 => _400.effects]));
     return {
       id,
       type: "group",
@@ -9826,7 +12047,7 @@ function parseVectorSvg(svg, options = {}) {
     if (child.attrs["data-vector-generation"] !== void 0) {
       try {
         meta.generation = _chunkCVFAAZXEcjs.parseProvenance.call(void 0, parseJson(child.attrs["data-vector-generation"]));
-      } catch (e14) {
+      } catch (e16) {
       }
     }
     const lens = child.attrs["data-vector-lens"] !== void 0 ? sanitizeVectorLens(parseJson(child.attrs["data-vector-lens"])) : null;
@@ -10261,13 +12482,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', _291 => _291.entered, 'optionalAccess', _292 => _292.has, 'call', _293 => _293(node.id)]);
+    const entered = !!_optionalChain([options, 'access', _401 => _401.entered, 'optionalAccess', _402 => _402.has, 'call', _403 => _403(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', _294 => _294.entered, 'optionalAccess', _295 => _295.has, 'call', _296 => _296(node.id)])))) node = expandVectorAppearance(node);
+  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _404 => _404.entered, 'optionalAccess', _405 => _405.has, 'call', _406 => _406(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));
@@ -10279,7 +12500,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', _297 => _297.mask, 'optionalAccess', _298 => _298.type]) !== "clip") return hitTestVectorNode(source, p, tolerance, m, options);
+  if (_optionalChain([group, 'access', _407 => _407.mask, 'optionalAccess', _408 => _408.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) => {
@@ -10328,24 +12549,24 @@ function mapAnchor(a, m) {
 }
 function bakeIntoGeometry(node, m) {
   if (isIdentityMatrix(m)) return node;
-  if (_optionalChain([node, 'access', _299 => _299.effects, 'optionalAccess', _300 => _300.length])) node = { ...node, effects: transformVectorEffects(node.effects, m, node) };
+  if (_optionalChain([node, 'access', _409 => _409.effects, 'optionalAccess', _410 => _410.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', _301 => _301.blend, 'optionalAccess', _302 => _302.spine]);
+    const spine = _optionalChain([group, 'access', _411 => _411.blend, 'optionalAccess', _412 => _412.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', _303 => _303.strokeWidthProfile, 'optionalAccess', _304 => _304.length]);
+  const mirrored = flips && _optionalChain([path, 'access', _413 => _413.strokeWidthProfile, 'optionalAccess', _414 => _414.length]);
   const layer = (l) => ({
     ...l,
     ...isVectorGradient(l.paint) || isVectorShadedPaint(l.paint) ? { paint: transformVectorPaint(l.paint, m) } : {},
-    ...flips && _optionalChain([l, 'access', _305 => _305.strokeWidthProfile, 'optionalAccess', _306 => _306.length]) ? { strokeWidthProfile: mirrorWidthProfile(l.strokeWidthProfile) } : {}
+    ...flips && _optionalChain([l, 'access', _415 => _415.strokeWidthProfile, 'optionalAccess', _416 => _416.length]) ? { strokeWidthProfile: mirrorWidthProfile(l.strokeWidthProfile) } : {}
   });
   return {
     ...path,
@@ -10580,7 +12801,7 @@ function roundSubpaths(subpaths, precision = 3) {
 
 // src/vector/symmetry.ts
 function isVectorSymmetryGroup(node) {
-  return _optionalChain([node, 'optionalAccess', _307 => _307.type]) === "group" && !!node.symmetry && !node.blend && !node.liveBoolean && !node.mask && !node.frame;
+  return _optionalChain([node, 'optionalAccess', _417 => _417.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;
@@ -11169,4 +13390,58 @@ function transformVectorSymmetry(s, m) {
 
 
 
-exports.isVectorMeshGradient = isVectorMeshGradient; exports.isVectorFreeformGradient = isVectorFreeformGradient; exports.isVectorShadedPaint = isVectorShadedPaint; exports.vectorRgbaToCss = vectorRgbaToCss; exports.VECTOR_MESH_MAX = VECTOR_MESH_MAX; exports.createVectorMeshGradient = createVectorMeshGradient; exports.vectorMeshPointAt = vectorMeshPointAt; exports.vectorMeshColorAt = vectorMeshColorAt; exports.vectorMeshLines = vectorMeshLines; exports.vectorFreeformSpreadScale = vectorFreeformSpreadScale; exports.vectorFreeformLineSegments = vectorFreeformLineSegments; exports.vectorFreeformField = vectorFreeformField; exports.sampleVectorFreeform = sampleVectorFreeform; exports.autoVectorFreeformGradient = autoVectorFreeformGradient; exports.vectorShadedSvgDefs = vectorShadedSvgDefs; exports.mapVectorShadedPaint = mapVectorShadedPaint; exports.transformVectorShadedPaint = transformVectorShadedPaint; exports.sanitizeVectorShadedPaint = sanitizeVectorShadedPaint; exports.removeVectorFreeformPoint = removeVectorFreeformPoint; exports.nearestVectorShadingPoint = nearestVectorShadingPoint; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_GRADIENT_TYPES = VECTOR_GRADIENT_TYPES; exports.VECTOR_GRADIENT_SPREADS = VECTOR_GRADIENT_SPREADS; exports.VECTOR_GRADIENT_INTERPOLATIONS = VECTOR_GRADIENT_INTERPOLATIONS; exports.VECTOR_STROKE_GRADIENT_MODES = VECTOR_STROKE_GRADIENT_MODES; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_BLEND_MODES = VECTOR_BLEND_MODES; exports.VECTOR_HORIZONTAL_RESIZING = VECTOR_HORIZONTAL_RESIZING; exports.VECTOR_VERTICAL_RESIZING = VECTOR_VERTICAL_RESIZING; exports.VECTOR_LENS_TYPES = VECTOR_LENS_TYPES; exports.VECTOR_CONNECTOR_SIDES = VECTOR_CONNECTOR_SIDES; exports.VECTOR_CONNECTOR_ROUTES = VECTOR_CONNECTOR_ROUTES; exports.VECTOR_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; exports.VECTOR_MASK_TYPES = VECTOR_MASK_TYPES; exports.VECTOR_SYMMETRY_MODES = VECTOR_SYMMETRY_MODES; exports.VECTOR_TEXT_ALIGNS = VECTOR_TEXT_ALIGNS; exports.VECTOR_PATH_TEXT_BASELINES = VECTOR_PATH_TEXT_BASELINES; exports.VECTOR_PERSPECTIVE_PLANES = VECTOR_PERSPECTIVE_PLANES; exports.VECTOR_CONSTRAINT_KINDS = VECTOR_CONSTRAINT_KINDS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_EFFECT_TYPES = VECTOR_EFFECT_TYPES; exports.VECTOR_MERGE_MODES = VECTOR_MERGE_MODES; exports.VECTOR_FILTER_TYPES = VECTOR_FILTER_TYPES; exports.isVectorGradient = isVectorGradient; exports.parseVectorColor = parseVectorColor; exports.VECTOR_GRADIENT_MIN_STOPS = VECTOR_GRADIENT_MIN_STOPS; exports.gradientMidpointRemap = gradientMidpointRemap; exports.sortedVectorGradientStops = sortedVectorGradientStops; exports.vectorGradientNeedsExpansion = vectorGradientNeedsExpansion; exports.vectorGradientRamp = vectorGradientRamp; exports.sampleVectorGradient = sampleVectorGradient; exports.expandVectorGradientStops = expandVectorGradientStops; exports.samplePlainStops = samplePlainStops; exports.reverseVectorGradient = reverseVectorGradient; exports.insertVectorGradientStop = insertVectorGradientStop; exports.moveVectorGradientStop = moveVectorGradientStop; exports.removeVectorGradientStop = removeVectorGradientStop; exports.vectorGradientMidpointPosition = vectorGradientMidpointPosition; exports.vectorGradientMidpointFromPosition = vectorGradientMidpointFromPosition; exports.spanVectorGradientStops = spanVectorGradientStops; exports.hasExplicitGradientGeometry = hasExplicitGradientGeometry; exports.vectorGradientPoints = vectorGradientPoints; exports.vectorBoxMatrix = vectorBoxMatrix; exports.vectorGradientUnitsMatrix = vectorGradientUnitsMatrix; exports.vectorGradientMatrix = vectorGradientMatrix; exports.vectorGradientFocalParam = vectorGradientFocalParam; exports.vectorGradientParam = vectorGradientParam; exports.applyVectorGradientSpread = applyVectorGradientSpread; exports.vectorGradientTAt = vectorGradientTAt; exports.sampleVectorGradientAt = sampleVectorGradientAt; exports.vectorGradientAspect = vectorGradientAspect; exports.explicitVectorGradient = explicitVectorGradient; exports.pinVectorGradient = pinVectorGradient; exports.transformVectorGradient = transformVectorGradient; exports.mapVectorGradient = mapVectorGradient; exports.mapVectorPaint = mapVectorPaint; exports.transformVectorPaint = transformVectorPaint; exports.isCentredVectorGradient = isCentredVectorGradient; exports.vectorGradientHandles = vectorGradientHandles; exports.moveVectorGradientHandle = moveVectorGradientHandle; exports.setVectorGradientVector = setVectorGradientVector; exports.VECTOR_GRADIENT_MAX_PERIODS = VECTOR_GRADIENT_MAX_PERIODS; exports.periodicVectorGradientStops = periodicVectorGradientStops; exports.expandVectorGradientSpread = expandVectorGradientSpread; exports.vectorGradientArea = vectorGradientArea; exports.patternAttrs = patternAttrs; exports.vectorGradientSvgDefs = vectorGradientSvgDefs; exports.sampleVectorPaintDefAt = sampleVectorPaintDefAt; exports.sanitizeVectorGradient = sanitizeVectorGradient; exports.convertVectorGradient = convertVectorGradient; exports.defaultVectorGradient = defaultVectorGradient; exports.applyVectorGradientPatch = applyVectorGradientPatch; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.multiplyMatrices = multiplyMatrices; exports.translateMatrix = translateMatrix; exports.scaleMatrix = scaleMatrix; exports.rotateMatrix = rotateMatrix; exports.matrixAbout = matrixAbout; exports.skewMatrix = skewMatrix; exports.applyMatrix = applyMatrix; exports.isIdentityMatrix = isIdentityMatrix; exports.invertMatrix = invertMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.matrixRotation = matrixRotation; exports.decomposeRigid = decomposeRigid; exports.isVectorSymmetryGroup = isVectorSymmetryGroup; exports.vectorSymmetryMatrices = vectorSymmetryMatrices; exports.vectorSymmetryDrawn = vectorSymmetryDrawn; exports.vectorSymmetryAxes = vectorSymmetryAxes; exports.sanitizeVectorSymmetry = sanitizeVectorSymmetry; exports.VECTOR_SYMMETRY_MODE_LABELS = VECTOR_SYMMETRY_MODE_LABELS; exports.transformVectorSymmetry = transformVectorSymmetry; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.cornerSetback = cornerSetback; exports.fitCornerRadius = fitCornerRadius; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.hasVectorCorners = hasVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.expandVectorCorners = expandVectorCorners; exports.setAnchorCorner = setAnchorCorner; exports.nextVectorCornerKind = nextVectorCornerKind; exports.setSubpathCorners = setSubpathCorners; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.isUniformWidthProfile = isUniformWidthProfile; exports.widthProfileAt = widthProfileAt; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.reverseWidthProfile = reverseWidthProfile; exports.mirrorWidthProfile = mirrorWidthProfile; exports.insertWidthPoint = insertWidthPoint; exports.setWidthPoint = setWidthPoint; exports.removeWidthPoints = removeWidthPoints; exports.taperWaveFactor = taperWaveFactor; exports.generateWidthProfile = generateWidthProfile; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.pressureWidthProfile = pressureWidthProfile; exports.dashIntervals = dashIntervals; exports.variableStrokeRings = variableStrokeRings; exports.variableStrokeOutline = variableStrokeOutline; exports.nearestStrokePosition = nearestStrokePosition; exports.strokePositionPoint = strokePositionPoint; exports.isClosedBezierShape = isClosedBezierShape; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.hasStrokeExtras = hasStrokeExtras; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.arrowheadWeight = arrowheadWeight; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.hitTestVectorStroke = hitTestVectorStroke; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorPaintSolid = vectorPaintSolid; exports.shadeVectorColor = shadeVectorColor; exports.vectorPathRings = vectorPathRings; exports.vectorExtrudeFaces = vectorExtrudeFaces; exports.VECTOR_BRUSHSTROKE_SCALE = VECTOR_BRUSHSTROKE_SCALE; exports.vectorBrushstrokeBrushes = vectorBrushstrokeBrushes; exports.vectorBrushstrokeBrush = vectorBrushstrokeBrush; exports.vectorBrushstrokeBrushOf = vectorBrushstrokeBrushOf; exports.vectorBrushstrokeBrushError = vectorBrushstrokeBrushError; exports.vectorBrushstrokeDefaultColour = vectorBrushstrokeDefaultColour; exports.sanitizeVectorBrushstroke = sanitizeVectorBrushstroke; exports.VECTOR_BRUSHSTROKE_MAX_SEED = VECTOR_BRUSHSTROKE_MAX_SEED; exports.sanitizeVectorBrushstrokePaper = sanitizeVectorBrushstrokePaper; exports.vectorBrushstrokeCharacterError = vectorBrushstrokeCharacterError; exports.randomVectorBrushstrokeSeed = randomVectorBrushstrokeSeed; exports.isVectorBrushstrokeLayer = isVectorBrushstrokeLayer; exports.vectorBrushstrokeReach = vectorBrushstrokeReach; exports.vectorBrushstrokeImages = vectorBrushstrokeImages; exports.VECTOR_STROKE_SETTING_KEYS = VECTOR_STROKE_SETTING_KEYS; exports.VECTOR_BLEND_MODE_LABELS = VECTOR_BLEND_MODE_LABELS; exports.isVectorBlendMode = isVectorBlendMode; exports.vectorBlendModeCss = vectorBlendModeCss; exports.vectorBlendModeFromCss = vectorBlendModeFromCss; exports.isPlainVectorPaintLayer = isPlainVectorPaintLayer; exports.isDrawnVectorPaintLayer = isDrawnVectorPaintLayer; exports.vectorFills = vectorFills; exports.vectorStrokeSettings = vectorStrokeSettings; exports.vectorStrokes = vectorStrokes; exports.hasVectorPaintStacks = hasVectorPaintStacks; exports.withVectorFills = withVectorFills; exports.withVectorStrokes = withVectorStrokes; exports.normalizeVectorPaintStacks = normalizeVectorPaintStacks; exports.sanitizeVectorFills = sanitizeVectorFills; exports.sanitizeVectorStrokeSettings = sanitizeVectorStrokeSettings; exports.sanitizeVectorStrokes = sanitizeVectorStrokes; exports.vectorPaintLayerNodes = vectorPaintLayerNodes; exports.needsVectorPaintLayers = needsVectorPaintLayers; exports.vectorStrokeStackReach = vectorStrokeStackReach; exports.hitTestVectorPaintLayer = hitTestVectorPaintLayer; exports.hitTestVectorPaintStack = hitTestVectorPaintStack; exports.vectorStacksHaveGradient = vectorStacksHaveGradient; exports.newVectorStrokeLayer = newVectorStrokeLayer; exports.vectorTargetPaint = vectorTargetPaint; exports.withVectorTargetPaint = withVectorTargetPaint; exports.effectPathLength = effectPathLength; exports.effectPathVertexCount = effectPathVertexCount; exports.trimIntervals = trimIntervals; exports.trimPaths = trimPaths; exports.trimPathsIndividually = trimPathsIndividually; exports.puckerBloatPaths = puckerBloatPaths; exports.roundCornerPaths = roundCornerPaths; exports.offsetPaths = offsetPaths; exports.sweepPath = sweepPath; exports.twistPaths = twistPaths; exports.zigzagPaths = zigzagPaths; exports.wigglePaths = wigglePaths; exports.mergePaths = mergePaths; exports.vectorRepeaterCopies = vectorRepeaterCopies; exports.repeatPaths = repeatPaths; exports.pathsCenter = pathsCenter; exports.mapVectorPoints = mapVectorPoints; exports.mapVectorSubpaths = mapVectorSubpaths; exports.mapBezierPath = mapBezierPath; exports.isVectorFrame = isVectorFrame; exports.vectorFrameRectPath = vectorFrameRectPath; exports.vectorFrameDrawn = vectorFrameDrawn; exports.vectorFrameContains = vectorFrameContains; exports.vectorFrameChildMatrix = vectorFrameChildMatrix; exports.sanitizeVectorFrame = sanitizeVectorFrame; exports.sanitizeVectorResizing = sanitizeVectorResizing; exports.VECTOR_HORIZONTAL_RESIZING_LABELS = VECTOR_HORIZONTAL_RESIZING_LABELS; exports.VECTOR_VERTICAL_RESIZING_LABELS = VECTOR_VERTICAL_RESIZING_LABELS; exports.vectorBoundsInside = vectorBoundsInside; exports.vectorArtboards = vectorArtboards; exports.vectorFrameDocument = vectorFrameDocument; exports.getVectorFramePanel = getVectorFramePanel; exports.splitIntoFaces = splitIntoFaces; exports.knifePath = knifePath; exports.eraserRegion = eraserRegion; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.polylineBounds = polylineBounds; exports.simplifyPolyline = simplifyPolyline; exports.VECTOR_FILTER_DEFAULTS = VECTOR_FILTER_DEFAULTS; exports.VECTOR_FILTER_LABELS = VECTOR_FILTER_LABELS; exports.VECTOR_FILTER_PARAM_SPECS = VECTOR_FILTER_PARAM_SPECS; exports.isVectorFilterType = isVectorFilterType; exports.normalizeVectorFilterParams = normalizeVectorFilterParams; exports.vectorFilterParamKeys = vectorFilterParamKeys; exports.createVectorFilter = createVectorFilter; exports.sanitizeVectorFilters = sanitizeVectorFilters; exports.activeVectorFilters = activeVectorFilters; exports.vectorFilterReach = vectorFilterReach; exports.vectorFilterSvg = vectorFilterSvg; exports.vectorFilterMarkup = vectorFilterMarkup; exports.VECTOR_FILTER_MENU = VECTOR_FILTER_MENU; exports.isVectorMaskType = isVectorMaskType; exports.sanitizeVectorMask = sanitizeVectorMask; exports.isVectorMaskGroup = isVectorMaskGroup; exports.isVectorMaskActive = isVectorMaskActive; exports.vectorMaskSource = vectorMaskSource; exports.vectorMaskContents = vectorMaskContents; exports.vectorMaskOwner = vectorMaskOwner; exports.vectorMaskSummary = vectorMaskSummary; exports.vectorMaskRegionShapes = vectorMaskRegionShapes; exports.vectorMaskRegion = vectorMaskRegion; exports.vectorMaskRegionPath = vectorMaskRegionPath; exports.vectorMaskContains = vectorMaskContains; exports.vectorMaskedShapes = vectorMaskedShapes; exports.vectorMaskedGeometry = vectorMaskedGeometry; exports.vectorMaskedLocalBounds = vectorMaskedLocalBounds; exports.vectorMaskContentBounds = vectorMaskContentBounds; exports.vectorMaskRenderData = vectorMaskRenderData; exports.DEFAULT_TEXT_STYLE = DEFAULT_TEXT_STYLE; exports.DEFAULT_AUTO_LEADING = DEFAULT_AUTO_LEADING; exports.fitRuns = fitRuns; exports.styleAt = styleAt; exports.restyleRange = restyleRange; exports.spliceRuns = spliceRuns; exports.paragraphRanges = paragraphRanges; exports.fitParagraphRuns = fitParagraphRuns; exports.fontOf = fontOf; exports.transformTextRect = transformTextRect; exports.lineToTextSpace = lineToTextSpace; exports.layoutText = layoutText; exports.textIndexAt = textIndexAt; exports.caretAt = caretAt; exports.textSelectionQuads = textSelectionQuads; exports.textArrowStep = textArrowStep; exports.textLineMove = textLineMove; exports.textDecorations = textDecorations; exports.textRectPath = textRectPath; exports.textFragmentOutline = textFragmentOutline; exports.drawTextFragment = drawTextFragment; exports.cssFontFamily = cssFontFamily; exports.cssFont = cssFont; exports.createCanvasTextShaper = createCanvasTextShaper; exports.createOutlineTextShaper = createOutlineTextShaper; exports.createMetricTextShaper = createMetricTextShaper; exports.setVectorTextShaper = setVectorTextShaper; exports.getVectorTextShaper = getVectorTextShaper; exports.vectorTextShaperGeneration = vectorTextShaperGeneration; exports.vectorTextHasOutlines = vectorTextHasOutlines; exports.vectorTextFamilies = vectorTextFamilies; exports.DEFAULT_VECTOR_FONT = DEFAULT_VECTOR_FONT; exports.VECTOR_CHARACTER_STYLE_KEYS = VECTOR_CHARACTER_STYLE_KEYS; exports.VECTOR_PARAGRAPH_STYLE_KEYS = VECTOR_PARAGRAPH_STYLE_KEYS; exports.VectorTextError = VectorTextError; exports.fitVectorTextRuns = fitVectorTextRuns; exports.vectorTextRuns = vectorTextRuns; exports.vectorTextStyleAt = vectorTextStyleAt; exports.measureVectorPath = measureVectorPath; exports.vectorPathAt = vectorPathAt; exports.vectorPathTextPositions = vectorPathTextPositions; exports.layoutVectorText = layoutVectorText; exports.glyphBox = glyphBox; exports.vectorTextPaths = vectorTextPaths; exports.vectorTextPaintSource = vectorTextPaintSource; exports.vectorTextCaret = vectorTextCaret; exports.vectorTextIndexAt = vectorTextIndexAt; exports.vectorTextSelectionQuads = vectorTextSelectionQuads; exports.patchVectorCharacterStyle = patchVectorCharacterStyle; exports.patchVectorParagraphStyle = patchVectorParagraphStyle; exports.sanitizeVectorTextFrame = sanitizeVectorTextFrame; exports.normalizeVectorTextRuns = normalizeVectorTextRuns; exports.vectorTextOrientation = vectorTextOrientation; exports.sanitizeVectorTextFields = sanitizeVectorTextFields; exports.vectorTextRange = vectorTextRange; exports.replaceVectorText = replaceVectorText; exports.styleVectorText = styleVectorText; exports.bakeVectorTextGeometry = bakeVectorTextGeometry; exports.vectorTextName = vectorTextName; exports.pathTextFrameFromBezier = pathTextFrameFromBezier; exports.vectorTextBoxOutline = vectorTextBoxOutline; exports.vectorTextSpans = vectorTextSpans; exports.vectorTextGeometryNode = vectorTextGeometryNode; exports.vectorTextSpanSvg = vectorTextSpanSvg; exports.VECTOR_SYMBOL_MAX_DEPTH = VECTOR_SYMBOL_MAX_DEPTH; exports.vectorSymbolsUsedIn = vectorSymbolsUsedIn; exports.vectorSymbolUses = vectorSymbolUses; exports.resolveVectorSymbols = resolveVectorSymbols; exports.stripVectorSymbolArt = stripVectorSymbolArt; exports.scaleVectorStrokeWidths = scaleVectorStrokeWidths; exports.tintVectorNode = tintVectorNode; exports.prefixVectorIds = prefixVectorIds; exports.vectorInstanceGroup = vectorInstanceGroup; exports.composeVectorMatrices = composeVectorMatrices; exports.vectorBevelFaces = vectorBevelFaces; exports.isVectorLens = isVectorLens; exports.VECTOR_LENS_LABELS = VECTOR_LENS_LABELS; exports.VECTOR_LENS_SPECS = VECTOR_LENS_SPECS; exports.sanitizeVectorLens = sanitizeVectorLens; exports.vectorLensColorMap = vectorLensColorMap; exports.mapVectorPaintColors = mapVectorPaintColors; exports.vectorLensDrawn = vectorLensDrawn; exports.resolveVectorLenses = resolveVectorLenses; exports.stripVectorLensViews = stripVectorLensViews; exports.WARP_STYLES = WARP_STYLES; exports.WARP_STYLE_LABELS = WARP_STYLE_LABELS; exports.warpPresetGrid = warpPresetGrid; exports.warpPresetMesh = warpPresetMesh; exports.warpMeshColumns = warpMeshColumns; exports.warpMeshRows = warpMeshRows; exports.isValidWarpMesh = isValidWarpMesh; exports.fitWarpMesh = fitWarpMesh; exports.identityWarpMesh = identityWarpMesh; exports.evalWarpMesh = evalWarpMesh; exports.splitWarpMeshU = splitWarpMeshU; exports.splitWarpMeshV = splitWarpMeshV; exports.removeWarpMeshSplitU = removeWarpMeshSplitU; exports.removeWarpMeshSplitV = removeWarpMeshSplitV; exports.mapWarpMeshPoints = mapWarpMeshPoints; exports.resizeWarpMesh = resizeWarpMesh; exports.warpMeshControlBounds = warpMeshControlBounds; exports.warpMeshParamAt = warpMeshParamAt; exports.dragWarpMeshPoint = dragWarpMeshPoint; exports.pullWarpMesh = pullWarpMesh; exports.warpMeshEditPoints = warpMeshEditPoints; exports.warpMeshGridCurves = warpMeshGridCurves; exports.vectorMeshFromOutline = vectorMeshFromOutline; exports.vectorMeshOutline = vectorMeshOutline; exports.VECTOR_EFFECT_DEFAULTS = VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_PARAM_SPECS = VECTOR_EFFECT_PARAM_SPECS; exports.vectorEnvelopeMesh = vectorEnvelopeMesh; exports.vectorEnvelopeMap = vectorEnvelopeMap; exports.normalizeVectorEffectParams = normalizeVectorEffectParams; exports.createVectorEffect = createVectorEffect; exports.activeVectorEffects = activeVectorEffects; exports.hasOwnVectorAppearance = hasOwnVectorAppearance; exports.hasVectorAppearance = hasVectorAppearance; exports.isVectorLiveBoolean = isVectorLiveBoolean; exports.vectorOperandOperation = vectorOperandOperation; exports.vectorLiveBooleanSteps = vectorLiveBooleanSteps; exports.clearVectorLiveBooleanCache = clearVectorLiveBooleanCache; exports.foldVectorBooleanOperands = foldVectorBooleanOperands; exports.applyVectorEffects = applyVectorEffects; exports.vectorInstanceDrawn = vectorInstanceDrawn; exports.vectorChildAppearanceShapes = vectorChildAppearanceShapes; exports.vectorEffectInputPaths = vectorEffectInputPaths; exports.vectorEffectInputBounds = vectorEffectInputBounds; exports.vectorNodeEnvelope = vectorNodeEnvelope; exports.vectorEnvelopeFrame = vectorEnvelopeFrame; exports.vectorAppearanceShapes = vectorAppearanceShapes; exports.vectorAppearanceOutline = vectorAppearanceOutline; exports.vectorAppearanceNodes = vectorAppearanceNodes; exports.expandVectorAppearance = expandVectorAppearance; exports.expandVectorAppearances = expandVectorAppearances; exports.sanitizeVectorEffects = sanitizeVectorEffects; exports.transformVectorEffects = transformVectorEffects; exports.vectorEnteredGroups = vectorEnteredGroups; exports.isVectorMasterPage = isVectorMasterPage; exports.vectorPages = vectorPages; exports.vectorMasterPages = vectorMasterPages; exports.vectorMasterArt = vectorMasterArt; exports.resolveVectorMasterPages = resolveVectorMasterPages; exports.stripVectorMasterArt = stripVectorMasterArt; exports.isVectorConnector = isVectorConnector; exports.vectorConnectionSites = vectorConnectionSites; exports.nearestVectorConnectionSite = nearestVectorConnectionSite; exports.vectorConnectorWorldAnchors = vectorConnectorWorldAnchors; exports.routeVectorConnector = routeVectorConnector; exports.rerouteVectorConnectors = rerouteVectorConnectors; exports.sanitizeVectorConnector = sanitizeVectorConnector; exports.VECTOR_CONNECTOR_ROUTE_LABELS = VECTOR_CONNECTOR_ROUTE_LABELS; exports.VECTOR_CONNECTOR_SIDE_LABELS = VECTOR_CONNECTOR_SIDE_LABELS; exports.getVectorConnectorPanel = getVectorConnectorPanel; exports.vectorConnectorTargetAt = vectorConnectorTargetAt; exports.vectorStrokeGradientDefs = vectorStrokeGradientDefs; exports.vectorCornersAttribute = vectorCornersAttribute; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.vectorPathLocalBounds = vectorPathLocalBounds; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorNodeLocalPaintBounds = vectorNodeLocalPaintBounds; exports.vectorNodeFilterSvg = vectorNodeFilterSvg; exports.widthProfileToAttribute = widthProfileToAttribute; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.VECTOR_SPATIAL_MIN = VECTOR_SPATIAL_MIN; exports.VectorRTree = VectorRTree; exports.vectorNodePaintBox = vectorNodePaintBox; exports.vectorSpatialIndex = vectorSpatialIndex; exports.vectorNodesNear = vectorNodesNear; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorNode = cloneVectorNode; exports.cloneVectorDocument = cloneVectorDocument; exports.hasPaint = hasPaint; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathSegment = subpathSegment; exports.subpathsToBezier = subpathsToBezier; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPathData = vectorPathData; exports.inferAnchorType = inferAnchorType; exports.bezierToSubpaths = bezierToSubpaths; exports.walkVectorNodes = walkVectorNodes; exports.findVectorNode = findVectorNode; exports.locateVectorNode = locateVectorNode; exports.collectPaintedNodes = collectPaintedNodes; exports.collectPathNodes = collectPathNodes; exports.nodeMatrix = nodeMatrix; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorNodeBounds = vectorNodeBounds; exports.unionBounds = unionBounds; exports.boundsIntersect = boundsIntersect; exports.boundsFromPoints = boundsFromPoints; exports.hitTestVectorNode = hitTestVectorNode; exports.vectorStrokeOutline = vectorStrokeOutline; exports.hitTestVectorNodes = hitTestVectorNodes; exports.nearestSegment = nearestSegment; exports.transformVectorNode = transformVectorNode; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorWorldMatrix = vectorWorldMatrix; exports.vectorParentMatrix = vectorParentMatrix; exports.translateAnchor = translateAnchor; exports.moveAnchorHandle = moveAnchorHandle; exports.convertAnchor = convertAnchor; exports.insertAnchor = insertAnchor; exports.removeAnchors = removeAnchors; exports.reverseSubpath = reverseSubpath; exports.KAPPA = KAPPA2; exports.rectSubpath = rectSubpath; exports.ellipseSubpath = ellipseSubpath; exports.polygonSubpath = polygonSubpath; exports.starSubpath = starSubpath; exports.lineSubpath = lineSubpath; exports.roundSubpaths = roundSubpaths;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.isVectorMeshGradient = isVectorMeshGradient; exports.isVectorFreeformGradient = isVectorFreeformGradient; exports.isVectorShadedPaint = isVectorShadedPaint; exports.vectorRgbaToCss = vectorRgbaToCss; exports.VECTOR_MESH_MAX = VECTOR_MESH_MAX; exports.createVectorMeshGradient = createVectorMeshGradient; exports.vectorMeshPointAt = vectorMeshPointAt; exports.vectorMeshColorAt = vectorMeshColorAt; exports.vectorMeshLines = vectorMeshLines; exports.vectorFreeformSpreadScale = vectorFreeformSpreadScale; exports.vectorFreeformLineSegments = vectorFreeformLineSegments; exports.vectorFreeformField = vectorFreeformField; exports.sampleVectorFreeform = sampleVectorFreeform; exports.autoVectorFreeformGradient = autoVectorFreeformGradient; exports.vectorShadedSvgDefs = vectorShadedSvgDefs; exports.mapVectorShadedPaint = mapVectorShadedPaint; exports.transformVectorShadedPaint = transformVectorShadedPaint; exports.sanitizeVectorShadedPaint = sanitizeVectorShadedPaint; exports.removeVectorFreeformPoint = removeVectorFreeformPoint; exports.nearestVectorShadingPoint = nearestVectorShadingPoint; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_GRADIENT_TYPES = VECTOR_GRADIENT_TYPES; exports.VECTOR_GRADIENT_SPREADS = VECTOR_GRADIENT_SPREADS; exports.VECTOR_GRADIENT_INTERPOLATIONS = VECTOR_GRADIENT_INTERPOLATIONS; exports.VECTOR_STROKE_GRADIENT_MODES = VECTOR_STROKE_GRADIENT_MODES; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_BLEND_MODES = VECTOR_BLEND_MODES; exports.VECTOR_HORIZONTAL_RESIZING = VECTOR_HORIZONTAL_RESIZING; exports.VECTOR_VERTICAL_RESIZING = VECTOR_VERTICAL_RESIZING; exports.VECTOR_LENS_TYPES = VECTOR_LENS_TYPES; exports.VECTOR_CONNECTOR_SIDES = VECTOR_CONNECTOR_SIDES; exports.VECTOR_CONNECTOR_ROUTES = VECTOR_CONNECTOR_ROUTES; exports.VECTOR_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; exports.VECTOR_MASK_TYPES = VECTOR_MASK_TYPES; exports.VECTOR_SYMMETRY_MODES = VECTOR_SYMMETRY_MODES; exports.VECTOR_TEXT_ALIGNS = VECTOR_TEXT_ALIGNS; exports.VECTOR_PATH_TEXT_BASELINES = VECTOR_PATH_TEXT_BASELINES; exports.VECTOR_PERSPECTIVE_PLANES = VECTOR_PERSPECTIVE_PLANES; exports.VECTOR_CONSTRAINT_KINDS = VECTOR_CONSTRAINT_KINDS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_EFFECT_TYPES = VECTOR_EFFECT_TYPES; exports.VECTOR_MERGE_MODES = VECTOR_MERGE_MODES; exports.VECTOR_FILTER_TYPES = VECTOR_FILTER_TYPES; exports.isVectorGradient = isVectorGradient; exports.parseVectorColor = parseVectorColor; exports.VECTOR_GRADIENT_MIN_STOPS = VECTOR_GRADIENT_MIN_STOPS; exports.gradientMidpointRemap = gradientMidpointRemap; exports.sortedVectorGradientStops = sortedVectorGradientStops; exports.vectorGradientNeedsExpansion = vectorGradientNeedsExpansion; exports.vectorGradientRamp = vectorGradientRamp; exports.sampleVectorGradient = sampleVectorGradient; exports.expandVectorGradientStops = expandVectorGradientStops; exports.samplePlainStops = samplePlainStops; exports.reverseVectorGradient = reverseVectorGradient; exports.insertVectorGradientStop = insertVectorGradientStop; exports.moveVectorGradientStop = moveVectorGradientStop; exports.removeVectorGradientStop = removeVectorGradientStop; exports.vectorGradientMidpointPosition = vectorGradientMidpointPosition; exports.vectorGradientMidpointFromPosition = vectorGradientMidpointFromPosition; exports.spanVectorGradientStops = spanVectorGradientStops; exports.hasExplicitGradientGeometry = hasExplicitGradientGeometry; exports.vectorGradientPoints = vectorGradientPoints; exports.vectorBoxMatrix = vectorBoxMatrix; exports.vectorGradientUnitsMatrix = vectorGradientUnitsMatrix; exports.vectorGradientMatrix = vectorGradientMatrix; exports.vectorGradientFocalParam = vectorGradientFocalParam; exports.vectorGradientParam = vectorGradientParam; exports.applyVectorGradientSpread = applyVectorGradientSpread; exports.vectorGradientTAt = vectorGradientTAt; exports.sampleVectorGradientAt = sampleVectorGradientAt; exports.vectorGradientAspect = vectorGradientAspect; exports.explicitVectorGradient = explicitVectorGradient; exports.pinVectorGradient = pinVectorGradient; exports.transformVectorGradient = transformVectorGradient; exports.mapVectorGradient = mapVectorGradient; exports.mapVectorPaint = mapVectorPaint; exports.transformVectorPaint = transformVectorPaint; exports.isCentredVectorGradient = isCentredVectorGradient; exports.vectorGradientHandles = vectorGradientHandles; exports.moveVectorGradientHandle = moveVectorGradientHandle; exports.setVectorGradientVector = setVectorGradientVector; exports.VECTOR_GRADIENT_MAX_PERIODS = VECTOR_GRADIENT_MAX_PERIODS; exports.periodicVectorGradientStops = periodicVectorGradientStops; exports.expandVectorGradientSpread = expandVectorGradientSpread; exports.vectorGradientArea = vectorGradientArea; exports.patternAttrs = patternAttrs; exports.vectorGradientSvgDefs = vectorGradientSvgDefs; exports.sampleVectorPaintDefAt = sampleVectorPaintDefAt; exports.sanitizeVectorGradient = sanitizeVectorGradient; exports.convertVectorGradient = convertVectorGradient; exports.defaultVectorGradient = defaultVectorGradient; exports.applyVectorGradientPatch = applyVectorGradientPatch; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.multiplyMatrices = multiplyMatrices; exports.translateMatrix = translateMatrix; exports.scaleMatrix = scaleMatrix; exports.rotateMatrix = rotateMatrix; exports.matrixAbout = matrixAbout; exports.skewMatrix = skewMatrix; exports.applyMatrix = applyMatrix; exports.isIdentityMatrix = isIdentityMatrix; exports.invertMatrix = invertMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.matrixRotation = matrixRotation; exports.decomposeRigid = decomposeRigid; exports.isVectorSymmetryGroup = isVectorSymmetryGroup; exports.vectorSymmetryMatrices = vectorSymmetryMatrices; exports.vectorSymmetryDrawn = vectorSymmetryDrawn; exports.vectorSymmetryAxes = vectorSymmetryAxes; exports.sanitizeVectorSymmetry = sanitizeVectorSymmetry; exports.VECTOR_SYMMETRY_MODE_LABELS = VECTOR_SYMMETRY_MODE_LABELS; exports.transformVectorSymmetry = transformVectorSymmetry; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.cornerSetback = cornerSetback; exports.fitCornerRadius = fitCornerRadius; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.hasVectorCorners = hasVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.expandVectorCorners = expandVectorCorners; exports.setAnchorCorner = setAnchorCorner; exports.nextVectorCornerKind = nextVectorCornerKind; exports.setSubpathCorners = setSubpathCorners; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.isUniformWidthProfile = isUniformWidthProfile; exports.widthProfileAt = widthProfileAt; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.reverseWidthProfile = reverseWidthProfile; exports.mirrorWidthProfile = mirrorWidthProfile; exports.insertWidthPoint = insertWidthPoint; exports.setWidthPoint = setWidthPoint; exports.removeWidthPoints = removeWidthPoints; exports.taperWaveFactor = taperWaveFactor; exports.generateWidthProfile = generateWidthProfile; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.pressureWidthProfile = pressureWidthProfile; exports.dashIntervals = dashIntervals; exports.variableStrokeRings = variableStrokeRings; exports.variableStrokeOutline = variableStrokeOutline; exports.nearestStrokePosition = nearestStrokePosition; exports.strokePositionPoint = strokePositionPoint; exports.isClosedBezierShape = isClosedBezierShape; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.hasStrokeExtras = hasStrokeExtras; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.arrowheadWeight = arrowheadWeight; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.hitTestVectorStroke = hitTestVectorStroke; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorPaintSolid = vectorPaintSolid; exports.shadeVectorColor = shadeVectorColor; exports.vectorPathRings = vectorPathRings; exports.vectorExtrudeFaces = vectorExtrudeFaces; exports.EFFECT_STRIP_HEIGHT = EFFECT_STRIP_HEIGHT; exports.EFFECT_MAP_REPEATS = EFFECT_MAP_REPEATS; exports.effectPaintSize = effectPaintSize; exports.readEffectStrokeMap = readEffectStrokeMap; exports.effectPaintKey = effectPaintKey; exports.isPaintEffectPaint = isPaintEffectPaint; exports.readPaintEffectPaint = readPaintEffectPaint; exports.sampleEffectField = sampleEffectField; exports.sampleEffectAt = sampleEffectAt; exports.effectDabField = effectDabField; exports.stampSampler = stampSampler; exports.brushStickerRefs = brushStickerRefs; exports.PAPER_FAMILIES = PAPER_FAMILIES; exports.PAPER_LIBRARY = PAPER_LIBRARY; exports.DEFAULT_PAPER = DEFAULT_PAPER; exports.paperPreset = paperPreset; exports.clonePaper = clonePaper; exports.normalizePaper = normalizePaper; exports.hexToRgb8 = hexToRgb8; exports.renderPaper = renderPaper; exports.TipGrain = TipGrain; exports.penOrientation = penOrientation; exports.tiltToOrientation = tiltToOrientation; exports.PenSmoother = PenSmoother; exports.IDENTITY_COPY = IDENTITY_COPY; exports.PenDabWalker = PenDabWalker; exports.DryStroke = DryStroke; exports.mixerTip = mixerTip; exports.toStrokePoint = toStrokePoint; exports.multiColorPalette = multiColorPalette; exports.multiColorGradient = multiColorGradient; exports.multiColorForDab = multiColorForDab; exports.PaintDabStroke = PaintDabStroke; exports.wetPaperInput = wetPaperInput; exports.WetStrokeDriver = WetStrokeDriver; exports.WET_MEDIUM_PARAMS = WET_MEDIUM_PARAMS; exports.WET_GPU_MODES = WET_GPU_MODES; exports.GPU_LEAD = GPU_LEAD; exports.PaintWetLayers = PaintWetLayers; exports.wetPigmentOf = wetPigmentOf; exports.VECTOR_WET_STEPS = VECTOR_WET_STEPS; exports.vectorMediaEngine = vectorMediaEngine; exports.usesVectorBackdrop = usesVectorBackdrop; exports.WetBrushstrokeJob = WetBrushstrokeJob; exports.renderWetBrushstroke = renderWetBrushstroke; exports.vectorBackdropRect = vectorBackdropRect; exports.renderBackdropBrushstroke = renderBackdropBrushstroke; exports.VECTOR_BRUSHSTROKE_SCALE = VECTOR_BRUSHSTROKE_SCALE; exports.isVectorBrushstrokeEngine = isVectorBrushstrokeEngine; exports.vectorBrushstrokeBrushes = vectorBrushstrokeBrushes; exports.vectorBrushstrokeBrush = vectorBrushstrokeBrush; exports.vectorBrushstrokeBrushOf = vectorBrushstrokeBrushOf; exports.vectorBrushstrokeBrushError = vectorBrushstrokeBrushError; exports.vectorBrushstrokeDefaultColour = vectorBrushstrokeDefaultColour; exports.sanitizeVectorBrushstroke = sanitizeVectorBrushstroke; exports.vectorBrushstrokePaintError = vectorBrushstrokePaintError; exports.readVectorBrushstrokePaint = readVectorBrushstrokePaint; exports.VECTOR_BRUSHSTROKE_MAX_SEED = VECTOR_BRUSHSTROKE_MAX_SEED; exports.sanitizeVectorBrushstrokePaper = sanitizeVectorBrushstrokePaper; exports.vectorBrushstrokeCharacterError = vectorBrushstrokeCharacterError; exports.randomVectorBrushstrokeSeed = randomVectorBrushstrokeSeed; exports.isVectorBrushstrokeLayer = isVectorBrushstrokeLayer; exports.vectorBrushstrokeReach = vectorBrushstrokeReach; exports.setVectorBackdropSource = setVectorBackdropSource; exports.onVectorBrushstrokesSettled = onVectorBrushstrokesSettled; exports.vectorBrushstrokesSettling = vectorBrushstrokesSettling; exports.settleVectorBrushstrokes = settleVectorBrushstrokes; exports.vectorBrushstrokeImages = vectorBrushstrokeImages; exports.VECTOR_STROKE_SETTING_KEYS = VECTOR_STROKE_SETTING_KEYS; exports.VECTOR_BLEND_MODE_LABELS = VECTOR_BLEND_MODE_LABELS; exports.isVectorBlendMode = isVectorBlendMode; exports.vectorBlendModeCss = vectorBlendModeCss; exports.vectorBlendModeFromCss = vectorBlendModeFromCss; exports.isPlainVectorPaintLayer = isPlainVectorPaintLayer; exports.isDrawnVectorPaintLayer = isDrawnVectorPaintLayer; exports.vectorFills = vectorFills; exports.vectorStrokeSettings = vectorStrokeSettings; exports.vectorStrokes = vectorStrokes; exports.hasVectorPaintStacks = hasVectorPaintStacks; exports.withVectorFills = withVectorFills; exports.withVectorStrokes = withVectorStrokes; exports.normalizeVectorPaintStacks = normalizeVectorPaintStacks; exports.sanitizeVectorFills = sanitizeVectorFills; exports.sanitizeVectorStrokeSettings = sanitizeVectorStrokeSettings; exports.sanitizeVectorStrokes = sanitizeVectorStrokes; exports.vectorPaintLayerNodes = vectorPaintLayerNodes; exports.needsVectorPaintLayers = needsVectorPaintLayers; exports.vectorStrokeStackReach = vectorStrokeStackReach; exports.hitTestVectorPaintLayer = hitTestVectorPaintLayer; exports.hitTestVectorPaintStack = hitTestVectorPaintStack; exports.vectorStacksHaveGradient = vectorStacksHaveGradient; exports.newVectorStrokeLayer = newVectorStrokeLayer; exports.vectorTargetPaint = vectorTargetPaint; exports.withVectorTargetPaint = withVectorTargetPaint; exports.effectPathLength = effectPathLength; exports.effectPathVertexCount = effectPathVertexCount; exports.trimIntervals = trimIntervals; exports.trimPaths = trimPaths; exports.trimPathsIndividually = trimPathsIndividually; exports.puckerBloatPaths = puckerBloatPaths; exports.roundCornerPaths = roundCornerPaths; exports.offsetPaths = offsetPaths; exports.sweepPath = sweepPath; exports.twistPaths = twistPaths; exports.zigzagPaths = zigzagPaths; exports.wigglePaths = wigglePaths; exports.mergePaths = mergePaths; exports.vectorRepeaterCopies = vectorRepeaterCopies; exports.repeatPaths = repeatPaths; exports.pathsCenter = pathsCenter; exports.mapVectorPoints = mapVectorPoints; exports.mapVectorSubpaths = mapVectorSubpaths; exports.mapBezierPath = mapBezierPath; exports.isVectorFrame = isVectorFrame; exports.vectorFrameRectPath = vectorFrameRectPath; exports.vectorFrameDrawn = vectorFrameDrawn; exports.vectorFrameContains = vectorFrameContains; exports.vectorFrameChildMatrix = vectorFrameChildMatrix; exports.sanitizeVectorFrame = sanitizeVectorFrame; exports.sanitizeVectorResizing = sanitizeVectorResizing; exports.VECTOR_HORIZONTAL_RESIZING_LABELS = VECTOR_HORIZONTAL_RESIZING_LABELS; exports.VECTOR_VERTICAL_RESIZING_LABELS = VECTOR_VERTICAL_RESIZING_LABELS; exports.vectorBoundsInside = vectorBoundsInside; exports.vectorArtboards = vectorArtboards; exports.vectorFrameDocument = vectorFrameDocument; exports.getVectorFramePanel = getVectorFramePanel; exports.splitIntoFaces = splitIntoFaces; exports.knifePath = knifePath; exports.eraserRegion = eraserRegion; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.polylineBounds = polylineBounds; exports.simplifyPolyline = simplifyPolyline; exports.VECTOR_FILTER_DEFAULTS = VECTOR_FILTER_DEFAULTS; exports.VECTOR_FILTER_LABELS = VECTOR_FILTER_LABELS; exports.VECTOR_FILTER_PARAM_SPECS = VECTOR_FILTER_PARAM_SPECS; exports.isVectorFilterType = isVectorFilterType; exports.normalizeVectorFilterParams = normalizeVectorFilterParams; exports.vectorFilterParamKeys = vectorFilterParamKeys; exports.createVectorFilter = createVectorFilter; exports.sanitizeVectorFilters = sanitizeVectorFilters; exports.activeVectorFilters = activeVectorFilters; exports.vectorFilterReach = vectorFilterReach; exports.vectorFilterSvg = vectorFilterSvg; exports.vectorFilterMarkup = vectorFilterMarkup; exports.VECTOR_FILTER_MENU = VECTOR_FILTER_MENU; exports.isVectorMaskType = isVectorMaskType; exports.sanitizeVectorMask = sanitizeVectorMask; exports.isVectorMaskGroup = isVectorMaskGroup; exports.isVectorMaskActive = isVectorMaskActive; exports.vectorMaskSource = vectorMaskSource; exports.vectorMaskContents = vectorMaskContents; exports.vectorMaskOwner = vectorMaskOwner; exports.vectorMaskSummary = vectorMaskSummary; exports.vectorMaskRegionShapes = vectorMaskRegionShapes; exports.vectorMaskRegion = vectorMaskRegion; exports.vectorMaskRegionPath = vectorMaskRegionPath; exports.vectorMaskContains = vectorMaskContains; exports.vectorMaskedShapes = vectorMaskedShapes; exports.vectorMaskedGeometry = vectorMaskedGeometry; exports.vectorMaskedLocalBounds = vectorMaskedLocalBounds; exports.vectorMaskContentBounds = vectorMaskContentBounds; exports.vectorMaskRenderData = vectorMaskRenderData; exports.DEFAULT_TEXT_STYLE = DEFAULT_TEXT_STYLE; exports.DEFAULT_AUTO_LEADING = DEFAULT_AUTO_LEADING; exports.fitRuns = fitRuns; exports.styleAt = styleAt; exports.restyleRange = restyleRange; exports.spliceRuns = spliceRuns; exports.paragraphRanges = paragraphRanges; exports.fitParagraphRuns = fitParagraphRuns; exports.fontOf = fontOf; exports.transformTextRect = transformTextRect; exports.lineToTextSpace = lineToTextSpace; exports.layoutText = layoutText; exports.textIndexAt = textIndexAt; exports.caretAt = caretAt; exports.textSelectionQuads = textSelectionQuads; exports.textArrowStep = textArrowStep; exports.textLineMove = textLineMove; exports.textDecorations = textDecorations; exports.textRectPath = textRectPath; exports.textFragmentOutline = textFragmentOutline; exports.drawTextFragment = drawTextFragment; exports.cssFontFamily = cssFontFamily; exports.cssFont = cssFont; exports.createCanvasTextShaper = createCanvasTextShaper; exports.createOutlineTextShaper = createOutlineTextShaper; exports.createMetricTextShaper = createMetricTextShaper; exports.setVectorTextShaper = setVectorTextShaper; exports.getVectorTextShaper = getVectorTextShaper; exports.vectorTextShaperGeneration = vectorTextShaperGeneration; exports.vectorTextHasOutlines = vectorTextHasOutlines; exports.vectorTextFamilies = vectorTextFamilies; exports.DEFAULT_VECTOR_FONT = DEFAULT_VECTOR_FONT; exports.VECTOR_CHARACTER_STYLE_KEYS = VECTOR_CHARACTER_STYLE_KEYS; exports.VECTOR_PARAGRAPH_STYLE_KEYS = VECTOR_PARAGRAPH_STYLE_KEYS; exports.VectorTextError = VectorTextError; exports.fitVectorTextRuns = fitVectorTextRuns; exports.vectorTextRuns = vectorTextRuns; exports.vectorTextStyleAt = vectorTextStyleAt; exports.measureVectorPath = measureVectorPath; exports.vectorPathAt = vectorPathAt; exports.vectorPathTextPositions = vectorPathTextPositions; exports.layoutVectorText = layoutVectorText; exports.glyphBox = glyphBox; exports.vectorTextPaths = vectorTextPaths; exports.vectorTextPaintSource = vectorTextPaintSource; exports.vectorTextCaret = vectorTextCaret; exports.vectorTextIndexAt = vectorTextIndexAt; exports.vectorTextSelectionQuads = vectorTextSelectionQuads; exports.patchVectorCharacterStyle = patchVectorCharacterStyle; exports.patchVectorParagraphStyle = patchVectorParagraphStyle; exports.sanitizeVectorTextFrame = sanitizeVectorTextFrame; exports.normalizeVectorTextRuns = normalizeVectorTextRuns; exports.vectorTextOrientation = vectorTextOrientation; exports.sanitizeVectorTextFields = sanitizeVectorTextFields; exports.vectorTextRange = vectorTextRange; exports.replaceVectorText = replaceVectorText; exports.styleVectorText = styleVectorText; exports.bakeVectorTextGeometry = bakeVectorTextGeometry; exports.vectorTextName = vectorTextName; exports.pathTextFrameFromBezier = pathTextFrameFromBezier; exports.vectorTextBoxOutline = vectorTextBoxOutline; exports.vectorTextSpans = vectorTextSpans; exports.vectorTextGeometryNode = vectorTextGeometryNode; exports.vectorTextSpanSvg = vectorTextSpanSvg; exports.VECTOR_SYMBOL_MAX_DEPTH = VECTOR_SYMBOL_MAX_DEPTH; exports.vectorSymbolsUsedIn = vectorSymbolsUsedIn; exports.vectorSymbolUses = vectorSymbolUses; exports.resolveVectorSymbols = resolveVectorSymbols; exports.stripVectorSymbolArt = stripVectorSymbolArt; exports.scaleVectorStrokeWidths = scaleVectorStrokeWidths; exports.tintVectorNode = tintVectorNode; exports.prefixVectorIds = prefixVectorIds; exports.vectorInstanceGroup = vectorInstanceGroup; exports.composeVectorMatrices = composeVectorMatrices; exports.vectorBevelFaces = vectorBevelFaces; exports.isVectorLens = isVectorLens; exports.VECTOR_LENS_LABELS = VECTOR_LENS_LABELS; exports.VECTOR_LENS_SPECS = VECTOR_LENS_SPECS; exports.sanitizeVectorLens = sanitizeVectorLens; exports.vectorLensColorMap = vectorLensColorMap; exports.mapVectorPaintColors = mapVectorPaintColors; exports.vectorLensDrawn = vectorLensDrawn; exports.resolveVectorLenses = resolveVectorLenses; exports.stripVectorLensViews = stripVectorLensViews; exports.WARP_STYLES = WARP_STYLES; exports.WARP_STYLE_LABELS = WARP_STYLE_LABELS; exports.warpPresetGrid = warpPresetGrid; exports.warpPresetMesh = warpPresetMesh; exports.warpMeshColumns = warpMeshColumns; exports.warpMeshRows = warpMeshRows; exports.isValidWarpMesh = isValidWarpMesh; exports.fitWarpMesh = fitWarpMesh; exports.identityWarpMesh = identityWarpMesh; exports.evalWarpMesh = evalWarpMesh; exports.splitWarpMeshU = splitWarpMeshU; exports.splitWarpMeshV = splitWarpMeshV; exports.removeWarpMeshSplitU = removeWarpMeshSplitU; exports.removeWarpMeshSplitV = removeWarpMeshSplitV; exports.mapWarpMeshPoints = mapWarpMeshPoints; exports.resizeWarpMesh = resizeWarpMesh; exports.warpMeshControlBounds = warpMeshControlBounds; exports.warpMeshParamAt = warpMeshParamAt; exports.dragWarpMeshPoint = dragWarpMeshPoint; exports.pullWarpMesh = pullWarpMesh; exports.warpMeshEditPoints = warpMeshEditPoints; exports.warpMeshGridCurves = warpMeshGridCurves; exports.vectorMeshFromOutline = vectorMeshFromOutline; exports.vectorMeshOutline = vectorMeshOutline; exports.VECTOR_EFFECT_DEFAULTS = VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_PARAM_SPECS = VECTOR_EFFECT_PARAM_SPECS; exports.vectorEnvelopeMesh = vectorEnvelopeMesh; exports.vectorEnvelopeMap = vectorEnvelopeMap; exports.normalizeVectorEffectParams = normalizeVectorEffectParams; exports.createVectorEffect = createVectorEffect; exports.activeVectorEffects = activeVectorEffects; exports.hasOwnVectorAppearance = hasOwnVectorAppearance; exports.hasVectorAppearance = hasVectorAppearance; exports.isVectorLiveBoolean = isVectorLiveBoolean; exports.vectorOperandOperation = vectorOperandOperation; exports.vectorLiveBooleanSteps = vectorLiveBooleanSteps; exports.clearVectorLiveBooleanCache = clearVectorLiveBooleanCache; exports.foldVectorBooleanOperands = foldVectorBooleanOperands; exports.applyVectorEffects = applyVectorEffects; exports.vectorInstanceDrawn = vectorInstanceDrawn; exports.vectorChildAppearanceShapes = vectorChildAppearanceShapes; exports.vectorEffectInputPaths = vectorEffectInputPaths; exports.vectorEffectInputBounds = vectorEffectInputBounds; exports.vectorNodeEnvelope = vectorNodeEnvelope; exports.vectorEnvelopeFrame = vectorEnvelopeFrame; exports.vectorAppearanceShapes = vectorAppearanceShapes; exports.vectorAppearanceOutline = vectorAppearanceOutline; exports.vectorAppearanceNodes = vectorAppearanceNodes; exports.expandVectorAppearance = expandVectorAppearance; exports.expandVectorAppearances = expandVectorAppearances; exports.sanitizeVectorEffects = sanitizeVectorEffects; exports.transformVectorEffects = transformVectorEffects; exports.vectorEnteredGroups = vectorEnteredGroups; exports.isVectorMasterPage = isVectorMasterPage; exports.vectorPages = vectorPages; exports.vectorMasterPages = vectorMasterPages; exports.vectorMasterArt = vectorMasterArt; exports.resolveVectorMasterPages = resolveVectorMasterPages; exports.stripVectorMasterArt = stripVectorMasterArt; exports.isVectorConnector = isVectorConnector; exports.vectorConnectionSites = vectorConnectionSites; exports.nearestVectorConnectionSite = nearestVectorConnectionSite; exports.vectorConnectorWorldAnchors = vectorConnectorWorldAnchors; exports.routeVectorConnector = routeVectorConnector; exports.rerouteVectorConnectors = rerouteVectorConnectors; exports.sanitizeVectorConnector = sanitizeVectorConnector; exports.VECTOR_CONNECTOR_ROUTE_LABELS = VECTOR_CONNECTOR_ROUTE_LABELS; exports.VECTOR_CONNECTOR_SIDE_LABELS = VECTOR_CONNECTOR_SIDE_LABELS; exports.getVectorConnectorPanel = getVectorConnectorPanel; exports.vectorConnectorTargetAt = vectorConnectorTargetAt; exports.vectorStrokeGradientDefs = vectorStrokeGradientDefs; exports.vectorCornersAttribute = vectorCornersAttribute; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.vectorPathLocalBounds = vectorPathLocalBounds; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorNodeLocalPaintBounds = vectorNodeLocalPaintBounds; exports.vectorNodeFilterSvg = vectorNodeFilterSvg; exports.widthProfileToAttribute = widthProfileToAttribute; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.VECTOR_SPATIAL_MIN = VECTOR_SPATIAL_MIN; exports.VectorRTree = VectorRTree; exports.vectorNodePaintBox = vectorNodePaintBox; exports.vectorSpatialIndex = vectorSpatialIndex; exports.vectorNodesNear = vectorNodesNear; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorNode = cloneVectorNode; exports.cloneVectorDocument = cloneVectorDocument; exports.hasPaint = hasPaint; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathSegment = subpathSegment; exports.subpathsToBezier = subpathsToBezier; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPathData = vectorPathData; exports.inferAnchorType = inferAnchorType; exports.bezierToSubpaths = bezierToSubpaths; exports.walkVectorNodes = walkVectorNodes; exports.findVectorNode = findVectorNode; exports.locateVectorNode = locateVectorNode; exports.collectPaintedNodes = collectPaintedNodes; exports.collectPathNodes = collectPathNodes; exports.nodeMatrix = nodeMatrix; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorNodeBounds = vectorNodeBounds; exports.unionBounds = unionBounds; exports.boundsIntersect = boundsIntersect; exports.boundsFromPoints = boundsFromPoints; exports.hitTestVectorNode = hitTestVectorNode; exports.vectorStrokeOutline = vectorStrokeOutline; exports.hitTestVectorNodes = hitTestVectorNodes; exports.nearestSegment = nearestSegment; exports.transformVectorNode = transformVectorNode; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorWorldMatrix = vectorWorldMatrix; exports.vectorParentMatrix = vectorParentMatrix; exports.translateAnchor = translateAnchor; exports.moveAnchorHandle = moveAnchorHandle; exports.convertAnchor = convertAnchor; exports.insertAnchor = insertAnchor; exports.removeAnchors = removeAnchors; exports.reverseSubpath = reverseSubpath; exports.KAPPA = KAPPA2; exports.rectSubpath = rectSubpath; exports.ellipseSubpath = ellipseSubpath; exports.polygonSubpath = polygonSubpath; exports.starSubpath = starSubpath; exports.lineSubpath = lineSubpath; exports.roundSubpaths = roundSubpaths;