@pixerate/editor 0.106.0 → 0.108.0

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

@@ -21,6 +21,11 @@
 
 
 
+
+
+
+
+
 
 
 
@@ -95,6 +100,7 @@ var VECTOR_BLEND_MODES = [
   "luminosity"
 ];
 var VECTOR_BLEND_SPACINGS = ["steps", "distance", "smoothColor"];
+var VECTOR_MASK_TYPES = ["clip", "alpha", "luminance"];
 var VECTOR_TOOLS = [
   "select",
   "direct",
@@ -1622,14 +1628,14 @@ function nearestStrokePosition(path, p, only) {
     if (!(total > 0)) return;
     let acc = 0;
     c.segments.forEach((seg, si) => {
-      const near = _chunkXGD3FSNCcjs.segmentNearest.call(void 0, seg, p);
-      if (!best || near.distance < best.distance) {
-        const s = acc + _chunkXGD3FSNCcjs.segmentLength.call(void 0, seg, 0, near.t);
-        const tan = _chunkXGD3FSNCcjs.segmentTangent.call(void 0, seg, near.t);
-        const pt2 = seg.length === 2 ? lerp(seg[0], seg[1], near.t) : evalSeg(seg, near.t);
+      const near2 = _chunkXGD3FSNCcjs.segmentNearest.call(void 0, seg, p);
+      if (!best || near2.distance < best.distance) {
+        const s = acc + _chunkXGD3FSNCcjs.segmentLength.call(void 0, seg, 0, near2.t);
+        const tan = _chunkXGD3FSNCcjs.segmentTangent.call(void 0, seg, near2.t);
+        const pt2 = seg.length === 2 ? lerp(seg[0], seg[1], near2.t) : evalSeg(seg, near2.t);
         const n = leftNormal([tan[0], tan[1]]);
         const side = (p[0] - pt2[0]) * n[0] + (p[1] - pt2[1]) * n[1] >= 0 ? "left" : "right";
-        best = { contour: ci, t: Math.min(Math.max(s / total, 0), 1), distance: near.distance, side, point: pt2, tangent: [tan[0], tan[1]], length: total };
+        best = { contour: ci, t: Math.min(Math.max(s / total, 0), 1), distance: near2.distance, side, point: pt2, tangent: [tan[0], tan[1]], length: total };
       }
       acc += lengths[si];
     });
@@ -1814,7 +1820,7 @@ function vectorStrokeParts(path, style) {
   const cap = capExtent(style, width);
   const tipMode = style.arrowAlign === "tip";
   const trims = contours.map(() => [0, 0]);
-  const place = (end, contour, ci) => {
+  const place2 = (end, contour, ci) => {
     const kind = end === "start" ? style.startArrow : style.endArrow;
     if (!kind || contour.closed) return;
     const hw = arrowheadWeight(style, end);
@@ -1835,8 +1841,8 @@ function vectorStrokeParts(path, style) {
     }
     heads.push({ end, kind, tip, dir, inset, path: arrowheadPath(kind, tip, dir, hw) });
   };
-  place("start", first, 0);
-  place("end", last, contours.length - 1);
+  place2("start", first, 0);
+  place2("end", last, contours.length - 1);
   if (!tipMode || !heads.length) return { align, line: path, drawWidth, heads };
   const trimmed = contours.map((c, i) => {
     const [s0, s1] = trims[i];
@@ -1869,13 +1875,13 @@ function hitTestVectorStroke(path, p, style, tolerance = 0) {
   let d;
   let reach = width / 2;
   if (profile) {
-    const near = nearestStrokePosition(parts.line, point);
-    if (!near) return false;
-    d = near.distance;
-    const w = widthProfileAt(profile, near.t);
-    reach = width / 2 * (near.side === "left" ? w.left : w.right);
+    const near2 = nearestStrokePosition(parts.line, point);
+    if (!near2) return false;
+    d = near2.distance;
+    const w = widthProfileAt(profile, near2.t);
+    reach = width / 2 * (near2.side === "left" ? w.left : w.right);
     if (parts.align !== "center") reach *= 2;
-    const atEnd = near.t <= 1e-9 || near.t >= 1 - 1e-9;
+    const atEnd = near2.t <= 1e-9 || near2.t >= 1 - 1e-9;
     if (atEnd && (style.strokeLinecap === "round" || style.strokeLinecap === "square") && d > reach) {
       reach = Math.max(reach, width / 2 * (w.left + w.right) / 2);
     }
@@ -2318,206 +2324,966 @@ function mapBezierPath(path, f, tolerance = 0.1, options = {}) {
   return subpathsToBezier(mapVectorSubpaths(bezierToSubpaths(path), f, tolerance, options), { corners: false });
 }
 
-// src/vector/warp.ts
-function polylineAt(pts) {
-  const acc = [0];
-  for (let i = 1; i < pts.length; i++) acc.push(acc[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y));
-  const total = acc[acc.length - 1];
-  return (u) => {
-    if (!(total > 0)) return pts[0];
-    const L = Math.min(1, Math.max(0, u)) * total;
-    let i = 1;
-    while (i < acc.length - 1 && acc[i] < L) i++;
-    const seg = acc[i] - acc[i - 1];
-    return _chunkDWGZUSEScjs.lerpVec2.call(void 0, pts[i - 1], pts[i], seg > 0 ? (L - acc[i - 1]) / seg : 0);
+// src/vector/pathCut.ts
+var loopArea = (l) => _chunkXGD3FSNCcjs.contourSignedArea.call(void 0, l.segs);
+function loopSample(l) {
+  const k = l.chord.findIndex((c) => !c);
+  return _chunkXGD3FSNCcjs.segmentPoint.call(void 0, l.segs[k >= 0 ? k : 0], 0.5);
+}
+var contains = (l, p) => _chunkXGD3FSNCcjs.windingNumber.call(void 0, [l.segs], p) !== 0;
+function groupFaces(loops) {
+  const usable = loops.filter((l) => l.segs.length && Math.abs(loopArea(l)) > 1e-12);
+  if (!usable.length) return [];
+  const largest = usable.reduce((a, b) => Math.abs(loopArea(b)) > Math.abs(loopArea(a)) ? b : a);
+  const sign = Math.sign(loopArea(largest));
+  const outers = usable.filter((l) => Math.sign(loopArea(l)) === sign).sort((a, b) => Math.abs(loopArea(a)) - Math.abs(loopArea(b)));
+  const faces = new Map(outers.map((o) => [o, { loops: [o] }]));
+  for (const hole of usable.filter((l) => Math.sign(loopArea(l)) !== sign)) {
+    const p = loopSample(hole);
+    const parent = outers.find((o) => Math.abs(loopArea(o)) > Math.abs(loopArea(hole)) && contains(o, p));
+    if (parent) faces.get(parent).loops.push(hole);
+  }
+  return outers.reverse().map((o) => faces.get(o));
+}
+function faceToPath(face) {
+  return _chunkXGD3FSNCcjs.contoursToPath.call(void 0, face.loops.map((l) => ({ segments: l.segs, closed: true })));
+}
+function facesOf(path, fillRule) {
+  const normalized = _chunkXGD3FSNCcjs.normalizeBezierPath.call(void 0, path, fillRule);
+  const loops = _chunkXGD3FSNCcjs.pathToContours.call(void 0, normalized).map((c) => {
+    const segs = _chunkXGD3FSNCcjs.closeContour.call(void 0, c, true).map((s) => s.slice());
+    return { segs, chord: segs.map(() => false) };
+  });
+  return groupFaces(loops);
+}
+function splitIntoFaces(path, fillRule = "nonzero") {
+  return facesOf(path, fillRule).map(faceToPath);
+}
+function rootsInUnit(a, b, c, d, scale3) {
+  const f = (t) => ((a * t + b) * t + c) * t + d;
+  const tol = 1e-12 * Math.max(1, scale3);
+  const cuts = [0];
+  const qa = 3 * a;
+  const qb = 2 * b;
+  if (Math.abs(qa) > 1e-18) {
+    const disc = qb * qb - 4 * qa * c;
+    if (disc >= 0) {
+      const r = Math.sqrt(disc);
+      for (const t of [(-qb - r) / (2 * qa), (-qb + r) / (2 * qa)].sort((x, y) => x - y)) if (t > 0 && t < 1) cuts.push(t);
+    }
+  } else if (Math.abs(qb) > 1e-18) {
+    const t = -c / qb;
+    if (t > 0 && t < 1) cuts.push(t);
+  }
+  cuts.push(1);
+  const roots = [];
+  const push = (t) => {
+    if (!roots.some((r) => Math.abs(r - t) < 1e-9)) roots.push(t);
   };
-}
-function sampleSubpath(sp, per = 24) {
-  const n = sp.anchors.length;
-  const out = [];
-  for (let i = 0; i < n; i++) {
-    const a = sp.anchors[i];
-    const b = sp.anchors[(i + 1) % n];
-    const c = [{ x: a.x, y: a.y }, _nullishCoalesce(a.out, () => ( a)), _nullishCoalesce(b.in, () => ( b)), { x: b.x, y: b.y }];
-    for (let k = 0; k < per; k++) {
-      const t = k / per;
-      const ab = _chunkDWGZUSEScjs.lerpVec2.call(void 0, c[0], c[1], t);
-      const bc = _chunkDWGZUSEScjs.lerpVec2.call(void 0, c[1], c[2], t);
-      const cd = _chunkDWGZUSEScjs.lerpVec2.call(void 0, c[2], c[3], t);
-      out.push(_chunkDWGZUSEScjs.lerpVec2.call(void 0, _chunkDWGZUSEScjs.lerpVec2.call(void 0, ab, bc, t), _chunkDWGZUSEScjs.lerpVec2.call(void 0, bc, cd, t), t));
+  for (let i = 0; i < cuts.length - 1; i++) {
+    let lo = cuts[i];
+    let hi = cuts[i + 1];
+    let flo = f(lo);
+    const fhi = f(hi);
+    if (Math.abs(flo) <= tol) push(lo);
+    if (Math.abs(fhi) <= tol) push(hi);
+    if (flo * fhi >= 0) continue;
+    for (let k = 0; k < 80; k++) {
+      const m = (lo + hi) / 2;
+      const fm = f(m);
+      if (fm === 0) {
+        lo = hi = m;
+        break;
+      }
+      if (fm * flo < 0) hi = m;
+      else {
+        lo = m;
+        flo = fm;
+      }
     }
+    push((lo + hi) / 2);
+  }
+  return roots.sort((x, y) => x - y);
+}
+function lineHits(p, q, seg) {
+  const dx = q[0] - p[0];
+  const dy = q[1] - p[1];
+  const len2 = dx * dx + dy * dy;
+  if (len2 < 1e-24) return [];
+  const h = (pt2) => (pt2[0] - p[0]) * -dy + (pt2[1] - p[1]) * dx;
+  let coeffs;
+  if (seg.length === 2) coeffs = [0, 0, h(seg[1]) - h(seg[0]), h(seg[0])];
+  else {
+    const [h0, h1, h2, h3] = seg.map(h);
+    coeffs = [-h0 + 3 * h1 - 3 * h2 + h3, 3 * h0 - 6 * h1 + 3 * h2, -3 * h0 + 3 * h1, h0];
+  }
+  if (coeffs.every((c) => Math.abs(c) < 1e-12 * Math.max(1, len2))) return [];
+  const scale3 = Math.sqrt(len2) * Math.max(1, ...seg.map((pt2) => Math.abs(pt2[0]) + Math.abs(pt2[1])));
+  const out = [];
+  for (const t of rootsInUnit(...coeffs, scale3)) {
+    const point = _chunkXGD3FSNCcjs.segmentPoint.call(void 0, seg, t);
+    const s = ((point[0] - p[0]) * dx + (point[1] - p[1]) * dy) / len2;
+    if (s >= -1e-9 && s <= 1 + 1e-9) out.push({ s: Math.min(1, Math.max(0, s)), t, point });
   }
   return out;
 }
-function vectorMeshFromOutline(sp, columns = 4, rows = 4) {
-  if (!sp.closed || sp.anchors.length < 2) return null;
-  let ring = sampleSubpath(sp);
-  const xs = ring.map((p) => p.x);
-  const ys = ring.map((p) => p.y);
-  const box = { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) };
-  if (!(box.x1 - box.x0 > 1e-9 && box.y1 - box.y0 > 1e-9)) return null;
-  const nearest = (c2) => {
-    let best = 0;
-    for (let i = 1; i < ring.length; i++) if (Math.hypot(ring[i].x - c2.x, ring[i].y - c2.y) < Math.hypot(ring[best].x - c2.x, ring[best].y - c2.y)) best = i;
-    return best;
-  };
-  const cornersOf = () => [
-    { x: box.x0, y: box.y0 },
-    { x: box.x1, y: box.y0 },
-    { x: box.x1, y: box.y1 },
-    { x: box.x0, y: box.y1 }
-  ].map(nearest);
-  let c = cornersOf();
-  const n = ring.length;
-  const fwd = (from, to) => (to - from + n) % n;
-  if (!(fwd(c[0], c[1]) < fwd(c[0], c[2]) && fwd(c[0], c[2]) < fwd(c[0], c[3]))) {
-    ring = ring.slice().reverse();
-    c = cornersOf();
-    if (!(fwd(c[0], c[1]) < fwd(c[0], c[2]) && fwd(c[0], c[2]) < fwd(c[0], c[3]))) return null;
-  }
-  if (new Set(c).size < 4) return null;
-  const walk = (from, to) => {
-    const out = [];
-    for (let i = from; ; i = (i + 1) % n) {
-      out.push(ring[i]);
-      if (i === to) break;
+var near = (a, b, eps) => Math.abs(a[0] - b[0]) <= eps && Math.abs(a[1] - b[1]) <= eps;
+var degenerate = (seg, eps) => seg.every((p) => near(p, seg[0], eps));
+function arc(l, a, b, eps) {
+  const n = l.segs.length;
+  const segs = [];
+  const chord = [];
+  const push = (k, t0, t1) => {
+    const piece = t0 <= 0 && t1 >= 1 ? l.segs[k].slice() : _chunkXGD3FSNCcjs.subSegment.call(void 0, l.segs[k], t0, t1);
+    if (!degenerate(piece, eps)) {
+      segs.push(piece);
+      chord.push(l.chord[k]);
     }
-    return out;
-  };
-  const top = polylineAt(walk(c[0], c[1]));
-  const right = polylineAt(walk(c[1], c[2]));
-  const bottomLR = polylineAt(walk(c[2], c[3]).reverse());
-  const leftTB = polylineAt(walk(c[3], c[0]).reverse());
-  const p00 = top(0);
-  const p10 = top(1);
-  const p01 = bottomLR(0);
-  const p11 = bottomLR(1);
-  const coons = (s, t) => {
-    const T = top(s);
-    const B = bottomLR(s);
-    const L = leftTB(t);
-    const R = right(t);
-    return {
-      x: (1 - t) * T.x + t * B.x + (1 - s) * L.x + s * R.x - ((1 - s) * (1 - t) * p00.x + s * (1 - t) * p10.x + (1 - s) * t * p01.x + s * t * p11.x),
-      y: (1 - t) * T.y + t * B.y + (1 - s) * L.y + s * R.y - ((1 - s) * (1 - t) * p00.y + s * (1 - t) * p10.y + (1 - s) * t * p01.y + s * t * p11.y)
-    };
   };
-  return _chunkDWGZUSEScjs.fitWarpMesh.call(void 0, coons, _chunkDWGZUSEScjs.evenKnots.call(void 0, _chunkDWGZUSEScjs.clampMeshCount.call(void 0, columns)), _chunkDWGZUSEScjs.evenKnots.call(void 0, _chunkDWGZUSEScjs.clampMeshCount.call(void 0, rows)));
+  if (a.seg === b.seg && b.t >= a.t + 1e-12) {
+    push(a.seg, a.t, b.t);
+    return { segs, chord };
+  }
+  push(a.seg, a.t, 1);
+  for (let k = (a.seg + 1) % n; k !== b.seg; k = (k + 1) % n) push(k, 0, 1);
+  push(b.seg, 0, b.t);
+  return { segs, chord };
 }
-function vectorMeshOutline(m) {
-  const nx = _chunkDWGZUSEScjs.warpMeshColumns.call(void 0, m);
-  const ny = _chunkDWGZUSEScjs.warpMeshRows.call(void 0, m);
-  const pt2 = (i, j) => m.points[j * nx + i];
+function polySegs(points, eps) {
+  const out = [];
+  for (let i = 1; i < points.length; i++) if (!near(points[i - 1], points[i], eps)) out.push([points[i - 1], points[i]]);
+  return out;
+}
+function knifePath(path, fillRule, knife) {
+  const pts = knife.filter((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]));
+  if (pts.length < 2) return null;
+  let faces = facesOf(path, fillRule);
+  if (!faces.length) return null;
+  const b = _chunkXGD3FSNCcjs.bezierPathBounds.call(void 0, path);
+  const size = b ? Math.max(b.maxX - b.minX, b.maxY - b.minY, 1) : 1;
+  const eps = size * 1e-9;
+  let cursor = -Infinity;
+  let cuts = 0;
+  for (let guard = 0; guard < 512; guard++) {
+    let best = null;
+    faces.forEach((face2, fi2) => {
+      const hits = [];
+      for (let m = 0; m < pts.length - 1; m++) {
+        if (m + 1 < cursor - 1e-9) continue;
+        const kb = { minX: Math.min(pts[m][0], pts[m + 1][0]), maxX: Math.max(pts[m][0], pts[m + 1][0]), minY: Math.min(pts[m][1], pts[m + 1][1]), maxY: Math.max(pts[m][1], pts[m + 1][1]) };
+        face2.loops.forEach(
+          (l, li) => l.segs.forEach((seg, si) => {
+            const sb = _chunkXGD3FSNCcjs.segmentBounds.call(void 0, seg);
+            if (sb.maxX < kb.minX - eps || sb.minX > kb.maxX + eps || sb.maxY < kb.minY - eps || sb.minY > kb.maxY + eps) return;
+            for (const h of lineHits(pts[m], pts[m + 1], seg)) {
+              const s = m + h.s;
+              if (s >= cursor - 1e-9) hits.push({ s, loop: li, seg: si, t: h.t, point: h.point });
+            }
+          })
+        );
+      }
+      hits.sort((x, y) => x.s - y.s);
+      const unique = hits.filter((h, i) => i === 0 || h.s - hits[i - 1].s > 1e-9 || !near(h.point, hits[i - 1].point, eps * 10));
+      const inside = (s) => {
+        const m = Math.min(pts.length - 2, Math.floor(s));
+        const u = s - m;
+        const q = [pts[m][0] + (pts[m + 1][0] - pts[m][0]) * u, pts[m][1] + (pts[m + 1][1] - pts[m][1]) * u];
+        return _chunkXGD3FSNCcjs.windingNumber.call(void 0, face2.loops.map((l) => l.segs), q) !== 0;
+      };
+      for (let i = 0; i < unique.length - 1; i++) {
+        const from2 = unique[i];
+        const to2 = unique[i + 1];
+        if (near(from2.point, to2.point, eps * 10) || !inside((from2.s + to2.s) / 2)) continue;
+        if (!best || from2.s < best.from.s) best = { face: fi2, from: from2, to: to2 };
+        break;
+      }
+    });
+    if (!best) break;
+    const { face: fi, from, to } = best;
+    const face = faces[fi];
+    const corners = [from.point];
+    for (let m = Math.floor(from.s) + 1; m <= to.s - 1e-12 && m < pts.length; m++) if (m > from.s) corners.push(pts[m]);
+    corners.push(to.point);
+    const forward = polySegs(corners, eps);
+    const back = polySegs(corners.slice().reverse(), eps);
+    const la = face.loops[from.loop];
+    const loops = face.loops.filter((_, i) => i !== from.loop && i !== to.loop);
+    if (from.loop === to.loop) {
+      const ab = arc(la, from, to, eps);
+      const ba = arc(la, to, from, eps);
+      loops.push(
+        { segs: [...ab.segs, ...back], chord: [...ab.chord, ...back.map(() => true)] },
+        { segs: [...ba.segs, ...forward], chord: [...ba.chord, ...forward.map(() => true)] }
+      );
+    } else {
+      const lb = face.loops[to.loop];
+      const roundA = arc(la, from, from, eps);
+      const roundB = arc(lb, to, to, eps);
+      loops.push({
+        segs: [...roundA.segs, ...forward, ...roundB.segs, ...back],
+        chord: [...roundA.chord, ...forward.map(() => true), ...roundB.chord, ...back.map(() => true)]
+      });
+    }
+    faces = [...faces.slice(0, fi), ...groupFaces(loops), ...faces.slice(fi + 1)];
+    cursor = to.s;
+    cuts++;
+  }
+  return cuts ? faces.map(faceToPath) : null;
+}
+function eraserRegion(points, width) {
+  const pts = points.filter((p) => Number.isFinite(p[0]) && Number.isFinite(p[1]));
+  const r = width / 2;
+  if (!pts.length || !(r > 0)) return [];
+  const moved = pts.some((p) => !near(p, pts[0], 1e-9));
+  if (!moved) {
+    const [cx, cy] = pts[0];
+    const k = r * 0.5522847498307936;
+    return [
+      { type: "M", x: cx, y: cy - r },
+      { type: "C", x1: cx + k, y1: cy - r, x2: cx + r, y2: cy - k, x: cx + r, y: cy },
+      { type: "C", x1: cx + r, y1: cy + k, x2: cx + k, y2: cy + r, x: cx, y: cy + r },
+      { type: "C", x1: cx - k, y1: cy + r, x2: cx - r, y2: cy + k, x: cx - r, y: cy },
+      { type: "C", x1: cx - r, y1: cy - k, x2: cx - k, y2: cy - r, x: cx, y: cy - r },
+      { type: "Z" }
+    ];
+  }
+  const line = [{ type: "M", x: pts[0][0], y: pts[0][1] }, ...pts.slice(1).map((p) => ({ type: "L", x: p[0], y: p[1] }))];
+  return _chunkXGD3FSNCcjs.outlineStroke.call(void 0, line, { width, cap: "round", join: "round" });
+}
+function eraseFromFill(path, fillRule, region) {
+  const overlap = _chunkXGD3FSNCcjs.pathBoolean.call(void 0, "intersection", [{ path, fillRule }, { path: region }]).path;
+  if (!_chunkXGD3FSNCcjs.pathToContours.call(void 0, overlap).some((c) => Math.abs(_chunkXGD3FSNCcjs.contourSignedArea.call(void 0, _chunkXGD3FSNCcjs.closeContour.call(void 0, c, true))) > 1e-9)) return null;
+  const rest = _chunkXGD3FSNCcjs.pathBoolean.call(void 0, "difference", [{ path, fillRule }, { path: region }]).path;
+  return splitIntoFaces(rest);
+}
+function eraseFromOutline(sp, region, options = {}) {
+  const regionSegs = _chunkXGD3FSNCcjs.pathToContours.call(void 0, region).flatMap((c) => _chunkXGD3FSNCcjs.closeContour.call(void 0, c, true));
+  if (!regionSegs.length) return null;
+  const rb = _chunkXGD3FSNCcjs.bezierPathBounds.call(void 0, region);
+  const count = subpathSegmentCount(sp);
+  if (!rb || count === 0) return null;
+  const inside = options.keep === "inside";
+  const removed = (p) => _chunkXGD3FSNCcjs.pointInBezierPath.call(void 0, region, p, _nullishCoalesce(options.fillRule, () => ( "nonzero"))) !== inside;
   const runs = [];
-  for (let i = 0; i + 3 < nx; i += 3) runs.push([pt2(i, 0), pt2(i + 1, 0), pt2(i + 2, 0), pt2(i + 3, 0)]);
-  for (let j = 0; j + 3 < ny; j += 3) runs.push([pt2(nx - 1, j), pt2(nx - 1, j + 1), pt2(nx - 1, j + 2), pt2(nx - 1, j + 3)]);
-  for (let i = nx - 1; i - 3 >= 0; i -= 3) runs.push([pt2(i, ny - 1), pt2(i - 1, ny - 1), pt2(i - 2, ny - 1), pt2(i - 3, ny - 1)]);
-  for (let j = ny - 1; j - 3 >= 0; j -= 3) runs.push([pt2(0, j), pt2(0, j - 1), pt2(0, j - 2), pt2(0, j - 3)]);
-  const anchors = runs.map((r, k) => {
-    const prev = runs[(k + runs.length - 1) % runs.length];
-    return { x: r[0].x, y: r[0].y, in: { ...prev[2] }, out: { ...r[1] } };
-  });
-  return { closed: true, anchors };
+  let cur = [];
+  let any = false;
+  for (let i = 0; i < count; i++) {
+    const seg = subpathSegment(sp, i);
+    const sb = _chunkXGD3FSNCcjs.segmentBounds.call(void 0, seg);
+    const ts = [0, 1];
+    if (!(sb.maxX < rb.minX || sb.minX > rb.maxX || sb.maxY < rb.minY || sb.minY > rb.maxY)) {
+      for (const r of regionSegs) {
+        const b = _chunkXGD3FSNCcjs.segmentBounds.call(void 0, r);
+        if (b.maxX < sb.minX || b.minX > sb.maxX || b.maxY < sb.minY || b.minY > sb.maxY) continue;
+        for (const hit of _chunkXGD3FSNCcjs.segmentIntersections.call(void 0, seg, r)) if (hit.ta > 1e-9 && hit.ta < 1 - 1e-9) ts.push(hit.ta);
+      }
+    }
+    ts.sort((a, b) => a - b);
+    for (let k = 0; k < ts.length - 1; k++) {
+      const t0 = ts[k];
+      const t1 = ts[k + 1];
+      if (t1 - t0 < 1e-9) continue;
+      if (removed(_chunkXGD3FSNCcjs.segmentPoint.call(void 0, seg, (t0 + t1) / 2))) {
+        any = true;
+        if (cur.length) runs.push(cur);
+        cur = [];
+      } else cur.push({ seg: i, t0, t1 });
+    }
+  }
+  if (cur.length) runs.push(cur);
+  if (!any) return null;
+  if (sp.closed && runs.length >= 2) {
+    const first = runs[0][0];
+    const lastRun = runs[runs.length - 1];
+    const last = lastRun[lastRun.length - 1];
+    if (first.seg === 0 && first.t0 === 0 && last.seg === count - 1 && last.t1 === 1) lastRun.push(...runs.shift());
+  }
+  const out = [];
+  for (const run of runs) {
+    const anchors = [];
+    for (const { seg, t0, t1 } of run) {
+      const c = _chunkXGD3FSNCcjs.subSegment.call(void 0, subpathSegment(sp, seg), t0, t1);
+      const line = c.length === 2;
+      const start = c[0];
+      const end = c[c.length - 1];
+      if (!anchors.length) anchors.push({ x: start[0], y: start[1] });
+      if (!line) anchors[anchors.length - 1].out = { x: c[1][0], y: c[1][1] };
+      const next = { x: end[0], y: end[1] };
+      if (!line) next.in = { x: c[2][0], y: c[2][1] };
+      anchors.push(next);
+    }
+    if (anchors.length < 2) continue;
+    for (const a of anchors) {
+      const type = inferAnchorType(a);
+      if (type !== "corner") a.type = type;
+    }
+    out.push({ anchors, closed: false });
+  }
+  return out;
+}
+function polylineBounds(points, pad = 0) {
+  if (!points.length) return null;
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [x, y] of points) {
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  }
+  return { x: minX - pad, y: minY - pad, width: maxX - minX + 2 * pad, height: maxY - minY + 2 * pad };
+}
+function simplifyPolyline(points, tolerance) {
+  const n = points.length;
+  if (n < 3) return points.slice();
+  const keep = new Array(n).fill(false);
+  keep[0] = keep[n - 1] = true;
+  const stack = [[0, n - 1]];
+  while (stack.length) {
+    const [a, b] = stack.pop();
+    const [ax, ay] = points[a];
+    const dx = points[b][0] - ax;
+    const dy = points[b][1] - ay;
+    const len2 = Math.hypot(dx, dy);
+    let far = -1;
+    let farD = 0;
+    for (let i = a + 1; i < b; i++) {
+      const [px, py] = points[i];
+      const d = len2 < 1e-12 ? Math.hypot(px - ax, py - ay) : Math.abs((px - ax) * dy - (py - ay) * dx) / len2;
+      if (d > farD) {
+        farD = d;
+        far = i;
+      }
+    }
+    if (far >= 0 && farD > tolerance) {
+      keep[far] = true;
+      stack.push([a, far], [far, b]);
+    }
+  }
+  return points.filter((_, i) => keep[i]);
 }
 
-// src/vector/appearance.ts
-var VECTOR_EFFECT_DEFAULTS = {
-  trim: { start: 0, end: 50, offset: 0, mode: "simultaneous" },
-  roundCorners: { radius: 10 },
-  puckerBloat: { amount: 30 },
-  twist: { angle: 45, center: { x: 0, y: 0 } },
-  zigzag: { size: 5, ridges: 4, smooth: false },
-  wiggle: { size: 5, detail: 6, smooth: true, speed: 2, correlation: 50, phase: 0, seed: 1, time: 0 },
-  offset: { amount: 5, join: "miter", miterLimit: 4, copies: 1, copyOffset: 0 },
-  merge: { mode: "add" },
-  repeater: {
-    copies: 3,
-    offset: 0,
-    position: { x: 100, y: 0 },
-    anchor: { x: 0, y: 0 },
-    rotation: 0,
-    scale: { x: 100, y: 100 },
-    startOpacity: 100,
-    endOpacity: 100,
-    composite: "below"
-  },
-  envelope: { style: "arc", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", rows: 2, columns: 2, mesh: null }
+// 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_EFFECT_LABELS = {
-  trim: "Trim Paths",
-  roundCorners: "Round Corners",
-  puckerBloat: "Pucker & Bloat",
-  twist: "Twist",
-  zigzag: "Zig Zag",
-  wiggle: "Wiggle Paths",
-  offset: "Offset Paths",
-  merge: "Merge Paths",
-  repeater: "Repeater",
-  envelope: "Envelope"
+var VECTOR_FILTER_LABELS = {
+  dropShadow: "Drop Shadow",
+  innerShadow: "Inner Shadow",
+  outerGlow: "Outer Glow",
+  innerGlow: "Inner Glow",
+  layerBlur: "Layer Blur",
+  feather: "Feather"
 };
-var VECTOR_EFFECT_PARAM_SPECS = {
-  trim: [
-    { key: "start", label: "Start %", kind: "number", min: 0, max: 100, step: 1, slider: true },
-    { key: "end", label: "End %", kind: "number", min: 0, max: 100, step: 1, slider: true },
-    { key: "offset", label: "Offset \xB0", kind: "number", min: -360, max: 360, step: 1, slider: true },
-    {
-      key: "mode",
-      label: "Paths",
-      kind: "select",
-      options: [
-        { value: "simultaneous", label: "Simultaneously" },
-        { value: "individual", label: "Individually" }
-      ]
-    }
-  ],
-  roundCorners: [{ key: "radius", label: "Radius", kind: "number", min: 0, max: 200, step: 1, slider: true }],
-  puckerBloat: [{ key: "amount", label: "Amount %", kind: "number", min: -100, max: 100, step: 1, slider: true }],
-  twist: [
-    { key: "angle", label: "Angle \xB0", kind: "number", min: -720, max: 720, step: 1, slider: true },
-    { key: "center", label: "Centre", kind: "vec2", step: 1 }
-  ],
-  zigzag: [
-    { key: "size", label: "Size", kind: "number", min: 0, max: 100, step: 0.5, slider: true },
-    { key: "ridges", label: "Ridges", kind: "number", min: 0, max: 50, step: 1, slider: true },
-    { key: "smooth", label: "Smooth", kind: "boolean" }
-  ],
-  wiggle: [
-    { key: "size", label: "Size", kind: "number", min: 0, max: 100, step: 0.5, slider: true },
-    { key: "detail", label: "Detail", kind: "number", min: 0, max: 50, step: 1, slider: true },
-    { key: "smooth", label: "Smooth", kind: "boolean" },
-    { key: "correlation", label: "Correlation %", kind: "number", min: 0, max: 100, step: 1, slider: true },
-    { key: "speed", label: "Speed", kind: "number", min: 0, step: 0.1 },
-    { key: "phase", label: "Phase \xB0", kind: "number", step: 1 },
-    { key: "time", label: "Time (s)", kind: "number", min: 0, max: 10, step: 0.05, slider: true },
-    { key: "seed", label: "Seed", kind: "number", step: 1 }
-  ],
-  offset: [
-    { key: "amount", label: "Amount", kind: "number", min: -100, max: 100, step: 0.5, slider: true },
-    {
-      key: "join",
-      label: "Join",
-      kind: "select",
-      options: [
-        { value: "miter", label: "Miter" },
-        { value: "round", label: "Round" },
-        { value: "bevel", label: "Bevel" }
-      ]
-    },
-    { key: "miterLimit", label: "Miter limit", kind: "number", min: 1, step: 0.5 },
-    { key: "copies", label: "Copies", kind: "number", min: 1, max: 20, step: 1 },
-    { key: "copyOffset", label: "Copy offset", kind: "number", step: 0.5 }
-  ],
-  merge: [
-    {
-      key: "mode",
-      label: "Mode",
-      kind: "select",
-      options: [
-        { value: "merge", label: "Merge" },
-        { value: "add", label: "Add" },
-        { value: "subtract", label: "Subtract" },
-        { value: "intersect", label: "Intersect" },
-        { value: "exclude", label: "Exclude" }
+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', _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 === "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', _44 => _44[primitives.length - 1], 'optionalAccess', _45 => _45.attrs, 'access', _46 => _46.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', _47 => _47.children, 'optionalAccess', _48 => _48.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/mask.ts
+function isVectorMaskType(value) {
+  return typeof value === "string" && VECTOR_MASK_TYPES.includes(value);
+}
+function sanitizeVectorMask(value) {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (!isVectorMaskType(r.type)) return null;
+  return r.invert === true ? { type: r.type, invert: true } : { type: r.type };
+}
+function isVectorMaskGroup(node) {
+  return _optionalChain([node, 'optionalAccess', _49 => _49.type]) === "group" && !!node.mask && isVectorMaskType(node.mask.type) && !node.blend && !node.liveBoolean && node.children.length > 0;
+}
+function isVectorMaskActive(node) {
+  return isVectorMaskGroup(node) && node.children[0].visible !== false;
+}
+function vectorMaskSource(node) {
+  return isVectorMaskGroup(node) ? node.children[0] : null;
+}
+function vectorMaskContents(group) {
+  return isVectorMaskGroup(group) ? group.children.slice(1) : group.children;
+}
+function vectorMaskOwner(nodes, id) {
+  for (const n of nodes) {
+    if (n.type !== "group") continue;
+    if (isVectorMaskGroup(n) && n.children[0].id === id) return n;
+    const inner = vectorMaskOwner(n.children, id);
+    if (inner) return inner;
+  }
+  return null;
+}
+function vectorMaskSummary(node) {
+  if (!isVectorMaskGroup(node)) return null;
+  return {
+    type: node.mask.type,
+    invert: !!node.mask.invert,
+    maskId: node.children[0].id,
+    contents: node.children.slice(1).map((c) => c.id),
+    enabled: node.children[0].visible !== false
+  };
+}
+var place = (path, m) => _chunkDWGZUSEScjs.isIdentityMatrix.call(void 0, m) ? path : _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, path, m);
+function vectorMaskRegionShapes(node, type, parent = _chunkDWGZUSEScjs.IDENTITY_MATRIX, self = true) {
+  if (!self && node.visible === false) return [];
+  const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, nodeMatrix(node), parent);
+  if (isVectorMaskActive(node) || node.type === "group" && _optionalChain([node, 'access', _50 => _50.effects, 'optionalAccess', _51 => _51.length])) {
+    return vectorAppearanceShapes(node).flatMap((s) => regionOfPath(s.path, s.source, type, m));
+  }
+  const drawn = expandVectorAppearance(node);
+  if (drawn.type === "group") {
+    const inner = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, nodeMatrix(drawn), parent);
+    return drawn.children.flatMap((c) => vectorMaskRegionShapes(c, type, inner, false));
+  }
+  return regionOfPath(subpathsToBezier(drawn.subpaths), drawn, type, m);
+}
+function regionOfPath(path, style, type, m) {
+  if (!path.length) return [];
+  const fillRule = _nullishCoalesce(style.fillRule, () => ( "nonzero"));
+  if (type === "clip") return [{ path: place(path, m), fillRule }];
+  const out = [];
+  let filled = false;
+  for (const l of vectorPaintLayerNodes(style)) {
+    if (!l.drawn) continue;
+    if (l.kind === "fill") {
+      if (!filled) out.push({ path: place(path, m), fillRule });
+      filled = true;
+    } else if ((_nullishCoalesce(l.node.strokeWidth, () => ( 1))) > 0) {
+      const area = vectorStrokeOutlinePath(path, l.node);
+      if (area.length) out.push({ path: place(area, m), fillRule: "nonzero" });
+    }
+  }
+  return out;
+}
+var regionCache = /* @__PURE__ */ new WeakMap();
+function vectorMaskRegion(group) {
+  let hit = regionCache.get(group);
+  if (!hit) {
+    hit = vectorMaskRegionShapes(group.children[0], group.mask.type);
+    regionCache.set(group, hit);
+  }
+  return hit;
+}
+var unionCache = /* @__PURE__ */ new WeakMap();
+function vectorMaskRegionPath(group) {
+  let hit = unionCache.get(group);
+  if (!hit) {
+    const shapes = vectorMaskRegion(group);
+    hit = !shapes.length ? [] : shapes.length === 1 && shapes[0].fillRule === "nonzero" ? shapes[0].path : _chunkXGD3FSNCcjs.pathBoolean.call(void 0, "union", shapes.map((s) => ({ path: s.path, fillRule: s.fillRule }))).path;
+    unionCache.set(group, hit);
+  }
+  return hit;
+}
+function inRegion(group, p, tolerance) {
+  const pt2 = [p.x, p.y];
+  for (const s of vectorMaskRegion(group)) {
+    if (_chunkXGD3FSNCcjs.pointInBezierPath.call(void 0, s.path, pt2, s.fillRule)) return true;
+    if (tolerance > 0 && _chunkXGD3FSNCcjs.distanceToBezierPath.call(void 0, s.path, pt2) <= tolerance) return true;
+  }
+  return false;
+}
+function vectorMaskContains(group, p, tolerance = 0) {
+  if (!isVectorMaskActive(group)) return true;
+  if (group.mask.type !== "clip") {
+    const source = group.children[0];
+    const hit = hitTestVectorNode(source.visible === false ? { ...source, visible: true } : source, p, group.mask.invert ? 0 : tolerance);
+    return group.mask.invert ? !hit || tolerance > 0 && hitNearEdge(group, p, tolerance) : hit;
+  }
+  if (!group.mask.invert) return inRegion(group, p, tolerance);
+  return !inRegion(group, p, 0) || hitNearEdge(group, p, tolerance);
+}
+function hitNearEdge(group, p, tolerance) {
+  if (tolerance <= 0) return false;
+  return vectorMaskRegion(group).some((s) => _chunkXGD3FSNCcjs.distanceToBezierPath.call(void 0, s.path, [p.x, p.y]) <= tolerance);
+}
+function clipOpen(path, region, invert2) {
+  const out = [];
+  for (const sp of bezierToSubpaths(path)) {
+    const pieces = eraseFromOutline(sp, region, { keep: invert2 ? "outside" : "inside" });
+    if (pieces === null) {
+      const a = sp.anchors[0];
+      const inside = !!a && _chunkXGD3FSNCcjs.pointInBezierPath.call(void 0, region, [a.x, a.y], "nonzero");
+      if (inside !== invert2) out.push(...subpathsToBezier([sp]));
+    } else out.push(...subpathsToBezier(pieces));
+  }
+  return out;
+}
+function clipShapePath(path, fillRule, region, invert2) {
+  const subpaths = bezierToSubpaths(path);
+  const closed = subpaths.filter((sp) => sp.closed);
+  const open = subpaths.filter((sp) => !sp.closed);
+  const out = [];
+  if (closed.length) {
+    const operands = [{ path: subpathsToBezier(closed), fillRule }, { path: region, fillRule: "nonzero" }];
+    out.push(...region.length ? _chunkXGD3FSNCcjs.pathBoolean.call(void 0, invert2 ? "difference" : "intersection", operands).path : invert2 ? operands[0].path : []);
+  }
+  if (open.length) out.push(...region.length ? clipOpen(subpathsToBezier(open), region, invert2) : invert2 ? subpathsToBezier(open) : []);
+  return out;
+}
+function vectorMaskedShapes(group) {
+  const contents = group.children.flatMap((c, i) => i === 0 ? [] : vectorChildAppearanceShapes(c, i));
+  const shapes = applyVectorEffects(contents, group.effects);
+  if (!isVectorMaskActive(group)) return shapes;
+  const region = vectorMaskRegionPath(group);
+  const invert2 = !!group.mask.invert;
+  const out = [];
+  for (const s of shapes) {
+    const path = clipShapePath(s.path, _nullishCoalesce(s.source.fillRule, () => ( "nonzero")), region, invert2);
+    if (path.length) out.push({ ...s, path, source: s.source.fillRule === "evenodd" ? { ...s.source, fillRule: "nonzero" } : s.source });
+  }
+  return out;
+}
+function vectorMaskedGeometry(node) {
+  if (node.type !== "group") return node;
+  if (isVectorMaskActive(node)) {
+    return {
+      id: node.id,
+      type: "group",
+      ...node.transform ? { transform: node.transform } : {},
+      ...node.opacity !== void 0 ? { opacity: node.opacity } : {},
+      ...node.visible === false ? { visible: false } : {},
+      ...node.locked ? { locked: true } : {},
+      children: vectorAppearanceNodes(node)
+    };
+  }
+  let changed = false;
+  const children = node.children.map((c) => {
+    const next = vectorMaskedGeometry(c);
+    if (next !== c) changed = true;
+    return next;
+  });
+  return changed ? { ...node, children } : node;
+}
+function vectorMaskedLocalBounds(group) {
+  const b = _chunkXGD3FSNCcjs.bezierPathBounds.call(void 0, vectorAppearanceShapes(group).flatMap((s) => s.path));
+  return b ? { x: b.minX, y: b.minY, width: b.maxX - b.minX, height: b.maxY - b.minY } : null;
+}
+function paintReach(node) {
+  const own = vectorFilterReach(activeVectorFilters(node));
+  if (node.type === "path") return own + vectorStrokeStackReach(node);
+  return own + Math.max(0, ...node.children.map(paintReach));
+}
+function vectorMaskContentBounds(group) {
+  const contents = group.children.slice(1);
+  const b = unionBounds(contents.map((c) => vectorNodeBounds(c, _chunkDWGZUSEScjs.IDENTITY_MATRIX)));
+  if (!b) return null;
+  const pad = Math.max(0, ...contents.map(paintReach)) + Math.max(b.width, b.height) * 0.05 + 4;
+  return { x: b.x - pad, y: b.y - pad, width: b.width + 2 * pad, height: b.height + 2 * pad };
+}
+var fe2 = (tag, attrs) => ({ tag, attrs });
+var LUMA = "-0.2125 -0.7154 -0.0721 0 1";
+function invertFilter(type, id, bounds) {
+  const primitives = type === "alpha" ? [fe2("feColorMatrix", { in: "SourceGraphic", type: "matrix", values: "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 -1 1" })] : [
+    // Over black first, so a transparent area reads as dark (hidden) before inverting.
+    fe2("feFlood", { "flood-color": "#000000", result: "black" }),
+    fe2("feComposite", { in: "SourceGraphic", in2: "black", operator: "over", result: "flat" }),
+    fe2("feColorMatrix", { in: "flat", type: "matrix", values: `${LUMA} ${LUMA} ${LUMA} 0 0 0 0 1` })
+  ];
+  const r = (n) => Math.round(n * 1e3) / 1e3;
+  return { id, x: r(bounds.x), y: r(bounds.y), width: r(bounds.width), height: r(bounds.height), primitives };
+}
+var rectPath = (b) => [
+  { type: "M", x: b.x, y: b.y },
+  { type: "L", x: b.x + b.width, y: b.y },
+  { type: "L", x: b.x + b.width, y: b.y + b.height },
+  { type: "L", x: b.x, y: b.y + b.height },
+  { type: "Z" }
+];
+function vectorMaskRenderData(group, id, filterId, precision = 3) {
+  if (!isVectorMaskActive(group) || group.children.length < 2) return null;
+  const invert2 = !!group.mask.invert;
+  const bounds = vectorMaskContentBounds(group);
+  if (group.mask.type === "clip") {
+    const shapes = vectorMaskRegion(group);
+    if (!invert2) return { type: "clip", invert: invert2, id, clip: shapes.map((s) => ({ d: _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, s.path, { precision }), clipRule: s.fillRule })) };
+    const box = _nullishCoalesce(bounds, () => ( { x: 0, y: 0, width: 0, height: 0 }));
+    const region = vectorMaskRegionPath(group);
+    return { type: "clip", invert: invert2, id, clip: [{ d: _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, [...rectPath(box), ...region], { precision }), clipRule: "evenodd" }] };
+  }
+  if (!bounds) return null;
+  if (!invert2) return { type: group.mask.type, invert: invert2, id, bounds };
+  const filter = invertFilter(group.mask.type, filterId, bounds);
+  return { type: group.mask.type, invert: invert2, id, bounds, filter: `url(#${filterId})`, invertFilter: filter };
+}
+
+// src/vector/warp.ts
+function polylineAt(pts) {
+  const acc = [0];
+  for (let i = 1; i < pts.length; i++) acc.push(acc[i - 1] + Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y));
+  const total = acc[acc.length - 1];
+  return (u) => {
+    if (!(total > 0)) return pts[0];
+    const L = Math.min(1, Math.max(0, u)) * total;
+    let i = 1;
+    while (i < acc.length - 1 && acc[i] < L) i++;
+    const seg = acc[i] - acc[i - 1];
+    return _chunkDWGZUSEScjs.lerpVec2.call(void 0, pts[i - 1], pts[i], seg > 0 ? (L - acc[i - 1]) / seg : 0);
+  };
+}
+function sampleSubpath(sp, per = 24) {
+  const n = sp.anchors.length;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const a = sp.anchors[i];
+    const b = sp.anchors[(i + 1) % n];
+    const c = [{ x: a.x, y: a.y }, _nullishCoalesce(a.out, () => ( a)), _nullishCoalesce(b.in, () => ( b)), { x: b.x, y: b.y }];
+    for (let k = 0; k < per; k++) {
+      const t = k / per;
+      const ab = _chunkDWGZUSEScjs.lerpVec2.call(void 0, c[0], c[1], t);
+      const bc = _chunkDWGZUSEScjs.lerpVec2.call(void 0, c[1], c[2], t);
+      const cd = _chunkDWGZUSEScjs.lerpVec2.call(void 0, c[2], c[3], t);
+      out.push(_chunkDWGZUSEScjs.lerpVec2.call(void 0, _chunkDWGZUSEScjs.lerpVec2.call(void 0, ab, bc, t), _chunkDWGZUSEScjs.lerpVec2.call(void 0, bc, cd, t), t));
+    }
+  }
+  return out;
+}
+function vectorMeshFromOutline(sp, columns = 4, rows = 4) {
+  if (!sp.closed || sp.anchors.length < 2) return null;
+  let ring = sampleSubpath(sp);
+  const xs = ring.map((p) => p.x);
+  const ys = ring.map((p) => p.y);
+  const box = { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) };
+  if (!(box.x1 - box.x0 > 1e-9 && box.y1 - box.y0 > 1e-9)) return null;
+  const nearest = (c2) => {
+    let best = 0;
+    for (let i = 1; i < ring.length; i++) if (Math.hypot(ring[i].x - c2.x, ring[i].y - c2.y) < Math.hypot(ring[best].x - c2.x, ring[best].y - c2.y)) best = i;
+    return best;
+  };
+  const cornersOf = () => [
+    { x: box.x0, y: box.y0 },
+    { x: box.x1, y: box.y0 },
+    { x: box.x1, y: box.y1 },
+    { x: box.x0, y: box.y1 }
+  ].map(nearest);
+  let c = cornersOf();
+  const n = ring.length;
+  const fwd = (from, to) => (to - from + n) % n;
+  if (!(fwd(c[0], c[1]) < fwd(c[0], c[2]) && fwd(c[0], c[2]) < fwd(c[0], c[3]))) {
+    ring = ring.slice().reverse();
+    c = cornersOf();
+    if (!(fwd(c[0], c[1]) < fwd(c[0], c[2]) && fwd(c[0], c[2]) < fwd(c[0], c[3]))) return null;
+  }
+  if (new Set(c).size < 4) return null;
+  const walk = (from, to) => {
+    const out = [];
+    for (let i = from; ; i = (i + 1) % n) {
+      out.push(ring[i]);
+      if (i === to) break;
+    }
+    return out;
+  };
+  const top = polylineAt(walk(c[0], c[1]));
+  const right = polylineAt(walk(c[1], c[2]));
+  const bottomLR = polylineAt(walk(c[2], c[3]).reverse());
+  const leftTB = polylineAt(walk(c[3], c[0]).reverse());
+  const p00 = top(0);
+  const p10 = top(1);
+  const p01 = bottomLR(0);
+  const p11 = bottomLR(1);
+  const coons = (s, t) => {
+    const T = top(s);
+    const B = bottomLR(s);
+    const L = leftTB(t);
+    const R = right(t);
+    return {
+      x: (1 - t) * T.x + t * B.x + (1 - s) * L.x + s * R.x - ((1 - s) * (1 - t) * p00.x + s * (1 - t) * p10.x + (1 - s) * t * p01.x + s * t * p11.x),
+      y: (1 - t) * T.y + t * B.y + (1 - s) * L.y + s * R.y - ((1 - s) * (1 - t) * p00.y + s * (1 - t) * p10.y + (1 - s) * t * p01.y + s * t * p11.y)
+    };
+  };
+  return _chunkDWGZUSEScjs.fitWarpMesh.call(void 0, coons, _chunkDWGZUSEScjs.evenKnots.call(void 0, _chunkDWGZUSEScjs.clampMeshCount.call(void 0, columns)), _chunkDWGZUSEScjs.evenKnots.call(void 0, _chunkDWGZUSEScjs.clampMeshCount.call(void 0, rows)));
+}
+function vectorMeshOutline(m) {
+  const nx = _chunkDWGZUSEScjs.warpMeshColumns.call(void 0, m);
+  const ny = _chunkDWGZUSEScjs.warpMeshRows.call(void 0, m);
+  const pt2 = (i, j) => m.points[j * nx + i];
+  const runs = [];
+  for (let i = 0; i + 3 < nx; i += 3) runs.push([pt2(i, 0), pt2(i + 1, 0), pt2(i + 2, 0), pt2(i + 3, 0)]);
+  for (let j = 0; j + 3 < ny; j += 3) runs.push([pt2(nx - 1, j), pt2(nx - 1, j + 1), pt2(nx - 1, j + 2), pt2(nx - 1, j + 3)]);
+  for (let i = nx - 1; i - 3 >= 0; i -= 3) runs.push([pt2(i, ny - 1), pt2(i - 1, ny - 1), pt2(i - 2, ny - 1), pt2(i - 3, ny - 1)]);
+  for (let j = ny - 1; j - 3 >= 0; j -= 3) runs.push([pt2(0, j), pt2(0, j - 1), pt2(0, j - 2), pt2(0, j - 3)]);
+  const anchors = runs.map((r, k) => {
+    const prev = runs[(k + runs.length - 1) % runs.length];
+    return { x: r[0].x, y: r[0].y, in: { ...prev[2] }, out: { ...r[1] } };
+  });
+  return { closed: true, anchors };
+}
+
+// src/vector/appearance.ts
+var VECTOR_EFFECT_DEFAULTS = {
+  trim: { start: 0, end: 50, offset: 0, mode: "simultaneous" },
+  roundCorners: { radius: 10 },
+  puckerBloat: { amount: 30 },
+  twist: { angle: 45, center: { x: 0, y: 0 } },
+  zigzag: { size: 5, ridges: 4, smooth: false },
+  wiggle: { size: 5, detail: 6, smooth: true, speed: 2, correlation: 50, phase: 0, seed: 1, time: 0 },
+  offset: { amount: 5, join: "miter", miterLimit: 4, copies: 1, copyOffset: 0 },
+  merge: { mode: "add" },
+  repeater: {
+    copies: 3,
+    offset: 0,
+    position: { x: 100, y: 0 },
+    anchor: { x: 0, y: 0 },
+    rotation: 0,
+    scale: { x: 100, y: 100 },
+    startOpacity: 100,
+    endOpacity: 100,
+    composite: "below"
+  },
+  envelope: { style: "arc", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", rows: 2, columns: 2, mesh: null }
+};
+var VECTOR_EFFECT_LABELS = {
+  trim: "Trim Paths",
+  roundCorners: "Round Corners",
+  puckerBloat: "Pucker & Bloat",
+  twist: "Twist",
+  zigzag: "Zig Zag",
+  wiggle: "Wiggle Paths",
+  offset: "Offset Paths",
+  merge: "Merge Paths",
+  repeater: "Repeater",
+  envelope: "Envelope"
+};
+var VECTOR_EFFECT_PARAM_SPECS = {
+  trim: [
+    { key: "start", label: "Start %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "end", label: "End %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "offset", label: "Offset \xB0", kind: "number", min: -360, max: 360, step: 1, slider: true },
+    {
+      key: "mode",
+      label: "Paths",
+      kind: "select",
+      options: [
+        { value: "simultaneous", label: "Simultaneously" },
+        { value: "individual", label: "Individually" }
+      ]
+    }
+  ],
+  roundCorners: [{ key: "radius", label: "Radius", kind: "number", min: 0, max: 200, step: 1, slider: true }],
+  puckerBloat: [{ key: "amount", label: "Amount %", kind: "number", min: -100, max: 100, step: 1, slider: true }],
+  twist: [
+    { key: "angle", label: "Angle \xB0", kind: "number", min: -720, max: 720, step: 1, slider: true },
+    { key: "center", label: "Centre", kind: "vec2", step: 1 }
+  ],
+  zigzag: [
+    { key: "size", label: "Size", kind: "number", min: 0, max: 100, step: 0.5, slider: true },
+    { key: "ridges", label: "Ridges", kind: "number", min: 0, max: 50, step: 1, slider: true },
+    { key: "smooth", label: "Smooth", kind: "boolean" }
+  ],
+  wiggle: [
+    { key: "size", label: "Size", kind: "number", min: 0, max: 100, step: 0.5, slider: true },
+    { key: "detail", label: "Detail", kind: "number", min: 0, max: 50, step: 1, slider: true },
+    { key: "smooth", label: "Smooth", kind: "boolean" },
+    { key: "correlation", label: "Correlation %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "speed", label: "Speed", kind: "number", min: 0, step: 0.1 },
+    { key: "phase", label: "Phase \xB0", kind: "number", step: 1 },
+    { key: "time", label: "Time (s)", kind: "number", min: 0, max: 10, step: 0.05, slider: true },
+    { key: "seed", label: "Seed", kind: "number", step: 1 }
+  ],
+  offset: [
+    { key: "amount", label: "Amount", kind: "number", min: -100, max: 100, step: 0.5, slider: true },
+    {
+      key: "join",
+      label: "Join",
+      kind: "select",
+      options: [
+        { value: "miter", label: "Miter" },
+        { value: "round", label: "Round" },
+        { value: "bevel", label: "Bevel" }
+      ]
+    },
+    { key: "miterLimit", label: "Miter limit", kind: "number", min: 1, step: 0.5 },
+    { key: "copies", label: "Copies", kind: "number", min: 1, max: 20, step: 1 },
+    { key: "copyOffset", label: "Copy offset", kind: "number", step: 0.5 }
+  ],
+  merge: [
+    {
+      key: "mode",
+      label: "Mode",
+      kind: "select",
+      options: [
+        { value: "merge", label: "Merge" },
+        { value: "add", label: "Add" },
+        { value: "subtract", label: "Subtract" },
+        { value: "intersect", label: "Intersect" },
+        { value: "exclude", label: "Exclude" }
       ]
     }
   ],
@@ -2604,7 +3370,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', _43 => _43[spec.key]]);
+    const v2 = _optionalChain([params, 'optionalAccess', _52 => _52[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;
@@ -2615,7 +3381,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', _44 => _44.mesh]);
+    const given = _optionalChain([params, 'optionalAccess', _53 => _53.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) {
@@ -2632,10 +3398,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', _45 => _45.effects, 'optionalAccess', _46 => _46.filter, 'call', _47 => _47(isEnabled)]), () => ( []));
+  return _nullishCoalesce(_optionalChain([node, 'access', _54 => _54.effects, 'optionalAccess', _55 => _55.filter, 'call', _56 => _56(isEnabled)]), () => ( []));
 }
 function hasOwnVectorAppearance(node) {
-  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _48 => _48.effects, 'optionalAccess', _49 => _49.some, 'call', _50 => _50(isEnabled)]);
+  return node.type === "group" && !!node.liveBoolean || !!_optionalChain([node, 'access', _57 => _57.effects, 'optionalAccess', _58 => _58.some, 'call', _59 => _59(isEnabled)]);
 }
 var liveCache = /* @__PURE__ */ new WeakMap();
 function hasVectorAppearance(node) {
@@ -2647,7 +3413,7 @@ function hasVectorAppearance(node) {
   return v2;
 }
 function isVectorLiveBoolean(node) {
-  return _optionalChain([node, 'optionalAccess', _51 => _51.type]) === "group" && !!node.liveBoolean;
+  return _optionalChain([node, 'optionalAccess', _60 => _60.type]) === "group" && !!node.liveBoolean;
 }
 function vectorOperandOperation(group, child) {
   return _nullishCoalesce(_nullishCoalesce(child.booleanOperation, () => ( group.liveBoolean)), () => ( "union"));
@@ -2764,7 +3530,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', _52 => _52.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _53 => _53.y]), () => ( 0))) });
+var add3 = (a, b) => ({ x: a.x + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _61 => _61.x]), () => ( 0))), y: a.y + (_nullishCoalesce(_optionalChain([b, 'optionalAccess', _62 => _62.y]), () => ( 0))) });
 var mapPaths = (shapes, fn) => {
   const out = fn(shapes.map((s) => s.path));
   return shapes.map((s, i) => ({ ...s, path: _nullishCoalesce(out[i], () => ( [])) }));
@@ -2829,7 +3595,7 @@ function applyVectorEffects(shapes, effects) {
   }
   return list;
 }
-function childShapes(child, index) {
+function vectorChildAppearanceShapes(child, index) {
   if (child.visible === false) return [];
   const m = child.transform;
   const k = _nullishCoalesce(child.opacity, () => ( 1));
@@ -2844,7 +3610,7 @@ function liveBooleanShapes(group) {
   const operands = [];
   let source = null;
   group.children.forEach((child, i) => {
-    const shapes = childShapes(child, i);
+    const shapes = vectorChildAppearanceShapes(child, i);
     if (!shapes.length) return;
     source ??= shapes[0].source;
     const path = shapes.length === 1 ? shapes[0].path : _chunkXGD3FSNCcjs.pathBoolean.call(void 0, "union", shapes.map((s) => ({ path: s.path, fillRule: _nullishCoalesce(s.source.fillRule, () => ( "nonzero")) }))).path;
@@ -2858,7 +3624,8 @@ var shapeCache = /* @__PURE__ */ new WeakMap();
 function baseShapes(node) {
   if (node.type === "path") return [{ source: node, path: subpathsToBezier(node.subpaths), opacity: 1, order: [] }];
   if (node.liveBoolean) return liveBooleanShapes(node);
-  return node.children.flatMap((c, i) => childShapes(c, i));
+  if (isVectorMaskGroup(node)) return node.children.flatMap((c, i) => i === 0 ? [] : vectorChildAppearanceShapes(c, i));
+  return node.children.flatMap((c, i) => vectorChildAppearanceShapes(c, i));
 }
 function vectorEffectInputPaths(node, effectId) {
   const list = _nullishCoalesce(node.effects, () => ( []));
@@ -2871,10 +3638,10 @@ function vectorEffectInputBounds(node, effectId) {
   return paths ? pathsBounds(paths) : null;
 }
 function vectorNodeEnvelope(node) {
-  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _54 => _54.effects, 'optionalAccess', _55 => _55.find, 'call', _56 => _56((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
+  return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _63 => _63.effects, 'optionalAccess', _64 => _64.find, 'call', _65 => _65((e) => e.type === "envelope" && e.enabled !== false)]), () => ( null));
 }
 function vectorEnvelopeFrame(node, effectId) {
-  const e = effectId ? _optionalChain([node, 'access', _57 => _57.effects, 'optionalAccess', _58 => _58.find, 'call', _59 => _59((x) => x.id === effectId)]) : vectorNodeEnvelope(node);
+  const e = effectId ? _optionalChain([node, 'access', _66 => _66.effects, 'optionalAccess', _67 => _67.find, 'call', _68 => _68((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;
@@ -2883,7 +3650,7 @@ function vectorEnvelopeFrame(node, effectId) {
 function vectorAppearanceShapes(node) {
   const hit = shapeCache.get(node);
   if (hit) return hit;
-  const out = applyVectorEffects(baseShapes(node), node.effects).sort((a, b) => compareOrder(a.order, b.order));
+  const out = (isVectorMaskGroup(node) ? vectorMaskedShapes(node) : applyVectorEffects(baseShapes(node), node.effects)).sort((a, b) => compareOrder(a.order, b.order));
   shapeCache.set(node, out);
   return out;
 }
@@ -2924,7 +3691,7 @@ function placement(node) {
     ...node.blendStep ? { blendStep: true } : {},
     ...node.booleanOperation ? { booleanOperation: node.booleanOperation } : {},
     ...node.blendMode ? { blendMode: node.blendMode } : {},
-    ..._optionalChain([node, 'access', _60 => _60.filters, 'optionalAccess', _61 => _61.length]) ? { filters: node.filters } : {}
+    ..._optionalChain([node, 'access', _69 => _69.filters, 'optionalAccess', _70 => _70.length]) ? { filters: node.filters } : {}
   };
 }
 function vectorAppearanceNodes(node) {
@@ -2939,6 +3706,11 @@ function expandVectorAppearance(node) {
   if (!hasOwnVectorAppearance(node)) {
     const group = node;
     out = { ...group, children: group.children.map(expandVectorAppearance) };
+  } else if (isVectorMaskGroup(node)) {
+    const { effects, ...group } = node;
+    const [mask, ...contents] = node.children;
+    const wrapper = { id: `${node.id}~content`, type: "group", effects, children: contents };
+    out = { ...group, children: [expandVectorAppearance(mask), ...contents.length ? [expandVectorAppearance(wrapper)] : []] };
   } else {
     const shapes = vectorAppearanceShapes(node);
     if (node.type === "path" && shapes.length === 1) {
@@ -3010,10 +3782,10 @@ function vectorEnteredGroups(nodes, ids) {
   const want = new Set(ids);
   const visit = (list, live) => {
     for (const n of list) {
-      const own = n.type === "group" && hasOwnVectorAppearance(n);
+      const own = n.type === "group" && (hasOwnVectorAppearance(n) || isVectorMaskGroup(n));
       if (want.has(n.id)) {
         for (const id of live) out.add(id);
-        if (own) out.add(n.id);
+        if (own && hasOwnVectorAppearance(n)) out.add(n.id);
       }
       if (n.type === "group") visit(n.children, own ? [...live, n.id] : live);
     }
@@ -3200,6 +3972,11 @@ function vectorPathWorldBezier(node, parent = _chunkDWGZUSEScjs.IDENTITY_MATRIX,
   return _chunkDWGZUSEScjs.isIdentityMatrix.call(void 0, m) ? path : _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, path, m);
 }
 function vectorNodeBounds(node, parent = _chunkDWGZUSEScjs.IDENTITY_MATRIX) {
+  if (isVectorMaskActive(node)) {
+    const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, nodeMatrix(node), parent);
+    const b2 = _chunkXGD3FSNCcjs.bezierPathBounds.call(void 0, vectorAppearanceShapes(node).flatMap((s) => _chunkDWGZUSEScjs.isIdentityMatrix.call(void 0, m) ? s.path : _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, s.path, m)));
+    return b2 ? { x: b2.minX, y: b2.minY, width: b2.maxX - b2.minX, height: b2.maxY - b2.minY } : null;
+  }
   node = expandVectorAppearance(node);
   if (node.type === "group") {
     const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, nodeMatrix(node), parent);
@@ -3232,7 +4009,15 @@ 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', _62 => _62.entered, 'optionalAccess', _63 => _63.has, 'call', _64 => _64(node.id)])))) node = expandVectorAppearance(node);
+  if (isVectorMaskGroup(node)) {
+    const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, nodeMatrix(node), parent);
+    const entered = !!_optionalChain([options, 'access', _71 => _71.entered, 'optionalAccess', _72 => _72.has, 'call', _73 => _73(node.id)]);
+    if (!entered && isVectorMaskActive(node) && !vectorMaskContains(node, _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.invertMatrix.call(void 0, m), p), tolerance)) return false;
+    const shown = !entered && hasOwnVectorAppearance(node) ? expandVectorAppearance(node).children : node.children;
+    for (let i = shown.length - 1; i >= 1; i--) if (hitTestVectorNode(shown[i], p, tolerance, m, options)) return true;
+    return entered && hitTestVectorMaskSource(node, p, tolerance, m, options);
+  }
+  if (!(node.type === "group" && (!hasOwnVectorAppearance(node) || _optionalChain([options, 'access', _74 => _74.entered, 'optionalAccess', _75 => _75.has, 'call', _76 => _76(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));
@@ -3241,6 +4026,18 @@ function hitTestVectorNode(node, p, tolerance = 0, parent = _chunkDWGZUSEScjs.ID
   if (path.length === 0) return false;
   return hitTestVectorPaintStack(node, path, p, tolerance);
 }
+function hitTestVectorMaskSource(group, p, tolerance, m, options) {
+  const source = group.children[0];
+  if (source.visible === false) return false;
+  if (_optionalChain([group, 'access', _77 => _77.mask, 'optionalAccess', _78 => _78.type]) !== "clip") return hitTestVectorNode(source, p, tolerance, m, options);
+  const paths = collectPathNodes(source).filter((n) => n.visible !== false);
+  const pt2 = [p.x, p.y];
+  return paths.some((n) => {
+    const world = vectorParentMatrix([source], n.id);
+    const path = vectorPathWorldBezier(n, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _nullishCoalesce(world, () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX)), m));
+    return _chunkXGD3FSNCcjs.pointInBezierPath.call(void 0, path, pt2, _nullishCoalesce(n.fillRule, () => ( "nonzero"))) || _chunkXGD3FSNCcjs.distanceToBezierPath.call(void 0, path, pt2) <= tolerance;
+  });
+}
 function vectorStrokeOutline(node, parent = _chunkDWGZUSEScjs.IDENTITY_MATRIX) {
   if (!hasPaint(node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return [];
   return vectorStrokeOutlinePath(vectorPathWorldBezier(node, parent), node);
@@ -3279,22 +4076,22 @@ function mapAnchor(a, m) {
 }
 function bakeIntoGeometry(node, m) {
   if (_chunkDWGZUSEScjs.isIdentityMatrix.call(void 0, m)) return node;
-  if (_optionalChain([node, 'access', _65 => _65.effects, 'optionalAccess', _66 => _66.length])) node = { ...node, effects: transformVectorEffects(node.effects, m, node) };
+  if (_optionalChain([node, 'access', _79 => _79.effects, 'optionalAccess', _80 => _80.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', _67 => _67.blend, 'optionalAccess', _68 => _68.spine]);
+    const spine = _optionalChain([group, 'access', _81 => _81.blend, 'optionalAccess', _82 => _82.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 flips = m[0] * m[3] - m[1] * m[2] < 0;
-  const mirrored = flips && _optionalChain([path, 'access', _69 => _69.strokeWidthProfile, 'optionalAccess', _70 => _70.length]);
+  const mirrored = flips && _optionalChain([path, 'access', _83 => _83.strokeWidthProfile, 'optionalAccess', _84 => _84.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) } : {}
+    ...flips && _optionalChain([l, 'access', _85 => _85.strokeWidthProfile, 'optionalAccess', _86 => _86.length]) ? { strokeWidthProfile: mirrorWidthProfile(l.strokeWidthProfile) } : {}
   });
   return {
     ...path,
@@ -3498,14 +4295,14 @@ function roundSubpaths(subpaths, precision = 3) {
 
 // src/vector/pathEffects.ts
 var EPS3 = 1e-9;
-var degenerate = (s) => s.every((p) => Math.abs(p[0] - s[0][0]) < EPS3 && Math.abs(p[1] - s[0][1]) < EPS3);
+var degenerate2 = (s) => s.every((p) => Math.abs(p[0] - s[0][0]) < EPS3 && Math.abs(p[1] - s[0][1]) < EPS3);
 function raise(seg) {
   if (seg.length !== 3) return seg.map((p) => [p[0], p[1]]);
   const [p0, p1, p2] = seg;
   return [p0, [p0[0] + 2 / 3 * (p1[0] - p0[0]), p0[1] + 2 / 3 * (p1[1] - p0[1])], [p2[0] + 2 / 3 * (p1[0] - p2[0]), p2[1] + 2 / 3 * (p1[1] - p2[1])], p2];
 }
 function subsOf(path) {
-  return _chunkXGD3FSNCcjs.pathToContours.call(void 0, path).map((c) => ({ segs: _chunkXGD3FSNCcjs.closeContour.call(void 0, c).filter((s) => !degenerate(s)).map(raise), closed: c.closed })).filter((s) => s.segs.length > 0);
+  return _chunkXGD3FSNCcjs.pathToContours.call(void 0, path).map((c) => ({ segs: _chunkXGD3FSNCcjs.closeContour.call(void 0, c).filter((s) => !degenerate2(s)).map(raise), closed: c.closed })).filter((s) => s.segs.length > 0);
 }
 var subsToPath = (subs) => _chunkXGD3FSNCcjs.contoursToPath.call(void 0, subs.map((s) => ({ segments: s.segs, closed: s.closed })));
 var unit2 = (x, y) => {
@@ -3557,9 +4354,9 @@ 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', _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 (degenerate2(piece)) continue;
+      const last = _optionalChain([out, 'access', _87 => _87[out.length - 1], 'optionalAccess', _88 => _88.segs]);
+      const end = _optionalChain([last, 'optionalAccess', _89 => _89[last.length - 1], 'optionalAccess', _90 => _90.at, 'call', _91 => _91(-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);
     }
@@ -3853,9 +4650,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', _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.scaleMatrix.call(void 0, Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _92 => _92.scale, 'optionalAccess', _93 => _93.x]), () => ( 100))) / 100, k), Math.pow((_nullishCoalesce(_optionalChain([r, 'access', _94 => _94.scale, 'optionalAccess', _95 => _95.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', _82 => _82.position, 'optionalAccess', _83 => _83.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _84 => _84.position, 'optionalAccess', _85 => _85.y]), () => ( 0))) * k));
+    m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, m, _chunkDWGZUSEScjs.translateMatrix.call(void 0, pivot.x + (_nullishCoalesce(_optionalChain([r, 'access', _96 => _96.position, 'optionalAccess', _97 => _97.x]), () => ( 0))) * k, pivot.y + (_nullishCoalesce(_optionalChain([r, 'access', _98 => _98.position, 'optionalAccess', _99 => _99.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)) });
@@ -4329,14 +5126,14 @@ function lerpStops(a, b, t) {
 function lerpGradient(a, b, t) {
   if (a.type !== b.type) return null;
   const { stops, resampled } = lerpStops(a, b, t);
-  const near = t < 0.5 ? a : b;
+  const near2 = t < 0.5 ? a : b;
   const out = { type: a.type, stops };
   if (!resampled) {
     if (a.interpolation && a.interpolation !== "srgb") out.interpolation = a.interpolation;
     if (a.smoothness) out.smoothness = a.smoothness;
   }
-  if (near.spread && near.spread !== "pad") out.spread = near.spread;
-  if (near.strokeMode && near.strokeMode !== "within") out.strokeMode = near.strokeMode;
+  if (near2.spread && near2.spread !== "pad") out.spread = near2.spread;
+  if (near2.strokeMode && near2.strokeMode !== "within") out.strokeMode = near2.strokeMode;
   const ea = hasExplicitGradientGeometry(a);
   const eb = hasExplicitGradientGeometry(b);
   if (!ea && !eb) {
@@ -4354,7 +5151,7 @@ function lerpGradient(a, b, t) {
   const pa = vectorGradientPoints(a);
   const pb = vectorGradientPoints(b);
   if (pa.units !== pb.units) {
-    const src = explicitVectorGradient(near);
+    const src = explicitVectorGradient(near2);
     return { ...src, stops: out.stops, ...out.interpolation ? { interpolation: out.interpolation } : {}, ...out.smoothness ? { smoothness: out.smoothness } : {} };
   }
   out.start = lerpPoint(pa.start, pb.start, t);
@@ -4388,7 +5185,7 @@ function interpolateVectorPaint(a, b, t) {
   return t < 0.5 ? a : b;
 }
 function interpolateWidthProfiles(a, b, t) {
-  if (!_optionalChain([a, 'optionalAccess', _86 => _86.length]) && !_optionalChain([b, 'optionalAccess', _87 => _87.length])) return null;
+  if (!_optionalChain([a, 'optionalAccess', _100 => _100.length]) && !_optionalChain([b, 'optionalAccess', _101 => _101.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) => {
@@ -4398,7 +5195,7 @@ function interpolateWidthProfiles(a, b, t) {
   });
 }
 function lerpDashes(a, b, t) {
-  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _88 => _88.length]) && d.some((v2) => v2 > 0);
+  const dashed = (d) => !!_optionalChain([d, 'optionalAccess', _102 => _102.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) => {
@@ -4414,18 +5211,18 @@ function lerpDashes(a, b, t) {
 }
 var SWITCHED_KEYS = ["strokeLinecap", "strokeLinejoin", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign"];
 function interpolateVectorStyle(a, b, t) {
-  const near = t < 0.5 ? a : b;
+  const near2 = t < 0.5 ? a : b;
   const out = {};
   const fill = interpolateVectorPaint(a.fill, b.fill, t);
   if (fill !== void 0) out.fill = fill;
   const stroke = interpolateVectorPaint(a.stroke, b.stroke, t);
   if (stroke !== void 0) out.stroke = stroke;
   if (a.strokeWidth !== void 0 || b.strokeWidth !== void 0) out.strokeWidth = lerpN(_nullishCoalesce(a.strokeWidth, () => ( 1)), _nullishCoalesce(b.strokeWidth, () => ( 1)), t);
-  for (const key of SWITCHED_KEYS) if (near[key] !== void 0 && near[key] !== null) out[key] = near[key];
+  for (const key of SWITCHED_KEYS) if (near2[key] !== void 0 && near2[key] !== null) out[key] = near2[key];
   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', _89 => _89.length])) out.strokeDasharray = dash;
+  if (_optionalChain([dash, 'optionalAccess', _103 => _103.length])) out.strokeDasharray = dash;
   const profile = interpolateWidthProfiles(a.strokeWidthProfile, b.strokeWidthProfile, t);
   if (profile) out.strokeWidthProfile = profile;
   return out;
@@ -4436,7 +5233,7 @@ function reversedStyle(s) {
   out.endArrow = s.startArrow;
   out.startArrowScale = s.endArrowScale;
   out.endArrowScale = s.startArrowScale;
-  if (_optionalChain([s, 'access', _90 => _90.strokeWidthProfile, 'optionalAccess', _91 => _91.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
+  if (_optionalChain([s, 'access', _104 => _104.strokeWidthProfile, 'optionalAccess', _105 => _105.length])) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
   for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
   return out;
 }
@@ -4483,286 +5280,91 @@ function preparePathMorph(a, b, options, ma = nodeMatrix(a), mb = nodeMatrix(b))
     const opacity = lerpN(_nullishCoalesce(a.opacity, () => ( 1)), _nullishCoalesce(b.opacity, () => ( 1)), t);
     if (opacity < 1) node.opacity = opacity;
     if (rigid && !_chunkDWGZUSEScjs.isIdentityMatrix.call(void 0, m)) node.transform = m;
-    return node;
-  };
-}
-function flattenPaths(node, parent = _chunkDWGZUSEScjs.IDENTITY_MATRIX) {
-  const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, nodeMatrix(node), parent);
-  if (node.type === "path") return [{ path: node, m, opacity: 1 }];
-  const o = _nullishCoalesce(node.opacity, () => ( 1));
-  return node.children.filter((c) => c.visible !== false).flatMap((c) => flattenPaths(c, m)).map((e) => ({ ...e, opacity: e.opacity * o }));
-}
-var placedBounds = (path, m) => boundsOfPoints(contoursOf(path, m).flatMap((c) => c.pts));
-function collapsedPath(path, m, from, to) {
-  const own = placedBounds(path, m);
-  const c = own ? [own.x + own.width / 2, own.y + own.height / 2] : [0, 0];
-  const fx = from && from.width > 0 ? (c[0] - from.x) / from.width : 0.5;
-  const fy = from && from.height > 0 ? (c[1] - from.y) / from.height : 0.5;
-  const p = to ? { x: to.x + to.width * fx, y: to.y + to.height * fy } : { x: c[0], y: c[1] };
-  const subpaths = path.subpaths.map((sp) => ({ closed: sp.closed, anchors: sp.anchors.map(() => ({ x: p.x, y: p.y })) }));
-  const { transform: _t, ...rest } = path;
-  return { ...rest, subpaths };
-}
-function createVectorMorph(a, b, options = {}) {
-  if (a.type === "path" && b.type === "path") {
-    const at2 = preparePathMorph(a, b, options);
-    return { at: at2 };
-  }
-  const pa = flattenPaths(a);
-  const pb = flattenPaths(b);
-  const ba = unionBounds(pa.map((e) => placedBounds(e.path, e.m)));
-  const bb = unionBounds(pb.map((e) => placedBounds(e.path, e.m)));
-  const id = _nullishCoalesce(options.id, () => ( a.id));
-  const parts = [];
-  const opacities = [];
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    const x = pa[i];
-    const y = pb[i];
-    const sub5 = { ...options, id: `${id}-${i}`, starts: void 0 };
-    if (x && y) {
-      parts.push(preparePathMorph(x.path, y.path, sub5, x.m, y.m));
-      opacities.push([x.opacity, y.opacity]);
-    } else if (x) {
-      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub5, x.m, _chunkDWGZUSEScjs.IDENTITY_MATRIX));
-      opacities.push([x.opacity, x.opacity]);
-    } else if (y) {
-      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub5, _chunkDWGZUSEScjs.IDENTITY_MATRIX, y.m));
-      opacities.push([y.opacity, y.opacity]);
-    }
-  }
-  return {
-    at: (t) => {
-      const children = parts.map((p, i) => {
-        const n = p(t);
-        const o = lerpN(opacities[i][0], opacities[i][1], t) * (_nullishCoalesce(n.opacity, () => ( 1)));
-        if (o < 1) n.opacity = o;
-        else delete n.opacity;
-        return n;
-      });
-      const group = { id, type: "group", children };
-      return group;
-    }
-  };
-}
-function interpolateVectorPaths(a, b, t, options = {}) {
-  return createVectorMorph(a, b, options).at(t);
-}
-var keyframeMorphs = /* @__PURE__ */ new WeakMap();
-function evaluateVectorPathKeyframes(keyframes, time, options = {}) {
-  const keys = keyframes.filter((k) => Number.isFinite(k.time)).sort((x, y) => x.time - y.time);
-  if (!keys.length) return null;
-  if (!(time > keys[0].time)) return keys[0].value;
-  const last = keys[keys.length - 1];
-  if (time >= last.time) return last.value;
-  let i = 0;
-  while (i + 1 < keys.length && keys[i + 1].time <= time) i++;
-  const a = keys[i];
-  const b = keys[i + 1];
-  if (time === a.time) return a.value;
-  if (a.easing === "hold") return a.value;
-  const span = b.time - a.time;
-  const u = Math.min(1, Math.max(0, _chunk2FHLHZALcjs.evaluateEasing.call(void 0, a.easing, (time - a.time) / span, span)));
-  let inner = keyframeMorphs.get(a.value);
-  if (!inner) keyframeMorphs.set(a.value, inner = /* @__PURE__ */ new WeakMap());
-  let morph = inner.get(b.value);
-  if (!morph) inner.set(b.value, morph = createVectorMorph(a.value, b.value, 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;
-  });
+    return node;
+  };
 }
-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;
+function flattenPaths(node, parent = _chunkDWGZUSEScjs.IDENTITY_MATRIX) {
+  const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, nodeMatrix(node), parent);
+  if (node.type === "path") return [{ path: node, m, opacity: 1 }];
+  const o = _nullishCoalesce(node.opacity, () => ( 1));
+  return node.children.filter((c) => c.visible !== false).flatMap((c) => flattenPaths(c, m)).map((e) => ({ ...e, opacity: e.opacity * o }));
 }
-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");
+var placedBounds = (path, m) => boundsOfPoints(contoursOf(path, m).flatMap((c) => c.pts));
+function collapsedPath(path, m, from, to) {
+  const own = placedBounds(path, m);
+  const c = own ? [own.x + own.width / 2, own.y + own.height / 2] : [0, 0];
+  const fx = from && from.width > 0 ? (c[0] - from.x) / from.width : 0.5;
+  const fy = from && from.height > 0 ? (c[1] - from.y) / from.height : 0.5;
+  const p = to ? { x: to.x + to.width * fx, y: to.y + to.height * fy } : { x: c[0], y: c[1] };
+  const subpaths = path.subpaths.map((sp) => ({ closed: sp.closed, anchors: sp.anchors.map(() => ({ x: p.x, y: p.y })) }));
+  const { transform: _t, ...rest } = path;
+  return { ...rest, subpaths };
+}
+function createVectorMorph(a, b, options = {}) {
+  if (a.type === "path" && b.type === "path") {
+    const at2 = preparePathMorph(a, b, options);
+    return { at: at2 };
   }
-  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");
+  const pa = flattenPaths(a);
+  const pb = flattenPaths(b);
+  const ba = unionBounds(pa.map((e) => placedBounds(e.path, e.m)));
+  const bb = unionBounds(pb.map((e) => placedBounds(e.path, e.m)));
+  const id = _nullishCoalesce(options.id, () => ( a.id));
+  const parts = [];
+  const opacities = [];
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const x = pa[i];
+    const y = pb[i];
+    const sub5 = { ...options, id: `${id}-${i}`, starts: void 0 };
+    if (x && y) {
+      parts.push(preparePathMorph(x.path, y.path, sub5, x.m, y.m));
+      opacities.push([x.opacity, y.opacity]);
+    } else if (x) {
+      parts.push(preparePathMorph(x.path, collapsedPath(x.path, x.m, ba, bb), sub5, x.m, _chunkDWGZUSEScjs.IDENTITY_MATRIX));
+      opacities.push([x.opacity, x.opacity]);
+    } else if (y) {
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub5, _chunkDWGZUSEScjs.IDENTITY_MATRIX, y.m));
+      opacities.push([y.opacity, y.opacity]);
     }
-    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
+    at: (t) => {
+      const children = parts.map((p, i) => {
+        const n = p(t);
+        const o = lerpN(opacities[i][0], opacities[i][1], t) * (_nullishCoalesce(n.opacity, () => ( 1)));
+        if (o < 1) n.opacity = o;
+        else delete n.opacity;
+        return n;
+      });
+      const group = { id, type: "group", children };
+      return group;
+    }
   };
 }
-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 interpolateVectorPaths(a, b, t, options = {}) {
+  return createVectorMorph(a, b, options).at(t);
 }
-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 keyframeMorphs = /* @__PURE__ */ new WeakMap();
+function evaluateVectorPathKeyframes(keyframes, time, options = {}) {
+  const keys = keyframes.filter((k) => Number.isFinite(k.time)).sort((x, y) => x.time - y.time);
+  if (!keys.length) return null;
+  if (!(time > keys[0].time)) return keys[0].value;
+  const last = keys[keys.length - 1];
+  if (time >= last.time) return last.value;
+  let i = 0;
+  while (i + 1 < keys.length && keys[i + 1].time <= time) i++;
+  const a = keys[i];
+  const b = keys[i + 1];
+  if (time === a.time) return a.value;
+  if (a.easing === "hold") return a.value;
+  const span = b.time - a.time;
+  const u = Math.min(1, Math.max(0, _chunk2FHLHZALcjs.evaluateEasing.call(void 0, a.easing, (time - a.time) / span, span)));
+  let inner = keyframeMorphs.get(a.value);
+  if (!inner) keyframeMorphs.set(a.value, inner = /* @__PURE__ */ new WeakMap());
+  let morph = inner.get(b.value);
+  if (!morph) inner.set(b.value, morph = createVectorMorph(a.value, b.value, options));
+  return morph.at(u);
 }
-var VECTOR_FILTER_MENU = VECTOR_FILTER_TYPES.map((type) => ({ type, label: VECTOR_FILTER_LABELS[type] }));
 
 // src/vector/gradientStroke.ts
 var SHARP = 1.25;
@@ -4939,7 +5541,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', _98 => _98[+m[1]], 'optionalAccess', _99 => _99.anchors, 'access', _100 => _100[+m[2]]]);
+    const a = _optionalChain([subpaths, 'access', _106 => _106[+m[1]], 'optionalAccess', _107 => _107.anchors, 'access', _108 => _108[+m[2]]]);
     const radius = parseFloat(m[3]);
     if (!a || !(radius > 0)) continue;
     const kind = VECTOR_CORNER_KINDS.includes(m[4]) ? m[4] : void 0;
@@ -4961,7 +5563,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', _101 => _101.get, 'call', _102 => _102(owner), 'optionalAccess', _103 => _103.get, 'call', _104 => _104(key)]);
+  const cached = _optionalChain([paintCache, 'access', _109 => _109.get, 'call', _110 => _110(owner), 'optionalAccess', _111 => _111.get, 'call', _112 => _112(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;
@@ -5015,7 +5617,7 @@ function vectorNodeLocalPaintBounds(node) {
 }
 var filterCache = /* @__PURE__ */ new WeakMap();
 function vectorNodeFilterSvg(node, id) {
-  if (!_optionalChain([node, 'access', _105 => _105.filters, 'optionalAccess', _106 => _106.length])) return null;
+  if (!_optionalChain([node, 'access', _113 => _113.filters, 'optionalAccess', _114 => _114.length])) return null;
   const hit = filterCache.get(node);
   if (hit && hit.id === id) return hit.filter;
   const active = activeVectorFilters(node);
@@ -5095,7 +5697,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     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])) {
+    if (_optionalChain([node, 'access', _115 => _115.filters, 'optionalAccess', _116 => _116.length])) {
       const filter = vectorNodeFilterSvg(node, `${prefix}filter-${node.id}`);
       const data = ` data-vector-filters="${escapeAttr2(JSON.stringify(node.filters))}"`;
       if (filter) {
@@ -5142,7 +5744,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     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(" ")}"`;
+    if (_optionalChain([node, 'access', _117 => _117.strokeDasharray, 'optionalAccess', _118 => _118.length])) out2 += ` stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
     return out2;
   };
   const liveCorners = (node) => {
@@ -5185,7 +5787,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emit2 = (node, depth) => {
     if (node.visible === false && !options.includeHidden) return;
-    const wrappers = _nullishCoalesce(_optionalChain([options, 'access', _111 => _111.wrap, 'optionalAccess', _112 => _112[node.id]]), () => ( []));
+    const wrappers = _nullishCoalesce(_optionalChain([options, 'access', _119 => _119.wrap, 'optionalAccess', _120 => _120[node.id]]), () => ( []));
     wrappers.forEach((w2, i) => {
       let attrs = w2.id !== void 0 ? ` id="${escapeAttr2(w2.id)}"` : "";
       if (w2.transform) attrs += ` transform="${escapeAttr2(w2.transform)}"`;
@@ -5199,11 +5801,49 @@ function vectorDocumentToSvg(doc, options = {}) {
     emitNode(node, depth + wrappers.length);
     for (let i = wrappers.length - 1; i >= 0; i--) lines.push(`${indent(depth + i)}</g>`);
   };
+  const capture = (fn) => {
+    const at2 = lines.length;
+    fn();
+    return lines.splice(at2).map((l) => l.trim()).join("");
+  };
+  const emitMaskGroup = (node, depth) => {
+    const [source, ...contents] = node.children;
+    const body = _optionalChain([node, 'access', _121 => _121.effects, 'optionalAccess', _122 => _122.length]) && contents.length ? [{ id: `${node.id}~content`, type: "group", effects: node.effects, children: contents }] : contents;
+    const settings = { type: node.mask.type, ...node.mask.invert ? { invert: true } : {} };
+    lines.push(`${indent(depth)}<g${common(node)} data-vector-mask="${escapeAttr2(JSON.stringify(settings))}">`);
+    const mask = vectorMaskRenderData(node, `${prefix}mask-${node.id}`, `${prefix}mask-filter-${node.id}`, precision);
+    let ref = "";
+    if (mask && mask.type !== "clip") {
+      const b = mask.bounds;
+      const box = `x="${num2(b.x)}" y="${num2(b.y)}" width="${num2(b.width)}" height="${num2(b.height)}"`;
+      if (mask.invertFilter) defs.push(vectorFilterMarkup(mask.invertFilter));
+      const inner = capture(() => emitNode(source, depth + 1));
+      const drawn = mask.filter ? `<g data-vector-part="mask-invert" filter="${escapeAttr2(mask.filter)}">${inner}</g>` : inner;
+      defs.push(`<mask id="${escapeAttr2(mask.id)}" data-vector-part="mask-source" maskUnits="userSpaceOnUse" ${box}${mask.type === "alpha" ? ' mask-type="alpha"' : ""}>${drawn}</mask>`);
+      ref = ` mask="url(#${escapeAttr2(mask.id)})"`;
+    } else {
+      lines.push(`${indent(depth + 1)}<g data-vector-part="mask-source" display="none">`);
+      emitNode(source, depth + 2);
+      lines.push(`${indent(depth + 1)}</g>`);
+      if (_optionalChain([mask, 'optionalAccess', _123 => _123.clip])) {
+        defs.push(`<clipPath id="${escapeAttr2(mask.id)}">${mask.clip.map((c) => `<path d="${c.d}" clip-rule="${c.clipRule}"/>`).join("")}</clipPath>`);
+        ref = ` clip-path="url(#${escapeAttr2(mask.id)})"`;
+      }
+    }
+    lines.push(`${indent(depth + 1)}<g data-vector-part="masked"${ref}>`);
+    for (const child of body) emit2(child, depth + 2);
+    lines.push(`${indent(depth + 1)}</g>`);
+    lines.push(`${indent(depth)}</g>`);
+  };
   const emitNode = (node, depth) => {
+    if (isVectorMaskGroup(node)) {
+      emitMaskGroup(node, depth);
+      return;
+    }
     if (hasOwnVectorAppearance(node)) {
       const live2 = {
         kind: node.type,
-        ..._optionalChain([node, 'access', _113 => _113.effects, 'optionalAccess', _114 => _114.length]) ? { effects: node.effects } : {},
+        ..._optionalChain([node, 'access', _124 => _124.effects, 'optionalAccess', _125 => _125.length]) ? { effects: node.effects } : {},
         ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {}
       };
       lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr2(JSON.stringify(live2))}">`);
@@ -5253,7 +5893,7 @@ function vectorDocumentToSvg(doc, options = {}) {
       data += ` data-vector-width-profile="${widthProfileToAttribute(profile)}"`;
       if (node.strokeLinecap && node.strokeLinecap !== "butt") data += ` data-vector-stroke-linecap="${node.strokeLinecap}"`;
       if (node.strokeLinejoin && node.strokeLinejoin !== "miter") data += ` data-vector-stroke-linejoin="${node.strokeLinejoin}"`;
-      if (_optionalChain([node, 'access', _115 => _115.strokeDasharray, 'optionalAccess', _116 => _116.length])) data += ` data-vector-stroke-dasharray="${node.strokeDasharray.map(num2).join(" ")}"`;
+      if (_optionalChain([node, 'access', _126 => _126.strokeDasharray, 'optionalAccess', _127 => _127.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}/>`);
@@ -5402,6 +6042,26 @@ 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 collectMasks(el, raw) {
+  if ((el.name === "clipPath" || el.name === "mask") && el.attrs.id) raw.set(el.attrs.id, el);
+  for (const c of el.children) collectMasks(c, raw);
+}
+function attrOrStyle(el, name) {
+  for (const decl of (_nullishCoalesce(el.attrs.style, () => ( ""))).split(";")) {
+    const i = decl.indexOf(":");
+    if (i >= 0 && decl.slice(0, i).trim() === name) return decl.slice(i + 1).replace(/!important/, "").trim();
+  }
+  return el.attrs[name];
+}
+function urlId(value) {
+  return _nullishCoalesce(_optionalChain([/^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/, 'access', _128 => _128.exec, 'call', _129 => _129((_nullishCoalesce(value, () => ( ""))).trim()), 'optionalAccess', _130 => _130[1]]), () => ( null));
+}
+function clipRulesAsFillRules(el) {
+  const attrs = { ...el.attrs };
+  const rule = attrOrStyle(el, "clip-rule");
+  if (rule) attrs["fill-rule"] = rule;
+  return { ...el, attrs, children: el.children.map(clipRulesAsFillRules) };
+}
 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);
@@ -5459,9 +6119,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', _117 => _117.startsWith, 'call', _118 => _118("#")]) ? raw.get(href.slice(1)) : void 0;
+    el = _optionalChain([href, 'optionalAccess', _131 => _131.startsWith, 'call', _132 => _132("#")]) ? raw.get(href.slice(1)) : void 0;
   }
-  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 attr = (name) => _optionalChain([chain, 'access', _133 => _133.find, 'call', _134 => _134((el) => el.attrs[name] !== void 0), 'optionalAccess', _135 => _135.attrs, 'access', _136 => _136[name]]);
   const stops = _nullishCoalesce(chain.map(readStops).find((s) => s.length), () => ( []));
   if (!stops.length) return null;
   const user = attr("gradientUnits") === "userSpaceOnUse";
@@ -5540,6 +6200,9 @@ function parseVectorSvg(svg, options = {}) {
   collectGradients(root, rawGradients);
   const rawFilters = /* @__PURE__ */ new Map();
   collectFilters(root, rawFilters);
+  const rawMasks = /* @__PURE__ */ new Map();
+  collectMasks(root, rawMasks);
+  const resolving = /* @__PURE__ */ new Set();
   const filtersOf = (value) => {
     const url = /^url\(\s*['"]?#([^'")\s]+)['"]?\s*\)/.exec((_nullishCoalesce(value, () => ( ""))).trim());
     const el = url ? rawFilters.get(url[1]) : void 0;
@@ -5628,7 +6291,7 @@ function parseVectorSvg(svg, options = {}) {
   const stackedPath = (g, _style, m, meta) => {
     const fillEl = g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === "fill");
     const subpaths = fillEl ? shapeOf(fillEl) : null;
-    if (!_optionalChain([subpaths, 'optionalAccess', _123 => _123.length])) return null;
+    if (!_optionalChain([subpaths, 'optionalAccess', _137 => _137.length])) return null;
     const parse = (v2) => {
       try {
         return v2 ? JSON.parse(v2) : [];
@@ -5647,7 +6310,7 @@ function parseVectorSvg(svg, options = {}) {
     const key = (n) => JSON.stringify([n.subpaths, _nullishCoalesce(n.transform, () => ( null)), _nullishCoalesce(n.opacity, () => ( 1)), n.visible !== false, _nullishCoalesce(n.filters, () => ( null)), _nullishCoalesce(n.blendMode, () => ( "normal")), _nullishCoalesce(n.fillRule, () => ( "nonzero")), _nullishCoalesce(n.booleanOperation, () => ( null))]);
     for (const n of nodes2) {
       const prev = out[out.length - 1];
-      if (_optionalChain([prev, 'optionalAccess', _124 => _124.type]) === "path" && n.type === "path" && key(prev) === key(n)) {
+      if (_optionalChain([prev, 'optionalAccess', _138 => _138.type]) === "path" && n.type === "path" && key(prev) === key(n)) {
         const fills = vectorFills(n);
         const strokesBefore = vectorStrokes(prev);
         if (!(fills.length && strokesBefore.length)) {
@@ -5665,7 +6328,7 @@ function parseVectorSvg(svg, options = {}) {
     const part = (name) => g.children.find((c) => c.name === "path" && c.attrs["data-vector-part"] === name);
     const fillEl = part("fill");
     const subpaths = fillEl ? shapeOf(fillEl) : null;
-    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _125 => _125.length])) return null;
+    if (!fillEl || !_optionalChain([subpaths, 'optionalAccess', _139 => _139.length])) return null;
     const a = g.attrs;
     const fs = readStyle(fillEl, style);
     const strokeEl = part("stroke");
@@ -5702,7 +6365,7 @@ function parseVectorSvg(svg, options = {}) {
       ...profile.length ? { strokeWidthProfile: profile } : {},
       ...keptCap ? { strokeLinecap: keptCap } : {},
       ...keptJoin ? { strokeLinejoin: keptJoin } : {},
-      ..._optionalChain([keptDash, 'optionalAccess', _126 => _126.length]) ? { strokeDasharray: keptDash } : {}
+      ..._optionalChain([keptDash, 'optionalAccess', _140 => _140.length]) ? { strokeDasharray: keptDash } : {}
     };
     return placed(node, m);
   };
@@ -5738,68 +6401,148 @@ function parseVectorSvg(svg, options = {}) {
     const out = [];
     for (const child of el.children) {
       if (SKIP.has(child.name)) continue;
-      const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, parseSvgTransform(child.attrs.transform), matrix);
-      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 } : {},
-        ...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"];
-      if (BOOLEAN_OPERATIONS.includes(operation)) meta.booleanOperation = operation;
-      if (child.name === "g" && child.attrs["data-vector-live"] !== void 0) {
-        const node2 = liveNode(child, s, m, meta);
-        if (node2) out.push(node2);
-        continue;
-      }
-      if (child.name === "g" && child.attrs["data-vector-path"] !== void 0 && 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);
-        continue;
-      }
-      if (child.name === "g" || child.name === "svg" || child.name === "a" || child.name === "switch") {
-        const children = visit(child, s, m);
-        if (!children.length) continue;
-        const group = { id: idFor(child), type: "group", ...meta, children };
-        const blend = child.name === "g" ? blendFromAttribute(child.attrs["data-vector-blend"], m) : null;
-        if (blend) group.blend = blend;
-        out.push(group);
-        continue;
-      }
-      const subpaths = shapeOf(child);
-      if (!subpaths || !subpaths.length) continue;
-      const node = placed(
-        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);
+      const nodes2 = visitOne(child, style, matrix);
+      out.push(...nodes2.length ? masked(child, nodes2, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, parseSvgTransform(child.attrs.transform), matrix)) : nodes2);
     }
     return options.mergeStackedShapes ? mergeStacked(out) : out;
   };
-  const nodes = visit(root, readStyle(root, { fill: "#000", stroke: "none", strokeWidth: "" }), rootMatrix);
+  let rootStyle = { fill: "#000", stroke: "none", strokeWidth: "" };
+  const bboxMatrix = (nodes2) => {
+    const b = unionBounds(nodes2.map((n) => vectorNodeBounds(n)));
+    return b && b.width > 0 && b.height > 0 ? [b.width, 0, 0, b.height, b.x, b.y] : null;
+  };
+  const maskNode = (el, m, nodes2, units) => {
+    const id = el.attrs.id;
+    if (!id || resolving.has(id)) return null;
+    let space = m;
+    if (units === "objectBoundingBox") {
+      const box = bboxMatrix(nodes2);
+      if (!box) return null;
+      space = box;
+    }
+    resolving.add(id);
+    const isClip = el.name === "clipPath";
+    const content = isClip ? clipRulesAsFillRules(el) : el;
+    const inner = visit(content, readStyle(content, rootStyle), _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, parseSvgTransform(el.attrs.transform), space));
+    resolving.delete(id);
+    const strip2 = (n) => n.type === "path" ? withVectorStrokes(withVectorFills({ ...n, fill: null, stroke: null }, []), []) : { ...n, children: n.children.map(strip2) };
+    const list = isClip ? inner.map(strip2) : inner;
+    if (!list.length) return null;
+    return list.length === 1 ? list[0] : { id: idFor({ name: "g", attrs: {}, children: [] }), type: "group", name: isClip ? "Clip" : "Mask", children: list };
+  };
+  const masked = (el, nodes2, m) => {
+    let out = nodes2;
+    const clipEl = rawMasks.get(_nullishCoalesce(urlId(attrOrStyle(el, "clip-path")), () => ( "")));
+    if (_optionalChain([clipEl, 'optionalAccess', _141 => _141.name]) === "clipPath") {
+      const source = maskNode(clipEl, m, out, clipEl.attrs.clipPathUnits);
+      if (source) out = [{ id: idFor({ name: "g", attrs: {}, children: [] }), type: "group", name: "Clip Group", mask: { type: "clip" }, children: [source, ...out] }];
+    }
+    const maskEl = rawMasks.get(_nullishCoalesce(urlId(attrOrStyle(el, "mask")), () => ( "")));
+    if (_optionalChain([maskEl, 'optionalAccess', _142 => _142.name]) === "mask") {
+      const source = maskNode(maskEl, m, out, maskEl.attrs.maskContentUnits);
+      const type = attrOrStyle(maskEl, "mask-type") === "alpha" ? "alpha" : "luminance";
+      if (source) out = [{ id: idFor({ name: "g", attrs: {}, children: [] }), type: "group", name: "Opacity Mask", mask: { type }, children: [source, ...out] }];
+    }
+    return out;
+  };
+  const maskGroup = (g, style, m, meta) => {
+    let raw = null;
+    try {
+      raw = JSON.parse(g.attrs["data-vector-mask"]);
+    } catch (e8) {
+      raw = null;
+    }
+    const mask = sanitizeVectorMask(raw);
+    const part = (name) => g.children.find((c) => c.name === "g" && c.attrs["data-vector-part"] === name);
+    const maskedEl = part("masked");
+    if (!mask || !maskedEl) return null;
+    const id = idFor(g);
+    let sourceEl = part("mask-source");
+    if (!sourceEl) {
+      const el = rawMasks.get(_nullishCoalesce(urlId(maskedEl.attrs.mask), () => ( "")));
+      const invert2 = _optionalChain([el, 'optionalAccess', _143 => _143.children, 'access', _144 => _144.find, 'call', _145 => _145((c) => c.name === "g" && c.attrs["data-vector-part"] === "mask-invert")]);
+      sourceEl = _nullishCoalesce(invert2, () => ( el));
+    }
+    const source = sourceEl ? visit(sourceEl, style, m)[0] : void 0;
+    let contents = visit(maskedEl, style, m);
+    let effects;
+    const wrapper = contents.length === 1 && contents[0].type === "group" && contents[0].id === `${id}~content` ? contents[0] : null;
+    if (_optionalChain([wrapper, 'optionalAccess', _146 => _146.type]) === "group") {
+      effects = _nullishCoalesce(wrapper.effects, () => ( void 0));
+      contents = wrapper.children;
+    }
+    if (!source) return contents.length ? { id, type: "group", ...meta, children: contents } : null;
+    return { id, type: "group", ...meta, mask, ..._optionalChain([effects, 'optionalAccess', _147 => _147.length]) ? { effects } : {}, children: [source, ...contents] };
+  };
+  const visitOne = (child, style, matrix) => {
+    const out = [];
+    const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, parseSvgTransform(child.attrs.transform), matrix);
+    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 } : {},
+      ...blendMode && blendMode !== "normal" ? { blendMode } : {},
+      ...filters.length ? { filters } : {}
+    };
+    if (child.attrs["data-vector-blend-step"] !== void 0) return out;
+    const operation = child.attrs["data-vector-boolean-operation"];
+    if (BOOLEAN_OPERATIONS.includes(operation)) meta.booleanOperation = operation;
+    if (child.name === "g" && child.attrs["data-vector-mask"] !== void 0) {
+      const node2 = maskGroup(child, s, m, meta);
+      if (node2) out.push(node2);
+      return out;
+    }
+    if (child.name === "g" && child.attrs["data-vector-live"] !== void 0) {
+      const node2 = liveNode(child, s, m, meta);
+      if (node2) out.push(node2);
+      return out;
+    }
+    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);
+      return out;
+    }
+    if (child.name === "g" && child.attrs["data-vector-path"] !== void 0) {
+      const node2 = mergedPath(child, s, m, meta);
+      if (node2) out.push(node2);
+      return out;
+    }
+    if (child.name === "g" || child.name === "svg" || child.name === "a" || child.name === "switch") {
+      const children = visit(child, s, m);
+      if (!children.length) return out;
+      const group = { id: idFor(child), type: "group", ...meta, children };
+      const blend = child.name === "g" ? blendFromAttribute(child.attrs["data-vector-blend"], m) : null;
+      if (blend) group.blend = blend;
+      out.push(group);
+      return out;
+    }
+    const subpaths = shapeOf(child);
+    if (!subpaths || !subpaths.length) return out;
+    const node = placed(
+      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;
+  };
+  rootStyle = readStyle(root, rootStyle);
+  const nodes = visit(root, rootStyle, rootMatrix);
   return { width, height, nodes };
 }
 
@@ -6076,5 +6819,31 @@ 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_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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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_MASK_TYPES = VECTOR_MASK_TYPES; 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.splitIntoFaces = splitIntoFaces; exports.knifePath = knifePath; exports.eraserRegion = eraserRegion; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.polylineBounds = polylineBounds; exports.simplifyPolyline = simplifyPolyline; exports.VECTOR_FILTER_DEFAULTS = VECTOR_FILTER_DEFAULTS; exports.VECTOR_FILTER_LABELS = VECTOR_FILTER_LABELS; exports.VECTOR_FILTER_PARAM_SPECS = VECTOR_FILTER_PARAM_SPECS; exports.isVectorFilterType = isVectorFilterType; exports.normalizeVectorFilterParams = normalizeVectorFilterParams; exports.vectorFilterParamKeys = vectorFilterParamKeys; exports.createVectorFilter = createVectorFilter; exports.sanitizeVectorFilters = sanitizeVectorFilters; exports.activeVectorFilters = activeVectorFilters; exports.vectorFilterReach = vectorFilterReach; exports.vectorFilterSvg = vectorFilterSvg; exports.vectorFilterMarkup = vectorFilterMarkup; exports.VECTOR_FILTER_MENU = VECTOR_FILTER_MENU; exports.isVectorMaskType = isVectorMaskType; exports.sanitizeVectorMask = sanitizeVectorMask; exports.isVectorMaskGroup = isVectorMaskGroup; exports.isVectorMaskActive = isVectorMaskActive; exports.vectorMaskSource = vectorMaskSource; exports.vectorMaskContents = vectorMaskContents; exports.vectorMaskOwner = vectorMaskOwner; exports.vectorMaskSummary = vectorMaskSummary; exports.vectorMaskRegionShapes = vectorMaskRegionShapes; exports.vectorMaskRegion = vectorMaskRegion; exports.vectorMaskRegionPath = vectorMaskRegionPath; exports.vectorMaskContains = vectorMaskContains; exports.vectorMaskedShapes = vectorMaskedShapes; exports.vectorMaskedGeometry = vectorMaskedGeometry; exports.vectorMaskedLocalBounds = vectorMaskedLocalBounds; exports.vectorMaskContentBounds = vectorMaskContentBounds; exports.vectorMaskRenderData = vectorMaskRenderData; exports.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.vectorChildAppearanceShapes = vectorChildAppearanceShapes; exports.vectorEffectInputPaths = vectorEffectInputPaths; exports.vectorEffectInputBounds = vectorEffectInputBounds; exports.vectorNodeEnvelope = vectorNodeEnvelope; exports.vectorEnvelopeFrame = vectorEnvelopeFrame; exports.vectorAppearanceShapes = vectorAppearanceShapes; exports.vectorAppearanceOutline = vectorAppearanceOutline; exports.vectorAppearanceNodes = vectorAppearanceNodes; exports.expandVectorAppearance = expandVectorAppearance; exports.expandVectorAppearances = expandVectorAppearances; exports.sanitizeVectorEffects = sanitizeVectorEffects; exports.transformVectorEffects = transformVectorEffects; exports.vectorEnteredGroups = vectorEnteredGroups; exports.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.vectorNodeLocalPaintBounds = vectorNodeLocalPaintBounds; exports.vectorNodeFilterSvg = vectorNodeFilterSvg; exports.widthProfileToAttribute = widthProfileToAttribute; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg;
+//# sourceMappingURL=chunk-UTEVPQTS.cjs.map