@pixerate/editor 0.100.0 → 0.101.0

package/dist/{chunk-JF5PXN7W.cjs → chunk-KANRAHTL.cjs}

@@ -75,6 +75,25 @@ var VECTOR_GRADIENT_SPREADS = ["pad", "reflect", "repeat"];
 var VECTOR_GRADIENT_INTERPOLATIONS = ["srgb", "linear", "oklab"];
 var VECTOR_STROKE_GRADIENT_MODES = ["within", "along", "across"];
 var VECTOR_ARROWHEADS = ["triangle", "arrow", "open", "circle", "square", "bar"];
+var VECTOR_BLEND_MODES = [
+  "normal",
+  "darken",
+  "multiply",
+  "color-burn",
+  "lighten",
+  "screen",
+  "color-dodge",
+  "linear-dodge",
+  "overlay",
+  "soft-light",
+  "hard-light",
+  "difference",
+  "exclusion",
+  "hue",
+  "saturation",
+  "color",
+  "luminosity"
+];
 var VECTOR_BLEND_SPACINGS = ["steps", "distance", "smoothColor"];
 var VECTOR_TOOLS = [
   "select",
@@ -100,6 +119,7 @@ var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rot
 var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
 var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater", "envelope"];
 var VECTOR_MERGE_MODES = ["merge", "add", "subtract", "intersect", "exclude"];
+var VECTOR_FILTER_TYPES = ["dropShadow", "innerShadow", "outerGlow", "innerGlow", "layerBlur", "feather"];
 
 // src/vector/gradient.ts
 var clamp = (v2, lo, hi) => Math.min(hi, Math.max(lo, v2));
@@ -1255,8 +1275,8 @@ function removeWidthPoints(points, indices) {
 }
 function ease(u, e) {
   const x = Math.min(Math.max(u, 0), 1);
-  const round = Math.sqrt(Math.max(0, 1 - (1 - x) * (1 - x)));
-  return x + (round - x) * Math.min(Math.max(e, 0), 1);
+  const round3 = Math.sqrt(Math.max(0, 1 - (1 - x) * (1 - x)));
+  return x + (round3 - x) * Math.min(Math.max(e, 0), 1);
 }
 function taperWaveFactor(t, taper, wave) {
   let k = 1;
@@ -1880,6 +1900,278 @@ function vectorStrokeReach(style) {
   return reach;
 }
 
+// src/vector/paintLayers.ts
+var VECTOR_STROKE_SETTING_KEYS = [
+  "strokeWidth",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeDasharray",
+  "strokeAlign",
+  "startArrow",
+  "endArrow",
+  "arrowAlign",
+  "startArrowScale",
+  "endArrowScale",
+  "strokeWidthProfile"
+];
+var VECTOR_BLEND_MODE_LABELS = {
+  normal: "Normal",
+  darken: "Darken",
+  multiply: "Multiply",
+  "color-burn": "Color Burn",
+  lighten: "Lighten",
+  screen: "Screen",
+  "color-dodge": "Color Dodge",
+  "linear-dodge": "Linear Dodge (Add)",
+  overlay: "Overlay",
+  "soft-light": "Soft Light",
+  "hard-light": "Hard Light",
+  difference: "Difference",
+  exclusion: "Exclusion",
+  hue: "Hue",
+  saturation: "Saturation",
+  color: "Color",
+  luminosity: "Luminosity"
+};
+function isVectorBlendMode(value) {
+  return typeof value === "string" && VECTOR_BLEND_MODES.includes(value);
+}
+function vectorBlendModeCss(mode) {
+  if (!mode || mode === "normal" || !isVectorBlendMode(mode)) return void 0;
+  return mode === "linear-dodge" ? "plus-lighter" : mode;
+}
+function vectorBlendModeFromCss(value) {
+  const v2 = (_nullishCoalesce(value, () => ( ""))).trim().toLowerCase();
+  if (v2 === "plus-lighter") return "linear-dodge";
+  return isVectorBlendMode(v2) ? v2 : null;
+}
+var draws = (paint) => {
+  if (paint === void 0 || paint === null) return false;
+  if (typeof paint === "string") {
+    const p = paint.trim().toLowerCase();
+    return p !== "" && p !== "none" && p !== "transparent";
+  }
+  return true;
+};
+function isPlainVectorPaintLayer(layer) {
+  return (_nullishCoalesce(layer.opacity, () => ( 1))) >= 1 && (_nullishCoalesce(layer.blendMode, () => ( "normal"))) === "normal" && layer.visible !== false && (_nullishCoalesce(layer.kind, () => ( "paint"))) === "paint";
+}
+function isDrawnVectorPaintLayer(layer) {
+  return layer.visible !== false && (_nullishCoalesce(layer.kind, () => ( "paint"))) === "paint" && draws(layer.paint) && (_nullishCoalesce(layer.opacity, () => ( 1))) > 0;
+}
+function vectorFills(style) {
+  if (Array.isArray(style.fills)) return style.fills;
+  return draws(style.fill) ? [{ paint: style.fill }] : [];
+}
+function vectorStrokeSettings(style) {
+  const out = {};
+  for (const key of VECTOR_STROKE_SETTING_KEYS) {
+    const v2 = style[key];
+    if (v2 !== void 0 && v2 !== null) out[key] = v2;
+  }
+  return out;
+}
+function vectorStrokes(style) {
+  if (Array.isArray(style.strokes)) return style.strokes;
+  return draws(style.stroke) ? [{ paint: style.stroke, ...vectorStrokeSettings(style) }] : [];
+}
+function hasVectorPaintStacks(style) {
+  return Array.isArray(style.fills) || Array.isArray(style.strokes);
+}
+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', _38 => _38[0], 'optionalAccess', _39 => _39.paint]), () => ( null));
+    return next;
+  }
+  next.fills = fills.map((l) => ({ ...l }));
+  next.fill = fills[fills.length - 1].paint;
+  return next;
+}
+function withVectorStrokes(node, strokes) {
+  const next = { ...node };
+  if (strokes.length === 0) {
+    delete next.strokes;
+    next.stroke = null;
+    return next;
+  }
+  const top = strokes[strokes.length - 1];
+  for (const key of VECTOR_STROKE_SETTING_KEYS) delete next[key];
+  Object.assign(next, vectorStrokeSettings(top));
+  next.stroke = top.paint;
+  if (strokes.length === 1 && isPlainVectorPaintLayer(top)) delete next.strokes;
+  else next.strokes = strokes.map((l) => ({ ...l }));
+  return next;
+}
+var json = (v2) => JSON.stringify(_nullishCoalesce(v2, () => ( null)));
+function strokeShorthandDiff(node, top) {
+  const out = [];
+  if (json(node.stroke) !== json(_optionalChain([top, 'optionalAccess', _40 => _40.paint]))) out.push("stroke");
+  for (const key of VECTOR_STROKE_SETTING_KEYS) if (json(node[key]) !== json(_optionalChain([top, 'optionalAccess', _41 => _41[key]]))) out.push(key);
+  return out;
+}
+var checked = /* @__PURE__ */ new WeakSet();
+function normalizeVectorPaintStacks(node, prefer = "shorthand") {
+  if (!hasVectorPaintStacks(node)) {
+    if (!("fills" in node) && !("strokes" in node)) return node;
+    const next2 = { ...node };
+    delete next2.fills;
+    delete next2.strokes;
+    return next2;
+  }
+  if (checked.has(node)) return node;
+  let next = node;
+  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', _42 => _42.paint]))) {
+      if (!draws(node.fill)) fills = [];
+      else fills = top ? [...fills.slice(0, -1), { ...top, paint: node.fill }] : [{ paint: node.fill }];
+    }
+    next = withVectorFills(next, fills);
+  }
+  if (Array.isArray(node.strokes)) {
+    let strokes = node.strokes;
+    const top = strokes[strokes.length - 1];
+    const diff = prefer === "shorthand" ? strokeShorthandDiff(node, top) : [];
+    if (diff.length) {
+      if (diff.includes("stroke") && !draws(node.stroke)) strokes = [];
+      else {
+        const layer = top ? { ...top } : { paint: _nullishCoalesce(node.stroke, () => ( null)) };
+        for (const key of diff) {
+          if (key === "stroke") layer.paint = _nullishCoalesce(node.stroke, () => ( null));
+          else if (node[key] === void 0 || node[key] === null) delete layer[key];
+          else layer[key] = node[key];
+        }
+        strokes = top ? [...strokes.slice(0, -1), layer] : [layer];
+      }
+    }
+    next = withVectorStrokes(next, strokes);
+  }
+  const keys = ["fill", "fills", "stroke", "strokes", ...VECTOR_STROKE_SETTING_KEYS];
+  const same2 = keys.every((k) => k in next === k in node && json(next[k]) === json(node[k]));
+  const out = same2 ? node : next;
+  checked.add(out);
+  return out;
+}
+function sanitizePaint(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  return sanitizeVectorGradient(value);
+}
+function sanitizeLayerBase(raw) {
+  const out = { paint: sanitizePaint(raw.paint) };
+  if (typeof raw.opacity === "number" && Number.isFinite(raw.opacity) && raw.opacity < 1) out.opacity = Math.max(0, raw.opacity);
+  if (isVectorBlendMode(raw.blendMode) && raw.blendMode !== "normal") out.blendMode = raw.blendMode;
+  if (raw.visible === false) out.visible = false;
+  return out;
+}
+function sanitizeVectorFills(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((l) => !!l && typeof l === "object").map(sanitizeLayerBase);
+}
+var ARROW_ALIGNS = ["extend", "tip"];
+function sanitizeVectorStrokeSettings(raw) {
+  const out = {};
+  const num2 = (v2) => typeof v2 === "number" && Number.isFinite(v2) ? v2 : void 0;
+  const width = num2(raw.strokeWidth);
+  if (width !== void 0 && width >= 0) out.strokeWidth = width;
+  if (raw.strokeLinecap === "butt" || raw.strokeLinecap === "round" || raw.strokeLinecap === "square") out.strokeLinecap = raw.strokeLinecap;
+  if (raw.strokeLinejoin === "miter" || raw.strokeLinejoin === "round" || raw.strokeLinejoin === "bevel") out.strokeLinejoin = raw.strokeLinejoin;
+  if (Array.isArray(raw.strokeDasharray)) {
+    const dash = raw.strokeDasharray.filter((n) => typeof n === "number" && Number.isFinite(n) && n >= 0);
+    if (dash.length && dash.some((n) => n > 0)) out.strokeDasharray = dash;
+  }
+  if (raw.strokeAlign === "center" || raw.strokeAlign === "inside" || raw.strokeAlign === "outside") out.strokeAlign = raw.strokeAlign;
+  for (const key of ["startArrow", "endArrow"]) if (VECTOR_ARROWHEADS.includes(raw[key])) out[key] = raw[key];
+  if (ARROW_ALIGNS.includes(raw.arrowAlign)) out.arrowAlign = raw.arrowAlign;
+  for (const key of ["startArrowScale", "endArrowScale"]) {
+    const n = num2(raw[key]);
+    if (n !== void 0 && n > 0) out[key] = n;
+  }
+  if (Array.isArray(raw.strokeWidthProfile)) {
+    const p = sanitizeWidthProfile(raw.strokeWidthProfile);
+    if (p.length) out.strokeWidthProfile = p;
+  }
+  return out;
+}
+function sanitizeVectorStrokes(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((l) => !!l && typeof l === "object").map((raw) => {
+    if (raw.kind !== void 0 && raw.kind !== "paint") return { ...raw };
+    return { ...sanitizeLayerBase(raw), ...sanitizeVectorStrokeSettings(raw) };
+  });
+}
+var layerNodeCache = /* @__PURE__ */ new WeakMap();
+function vectorPaintLayerNodes(node) {
+  const hit = layerNodeCache.get(node);
+  if (hit) return hit;
+  const { fills: _f, strokes: _s, ...base } = node;
+  const plain2 = { ...base };
+  for (const key of VECTOR_STROKE_SETTING_KEYS) delete plain2[key];
+  const out = [];
+  vectorFills(node).forEach((layer, index) => {
+    out.push({ kind: "fill", index, layer, node: { ...plain2, fill: layer.paint, stroke: null }, drawn: isDrawnVectorPaintLayer(layer) });
+  });
+  vectorStrokes(node).forEach((layer, index) => {
+    const settings = (_nullishCoalesce(layer.kind, () => ( "paint"))) === "paint" ? vectorStrokeSettings(layer) : {};
+    out.push({ kind: "stroke", index, layer, node: { ...plain2, fill: null, ...settings, stroke: layer.paint }, drawn: isDrawnVectorPaintLayer(layer) });
+  });
+  layerNodeCache.set(node, out);
+  return out;
+}
+function needsVectorPaintLayers(node) {
+  if (!hasVectorPaintStacks(node)) return false;
+  const fills = vectorFills(node);
+  const strokes = vectorStrokes(node);
+  return fills.length > 1 || strokes.length > 1 || fills.some((l) => !isPlainVectorPaintLayer(l)) || strokes.some((l) => !isPlainVectorPaintLayer(l));
+}
+function vectorStrokeStackReach(node) {
+  let reach = 0;
+  for (const l of vectorPaintLayerNodes(node)) if (l.kind === "stroke" && l.drawn) reach = Math.max(reach, vectorStrokeReach(l.node));
+  return reach;
+}
+function hitTestVectorPaintLayer(node, path, p, tolerance = 0) {
+  if (!path.length) return null;
+  const layers = vectorPaintLayerNodes(node);
+  for (let i = layers.length - 1; i >= 0; i--) {
+    const l = layers[i];
+    if (!l.drawn) continue;
+    if (l.kind === "stroke") {
+      if ((_nullishCoalesce(l.node.strokeWidth, () => ( 1))) > 0 && hitTestVectorStroke(path, p, l.node, tolerance)) return { kind: "stroke", index: l.index };
+    } else if (_chunkXGD3FSNCcjs.pointInBezierPath.call(void 0, path, [p.x, p.y], _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return { kind: "fill", index: l.index };
+  }
+  return null;
+}
+function hitTestVectorPaintStack(node, path, p, tolerance = 0) {
+  if (hitTestVectorPaintLayer(node, path, p, tolerance)) return true;
+  if (vectorPaintLayerNodes(node).some((l) => l.kind === "stroke" && l.drawn)) return false;
+  return _chunkXGD3FSNCcjs.distanceToBezierPath.call(void 0, path, [p.x, p.y]) <= tolerance;
+}
+function vectorStacksHaveGradient(style) {
+  return [..._nullishCoalesce(style.fills, () => ( [])), ..._nullishCoalesce(style.strokes, () => ( []))].some((l) => isVectorGradient(l.paint));
+}
+function newVectorStrokeLayer(node, patch = {}) {
+  const top = vectorStrokes(node).at(-1);
+  const settings = top && (_nullishCoalesce(top.kind, () => ( "paint"))) === "paint" ? vectorStrokeSettings(top) : { strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)) };
+  return { paint: "#000000", ...settings, ...patch };
+}
+function vectorTargetPaint(style, target, layer = null) {
+  if (layer === null) return style[target];
+  const stack = target === "fill" ? vectorFills(style) : vectorStrokes(style);
+  return stack[layer] ? stack[layer].paint : style[target];
+}
+function withVectorTargetPaint(node, target, layer, paint) {
+  const stack = target === "fill" ? vectorFills(node) : vectorStrokes(node);
+  if (layer === null || !stack[layer]) {
+    if (!stack.length) return { ...node, [target]: paint };
+    layer = stack.length - 1;
+  }
+  const next = stack.map((l, i) => i === layer ? { ...l, paint } : l);
+  return target === "fill" ? withVectorFills(node, next) : withVectorStrokes(node, next);
+}
+
 // src/vector/pathMap.ts
 var MAX_PIECES = 1 << 20;
 var MAX_DEPTH = 6;
@@ -2312,7 +2604,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', _38 => _38[spec.key]]);
+    const v2 = _optionalChain([params, 'optionalAccess', _43 => _43[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;
@@ -2323,7 +2615,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', _39 => _39.mesh]);
+    const given = _optionalChain([params, 'optionalAccess', _44 => _44.mesh]);
     let mesh = given !== void 0 ? _chunkDWGZUSEScjs.isValidWarpMesh.call(void 0, given) ? cloneMesh(given) : null : o.mesh;
     if (o.style !== "mesh") mesh = null;
     if (mesh && given !== void 0) {
@@ -2340,10 +2632,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', _40 => _40.effects, 'optionalAccess', _41 => _41.filter, 'call', _42 => _42(isEnabled)]), () => ( []));
+  return _nullishCoalesce(_optionalChain([node, 'access', _45 => _45.effects, 'optionalAccess', _46 => _46.filter, 'call', _47 => _47(isEnabled)]), () => ( []));
 }
 function hasOwnVectorAppearance(node) {
-  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _43 => _43.effects, 'optionalAccess', _44 => _44.some, 'call', _45 => _45(isEnabled)]);
+  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _48 => _48.effects, 'optionalAccess', _49 => _49.some, 'call', _50 => _50(isEnabled)]);
 }
 var liveCache = /* @__PURE__ */ new WeakMap();
 function hasVectorAppearance(node) {
@@ -2355,7 +2647,7 @@ function hasVectorAppearance(node) {
   return v2;
 }
 function isVectorLiveBoolean(node) {
-  return _optionalChain([node, 'optionalAccess', _46 => _46.type]) === "group" && !!node.liveBoolean;
+  return _optionalChain([node, 'optionalAccess', _51 => _51.type]) === "group" && !!node.liveBoolean;
 }
 function vectorOperandOperation(group, child) {
   return _nullishCoalesce(_nullishCoalesce(child.booleanOperation, () => ( group.liveBoolean)), () => ( "union"));
@@ -2472,7 +2764,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', _47 => _47.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _48 => _48.y]), () => ( 0))) });
+var add3 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _52 => _52.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _53 => _53.y]), () => ( 0))) });
 var mapPaths = (shapes, fn) => {
   const out = fn(shapes.map((s) => s.path));
   return shapes.map((s, i) => ({ ...s, path: _nullishCoalesce(out[i], () => ( [])) }));
@@ -2579,10 +2871,10 @@ function vectorEffectInputBounds(node, effectId) {
   return paths ? pathsBounds(paths) : null;
 }
 function vectorNodeEnvelope(node) {
-  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _49 => _49.effects, 'optionalAccess', _50 => _50.find, 'call', _51 => _51((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
+  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _54 => _54.effects, 'optionalAccess', _55 => _55.find, 'call', _56 => _56((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
 }
 function vectorEnvelopeFrame(node, effectId) {
-  const e = effectId ? _optionalChain([node, 'access', _52 => _52.effects, 'optionalAccess', _53 => _53.find, 'call', _54 => _54((x) => x.id === effectId)]) : vectorNodeEnvelope(node);
+  const e = effectId ? _optionalChain([node, 'access', _57 => _57.effects, 'optionalAccess', _58 => _58.find, 'call', _59 => _59((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;
@@ -2616,6 +2908,9 @@ function shapeNode(shape, id) {
     locked: _l,
     visible: _v,
     opacity: _o,
+    // The node's own blend mode and filters stay on the node, not on each shape it draws.
+    blendMode: _bm,
+    filters: _fl,
     ...style
   } = shape.source;
   return { ...style, id, type: "path", subpaths: bezierToSubpaths(shape.path), ...shape.opacity < 1 ? { opacity: shape.opacity } : {} };
@@ -2627,7 +2922,9 @@ function placement(node) {
     ...node.visible === false ? { visible: false } : {},
     ...node.locked ? { locked: true } : {},
     ...node.blendStep ? { blendStep: true } : {},
-    ...node.booleanOperation ? { booleanOperation: node.booleanOperation } : {}
+    ...node.booleanOperation ? { booleanOperation: node.booleanOperation } : {},
+    ...node.blendMode ? { blendMode: node.blendMode } : {},
+    ..._optionalChain([node, 'access', _60 => _60.filters, 'optionalAccess', _61 => _61.length]) ? { filters: node.filters } : {}
   };
 }
 function vectorAppearanceNodes(node) {
@@ -2935,17 +3232,14 @@ function boundsFromPoints(a, b) {
 }
 function hitTestVectorNode(node, p, tolerance = 0, parent = _chunkDWGZUSEScjs.IDENTITY_MATRIX, options = {}) {
   if (node.visible === false) return false;
-  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _55 => _55.entered, 'optionalAccess', _56 => _56.has, 'call', _57 => _57(node.id)])))) node = expandVectorAppearance(node);
+  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _62 => _62.entered, 'optionalAccess', _63 => _63.has, 'call', _64 => _64(node.id)])))) node = expandVectorAppearance(node);
   if (node.type === "group") {
     const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, nodeMatrix(node), parent);
     return node.children.some((c) => hitTestVectorNode(c, p, tolerance, m, options));
   }
   const path = vectorPathWorldBezier(node, parent);
   if (path.length === 0) return false;
-  const point = [p.x, p.y];
-  if (hasPaint(node.fill) && _chunkXGD3FSNCcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
-  if (hasPaint(node.stroke)) return hitTestVectorStroke(path, p, node, tolerance);
-  return _chunkXGD3FSNCcjs.distanceToBezierPath.call(void 0, path, point) <= tolerance;
+  return hitTestVectorPaintStack(node, path, p, tolerance);
 }
 function vectorStrokeOutline(node, parent = _chunkDWGZUSEScjs.IDENTITY_MATRIX) {
   if (!hasPaint(node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return [];
@@ -2985,23 +3279,31 @@ function mapAnchor(a, m) {
 }
 function bakeIntoGeometry(node, m) {
   if (_chunkDWGZUSEScjs.isIdentityMatrix.call(void 0, m)) return node;
-  if (_optionalChain([node, 'access', _58 => _58.effects, 'optionalAccess', _59 => _59.length])) node = { ...node, effects: transformVectorEffects(node.effects, m, node) };
+  if (_optionalChain([node, 'access', _65 => _65.effects, 'optionalAccess', _66 => _66.length])) node = { ...node, effects: transformVectorEffects(node.effects, m, node) };
   if (node.type === "group") {
     const group = node;
     const children = group.children.map((c) => transformVectorNode(c, m));
-    const spine = _optionalChain([group, 'access', _60 => _60.blend, 'optionalAccess', _61 => _61.spine]);
+    const spine = _optionalChain([group, 'access', _67 => _67.blend, 'optionalAccess', _68 => _68.spine]);
     if (!spine) return { ...group, children };
     const moved = { closed: spine.closed, anchors: spine.anchors.map((a) => mapAnchor(a, m)) };
     return { ...group, children, blend: { ...group.blend, spine: moved } };
   }
   const path = node;
-  const mirrored = m[0] * m[3] - m[1] * m[2] < 0 && _optionalChain([path, 'access', _62 => _62.strokeWidthProfile, 'optionalAccess', _63 => _63.length]);
+  const flips = m[0] * m[3] - m[1] * m[2] < 0;
+  const mirrored = flips && _optionalChain([path, 'access', _69 => _69.strokeWidthProfile, 'optionalAccess', _70 => _70.length]);
+  const layer = (l) => ({
+    ...l,
+    ...isVectorGradient(l.paint) ? { paint: transformVectorPaint(l.paint, m) } : {},
+    ...flips && _optionalChain([l, 'access', _71 => _71.strokeWidthProfile, 'optionalAccess', _72 => _72.length]) ? { strokeWidthProfile: mirrorWidthProfile(l.strokeWidthProfile) } : {}
+  });
   return {
     ...path,
     ...mirrored ? { strokeWidthProfile: mirrorWidthProfile(path.strokeWidthProfile) } : {},
     // Gradients in the node's own space move with its geometry.
     ...isVectorGradient(path.fill) ? { fill: transformVectorPaint(path.fill, m) } : {},
     ...isVectorGradient(path.stroke) ? { stroke: transformVectorPaint(path.stroke, m) } : {},
+    ...Array.isArray(path.fills) ? { fills: path.fills.map(layer) } : {},
+    ...Array.isArray(path.strokes) ? { strokes: path.strokes.map(layer) } : {},
     subpaths: path.subpaths.map((sp) => ({
       closed: sp.closed,
       anchors: sp.anchors.map((a) => mapAnchor(a, m))
@@ -3256,8 +3558,8 @@ var Measured = class {
   append(sa, sb, out) {
     for (const piece of _chunkXGD3FSNCcjs.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', _73 => _73[out.length - 1], 'optionalAccess', _74 => _74.segs]);
+      const end = _optionalChain([last, 'optionalAccess', _75 => _75[last.length - 1], 'optionalAccess', _76 => _76.at, 'call', _77 => _77(-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);
     }
@@ -3551,9 +3853,9 @@ function vectorRepeaterCopies(r, pivot) {
   for (let i = 0; i < n; i++) {
     const k = i + offset;
     let m = _chunkDWGZUSEScjs.translateMatrix.call(void 0, -pivot.x, -pivot.y);
-    m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, m, _chunkDWGZUSEScjs.scaleMatrix.call(void 0, 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 = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, m, _chunkDWGZUSEScjs.scaleMatrix.call(void 0, Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _78 => _78.scale, 'optionalAccess', _79 => _79.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _80 => _80.scale, 'optionalAccess', _81 => _81.y]), () => ( 100))) / 100, k)));
     m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, m, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, (_nullishCoalesce(r.rotation, () => ( 0))) * k));
-    m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, m, _chunkDWGZUSEScjs.translateMatrix.call(void 0, 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 = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, m, _chunkDWGZUSEScjs.translateMatrix.call(void 0, pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _82 => _82.position, 'optionalAccess', _83 => _83.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _84 => _84.position, 'optionalAccess', _85 => _85.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)) });
@@ -4086,7 +4388,7 @@ function interpolateVectorPaint(a, b, t) {
   return t < 0.5 ? a : b;
 }
 function interpolateWidthProfiles(a, b, t) {
-  if (!_optionalChain([a, 'optionalAccess', _77 => _77.length]) && !_optionalChain([b, 'optionalAccess', _78 => _78.length])) return null;
+  if (!_optionalChain([a, 'optionalAccess', _86 => _86.length]) && !_optionalChain([b, 'optionalAccess', _87 => _87.length])) return null;
   const at2 = [..._nullishCoalesce(a, () => ( [])), ..._nullishCoalesce(b, () => ( [])), { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
   const ts = at2.filter((v2, i) => i === 0 || v2 - at2[i - 1] > 1e-6);
   return ts.map((pos) => {
@@ -4096,7 +4398,7 @@ function interpolateWidthProfiles(a, b, t) {
   });
 }
 function lerpDashes(a, b, t) {
-  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _79 => _79.length]) && d.some((v2) => v2 > 0);
+  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _88 => _88.length]) && d.some((v2) => v2 > 0);
   if (!dashed(a) && !dashed(b)) return t < 0.5 ? a : b;
   const even = (p) => p.length % 2 ? [...p, ...p] : p;
   const solid = (p) => {
@@ -4123,7 +4425,7 @@ function interpolateVectorStyle(a, b, t) {
   for (const key of ["startArrowScale", "endArrowScale"])
     if (a[key] !== void 0 || b[key] !== void 0) out[key] = lerpN(_nullishCoalesce(a[key], () => ( 1)), _nullishCoalesce(b[key], () => ( 1)), t);
   const dash = lerpDashes(a.strokeDasharray, b.strokeDasharray, t);
-  if (_optionalChain([dash, 'optionalAccess', _80 => _80.length])) out.strokeDasharray = dash;
+  if (_optionalChain([dash, 'optionalAccess', _89 => _89.length])) out.strokeDasharray = dash;
   const profile = interpolateWidthProfiles(a.strokeWidthProfile, b.strokeWidthProfile, t);
   if (profile) out.strokeWidthProfile = profile;
   return out;
@@ -4134,7 +4436,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _81 => _81.strokeWidthProfile, 'optionalAccess', _82 => _82.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _90 => _90.strokeWidthProfile, 'optionalAccess', _91 => _91.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -4267,6 +4569,201 @@ function evaluateVectorPathKeyframes(keyframes, time, options = {}) {
   return morph.at(u);
 }
 
+// src/vector/filters.ts
+var VECTOR_FILTER_DEFAULTS = {
+  dropShadow: { color: "#000000", opacity: 0.25, offsetX: 0, offsetY: 4, blur: 4, spread: 0 },
+  innerShadow: { color: "#000000", opacity: 0.25, offsetX: 0, offsetY: 4, blur: 4, spread: 0 },
+  outerGlow: { color: "#ffffbe", opacity: 0.75, blur: 10, spread: 0 },
+  innerGlow: { color: "#ffffbe", opacity: 0.75, blur: 10, spread: 0 },
+  layerBlur: { radius: 4 },
+  feather: { radius: 8 }
+};
+var VECTOR_FILTER_LABELS = {
+  dropShadow: "Drop Shadow",
+  innerShadow: "Inner Shadow",
+  outerGlow: "Outer Glow",
+  innerGlow: "Inner Glow",
+  layerBlur: "Layer Blur",
+  feather: "Feather"
+};
+var SHADOW_SPECS = [
+  { key: "color", label: "Color", kind: "color" },
+  { key: "opacity", label: "Opacity", kind: "number", min: 0, max: 1, step: 0.01, slider: true },
+  { key: "offsetX", label: "X", kind: "number", min: -1e3, max: 1e3, step: 1 },
+  { key: "offsetY", label: "Y", kind: "number", min: -1e3, max: 1e3, step: 1 },
+  { key: "blur", label: "Blur", kind: "number", min: 0, max: 500, step: 1 },
+  { key: "spread", label: "Spread", kind: "number", min: 0, max: 500, step: 1 }
+];
+var GLOW_SPECS = SHADOW_SPECS.filter((s) => s.key !== "offsetX" && s.key !== "offsetY");
+var VECTOR_FILTER_PARAM_SPECS = {
+  dropShadow: SHADOW_SPECS,
+  innerShadow: SHADOW_SPECS.map((s) => s.key === "spread" ? { ...s, label: "Choke" } : s),
+  outerGlow: GLOW_SPECS,
+  innerGlow: GLOW_SPECS.map((s) => s.key === "spread" ? { ...s, label: "Choke" } : s),
+  layerBlur: [{ key: "radius", label: "Radius", kind: "number", min: 0, max: 500, step: 1, slider: true }],
+  feather: [{ key: "radius", label: "Radius", kind: "number", min: 0, max: 500, step: 1, slider: true }]
+};
+function isVectorFilterType(value) {
+  return typeof value === "string" && VECTOR_FILTER_TYPES.includes(value);
+}
+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', _92 => _92[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();
+  }
+  return out;
+}
+function vectorFilterParamKeys(type) {
+  return VECTOR_FILTER_PARAM_SPECS[type].map((s) => s.key);
+}
+function createVectorFilter(type, id, params) {
+  const p = normalizeVectorFilterParams(type, params);
+  return p ? { id, type, params: p } : null;
+}
+function sanitizeVectorFilters(value) {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object") continue;
+    const r = raw;
+    if (!isVectorFilterType(r.type)) continue;
+    let id = typeof r.id === "string" && r.id && !used.has(r.id) ? r.id : "";
+    for (let k = out.length + 1; !id; k++) if (!used.has(`filter${k}`)) id = `filter${k}`;
+    used.add(id);
+    const filter = createVectorFilter(r.type, id, _nullishCoalesce(r.params, () => ( {})));
+    out.push(r.enabled === false ? { ...filter, enabled: false } : filter);
+  }
+  return out;
+}
+function activeVectorFilters(node) {
+  return (_nullishCoalesce(node.filters, () => ( []))).filter((f) => {
+    if (f.enabled === false || !isVectorFilterType(f.type)) return false;
+    if (f.type === "layerBlur" || f.type === "feather") return f.params.radius > 0;
+    return f.params.opacity > 0;
+  });
+}
+function vectorFilterReach(filters) {
+  let outer = 0;
+  let blur = 0;
+  for (const f of filters) {
+    switch (f.type) {
+      case "dropShadow":
+      case "innerShadow":
+        outer = Math.max(outer, Math.max(Math.abs(f.params.offsetX), Math.abs(f.params.offsetY)) + f.params.blur * 1.5 + f.params.spread);
+        break;
+      case "outerGlow":
+      case "innerGlow":
+        outer = Math.max(outer, f.params.blur * 1.5 + f.params.spread);
+        break;
+      case "layerBlur":
+        blur += f.params.radius * 1.5;
+        break;
+    }
+  }
+  return outer + blur;
+}
+var round = (n) => Math.round(n * 1e3) / 1e3;
+var fe = (tag, attrs, children) => ({ tag, attrs, ...children ? { children } : {} });
+function vectorFilterSvg(filters, id, bounds) {
+  const active = filters.filter((f) => activeVectorFilters({ filters: [f] }).length);
+  if (!active.length || !bounds) return null;
+  const primitives = [];
+  let body = "SourceGraphic";
+  let n = 0;
+  const name = (part) => `${part}${n}`;
+  for (const f of active) {
+    if (f.type !== "innerShadow" && f.type !== "innerGlow") continue;
+    n++;
+    const p = f.params;
+    primitives.push(fe("feComponentTransfer", { in: "SourceAlpha", result: name("inv") }, [fe("feFuncA", { type: "table", tableValues: "1 0" })]));
+    let last = name("inv");
+    if (f.type === "innerShadow" && (f.params.offsetX || f.params.offsetY)) {
+      primitives.push(fe("feOffset", { in: last, dx: round(f.params.offsetX), dy: round(f.params.offsetY), result: name("off") }));
+      last = name("off");
+    }
+    if (p.spread > 0) {
+      primitives.push(fe("feMorphology", { in: last, operator: "dilate", radius: round(p.spread), result: name("grow") }));
+      last = name("grow");
+    }
+    if (p.blur > 0) {
+      primitives.push(fe("feGaussianBlur", { in: last, stdDeviation: round(p.blur / 2), result: name("blur") }));
+      last = name("blur");
+    }
+    primitives.push(fe("feFlood", { "flood-color": p.color, "flood-opacity": round(p.opacity), result: name("color") }));
+    primitives.push(fe("feComposite", { in: name("color"), in2: last, operator: "in", result: name("tint") }));
+    primitives.push(fe("feComposite", { in: name("tint"), in2: "SourceAlpha", operator: "in", result: name("inner") }));
+    primitives.push(fe("feComposite", { in: name("inner"), in2: body, operator: "over", result: name("body") }));
+    body = name("body");
+  }
+  for (const f of active) {
+    if (f.type !== "feather") continue;
+    n++;
+    const r = f.params.radius;
+    primitives.push(fe("feMorphology", { in: "SourceAlpha", operator: "erode", radius: round(r / 2), result: name("core") }));
+    primitives.push(fe("feGaussianBlur", { in: name("core"), stdDeviation: round(r / 4), result: name("fade") }));
+    primitives.push(fe("feComposite", { in: body, in2: name("fade"), operator: "in", result: name("body") }));
+    body = name("body");
+  }
+  const under = [];
+  for (const f of active) {
+    if (f.type !== "dropShadow" && f.type !== "outerGlow") continue;
+    n++;
+    const p = f.params;
+    let last = "SourceAlpha";
+    if (p.spread > 0) {
+      primitives.push(fe("feMorphology", { in: last, operator: "dilate", radius: round(p.spread), result: name("grow") }));
+      last = name("grow");
+    }
+    if (p.blur > 0) {
+      primitives.push(fe("feGaussianBlur", { in: last, stdDeviation: round(p.blur / 2), result: name("blur") }));
+      last = name("blur");
+    }
+    if (f.type === "dropShadow" && (f.params.offsetX || f.params.offsetY)) {
+      primitives.push(fe("feOffset", { in: last, dx: round(f.params.offsetX), dy: round(f.params.offsetY), result: name("off") }));
+      last = name("off");
+    }
+    primitives.push(fe("feFlood", { "flood-color": p.color, "flood-opacity": round(p.opacity), result: name("color") }));
+    primitives.push(fe("feComposite", { in: name("color"), in2: last, operator: "in", result: name("shadow") }));
+    under.push(name("shadow"));
+  }
+  if (under.length) {
+    n++;
+    primitives.push(fe("feMerge", { result: name("merged") }, [...under, body].map((i) => fe("feMergeNode", { in: i }))));
+    body = name("merged");
+  }
+  for (const f of active) {
+    if (f.type !== "layerBlur") continue;
+    n++;
+    primitives.push(fe("feGaussianBlur", { in: body, stdDeviation: round(f.params.radius / 2), result: name("body") }));
+    body = name("body");
+  }
+  const lastResult = _optionalChain([primitives, 'access', _93 => _93[primitives.length - 1], 'optionalAccess', _94 => _94.attrs, 'access', _95 => _95.result]);
+  if (lastResult !== body) primitives.push(fe("feMerge", {}, [fe("feMergeNode", { in: body })]));
+  const pad = vectorFilterReach(active) + 2;
+  return {
+    id,
+    x: round(bounds.x - pad),
+    y: round(bounds.y - pad),
+    width: round(bounds.width + 2 * pad),
+    height: round(bounds.height + 2 * pad),
+    primitives
+  };
+}
+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', _96 => _96.children, 'optionalAccess', _97 => _97.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>`;
+}
+var VECTOR_FILTER_MENU = VECTOR_FILTER_TYPES.map((type) => ({ type, label: VECTOR_FILTER_LABELS[type] }));
+
 // src/vector/gradientStroke.ts
 var SHARP = 1.25;
 var TOLERANCE = 0.2;
@@ -4442,7 +4939,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', _83 => _83[+m[1]], 'optionalAccess', _84 => _84.anchors, 'access', _85 => _85[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _98 => _98[+m[1]], 'optionalAccess', _99 => _99.anchors, 'access', _100 => _100[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -4450,7 +4947,7 @@ function applyVectorCornersAttribute(subpaths, value) {
   }
   return subpaths;
 }
-var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var escapeAttr2 = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 function vectorPathLocalBounds(node) {
   const b = _chunkXGD3FSNCcjs.bezierPathBounds.call(void 0, subpathsToBezier(node.subpaths));
   return b ? { x: b.minX, y: b.minY, width: b.maxX - b.minX, height: b.maxY - b.minY } : null;
@@ -4464,7 +4961,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', _86 => _86.get, 'call', _87 => _87(owner), 'optionalAccess', _88 => _88.get, 'call', _89 => _89(key)]);
+  const cached = _optionalChain([paintCache, 'access', _101 => _101.get, 'call', _102 => _102(owner), 'optionalAccess', _103 => _103.get, 'call', _104 => _104(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;
@@ -4506,6 +5003,26 @@ function computeStrokeSvgParts(node, clipId, precision) {
     heads: parts.heads.map((h) => _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, h.path, { precision }))
   };
 }
+function vectorNodeLocalPaintBounds(node) {
+  const drawn = expandVectorAppearance(node);
+  const reach = (n) => n.type === "path" ? vectorStrokeStackReach(n) : Math.max(0, ...n.children.map(reach));
+  let b;
+  if (drawn.type === "path") b = vectorPathLocalBounds(drawn);
+  else b = unionBounds(drawn.children.filter((c) => c.visible !== false).map((c) => vectorNodeBounds(c, _chunkDWGZUSEScjs.IDENTITY_MATRIX)));
+  if (!b) return null;
+  const pad = reach(drawn);
+  return { x: b.x - pad, y: b.y - pad, width: b.width + 2 * pad, height: b.height + 2 * pad };
+}
+var filterCache = /* @__PURE__ */ new WeakMap();
+function vectorNodeFilterSvg(node, id) {
+  if (!_optionalChain([node, 'access', _105 => _105.filters, 'optionalAccess', _106 => _106.length])) return null;
+  const hit = filterCache.get(node);
+  if (hit && hit.id === id) return hit.filter;
+  const active = activeVectorFilters(node);
+  const filter = active.length ? vectorFilterSvg(active, id, vectorNodeLocalPaintBounds(node)) : null;
+  filterCache.set(node, { id, filter });
+  return filter;
+}
 function widthProfileToAttribute(points, precision = 4) {
   return points.map((p) => [p.t, p.left, p.right].map((n) => _chunkXGD3FSNCcjs.formatNumber.call(void 0, n, precision)).join(",")).join(";");
 }
@@ -4521,16 +5038,16 @@ function widthProfileFromAttribute(value) {
 var round2 = (n) => Math.round(n * 100) / 100;
 function gradientMarkup(def, extra = "") {
   const tag = def.type === "radial" ? "radialGradient" : "linearGradient";
-  const attrs = Object.entries(def.attrs).map(([k, v2]) => ` ${k}="${escapeAttr(String(v2))}"`).join("");
-  const stops = def.stops.map((s) => `<stop offset="${s.offset}" stop-color="${escapeAttr(s.stopColor)}"${s.stopOpacity !== void 0 ? ` stop-opacity="${s.stopOpacity}"` : ""}/>`).join("");
-  return `<${tag} id="${escapeAttr(def.id)}"${attrs}${extra}>${stops}</${tag}>`;
+  const attrs = Object.entries(def.attrs).map(([k, v2]) => ` ${k}="${escapeAttr2(String(v2))}"`).join("");
+  const stops = def.stops.map((s) => `<stop offset="${s.offset}" stop-color="${escapeAttr2(s.stopColor)}"${s.stopOpacity !== void 0 ? ` stop-opacity="${s.stopOpacity}"` : ""}/>`).join("");
+  return `<${tag} id="${escapeAttr2(def.id)}"${attrs}${extra}>${stops}</${tag}>`;
 }
 function paintDefMarkup(def, gradient) {
-  const extra = gradient ? ` data-vector-gradient="${escapeAttr(JSON.stringify(gradient))}"` : "";
+  const extra = gradient ? ` data-vector-gradient="${escapeAttr2(JSON.stringify(gradient))}"` : "";
   if (def.type !== "pattern") return gradientMarkup(def, extra);
-  const attrs = Object.entries(def.attrs).map(([k, v2]) => ` ${k}="${escapeAttr(String(v2))}"`).join("");
-  const inner = def.gradients.map((g) => gradientMarkup(g)).join("") + def.tiles.map((t) => `<path d="${t.d}" fill="${escapeAttr(t.fill)}"/>`).join("");
-  return `<pattern id="${escapeAttr(def.id)}"${attrs}${extra}>${inner}</pattern>`;
+  const attrs = Object.entries(def.attrs).map(([k, v2]) => ` ${k}="${escapeAttr2(String(v2))}"`).join("");
+  const inner = def.gradients.map((g) => gradientMarkup(g)).join("") + def.tiles.map((t) => `<path d="${t.d}" fill="${escapeAttr2(t.fill)}"/>`).join("");
+  return `<pattern id="${escapeAttr2(def.id)}"${attrs}${extra}>${inner}</pattern>`;
 }
 var paintMarkup = (paint, defs) => defs.map((d, i) => paintDefMarkup(d, i === 0 && isVectorGradient(paint) ? paint : void 0));
 function blendFromAttribute(value, m) {
@@ -4569,25 +5086,113 @@ function vectorDocumentToSvg(doc, options = {}) {
   const num2 = (n) => _chunkXGD3FSNCcjs.formatNumber.call(void 0, n, precision);
   const indent = (depth) => pretty ? "  ".repeat(depth) : "";
   const common = (node) => {
-    let out2 = ` id="${escapeAttr(node.id)}"`;
+    let out2 = ` id="${escapeAttr2(node.id)}"`;
     if (node.transform) out2 += ` transform="matrix(${node.transform.map((n) => _chunkXGD3FSNCcjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
     if (node.opacity !== void 0 && node.opacity < 1) out2 += ` opacity="${num2(node.opacity)}"`;
     if (node.visible === false) out2 += ` display="none"`;
     if (node.blendStep) out2 += ` data-vector-blend-step=""`;
-    if (node.type === "group" && node.blend) out2 += ` data-vector-blend="${escapeAttr(JSON.stringify(node.blend))}"`;
+    if (node.type === "group" && node.blend) out2 += ` data-vector-blend="${escapeAttr2(JSON.stringify(node.blend))}"`;
     if (node.booleanOperation) out2 += ` data-vector-boolean-operation="${node.booleanOperation}"`;
+    const blend = vectorBlendModeCss(node.blendMode);
+    if (blend) out2 += ` style="mix-blend-mode:${blend}"`;
+    if (_optionalChain([node, 'access', _107 => _107.filters, 'optionalAccess', _108 => _108.length])) {
+      const filter = vectorNodeFilterSvg(node, `${prefix}filter-${node.id}`);
+      const data = ` data-vector-filters="${escapeAttr2(JSON.stringify(node.filters))}"`;
+      if (filter) {
+        defs.push(vectorFilterMarkup(filter, data));
+        out2 += ` filter="url(#${escapeAttr2(filter.id)})"`;
+      } else out2 += data;
+    }
+    return out2;
+  };
+  const layerAttrs = (layer) => {
+    let out2 = "";
+    if (layer.opacity !== void 0 && layer.opacity < 1) out2 += ` opacity="${num2(layer.opacity)}"`;
+    const blend = vectorBlendModeCss(layer.blendMode);
+    if (blend) out2 += ` style="mix-blend-mode:${blend}"`;
     return out2;
   };
+  const strokePartLines = (node, parts, strokeValue, d, lineAttrs, depth) => {
+    const out2 = [];
+    if (options.strokes === "outline") {
+      const area = _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
+      out2.push(`${indent(depth)}<path data-vector-part="stroke-outline" d="${area}" fill="${escapeAttr2(strokeValue)}"/>`);
+      return out2;
+    }
+    let clip = "";
+    if (parts.clip) {
+      const rule = node.fillRule === "evenodd" ? "evenodd" : "nonzero";
+      const id = escapeAttr2(parts.clip.id);
+      if (parts.clip.kind === "clip") {
+        defs.push(`<clipPath id="${id}"><path d="${d}" clip-rule="${rule}"/></clipPath>`);
+        clip = ` clip-path="url(#${id})"`;
+      } else {
+        const b = parts.clip.bounds;
+        const box = `x="${num2(b.x)}" y="${num2(b.y)}" width="${num2(b.width)}" height="${num2(b.height)}"`;
+        defs.push(`<mask id="${id}" maskUnits="userSpaceOnUse" ${box}><rect ${box} fill="#fff"/><path d="${d}" fill="#000" fill-rule="${rule}"/></mask>`);
+        clip = ` mask="url(#${id})"`;
+      }
+    }
+    if (parts.outline !== void 0) out2.push(`${indent(depth)}<path data-vector-part="stroke-outline" d="${parts.outline}" fill="${escapeAttr2(strokeValue)}"${clip}/>`);
+    else out2.push(`${indent(depth)}<path data-vector-part="stroke" d="${parts.d}" fill="none"${lineAttrs(parts.width)}${clip}/>`);
+    for (const h2 of parts.heads) out2.push(`${indent(depth)}<path data-vector-part="head" d="${h2}" fill="${escapeAttr2(strokeValue)}"/>`);
+    return out2;
+  };
+  const lineAttrsOf = (node, strokeValue) => (width) => {
+    let out2 = ` stroke="${escapeAttr2(strokeValue)}" stroke-width="${num2(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', _109 => _109.strokeDasharray, 'optionalAccess', _110 => _110.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
+    return out2;
+  };
+  const liveCorners = (node) => {
+    const corners = vectorCornersAttribute(node.subpaths, precision);
+    return corners ? ` data-vector-d="${_chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners}"` : "";
+  };
+  const emitStacked = (node, depth) => {
+    const d = vectorPathData(node, precision);
+    const rule = node.fillRule === "evenodd" ? ` fill-rule="evenodd"` : "";
+    let data = ` data-vector-path="" data-vector-fills="${escapeAttr2(JSON.stringify(vectorFills(node)))}" data-vector-strokes="${escapeAttr2(JSON.stringify(vectorStrokes(node)))}"`;
+    if (node.fillRule === "evenodd") data += ` data-vector-fill-rule="evenodd"`;
+    lines.push(`${indent(depth)}<g${common(node)}${data}>`);
+    const layers = vectorPaintLayerNodes(node).filter((l) => l.drawn);
+    let geometry = liveCorners(node);
+    if (!layers.some((l) => l.kind === "fill")) {
+      lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}" fill="none"${rule}${geometry}/>`);
+      geometry = "";
+    }
+    for (const l of layers) {
+      const id = `${prefix}${l.kind}-${node.id}-${l.index}`;
+      const paint = vectorPaintToSvg(l.layer.paint, id, { node: l.node, precision, ...l.kind === "stroke" ? { role: "stroke" } : {} });
+      defs.push(...paintMarkup(l.layer.paint, paint.defs));
+      const attrs = ` data-vector-layer="${l.index}"${layerAttrs(l.layer)}`;
+      if (l.kind === "fill") {
+        lines.push(`${indent(depth + 1)}<path data-vector-part="fill"${attrs} d="${d}" fill="${escapeAttr2(paint.value)}"${rule}${geometry}/>`);
+        geometry = "";
+        continue;
+      }
+      const lineAttrs = lineAttrsOf(l.node, paint.value);
+      const parts = vectorStrokeSvgParts(l.node, `${prefix}clip-${node.id}-${l.index}`, precision);
+      if (!parts) {
+        lines.push(`${indent(depth + 1)}<path data-vector-part="stroke"${attrs} d="${d}" fill="none"${lineAttrs(_nullishCoalesce(l.node.strokeWidth, () => ( 1)))}/>`);
+        continue;
+      }
+      lines.push(`${indent(depth + 1)}<g data-vector-part="stroke-layer"${attrs}>`);
+      lines.push(...strokePartLines(l.node, parts, paint.value, d, lineAttrs, depth + 2));
+      lines.push(`${indent(depth + 1)}</g>`);
+    }
+    lines.push(`${indent(depth)}</g>`);
+  };
   const emit2 = (node, depth) => {
     if (node.visible === false && !options.includeHidden) return;
-    const wrappers = _nullishCoalesce(_optionalChain([options, 'access', _90 => _90.wrap, 'optionalAccess', _91 => _91[node.id]]), () => ( []));
+    const wrappers = _nullishCoalesce(_optionalChain([options, 'access', _111 => _111.wrap, 'optionalAccess', _112 => _112[node.id]]), () => ( []));
     wrappers.forEach((w2, i) => {
-      let attrs = w2.id !== void 0 ? ` id="${escapeAttr(w2.id)}"` : "";
-      if (w2.transform) attrs += ` transform="${escapeAttr(w2.transform)}"`;
+      let attrs = w2.id !== void 0 ? ` id="${escapeAttr2(w2.id)}"` : "";
+      if (w2.transform) attrs += ` transform="${escapeAttr2(w2.transform)}"`;
       if (w2.clip) {
         const shape = Object.entries(w2.clip.attrs).map(([k, v2]) => ` ${k}="${_chunkXGD3FSNCcjs.formatNumber.call(void 0, v2, 4)}"`).join("");
-        defs.push(`<clipPath id="${escapeAttr(w2.clip.id)}" clipPathUnits="objectBoundingBox"><${w2.clip.shape}${w2.clip.shapeId !== void 0 ? ` id="${escapeAttr(w2.clip.shapeId)}"` : ""}${shape}/></clipPath>`);
-        attrs += ` clip-path="url(#${escapeAttr(w2.clip.id)})"`;
+        defs.push(`<clipPath id="${escapeAttr2(w2.clip.id)}" clipPathUnits="objectBoundingBox"><${w2.clip.shape}${w2.clip.shapeId !== void 0 ? ` id="${escapeAttr2(w2.clip.shapeId)}"` : ""}${shape}/></clipPath>`);
+        attrs += ` clip-path="url(#${escapeAttr2(w2.clip.id)})"`;
       }
       lines.push(`${indent(depth + i)}<g${attrs}>`);
     });
@@ -4598,16 +5203,16 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (hasOwnVectorAppearance(node)) {
       const live2 = {
         kind: node.type,
-        ..._optionalChain([node, 'access', _92 => _92.effects, 'optionalAccess', _93 => _93.length]) ? { effects: node.effects } : {},
+        ..._optionalChain([node, 'access', _113 => _113.effects, 'optionalAccess', _114 => _114.length]) ? { effects: node.effects } : {},
         ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {}
       };
-      lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr(JSON.stringify(live2))}">`);
+      lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr2(JSON.stringify(live2))}">`);
       lines.push(`${indent(depth + 1)}<g data-vector-part="appearance">`);
       for (const shape of vectorAppearanceNodes(node)) emit2(shape, depth + 2);
       lines.push(`${indent(depth + 1)}</g>`);
       lines.push(`${indent(depth + 1)}<g data-vector-part="source" display="none">`);
       if (node.type === "path") {
-        const { effects: _e, transform: _t, opacity: _o, visible: _v, booleanOperation: _b, blendStep: _s, ...source } = node;
+        const { effects: _e, transform: _t, opacity: _o, visible: _v, booleanOperation: _b, blendStep: _s, blendMode: _bm, filters: _f, ...source } = node;
         emit2({ ...source, id: `${node.id}~src` }, depth + 2);
       } else for (const child of node.children) emit2(child, depth + 2);
       lines.push(`${indent(depth + 1)}</g>`);
@@ -4620,20 +5225,17 @@ function vectorDocumentToSvg(doc, options = {}) {
       lines.push(`${indent(depth)}</g>`);
       return;
     }
+    if (needsVectorPaintLayers(node)) {
+      emitStacked(node, depth);
+      return;
+    }
     const fill = vectorPaintToSvg(node.fill, `${prefix}fill-${node.id}`, { node, precision });
     const stroke = vectorPaintToSvg(node.stroke, `${prefix}stroke-${node.id}`, { node, role: "stroke", precision });
     defs.push(...paintMarkup(node.fill, fill.defs), ...paintMarkup(node.stroke, stroke.defs));
     const d = vectorPathData(node, precision);
-    const corners = vectorCornersAttribute(node.subpaths, precision);
-    const live = corners ? ` data-vector-d="${_chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners}"` : "";
-    const fillAttrs = ` fill="${escapeAttr(fill.value)}"${node.fillRule === "evenodd" ? ` fill-rule="evenodd"` : ""}`;
-    const lineAttrs = (width) => {
-      let out2 = ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num2(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', _94 => _94.strokeDasharray, 'optionalAccess', _95 => _95.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
-      return out2;
-    };
+    const live = liveCorners(node);
+    const fillAttrs = ` fill="${escapeAttr2(fill.value)}"${node.fillRule === "evenodd" ? ` fill-rule="evenodd"` : ""}`;
+    const lineAttrs = lineAttrsOf(node, stroke.value);
     const parts = stroke.value !== "none" ? vectorStrokeSvgParts(node, `${prefix}clip-${node.id}`, precision) : void 0;
     if (!parts) {
       lines.push(`${indent(depth)}<path${common(node)} d="${d}"${fillAttrs}${stroke.value !== "none" ? lineAttrs(_nullishCoalesce(node.strokeWidth, () => ( 1))) : ""}${live}/>`);
@@ -4651,32 +5253,11 @@ 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', _96 => _96.strokeDasharray, 'optionalAccess', _97 => _97.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
+      if (_optionalChain([node, 'access', _115 => _115.strokeDasharray, 'optionalAccess', _116 => _116.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
     }
     lines.push(`${indent(depth)}<g${common(node)}${data}>`);
     lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}"${fillAttrs}${live}/>`);
-    if (options.strokes === "outline") {
-      const area = _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
-      lines.push(`${indent(depth + 1)}<path data-vector-part="stroke-outline" d="${area}" fill="${escapeAttr(stroke.value)}"/>`);
-    } else {
-      let clip = "";
-      if (parts.clip) {
-        const rule = node.fillRule === "evenodd" ? "evenodd" : "nonzero";
-        const id = escapeAttr(parts.clip.id);
-        if (parts.clip.kind === "clip") {
-          defs.push(`<clipPath id="${id}"><path d="${d}" clip-rule="${rule}"/></clipPath>`);
-          clip = ` clip-path="url(#${id})"`;
-        } else {
-          const b = parts.clip.bounds;
-          const box = `x="${num2(b.x)}" y="${num2(b.y)}" width="${num2(b.width)}" height="${num2(b.height)}"`;
-          defs.push(`<mask id="${id}" maskUnits="userSpaceOnUse" ${box}><rect ${box} fill="#fff"/><path d="${d}" fill="#000" fill-rule="${rule}"/></mask>`);
-          clip = ` mask="url(#${id})"`;
-        }
-      }
-      if (parts.outline !== void 0) lines.push(`${indent(depth + 1)}<path data-vector-part="stroke-outline" d="${parts.outline}" fill="${escapeAttr(stroke.value)}"${clip}/>`);
-      else lines.push(`${indent(depth + 1)}<path data-vector-part="stroke" d="${parts.d}" fill="none"${lineAttrs(parts.width)}${clip}/>`);
-      for (const h2 of parts.heads) lines.push(`${indent(depth + 1)}<path data-vector-part="head" d="${h2}" fill="${escapeAttr(stroke.value)}"/>`);
-    }
+    lines.push(...strokePartLines(node, parts, stroke.value, d, lineAttrs, depth + 1));
     lines.push(`${indent(depth)}</g>`);
   };
   for (const node of doc.nodes) emit2(node, 1);
@@ -4686,7 +5267,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   const out = [`<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="0 0 ${w} ${h}">`];
   if (defs.length) out.push(`${indent(1)}<defs>${defs.join("")}</defs>`);
   if (doc.background && options.background !== false && hasPaint(doc.background)) {
-    out.push(`${indent(1)}<rect width="${w}" height="${h}" fill="${escapeAttr(doc.background)}"/>`);
+    out.push(`${indent(1)}<rect width="${w}" height="${h}" fill="${escapeAttr2(doc.background)}"/>`);
   }
   out.push(...lines, "</svg>");
   return out.join(nl);
@@ -4777,10 +5358,15 @@ var STYLE_KEYS2 = {
   "stroke-linecap": "strokeLinecap",
   "stroke-linejoin": "strokeLinejoin",
   "stroke-dasharray": "strokeDasharray",
-  "fill-rule": "fillRule"
+  "fill-rule": "fillRule",
+  "fill-opacity": "fillOpacity",
+  "stroke-opacity": "strokeOpacity",
+  "mix-blend-mode": "mixBlendMode",
+  filter: "filter"
 };
 function readStyle(el, parent) {
-  const out = { ...parent };
+  const { mixBlendMode: _m, filter: _f, ...inherited } = parent;
+  const out = { ...inherited };
   for (const [attr, key] of Object.entries(STYLE_KEYS2)) if (el.attrs[attr] !== void 0) out[key] = el.attrs[attr].trim();
   for (const decl of (_nullishCoalesce(el.attrs.style, () => ( ""))).split(";")) {
     const i = decl.indexOf(":");
@@ -4816,11 +5402,50 @@ function collectGradients(el, raw) {
   if (PAINT_SERVERS.has(el.name) && el.attrs.id) raw.set(el.attrs.id, el);
   for (const c of el.children) collectGradients(c, raw);
 }
+function collectFilters(el, raw) {
+  if (el.name === "filter" && el.attrs.id) raw.set(el.attrs.id, el);
+  for (const c of el.children) collectFilters(c, raw);
+}
+function filtersFromElement(el) {
+  const own = el.attrs["data-vector-filters"];
+  if (own !== void 0) {
+    try {
+      return sanitizeVectorFilters(JSON.parse(own));
+    } catch (e4) {
+      return [];
+    }
+  }
+  const prims = el.children.filter((c) => c.name.startsWith("fe"));
+  const out = [];
+  for (const p of prims) {
+    const std = _nullishCoalesce(numberList(p.attrs.stdDeviation)[0], () => ( 0));
+    if (p.name === "feDropShadow") {
+      const style = Object.fromEntries(
+        (_nullishCoalesce(p.attrs.style, () => ( ""))).split(";").map((d) => d.split(":").map((x) => x.trim())).filter((d) => d.length === 2)
+      );
+      const opacity = parseFloat(_nullishCoalesce(_nullishCoalesce(style["flood-opacity"], () => ( p.attrs["flood-opacity"])), () => ( "1")));
+      out.push({
+        type: "dropShadow",
+        params: {
+          color: _nullishCoalesce(_nullishCoalesce(style["flood-color"], () => ( p.attrs["flood-color"])), () => ( "#000000")),
+          opacity: Number.isFinite(opacity) ? opacity : 1,
+          offsetX: length(p.attrs.dx, 2),
+          offsetY: length(p.attrs.dy, 2),
+          blur: std * 2,
+          spread: 0
+        }
+      });
+    } else if (p.name === "feGaussianBlur" && prims.length === 1 && (p.attrs.in === void 0 || p.attrs.in === "SourceGraphic")) {
+      out.push({ type: "layerBlur", params: { radius: std * 2 } });
+    } else return [];
+  }
+  return sanitizeVectorFilters(out);
+}
 function gradientFromAttribute(value) {
   if (!value) return null;
   try {
     return sanitizeVectorGradient(JSON.parse(value));
-  } catch (e4) {
+  } catch (e5) {
     return null;
   }
 }
@@ -4834,9 +5459,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', _98 => _98.startsWith, 'call', _99 => _99("#")]) ? raw.get(href.slice(1)) : void 0;
+    el = _optionalChain([href, 'optionalAccess', _117 => _117.startsWith, 'call', _118 => _118("#")]) ? raw.get(href.slice(1)) : void 0;
   }
-  const attr = (name) => _optionalChain([chain, 'access', _100 => _100.find, 'call', _101 => _101((el) => el.attrs[name] !== void 0), 'optionalAccess', _102 => _102.attrs, 'access', _103 => _103[name]]);
+  const attr = (name) => _optionalChain([chain, 'access', _119 => _119.find, 'call', _120 => _120((el) => el.attrs[name] !== void 0), 'optionalAccess', _121 => _121.attrs, 'access', _122 => _122[name]]);
   const stops = _nullishCoalesce(chain.map(readStops).find((s) => s.length), () => ( []));
   if (!stops.length) return null;
   const user = attr("gradientUnits") === "userSpaceOnUse";
@@ -4913,6 +5538,13 @@ function parseVectorSvg(svg, options = {}) {
   };
   const rawGradients = /* @__PURE__ */ new Map();
   collectGradients(root, rawGradients);
+  const rawFilters = /* @__PURE__ */ new Map();
+  collectFilters(root, rawFilters);
+  const filtersOf = (value) => {
+    const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec((_nullishCoalesce(value, () => ( ""))).trim());
+    const el = url ? rawFilters.get(url[1]) : void 0;
+    return el ? filtersFromElement(el) : [];
+  };
   const paint = (value) => {
     const v2 = value.trim();
     const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec(v2);
@@ -4979,14 +5611,61 @@ function parseVectorSvg(svg, options = {}) {
     if (m === _chunkDWGZUSEScjs.IDENTITY_MATRIX) return node;
     const next = transformVectorNode(node, m);
     const strokeScale = Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
-    if (hasPaint(next.stroke) && strokeScale > 0 && Math.abs(strokeScale - 1) > 1e-9) next.strokeWidth = (_nullishCoalesce(next.strokeWidth, () => ( 1))) * strokeScale;
-    return next;
+    if (strokeScale > 0 && Math.abs(strokeScale - 1) > 1e-9) {
+      if (hasPaint(next.stroke)) next.strokeWidth = (_nullishCoalesce(next.strokeWidth, () => ( 1))) * strokeScale;
+      if (Array.isArray(next.strokes)) next.strokes = next.strokes.map((l) => (_nullishCoalesce(l.kind, () => ( "paint"))) === "paint" ? { ...l, strokeWidth: (_nullishCoalesce(l.strokeWidth, () => ( 1))) * strokeScale } : l);
+    }
+    return normalizeVectorPaintStacks(next, "stack");
+  };
+  const withOpacities = (node, s) => {
+    let out = node;
+    const fo = s.fillOpacity !== void 0 ? fraction(s.fillOpacity, 1) : 1;
+    const so = s.strokeOpacity !== void 0 ? fraction(s.strokeOpacity, 1) : 1;
+    if (fo < 1 && hasPaint(out.fill)) out = withVectorFills(out, [{ paint: out.fill, opacity: Math.max(0, fo) }]);
+    if (so < 1 && hasPaint(out.stroke)) out = withVectorStrokes(out, vectorStrokes(out).map((l) => ({ ...l, opacity: Math.max(0, so) })));
+    return out;
+  };
+  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', _123 => _123.length])) return null;
+    const parse = (v2) => {
+      try {
+        return v2 ? JSON.parse(v2) : [];
+      } catch (e6) {
+        return [];
+      }
+    };
+    let node = { id: idFor(g), type: "path", ...meta, subpaths, fill: null, stroke: null };
+    if (g.attrs["data-vector-fill-rule"] === "evenodd") node.fillRule = "evenodd";
+    node = withVectorFills(node, sanitizeVectorFills(parse(g.attrs["data-vector-fills"])));
+    node = withVectorStrokes(node, sanitizeVectorStrokes(parse(g.attrs["data-vector-strokes"])));
+    return placed(node, m);
+  };
+  const mergeStacked = (nodes2) => {
+    const out = [];
+    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', _124 => _124.type]) === "path" && n.type === "path" && key(prev) === key(n)) {
+        const fills = vectorFills(n);
+        const strokesBefore = vectorStrokes(prev);
+        if (!(fills.length && strokesBefore.length)) {
+          let merged = withVectorFills(prev, [...vectorFills(prev), ...fills]);
+          merged = withVectorStrokes(merged, [...strokesBefore, ...vectorStrokes(n)]);
+          out[out.length - 1] = merged;
+          continue;
+        }
+      }
+      out.push(n);
+    }
+    return out;
   };
   const mergedPath = (g, style, m, meta) => {
     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', _104 => _104.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _125 => _125.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style);
     const strokeEl = part("stroke");
@@ -5023,7 +5702,7 @@ function parseVectorSvg(svg, options = {}) {
       ...profile.length ? { strokeWidthProfile: profile } : {},
       ...keptCap ? { strokeLinecap: keptCap } : {},
       ...keptJoin ? { strokeLinejoin: keptJoin } : {},
-      ..._optionalChain([keptDash, 'optionalAccess', _105 => _105.length]) ? { strokeDasharray: keptDash } : {}
+      ..._optionalChain([keptDash, 'optionalAccess', _126 => _126.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
@@ -5031,7 +5710,7 @@ function parseVectorSvg(svg, options = {}) {
     let raw = {};
     try {
       raw = _nullishCoalesce(JSON.parse(g.attrs["data-vector-live"]), () => ( {}));
-    } catch (e5) {
+    } catch (e7) {
       raw = {};
     }
     const sourceEl = g.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === "source");
@@ -5063,10 +5742,14 @@ function parseVectorSvg(svg, options = {}) {
       const s = readStyle(child, style);
       const opacity = child.attrs.opacity !== void 0 ? parseFloat(child.attrs.opacity) : void 0;
       const hidden = child.attrs.display === "none" || child.attrs.visibility === "hidden";
+      const blendMode = vectorBlendModeFromCss(s.mixBlendMode);
+      const filters = filtersOf(s.filter);
       const meta = {
         ...child.attrs["inkscape:label"] || child.attrs["data-name"] ? { name: _nullishCoalesce(child.attrs["inkscape:label"], () => ( child.attrs["data-name"])) } : {},
         ...opacity !== void 0 && Number.isFinite(opacity) && opacity < 1 ? { opacity } : {},
-        ...hidden ? { visible: false } : {}
+        ...hidden ? { visible: false } : {},
+        ...blendMode && blendMode !== "normal" ? { blendMode } : {},
+        ...filters.length ? { filters } : {}
       };
       if (child.attrs["data-vector-blend-step"] !== void 0) continue;
       const operation = child.attrs["data-vector-boolean-operation"];
@@ -5076,6 +5759,11 @@ function parseVectorSvg(svg, options = {}) {
         if (node2) out.push(node2);
         continue;
       }
+      if (child.name === "g" && child.attrs["data-vector-path"] !== void 0 && child.attrs["data-vector-fills"] !== void 0) {
+        const node2 = stackedPath(child, s, m, meta);
+        if (node2) out.push(node2);
+        continue;
+      }
       if (child.name === "g" && child.attrs["data-vector-path"] !== void 0) {
         const node2 = mergedPath(child, s, m, meta);
         if (node2) out.push(node2);
@@ -5093,20 +5781,23 @@ function parseVectorSvg(svg, options = {}) {
       const subpaths = shapeOf(child);
       if (!subpaths || !subpaths.length) continue;
       const node = placed(
-        {
-          id: idFor(child),
-          type: "path",
-          ...meta,
-          subpaths,
-          fill: child.name === "line" ? null : paint(s.fill),
-          stroke: paint(s.stroke),
-          ...strokeStyle(s)
-        },
+        withOpacities(
+          {
+            id: idFor(child),
+            type: "path",
+            ...meta,
+            subpaths,
+            fill: child.name === "line" ? null : paint(s.fill),
+            stroke: paint(s.stroke),
+            ...strokeStyle(s)
+          },
+          s
+        ),
         m
       );
       out.push(node);
     }
-    return out;
+    return options.mergeStackedShapes ? mergeStacked(out) : out;
   };
   const nodes = visit(root, readStyle(root, { fill: "#000", stroke: "none", strokeWidth: "" }), rootMatrix);
   return { width, height, nodes };
@@ -5342,5 +6033,48 @@ function parseVectorSvg(svg, options = {}) {
 
 
 
-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_SPACINGS = VECTOR_BLEND_SPACINGS; 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.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.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.effectPathLength = effectPathLength; exports.effectPathVertexCount = effectPathVertexCount; exports.trimIntervals = trimIntervals; exports.trimPaths = trimPaths; exports.trimPathsIndividually = trimPathsIndividually; exports.puckerBloatPaths = puckerBloatPaths; exports.roundCornerPaths = roundCornerPaths; exports.offsetPaths = offsetPaths; 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.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.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.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.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.subpathToMorphContour = subpathToMorphContour; exports.morphContourToSubpath = morphContourToSubpath; exports.refineMorphContour = refineMorphContour; exports.reverseMorphContour = reverseMorphContour; exports.turnMorphContour = turnMorphContour; exports.correspondMorphContours = correspondMorphContours; exports.morphPathsCross = morphPathsCross; exports.interpolateMorphContours = interpolateMorphContours; exports.interpolateRigidMatrix = interpolateRigidMatrix; exports.interpolateVectorColor = interpolateVectorColor; exports.resampleGradientStops = resampleGradientStops; exports.interpolateVectorPaint = interpolateVectorPaint; exports.interpolateWidthProfiles = interpolateWidthProfiles; exports.interpolateVectorStyle = interpolateVectorStyle; exports.createVectorMorph = createVectorMorph; exports.interpolateVectorPaths = interpolateVectorPaths; exports.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; exports.vectorStrokeGradientDefs = vectorStrokeGradientDefs; exports.vectorCornersAttribute = vectorCornersAttribute; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.vectorPathLocalBounds = vectorPathLocalBounds; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.widthProfileToAttribute = widthProfileToAttribute; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg;
-//# sourceMappingURL=chunk-JF5PXN7W.cjs.map
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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_BLEND_SPACINGS = VECTOR_BLEND_SPACINGS; 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.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.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.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.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.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.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.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.subpathToMorphContour = subpathToMorphContour; exports.morphContourToSubpath = morphContourToSubpath; exports.refineMorphContour = refineMorphContour; exports.reverseMorphContour = reverseMorphContour; exports.turnMorphContour = turnMorphContour; exports.correspondMorphContours = correspondMorphContours; exports.morphPathsCross = morphPathsCross; exports.interpolateMorphContours = interpolateMorphContours; exports.interpolateRigidMatrix = interpolateRigidMatrix; exports.interpolateVectorColor = interpolateVectorColor; exports.resampleGradientStops = resampleGradientStops; exports.interpolateVectorPaint = interpolateVectorPaint; exports.interpolateWidthProfiles = interpolateWidthProfiles; exports.interpolateVectorStyle = interpolateVectorStyle; exports.createVectorMorph = createVectorMorph; exports.interpolateVectorPaths = interpolateVectorPaths; exports.evaluateVectorPathKeyframes = evaluateVectorPathKeyframes; 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.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;
+//# sourceMappingURL=chunk-KANRAHTL.cjs.map