@pixerate/editor 0.118.0 → 0.120.0

package/dist/{chunk-7LNZAWSJ.js → chunk-WORWH5K5.js}

@@ -75,6 +75,7 @@ var VECTOR_CONNECTOR_SIDES = ["auto", "top", "right", "bottom", "left", "center"
 var VECTOR_CONNECTOR_ROUTES = ["straight", "elbow", "curved"];
 var VECTOR_BLEND_SPACINGS = ["steps", "distance", "smoothColor"];
 var VECTOR_MASK_TYPES = ["clip", "alpha", "luminance"];
+var VECTOR_SYMMETRY_MODES = ["vertical", "horizontal", "dual", "diagonal", "radial"];
 var VECTOR_TEXT_ALIGNS = ["left", "center", "right", "justify"];
 var VECTOR_PATH_TEXT_BASELINES = ["baseline", "ascender", "descender", "center"];
 var VECTOR_CONSTRAINT_KINDS = [
@@ -121,7 +122,7 @@ var VECTOR_TOOLS = [
 ];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
-var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater", "envelope"];
+var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater", "envelope", "contour", "blockShadow"];
 var VECTOR_MERGE_MODES = ["merge", "add", "subtract", "intersect", "exclude"];
 var VECTOR_FILTER_TYPES = ["dropShadow", "innerShadow", "outerGlow", "innerGlow", "layerBlur", "feather"];
 
@@ -465,8 +466,8 @@ function vectorGradientParam(type, q, focal) {
     case "diamond":
       return Math.abs(q.x) + Math.abs(q.y);
     case "conic": {
-      const turn = Math.atan2(q.y, q.x) / (2 * Math.PI);
-      return turn - Math.floor(turn);
+      const turn2 = Math.atan2(q.y, q.x) / (2 * Math.PI);
+      return turn2 - Math.floor(turn2);
     }
     case "radial":
       return focal ? vectorGradientFocalParam(q, focal.f, focal.fr) : Math.hypot(q.x, q.y);
@@ -1451,12 +1452,12 @@ function squareTo(a, b) {
   return l > EPS ? mul2(w, 1 / l) : { x: 0, y: 0 };
 }
 function smoothCut(c, radius, smoothing) {
-  const turn = Math.PI - Math.acos(Math.max(-1, Math.min(1, c.cos)));
+  const turn2 = Math.PI - Math.acos(Math.max(-1, Math.min(1, c.cos)));
   const t = cornerSetback(c, radius);
   const room = Math.min(c.lu, c.lv) / 2;
   let s = Math.max(0, Math.min(1, smoothing));
   if ((1 + s) * t > room) s = Math.max(0, Math.min(s, room / t - 1));
-  const beta = turn * s / 2;
+  const beta = turn2 * s / 2;
   if (!(beta > 1e-6) || !(t > EPS)) return null;
   const p = Math.min((1 + s) * t, room);
   const qa = radius * Math.tan(beta / 2);
@@ -1471,7 +1472,7 @@ function smoothCut(c, radius, smoothing) {
   };
   const U = side(c.u, c.v);
   const V2 = side(c.v, c.u);
-  const sweep = turn * (1 - s);
+  const sweep = turn2 * (1 - s);
   const h = radius * (4 / 3) * Math.tan(sweep / 4);
   const tanU = sub2(U.a, U.q);
   const tanV = sub2(V2.a, V2.q);
@@ -1510,9 +1511,9 @@ function cutCorner(c, radius, kind, smoothing = 0) {
   }
   const d1 = mul2(a.dir, -1);
   const d2 = mul2(b.dir, -1);
-  const turn = Math.acos(Math.max(-1, Math.min(1, -dot2(d1, d2))));
+  const turn2 = Math.acos(Math.max(-1, Math.min(1, -dot2(d1, d2))));
   const chord = len(sub2(b.p, a.p));
-  const k = turn < 1e-9 ? chord / 3 : 4 / 3 * Math.tan(turn / 4) * chord / (2 * Math.sin(turn / 2));
+  const k = turn2 < 1e-9 ? chord / 3 : 4 / 3 * Math.tan(turn2 / 4) * chord / (2 * Math.sin(turn2 / 2));
   if (!Number.isFinite(k)) return null;
   return { tu: a.t, tv: b.t, start: a.p, out: add2(a.p, mul2(d1, k)), in: add2(b.p, mul2(d2, k)), end: b.p };
 }
@@ -2649,6 +2650,398 @@ function withVectorTargetPaint(node, target, layer, paint) {
   return target === "fill" ? withVectorFills(node, next) : withVectorStrokes(node, next);
 }
 
+// src/vector/pathEffects.ts
+var EPS2 = 1e-9;
+var degenerate = (s) => s.every((p) => Math.abs(p[0] - s[0][0]) < EPS2 && Math.abs(p[1] - s[0][1]) < EPS2);
+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 pathToContours(path).map((c) => ({ segs: closeContour(c).filter((s) => !degenerate(s)).map(raise), closed: c.closed })).filter((s) => s.segs.length > 0);
+}
+var subsToPath = (subs) => contoursToPath(subs.map((s) => ({ segments: s.segs, closed: s.closed })));
+var unit2 = (x, y) => {
+  const l = Math.hypot(x, y);
+  return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
+};
+function startTangent(s) {
+  for (let i = 1; i < s.length; i++) {
+    const u = unit2(s[i][0] - s[0][0], s[i][1] - s[0][1]);
+    if (u) return u;
+  }
+  return [1, 0];
+}
+function endTangent(s) {
+  const end = s[s.length - 1];
+  for (let i = s.length - 2; i >= 0; i--) {
+    const u = unit2(end[0] - s[i][0], end[1] - s[i][1]);
+    if (u) return u;
+  }
+  return [1, 0];
+}
+function tangentAt(s, t) {
+  if (t <= 1e-9) return startTangent(s);
+  if (t >= 1 - 1e-9) return endTangent(s);
+  const d = segmentDerivative(s, t);
+  return unit2(d[0], d[1]) ?? startTangent(s);
+}
+var perp2 = (v2) => [-v2[1], v2[0]];
+function effectPathLength(path) {
+  let total = 0;
+  for (const s of subsOf(path)) for (const seg of s.segs) total += segmentLength(seg);
+  return total;
+}
+function effectPathVertexCount(path) {
+  return subsOf(path).reduce((n, s) => n + s.segs.length + (s.closed ? 0 : 1), 0);
+}
+var Measured = class {
+  segs;
+  lens;
+  total;
+  constructor(path) {
+    this.segs = subsOf(path).flatMap((s) => s.segs);
+    this.lens = this.segs.map((s) => segmentLength(s));
+    this.total = this.lens.reduce((a, b) => a + b, 0);
+  }
+  /**
+   * Appends the part between lengths `sa` and `sb`, continuing the last piece when this one
+   * starts where it ends (across the start of a closed path).
+   */
+  append(sa, sb, out) {
+    for (const piece of trimSegments(this.segs, sa, sb, this.lens)) {
+      if (degenerate(piece)) continue;
+      const last = out[out.length - 1]?.segs;
+      const end = last?.[last.length - 1]?.at(-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);
+    }
+  }
+};
+function trimIntervals(start, end, offsetDegrees) {
+  let s = start / 100;
+  let e = end / 100;
+  if (!Number.isFinite(s) || !Number.isFinite(e)) return null;
+  if (s > e) [s, e] = [e, s];
+  s = Math.min(1, Math.max(0, s));
+  e = Math.min(1, Math.max(0, e));
+  if (e - s >= 1 - 1e-9) return null;
+  if (e - s <= 1e-9) return [];
+  const off = Number.isFinite(offsetDegrees) ? (offsetDegrees / 360 % 1 + 1) % 1 : 0;
+  s += off;
+  e += off;
+  if (e <= 1) return [[s, e]];
+  if (s >= 1) return [[s - 1, e - 1]];
+  return [
+    [s, 1],
+    [0, e - 1]
+  ];
+}
+function trimPaths(paths, start, end, offsetDegrees = 0) {
+  const iv = trimIntervals(start, end, offsetDegrees);
+  if (!iv) return paths.slice();
+  return paths.map((p) => {
+    const m = new Measured(p);
+    const out = [];
+    if (m.total > 0) for (const [a, b] of iv) m.append(a * m.total, b * m.total, out);
+    return subsToPath(out);
+  });
+}
+function trimPathsIndividually(paths, start, end, offsetDegrees = 0) {
+  const iv = trimIntervals(start, end, offsetDegrees);
+  if (!iv) return paths.slice();
+  const ms = paths.map((p) => new Measured(p));
+  const total = ms.reduce((n, m) => n + m.total, 0);
+  let base = 0;
+  return ms.map((m) => {
+    const out = [];
+    for (const [a, b] of iv) {
+      const la = Math.max(0, a * total - base);
+      const lb = Math.min(m.total, b * total - base);
+      if (lb > la) m.append(la, lb, out);
+    }
+    base += m.total;
+    return subsToPath(out);
+  });
+}
+function puckerBloatPaths(paths, amount) {
+  const a = amount / 100;
+  if (!a || !Number.isFinite(a)) return paths.slice();
+  return paths.map((p) => {
+    const verts = p.filter((c) => c.type !== "Z");
+    if (!verts.length) return p;
+    const cx = verts.reduce((s, c) => s + c.x, 0) / verts.length;
+    const cy = verts.reduce((s, c) => s + c.y, 0) / verts.length;
+    const mv = (x, y) => ({ x: x + (cx - x) * a, y: y + (cy - y) * a });
+    const mvh = (x, y) => ({ x: x + (x - cx) * a, y: y + (y - cy) * a });
+    const out = [];
+    let prev = { x: 0, y: 0 };
+    let start = { x: 0, y: 0 };
+    const curve = (c1, c2, q) => {
+      const h1 = mvh(c1.x, c1.y);
+      const h2 = mvh(c2.x, c2.y);
+      const e = mv(q.x, q.y);
+      out.push({ type: "C", x1: h1.x, y1: h1.y, x2: h2.x, y2: h2.y, x: e.x, y: e.y });
+    };
+    for (const c of p) {
+      switch (c.type) {
+        case "M": {
+          const e = mv(c.x, c.y);
+          out.push({ type: "M", x: e.x, y: e.y });
+          prev = start = { x: c.x, y: c.y };
+          break;
+        }
+        case "L":
+          curve(prev, c, c);
+          prev = { x: c.x, y: c.y };
+          break;
+        case "Q": {
+          const c1 = { x: prev.x + 2 / 3 * (c.x1 - prev.x), y: prev.y + 2 / 3 * (c.y1 - prev.y) };
+          const c2 = { x: c.x + 2 / 3 * (c.x1 - c.x), y: c.y + 2 / 3 * (c.y1 - c.y) };
+          curve(c1, c2, c);
+          prev = { x: c.x, y: c.y };
+          break;
+        }
+        case "C":
+          curve({ x: c.x1, y: c.y1 }, { x: c.x2, y: c.y2 }, c);
+          prev = { x: c.x, y: c.y };
+          break;
+        case "Z":
+          if (Math.hypot(prev.x - start.x, prev.y - start.y) > EPS2) curve(prev, start, start);
+          out.push({ type: "Z" });
+          prev = start;
+          break;
+      }
+    }
+    return out;
+  });
+}
+function roundCornerPaths(paths, radius) {
+  if (!(radius > 0) || !Number.isFinite(radius)) return paths.slice();
+  return paths.map((p) => subpathsToBezier(bezierToSubpaths(p).map((sp) => setSubpathCorners(sp, radius))));
+}
+function offsetPaths(paths, amount, join = "miter", miterLimit = 4, copies = 1, copyOffset = 0) {
+  const n = Math.min(1e3, Math.max(1, Math.round(Number.isFinite(copies) ? copies : 1)));
+  return paths.map((p) => {
+    const out = [];
+    for (let i = 0; i < n; i++) out.push(...offsetPath(p, amount * (i + 1 + copyOffset), { join, miterLimit }));
+    return out;
+  });
+}
+function sweepPath(path, dx, dy, fillRule = "nonzero", tolerance = 0.25) {
+  if (!path.length) return [];
+  if (!Number.isFinite(dx) || !Number.isFinite(dy) || Math.hypot(dx, dy) < 1e-9) return path.slice();
+  const bands = [];
+  for (const contour of pathToContours(path)) {
+    const ring = flattenChain(closeContour(contour, true), Math.max(1e-3, tolerance));
+    for (let i = 0; i < ring.length; i++) {
+      let p = ring[i];
+      let q = ring[(i + 1) % ring.length];
+      const turn2 = (q[0] - p[0]) * dy - (q[1] - p[1]) * dx;
+      if (Math.abs(turn2) < 1e-9) continue;
+      if (turn2 < 0) [p, q] = [q, p];
+      bands.push({ type: "M", x: p[0], y: p[1] }, { type: "L", x: q[0], y: q[1] }, { type: "L", x: q[0] + dx, y: q[1] + dy }, { type: "L", x: p[0] + dx, y: p[1] + dy }, { type: "Z" });
+    }
+  }
+  const moved = transformBezierPath(path, [1, 0, 0, 1, dx, dy]);
+  return pathBoolean("union", [{ path, fillRule }, { path: moved, fillRule }, ...bands.length ? [{ path: bands, fillRule: "nonzero" }] : []]).path;
+}
+function twistPaths(paths, angle, center) {
+  let rmax = 0;
+  for (const p of paths) for (const c of p) if (c.type !== "Z") rmax = Math.max(rmax, Math.hypot(c.x - center.x, c.y - center.y));
+  const a = angle * Math.PI / 180;
+  if (!a || rmax <= 1e-9 || !Number.isFinite(a)) return paths.slice();
+  const k = a / rmax;
+  const rot = (v2, th) => {
+    const s = Math.sin(th);
+    const co = Math.cos(th);
+    return [v2[0] * co - v2[1] * s, v2[0] * s + v2[1] * co];
+  };
+  const map = (p) => {
+    const v2 = [p[0] - center.x, p[1] - center.y];
+    const r = rot(v2, k * Math.hypot(v2[0], v2[1]));
+    return [center.x + r[0], center.y + r[1]];
+  };
+  const jac = (p, dv) => {
+    const v2 = [p[0] - center.x, p[1] - center.y];
+    const r = Math.hypot(v2[0], v2[1]);
+    let w = dv;
+    if (r > 1e-12) {
+      const f = k * (v2[0] * dv[0] + v2[1] * dv[1]) / r;
+      w = [dv[0] - v2[1] * f, dv[1] + v2[0] * f];
+    }
+    return rot(w, k * r);
+  };
+  return paths.map((p) => {
+    const out = [];
+    for (const sub5 of subsOf(p)) {
+      const segs = [];
+      for (const seg of sub5.segs) {
+        const cubic = seg.length === 2 ? [seg[0], seg[0], seg[1], seg[1]] : seg;
+        const len2 = segmentLength(seg);
+        const m = Math.min(64, Math.max(1, Math.ceil(Math.abs(a) * len2 / rmax / 0.15 + len2 / 50)));
+        for (let i = 0; i < m; i++) {
+          const q = subSegment(cubic, i / m, (i + 1) / m);
+          const p0 = map(q[0]);
+          const p3 = map(q[3]);
+          const h1 = jac(q[0], [q[1][0] - q[0][0], q[1][1] - q[0][1]]);
+          const h2 = jac(q[3], [q[2][0] - q[3][0], q[2][1] - q[3][1]]);
+          segs.push([p0, [p0[0] + h1[0], p0[1] + h1[1]], [p3[0] + h2[0], p3[1] + h2[1]], p3]);
+        }
+      }
+      out.push({ segs, closed: sub5.closed });
+    }
+    return subsToPath(out);
+  });
+}
+function resample(sub5, m) {
+  const segs = sub5.segs;
+  const n = segs.length;
+  const lens = segs.map((s) => segmentLength(s));
+  const out = [];
+  for (let j = 0; j < n; j++) {
+    const piece = lens[j] / m;
+    for (let k = 0; k < m; k++) {
+      if (k === 0) {
+        const tout = startTangent(segs[j]);
+        const prev = sub5.closed || j > 0 ? (j + n - 1) % n : null;
+        let tan = tout;
+        if (prev !== null) {
+          const tin = endTangent(segs[prev]);
+          tan = unit2(tin[0] + tout[0], tin[1] + tout[1]) ?? tout;
+        }
+        out.push({ p: segs[j][0], tan, lenPrev: prev === null ? 0 : lens[prev] / m, lenNext: piece });
+      } else {
+        const t = segmentParamAtLength(segs[j], piece * k, lens[j]);
+        out.push({ p: segmentPoint(segs[j], t), tan: tangentAt(segs[j], t), lenPrev: piece, lenNext: piece });
+      }
+    }
+  }
+  if (!sub5.closed) {
+    const last = segs[n - 1];
+    out.push({ p: last[last.length - 1], tan: endTangent(last), lenPrev: lens[n - 1] / m, lenNext: 0 });
+  }
+  return out;
+}
+function emit(samples, disp, closed, smooth, handle) {
+  const n = samples.length;
+  if (!n) return null;
+  const pt2 = (i) => [samples[i].p[0] + disp[i][0], samples[i].p[1] + disp[i][1]];
+  const segs = [];
+  const count = closed ? n : n - 1;
+  for (let i = 0; i < count; i++) {
+    const j = (i + 1) % n;
+    const a = samples[i];
+    const b = samples[j];
+    const p = pt2(i);
+    const q = pt2(j);
+    if (smooth) segs.push([p, [p[0] + a.tan[0] * a.lenNext * handle, p[1] + a.tan[1] * a.lenNext * handle], [q[0] - b.tan[0] * b.lenPrev * handle, q[1] - b.tan[1] * b.lenPrev * handle], q]);
+    else segs.push([p, q]);
+  }
+  if (!segs.length) return null;
+  return { segs, closed };
+}
+function zigzagPaths(paths, size, ridges, smooth = false) {
+  const m = Math.min(1e3, Math.max(0, Math.round(Number.isFinite(ridges) ? ridges : 0))) + 1;
+  return paths.map((p) => {
+    const out = [];
+    for (const sub5 of subsOf(p)) {
+      const s = resample(sub5, m);
+      const disp = s.map((x, i) => {
+        const n = perp2(x.tan);
+        const d = i % 2 === 0 ? size : -size;
+        return [n[0] * d, n[1] * d];
+      });
+      const e = emit(s, disp, sub5.closed, smooth, 0.36);
+      if (e) out.push(e);
+    }
+    return subsToPath(out);
+  });
+}
+var MASK64 = (1n << 64n) - 1n;
+function splitmix(x) {
+  x = x + 0x9e3779b97f4a7c15n & MASK64;
+  let z = x;
+  z = (z ^ z >> 30n) * 0xbf58476d1ce4e5b9n & MASK64;
+  z = (z ^ z >> 27n) * 0x94d049bb133111ebn & MASK64;
+  return z ^ z >> 31n;
+}
+function hash(seed, idx, t) {
+  const h = splitmix(splitmix(splitmix(seed) ^ idx) ^ BigInt.asUintN(64, BigInt(t)));
+  return Number(h >> 11n) / 2 ** 53 * 2 - 1;
+}
+function noise(seed, idx, t) {
+  const i = Math.floor(t);
+  const f = t - i;
+  const p0 = hash(seed, idx, i - 1);
+  const p1 = hash(seed, idx, i);
+  const p2 = hash(seed, idx, i + 1);
+  const p3 = hash(seed, idx, i + 2);
+  const v2 = 0.5 * (2 * p1 + (-p0 + p2) * f + (2 * p0 - 5 * p1 + 4 * p2 - p3) * f * f + (-p0 + 3 * p1 - 3 * p2 + p3) * f * f * f);
+  return Math.min(1, Math.max(-1, v2));
+}
+function wigglePaths(paths, w) {
+  if (!w.size || !Number.isFinite(w.size)) return paths.slice();
+  const m = Math.min(1e3, Math.max(0, Math.round(Number.isFinite(w.detail) ? w.detail : 0))) + 1;
+  const seed = BigInt.asUintN(64, BigInt(Math.round(Number.isFinite(w.seed) ? w.seed : 0)));
+  const t = (Number.isFinite(w.time) ? w.time : 0) * (Number.isFinite(w.speed) ? w.speed : 0) + (Number.isFinite(w.phase) ? w.phase : 0) / 360;
+  const corr = Math.min(1, Math.max(0, (Number.isFinite(w.correlation) ? w.correlation : 0) / 100));
+  const sx = noise(seed, MASK64, t);
+  const sy = noise(seed, MASK64 - 1n, t);
+  let idx = 0;
+  return paths.map((p) => {
+    const out = [];
+    for (const sub5 of subsOf(p)) {
+      const s = resample(sub5, m);
+      const disp = s.map(() => {
+        const i = BigInt(idx);
+        const ox = noise(seed, i * 2n, t + idx * 0.37);
+        const oy = noise(seed, i * 2n + 1n, t + idx * 0.61);
+        idx++;
+        return [(sx * corr + ox * (1 - corr)) * w.size, (sy * corr + oy * (1 - corr)) * w.size];
+      });
+      const e = emit(s, disp, sub5.closed, w.smooth, 1 / 3);
+      if (e) out.push(e);
+    }
+    return subsToPath(out);
+  });
+}
+var MERGE_OPS = { add: "union", subtract: "difference", intersect: "intersection", exclude: "xor" };
+function mergePaths(paths, mode = "merge") {
+  if (mode === "merge" || !(mode in MERGE_OPS)) return paths.flat();
+  const inputs = paths.filter((p) => p.length > 0).map((path) => ({ path, fillRule: "nonzero" }));
+  if (!inputs.length) return [];
+  return pathBoolean(MERGE_OPS[mode], inputs).path;
+}
+function vectorRepeaterCopies(r, pivot) {
+  const copies = Math.max(0, Number.isFinite(r.copies) ? Math.min(r.copies, 1e3) : 0);
+  const n = Math.ceil(copies);
+  const offset = Number.isFinite(r.offset) ? r.offset : 0;
+  const so = (r.startOpacity ?? 100) / 100;
+  const eo = (r.endOpacity ?? 100) / 100;
+  const fract = copies - Math.floor(copies);
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const k = i + offset;
+    let m = translateMatrix(-pivot.x, -pivot.y);
+    m = multiplyMatrices(m, scaleMatrix(Math.pow((r.scale?.x ?? 100) / 100, k), Math.pow((r.scale?.y ?? 100) / 100, k)));
+    m = multiplyMatrices(m, rotateMatrix((r.rotation ?? 0) * k));
+    m = multiplyMatrices(m, translateMatrix(pivot.x + (r.position?.x ?? 0) * k, pivot.y + (r.position?.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)) });
+  }
+  return out;
+}
+function repeatPaths(paths, r, pivot) {
+  return vectorRepeaterCopies(r, pivot).map((copy) => ({ copy, paths: paths.map((p) => transformBezierPath(p, copy.matrix)) }));
+}
+function pathsCenter(paths) {
+  const b = bezierPathBounds(paths.flat());
+  return b ? { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 } : { x: 0, y: 0 };
+}
+
 // src/vector/pathMap.ts
 var MAX_PIECES = 1 << 20;
 var MAX_DEPTH = 6;
@@ -3025,14 +3418,14 @@ function lineHits(p, q, seg) {
   return out;
 }
 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));
+var degenerate2 = (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() : subSegment(l.segs[k], t0, t1);
-    if (!degenerate(piece, eps)) {
+    if (!degenerate2(piece, eps)) {
       segs.push(piece);
       chord.push(l.chord[k]);
     }
@@ -4109,8 +4502,8 @@ function createOutlineTextShaper(fonts, options = {}) {
   const fallbackKey = (options.fallback ?? entries[0].family).toLowerCase();
   const pick = (font) => {
     if (font.postScriptName) {
-      const exact = entries.find((e) => e.postScript === font.postScriptName);
-      if (exact) return { entry: exact, available: true };
+      const exact2 = entries.find((e) => e.postScript === font.postScriptName);
+      if (exact2) return { entry: exact2, available: true };
     }
     const key = font.family.trim().toLowerCase();
     let pool = entries.filter((e) => e.key === key);
@@ -5872,7 +6265,9 @@ var VECTOR_EFFECT_DEFAULTS = {
     endOpacity: 100,
     composite: "below"
   },
-  envelope: { style: "arc", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", rows: 2, columns: 2, mesh: null }
+  envelope: { style: "arc", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", rows: 2, columns: 2, mesh: null },
+  contour: { direction: "inside", steps: 4, offset: 6, join: "round", miterLimit: 4, fillColor: "#ffffff", strokeColor: null, acceleration: 0 },
+  blockShadow: { angle: 45, distance: 20, color: "#1e293b", opacity: 100, endOpacity: 100 }
 };
 var VECTOR_EFFECT_LABELS = {
   trim: "Trim Paths",
@@ -5884,7 +6279,9 @@ var VECTOR_EFFECT_LABELS = {
   offset: "Offset Paths",
   merge: "Merge Paths",
   repeater: "Repeater",
-  envelope: "Envelope"
+  envelope: "Envelope",
+  contour: "Contour",
+  blockShadow: "Block Shadow"
 };
 var VECTOR_EFFECT_PARAM_SPECS = {
   trim: [
@@ -5940,18 +6337,52 @@ var VECTOR_EFFECT_PARAM_SPECS = {
   ],
   merge: [
     {
-      key: "mode",
-      label: "Mode",
+      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" }
+      ]
+    }
+  ],
+  contour: [
+    {
+      key: "direction",
+      label: "Direction",
+      kind: "select",
+      options: [
+        { value: "inside", label: "Inside" },
+        { value: "outside", label: "Outside" },
+        { value: "center", label: "To centre" }
+      ]
+    },
+    { key: "steps", label: "Steps", kind: "number", min: 1, max: 200, step: 1, slider: true },
+    { key: "offset", label: "Offset", kind: "number", min: 0.1, max: 200, step: 0.5, slider: true },
+    { key: "fillColor", label: "Fill to", kind: "color" },
+    { key: "strokeColor", label: "Stroke to", kind: "color" },
+    { key: "acceleration", label: "Acceleration", kind: "number", min: -100, max: 100, step: 1, slider: true },
+    {
+      key: "join",
+      label: "Join",
       kind: "select",
       options: [
-        { value: "merge", label: "Merge" },
-        { value: "add", label: "Add" },
-        { value: "subtract", label: "Subtract" },
-        { value: "intersect", label: "Intersect" },
-        { value: "exclude", label: "Exclude" }
+        { value: "miter", label: "Miter" },
+        { value: "round", label: "Round" },
+        { value: "bevel", label: "Bevel" }
       ]
     }
   ],
+  blockShadow: [
+    { key: "angle", label: "Angle \xB0", kind: "number", min: -360, max: 360, step: 1, slider: true },
+    { key: "distance", label: "Distance", kind: "number", min: 0, max: 2e3, step: 1, slider: true },
+    { key: "color", label: "Colour", kind: "color" },
+    { key: "opacity", label: "Opacity %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "endOpacity", label: "End opacity %", kind: "number", min: 0, max: 100, step: 1, slider: true }
+  ],
   repeater: [
     { key: "copies", label: "Copies", kind: "number", min: 0, max: 50, step: 0.1, slider: true },
     { key: "offset", label: "Offset", kind: "number", min: -10, max: 10, step: 0.1, slider: true },
@@ -6041,6 +6472,7 @@ function normalizeVectorEffectParams(type, params, base) {
     else if (spec.kind === "boolean" && typeof v2 === "boolean") out[spec.key] = v2;
     else if (spec.kind === "vec2" && isVec2(v2)) out[spec.key] = { x: v2.x, y: v2.y };
     else if (spec.kind === "select" && spec.options.some((o) => o.value === v2)) out[spec.key] = v2;
+    else if (spec.kind === "color" && (v2 === null || typeof v2 === "string" && parseVectorColor(v2))) out[spec.key] = v2;
   }
   if (type === "envelope") {
     const o = out;
@@ -6066,7 +6498,7 @@ function activeVectorEffects(node) {
   return node.effects?.filter(isEnabled) ?? [];
 }
 function hasOwnVectorAppearance(node) {
-  return node.type === "text" || node.type === "instance" || node.type === "group" && !!node.liveBoolean || isVectorFrame(node) || !!node.effects?.some(isEnabled);
+  return node.type === "text" || node.type === "instance" || node.type === "group" && !!node.liveBoolean || isVectorFrame(node) || isVectorSymmetryGroup(node) || !!node.effects?.some(isEnabled);
 }
 var liveCache = /* @__PURE__ */ new WeakMap();
 function hasVectorAppearance(node) {
@@ -6200,6 +6632,73 @@ var mapPaths = (shapes, fn) => {
   const out = fn(shapes.map((s) => s.path));
   return shapes.map((s, i) => ({ ...s, path: out[i] ?? [] }));
 };
+function blendPaint(from, to, t) {
+  if (to === null || typeof from !== "string") return from;
+  const a = parseVectorColor(from);
+  const b = parseVectorColor(to);
+  if (!a || !b) return from;
+  const h = (v2) => Math.round(Math.min(1, Math.max(0, v2)) * 255).toString(16).padStart(2, "0");
+  const m = a.map((v2, k) => v2 + (b[k] - v2) * t);
+  return `#${h(m[0])}${h(m[1])}${h(m[2])}`;
+}
+function contourShapes(shapes, c) {
+  const out = [];
+  const step = Math.max(0.01, c.offset);
+  const outside = c.direction === "outside";
+  for (const s of shapes) {
+    let n = Math.min(200, Math.max(1, Math.round(c.steps)));
+    if (c.direction === "center") {
+      const b = bezierPathBounds(s.path);
+      n = b ? Math.min(200, Math.max(1, Math.ceil(Math.min(b.maxX - b.minX, b.maxY - b.minY) / 2 / step))) : 0;
+    }
+    out.push({ ...s, order: [outside ? n : 0, ...s.order] });
+    const power = 2 ** (Math.min(100, Math.max(-100, c.acceleration)) / 50);
+    for (let k = 1; k <= n; k++) {
+      const [path] = offsetPaths([s.path], (outside ? 1 : -1) * step * k, c.join, c.miterLimit, 1, 0);
+      if (!path?.length) break;
+      const t = (k / n) ** power;
+      const source = { ...s.source, fill: blendPaint(s.source.fill, c.fillColor, t) ?? null, stroke: blendPaint(s.source.stroke, c.strokeColor, t) ?? null, fills: void 0, strokes: void 0 };
+      out.push({ source, path, opacity: s.opacity, order: [outside ? n - k : k, ...s.order] });
+    }
+  }
+  return out;
+}
+function blockShadowShapes(shapes, b) {
+  const rad2 = b.angle * Math.PI / 180;
+  const u = { x: Math.cos(rad2), y: Math.sin(rad2) };
+  const distance = Math.max(0, b.distance);
+  const shadows = [];
+  for (const s of shapes) {
+    const color2 = b.color ?? (typeof s.source.fill === "string" && s.source.fill !== "none" ? s.source.fill : "#000000");
+    const path = sweepPath(s.path, u.x * distance, u.y * distance, s.source.fillRule === "evenodd" ? "evenodd" : "nonzero");
+    const box = bezierPathBounds(s.path);
+    if (!path.length || !box) continue;
+    let fill = color2;
+    const near3 = Math.min(100, Math.max(0, b.opacity));
+    const far = Math.min(100, Math.max(0, b.endOpacity));
+    const top = Math.max(near3, far);
+    if (near3 !== far && distance > 0) {
+      const along2 = [box.minX * u.x + box.minY * u.y, box.maxX * u.x + box.minY * u.y, box.minX * u.x + box.maxY * u.y, box.maxX * u.x + box.maxY * u.y];
+      const t0 = Math.min(...along2);
+      const t1 = Math.max(...along2) + distance;
+      const c = { x: (box.minX + box.maxX) / 2, y: (box.minY + box.maxY) / 2 };
+      const k = c.x * u.x + c.y * u.y;
+      fill = {
+        type: "linear",
+        units: "userSpaceOnUse",
+        start: { x: c.x + u.x * (t0 - k), y: c.y + u.y * (t0 - k) },
+        end: { x: c.x + u.x * (t1 - k), y: c.y + u.y * (t1 - k) },
+        stops: [
+          { offset: 0, color: color2, opacity: near3 / top },
+          { offset: 1, color: color2, opacity: far / top }
+        ]
+      };
+    }
+    const source = { ...s.source, fill, stroke: null, fills: void 0, strokes: void 0, fillRule: "nonzero" };
+    shadows.push({ source, path, opacity: s.opacity * top / 100, order: [0, ...s.order] });
+  }
+  return [...shadows, ...shapes.map((s) => ({ ...s, order: [1, ...s.order] }))];
+}
 function applyVectorEffects(shapes, effects) {
   let list = shapes.slice();
   for (const e of effects ?? []) {
@@ -6240,6 +6739,12 @@ function applyVectorEffects(shapes, effects) {
         list = mapPaths(list, (p) => envelopePaths(p, params));
         break;
       }
+      case "contour":
+        list = contourShapes(list, e.params);
+        break;
+      case "blockShadow":
+        list = blockShadowShapes(list, e.params);
+        break;
       case "repeater": {
         const r = e.params;
         const copies = repeatPaths(
@@ -6333,8 +6838,8 @@ function vectorAppearanceShapes(node) {
     shapeCache.set(node, [vectorTextShaperGeneration(), shapes]);
     return shapes;
   }
-  if (isVectorFrame(node)) {
-    const shapes = vectorAppearanceShapes(vectorFrameDrawn(node));
+  if (isVectorFrame(node) || isVectorSymmetryGroup(node)) {
+    const shapes = vectorAppearanceShapes(isVectorFrame(node) ? vectorFrameDrawn(node) : vectorSymmetryDrawn(node));
     shapeCache.set(node, [vectorTextShaperGeneration(), shapes]);
     return shapes;
   }
@@ -6396,8 +6901,8 @@ function expandVectorAppearance(node) {
     expandCache.set(node, [vectorTextShaperGeneration(), drawn]);
     return drawn;
   }
-  if (isVectorFrame(node)) {
-    const drawn = vectorFrameDrawn(node);
+  if (isVectorFrame(node) || isVectorSymmetryGroup(node)) {
+    const drawn = isVectorFrame(node) ? vectorFrameDrawn(node) : vectorSymmetryDrawn(node);
     const out2 = hasVectorAppearance(drawn) ? expandVectorAppearance(drawn) : drawn;
     expandCache.set(node, [vectorTextShaperGeneration(), out2]);
     return out2;
@@ -6789,7 +7294,7 @@ var add4 = (a, b) => ({ x: a.x + b.x, y: a.y + b.y });
 var sub4 = (a, b) => ({ x: a.x - b.x, y: a.y - b.y });
 var scale2 = (a, k) => ({ x: a.x * k, y: a.y * k });
 var left = (d) => ({ x: d.y, y: -d.x });
-var unit2 = (v2) => {
+var unit3 = (v2) => {
   const l = Math.hypot(v2.x, v2.y);
   return l > 1e-12 ? { x: v2.x / l, y: v2.y / l } : { x: 1, y: 0 };
 };
@@ -6846,7 +7351,7 @@ function vectorStrokeGradientDefs(g, id, node, options = {}) {
     for (let i = 0; i < segCount; i++) {
       const a = pts[i];
       const b = pts[(i + 1) % n];
-      dirs.push(unit2(sub4(b, a)));
+      dirs.push(unit3(sub4(b, a)));
       lengths.push(lengths[i] + Math.hypot(b.x - a.x, b.y - a.y));
     }
     const total = lengths[segCount];
@@ -7344,9 +7849,9 @@ function vectorDocumentToSvg(doc, options = {}) {
   };
   const emitInstance = (node, depth) => {
     const data = { symbolId: node.symbolId, ...node.scaleStrokes === false ? { scaleStrokes: false } : {}, ...node.overrides ? { overrides: node.overrides } : {} };
-    const exact = !node.overrides && node.scaleStrokes !== false && !node.effects?.length && !node.filters?.length;
+    const exact2 = !node.overrides && node.scaleStrokes !== false && !node.effects?.length && !node.filters?.length;
     const ref = symbolRef(node.symbolId);
-    if (exact && ref) {
+    if (exact2 && ref) {
       lines.push(`${indent(depth)}<use${common(node)} href="#${escapeAttr2(ref)}" data-vector-instance="${escapeAttr2(JSON.stringify(data))}"/>`);
       return;
     }
@@ -7397,7 +7902,8 @@ function vectorDocumentToSvg(doc, options = {}) {
       const live2 = {
         kind: node.type,
         ...node.effects?.length ? { effects: node.effects } : {},
-        ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {}
+        ...node.type === "group" && node.liveBoolean ? { liveBoolean: node.liveBoolean } : {},
+        ...node.type === "group" && node.symmetry ? { symmetry: node.symmetry } : {}
       };
       lines.push(`${indent(depth)}<g${common(node)} data-vector-live="${escapeAttr2(JSON.stringify(live2))}">`);
       lines.push(`${indent(depth + 1)}<g data-vector-part="appearance">`);
@@ -7960,6 +8466,8 @@ function parseVectorSvg(svg, options = {}) {
     const group = { id, type: "group", ...meta, children: inner };
     if (effects.length) group.effects = transformVectorEffects(effects, m);
     if (liveBoolean) group.liveBoolean = liveBoolean;
+    const symmetry = sanitizeVectorSymmetry(raw.symmetry);
+    if (symmetry) group.symmetry = transformVectorSymmetry(symmetry, m);
     const blend = blendFromAttribute(g.attrs["data-vector-blend"], m);
     if (blend) group.blend = blend;
     return group;
@@ -8424,7 +8932,7 @@ function vectorNodesNear(nodes, rect, pad = 0) {
 }
 
 // src/vector/geometry.ts
-var EPS2 = 1e-9;
+var EPS3 = 1e-9;
 var cloneAnchor = (a) => ({
   x: a.x,
   y: a.y,
@@ -8450,7 +8958,7 @@ function hasPaint(paint) {
   return true;
 }
 var handleOf = (a, side) => a[side] ?? { x: a.x, y: a.y };
-var isOnAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS2 && Math.abs(h.y - a.y) < EPS2;
+var isOnAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS3 && Math.abs(h.y - a.y) < EPS3;
 function subpathSegmentCount(sp) {
   const n = sp.anchors.length;
   if (n < 2) return 0;
@@ -8732,8 +9240,9 @@ function bakeIntoGeometry(node, m) {
   if (node.type === "group") {
     const group = node;
     const children = group.children.map((c) => transformVectorNode(c, m));
+    const sym2 = group.symmetry ? { symmetry: transformVectorSymmetry(group.symmetry, m) } : {};
     const spine = group.blend?.spine;
-    if (!spine) return { ...group, children };
+    if (!spine) return { ...group, ...sym2, children };
     const moved = { closed: spine.closed, anchors: spine.anchors.map((a) => mapAnchor(a, m)) };
     return { ...group, children, blend: { ...group.blend, spine: moved } };
   }
@@ -8837,7 +9346,7 @@ function moveAnchorHandle(a, side, pos, breakHandles = false) {
   const dy = pos.y - a.y;
   const len2 = Math.hypot(dx, dy);
   if (type === "symmetric") next[other] = { x: a.x - dx, y: a.y - dy };
-  else if (type === "smooth" && len2 > EPS2) {
+  else if (type === "smooth" && len2 > EPS3) {
     const o = a[other];
     const olen = o ? Math.hypot(o.x - a.x, o.y - a.y) : len2;
     next[other] = { x: a.x - dx / len2 * olen, y: a.y - dy / len2 * olen };
@@ -8867,15 +9376,15 @@ function convertAnchor(sp, index, type) {
   else if (prev && next) dir = { x: next.x - prev.x, y: next.y - prev.y };
   else if (next) dir = { x: next.x - a.x, y: next.y - a.y };
   else if (prev) dir = { x: a.x - prev.x, y: a.y - prev.y };
-  if (!dir || Math.hypot(dir.x, dir.y) < EPS2) return { anchors, closed: sp.closed };
+  if (!dir || Math.hypot(dir.x, dir.y) < EPS3) return { anchors, closed: sp.closed };
   const dl = Math.hypot(dir.x, dir.y);
   const ux = dir.x / dl;
   const uy = dir.y / dl;
   lenIn = a.in && !isOnAnchor(a, a.in) ? Math.hypot(a.in.x - a.x, a.in.y - a.y) : prev ? Math.hypot(prev.x - a.x, prev.y - a.y) / 3 : 0;
   lenOut = a.out && !isOnAnchor(a, a.out) ? Math.hypot(a.out.x - a.x, a.out.y - a.y) : next ? Math.hypot(next.x - a.x, next.y - a.y) / 3 : 0;
   if (type === "symmetric") lenIn = lenOut = (lenIn + lenOut) / 2 || Math.max(lenIn, lenOut);
-  if (lenIn > EPS2) a.in = { x: a.x - ux * lenIn, y: a.y - uy * lenIn };
-  if (lenOut > EPS2) a.out = { x: a.x + ux * lenOut, y: a.y + uy * lenOut };
+  if (lenIn > EPS3) a.in = { x: a.x - ux * lenIn, y: a.y - uy * lenIn };
+  if (lenOut > EPS3) a.out = { x: a.x + ux * lenOut, y: a.y + uy * lenOut };
   a.type = type;
   return { anchors, closed: sp.closed };
 }
@@ -8910,444 +9419,167 @@ function reverseSubpath(sp) {
     const next = { x: a.x, y: a.y };
     if (a.out) next.in = { ...a.out };
     if (a.in) next.out = { ...a.in };
-    if (a.type) next.type = a.type;
-    if (a.corner) next.corner = { ...a.corner };
-    if (a.id) next.id = a.id;
-    return next;
-  });
-  return { anchors, closed: sp.closed };
-}
-var KAPPA2 = 0.5522847498307936;
-function rectSubpath(b, radius = 0, kind) {
-  const { x, y, width: w, height: h } = b;
-  const sp = { anchors: [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }], closed: true };
-  return radius > 0 ? setSubpathCorners(sp, radius, kind) : sp;
-}
-function ellipseSubpath(b) {
-  const rx = b.width / 2;
-  const ry = b.height / 2;
-  const cx = b.x + rx;
-  const cy = b.y + ry;
-  const kx = rx * KAPPA2;
-  const ky = ry * KAPPA2;
-  return {
-    closed: true,
-    anchors: [
-      { x: cx, y: cy - ry, in: { x: cx - kx, y: cy - ry }, out: { x: cx + kx, y: cy - ry }, type: "symmetric" },
-      { x: cx + rx, y: cy, in: { x: cx + rx, y: cy - ky }, out: { x: cx + rx, y: cy + ky }, type: "symmetric" },
-      { x: cx, y: cy + ry, in: { x: cx + kx, y: cy + ry }, out: { x: cx - kx, y: cy + ry }, type: "symmetric" },
-      { x: cx - rx, y: cy, in: { x: cx - rx, y: cy + ky }, out: { x: cx - rx, y: cy - ky }, type: "symmetric" }
-    ]
-  };
-}
-function polygonSubpath(b, sides = 6) {
-  const n = Math.max(3, Math.round(sides));
-  const cx = b.x + b.width / 2;
-  const cy = b.y + b.height / 2;
-  const anchors = [];
-  for (let i = 0; i < n; i++) {
-    const t = -Math.PI / 2 + i * 2 * Math.PI / n;
-    anchors.push({ x: cx + Math.cos(t) * b.width / 2, y: cy + Math.sin(t) * b.height / 2 });
-  }
-  return { anchors, closed: true };
-}
-function starSubpath(b, points = 5, innerRatio = 0.5) {
-  const n = Math.max(3, Math.round(points));
-  const cx = b.x + b.width / 2;
-  const cy = b.y + b.height / 2;
-  const anchors = [];
-  for (let i = 0; i < n * 2; i++) {
-    const t = -Math.PI / 2 + i * Math.PI / n;
-    const r = i % 2 === 0 ? 1 : innerRatio;
-    anchors.push({ x: cx + Math.cos(t) * r * b.width / 2, y: cy + Math.sin(t) * r * b.height / 2 });
-  }
-  return { anchors, closed: true };
-}
-function lineSubpath(a, b) {
-  return { anchors: [{ x: a.x, y: a.y }, { x: b.x, y: b.y }], closed: false };
-}
-function roundSubpaths(subpaths, precision = 3) {
-  const f = 10 ** precision;
-  const r = (n) => Math.round(n * f) / f;
-  const rp = (p) => ({ x: r(p.x), y: r(p.y) });
-  return subpaths.map((sp) => ({
-    closed: sp.closed,
-    anchors: sp.anchors.map((a) => ({ ...cloneAnchor(a), x: r(a.x), y: r(a.y), ...a.in ? { in: rp(a.in) } : {}, ...a.out ? { out: rp(a.out) } : {} }))
-  }));
-}
-
-// src/vector/pathEffects.ts
-var EPS3 = 1e-9;
-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 pathToContours(path).map((c) => ({ segs: closeContour(c).filter((s) => !degenerate2(s)).map(raise), closed: c.closed })).filter((s) => s.segs.length > 0);
-}
-var subsToPath = (subs) => contoursToPath(subs.map((s) => ({ segments: s.segs, closed: s.closed })));
-var unit3 = (x, y) => {
-  const l = Math.hypot(x, y);
-  return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
-};
-function startTangent(s) {
-  for (let i = 1; i < s.length; i++) {
-    const u = unit3(s[i][0] - s[0][0], s[i][1] - s[0][1]);
-    if (u) return u;
-  }
-  return [1, 0];
-}
-function endTangent(s) {
-  const end = s[s.length - 1];
-  for (let i = s.length - 2; i >= 0; i--) {
-    const u = unit3(end[0] - s[i][0], end[1] - s[i][1]);
-    if (u) return u;
-  }
-  return [1, 0];
-}
-function tangentAt(s, t) {
-  if (t <= 1e-9) return startTangent(s);
-  if (t >= 1 - 1e-9) return endTangent(s);
-  const d = segmentDerivative(s, t);
-  return unit3(d[0], d[1]) ?? startTangent(s);
-}
-var perp2 = (v2) => [-v2[1], v2[0]];
-function effectPathLength(path) {
-  let total = 0;
-  for (const s of subsOf(path)) for (const seg of s.segs) total += segmentLength(seg);
-  return total;
-}
-function effectPathVertexCount(path) {
-  return subsOf(path).reduce((n, s) => n + s.segs.length + (s.closed ? 0 : 1), 0);
-}
-var Measured = class {
-  segs;
-  lens;
-  total;
-  constructor(path) {
-    this.segs = subsOf(path).flatMap((s) => s.segs);
-    this.lens = this.segs.map((s) => segmentLength(s));
-    this.total = this.lens.reduce((a, b) => a + b, 0);
-  }
-  /**
-   * Appends the part between lengths `sa` and `sb`, continuing the last piece when this one
-   * starts where it ends (across the start of a closed path).
-   */
-  append(sa, sb, out) {
-    for (const piece of trimSegments(this.segs, sa, sb, this.lens)) {
-      if (degenerate2(piece)) continue;
-      const last = out[out.length - 1]?.segs;
-      const end = last?.[last.length - 1]?.at(-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);
-    }
-  }
-};
-function trimIntervals(start, end, offsetDegrees) {
-  let s = start / 100;
-  let e = end / 100;
-  if (!Number.isFinite(s) || !Number.isFinite(e)) return null;
-  if (s > e) [s, e] = [e, s];
-  s = Math.min(1, Math.max(0, s));
-  e = Math.min(1, Math.max(0, e));
-  if (e - s >= 1 - 1e-9) return null;
-  if (e - s <= 1e-9) return [];
-  const off = Number.isFinite(offsetDegrees) ? (offsetDegrees / 360 % 1 + 1) % 1 : 0;
-  s += off;
-  e += off;
-  if (e <= 1) return [[s, e]];
-  if (s >= 1) return [[s - 1, e - 1]];
-  return [
-    [s, 1],
-    [0, e - 1]
-  ];
-}
-function trimPaths(paths, start, end, offsetDegrees = 0) {
-  const iv = trimIntervals(start, end, offsetDegrees);
-  if (!iv) return paths.slice();
-  return paths.map((p) => {
-    const m = new Measured(p);
-    const out = [];
-    if (m.total > 0) for (const [a, b] of iv) m.append(a * m.total, b * m.total, out);
-    return subsToPath(out);
-  });
-}
-function trimPathsIndividually(paths, start, end, offsetDegrees = 0) {
-  const iv = trimIntervals(start, end, offsetDegrees);
-  if (!iv) return paths.slice();
-  const ms = paths.map((p) => new Measured(p));
-  const total = ms.reduce((n, m) => n + m.total, 0);
-  let base = 0;
-  return ms.map((m) => {
-    const out = [];
-    for (const [a, b] of iv) {
-      const la = Math.max(0, a * total - base);
-      const lb = Math.min(m.total, b * total - base);
-      if (lb > la) m.append(la, lb, out);
-    }
-    base += m.total;
-    return subsToPath(out);
-  });
-}
-function puckerBloatPaths(paths, amount) {
-  const a = amount / 100;
-  if (!a || !Number.isFinite(a)) return paths.slice();
-  return paths.map((p) => {
-    const verts = p.filter((c) => c.type !== "Z");
-    if (!verts.length) return p;
-    const cx = verts.reduce((s, c) => s + c.x, 0) / verts.length;
-    const cy = verts.reduce((s, c) => s + c.y, 0) / verts.length;
-    const mv = (x, y) => ({ x: x + (cx - x) * a, y: y + (cy - y) * a });
-    const mvh = (x, y) => ({ x: x + (x - cx) * a, y: y + (y - cy) * a });
-    const out = [];
-    let prev = { x: 0, y: 0 };
-    let start = { x: 0, y: 0 };
-    const curve = (c1, c2, q) => {
-      const h1 = mvh(c1.x, c1.y);
-      const h2 = mvh(c2.x, c2.y);
-      const e = mv(q.x, q.y);
-      out.push({ type: "C", x1: h1.x, y1: h1.y, x2: h2.x, y2: h2.y, x: e.x, y: e.y });
-    };
-    for (const c of p) {
-      switch (c.type) {
-        case "M": {
-          const e = mv(c.x, c.y);
-          out.push({ type: "M", x: e.x, y: e.y });
-          prev = start = { x: c.x, y: c.y };
-          break;
-        }
-        case "L":
-          curve(prev, c, c);
-          prev = { x: c.x, y: c.y };
-          break;
-        case "Q": {
-          const c1 = { x: prev.x + 2 / 3 * (c.x1 - prev.x), y: prev.y + 2 / 3 * (c.y1 - prev.y) };
-          const c2 = { x: c.x + 2 / 3 * (c.x1 - c.x), y: c.y + 2 / 3 * (c.y1 - c.y) };
-          curve(c1, c2, c);
-          prev = { x: c.x, y: c.y };
-          break;
-        }
-        case "C":
-          curve({ x: c.x1, y: c.y1 }, { x: c.x2, y: c.y2 }, c);
-          prev = { x: c.x, y: c.y };
-          break;
-        case "Z":
-          if (Math.hypot(prev.x - start.x, prev.y - start.y) > EPS3) curve(prev, start, start);
-          out.push({ type: "Z" });
-          prev = start;
-          break;
-      }
-    }
-    return out;
+    if (a.type) next.type = a.type;
+    if (a.corner) next.corner = { ...a.corner };
+    if (a.id) next.id = a.id;
+    return next;
   });
+  return { anchors, closed: sp.closed };
 }
-function roundCornerPaths(paths, radius) {
-  if (!(radius > 0) || !Number.isFinite(radius)) return paths.slice();
-  return paths.map((p) => subpathsToBezier(bezierToSubpaths(p).map((sp) => setSubpathCorners(sp, radius))));
-}
-function offsetPaths(paths, amount, join = "miter", miterLimit = 4, copies = 1, copyOffset = 0) {
-  const n = Math.min(1e3, Math.max(1, Math.round(Number.isFinite(copies) ? copies : 1)));
-  return paths.map((p) => {
-    const out = [];
-    for (let i = 0; i < n; i++) out.push(...offsetPath(p, amount * (i + 1 + copyOffset), { join, miterLimit }));
-    return out;
-  });
+var KAPPA2 = 0.5522847498307936;
+function rectSubpath(b, radius = 0, kind) {
+  const { x, y, width: w, height: h } = b;
+  const sp = { anchors: [{ x, y }, { x: x + w, y }, { x: x + w, y: y + h }, { x, y: y + h }], closed: true };
+  return radius > 0 ? setSubpathCorners(sp, radius, kind) : sp;
 }
-function twistPaths(paths, angle, center) {
-  let rmax = 0;
-  for (const p of paths) for (const c of p) if (c.type !== "Z") rmax = Math.max(rmax, Math.hypot(c.x - center.x, c.y - center.y));
-  const a = angle * Math.PI / 180;
-  if (!a || rmax <= 1e-9 || !Number.isFinite(a)) return paths.slice();
-  const k = a / rmax;
-  const rot = (v2, th) => {
-    const s = Math.sin(th);
-    const co = Math.cos(th);
-    return [v2[0] * co - v2[1] * s, v2[0] * s + v2[1] * co];
-  };
-  const map = (p) => {
-    const v2 = [p[0] - center.x, p[1] - center.y];
-    const r = rot(v2, k * Math.hypot(v2[0], v2[1]));
-    return [center.x + r[0], center.y + r[1]];
-  };
-  const jac = (p, dv) => {
-    const v2 = [p[0] - center.x, p[1] - center.y];
-    const r = Math.hypot(v2[0], v2[1]);
-    let w = dv;
-    if (r > 1e-12) {
-      const f = k * (v2[0] * dv[0] + v2[1] * dv[1]) / r;
-      w = [dv[0] - v2[1] * f, dv[1] + v2[0] * f];
-    }
-    return rot(w, k * r);
+function ellipseSubpath(b) {
+  const rx = b.width / 2;
+  const ry = b.height / 2;
+  const cx = b.x + rx;
+  const cy = b.y + ry;
+  const kx = rx * KAPPA2;
+  const ky = ry * KAPPA2;
+  return {
+    closed: true,
+    anchors: [
+      { x: cx, y: cy - ry, in: { x: cx - kx, y: cy - ry }, out: { x: cx + kx, y: cy - ry }, type: "symmetric" },
+      { x: cx + rx, y: cy, in: { x: cx + rx, y: cy - ky }, out: { x: cx + rx, y: cy + ky }, type: "symmetric" },
+      { x: cx, y: cy + ry, in: { x: cx + kx, y: cy + ry }, out: { x: cx - kx, y: cy + ry }, type: "symmetric" },
+      { x: cx - rx, y: cy, in: { x: cx - rx, y: cy + ky }, out: { x: cx - rx, y: cy - ky }, type: "symmetric" }
+    ]
   };
-  return paths.map((p) => {
-    const out = [];
-    for (const sub5 of subsOf(p)) {
-      const segs = [];
-      for (const seg of sub5.segs) {
-        const cubic = seg.length === 2 ? [seg[0], seg[0], seg[1], seg[1]] : seg;
-        const len2 = segmentLength(seg);
-        const m = Math.min(64, Math.max(1, Math.ceil(Math.abs(a) * len2 / rmax / 0.15 + len2 / 50)));
-        for (let i = 0; i < m; i++) {
-          const q = subSegment(cubic, i / m, (i + 1) / m);
-          const p0 = map(q[0]);
-          const p3 = map(q[3]);
-          const h1 = jac(q[0], [q[1][0] - q[0][0], q[1][1] - q[0][1]]);
-          const h2 = jac(q[3], [q[2][0] - q[3][0], q[2][1] - q[3][1]]);
-          segs.push([p0, [p0[0] + h1[0], p0[1] + h1[1]], [p3[0] + h2[0], p3[1] + h2[1]], p3]);
-        }
-      }
-      out.push({ segs, closed: sub5.closed });
-    }
-    return subsToPath(out);
-  });
 }
-function resample(sub5, m) {
-  const segs = sub5.segs;
-  const n = segs.length;
-  const lens = segs.map((s) => segmentLength(s));
-  const out = [];
-  for (let j = 0; j < n; j++) {
-    const piece = lens[j] / m;
-    for (let k = 0; k < m; k++) {
-      if (k === 0) {
-        const tout = startTangent(segs[j]);
-        const prev = sub5.closed || j > 0 ? (j + n - 1) % n : null;
-        let tan = tout;
-        if (prev !== null) {
-          const tin = endTangent(segs[prev]);
-          tan = unit3(tin[0] + tout[0], tin[1] + tout[1]) ?? tout;
-        }
-        out.push({ p: segs[j][0], tan, lenPrev: prev === null ? 0 : lens[prev] / m, lenNext: piece });
-      } else {
-        const t = segmentParamAtLength(segs[j], piece * k, lens[j]);
-        out.push({ p: segmentPoint(segs[j], t), tan: tangentAt(segs[j], t), lenPrev: piece, lenNext: piece });
-      }
-    }
-  }
-  if (!sub5.closed) {
-    const last = segs[n - 1];
-    out.push({ p: last[last.length - 1], tan: endTangent(last), lenPrev: lens[n - 1] / m, lenNext: 0 });
+function polygonSubpath(b, sides = 6) {
+  const n = Math.max(3, Math.round(sides));
+  const cx = b.x + b.width / 2;
+  const cy = b.y + b.height / 2;
+  const anchors = [];
+  for (let i = 0; i < n; i++) {
+    const t = -Math.PI / 2 + i * 2 * Math.PI / n;
+    anchors.push({ x: cx + Math.cos(t) * b.width / 2, y: cy + Math.sin(t) * b.height / 2 });
   }
-  return out;
+  return { anchors, closed: true };
 }
-function emit(samples, disp, closed, smooth, handle) {
-  const n = samples.length;
-  if (!n) return null;
-  const pt2 = (i) => [samples[i].p[0] + disp[i][0], samples[i].p[1] + disp[i][1]];
-  const segs = [];
-  const count = closed ? n : n - 1;
-  for (let i = 0; i < count; i++) {
-    const j = (i + 1) % n;
-    const a = samples[i];
-    const b = samples[j];
-    const p = pt2(i);
-    const q = pt2(j);
-    if (smooth) segs.push([p, [p[0] + a.tan[0] * a.lenNext * handle, p[1] + a.tan[1] * a.lenNext * handle], [q[0] - b.tan[0] * b.lenPrev * handle, q[1] - b.tan[1] * b.lenPrev * handle], q]);
-    else segs.push([p, q]);
+function starSubpath(b, points = 5, innerRatio = 0.5) {
+  const n = Math.max(3, Math.round(points));
+  const cx = b.x + b.width / 2;
+  const cy = b.y + b.height / 2;
+  const anchors = [];
+  for (let i = 0; i < n * 2; i++) {
+    const t = -Math.PI / 2 + i * Math.PI / n;
+    const r = i % 2 === 0 ? 1 : innerRatio;
+    anchors.push({ x: cx + Math.cos(t) * r * b.width / 2, y: cy + Math.sin(t) * r * b.height / 2 });
   }
-  if (!segs.length) return null;
-  return { segs, closed };
-}
-function zigzagPaths(paths, size, ridges, smooth = false) {
-  const m = Math.min(1e3, Math.max(0, Math.round(Number.isFinite(ridges) ? ridges : 0))) + 1;
-  return paths.map((p) => {
-    const out = [];
-    for (const sub5 of subsOf(p)) {
-      const s = resample(sub5, m);
-      const disp = s.map((x, i) => {
-        const n = perp2(x.tan);
-        const d = i % 2 === 0 ? size : -size;
-        return [n[0] * d, n[1] * d];
-      });
-      const e = emit(s, disp, sub5.closed, smooth, 0.36);
-      if (e) out.push(e);
-    }
-    return subsToPath(out);
-  });
-}
-var MASK64 = (1n << 64n) - 1n;
-function splitmix(x) {
-  x = x + 0x9e3779b97f4a7c15n & MASK64;
-  let z = x;
-  z = (z ^ z >> 30n) * 0xbf58476d1ce4e5b9n & MASK64;
-  z = (z ^ z >> 27n) * 0x94d049bb133111ebn & MASK64;
-  return z ^ z >> 31n;
+  return { anchors, closed: true };
 }
-function hash(seed, idx, t) {
-  const h = splitmix(splitmix(splitmix(seed) ^ idx) ^ BigInt.asUintN(64, BigInt(t)));
-  return Number(h >> 11n) / 2 ** 53 * 2 - 1;
+function lineSubpath(a, b) {
+  return { anchors: [{ x: a.x, y: a.y }, { x: b.x, y: b.y }], closed: false };
 }
-function noise(seed, idx, t) {
-  const i = Math.floor(t);
-  const f = t - i;
-  const p0 = hash(seed, idx, i - 1);
-  const p1 = hash(seed, idx, i);
-  const p2 = hash(seed, idx, i + 1);
-  const p3 = hash(seed, idx, i + 2);
-  const v2 = 0.5 * (2 * p1 + (-p0 + p2) * f + (2 * p0 - 5 * p1 + 4 * p2 - p3) * f * f + (-p0 + 3 * p1 - 3 * p2 + p3) * f * f * f);
-  return Math.min(1, Math.max(-1, v2));
+function roundSubpaths(subpaths, precision = 3) {
+  const f = 10 ** precision;
+  const r = (n) => Math.round(n * f) / f;
+  const rp = (p) => ({ x: r(p.x), y: r(p.y) });
+  return subpaths.map((sp) => ({
+    closed: sp.closed,
+    anchors: sp.anchors.map((a) => ({ ...cloneAnchor(a), x: r(a.x), y: r(a.y), ...a.in ? { in: rp(a.in) } : {}, ...a.out ? { out: rp(a.out) } : {} }))
+  }));
 }
-function wigglePaths(paths, w) {
-  if (!w.size || !Number.isFinite(w.size)) return paths.slice();
-  const m = Math.min(1e3, Math.max(0, Math.round(Number.isFinite(w.detail) ? w.detail : 0))) + 1;
-  const seed = BigInt.asUintN(64, BigInt(Math.round(Number.isFinite(w.seed) ? w.seed : 0)));
-  const t = (Number.isFinite(w.time) ? w.time : 0) * (Number.isFinite(w.speed) ? w.speed : 0) + (Number.isFinite(w.phase) ? w.phase : 0) / 360;
-  const corr = Math.min(1, Math.max(0, (Number.isFinite(w.correlation) ? w.correlation : 0) / 100));
-  const sx = noise(seed, MASK64, t);
-  const sy = noise(seed, MASK64 - 1n, t);
-  let idx = 0;
-  return paths.map((p) => {
+
+// src/vector/symmetry.ts
+function isVectorSymmetryGroup(node) {
+  return node?.type === "group" && !!node.symmetry && !node.blend && !node.liveBoolean && !node.mask && !node.frame;
+}
+var rad = (deg) => deg * Math.PI / 180;
+var exact = (v2) => Math.abs(v2) < 1e-12 ? 0 : v2;
+var around = (c, m) => multiplyMatrices(multiplyMatrices([1, 0, 0, 1, -c.x, -c.y], m), [1, 0, 0, 1, c.x, c.y]);
+var reflect = (c, deg) => {
+  const a = 2 * rad(deg);
+  return around(c, [exact(Math.cos(a)), exact(Math.sin(a)), exact(Math.sin(a)), exact(-Math.cos(a)), 0, 0]);
+};
+var turn = (c, deg) => around(c, [exact(Math.cos(rad(deg))), exact(Math.sin(rad(deg))), exact(-Math.sin(rad(deg))), exact(Math.cos(rad(deg))), 0, 0]);
+var AXIS = { horizontal: [0], vertical: [90], diagonal: [45], dual: [90, 0] };
+function vectorSymmetryMatrices(s) {
+  const c = s.center;
+  const r = s.rotation ?? 0;
+  if (s.mode === "radial") {
+    const n = Math.min(64, Math.max(2, Math.round(s.copies ?? 6)));
     const out = [];
-    for (const sub5 of subsOf(p)) {
-      const s = resample(sub5, m);
-      const disp = s.map(() => {
-        const i = BigInt(idx);
-        const ox = noise(seed, i * 2n, t + idx * 0.37);
-        const oy = noise(seed, i * 2n + 1n, t + idx * 0.61);
-        idx++;
-        return [(sx * corr + ox * (1 - corr)) * w.size, (sy * corr + oy * (1 - corr)) * w.size];
-      });
-      const e = emit(s, disp, sub5.closed, w.smooth, 1 / 3);
-      if (e) out.push(e);
-    }
-    return subsToPath(out);
-  });
+    for (let k = 1; k < n; k++) out.push(turn(c, 360 * k / n));
+    if (s.mirror) for (let k = 0; k < n; k++) out.push(reflect(c, r + 180 * k / n));
+    return out;
+  }
+  const axes = AXIS[s.mode].map((a) => reflect(c, a + r));
+  return s.mode === "dual" ? [...axes, turn(c, 180)] : axes;
 }
-var MERGE_OPS = { add: "union", subtract: "difference", intersect: "intersection", exclude: "xor" };
-function mergePaths(paths, mode = "merge") {
-  if (mode === "merge" || !(mode in MERGE_OPS)) return paths.flat();
-  const inputs = paths.filter((p) => p.length > 0).map((path) => ({ path, fillRule: "nonzero" }));
-  if (!inputs.length) return [];
-  return pathBoolean(MERGE_OPS[mode], inputs).path;
+function renamed(node, k) {
+  const id = `${node.id}~sym${k}`;
+  if (node.type === "group") return { ...node, id, children: node.children.map((c) => renamed(c, k)) };
+  return { ...node, id };
 }
-function vectorRepeaterCopies(r, pivot) {
-  const copies = Math.max(0, Number.isFinite(r.copies) ? Math.min(r.copies, 1e3) : 0);
-  const n = Math.ceil(copies);
-  const offset = Number.isFinite(r.offset) ? r.offset : 0;
-  const so = (r.startOpacity ?? 100) / 100;
-  const eo = (r.endOpacity ?? 100) / 100;
-  const fract = copies - Math.floor(copies);
+var drawnCache2 = /* @__PURE__ */ new WeakMap();
+function vectorSymmetryDrawn(node) {
+  let hit = drawnCache2.get(node);
+  if (hit) return hit;
+  const { symmetry, ...group } = node;
+  const copies = vectorSymmetryMatrices(symmetry).flatMap((m, k) => node.children.map((c) => ({ ...renamed(transformVectorNode(c, m), k + 1), locked: true })));
+  hit = { ...group, children: [...node.children, ...copies] };
+  drawnCache2.set(node, hit);
+  return hit;
+}
+function vectorSymmetryAxes(s, box) {
+  const r = s.rotation ?? 0;
+  const dirs = s.mode === "radial" ? Array.from({ length: Math.min(64, Math.max(2, Math.round(s.copies ?? 6))) }, (_, k) => r - 90 + 360 * k / Math.min(64, Math.max(2, Math.round(s.copies ?? 6)))) : AXIS[s.mode].map((a) => a + r);
   const out = [];
-  for (let i = 0; i < n; i++) {
-    const k = i + offset;
-    let m = translateMatrix(-pivot.x, -pivot.y);
-    m = multiplyMatrices(m, scaleMatrix(Math.pow((r.scale?.x ?? 100) / 100, k), Math.pow((r.scale?.y ?? 100) / 100, k)));
-    m = multiplyMatrices(m, rotateMatrix((r.rotation ?? 0) * k));
-    m = multiplyMatrices(m, translateMatrix(pivot.x + (r.position?.x ?? 0) * k, pivot.y + (r.position?.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)) });
+  for (const deg of dirs) {
+    const d = { x: Math.cos(rad(deg)), y: Math.sin(rad(deg)) };
+    let lo = s.mode === "radial" ? 0 : -Infinity;
+    let hi = Infinity;
+    let inside = true;
+    for (const [o, dv, min, max] of [
+      [s.center.x, d.x, box.x, box.x + box.width],
+      [s.center.y, d.y, box.y, box.y + box.height]
+    ]) {
+      if (Math.abs(dv) < 1e-12) {
+        if (o < min || o > max) inside = false;
+      } else {
+        const a = (min - o) / dv;
+        const b = (max - o) / dv;
+        lo = Math.max(lo, Math.min(a, b));
+        hi = Math.min(hi, Math.max(a, b));
+      }
+    }
+    if (inside && Number.isFinite(lo) && Number.isFinite(hi) && hi > lo) out.push([{ x: s.center.x + lo * d.x, y: s.center.y + lo * d.y }, { x: s.center.x + hi * d.x, y: s.center.y + hi * d.y }]);
   }
   return out;
 }
-function repeatPaths(paths, r, pivot) {
-  return vectorRepeaterCopies(r, pivot).map((copy) => ({ copy, paths: paths.map((p) => transformBezierPath(p, copy.matrix)) }));
+function sanitizeVectorSymmetry(value) {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (!VECTOR_SYMMETRY_MODES.includes(r.mode)) return null;
+  const c = r.center;
+  if (!c || !Number.isFinite(c.x) || !Number.isFinite(c.y)) return null;
+  const out = { mode: r.mode, center: { x: c.x, y: c.y } };
+  if (typeof r.rotation === "number" && Number.isFinite(r.rotation) && r.rotation % 360 !== 0) out.rotation = (r.rotation % 360 + 360) % 360;
+  if (out.mode === "radial") {
+    if (typeof r.copies === "number" && Number.isFinite(r.copies)) out.copies = Math.min(64, Math.max(2, Math.round(r.copies)));
+    if (r.mirror === true) out.mirror = true;
+  }
+  return out;
 }
-function pathsCenter(paths) {
-  const b = bezierPathBounds(paths.flat());
-  return b ? { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 } : { x: 0, y: 0 };
+var VECTOR_SYMMETRY_MODE_LABELS = {
+  vertical: "Mirror left / right",
+  horizontal: "Mirror top / bottom",
+  dual: "Four quarters",
+  diagonal: "Mirror diagonally",
+  radial: "Radial"
+};
+function transformVectorSymmetry(s, m) {
+  const center = { x: m[0] * s.center.x + m[2] * s.center.y + m[4], y: m[1] * s.center.x + m[3] * s.center.y + m[5] };
+  const det = m[0] * m[3] - m[1] * m[2];
+  const angle = Math.atan2(m[1], m[0]) * 180 / Math.PI;
+  const rotation = det < 0 ? -(s.rotation ?? 0) + 2 * angle : (s.rotation ?? 0) + angle;
+  const norm = (rotation % 360 + 360) % 360;
+  return { ...s, center, ...Math.abs(norm) > 1e-9 && Math.abs(norm - 360) > 1e-9 ? { rotation: norm } : { rotation: void 0 } };
 }
 
 export {
@@ -9384,6 +9616,7 @@ export {
   VECTOR_CONNECTOR_ROUTES,
   VECTOR_BLEND_SPACINGS,
   VECTOR_MASK_TYPES,
+  VECTOR_SYMMETRY_MODES,
   VECTOR_TEXT_ALIGNS,
   VECTOR_PATH_TEXT_BASELINES,
   VECTOR_CONSTRAINT_KINDS,
@@ -9455,6 +9688,13 @@ export {
   applyMatrixLinear,
   matrixRotation,
   decomposeRigid,
+  isVectorSymmetryGroup,
+  vectorSymmetryMatrices,
+  vectorSymmetryDrawn,
+  vectorSymmetryAxes,
+  sanitizeVectorSymmetry,
+  VECTOR_SYMMETRY_MODE_LABELS,
+  transformVectorSymmetry,
   vectorCornerAt,
   vectorCorners,
   cornerSetback,
@@ -9538,6 +9778,7 @@ export {
   puckerBloatPaths,
   roundCornerPaths,
   offsetPaths,
+  sweepPath,
   twistPaths,
   zigzagPaths,
   wigglePaths,
@@ -9794,4 +10035,4 @@ export {
   lineSubpath,
   roundSubpaths
 };
-//# sourceMappingURL=chunk-7LNZAWSJ.js.map
+//# sourceMappingURL=chunk-WORWH5K5.js.map