@pixerate/editor 0.113.0 → 0.114.0

package/dist/chunk-MMVHBKMM.js

@@ -0,0 +1,753 @@
+import {
+  IDENTITY_MATRIX,
+  expandVectorAppearance,
+  expandVectorCorners,
+  expandVectorGradientStops,
+  explicitVectorGradient,
+  hasExplicitGradientGeometry,
+  hasPaint,
+  inferAnchorType,
+  invertMatrix,
+  isIdentityMatrix,
+  isVectorGradient,
+  multiplyMatrices,
+  nodeMatrix,
+  reverseWidthProfile,
+  sampleVectorGradient,
+  sortedVectorGradientStops,
+  unionBounds,
+  vectorGradientPoints,
+  widthProfileAt
+} from "./chunk-VXR7XWMF.js";
+import {
+  segmentLength,
+  segmentParamAtLength,
+  splitSegment
+} from "./chunk-YCSFS3GK.js";
+import {
+  evaluateEasing
+} from "./chunk-AGR4P4UZ.js";
+import {
+  mixColorsOklab
+} from "./chunk-ZRJMJIQU.js";
+
+// src/vector/blend.ts
+var lerpN = (a, b, t) => a + (b - a) * t;
+var lerpP = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+var toP = (v) => [v.x, v.y];
+var mapP = (m, p) => [m[0] * p[0] + m[2] * p[1] + m[4], m[1] * p[0] + m[3] * p[1] + m[5]];
+var curvesOf = (c) => Math.max(0, (c.pts.length - 1) / 3) | 0;
+function subpathToMorphContour(sp, m = IDENTITY_MATRIX) {
+  const n = sp.anchors.length;
+  if (!n) return null;
+  const first = mapP(m, toP(sp.anchors[0]));
+  const pts = [first];
+  const count = n < 2 ? 0 : sp.closed ? n : n - 1;
+  for (let i = 0; i < count; i++) {
+    const a = sp.anchors[i];
+    const b = sp.anchors[(i + 1) % n];
+    const pa = toP(a);
+    const pb = toP(b);
+    const straight = (!a.out || a.out.x === a.x && a.out.y === a.y) && (!b.in || b.in.x === b.x && b.in.y === b.y);
+    const c1 = straight ? lerpP(pa, pb, 1 / 3) : toP(a.out ?? a);
+    const c2 = straight ? lerpP(pa, pb, 2 / 3) : toP(b.in ?? b);
+    pts.push(mapP(m, c1), mapP(m, c2), i === count - 1 && sp.closed ? first : mapP(m, pb));
+  }
+  return { closed: sp.closed && count > 0, pts };
+}
+function isStraight(p0, p1, p2, p3) {
+  const dx = p3[0] - p0[0];
+  const dy = p3[1] - p0[1];
+  const len = Math.hypot(dx, dy);
+  const tol = Math.max(1e-7, len * 1e-7);
+  if (len < 1e-12) return Math.hypot(p1[0] - p0[0], p1[1] - p0[1]) < tol && Math.hypot(p2[0] - p0[0], p2[1] - p0[1]) < tol;
+  const off = (p) => Math.abs((p[0] - p0[0]) * dy - (p[1] - p0[1]) * dx) / len;
+  const along = (p) => ((p[0] - p0[0]) * dx + (p[1] - p0[1]) * dy) / (len * len);
+  const u1 = along(p1);
+  const u2 = along(p2);
+  return off(p1) < tol && off(p2) < tol && u1 >= -1e-9 && u1 <= 1 + 1e-9 && u2 >= -1e-9 && u2 <= 1 + 1e-9;
+}
+function morphContourToSubpath(c, m = IDENTITY_MATRIX, closed = c.closed) {
+  const pts = isIdentityMatrix(m) ? c.pts : c.pts.map((p) => mapP(m, p));
+  const curves = curvesOf(c);
+  const dropLast = closed && c.closed && curves > 0;
+  const count = dropLast ? curves : curves + 1;
+  const anchors = [];
+  for (let k = 0; k < count; k++) anchors.push({ x: pts[3 * k][0], y: pts[3 * k][1] });
+  for (let k = 0; k < curves; k++) {
+    const p0 = pts[3 * k];
+    const p1 = pts[3 * k + 1];
+    const p2 = pts[3 * k + 2];
+    const p3 = pts[3 * k + 3];
+    if (isStraight(p0, p1, p2, p3)) continue;
+    anchors[k].out = { x: p1[0], y: p1[1] };
+    anchors[(k + 1) % count].in = { x: p2[0], y: p2[1] };
+  }
+  for (const a of anchors) {
+    const type = inferAnchorType(a);
+    if (type !== "corner") a.type = type;
+  }
+  const isClosed = closed && curves > 0;
+  return { anchors: dropCollinear(anchors, isClosed), closed: isClosed };
+}
+function dropCollinear(anchors, closed) {
+  const out = anchors.slice();
+  const min = closed ? 3 : 2;
+  let i = closed ? 0 : 1;
+  while (out.length > min && i < out.length - (closed ? 0 : 1)) {
+    const n = out.length;
+    const a = out[(i - 1 + n) % n];
+    const b = out[i];
+    const c = out[(i + 1) % n];
+    const plain = !b.in && !b.out && !a.out && !c.in;
+    const ux = b.x - a.x;
+    const uy = b.y - a.y;
+    const vx = c.x - b.x;
+    const vy = c.y - b.y;
+    const len = Math.hypot(ux, uy) + Math.hypot(vx, vy);
+    if (plain && Math.abs(ux * vy - uy * vx) <= 1e-9 * Math.max(1, len * len) && ux * vx + uy * vy >= 0) out.splice(i, 1);
+    else i++;
+  }
+  return out;
+}
+var segOf = (c, k) => c.pts.slice(3 * k, 3 * k + 4);
+function refineMorphContour(c, segments) {
+  const have = curvesOf(c);
+  if (have === 0) return { contour: { closed: c.closed, pts: Array.from({ length: 1 + 3 * segments }, () => [c.pts[0][0], c.pts[0][1]]) }, anchors: [0] };
+  const identity = Array.from({ length: c.closed ? have : have + 1 }, (_, i) => i);
+  if (have >= segments) return { contour: c, anchors: identity };
+  const segs = Array.from({ length: have }, (_, k) => segOf(c, k));
+  const lens = segs.map((s) => segmentLength(s));
+  const sum = lens.reduce((a, b) => a + b, 0);
+  const extra = segments - have;
+  const want = lens.map((l) => sum > 1e-12 ? l / sum * extra : extra / have);
+  const parts = want.map((w) => 1 + Math.floor(w));
+  let left = segments - parts.reduce((a, b) => a + b, 0);
+  const frac = want.map((w) => w - Math.floor(w));
+  const order = parts.map((_, i) => i).sort((a, b) => Math.abs(frac[b] - frac[a]) > 1e-9 ? frac[b] - frac[a] : a - b);
+  for (let i = 0; left > 0; i = (i + 1) % order.length, left--) parts[order[i]]++;
+  const pts = [c.pts[0]];
+  const anchors = [0];
+  let at = 0;
+  segs.forEach((seg, k) => {
+    const pieces = parts[k];
+    let rest = seg.slice();
+    let t0 = 0;
+    for (let j = 1; j < pieces; j++) {
+      const t = segmentParamAtLength(seg, lens[k] * j / pieces, lens[k]);
+      const u = Math.min(1, Math.max(0, (t - t0) / (1 - t0 || 1)));
+      const [l, r] = splitSegment(rest, u);
+      pts.push(l[1], l[2], l[3]);
+      rest = r;
+      t0 = t;
+    }
+    pts.push(rest[1], rest[2], k === have - 1 && c.closed ? c.pts[0] : rest[3]);
+    at += pieces;
+    if (k < have - 1 || !c.closed) anchors.push(at);
+  });
+  return { contour: { closed: c.closed, pts }, anchors };
+}
+function reverseMorphContour(c) {
+  return { closed: c.closed, pts: c.pts.slice().reverse() };
+}
+function turnMorphContour(c, s) {
+  const n = curvesOf(c);
+  if (!c.closed || n === 0) return c;
+  const k = (s % n + n) % n;
+  if (k === 0) return c;
+  const body = c.pts.slice(1);
+  return { closed: true, pts: [c.pts[3 * k], ...body.slice(3 * k), ...body.slice(0, 3 * k)] };
+}
+function anchorPoints(c) {
+  const n = curvesOf(c);
+  const count = c.closed ? n : n + 1;
+  return Array.from({ length: Math.max(1, count) }, (_, k) => c.pts[3 * k]);
+}
+function polygonArea(pts) {
+  let s = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const a = pts[i];
+    const b = pts[(i + 1) % pts.length];
+    s += a[0] * b[1] - b[0] * a[1];
+  }
+  return s / 2;
+}
+function frame(v) {
+  const n = Math.max(1, v.length);
+  let cx = 0;
+  let cy = 0;
+  for (const p of v) {
+    cx += p[0];
+    cy += p[1];
+  }
+  cx /= n;
+  cy /= n;
+  let s = 0;
+  for (const p of v) s += (p[0] - cx) ** 2 + (p[1] - cy) ** 2;
+  return { c: [cx, cy], r: Math.max(1e-9, Math.sqrt(s / n)) };
+}
+var RBINS = 5;
+var ABINS = 12;
+var TURN_WEIGHT = 0.1;
+function shapeContexts(v, closed) {
+  const { r } = frame(v);
+  const n = v.length;
+  return v.map((p, i) => {
+    const prev = v[closed ? (i - 1 + n) % n : Math.max(0, i - 1)];
+    const next = v[closed ? (i + 1) % n : Math.min(n - 1, i + 1)];
+    const dir = Math.atan2(next[1] - prev[1], next[0] - prev[0]);
+    const h = new Float64Array(RBINS * ABINS);
+    let total = 0;
+    for (let j = 0; j < n; j++) {
+      if (i === j) continue;
+      const dx = v[j][0] - p[0];
+      const dy = v[j][1] - p[1];
+      const d = Math.hypot(dx, dy) / r;
+      const lr = (Math.log2(Math.max(d, 1e-6)) + 3) / 4 * RBINS;
+      if (!(lr >= 0 && lr < RBINS)) continue;
+      let ang = Math.atan2(dy, dx) - dir;
+      ang = (ang % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI);
+      h[Math.floor(lr) * ABINS + Math.min(ABINS - 1, Math.floor(ang / (2 * Math.PI) * ABINS))] += 1;
+      total++;
+    }
+    if (total > 0) for (let k = 0; k < h.length; k++) h[k] /= total;
+    return h;
+  });
+}
+function chi2(a, b) {
+  let s = 0;
+  for (let k = 0; k < a.length; k++) {
+    const t = a[k] + b[k];
+    if (t > 1e-12) s += (a[k] - b[k]) * (a[k] - b[k]) / t;
+  }
+  return s / 2;
+}
+function bestStart(fixed, free, useShapeContext) {
+  const fa = anchorPoints(fixed);
+  const ga = anchorPoints(free);
+  const n = ga.length;
+  const ff = frame(fa);
+  const gf = frame(ga);
+  const fn = fa.map((p) => [(p[0] - ff.c[0]) / ff.r, (p[1] - ff.c[1]) / ff.r]);
+  const gn = ga.map((p) => [(p[0] - gf.c[0]) / gf.r, (p[1] - gf.c[1]) / gf.r]);
+  const fsc = useShapeContext ? shapeContexts(fa, fixed.closed) : null;
+  const gsc = useShapeContext ? shapeContexts(ga, free.closed) : null;
+  const m = Math.max(1, fn.length);
+  const cost = (s) => {
+    let dot = 0;
+    let cross = 0;
+    let sc = 0;
+    for (let i = 0; i < fn.length; i++) {
+      const j = free.closed ? (i + s) % n : i;
+      const p = fn[i];
+      const q = gn[j];
+      dot += p[0] * q[0] + p[1] * q[1];
+      cross += p[0] * q[1] - p[1] * q[0];
+      if (fsc && gsc) sc += chi2(fsc[i], gsc[j]);
+    }
+    const residual = Math.max(0, 1 - (dot * dot + cross * cross) / (m * m));
+    const turn = 1 - Math.cos(Math.atan2(cross, dot));
+    return residual + TURN_WEIGHT * turn + sc / m;
+  };
+  if (!free.closed) return { start: 0, cost: cost(0) };
+  const stride = n > 96 ? Math.ceil(n / 48) : 1;
+  let best = { start: 0, cost: Infinity };
+  for (let s = 0; s < n; s += stride) {
+    const c = cost(s);
+    if (c < best.cost - 1e-12) best = { start: s, cost: c };
+  }
+  if (stride > 1) {
+    const s0 = best.start;
+    for (let d = 1; d < stride; d++)
+      for (const s of [(s0 + d) % n, (s0 - d + n) % n]) {
+        const c = cost(s);
+        if (c < best.cost - 1e-12) best = { start: s, cost: c };
+      }
+  }
+  return best;
+}
+function placeIn(c, from, to) {
+  const b = unionBounds([boundsOfPoints(c.pts)]);
+  const p = b ? [b.x + b.width / 2, b.y + b.height / 2] : c.pts[0];
+  if (!from || !to) return p;
+  const fx = from.width > 0 ? (p[0] - from.x) / from.width : 0.5;
+  const fy = from.height > 0 ? (p[1] - from.y) / from.height : 0.5;
+  return [to.x + to.width * fx, to.y + to.height * fy];
+}
+function boundsOfPoints(pts) {
+  if (!pts.length) return null;
+  let x0 = Infinity;
+  let y0 = Infinity;
+  let x1 = -Infinity;
+  let y1 = -Infinity;
+  for (const p of pts) {
+    x0 = Math.min(x0, p[0]);
+    y0 = Math.min(y0, p[1]);
+    x1 = Math.max(x1, p[0]);
+    y1 = Math.max(y1, p[1]);
+  }
+  return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}
+function correspondMorphContours(a, b, options = {}) {
+  const minSeg = Math.max(1, Math.round(options.minSegments ?? 16));
+  const maxSeg = Math.max(minSeg, Math.round(options.maxSegments ?? 400));
+  const spacing = options.spacing && options.spacing > 0 ? options.spacing : null;
+  const useSC = options.shapeContext !== false;
+  const match = options.matchStart !== false;
+  const ba = boundsOfPoints(a.flatMap((c) => c.pts));
+  const bb = boundsOfPoints(b.flatMap((c) => c.pts));
+  const contourLength = (c) => {
+    let l = 0;
+    for (let k = 0; k < curvesOf(c); k++) l += segmentLength(segOf(c, k));
+    return l;
+  };
+  const pairs = [];
+  const [sa, sb] = options.starts ?? [];
+  for (let k = 0; k < Math.max(a.length, b.length); k++) {
+    const ca = a[k];
+    const cb = b[k];
+    const explicitA = k === 0 && sa !== null && sa !== void 0 ? sa : null;
+    const explicitB = k === 0 && sb !== null && sb !== void 0 ? sb : null;
+    const counts = [ca ? curvesOf(ca) : 0, cb ? curvesOf(cb) : 0];
+    const longest = Math.max(ca ? contourLength(ca) : 0, cb ? contourLength(cb) : 0);
+    let n = Math.max(counts[0], counts[1], minSeg, spacing ? Math.ceil(longest / spacing) : 0);
+    n = Math.max(counts[0], counts[1], Math.min(n, maxSeg));
+    const point = (c, from, to) => {
+      const p = placeIn(c, from, to);
+      return { closed: c.closed, pts: Array.from({ length: 1 + 3 * n }, () => [p[0], p[1]]) };
+    };
+    if (ca && cb) {
+      const ra = refineMorphContour(ca, n);
+      const rb = refineMorphContour(cb, n);
+      pairs.push({
+        x: ra.contour,
+        y: rb.contour,
+        point: false,
+        startX: explicitA === null ? null : ra.anchors[explicitA] ?? null,
+        startY: explicitB === null ? null : explicitB === rb.anchors.length - 1 && !cb.closed ? -1 : rb.anchors[explicitB] ?? null
+      });
+      if (explicitA !== null && !ca.closed && explicitA === ra.anchors.length - 1 && explicitA > 0) pairs[pairs.length - 1].startX = -1;
+    } else if (ca) pairs.push({ x: refineMorphContour(ca, n).contour, y: point(ca, ba, bb), point: true, startX: null, startY: null });
+    else if (cb) pairs.push({ x: point(cb, bb, ba), y: refineMorphContour(cb, n).contour, point: true, startX: null, startY: null });
+  }
+  const startAt = (c, s) => {
+    if (s === null) return c;
+    if (s === -1) return reverseMorphContour(c);
+    return c.closed ? turnMorphContour(c, s) : c;
+  };
+  const explicit = pairs.length > 0 && (pairs[0].startX !== null || pairs[0].startY !== null);
+  const ref = pairs.find((p) => !p.point && p.x.closed && p.y.closed);
+  const fixedBack = ref ? Math.sign(polygonArea(anchorPoints(ref.x))) !== Math.sign(polygonArea(anchorPoints(ref.y))) && Math.abs(polygonArea(anchorPoints(ref.y))) > 1e-12 : explicit ? false : null;
+  let best = null;
+  for (const back of fixedBack === null ? [false, true] : [fixedBack]) {
+    const xs = [];
+    const ys = [];
+    let cost = 0;
+    pairs.forEach((p, k) => {
+      let x = k === 0 ? startAt(p.x, p.startX) : p.x;
+      let y = k === 0 ? startAt(p.y, p.startY) : p.y;
+      if (back) y = reverseMorphContour(y);
+      if (p.point) {
+        xs.push(x);
+        ys.push(y);
+        return;
+      }
+      const pinned = k === 0 && explicit;
+      const turnX = !y.closed && x.closed;
+      if (match && !pinned && (y.closed || turnX)) {
+        const r = turnX ? bestStart(y, x, useSC) : bestStart(x, y, useSC);
+        if (turnX) x = turnMorphContour(x, r.start);
+        else y = turnMorphContour(y, r.start);
+        cost += r.cost;
+      } else cost += bestStart(x, { ...y, closed: false }, useSC).cost;
+      xs.push(x);
+      ys.push(y);
+    });
+    if (!best || cost < best.cost - 1e-9) best = { xs, ys, cost, back };
+  }
+  return best ? { a: best.xs, b: best.ys, reversed: best.back } : { a: [], b: [], reversed: false };
+}
+function morphPathsCross(a, b) {
+  let count = 0;
+  const d = (p, q, r) => (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
+  for (let k = 0; k < Math.min(a.length, b.length); k++) {
+    const pa = anchorPoints(a[k]);
+    const pb = anchorPoints(b[k]);
+    const n = Math.min(pa.length, pb.length);
+    for (let i = 0; i < n; i++)
+      for (let j = i + 1; j < n; j++) {
+        const d1 = d(pa[j], pb[j], pa[i]);
+        const d2 = d(pa[j], pb[j], pb[i]);
+        const d3 = d(pa[i], pb[i], pa[j]);
+        const d4 = d(pa[i], pb[i], pb[j]);
+        if (d1 * d2 < 0 && d3 * d4 < 0) count++;
+      }
+  }
+  return count;
+}
+function procrustes(a, b) {
+  const pa = a.flatMap(anchorPoints);
+  const pb = b.flatMap(anchorPoints);
+  const ca = frame(pa).c;
+  const cb = frame(pb).c;
+  let ss = 0;
+  let dot = 0;
+  let cross = 0;
+  for (let i = 0; i < Math.min(pa.length, pb.length); i++) {
+    const p = [pa[i][0] - ca[0], pa[i][1] - ca[1]];
+    const q = [pb[i][0] - cb[0], pb[i][1] - cb[1]];
+    ss += p[0] * p[0] + p[1] * p[1];
+    dot += p[0] * q[0] + p[1] * q[1];
+    cross += p[0] * q[1] - p[1] * q[0];
+  }
+  return { ca, cb, theta: Math.atan2(cross, dot), s: ss > 1e-12 ? Math.hypot(dot, cross) / ss : 1 };
+}
+function interpolateMorphContours(a, b, u, options = {}) {
+  const w = options.linear ? 0 : Math.min(1, Math.max(0, options.rigidity ?? 1));
+  const sim = w > 0 ? options.similarity ?? procrustes(a, b) : null;
+  const rot = (p, ang, k) => {
+    const c = Math.cos(ang);
+    const s = Math.sin(ang);
+    return [k * (c * p[0] - s * p[1]), k * (s * p[0] + c * p[1])];
+  };
+  const thetaU = sim ? sim.theta * u : 0;
+  const sU = sim ? Math.max(1e-9, sim.s) ** u : 1;
+  const cU = sim ? lerpP(sim.ca, sim.cb, u) : [0, 0];
+  return a.map((ca, k) => {
+    const cb = b[k];
+    const pts = ca.pts.map((p, i) => {
+      const q = cb.pts[i] ?? p;
+      const linear = lerpP(p, q, u);
+      if (!sim) return linear;
+      const d = [p[0] - sim.ca[0], p[1] - sim.ca[1]];
+      const full = rot(d, sim.theta, sim.s);
+      const resid = [q[0] - (full[0] + sim.cb[0]), q[1] - (full[1] + sim.cb[1])];
+      const part = rot(d, thetaU, sU);
+      const rigid = [part[0] + cU[0] + resid[0] * u, part[1] + cU[1] + resid[1] * u];
+      return lerpP(linear, rigid, w);
+    });
+    return { closed: ca.closed && cb.closed, pts };
+  });
+}
+function interpolateRigidMatrix(a, b, t) {
+  const decompose = (m) => {
+    const sx2 = Math.hypot(m[0], m[1]);
+    const ang2 = sx2 > 1e-12 ? Math.atan2(m[1], m[0]) : 0;
+    const c2 = Math.cos(ang2);
+    const s2 = Math.sin(ang2);
+    return { e: m[4], f: m[5], ang: ang2, sx: sx2, sh: c2 * m[2] + s2 * m[3], sy: -s2 * m[2] + c2 * m[3] };
+  };
+  const p = decompose(a);
+  const q = decompose(b);
+  let turn = q.ang - p.ang;
+  turn = ((turn + Math.PI) % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI) - Math.PI;
+  const ang = p.ang + turn * t;
+  const sx = lerpN(p.sx, q.sx, t);
+  const sh = lerpN(p.sh, q.sh, t);
+  const sy = lerpN(p.sy, q.sy, t);
+  const c = Math.cos(ang);
+  const s = Math.sin(ang);
+  return [c * sx, s * sx, c * sh - s * sy, s * sh + c * sy, lerpN(p.e, q.e, t), lerpN(p.f, q.f, t)];
+}
+function interpolateVectorColor(a, b, t) {
+  if (t <= 0) return a;
+  if (t >= 1) return b;
+  return mixColorsOklab(a, b, t) ?? (t < 0.5 ? a : b);
+}
+function resampleGradientStops(g, offsets) {
+  return offsets.map((offset) => {
+    const s = sampleVectorGradient(g, offset);
+    return s.opacity < 1 ? { offset, color: s.color, opacity: Math.round(s.opacity * 1e4) / 1e4 } : { offset, color: s.color };
+  });
+}
+function lerpAngle(a, b, t) {
+  const d = ((b - a + 180) % 360 + 360) % 360 - 180;
+  return a + d * t;
+}
+var lerpPoint = (a, b, t) => ({ x: lerpN(a.x, b.x, t), y: lerpN(a.y, b.y, t) });
+var sameColourModel = (a, b) => (a.interpolation ?? "srgb") === (b.interpolation ?? "srgb") && (a.smoothness ?? 0) === (b.smoothness ?? 0);
+function lerpStops(a, b, t) {
+  let stopsA = sortedVectorGradientStops(a);
+  let stopsB = sortedVectorGradientStops(b);
+  const resampled = stopsA.length !== stopsB.length || !sameColourModel(a, b);
+  if (resampled) {
+    const offs = [...expandVectorGradientStops(a), ...expandVectorGradientStops(b), ...stopsA, ...stopsB].map((s) => s.offset).filter(Number.isFinite).sort((x, y) => x - y);
+    const common = offs.filter((o, i) => i === 0 || o - offs[i - 1] > 1e-4);
+    stopsA = resampleGradientStops(a, common);
+    stopsB = resampleGradientStops(b, common);
+  }
+  const stops = stopsA.map((x, i) => {
+    const y = stopsB[i];
+    const opacity = lerpN(x.opacity ?? 1, y.opacity ?? 1, t);
+    const stop = { offset: lerpN(x.offset, y.offset, t), color: interpolateVectorColor(x.color, y.color, t) };
+    if (opacity < 1) stop.opacity = opacity;
+    const mid = lerpN(x.midpoint ?? 0.5, y.midpoint ?? 0.5, t);
+    if (Math.abs(mid - 0.5) > 1e-6) stop.midpoint = mid;
+    return stop;
+  });
+  return { stops, resampled };
+}
+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 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;
+  const ea = hasExplicitGradientGeometry(a);
+  const eb = hasExplicitGradientGeometry(b);
+  if (!ea && !eb) {
+    if (a.angle !== void 0 || b.angle !== void 0 || a.type === "linear" || a.type === "reflected") {
+      const fallback = a.type === "linear" || a.type === "reflected" ? 180 : 90;
+      out.angle = lerpAngle(a.angle ?? fallback, b.angle ?? fallback, t);
+    }
+    if (a.type !== "linear" && a.type !== "reflected") {
+      out.cx = lerpN(a.cx ?? 0.5, b.cx ?? 0.5, t);
+      out.cy = lerpN(a.cy ?? 0.5, b.cy ?? 0.5, t);
+      out.r = lerpN(a.r ?? 0.5, b.r ?? 0.5, t);
+    }
+    return out;
+  }
+  const pa = vectorGradientPoints(a);
+  const pb = vectorGradientPoints(b);
+  if (pa.units !== pb.units) {
+    const src = explicitVectorGradient(near);
+    return { ...src, stops: out.stops, ...out.interpolation ? { interpolation: out.interpolation } : {}, ...out.smoothness ? { smoothness: out.smoothness } : {} };
+  }
+  out.start = lerpPoint(pa.start, pb.start, t);
+  out.end = lerpPoint(pa.end, pb.end, t);
+  out.width = lerpPoint(pa.width, pb.width, t);
+  out.units = pa.units;
+  if (a.type === "radial") {
+    if (pa.focal || pb.focal) out.focal = lerpPoint(pa.focal ?? pa.start, pb.focal ?? pb.start, t);
+    const fr = lerpN(pa.focalRadius, pb.focalRadius, t);
+    if (fr > 0) out.focalRadius = fr;
+  }
+  return out;
+}
+function solidLike(color, like) {
+  return { ...like, stops: like.stops.map((s) => color === null ? { offset: s.offset, color: s.color, opacity: 0 } : { offset: s.offset, color }) };
+}
+function interpolateVectorPaint(a, b, t) {
+  if (t <= 0) return a;
+  if (t >= 1) return b;
+  const pa = hasPaint(a);
+  const pb = hasPaint(b);
+  if (!pa && !pb) return t < 0.5 ? a : b;
+  if (typeof a === "string" && pa && typeof b === "string" && pb) return interpolateVectorColor(a, b, t);
+  if (!pa && typeof b === "string") return interpolateVectorColor("transparent", b, t);
+  if (!pb && typeof a === "string") return interpolateVectorColor(a, "transparent", t);
+  const ga = pa && isVectorGradient(a) ? a : null;
+  const gb = pb && isVectorGradient(b) ? b : null;
+  if (ga && gb) return lerpGradient(ga, gb, t) ?? (t < 0.5 ? a : b);
+  if (gb) return lerpGradient(solidLike(pa ? a : null, gb), gb, t) ?? b;
+  if (ga) return lerpGradient(ga, solidLike(pb ? b : null, ga), t) ?? a;
+  return t < 0.5 ? a : b;
+}
+function interpolateWidthProfiles(a, b, t) {
+  if (!a?.length && !b?.length) return null;
+  const at = [...a ?? [], ...b ?? [], { t: 0 }, { t: 1 }].map((p) => p.t).sort((x, y) => x - y);
+  const ts = at.filter((v, i) => i === 0 || v - at[i - 1] > 1e-6);
+  return ts.map((pos) => {
+    const x = widthProfileAt(a, pos);
+    const y = widthProfileAt(b, pos);
+    return { t: pos, left: lerpN(x.left, y.left, t), right: lerpN(x.right, y.right, t) };
+  });
+}
+function lerpDashes(a, b, t) {
+  const dashed = (d) => !!d?.length && d.some((v) => v > 0);
+  if (!dashed(a) && !dashed(b)) return t < 0.5 ? a : b;
+  const even = (p) => p.length % 2 ? [...p, ...p] : p;
+  const solid = (p) => {
+    const e = even(p);
+    const out = [];
+    for (let i = 0; i < e.length; i += 2) out.push(e[i] + e[i + 1], 0);
+    return out;
+  };
+  const x = dashed(a) ? even(a) : solid(b);
+  const y = dashed(b) ? even(b) : solid(a);
+  if (x.length !== y.length) return t < 0.5 ? a : b;
+  return x.map((v, i) => lerpN(v, y[i], t));
+}
+var SWITCHED_KEYS = ["strokeLinecap", "strokeLinejoin", "fillRule", "strokeAlign", "startArrow", "endArrow", "arrowAlign"];
+function interpolateVectorStyle(a, b, t) {
+  const near = 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(a.strokeWidth ?? 1, 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 ["startArrowScale", "endArrowScale"])
+    if (a[key] !== void 0 || b[key] !== void 0) out[key] = lerpN(a[key] ?? 1, b[key] ?? 1, t);
+  const dash = lerpDashes(a.strokeDasharray, b.strokeDasharray, t);
+  if (dash?.length) out.strokeDasharray = dash;
+  const profile = interpolateWidthProfiles(a.strokeWidthProfile, b.strokeWidthProfile, t);
+  if (profile) out.strokeWidthProfile = profile;
+  return out;
+}
+function reversedStyle(s) {
+  const out = { ...s };
+  out.startArrow = s.endArrow;
+  out.endArrow = s.startArrow;
+  out.startArrowScale = s.endArrowScale;
+  out.endArrowScale = s.startArrowScale;
+  if (s.strokeWidthProfile?.length) out.strokeWidthProfile = reverseWidthProfile(s.strokeWidthProfile);
+  for (const k of ["startArrow", "endArrow", "startArrowScale", "endArrowScale"]) if (out[k] === void 0) delete out[k];
+  return out;
+}
+var STYLE_KEYS = [
+  "fill",
+  "stroke",
+  "strokeWidth",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeDasharray",
+  "fillRule",
+  "strokeAlign",
+  "startArrow",
+  "endArrow",
+  "arrowAlign",
+  "startArrowScale",
+  "endArrowScale",
+  "strokeWidthProfile"
+];
+function styleOf(n) {
+  const out = {};
+  for (const k of STYLE_KEYS) if (n[k] !== void 0) out[k] = n[k];
+  return out;
+}
+function contoursOf(node, m) {
+  return expandVectorCorners(node.subpaths).map((sp) => subpathToMorphContour(sp, m)).filter((c) => !!c);
+}
+function preparePathMorph(a, b, options, ma = nodeMatrix(a), mb = nodeMatrix(b)) {
+  const corr = correspondMorphContours(contoursOf(a, ma), contoursOf(b, mb), options);
+  const sim = procrustes(corr.a, corr.b);
+  const styleA = styleOf(a);
+  const styleB = corr.reversed ? reversedStyle(styleOf(b)) : styleOf(b);
+  const rigid = !isIdentityMatrix(ma) || !isIdentityMatrix(mb);
+  const id = options.id ?? a.id;
+  return (t) => {
+    const contours = interpolateMorphContours(corr.a, corr.b, t, { linear: options.linear, rigidity: options.rigidity, similarity: sim });
+    const m = rigid ? interpolateRigidMatrix(ma, mb, t) : IDENTITY_MATRIX;
+    const back = rigid ? invertMatrix(m) : IDENTITY_MATRIX;
+    const subpaths = contours.map((c, k) => {
+      const closed = t <= 0 ? corr.a[k].closed : t >= 1 ? corr.b[k].closed : corr.a[k].closed && corr.b[k].closed;
+      return morphContourToSubpath({ closed: corr.a[k].closed && corr.b[k].closed, pts: c.pts }, back, closed);
+    });
+    const node = { id, type: "path", subpaths, ...interpolateVectorStyle(styleA, styleB, t) };
+    const opacity = lerpN(a.opacity ?? 1, b.opacity ?? 1, t);
+    if (opacity < 1) node.opacity = opacity;
+    if (rigid && !isIdentityMatrix(m)) node.transform = m;
+    return node;
+  };
+}
+function flattenPaths(node, parent = IDENTITY_MATRIX) {
+  const m = multiplyMatrices(nodeMatrix(node), parent);
+  if (node.type === "path") return [{ path: node, m, opacity: 1 }];
+  if (node.type === "text" || node.type === "instance") return flattenPaths(expandVectorAppearance(node), parent);
+  const o = 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 at = preparePathMorph(a, b, options);
+    return { at };
+  }
+  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 = 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 sub = { ...options, id: `${id}-${i}`, starts: void 0 };
+    if (x && y) {
+      parts.push(preparePathMorph(x.path, y.path, sub, 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), sub, x.m, IDENTITY_MATRIX));
+      opacities.push([x.opacity, x.opacity]);
+    } else if (y) {
+      parts.push(preparePathMorph(collapsedPath(y.path, y.m, bb, ba), y.path, sub, 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) * (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, evaluateEasing(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);
+}
+
+export {
+  subpathToMorphContour,
+  morphContourToSubpath,
+  refineMorphContour,
+  reverseMorphContour,
+  turnMorphContour,
+  correspondMorphContours,
+  morphPathsCross,
+  interpolateMorphContours,
+  interpolateRigidMatrix,
+  interpolateVectorColor,
+  resampleGradientStops,
+  interpolateVectorPaint,
+  interpolateWidthProfiles,
+  interpolateVectorStyle,
+  createVectorMorph,
+  interpolateVectorPaths,
+  evaluateVectorPathKeyframes
+};
+//# sourceMappingURL=chunk-MMVHBKMM.js.map