@ssgoi/core 6.5.0 → 6.6.0

package/dist/index.js

@@ -1,23 +1,23 @@
-var Mt = Object.defineProperty;
-var Ut = (e, t, n) => t in e ? Mt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
-var $ = (e, t, n) => Ut(e, typeof t != "symbol" ? t + "" : t, n);
-import { P as K, V as Dt, W as m, M as C, S as Rt } from "./multi-animation-Ch5rI3rB.js";
-import { A as Fs } from "./multi-animation-Ch5rI3rB.js";
-function v(e, t) {
+var Rt = Object.defineProperty;
+var Ut = (e, t, n) => t in e ? Rt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var C = (e, t, n) => Ut(e, typeof t != "symbol" ? t + "" : t, n);
+import { P as J, V as vt, W as g, M as x, S as Vt } from "./multi-animation-Ch5rI3rB.js";
+import { A as Ls } from "./multi-animation-Ch5rI3rB.js";
+function D(e, t) {
   const n = [];
   for (let s = 0; s < e.length; s++)
     for (let o = s + 1; o < e.length; o++) {
-      const i = e[s], r = e[o];
-      !i || !r || n.push({
+      const i = e[s], l = e[o];
+      !i || !l || n.push({
         from: i,
-        to: r,
+        to: l,
         transition: t(),
         symmetric: !0
       });
     }
   return n;
 }
-function vt(e, t) {
+function Ot(e, t) {
   return [
     {
       from: e.exit,
@@ -31,41 +31,41 @@ function vt(e, t) {
     }
   ];
 }
-function G(e, t, n) {
+function Q(e, t, n) {
   const s = [];
   for (let o = 0; o < e.length; o++)
     for (let i = o + 1; i < e.length; i++) {
-      const r = e[o], l = e[i];
-      !r || !l || s.push(
+      const l = e[o], a = e[i];
+      !l || !a || s.push(
         {
-          from: r,
-          to: l,
+          from: l,
+          to: a,
           transition: n(t.forward)
         },
         {
-          from: l,
-          to: r,
+          from: a,
+          to: l,
           transition: n(t.backward)
         }
       );
     }
   return s;
 }
-class k {
+class L {
   constructor(t) {
-    $(this, "omega");
+    C(this, "omega");
     // Angular frequency
-    $(this, "zeta");
+    C(this, "zeta");
     // Damping ratio
-    $(this, "restDelta");
-    $(this, "restSpeed");
+    C(this, "restDelta");
+    C(this, "restSpeed");
     const { stiffness: n, damping: s } = t, o = 1;
-    this.omega = Math.sqrt(n / o), this.zeta = s / (2 * Math.sqrt(n * o)), this.restDelta = t.restDelta ?? K, this.restSpeed = t.restSpeed ?? Dt;
+    this.omega = Math.sqrt(n / o), this.zeta = s / (2 * Math.sqrt(n * o)), this.restDelta = t.restDelta ?? J, this.restSpeed = t.restSpeed ?? vt;
   }
   step(t, n, s) {
-    const o = Math.min(s, 0.033), { omega: i, zeta: r } = this, { position: l, velocity: c } = t, a = -2 * o * r * i * c, p = o * i * i * (n - l), d = c + a + p;
+    const o = Math.min(s, 0.033), { omega: i, zeta: l } = this, { position: a, velocity: r } = t, c = -2 * o * l * i * r, p = o * i * i * (n - a), d = r + c + p;
     return {
-      position: l + o * d,
+      position: a + o * d,
       velocity: d
     };
   }
@@ -74,20 +74,20 @@ class k {
     return s < this.restDelta && o < this.restSpeed;
   }
 }
-class Vt {
+class Nt {
   constructor(t) {
-    $(this, "leader");
-    $(this, "follower");
-    $(this, "restDelta");
-    $(this, "restSpeed");
-    this.restDelta = t.restDelta ?? K, this.restSpeed = t.restSpeed ?? Dt, this.leader = new k({
+    C(this, "leader");
+    C(this, "follower");
+    C(this, "restDelta");
+    C(this, "restSpeed");
+    this.restDelta = t.restDelta ?? J, this.restSpeed = t.restSpeed ?? vt, this.leader = new L({
       stiffness: t.stiffness,
       damping: t.damping,
       restDelta: this.restDelta,
       restSpeed: this.restSpeed
     });
     let n, s, o, i;
-    typeof t.follower == "number" ? (n = t.stiffness * t.follower, s = t.damping) : t.follower ? (n = t.follower.stiffness, s = t.follower.damping, o = t.follower.restDelta, i = t.follower.restSpeed) : (n = t.stiffness, s = t.damping), this.follower = new k({
+    typeof t.follower == "number" ? (n = t.stiffness * t.follower, s = t.damping) : t.follower ? (n = t.follower.stiffness, s = t.follower.damping, o = t.follower.restDelta, i = t.follower.restSpeed) : (n = t.stiffness, s = t.damping), this.follower = new L({
       stiffness: n,
       damping: s,
       restDelta: o ?? this.restDelta,
@@ -98,15 +98,15 @@ class Vt {
     const i = t._leader ?? {
       position: t.position,
       velocity: t.velocity
-    }, r = this.leader.step(i, n, s), l = this.follower.step(
+    }, l = this.leader.step(i, n, s), a = this.follower.step(
       t,
-      r.position,
+      l.position,
       s
     );
     return {
-      position: l.position,
-      velocity: l.velocity,
-      _leader: r
+      position: a.position,
+      velocity: a.velocity,
+      _leader: l
     };
   }
   isSettled(t, n) {
@@ -114,46 +114,46 @@ class Vt {
     return s._leader ? Math.abs(n - s._leader.position) < this.restDelta && Math.abs(s._leader.velocity) < this.restSpeed && o : o;
   }
 }
-const zt = 0.01, Nt = 500, Xt = 10;
-class Bt {
+const Xt = 0.01, Bt = 500, Zt = 10;
+class Wt {
   constructor(t) {
-    $(this, "acceleration");
-    $(this, "resistance");
-    $(this, "resistanceType");
-    $(this, "min");
-    $(this, "max");
-    $(this, "bounceStiffness");
-    $(this, "bounceDamping");
-    $(this, "restDelta");
-    this.acceleration = t.acceleration, this.resistance = t.resistance, this.resistanceType = t.resistanceType ?? "quadratic", this.min = t.min, this.max = t.max, this.bounceStiffness = t.bounceStiffness ?? Nt, this.bounceDamping = t.bounceDamping ?? Xt, this.restDelta = t.restDelta ?? zt;
+    C(this, "acceleration");
+    C(this, "resistance");
+    C(this, "resistanceType");
+    C(this, "min");
+    C(this, "max");
+    C(this, "bounceStiffness");
+    C(this, "bounceDamping");
+    C(this, "restDelta");
+    this.acceleration = t.acceleration, this.resistance = t.resistance, this.resistanceType = t.resistanceType ?? "quadratic", this.min = t.min, this.max = t.max, this.bounceStiffness = t.bounceStiffness ?? Bt, this.bounceDamping = t.bounceDamping ?? Zt, this.restDelta = t.restDelta ?? Xt;
   }
   step(t, n, s) {
-    const o = Math.min(s, 0.033), { acceleration: i, resistance: r, resistanceType: l, min: c, max: a } = this, { position: p, velocity: d } = t, f = c !== void 0 && p < c, u = a !== void 0 && p > a;
+    const o = Math.min(s, 0.033), { acceleration: i, resistance: l, resistanceType: a, min: r, max: c } = this, { position: p, velocity: d } = t, f = r !== void 0 && p < r, u = c !== void 0 && p > c;
     let y;
     if (f || u) {
-      const b = p - (f ? c : a), x = -this.bounceStiffness * b, E = -this.bounceDamping * d;
-      y = x + E;
+      const b = p - (f ? r : c), P = -this.bounceStiffness * b, _ = -this.bounceDamping * d;
+      y = P + _;
     } else {
-      const S = n > p ? 1 : -1;
+      const m = n > p ? 1 : -1;
       let b;
-      l === "linear" ? b = r * d : b = r * d * Math.abs(d), y = S * i - b;
+      a === "linear" ? b = l * d : b = l * d * Math.abs(d), y = m * i - b;
     }
     const h = d + y * o;
-    let w = p + h * o;
+    let S = p + h * o;
     if (!f && !u) {
-      const S = n > p ? 1 : -1;
-      (S > 0 && w > n || S < 0 && w < n) && (w = n);
+      const m = n > p ? 1 : -1;
+      (m > 0 && S > n || m < 0 && S < n) && (S = n);
     }
     return {
-      position: w,
-      velocity: w === n ? 0 : h
+      position: S,
+      velocity: S === n ? 0 : h
     };
   }
   isSettled(t, n) {
     return Math.abs(n - t.position) < this.restDelta;
   }
 }
-class g {
+class w {
   /**
    * Create an Integrator from physics config
    *
@@ -167,7 +167,7 @@ class g {
         "Cannot use both 'spring' and 'inertia' together. Choose one physics type."
       );
     if (t.inertia)
-      return new Bt({
+      return new Wt({
         acceleration: t.inertia.acceleration,
         resistance: t.inertia.resistance,
         resistanceType: t.inertia.resistanceType,
@@ -184,7 +184,7 @@ class g {
       return typeof s == "number" ? o = s : typeof s == "object" && (o = {
         stiffness: s.stiffness,
         damping: s.damping
-      }), new Vt({
+      }), new Nt({
         stiffness: n.stiffness,
         damping: n.damping,
         follower: o,
@@ -192,7 +192,7 @@ class g {
         restSpeed: n.restSpeed
       });
     }
-    return new k({
+    return new L({
       stiffness: n.stiffness,
       damping: n.damping,
       restDelta: n.restDelta,
@@ -204,32 +204,32 @@ class g {
    * @deprecated Use from({ spring: config }) instead
    */
   static fromSpring(t) {
-    return g.from({ spring: t });
+    return w.from({ spring: t });
   }
 }
-class Wt {
+class qt {
   constructor(t) {
-    $(this, "durationSec");
+    C(this, "durationSec");
     this.durationSec = Math.max(1 / 60, t.durationSec);
   }
   step(t, n, s) {
     const o = n - t.position;
     if (o === 0) return t;
-    const i = Math.sign(o), r = Math.abs(o) / this.durationSec, l = i * r * s, c = t.position + l;
-    return (i > 0 ? c >= n : c <= n) ? { position: n, velocity: 0 } : { position: c, velocity: i * r };
+    const i = Math.sign(o), l = Math.abs(o) / this.durationSec, a = i * l * s, r = t.position + a;
+    return (i > 0 ? r >= n : r <= n) ? { position: n, velocity: 0 } : { position: r, velocity: i * l };
   }
   isSettled(t, n) {
-    return Math.abs(t.position - n) < K;
+    return Math.abs(t.position - n) < J;
   }
 }
-function J(e, t) {
+function tt(e, t) {
   function n(i) {
-    let r = 0, l = 0;
-    const c = i.offsetWidth, a = i.offsetHeight;
+    let l = 0, a = 0;
+    const r = i.offsetWidth, c = i.offsetHeight;
     let p = i;
     for (; p; )
-      r += p.offsetTop, l += p.offsetLeft, p = p.offsetParent;
-    return r -= window.scrollY, l -= window.scrollX, { top: r, left: l, width: c, height: a };
+      l += p.offsetTop, a += p.offsetLeft, p = p.offsetParent;
+    return l -= window.scrollY, a -= window.scrollX, { top: l, left: a, width: r, height: c };
   }
   const s = n(e), o = n(t);
   return new DOMRect(
@@ -239,7 +239,7 @@ function J(e, t) {
     o.height
   );
 }
-function tt(e, t) {
+function nt(e, t) {
   const n = e.getBoundingClientRect(), s = t.getBoundingClientRect(), o = e.offsetWidth > 0 ? n.width / e.offsetWidth : 1, i = e.offsetHeight > 0 ? n.height / e.offsetHeight : 1;
   return new DOMRect(
     (s.left - n.left) / o,
@@ -248,8 +248,8 @@ function tt(e, t) {
     s.height / i
   );
 }
-function I(e, t) {
-  const { scrollingElement: n, positionedParent: s } = e, o = n !== s && n.contains(s) ? J(n, s).top : 0;
+function T(e, t) {
+  const { scrollingElement: n, positionedParent: s } = e, o = n !== s && n.contains(s) ? tt(n, s).top : 0;
   return {
     top: e[t].scroll.y,
     left: 0,
@@ -257,7 +257,7 @@ function I(e, t) {
     height: n.clientHeight - o
   };
 }
-const et = 8, nt = {
+const st = 8, ot = {
   spring: {
     stiffness: 1e3,
     damping: 40,
@@ -266,10 +266,10 @@ const et = 8, nt = {
     restSpeed: 0.1
   }
 };
-function Zt({
+function Kt({
   direction: e
 }) {
-  const t = e === "forward" ? et : -et;
+  const t = e === "forward" ? st : -st;
   return {
     out: {
       willChange: "transform, opacity",
@@ -291,25 +291,25 @@ function Zt({
     }
   };
 }
-function qt() {
+function jt() {
   return {
-    outPhysics: nt,
-    inPhysics: nt,
+    outPhysics: ot,
+    inPhysics: ot,
     // Both sides run together — the cross-fade is the whole point of the
     // snappy feel. (fluid's sibling uses staggered fade-through.)
     composition: { mode: "parallel", startAt: [0, 0] },
-    build: Zt
+    build: Kt
   };
 }
-const st = 30, jt = {
+const it = 30, Gt = {
   inertia: { acceleration: 150, resistance: 1.5, restDelta: 0.1 }
-}, Kt = {
+}, Jt = {
   spring: { stiffness: 180, damping: 34, restDelta: 0.1, restSpeed: 0.1 }
 };
-function Gt({
+function Qt({
   direction: e
 }) {
-  const t = e === "forward" ? 1 : -1, n = -st * t, s = st * t;
+  const t = e === "forward" ? 1 : -1, n = -it * t, s = it * t;
   return {
     out: {
       willChange: "transform, opacity",
@@ -332,29 +332,29 @@ function Gt({
     }
   };
 }
-function Jt() {
+function te() {
   return {
-    outPhysics: jt,
-    inPhysics: Kt,
+    outPhysics: Gt,
+    inPhysics: Jt,
     // Phased motion: outgoing falls away first under inertia, then incoming
     // springs in. The fade-through shape comes from the integrator curves
     // plus the sequence handoff, not from FADE_SPLIT inside animate(t).
     composition: { mode: "sequence" },
-    build: Gt
+    build: Qt
   };
 }
-const Qt = {
-  snappy: qt(),
-  fluid: Jt()
-}, ot = 8, te = {
+const ee = {
+  snappy: jt(),
+  fluid: te()
+}, rt = 8, ne = {
   inertia: { acceleration: 150, resistance: 1.5, restDelta: 0.1 }
-}, ee = {
+}, se = {
   spring: { stiffness: 180, damping: 34, restDelta: 0.1, restSpeed: 0.1 }
 };
-function ne({
+function oe({
   direction: e
 }) {
-  const t = e === "forward" ? 1 : -1, n = -ot * t, s = ot * t;
+  const t = e === "forward" ? 1 : -1, n = -rt * t, s = rt * t;
   return {
     out: {
       willChange: "transform, opacity",
@@ -377,21 +377,21 @@ function ne({
     }
   };
 }
-function se() {
+function ie() {
   return {
-    outPhysics: te,
-    inPhysics: ee,
+    outPhysics: ne,
+    inPhysics: se,
     composition: { mode: "sequence" },
-    build: ne
+    build: oe
   };
 }
-const oe = 8, ie = {
+const re = 8, ae = {
   inertia: { acceleration: 150, resistance: 1.5, restDelta: 0.1 }
-}, re = {
+}, le = {
   spring: { stiffness: 180, damping: 34, restDelta: 0.1, restSpeed: 0.1 }
 };
-function ae(e) {
-  const t = oe;
+function ce(e) {
+  const t = re;
   return {
     out: {
       willChange: "opacity",
@@ -413,32 +413,32 @@ function ae(e) {
     }
   };
 }
-function le() {
+function pe() {
   return {
-    outPhysics: ie,
-    inPhysics: re,
+    outPhysics: ae,
+    inPhysics: le,
     composition: { mode: "sequence" },
-    build: ae
+    build: ce
   };
 }
-const it = se(), ce = {
-  snappy: it,
-  directional: it,
-  "non-directional": le()
-}, rt = {
+const at = ie(), de = {
+  snappy: at,
+  directional: at,
+  "non-directional": pe()
+}, lt = {
   spring: { stiffness: 280, damping: 30, restDelta: 0.1, restSpeed: 0.1 }
-}, M = 0.1, U = 1 / 3, at = (e) => Math.max(0, Math.min(1, e));
-function pe({
+}, R = 0.1, U = 1 / 3, ct = (e) => Math.max(0, Math.min(1, e));
+function fe({
   direction: e
 }) {
-  const t = e === "forward" ? 1 : -1, n = 1 - t * M;
+  const t = e === "forward" ? 1 : -1, n = 1 - t * R;
   return {
     out: {
       willChange: "transform, opacity",
       startStyle: {},
       animate: (s) => ({
-        transform: `scale(${1 + t * s * M})`,
-        opacity: `${at(1 - s / U)}`
+        transform: `scale(${1 + t * s * R})`,
+        opacity: `${ct(1 - s / U)}`
       })
     },
     in: {
@@ -448,130 +448,130 @@ function pe({
         opacity: "0"
       },
       animate: (s) => ({
-        transform: `scale(${n + t * s * M})`,
-        opacity: `${at((s - U) / (1 - U))}`
+        transform: `scale(${n + t * s * R})`,
+        opacity: `${ct((s - U) / (1 - U))}`
       })
     }
   };
 }
-function de() {
+function ye() {
   return {
-    outPhysics: rt,
-    inPhysics: rt,
+    outPhysics: lt,
+    inPhysics: lt,
     // Scale must move together on both sides; fade-through is encoded inside
     // each tick (piecewise), not via composition staggering — so parallel.
     composition: { mode: "parallel" },
-    build: pe
+    build: fe
   };
 }
-const lt = {
+const pt = {
   spring: { stiffness: 280, damping: 30, restDelta: 0.1, restSpeed: 0.1 }
-}, R = 0.1, V = 1 / 3, ct = (e) => Math.max(0, Math.min(1, e));
-function fe() {
+}, V = 0.1, N = 1 / 3, dt = (e) => Math.max(0, Math.min(1, e));
+function he() {
   return {
     out: {
       willChange: "opacity",
       startStyle: {},
       animate: (e) => ({
-        opacity: `${ct(1 - e / V)}`
+        opacity: `${dt(1 - e / N)}`
       })
     },
     in: {
       willChange: "transform, opacity",
       startStyle: {
-        transform: `scale(${1 - R})`,
+        transform: `scale(${1 - V})`,
         opacity: "0"
       },
       animate: (e) => ({
-        transform: `scale(${1 - R + e * R})`,
-        opacity: `${ct((e - V) / (1 - V))}`
+        transform: `scale(${1 - V + e * V})`,
+        opacity: `${dt((e - N) / (1 - N))}`
       })
     }
   };
 }
-function ye() {
+function ue() {
   return {
-    outPhysics: lt,
-    inPhysics: lt,
+    outPhysics: pt,
+    inPhysics: pt,
     composition: { mode: "parallel" },
-    build: fe
+    build: he
   };
 }
-const pt = de(), he = {
-  snappy: pt,
-  directional: pt,
-  "non-directional": ye()
-}, ue = {
-  x: Qt,
-  y: ce,
-  z: he
+const ft = ye(), me = {
+  snappy: ft,
+  directional: ft,
+  "non-directional": ue()
+}, ge = {
+  x: ee,
+  y: de,
+  z: me
 };
-function me(e, t) {
-  const n = ue[e];
+function we(e, t) {
+  const n = ge[e];
   return n[t] ?? n.snappy;
 }
-const ge = "x", we = "snappy";
-function dt(e, t) {
+const Se = "x", be = "snappy";
+function yt(e, t) {
   e.style.willChange = t.willChange, e.style.backfaceVisibility = "hidden", e.style.contain = "layout paint";
   for (const [n, s] of Object.entries(t.startStyle))
     e.style[n] = s;
 }
-function It(e) {
+function Tt(e) {
   e.style.willChange = "auto", e.style.backfaceVisibility = "", e.style.contain = "", e.style.transform = "", e.style.opacity = "", e.style.clipPath = "";
 }
-function Se(e) {
-  It(e), e.style.pointerEvents = "";
+function $e(e) {
+  Tt(e), e.style.pointerEvents = "";
 }
-const be = (e = {}) => {
-  const t = e.direction ?? "forward", n = e.type ?? ge, s = e.feel ?? we, o = me(n, s), i = o.build({ direction: t });
+const Ce = (e = {}) => {
+  const t = e.direction ?? "forward", n = e.type ?? Se, s = e.feel ?? be, o = we(n, s), i = o.build({ direction: t });
   return {
-    prepare: ({ from: r, to: l }) => (r.then((c) => {
-      dt(c, i.out), c.style.pointerEvents = "none";
-    }), l.then((c) => {
-      dt(c, i.in);
+    prepare: ({ from: l, to: a }) => (l.then((r) => {
+      yt(r, i.out), r.style.pointerEvents = "none";
+    }), a.then((r) => {
+      yt(r, i.in);
     }), {}),
-    animation: ({ from: r, to: l, context: c }) => {
+    animation: ({ from: l, to: a, context: r }) => {
       if (n === "z") {
-        const d = I(c, "from"), f = I(c, "to");
-        r.style.clipPath = `inset(${d.top}px 0 calc(100% - ${d.top + d.height}px) 0)`, l.style.clipPath = `inset(${f.top}px 0 calc(100% - ${f.top + f.height}px) 0)`;
+        const d = T(r, "from"), f = T(r, "to");
+        l.style.clipPath = `inset(${d.top}px 0 calc(100% - ${d.top + d.height}px) 0)`, a.style.clipPath = `inset(${f.top}px 0 calc(100% - ${f.top + f.height}px) 0)`;
       }
-      const a = new m({
-        element: r,
-        integrator: g.from(o.outPhysics),
+      const c = new g({
+        element: l,
+        integrator: w.from(o.outPhysics),
         style: (d) => i.out.animate(d),
         // Restore the reused from node's inline styles on complete. This
         // covers willChange/backfaceVisibility/contain/transform/opacity (from
         // applyStartStyle + the WAAPI final frame), pointerEvents (set in
         // prepare), and clipPath (set above for z; harmless no-op otherwise).
-        onComplete: () => Se(r)
-      }), p = new m({
-        element: l,
-        integrator: g.from(o.inPhysics),
+        onComplete: () => $e(l)
+      }), p = new g({
+        element: a,
+        integrator: w.from(o.inPhysics),
         style: (d) => i.in.animate(d),
-        onComplete: () => It(l)
+        onComplete: () => Tt(a)
       });
-      return new C([a, p], o.composition);
+      return new x([c, p], o.composition);
     }
   };
 };
-function $e(e, t, n) {
+function xe(e, t, n) {
   return e === "y" ? t === "non-directional" ? "non-directional" : "directional" : e !== "x" || t === "snappy" || n === "snappy" ? "snappy" : "fluid";
 }
-function ws(e) {
-  const { paths: t } = e, n = e.type ?? "x", s = e.variant, o = e.feel, i = $e(n, s, o);
-  return G(
+function $s(e) {
+  const { paths: t } = e, n = e.type ?? "x", s = e.variant, o = e.feel, i = xe(n, s, o);
+  return Q(
     t,
     { forward: "forward", backward: "backward" },
-    (r) => be({ type: n, direction: r, feel: i })
+    (l) => Ce({ type: n, direction: l, feel: i })
   );
 }
-const Ce = {
+const Ee = {
   spring: { stiffness: 200, damping: 22 }
-}, Ee = 10, xe = "horizontal", Pe = "#000000";
-function ft(e, t, n, s, o, i) {
+}, Pe = 10, _e = "horizontal", Ie = "#000000";
+function ht(e, t, n, s, o, i) {
   window.getComputedStyle(e).position === "static" && (e.style.position = "relative");
-  const l = document.createElement("div");
-  l.style.cssText = `
+  const a = document.createElement("div");
+  a.style.cssText = `
     position: absolute;
     top: 0;
     left: 0;
@@ -581,14 +581,14 @@ function ft(e, t, n, s, o, i) {
     z-index: 9999;
     overflow: hidden;
   `;
-  const c = [];
-  for (let a = 0; a < t; a++) {
+  const r = [];
+  for (let c = 0; c < t; c++) {
     const p = document.createElement("div");
     if (n === "horizontal") {
       const d = 100 / t;
       p.style.cssText = `
         position: absolute;
-        top: ${d * a}%;
+        top: ${d * c}%;
         left: 0;
         width: 100%;
         height: calc(${d}% + 1px);
@@ -602,7 +602,7 @@ function ft(e, t, n, s, o, i) {
       p.style.cssText = `
         position: absolute;
         top: 0;
-        left: ${d * a}%;
+        left: ${d * c}%;
         width: calc(${d}% + 1px);
         height: 100%;
         background: ${s};
@@ -611,27 +611,27 @@ function ft(e, t, n, s, o, i) {
         will-change: transform;
       `;
     }
-    c.push(p), l.appendChild(p);
+    r.push(p), a.appendChild(p);
   }
-  return e.appendChild(l), { container: l, blinds: c };
+  return e.appendChild(a), { container: a, blinds: r };
 }
-const _e = (e = {}) => {
-  const t = e.blindCount ?? Ee, n = e.direction ?? xe, s = e.blindColor ?? Pe, o = e.physics ?? Ce;
+const De = (e = {}) => {
+  const t = e.blindCount ?? Pe, n = e.direction ?? _e, s = e.blindColor ?? Ie, o = e.physics ?? Ee;
   return {
-    prepare: async ({ from: i, to: r }) => {
-      const l = await i, c = await r;
-      l.style.zIndex = "1000";
-      const a = ft(
-        l,
+    prepare: async ({ from: i, to: l }) => {
+      const a = await i, r = await l;
+      a.style.zIndex = "1000";
+      const c = ht(
+        a,
         t,
         n,
         s,
         "hidden",
         "left"
       );
-      c.style.position = "relative", c.style.zIndex = "0";
-      const p = ft(
-        c,
+      r.style.position = "relative", r.style.zIndex = "0";
+      const p = ht(
+        r,
         t,
         n,
         s,
@@ -639,55 +639,55 @@ const _e = (e = {}) => {
         "right"
       );
       return {
-        fromEl: l,
-        fromBlinds: a.blinds,
-        fromContainer: a.container,
+        fromEl: a,
+        fromBlinds: c.blinds,
+        fromContainer: c.container,
         toBlinds: p.blinds,
         toContainer: p.container
       };
     },
     animation: ({
       fromEl: i,
-      fromBlinds: r,
-      fromContainer: l,
-      toBlinds: c,
-      toContainer: a
+      fromBlinds: l,
+      fromContainer: a,
+      toBlinds: r,
+      toContainer: c
     }) => {
-      const p = r.map(
-        (y) => new m({
+      const p = l.map(
+        (y) => new g({
           element: y,
-          integrator: g.from(o),
+          integrator: w.from(o),
           style: (h) => ({
             transform: n === "horizontal" ? `scaleX(${h})` : `scaleY(${h})`
           })
         })
-      ), d = c.map(
-        (y, h) => new m({
+      ), d = r.map(
+        (y, h) => new g({
           element: y,
-          integrator: g.from(o),
-          style: (w, S) => ({
-            transform: n === "horizontal" ? `scaleX(${S})` : `scaleY(${S})`
+          integrator: w.from(o),
+          style: (S, m) => ({
+            transform: n === "horizontal" ? `scaleX(${m})` : `scaleY(${m})`
           }),
-          onComplete: h === c.length - 1 ? () => {
-            a.remove(), l.remove(), i.style.zIndex = "", i.style.position = "";
+          onComplete: h === r.length - 1 ? () => {
+            c.remove(), a.remove(), i.style.zIndex = "", i.style.position = "";
           } : void 0
         })
-      ), f = new C(p, { mode: "parallel" }), u = new C(d, { mode: "parallel" });
-      return new C([f, u], { mode: "sequence" });
+      ), f = new x(p, { mode: "parallel" }), u = new x(d, { mode: "parallel" });
+      return new x([f, u], { mode: "sequence" });
     }
   };
 };
-function Ss(e) {
+function Cs(e) {
   const { paths: t, type: n = "horizontal" } = e;
-  return v(
+  return D(
     t,
-    () => _e({ direction: n })
+    () => De({ direction: n })
   );
 }
-const De = {
+const ve = {
   spring: { stiffness: 200, damping: 20, doubleSpring: 0.7 }
-}, O = 0.5;
-function ve(e) {
+}, F = 0.5;
+function Oe(e) {
   const t = e === "enter" ? -100 : 100, n = e === "enter" ? 100 : -100;
   return {
     out: {
@@ -695,32 +695,32 @@ function ve(e) {
       startStyle: {},
       animate: (s) => ({
         transform: `translate3d(${t * s}%, 0, 0)`,
-        opacity: `${O + (1 - O) * (1 - s)}`
+        opacity: `${F + (1 - F) * (1 - s)}`
       })
     },
     in: {
       willChange: "transform, opacity",
       startStyle: {
         transform: `translate3d(${n}%, 0, 0)`,
-        opacity: `${O}`
+        opacity: `${F}`
       },
       animate: (s) => ({
         transform: `translate3d(${n * (1 - s)}%, 0, 0)`,
-        opacity: `${O + (1 - O) * s}`
+        opacity: `${F + (1 - F) * s}`
       })
     }
   };
 }
-function Ie() {
+function Te() {
   return {
-    physics: De,
-    build: ve
+    physics: ve,
+    build: Oe
   };
 }
-const Te = {
+const Ae = {
   spring: { stiffness: 170, damping: 22 }
 };
-function Oe(e) {
+function Fe(e) {
   const t = e === "enter" ? -20 : 100, n = e === "enter" ? 100 : -20;
   return {
     out: {
@@ -741,166 +741,172 @@ function Oe(e) {
     }
   };
 }
-function Ae() {
+function ke() {
   return {
-    physics: Te,
-    build: Oe
+    physics: Ae,
+    build: Fe
   };
 }
-const Fe = {
-  parallax: Ae(),
-  crossfade: Ie()
-}, ke = "parallax";
-function yt(e, t) {
+const Ye = {
+  parallax: ke(),
+  crossfade: Te()
+}, v = "0", Le = "1", O = "2", He = "parallax";
+function ut(e, t) {
   e.style.willChange = t.willChange, e.style.backfaceVisibility = "hidden", e.style.contain = "layout paint";
   for (const [n, s] of Object.entries(t.startStyle))
     e.style[n] = s;
 }
-const Ye = (e = {}) => {
-  const t = e.direction ?? "enter", n = Fe[e.type ?? ke], s = n.physics, o = n.build(t);
+const Me = (e = {}) => {
+  const t = e.direction ?? "enter", n = Ye[e.type ?? He], s = n.physics, o = n.build(t), i = t === "enter" ? v : O, l = t === "enter" ? O : v;
   return {
-    prepare: ({ from: i, to: r }) => (i.then((l) => {
-      yt(l, o.out), l.style.pointerEvents = "none", l.style.zIndex = t === "enter" ? "-1" : "100";
-    }), r.then((l) => {
-      yt(l, o.in);
+    prepare: ({ from: a, to: r }) => (a.then((c) => {
+      ut(c, o.out), c.style.pointerEvents = "none", c.style.zIndex = i;
+    }), r.then((c) => {
+      ut(c, o.in), c.style.position = "relative", c.style.zIndex = l;
     }), {}),
-    animation: ({ from: i, to: r }) => {
-      const l = new m({
-        element: i,
-        integrator: g.from(s),
-        style: (a) => o.out.animate(a),
+    animation: ({ from: a, to: r }) => {
+      const c = new g({
+        element: a,
+        integrator: w.from(s),
+        style: (d) => o.out.animate(d),
         // The outgoing node is the real, reused element (re-hidden on navigate),
         // so clear every inline style we set on it — mirroring the `to` cleanup,
         // plus the out-only `pointerEvents` / `zIndex`.
         onComplete: () => {
-          i.style.willChange = "auto", i.style.backfaceVisibility = "", i.style.contain = "", i.style.transform = "", i.style.opacity = "", i.style.pointerEvents = "", i.style.zIndex = "";
+          a.style.willChange = "auto", a.style.backfaceVisibility = "", a.style.contain = "", a.style.transform = "", a.style.opacity = "", a.style.pointerEvents = "", a.style.zIndex = "";
         }
-      }), c = new m({
+      }), p = new g({
         element: r,
-        integrator: g.from(s),
-        style: (a) => o.in.animate(a),
+        integrator: w.from(s),
+        style: (d) => o.in.animate(d),
         onComplete: () => {
-          r.style.willChange = "auto", r.style.backfaceVisibility = "", r.style.contain = "", r.style.transform = "", r.style.opacity = "";
+          r.style.willChange = "auto", r.style.backfaceVisibility = "", r.style.contain = "", r.style.transform = "", r.style.opacity = "", r.style.position === "relative" && (r.style.position = ""), r.style.zIndex === l && (r.style.zIndex = "");
         }
       });
-      return new C([l, c], { mode: "parallel" });
+      for (const d of [c, p]) {
+        const f = d.onComplete;
+        d.onComplete = () => {
+          f == null || f(), d.releaseFill();
+        };
+      }
+      return new x([c, p], { mode: "parallel" });
     }
   };
 };
-function Le(e) {
+function ze(e) {
   return e === "slide" || e === "crossfade" ? "crossfade" : "parallax";
 }
-function bs(e) {
-  const { enter: t, exit: n } = e, s = e.type, o = Le(s);
-  return vt(
+function xs(e) {
+  const { enter: t, exit: n } = e, s = e.type, o = ze(s);
+  return Ot(
     { enter: t, exit: n },
-    (i) => Ye({ direction: i, type: o })
+    (i) => Me({ direction: i, type: o })
   );
 }
-const He = {
+const Re = {
   spring: { stiffness: 180, damping: 20, doubleSpring: !0 }
-}, Me = {
+}, Ue = {
   spring: { stiffness: 170, damping: 20, doubleSpring: !0 }
-}, Ue = (e = {}) => {
-  const t = e.physics ?? Me, n = e.physics ?? He;
+}, Ve = (e = {}) => {
+  const t = e.physics ?? Ue, n = e.physics ?? Re;
   return {
     prepare: ({ to: s }) => (s.then((o) => {
       o.style.opacity = "0", o.style.willChange = "opacity";
     }), {}),
     animation: ({ from: s, to: o }) => {
-      const i = new m({
+      const i = new g({
         element: s,
-        integrator: g.from(n),
+        integrator: w.from(n),
         // Default bounds (0, 1). `u` runs 1→0 as the animation moves
         // forward, mapping opacity from fully visible to invisible.
-        style: (l, c) => ({ opacity: c }),
+        style: (a, r) => ({ opacity: r }),
         onComplete: () => {
           s.style.willChange = "auto", s.style.opacity = "";
         }
-      }), r = new m({
+      }), l = new g({
         element: o,
-        integrator: g.from(t),
-        style: (l) => ({ opacity: l }),
+        integrator: w.from(t),
+        style: (a) => ({ opacity: a }),
         onComplete: () => {
           o.style.willChange = "auto", o.style.opacity = "";
         }
       });
-      return new C([i, r], { mode: "sequence" });
+      return new x([i, l], { mode: "sequence" });
     }
   };
 };
-function $s(e) {
+function Es(e) {
   const { paths: t } = e;
-  return v(t, () => Ue());
+  return D(t, () => Ve());
 }
-const z = {
+const X = {
   scaleDown: { stiffness: 20, damping: 7 },
   translate: { stiffness: 15, damping: 7 },
   scaleUp: { stiffness: 20, damping: 7 }
-}, T = {
+}, A = {
   scaleDown: 0,
   translate: 0.2,
   scaleUp: 0.8
-}, Re = 0.8, Ve = "white", ht = 1e3 / 60, ze = 600;
-function Ne(e) {
-  const { items: t, from: n, to: s, recordFrame: o } = e, i = ht / 1e3, r = Math.abs(s - n), l = t.map((a) => ({
-    item: a,
-    integrator: new k({
-      stiffness: a.spring.stiffness,
-      damping: a.spring.damping
+}, Ne = 0.8, Xe = "white", mt = 1e3 / 60, Be = 600;
+function Ze(e) {
+  const { items: t, from: n, to: s, recordFrame: o } = e, i = mt / 1e3, l = Math.abs(s - n), a = t.map((c) => ({
+    item: c,
+    integrator: new L({
+      stiffness: c.spring.stiffness,
+      damping: c.spring.damping
     }),
     state: { position: n, velocity: 0 },
     started: !1,
     settled: !1,
     settleTime: 0
   }));
-  for (let a = 0; a < l.length; a++)
-    (a === 0 || l[a].item.offset === 0) && (l[a].started = !0);
+  for (let c = 0; c < a.length; c++)
+    (c === 0 || a[c].item.offset === 0) && (a[c].started = !0);
   o(0);
-  let c = 0;
-  for (let a = 1; a <= ze; a++) {
-    const p = a * ht;
-    c = p;
-    for (const d of l)
-      !d.started || d.settled || (d.state = d.integrator.step(d.state, s, i), d.integrator.isSettled(d.state, s) ? (d.settleTime += i, d.settleTime >= Rt && (d.state = { position: s, velocity: 0 }, d.settled = !0)) : d.settleTime = 0, d.item.tick(d.state.position));
-    for (let d = 1; d < l.length; d++) {
-      const f = l[d];
+  let r = 0;
+  for (let c = 1; c <= Be; c++) {
+    const p = c * mt;
+    r = p;
+    for (const d of a)
+      !d.started || d.settled || (d.state = d.integrator.step(d.state, s, i), d.integrator.isSettled(d.state, s) ? (d.settleTime += i, d.settleTime >= Vt && (d.state = { position: s, velocity: 0 }, d.settled = !0)) : d.settleTime = 0, d.item.tick(d.state.position));
+    for (let d = 1; d < a.length; d++) {
+      const f = a[d];
       if (f.started) continue;
-      const u = l[d - 1];
+      const u = a[d - 1];
       if (!u.started) continue;
-      (r === 0 ? 1 : Math.abs(u.state.position - n) / r) >= f.item.offset && (f.started = !0);
+      (l === 0 ? 1 : Math.abs(u.state.position - n) / l) >= f.item.offset && (f.started = !0);
     }
-    if (o(p), l.every((d) => d.settled)) return p;
+    if (o(p), a.every((d) => d.settled)) return p;
   }
-  return c;
+  return r;
 }
-function N(e, t) {
+function B(e, t) {
   return e != null && e.spring ? {
     stiffness: e.spring.stiffness,
     damping: e.spring.damping
   } : t;
 }
-function ut(e) {
-  const { rect: t, scale: n, direction: s, override: o } = e, i = s === "out" ? { scale: 1, translateY: -t.top } : { scale: n, translateY: -t.top + t.height }, r = N(o, z.scaleDown), l = N(o, z.translate), c = N(o, z.scaleUp), a = s === "out" ? 1 : 0, p = s === "out" ? 0 : 1, d = s === "out" ? [
+function gt(e) {
+  const { rect: t, scale: n, direction: s, override: o } = e, i = s === "out" ? { scale: 1, translateY: -t.top } : { scale: n, translateY: -t.top + t.height }, l = B(o, X.scaleDown), a = B(o, X.translate), r = B(o, X.scaleUp), c = s === "out" ? 1 : 0, p = s === "out" ? 0 : 1, d = s === "out" ? [
     {
-      spring: r,
-      offset: T.scaleDown,
+      spring: l,
+      offset: A.scaleDown,
       tick: (y) => {
         const h = 1 - y;
         i.scale = 1 - (1 - n) * h;
       }
     },
     {
-      spring: l,
-      offset: T.translate,
+      spring: a,
+      offset: A.translate,
       tick: (y) => {
         const h = 1 - y;
         i.translateY = -t.top - t.height * h;
       }
     },
     {
-      spring: c,
-      offset: T.scaleUp,
+      spring: r,
+      offset: A.scaleUp,
       tick: (y) => {
         const h = 1 - y;
         i.scale = n + (1 - n) * h;
@@ -908,29 +914,29 @@ function ut(e) {
     }
   ] : [
     {
-      spring: r,
-      offset: T.scaleDown,
+      spring: l,
+      offset: A.scaleDown,
       tick: (y) => {
         i.scale = 1 - (1 - n) * y;
       }
     },
     {
-      spring: l,
-      offset: T.translate,
+      spring: a,
+      offset: A.translate,
       tick: (y) => {
         i.translateY = -t.top + t.height * (1 - y);
       }
     },
     {
-      spring: c,
-      offset: T.scaleUp,
+      spring: r,
+      offset: A.scaleUp,
       tick: (y) => {
         i.scale = n + (1 - n) * y;
       }
     }
-  ], f = [], u = Ne({
+  ], f = [], u = Ze({
     items: d,
-    from: a,
+    from: c,
     to: p,
     recordFrame: (y) => f.push({
       time: y,
@@ -940,29 +946,29 @@ function ut(e) {
   });
   return { snapshots: f, totalDuration: u };
 }
-function Xe(e, t) {
+function We(e, t) {
   if (e.length === 0) return { time: 0, scale: 1, translateY: 0 };
   if (e.length === 1 || t <= 0) return e[0];
   if (t >= 1) return e[e.length - 1];
   const n = t * (e.length - 1), s = Math.floor(n), o = Math.ceil(n);
   if (s === o) return e[s];
-  const i = e[s], r = e[o], l = n - s;
+  const i = e[s], l = e[o], a = n - s;
   return {
-    time: i.time + (r.time - i.time) * l,
-    scale: i.scale + (r.scale - i.scale) * l,
-    translateY: i.translateY + (r.translateY - i.translateY) * l
+    time: i.time + (l.time - i.time) * a,
+    scale: i.scale + (l.scale - i.scale) * a,
+    translateY: i.translateY + (l.translateY - i.translateY) * a
   };
 }
-const Be = [
+const qe = [
   [1, 1],
   [-1, 1],
   [1, -1],
   [-1, -1]
 ];
-function We(e, t) {
-  const o = (i, r, l) => {
-    const c = document.createElement("div");
-    Object.assign(c.style, {
+function Ke(e, t) {
+  const o = (i, l, a) => {
+    const r = document.createElement("div");
+    Object.assign(r.style, {
       position: "fixed",
       pointerEvents: "none",
       zIndex: "9999",
@@ -970,14 +976,14 @@ function We(e, t) {
       height: "15px",
       ...i
     });
-    const a = document.createElement("div");
-    Object.assign(a.style, {
+    const c = document.createElement("div");
+    Object.assign(c.style, {
       position: "absolute",
       width: "15px",
       height: "1px",
       backgroundColor: e,
-      [l]: "0",
-      [r]: "0"
+      [a]: "0",
+      [l]: "0"
     });
     const p = document.createElement("div");
     return Object.assign(p.style, {
@@ -985,9 +991,9 @@ function We(e, t) {
       width: "1px",
       height: "15px",
       backgroundColor: e,
-      [l]: "0",
-      [r]: "0"
-    }), c.appendChild(a), c.appendChild(p), c;
+      [a]: "0",
+      [l]: "0"
+    }), r.appendChild(c), r.appendChild(p), r;
   };
   return {
     topLeft: o(
@@ -1024,11 +1030,11 @@ function We(e, t) {
     )
   };
 }
-function mt(e, t) {
+function wt(e, t) {
   const n = t.left + t.width / 2, s = t.top + t.height / 2;
   e.style.transformOrigin = `${n}px ${s}px`;
 }
-function gt(e, t) {
+function St(e, t) {
   e.style.clipPath = `polygon(
     ${t.left}px ${t.top}px,
     ${t.left + t.width}px ${t.top}px,
@@ -1036,24 +1042,24 @@ function gt(e, t) {
     ${t.left}px ${t.top + t.height}px
   )`;
 }
-function X(e, t, n, s, o) {
+function Z(e, t, n, s, o) {
   const i = n / 1e3;
-  return new m({
+  return new g({
     element: e,
-    integrator: new Wt({ durationSec: i }),
+    integrator: new qt({ durationSec: i }),
     lowerBound: 0,
     upperBound: 1,
-    style: (r) => s(Xe(t, r)),
+    style: (l) => s(We(t, l)),
     onComplete: o
   });
 }
-const Ze = (e = {}) => {
+const je = (e = {}) => {
   var o;
-  const t = ((o = e.border) == null ? void 0 : o.color) ?? Ve, n = Re, s = e.physics;
+  const t = ((o = e.border) == null ? void 0 : o.color) ?? Xe, n = Ne, s = e.physics;
   return {
-    prepare: ({ from: i, to: r, context: l }) => {
-      const c = I(l, "from"), a = I(l, "to"), p = J(document.body, l.positionedParent), d = We(t, {
-        ...c,
+    prepare: ({ from: i, to: l, context: a }) => {
+      const r = T(a, "from"), c = T(a, "to"), p = tt(document.body, a.positionedParent), d = Ke(t, {
+        ...r,
         top: p.top
       });
       for (const f of [
@@ -1062,25 +1068,25 @@ const Ze = (e = {}) => {
         "bottomLeft",
         "bottomRight"
       ])
-        l.positionedParent.appendChild(d[f]);
+        a.positionedParent.appendChild(d[f]);
       return i.then((f) => {
-        mt(f, c), gt(f, c), f.style.transform = `translateY(${-c.top}px)`;
-      }), r.then((f) => {
-        mt(f, a), gt(f, a), f.style.transform = `translateY(${-a.top + a.height}px) scale(${n})`;
-      }), { borders: d, fromRect: c, toRect: a };
+        wt(f, r), St(f, r), f.style.transform = `translateY(${-r.top}px)`;
+      }), l.then((f) => {
+        wt(f, c), St(f, c), f.style.transform = `translateY(${-c.top + c.height}px) scale(${n})`;
+      }), { borders: d, fromRect: r, toRect: c };
     },
-    animation: ({ from: i, to: r, context: l, borders: c, fromRect: a, toRect: p }) => {
-      const d = ut({
-        rect: a,
+    animation: ({ from: i, to: l, context: a, borders: r, fromRect: c, toRect: p }) => {
+      const d = gt({
+        rect: c,
         scale: n,
         direction: "out",
         override: s
-      }), f = ut({
+      }), f = gt({
         rect: p,
         scale: n,
         direction: "in",
         override: s
-      }), u = X(
+      }), u = Z(
         i,
         d.snapshots,
         d.totalDuration,
@@ -1090,54 +1096,54 @@ const Ze = (e = {}) => {
         () => {
           i.style.clipPath = "", i.style.transformOrigin = "", i.style.transform = "";
         }
-      ), y = X(
-        r,
+      ), y = Z(
+        l,
         f.snapshots,
         f.totalDuration,
         (b) => ({
           transform: `translateY(${b.translateY}px) scale(${b.scale})`
         }),
         () => {
-          r.style.clipPath = "", r.style.transformOrigin = "", r.style.transform = "";
+          l.style.clipPath = "", l.style.transformOrigin = "", l.style.transform = "";
         }
-      ), h = Be.map(([b, x], E) => {
-        const P = ["topLeft", "topRight", "bottomLeft", "bottomRight"][E];
-        return X(
-          c[P],
+      ), h = qe.map(([b, P], _) => {
+        const I = ["topLeft", "topRight", "bottomLeft", "bottomRight"][_];
+        return Z(
+          r[I],
           d.snapshots,
           d.totalDuration,
-          (D) => {
-            const _ = (a.width - a.width * D.scale) / 2 * 0.7 * b, H = (a.height - a.height * D.scale) / 2 * 0.7 * x;
-            return { transform: `translate(${_}px, ${H}px)` };
+          ($) => {
+            const E = (c.width - c.width * $.scale) / 2 * 0.7 * b, z = (c.height - c.height * $.scale) / 2 * 0.7 * P;
+            return { transform: `translate(${E}px, ${z}px)` };
           }
         );
-      }), w = new C([u, y, ...h], {
+      }), S = new x([u, y, ...h], {
         mode: "parallel"
-      }), S = w.onComplete;
-      return w.onComplete = () => {
-        S == null || S();
-        const b = l.positionedParent;
-        for (const x of [
+      }), m = S.onComplete;
+      return S.onComplete = () => {
+        m == null || m();
+        const b = a.positionedParent;
+        for (const P of [
           "topLeft",
           "topRight",
           "bottomLeft",
           "bottomRight"
         ]) {
-          const E = c[x];
-          E.parentElement === b && b.removeChild(E);
+          const _ = r[P];
+          _.parentElement === b && b.removeChild(_);
         }
-      }, w;
+      }, S;
     }
   };
 };
-function Cs(e) {
+function Ps(e) {
   const { paths: t, options: n } = e, s = (n == null ? void 0 : n.borderColor) !== void 0 ? { border: { color: n.borderColor } } : void 0;
-  return v(t, () => Ze(s));
+  return D(t, () => je(s));
 }
-const wt = "data-hero-enter-key", St = "data-hero-exit-key", B = "data-hero-key";
-class qe {
+const bt = "data-hero-enter-key", $t = "data-hero-exit-key", W = "data-hero-key";
+class Ge {
   constructor() {
-    $(this, "previousFromOpacity", "");
+    C(this, "previousFromOpacity", "");
   }
   prepare(t) {
     t.from.then((n) => {
@@ -1150,38 +1156,38 @@ class qe {
     }), [];
   }
 }
-const je = () => new qe();
-class Ke {
+const Je = () => new Ge();
+class Qe {
   contribute(t) {
-    const { from: n, to: s, physics: o, onComplete: i } = t, r = n.style.opacity, l = s.style.opacity, c = n.style.willChange, a = s.style.willChange;
+    const { from: n, to: s, physics: o, onComplete: i } = t, l = n.style.opacity, a = s.style.opacity, r = n.style.willChange, c = s.style.willChange;
     return s.style.opacity = "0", n.style.willChange = "opacity", s.style.willChange = "opacity", i(() => {
-      n.style.opacity = r, s.style.opacity = l, n.style.willChange = c, s.style.willChange = a;
+      n.style.opacity = l, s.style.opacity = a, n.style.willChange = r, s.style.willChange = c;
     }), [
-      new m({
+      new g({
         element: n,
-        integrator: g.from(o),
+        integrator: w.from(o),
         style: (p, d) => ({ opacity: d })
       }),
-      new m({
+      new g({
         element: s,
-        integrator: g.from(o),
+        integrator: w.from(o),
         style: (p) => ({ opacity: p })
       })
     ];
   }
 }
-const Ge = () => new Ke(), Je = {
-  static: je,
-  fade: Ge
-}, Qe = {
+const tn = () => new Qe(), en = {
+  static: Je,
+  fade: tn
+}, nn = {
   spring: { stiffness: 320, damping: 30 }
-}, tn = () => Qe, en = {
+}, sn = () => nn, on = {
   spring: { stiffness: 300, damping: 30, doubleSpring: 1 }
-}, nn = () => en, sn = {
-  default: tn,
-  smooth: nn
-}, on = 700, rn = "data-hero-aspect-ratio", an = "data-hero-radius";
-function ln(e) {
+}, rn = () => on, an = {
+  default: sn,
+  smooth: rn
+}, ln = 700, cn = "data-hero-aspect-ratio", pn = "data-hero-radius";
+function dn(e) {
   if (!e) return null;
   if (e.includes("/")) {
     const [n, s] = e.split("/"), o = parseFloat(n ?? ""), i = parseFloat(s ?? "");
@@ -1190,19 +1196,19 @@ function ln(e) {
   const t = parseFloat(e);
   return Number.isFinite(t) && t > 0 ? t : null;
 }
-function bt(e) {
-  const t = e.getAttribute(an);
+function Ct(e) {
+  const t = e.getAttribute(pn);
   if (!t) return 0;
   const n = parseFloat(t);
   return Number.isFinite(n) && n > 0 ? n : 0;
 }
-function Y(e) {
+function H(e) {
   return e.left + e.width / 2;
 }
-function L(e) {
+function M(e) {
   return e.top + e.height / 2;
 }
-function cn(e, t) {
+function fn(e, t) {
   return {
     top: Math.max(0, t.top - e.top),
     right: Math.max(0, e.left + e.width - (t.left + t.width)),
@@ -1210,7 +1216,7 @@ function cn(e, t) {
     left: Math.max(0, t.left - e.left)
   };
 }
-function pn(e, t, n) {
+function yn(e, t, n) {
   const s = e.width / e.height;
   let o, i;
   return n === "contain" ? s > t ? (i = e.height, o = i * t) : (o = e.width, i = o / t) : s > t ? (o = e.width, i = o / t) : (i = e.height, o = i * t), {
@@ -1220,8 +1226,8 @@ function pn(e, t, n) {
     height: i
   };
 }
-function $t(e, t, n) {
-  const s = J(e, t), o = ln(t.getAttribute(rn));
+function xt(e, t, n) {
+  const s = tt(e, t), o = dn(t.getAttribute(cn));
   if (o === null)
     return {
       bbox: s,
@@ -1229,24 +1235,24 @@ function $t(e, t, n) {
       window: s,
       clipInset: { top: 0, right: 0, bottom: 0, left: 0 }
     };
-  const i = pn(s, o, n), r = n === "cover" ? s : i;
+  const i = yn(s, o, n), l = n === "cover" ? s : i;
   return {
     bbox: s,
     content: i,
-    window: r,
-    clipInset: cn(i, r)
+    window: l,
+    clipInset: fn(i, l)
   };
 }
-function dn(e, t, n, s) {
-  const o = n.width / s, i = n.height / s, r = e.width / 2 + (Y(n) - Y(t)) / s - o / 2, l = e.height / 2 + (L(n) - L(t)) / s - i / 2;
+function hn(e, t, n, s) {
+  const o = n.width / s, i = n.height / s, l = e.width / 2 + (H(n) - H(t)) / s - o / 2, a = e.height / 2 + (M(n) - M(t)) / s - i / 2;
   return {
-    top: Math.max(0, l),
-    right: Math.max(0, e.width - r - o),
-    bottom: Math.max(0, e.height - l - i),
-    left: Math.max(0, r)
+    top: Math.max(0, a),
+    right: Math.max(0, e.width - l - o),
+    bottom: Math.max(0, e.height - a - i),
+    left: Math.max(0, l)
   };
 }
-function A(e, t) {
+function k(e, t) {
   const n = /* @__PURE__ */ new Map(), s = e.querySelectorAll(`[${t}]`);
   for (const o of Array.from(s)) {
     const i = o.getAttribute(t);
@@ -1254,44 +1260,44 @@ function A(e, t) {
   }
   return n;
 }
-function fn(e, t) {
-  const n = [], s = A(t, wt), o = A(e, St);
-  for (const [l, c] of s) {
-    const a = o.get(l);
-    a && n.push({
-      key: l,
-      fromEl: a,
-      toEl: c,
+function un(e, t) {
+  const n = [], s = k(t, bt), o = k(e, $t);
+  for (const [a, r] of s) {
+    const c = o.get(a);
+    c && n.push({
+      key: a,
+      fromEl: c,
+      toEl: r,
       fromFit: "cover",
       toFit: "contain"
     });
   }
-  const i = A(e, wt), r = A(t, St);
-  for (const [l, c] of i) {
-    const a = r.get(l);
-    a && n.push({
-      key: l,
-      fromEl: c,
-      toEl: a,
+  const i = k(e, bt), l = k(t, $t);
+  for (const [a, r] of i) {
+    const c = l.get(a);
+    c && n.push({
+      key: a,
+      fromEl: r,
+      toEl: c,
       fromFit: "contain",
       toFit: "cover"
     });
   }
   return n;
 }
-function yn(e, t) {
+function mn(e, t) {
   const n = [], s = Array.from(
-    t.querySelectorAll(`[${B}]`)
+    t.querySelectorAll(`[${W}]`)
   );
   for (const o of s) {
-    const i = o.getAttribute(B);
+    const i = o.getAttribute(W);
     if (!i) continue;
-    const r = e.querySelector(
-      `[${B}="${i}"]`
+    const l = e.querySelector(
+      `[${W}="${i}"]`
     );
-    r && n.push({
+    l && n.push({
       key: i,
-      fromEl: r,
+      fromEl: l,
       toEl: o,
       fromFit: "contain",
       toFit: "contain"
@@ -1299,104 +1305,104 @@ function yn(e, t) {
   }
   return n;
 }
-function hn(e, t) {
-  const n = fn(e, t);
-  return n.length > 0 ? n : yn(e, t);
+function gn(e, t) {
+  const n = un(e, t);
+  return n.length > 0 ? n : mn(e, t);
 }
-function un(e, t, n) {
-  const { fromEl: s, toEl: o } = t, i = $t(e, s, t.fromFit), r = $t(e, o, t.toFit), l = i.content, c = i.window, a = r.content, p = r.window, d = r.clipInset, f = bt(s), u = bt(o);
-  if (l.width === 0 || l.height === 0 || c.width === 0 || c.height === 0 || a.width === 0 || a.height === 0 || p.width === 0 || p.height === 0)
+function wn(e, t, n) {
+  const { fromEl: s, toEl: o } = t, i = xt(e, s, t.fromFit), l = xt(e, o, t.toFit), a = i.content, r = i.window, c = l.content, p = l.window, d = l.clipInset, f = Ct(s), u = Ct(o);
+  if (a.width === 0 || a.height === 0 || r.width === 0 || r.height === 0 || c.width === 0 || c.height === 0 || p.width === 0 || p.height === 0)
     return null;
   const y = Math.max(
-    l.width / a.width,
-    l.height / a.height
-  ), h = Y(l), w = L(l), S = Y(a), b = L(a), x = h - S, E = w - b;
-  if (Math.abs(E) > n) return null;
-  const P = dn(
-    a,
-    l,
+    a.width / c.width,
+    a.height / c.height
+  ), h = H(a), S = M(a), m = H(c), b = M(c), P = h - m, _ = S - b;
+  if (Math.abs(_) > n) return null;
+  const I = hn(
     c,
+    a,
+    r,
     y
   );
   return {
-    toContent: a,
+    toContent: c,
     hasRadius: f > 0 || u > 0,
-    styleFor: (D, _) => {
-      const H = _ * x, At = _ * E, Q = D + _ * y, Ft = (f * _ + u * D) / Q, kt = P.top * _ + d.top * D, Yt = P.right * _ + d.right * D, Lt = P.bottom * _ + d.bottom * D, Ht = P.left * _ + d.left * D;
+    styleFor: ($, E) => {
+      const z = E * P, kt = E * _, et = $ + E * y, Yt = (f * E + u * $) / et, Lt = I.top * E + d.top * $, Ht = I.right * E + d.right * $, Mt = I.bottom * E + d.bottom * $, zt = I.left * E + d.left * $;
       return {
-        transform: `translate(${H}px, ${At}px) scale(${Q})`,
-        clipPath: `inset(${kt}px ${Yt}px ${Lt}px ${Ht}px round ${Ft}px)`
+        transform: `translate(${z}px, ${kt}px) scale(${et})`,
+        clipPath: `inset(${Lt}px ${Ht}px ${Mt}px ${zt}px round ${Yt}px)`
       };
     }
   };
 }
-function mn(e, t) {
+function Sn(e, t) {
   e.style.transform = t.transform, e.style.clipPath = t.clipPath;
 }
-class gn {
+class bn {
   contribute(t) {
-    const { resolved: n, physics: s, positionedParent: o, maxDistance: i, onComplete: r } = t, l = [];
-    for (const c of n.pairs) {
-      const { fromEl: a, toEl: p } = c, d = un(o, c, i);
+    const { resolved: n, physics: s, positionedParent: o, maxDistance: i, onComplete: l } = t, a = [];
+    for (const r of n.pairs) {
+      const { fromEl: c, toEl: p } = r, d = wn(o, r, i);
       if (!d) continue;
       const f = p.cloneNode(!0);
-      f.style.position = "absolute", f.style.left = `${d.toContent.left}px`, f.style.top = `${d.toContent.top}px`, f.style.width = `${d.toContent.width}px`, f.style.height = `${d.toContent.height}px`, f.style.margin = "0", f.style.transformOrigin = "center center", f.style.zIndex = "1000", f.style.willChange = "transform, clip-path", f.style.pointerEvents = "none", f.style.maxWidth = "none", f.style.maxHeight = "none", d.hasRadius && (f.style.borderRadius = "0"), mn(f, d.styleFor(0, 1)), o.appendChild(f);
-      const u = a.style.opacity, y = p.style.opacity;
-      a.style.opacity = "0", p.style.opacity = "0", r(() => {
-        a.style.opacity = u, p.style.opacity = y, f.parentElement && f.parentElement.removeChild(f);
-      }), l.push(
-        new m({
+      f.style.position = "absolute", f.style.left = `${d.toContent.left}px`, f.style.top = `${d.toContent.top}px`, f.style.width = `${d.toContent.width}px`, f.style.height = `${d.toContent.height}px`, f.style.margin = "0", f.style.transformOrigin = "center center", f.style.zIndex = "1000", f.style.willChange = "transform, clip-path", f.style.pointerEvents = "none", f.style.maxWidth = "none", f.style.maxHeight = "none", d.hasRadius && (f.style.borderRadius = "0"), Sn(f, d.styleFor(0, 1)), o.appendChild(f);
+      const u = c.style.opacity, y = p.style.opacity;
+      c.style.opacity = "0", p.style.opacity = "0", l(() => {
+        c.style.opacity = u, p.style.opacity = y, f.parentElement && f.parentElement.removeChild(f);
+      }), a.push(
+        new g({
           element: f,
-          integrator: g.from(s),
+          integrator: w.from(s),
           style: d.styleFor
         })
       );
     }
-    return l;
+    return a;
   }
 }
-function wn(e) {
-  return [new gn(), Je[e.type]()];
+function $n(e) {
+  return [new bn(), en[e.type]()];
 }
-const Sn = (e) => {
-  const t = wn(e), n = sn[e.variant](), s = on;
+const Cn = (e) => {
+  const t = $n(e), n = an[e.variant](), s = ln;
   return {
     prepare: (o) => {
-      var l;
+      var a;
       const i = Promise.all([
         o.from,
         o.to
-      ]).then(([c, a]) => ({ pairs: hn(c, a) })), r = {
+      ]).then(([r, c]) => ({ pairs: gn(r, c) })), l = {
         from: o.from,
         to: o.to,
         resolved: i
       };
-      for (const c of t)
-        (l = c.prepare) == null || l.call(c, r);
-      return i.then((c) => ({ resolved: c }));
+      for (const r of t)
+        (a = r.prepare) == null || a.call(r, l);
+      return i.then((r) => ({ resolved: r }));
     },
-    animation: ({ from: o, to: i, context: r, resolved: l }) => {
-      if (l.pairs.length === 0)
-        return new C([], { mode: "parallel" });
-      const c = [], a = (y) => {
-        c.push(y);
+    animation: ({ from: o, to: i, context: l, resolved: a }) => {
+      if (a.pairs.length === 0)
+        return new x([], { mode: "parallel" });
+      const r = [], c = (y) => {
+        r.push(y);
       }, p = {
         from: o,
         to: i,
-        resolved: l,
+        resolved: a,
         physics: n,
-        positionedParent: r.positionedParent,
+        positionedParent: l.positionedParent,
         maxDistance: s,
-        onComplete: a
+        onComplete: c
       }, d = [];
       for (const y of t)
         y.contribute && d.push(...y.contribute(p));
       if (d.length === 0)
-        return new C([], { mode: "parallel" });
-      const f = new C(d, { mode: "parallel" }), u = f.onComplete;
+        return new x([], { mode: "parallel" });
+      const f = new x(d, { mode: "parallel" }), u = f.onComplete;
       return f.onComplete = () => {
         u == null || u();
-        for (const y of c)
+        for (const y of r)
           try {
             y();
           } catch (h) {
@@ -1406,33 +1412,33 @@ const Sn = (e) => {
     }
   };
 };
-function Es(e) {
+function _s(e) {
   const { paths: t } = e, n = e.type ?? "static", s = e.variant ?? "default";
-  return v(
+  return D(
     t,
-    () => Sn({ type: n, variant: s })
+    () => Cn({ type: n, variant: s })
   );
 }
-const bn = {
+const xn = {
   spring: { stiffness: 50, damping: 30 }
-}, $n = {
+}, En = {
   spring: { stiffness: 80, damping: 25 }
-}, Cn = (e = {}) => {
-  const t = e.physics ?? bn, n = e.initialRotation ?? 45, s = e.initialScale ?? 0.01, o = e.rotationTriggerPoint ?? 0.8;
+}, Pn = (e = {}) => {
+  const t = e.physics ?? xn, n = e.initialRotation ?? 45, s = e.initialScale ?? 0.01, o = e.rotationTriggerPoint ?? 0.8;
   return {
-    prepare: ({ from: i, to: r, context: l }) => (i.then((c) => {
-      c.style.opacity = "1";
-    }), r.then((c) => {
-      const a = I(l, "to"), p = Math.min(a.width, a.height) * 0.4;
-      c.style.setProperty("--max-border-radius", `${p}px`), c.style.setProperty("--border-radius-scale", "1"), c.style.willChange = "transform", c.style.backfaceVisibility = "hidden";
-      const d = a.left + a.width / 2, f = a.top + a.height / 2;
-      c.style.transformOrigin = `${d}px ${f}px`, c.style.position = "fixed", c.style.top = `${a.top}px`, c.style.left = `${a.left}px`, c.style.width = `${a.width}px`, c.style.height = `${a.height}px`, c.style.zIndex = "1000", c.style.overflow = "hidden", c.style.transform = `rotate(${n}deg) scale(${s}) translateZ(0)`, c.style.borderRadius = "calc(var(--max-border-radius) * var(--border-radius-scale))", c.style.opacity = "1";
+    prepare: ({ from: i, to: l, context: a }) => (i.then((r) => {
+      r.style.opacity = "1";
+    }), l.then((r) => {
+      const c = T(a, "to"), p = Math.min(c.width, c.height) * 0.4;
+      r.style.setProperty("--max-border-radius", `${p}px`), r.style.setProperty("--border-radius-scale", "1"), r.style.willChange = "transform", r.style.backfaceVisibility = "hidden";
+      const d = c.left + c.width / 2, f = c.top + c.height / 2;
+      r.style.transformOrigin = `${d}px ${f}px`, r.style.position = "fixed", r.style.top = `${c.top}px`, r.style.left = `${c.left}px`, r.style.width = `${c.width}px`, r.style.height = `${c.height}px`, r.style.zIndex = "1000", r.style.overflow = "hidden", r.style.transform = `rotate(${n}deg) scale(${s}) translateZ(0)`, r.style.borderRadius = "calc(var(--max-border-radius) * var(--border-radius-scale))", r.style.opacity = "1";
     }), {}),
-    animation: ({ from: i, to: r }) => {
-      const l = new m({
+    animation: ({ from: i, to: l }) => {
+      const a = new g({
         element: i,
-        integrator: g.from($n),
-        style: (a, p) => ({ opacity: p }),
+        integrator: w.from(En),
+        style: (c, p) => ({ opacity: p }),
         // The outgoing node is reused (re-hidden, shown again on the next
         // navigation), so reset every inline style we wrote to it — mirroring
         // the "to" cleanup below. prepare sets opacity and the out style fades
@@ -1440,33 +1446,33 @@ const bn = {
         onComplete: () => {
           i.style.opacity = "";
         }
-      }), c = new m({
-        element: r,
-        integrator: g.from(t),
-        style: (a) => {
+      }), r = new g({
+        element: l,
+        integrator: w.from(t),
+        style: (c) => {
           let p;
-          if (a <= 0.05)
+          if (c <= 0.05)
             p = s;
-          else if (a <= o) {
-            const y = (a - 0.05) / (o - 0.05), h = Math.pow(y, 9);
+          else if (c <= o) {
+            const y = (c - 0.05) / (o - 0.05), h = Math.pow(y, 9);
             p = s + (0.8 - s) * h;
           } else {
-            const y = (a - o) / (1 - o);
+            const y = (c - o) / (1 - o);
             p = 0.8 + 0.2 * (1 - Math.pow(1 - y, 3));
           }
           const d = 0.7;
           let f;
-          if (a <= d)
+          if (c <= d)
             f = n;
           else {
-            const y = (a - d) / (1 - d), h = 1 - Math.pow(1 - y, 2);
+            const y = (c - d) / (1 - d), h = 1 - Math.pow(1 - y, 2);
             f = n * (1 - h);
           }
           let u;
-          if (a <= d)
+          if (c <= d)
             u = 1;
           else {
-            const y = (a - d) / (1 - d);
+            const y = (c - d) / (1 - d);
             u = 1 - Math.pow(y, 0.5);
           }
           return {
@@ -1475,21 +1481,21 @@ const bn = {
           };
         },
         onComplete: () => {
-          r.style.willChange = "", r.style.backfaceVisibility = "", r.style.removeProperty("--max-border-radius"), r.style.removeProperty("--border-radius-scale"), r.style.transform = "", r.style.transformOrigin = "", r.style.position = "", r.style.zIndex = "", r.style.top = "", r.style.left = "", r.style.width = "", r.style.height = "", r.style.overflow = "", r.style.borderRadius = "";
+          l.style.willChange = "", l.style.backfaceVisibility = "", l.style.removeProperty("--max-border-radius"), l.style.removeProperty("--border-radius-scale"), l.style.transform = "", l.style.transformOrigin = "", l.style.position = "", l.style.zIndex = "", l.style.top = "", l.style.left = "", l.style.width = "", l.style.height = "", l.style.overflow = "", l.style.borderRadius = "";
         }
       });
-      return new C([l, c], { mode: "parallel" });
+      return new x([a, r], { mode: "parallel" });
     }
   };
 };
-function xs(e) {
+function Is(e) {
   const { paths: t } = e;
-  return v(t, () => Cn());
+  return D(t, () => Pn());
 }
-const En = {
+const _n = {
   spring: { stiffness: 100, damping: 30 }
-}, xn = (e = {}) => {
-  const t = e.physics ?? En;
+}, In = (e = {}) => {
+  const t = e.physics ?? _n;
   return {
     prepare: ({ from: n, to: s }) => (n.then((o) => {
       o.style.transformOrigin = "center center", o.style.willChange = "transform, opacity";
@@ -1497,12 +1503,12 @@ const En = {
       o.style.opacity = "0", o.style.transform = "rotate(-180deg)", o.style.transformOrigin = "center center", o.style.willChange = "transform, opacity";
     }), {}),
     animation: ({ from: n, to: s }) => {
-      const o = new m({
+      const o = new g({
         element: n,
-        integrator: g.from(t),
-        style: (r) => ({
-          transform: `rotate(${r * 180}deg)`,
-          opacity: r < 0.5 ? 1 : 0
+        integrator: w.from(t),
+        style: (l) => ({
+          transform: `rotate(${l * 180}deg)`,
+          opacity: l < 0.5 ? 1 : 0
         }),
         // The outgoing node is reused (re-hidden, shown again on the next
         // navigation), so clear every inline style we wrote to `from`
@@ -1510,27 +1516,27 @@ const En = {
         onComplete: () => {
           n.style.willChange = "auto", n.style.transform = "", n.style.transformOrigin = "", n.style.opacity = "";
         }
-      }), i = new m({
+      }), i = new g({
         element: s,
-        integrator: g.from(t),
+        integrator: w.from(t),
         // u runs 1→0, so -u*180 unwinds -180→0.
-        style: (r, l) => ({
-          transform: `rotate(${-l * 180}deg)`,
-          opacity: r > 0.5 ? 1 : 0
+        style: (l, a) => ({
+          transform: `rotate(${-a * 180}deg)`,
+          opacity: l > 0.5 ? 1 : 0
         }),
         onComplete: () => {
           s.style.willChange = "auto", s.style.transform = "", s.style.transformOrigin = "", s.style.opacity = "";
         }
       });
-      return new C([o, i], { mode: "parallel" });
+      return new x([o, i], { mode: "parallel" });
     }
   };
 };
-function Ps(e) {
+function Ds(e) {
   const { paths: t } = e;
-  return v(t, () => xn());
+  return D(t, () => In());
 }
-const Pn = {
+const Dn = {
   spring: {
     stiffness: 20,
     damping: 8,
@@ -1538,81 +1544,87 @@ const Pn = {
     restDelta: 1e-3,
     restSpeed: 1e-3
   }
-}, Ct = (e = {}) => {
-  const t = e.direction ?? "up", n = e.physics ?? Pn, s = t === "up";
+}, Et = (e = {}) => {
+  const t = e.direction ?? "up", n = e.physics ?? Dn, s = t === "up", o = s ? v : O, i = s ? O : v;
   return {
-    prepare: ({ from: o, to: i }) => (o.then((r) => {
-      r.style.zIndex = s ? "-1" : "1", r.style.willChange = "transform", r.style.backfaceVisibility = "hidden", r.style.contain = "layout paint", r.style.pointerEvents = "none";
-    }), i.then((r) => {
-      r.style.willChange = "transform", r.style.backfaceVisibility = "hidden", r.style.contain = "layout paint";
+    prepare: ({ from: l, to: a }) => (l.then((r) => {
+      r.style.zIndex = o, r.style.willChange = "transform", r.style.backfaceVisibility = "hidden", r.style.contain = "layout paint", r.style.pointerEvents = "none";
+    }), a.then((r) => {
+      r.style.willChange = "transform", r.style.backfaceVisibility = "hidden", r.style.contain = "layout paint", r.style.position = "relative", r.style.zIndex = i;
     }), {}),
-    animation: ({ from: o, to: i }) => {
-      const r = o.offsetHeight, l = i.offsetHeight, c = window.innerHeight, a = Math.max(Math.min(r, l), c), p = new m({
-        element: o,
-        integrator: g.from(n),
-        style: (f) => ({ transform: `translate3d(0, ${s ? -a * f : a * f}px, 0)` }),
+    animation: ({ from: l, to: a }) => {
+      const r = l.offsetHeight, c = a.offsetHeight, p = window.innerHeight, d = Math.max(Math.min(r, c), p), f = new g({
+        element: l,
+        integrator: w.from(n),
+        style: (y) => ({ transform: `translate3d(0, ${s ? -d * y : d * y}px, 0)` }),
         // The outgoing node is the real, reused element (re-hidden then shown
         // again on the next navigation), so mirror the incoming cleanup and
         // also reset the out-only props applied in prepare (zIndex,
         // pointerEvents) — otherwise the leftover inline styles corrupt the
         // page the next time it appears.
         onComplete: () => {
-          o.style.willChange = "auto", o.style.backfaceVisibility = "", o.style.contain = "", o.style.transform = "", o.style.pointerEvents = "", o.style.zIndex = "";
+          l.style.willChange = "auto", l.style.backfaceVisibility = "", l.style.contain = "", l.style.transform = "", l.style.pointerEvents = "", l.style.zIndex = "";
         }
-      }), d = new m({
-        element: i,
-        integrator: g.from(n),
-        style: (f, u) => ({ transform: `translate3d(0, ${s ? u * a : u * -a}px, 0)` }),
+      }), u = new g({
+        element: a,
+        integrator: w.from(n),
+        style: (y, h) => ({ transform: `translate3d(0, ${s ? h * d : h * -d}px, 0)` }),
         onComplete: () => {
-          i.style.willChange = "auto", i.style.backfaceVisibility = "", i.style.contain = "", i.style.transform = "";
+          a.style.willChange = "auto", a.style.backfaceVisibility = "", a.style.contain = "", a.style.transform = "", a.style.position === "relative" && (a.style.position = ""), a.style.zIndex === i && (a.style.zIndex = "");
         }
       });
-      return new C([p, d], { mode: "parallel" });
+      for (const y of [f, u]) {
+        const h = y.onComplete;
+        y.onComplete = () => {
+          h == null || h(), y.releaseFill();
+        };
+      }
+      return new x([f, u], { mode: "parallel" });
     }
   };
 };
-function _s(e) {
+function vs(e) {
   const { paths: t, type: n = "directional" } = e;
-  return n === "non-directional" ? v(
+  return n === "non-directional" ? D(
     t,
-    () => Ct({ direction: "up" })
-  ) : G(
+    () => Et({ direction: "up" })
+  ) : Q(
     t,
     { forward: "up", backward: "down" },
-    (s) => Ct({ direction: s })
+    (s) => Et({ direction: s })
   );
 }
-const _n = {
+const vn = {
   spring: { stiffness: 200, damping: 24 }
-}, Dn = {
+}, On = {
   inertia: { acceleration: 25, resistance: 1.2 }
-}, W = 0.2;
-function vn() {
+}, q = 0.2;
+function Tn() {
   return {
-    enterPhysics: _n,
-    exitPhysics: Dn,
+    enterPhysics: vn,
+    exitPhysics: On,
     background: {
       willChange: "transform, opacity",
       enterStyle: (e, t) => ({
-        transform: `scale(${1 - W * e})`,
+        transform: `scale(${1 - q * e})`,
         opacity: t
       }),
       exitStyle: (e) => ({
-        transform: `scale(${1 - W + W * e})`,
+        transform: `scale(${1 - q + q * e})`,
         opacity: e
       })
     }
   };
 }
-const In = {
+const An = {
   spring: { stiffness: 300, damping: 30 }
-}, Tn = {
+}, Fn = {
   inertia: { acceleration: 30, resistance: 1 }
 };
-function On() {
+function kn() {
   return {
-    enterPhysics: In,
-    exitPhysics: Tn,
+    enterPhysics: An,
+    exitPhysics: Fn,
     background: {
       willChange: "",
       enterStyle: () => ({}),
@@ -1620,137 +1632,142 @@ function On() {
     }
   };
 }
-const An = {
-  static: On(),
-  "background-scale": vn()
-}, Fn = "static", kn = "transform", Yn = (e = {}) => {
-  const t = e.direction ?? "enter", n = An[e.type ?? Fn], s = t === "enter" ? n.enterPhysics : n.exitPhysics, o = n.background, i = o.willChange !== "";
+const Yn = {
+  static: kn(),
+  "background-scale": Tn()
+}, Ln = "static", Hn = "transform", Mn = (e = {}) => {
+  const t = e.direction ?? "enter", n = Yn[e.type ?? Ln], s = t === "enter" ? n.enterPhysics : n.exitPhysics, o = n.background, i = o.willChange !== "";
   return {
-    prepare: ({ from: r, to: l }) => {
-      const c = t === "enter" ? l : r, a = t === "enter" ? r : l;
-      return c.then((p) => {
-        p.style.willChange = kn, p.style.backfaceVisibility = "hidden", p.style.contain = "layout paint", t === "exit" && (p.style.pointerEvents = "none", p.style.zIndex = "100");
-      }), a.then((p) => {
-        i && (p.style.willChange = o.willChange, p.style.backfaceVisibility = "hidden", p.style.contain = "layout paint"), t === "enter" && (p.style.pointerEvents = "none", p.style.zIndex = "-1");
+    prepare: ({ from: l, to: a }) => {
+      const r = t === "enter" ? a : l, c = t === "enter" ? l : a;
+      return r.then((p) => {
+        p.style.willChange = Hn, p.style.backfaceVisibility = "hidden", p.style.contain = "layout paint", p.style.zIndex = O, t === "enter" ? p.style.position = "relative" : p.style.pointerEvents = "none";
+      }), c.then((p) => {
+        i && (p.style.willChange = o.willChange, p.style.backfaceVisibility = "hidden", p.style.contain = "layout paint"), p.style.zIndex = v, t === "enter" ? p.style.pointerEvents = "none" : p.style.position = "relative";
       }), {};
     },
-    animation: ({ from: r, to: l, context: c }) => {
-      const a = t === "enter" ? l : r, p = t === "enter" ? r : l, d = I(
-        c,
+    animation: ({ from: l, to: a, context: r }) => {
+      const c = t === "enter" ? a : l, p = t === "enter" ? l : a, d = T(
+        r,
         t === "enter" ? "to" : "from"
       ), f = () => {
-        r.style.pointerEvents = "", r.style.zIndex = "";
+        l.style.pointerEvents = "", l.style.zIndex = "";
+      }, u = () => {
+        const $ = t === "enter" ? O : v;
+        a.style.position === "relative" && (a.style.position = ""), a.style.zIndex === $ && (a.style.zIndex = "");
+      }, y = ($) => {
+        const E = $.onComplete;
+        $.onComplete = () => {
+          E == null || E(), $.releaseFill();
+        };
       };
-      a.style.clipPath = `inset(${d.top}px 0 calc(100% - ${d.top + d.height}px) 0)`;
-      const u = t === "enter" ? (E, P) => ({
-        transform: `translate3d(0, ${P * d.height}px, 0)`
-      }) : (E) => ({
+      c.style.clipPath = `inset(${d.top}px 0 calc(100% - ${d.top + d.height}px) 0)`;
+      const h = t === "enter" ? ($, E) => ({
         transform: `translate3d(0, ${E * d.height}px, 0)`
-      }), y = new m({
-        element: a,
-        integrator: g.from(s),
-        style: u,
+      }) : ($) => ({
+        transform: `translate3d(0, ${$ * d.height}px, 0)`
+      }), S = new g({
+        element: c,
+        integrator: w.from(s),
+        style: h,
         onComplete: () => {
-          a.style.willChange = "auto", a.style.backfaceVisibility = "", a.style.contain = "", a.style.clipPath = "", a.style.transform = "", f();
+          c.style.willChange = "auto", c.style.backfaceVisibility = "", c.style.contain = "", c.style.clipPath = "", c.style.transform = "", f(), u();
         }
       });
-      if (!i)
-        return new C([y], { mode: "parallel" });
-      const h = I(
-        c,
+      if (y(S), !i)
+        return new x([S], { mode: "parallel" });
+      const m = T(
+        r,
         t === "enter" ? "from" : "to"
-      ), w = h.left + h.width / 2, S = h.top + h.height / 2;
-      p.style.clipPath = `inset(${h.top}px 0 calc(100% - ${h.top + h.height}px) 0)`, p.style.transformOrigin = `${w}px ${S}px`;
-      const b = t === "enter" ? (E, P) => o.enterStyle(E, P) : (E) => o.exitStyle(E), x = new m({
+      ), b = m.left + m.width / 2, P = m.top + m.height / 2;
+      p.style.clipPath = `inset(${m.top}px 0 calc(100% - ${m.top + m.height}px) 0)`, p.style.transformOrigin = `${b}px ${P}px`;
+      const _ = t === "enter" ? ($, E) => o.enterStyle($, E) : ($) => o.exitStyle($), I = new g({
         element: p,
-        integrator: g.from(s),
-        style: b,
-        // On `exit` the background is the incoming (`to`) node; on `enter` it is
-        // the reused outgoing (`from`) node — in both cases its inline styles
-        // must be restored when the animation settles, so the reused node is
-        // not left scaled/faded/clipped the next time it is shown. The `enter`
-        // branch mirrors the `exit` cleanup and additionally clears the
-        // transform/opacity final frame WAAPI leaves behind.
-        onComplete: t === "exit" ? () => {
-          p.style.willChange = "auto", p.style.backfaceVisibility = "", p.style.contain = "", p.style.clipPath = "", p.style.transformOrigin = "";
-        } : () => {
+        integrator: w.from(s),
+        style: _,
+        // The background is the reused outgoing (`from`) node on `enter` and the
+        // surviving incoming (`to`) node on `exit` — in both cases its inline
+        // styles must be cleared on settle so the reused node is not left
+        // scaled/faded/clipped the next time it is shown. releaseFill below
+        // drops the WAAPI fill so these resets actually take effect.
+        onComplete: () => {
           p.style.willChange = "auto", p.style.backfaceVisibility = "", p.style.contain = "", p.style.clipPath = "", p.style.transformOrigin = "", p.style.transform = "", p.style.opacity = "";
         }
       });
-      return new C([y, x], { mode: "parallel" });
+      return y(I), new x([S, I], { mode: "parallel" });
     }
   };
 };
-function Ln(e) {
+function zn(e) {
   return e === "scale" || e === "background-scale" ? "background-scale" : "static";
 }
-function Ds(e) {
-  const { enter: t, exit: n } = e, s = e.type, o = Ln(s);
-  return vt(
+function Os(e) {
+  const { enter: t, exit: n } = e, s = e.type, o = zn(s);
+  return Ot(
     { enter: t, exit: n },
-    (i) => Yn({ direction: i, type: o })
+    (i) => Mn({ direction: i, type: o })
   );
 }
-const Hn = {
+const Rn = {
   spring: { stiffness: 170, damping: 22, doubleSpring: 0.8 }
-}, Mn = (e = {}) => {
-  const t = e.direction ?? "left", n = e.physics ?? Hn, s = t === "left";
+}, Un = (e = {}) => {
+  const t = e.direction ?? "left", n = e.physics ?? Rn, s = t === "left";
   return {
-    prepare: ({ from: o, to: i }) => (o.then((r) => {
-      r.style.willChange = "transform", r.style.backfaceVisibility = "hidden", r.style.contain = "layout paint", r.style.pointerEvents = "none";
-    }), i.then((r) => {
-      const l = s ? 100 : -100;
-      r.style.transform = `translate3d(${l}%, 0, 0)`, r.style.willChange = "transform", r.style.backfaceVisibility = "hidden", r.style.contain = "layout paint";
+    prepare: ({ from: o, to: i }) => (o.then((l) => {
+      l.style.willChange = "transform", l.style.backfaceVisibility = "hidden", l.style.contain = "layout paint", l.style.pointerEvents = "none";
+    }), i.then((l) => {
+      const a = s ? 100 : -100;
+      l.style.transform = `translate3d(${a}%, 0, 0)`, l.style.willChange = "transform", l.style.backfaceVisibility = "hidden", l.style.contain = "layout paint";
     }), {}),
     animation: ({ from: o, to: i }) => {
-      const r = new m({
+      const l = new g({
         element: o,
-        integrator: g.from(n),
-        style: (c) => ({ transform: `translate3d(${s ? -100 * c : 100 * c}%, 0, 0)` }),
+        integrator: w.from(n),
+        style: (r) => ({ transform: `translate3d(${s ? -100 * r : 100 * r}%, 0, 0)` }),
         // The outgoing node is the real Activity page and gets reused on the
         // next navigation, so reset every inline style we wrote to it (mirror
         // the incoming cleanup, plus the out-only pointerEvents).
         onComplete: () => {
           o.style.willChange = "auto", o.style.backfaceVisibility = "", o.style.contain = "", o.style.transform = "", o.style.pointerEvents = "";
         }
-      }), l = new m({
+      }), a = new g({
         element: i,
-        integrator: g.from(n),
-        style: (c, a) => ({ transform: `translate3d(${s ? a * 100 : a * -100}%, 0, 0)` }),
+        integrator: w.from(n),
+        style: (r, c) => ({ transform: `translate3d(${s ? c * 100 : c * -100}%, 0, 0)` }),
         onComplete: () => {
           i.style.willChange = "auto", i.style.backfaceVisibility = "", i.style.contain = "", i.style.transform = "";
         }
       });
-      return new C([r, l], { mode: "parallel" });
+      return new x([l, a], { mode: "parallel" });
     }
   };
 };
-function vs(e) {
+function Ts(e) {
   const { paths: t } = e;
-  return G(
+  return Q(
     t,
     { forward: "left", backward: "right" },
-    (n) => Mn({ direction: n })
+    (n) => Un({ direction: n })
   );
 }
-const Un = {
+const Vn = {
   spring: { stiffness: 17, damping: 6 }
-}, Z = 20, F = 800, Rn = (e = {}) => {
-  const t = e.physics ?? Un;
+}, K = 20, Y = 800, Nn = (e = {}) => {
+  const t = e.physics ?? Vn;
   return {
     prepare: ({ from: n, to: s }) => (n.then((o) => {
-      o.style.willChange = "transform", o.style.backfaceVisibility = "hidden", o.style.contain = "layout paint", o.style.pointerEvents = "none", o.style.transform = `perspective(${F}px) rotateY(0deg) translate3d(0%, 0, 0)`;
+      o.style.willChange = "transform", o.style.backfaceVisibility = "hidden", o.style.contain = "layout paint", o.style.pointerEvents = "none", o.style.transform = `perspective(${Y}px) rotateY(0deg) translate3d(0%, 0, 0)`;
     }), s.then((o) => {
-      o.style.willChange = "transform", o.style.backfaceVisibility = "hidden", o.style.contain = "layout paint", o.style.transform = `perspective(${F}px) rotateY(${Z}deg) translate3d(-100%, 0, 0)`;
+      o.style.willChange = "transform", o.style.backfaceVisibility = "hidden", o.style.contain = "layout paint", o.style.transform = `perspective(${Y}px) rotateY(${K}deg) translate3d(-100%, 0, 0)`;
     }), {}),
     animation: ({ from: n, to: s }) => {
-      const o = new m({
+      const o = new g({
         element: n,
-        integrator: g.from(t),
-        style: (r) => {
-          const l = -r * Z, c = r * 100;
+        integrator: w.from(t),
+        style: (l) => {
+          const a = -l * K, r = l * 100;
           return {
-            transform: `perspective(${F}px) rotateY(${l}deg) translate3d(${c}%, 0, 0)`
+            transform: `perspective(${Y}px) rotateY(${a}deg) translate3d(${r}%, 0, 0)`
           };
         },
         // The outgoing node is reused (Activity/cacheComponents re-hide it),
@@ -1759,28 +1776,28 @@ const Un = {
         onComplete: () => {
           n.style.transform = "", n.style.willChange = "auto", n.style.backfaceVisibility = "", n.style.contain = "", n.style.pointerEvents = "";
         }
-      }), i = new m({
+      }), i = new g({
         element: s,
-        integrator: g.from(t),
-        style: (r, l) => {
-          const c = l * Z, a = -l * 100;
+        integrator: w.from(t),
+        style: (l, a) => {
+          const r = a * K, c = -a * 100;
           return {
-            transform: `perspective(${F}px) rotateY(${c}deg) translate3d(${a}%, 0, 0)`
+            transform: `perspective(${Y}px) rotateY(${r}deg) translate3d(${c}%, 0, 0)`
           };
         },
         onComplete: () => {
           s.style.transform = "", s.style.willChange = "auto", s.style.backfaceVisibility = "", s.style.contain = "";
         }
       });
-      return new C([o, i], { mode: "sequence" });
+      return new x([o, i], { mode: "sequence" });
     }
   };
 };
-function Is(e) {
+function As(e) {
   const { paths: t } = e;
-  return v(t, () => Rn());
+  return D(t, () => Nn());
 }
-function Vn({
+function Xn({
   enterRect: e,
   exitRect: t,
   pageRect: n,
@@ -1788,19 +1805,19 @@ function Vn({
   enterRadius: o,
   exitRadius: i
 }) {
-  const r = t.left - e.left + (t.width - e.width) / 2 - s.x, l = t.top - e.top + (t.height - e.height) / 2 - s.y, c = t.width / e.width, a = t.height / e.height, p = e.top / n.height * 100, d = (n.width - (e.left + e.width)) / n.width * 100, f = (n.height - (e.top + e.height)) / n.height * 100, u = e.left / n.width * 100;
+  const l = t.left - e.left + (t.width - e.width) / 2 - s.x, a = t.top - e.top + (t.height - e.height) / 2 - s.y, r = t.width / e.width, c = t.height / e.height, p = e.top / n.height * 100, d = (n.width - (e.left + e.width)) / n.width * 100, f = (n.height - (e.top + e.height)) / n.height * 100, u = e.left / n.width * 100;
   return {
     transformOrigin: `${e.left + e.width / 2}px ${e.top + e.height / 2}px`,
     animate: (y) => {
-      const h = 1 - y, w = 1 + (c - 1) * h, S = 1 + (a - 1) * h, x = (i * h + o * (1 - h)) / ((w + S) / 2);
+      const h = 1 - y, S = 1 + (r - 1) * h, m = 1 + (c - 1) * h, P = (i * h + o * (1 - h)) / ((S + m) / 2);
       return {
-        clipPath: `inset(${p * h}% ${d * h}% ${f * h}% ${u * h}% round ${x}px)`,
-        transform: `translate(${r * h}px, ${l * h}px) scale(${w}, ${S})`
+        clipPath: `inset(${p * h}% ${d * h}% ${f * h}% ${u * h}% round ${P}px)`,
+        transform: `translate(${l * h}px, ${a * h}px) scale(${S}, ${m})`
       };
     }
   };
 }
-function zn({
+function Bn({
   enterRect: e,
   exitRect: t,
   pageRect: n,
@@ -1808,187 +1825,183 @@ function zn({
   enterRadius: o,
   exitRadius: i
 }) {
-  const r = t.left - e.left + (t.width - e.width) / 2 + s.x, l = t.top - e.top + (t.height - e.height) / 2 + s.y, c = t.width / e.width, a = t.height / e.height, p = e.top / n.height * 100, d = (n.width - (e.left + e.width)) / n.width * 100, f = (n.height - (e.top + e.height)) / n.height * 100, u = e.left / n.width * 100;
+  const l = t.left - e.left + (t.width - e.width) / 2 + s.x, a = t.top - e.top + (t.height - e.height) / 2 + s.y, r = t.width / e.width, c = t.height / e.height, p = e.top / n.height * 100, d = (n.width - (e.left + e.width)) / n.width * 100, f = (n.height - (e.top + e.height)) / n.height * 100, u = e.left / n.width * 100;
   return {
     transformOrigin: `${e.left + e.width / 2}px ${e.top + e.height / 2}px`,
     animate: (y) => {
-      const h = 1 - y, w = 1 + (c - 1) * h, S = 1 + (a - 1) * h, x = (o * (1 - h) + i * h) / ((w + S) / 2);
+      const h = 1 - y, S = 1 + (r - 1) * h, m = 1 + (c - 1) * h, P = (o * (1 - h) + i * h) / ((S + m) / 2);
       return {
-        clipPath: `inset(${p * h}% ${d * h}% ${f * h}% ${u * h}% round ${x}px)`,
-        transform: `translate(${r * h - s.x}px, ${l * h}px) scale(${w}, ${S})`
+        clipPath: `inset(${p * h}% ${d * h}% ${f * h}% ${u * h}% round ${P}px)`,
+        transform: `translate(${l * h - s.x}px, ${a * h}px) scale(${S}, ${m})`
       };
     }
   };
 }
-const Nn = {
+const Zn = {
   spring: {
     stiffness: 430,
     damping: 33,
     doubleSpring: 1
   }
-}, Tt = 0.12, Xn = 18;
-function Bn() {
+}, At = 0.12, Wn = 18;
+function qn() {
   return {
     transformOrigin: "50% 50%",
     animate: (e) => {
       const t = 1 - e;
       return {
-        transform: `scale(${1 - Tt * t})`
+        transform: `scale(${1 - At * t})`
       };
     }
   };
 }
-function Wn() {
+function Kn() {
   return {
     transformOrigin: "50% 50%",
     animate: (e) => {
       const t = 1 - e;
       return {
-        transform: `scale(${1 - Tt * t})`
+        transform: `scale(${1 - At * t})`
       };
     }
   };
 }
-const q = {
+const j = {
   willChange: "backdrop-filter",
   initialStyle: {
     position: "absolute",
     inset: "0",
     pointerEvents: "none",
-    // z-index is mode-dependent and applied in OverlayStrategy.contribute
-    // once `resolved.mode` is known. Sits between the background page and
-    // the zoomed tile:
-    //   enter — tile (`to`) is default(0), background (`from`) at -2,
-    //           overlay at -1.
-    //   exit  — tile (`from`) is at +2, background (`to`) default(0),
-    //           overlay at +1.
+    // z-index is applied in OverlayStrategy.contribute. The overlay always
+    // sits at Z_OVERLAY, between the background page (Z_BACKGROUND) and the
+    // zoomed tile (Z_FOREGROUND), in both enter and exit.
     backdropFilter: "blur(0px)",
     WebkitBackdropFilter: "blur(0px)"
   },
   style: (e, t) => {
-    const n = e === "enter" ? t : 1 - t, s = `blur(${Xn * n}px)`;
+    const n = e === "enter" ? t : 1 - t, s = `blur(${Wn * n}px)`;
     return {
       backdropFilter: s,
       WebkitBackdropFilter: s
     };
   }
 };
-class Zn {
+class jn {
   constructor() {
-    $(this, "physics", Nn);
+    C(this, "physics", Zn);
   }
   contribute(t) {
-    const { from: n, to: s, resolved: o, physics: i } = t, r = o.mode === "enter", l = r ? n : s, c = r ? Bn() : Wn();
-    return c && (l.style.transformOrigin = c.transformOrigin), [
-      new m({
-        element: l,
-        integrator: g.from(i),
-        style: r ? (a, p) => c.animate(p) : (a) => c.animate(a)
+    const { from: n, to: s, resolved: o, physics: i } = t, l = o.mode === "enter", a = l ? n : s, r = l ? qn() : Kn();
+    return r && (a.style.transformOrigin = r.transformOrigin), [
+      new g({
+        element: a,
+        integrator: w.from(i),
+        style: l ? (c, p) => r.animate(p) : (c) => r.animate(c)
       })
     ];
   }
 }
-class qn {
+class Gn {
   prepare(t) {
     const n = t.createElement("zoom-overlay");
-    return Object.assign(n.style, q.initialStyle), n.style.willChange = q.willChange, t.context.positionedParent.appendChild(n), { overlay: n };
+    return Object.assign(n.style, j.initialStyle), n.style.willChange = j.willChange, t.context.positionedParent.appendChild(n), { overlay: n };
   }
   contribute(t) {
     const n = t.extras.overlay;
-    return n ? (n.style.zIndex = t.resolved.mode === "enter" ? "-1" : "1", [
-      new m({
+    return n ? (n.style.zIndex = Le, [
+      new g({
         element: n,
-        integrator: g.from(t.physics),
-        style: (s) => q.style(t.resolved.mode, s)
+        integrator: w.from(t.physics),
+        style: (s) => j.style(t.resolved.mode, s)
       })
     ]) : [];
   }
 }
-const jn = {
+const Jn = {
   spring: {
     stiffness: 430,
     damping: 33,
     doubleSpring: 1
   }
 };
-function Kn({
+function Qn({
   enterRect: e,
   exitRect: t,
   scrollOffset: n
 }) {
-  const s = e.left - t.left + (e.width - t.width) / 2 + n.x, o = e.top - t.top + (e.height - t.height) / 2 + n.y, i = e.width / t.width, r = e.height / t.height, l = Math.max(i, r);
+  const s = e.left - t.left + (e.width - t.width) / 2 + n.x, o = e.top - t.top + (e.height - t.height) / 2 + n.y, i = e.width / t.width, l = e.height / t.height, a = Math.max(i, l);
   return {
     transformOrigin: `${t.left + t.width / 2}px ${t.top + t.height / 2}px`,
-    animate: (c) => {
-      const a = 1 - c;
+    animate: (r) => {
+      const c = 1 - r;
       return {
-        transform: `translate(${s * a - n.x}px, ${o * a}px) scale(${1 + (l - 1) * a})`
+        transform: `translate(${s * c - n.x}px, ${o * c}px) scale(${1 + (a - 1) * c})`
       };
     }
   };
 }
-function Gn({
+function ts({
   enterRect: e,
   exitRect: t,
   scrollOffset: n
 }) {
-  const s = e.left - t.left + (e.width - t.width) / 2 - n.x, o = e.top - t.top + (e.height - t.height) / 2 - n.y, i = e.width / t.width, r = e.height / t.height, l = Math.max(i, r);
+  const s = e.left - t.left + (e.width - t.width) / 2 - n.x, o = e.top - t.top + (e.height - t.height) / 2 - n.y, i = e.width / t.width, l = e.height / t.height, a = Math.max(i, l);
   return {
     transformOrigin: `${t.left + t.width / 2}px ${t.top + t.height / 2}px`,
-    animate: (c) => {
-      const a = 1 - c;
+    animate: (r) => {
+      const c = 1 - r;
       return {
-        transform: `translate(${s * a}px, ${o * a}px) scale(${1 + (l - 1) * a})`
+        transform: `translate(${s * c}px, ${o * c}px) scale(${1 + (a - 1) * c})`
       };
     }
   };
 }
-class Jn {
+class es {
   constructor() {
-    $(this, "physics", jn);
+    C(this, "physics", Jn);
   }
   contribute(t) {
-    const { from: n, to: s, resolved: o, input: i, physics: r } = t, l = o.mode === "enter", c = l ? n : s, a = l ? Kn(i) : Gn(i);
-    return a && (c.style.transformOrigin = a.transformOrigin), [
-      new m({
-        element: c,
-        integrator: g.from(r),
-        style: l ? (p, d) => a.animate(d) : (p) => a.animate(p)
+    const { from: n, to: s, resolved: o, input: i, physics: l } = t, a = o.mode === "enter", r = a ? n : s, c = a ? Qn(i) : ts(i);
+    return c && (r.style.transformOrigin = c.transformOrigin), [
+      new g({
+        element: r,
+        integrator: w.from(l),
+        style: a ? (p, d) => c.animate(d) : (p) => c.animate(p)
       })
     ];
   }
 }
-const Qn = {
+const ns = {
   spring: {
     stiffness: 530,
     damping: 34,
     doubleSpring: 1
   }
 };
-class ts {
+class ss {
   constructor() {
-    $(this, "physics", Qn);
+    C(this, "physics", ns);
   }
   contribute(t) {
     return [];
   }
 }
-const es = {
-  expand: () => new Jn(),
-  static: () => new ts(),
-  blur: () => new Zn()
+const os = {
+  expand: () => new es(),
+  static: () => new ss(),
+  blur: () => new jn()
 };
-function ns(e) {
-  return es[e]();
+function is(e) {
+  return os[e]();
 }
-const j = "data-zoom-enter-key", Et = "data-zoom-exit-key", ss = "data-zoom-radius";
-function xt(e) {
-  const t = e.getAttribute(ss);
+const G = "data-zoom-enter-key", Pt = "data-zoom-exit-key", rs = "data-zoom-radius";
+function _t(e) {
+  const t = e.getAttribute(rs);
   if (!t) return 0;
   const n = parseFloat(t);
   return Number.isFinite(n) && n > 0 ? n : 0;
 }
-function os(e, t) {
+function as(e, t) {
   const n = [];
   let s = t;
   for (; s && s !== e; ) {
@@ -2000,89 +2013,91 @@ function os(e, t) {
   }
   return n;
 }
-function Pt(e) {
-  const t = e.querySelectorAll(`[${j}]`);
+function It(e) {
+  const t = e.querySelectorAll(`[${G}]`);
   return t.length !== 1 ? null : t[0];
 }
-function _t(e, t) {
-  const n = e.querySelectorAll(`[${Et}]`);
+function Dt(e, t) {
+  const n = e.querySelectorAll(`[${Pt}]`);
   for (const s of n)
-    if (s.getAttribute(Et) === t)
+    if (s.getAttribute(Pt) === t)
       return s;
   return null;
 }
-function is(e, t) {
-  const n = Pt(e), s = Pt(t);
+function ls(e, t) {
+  const n = It(e), s = It(t);
   if (!n && s) {
-    const o = s.getAttribute(j);
+    const o = s.getAttribute(G);
     if (!o) return null;
-    const i = _t(e, o);
+    const i = Dt(e, o);
     return i ? { mode: "enter", enterEl: s, exitEl: i } : null;
   }
   if (n && !s) {
-    const o = n.getAttribute(j);
+    const o = n.getAttribute(G);
     if (!o) return null;
-    const i = _t(t, o);
+    const i = Dt(t, o);
     return i ? { mode: "exit", enterEl: n, exitEl: i } : null;
   }
   return null;
 }
-function rs(e, t, n, s) {
+function cs(e, t, n, s) {
   return {
-    enterRect: tt(
+    enterRect: nt(
       e.mode === "enter" ? n : t,
       e.enterEl
     ),
-    exitRect: tt(
+    exitRect: nt(
       e.mode === "enter" ? t : n,
       e.exitEl
     ),
     pageRect: e.mode === "enter" ? n.getBoundingClientRect() : t.getBoundingClientRect(),
     scrollOffset: s,
-    enterRadius: xt(e.enterEl),
-    exitRadius: xt(e.exitEl)
+    enterRadius: _t(e.enterEl),
+    exitRadius: _t(e.exitEl)
   };
 }
-class as {
+class ps {
   prepare(t) {
     t.from.then((n) => {
       n.style.willChange = "transform, clip-path, opacity", n.style.backfaceVisibility = "hidden", n.style.contain = "layout paint";
     });
   }
   contribute(t) {
-    const { from: n, to: s, resolved: o, input: i, physics: r, onComplete: l } = t, c = o.mode === "enter", a = c ? Vn(i) : zn(i), p = c ? s : n, d = c ? "t" : "u";
-    a && (p.style.transformOrigin = a.transformOrigin);
-    const f = c ? "-2" : "2", u = n.style.zIndex;
-    return n.style.zIndex = f, l(() => {
-      p.style.willChange = "auto", p.style.backfaceVisibility = "", p.style.transformOrigin = "", p.style.contain = "", n.style.zIndex = u, n.style.willChange = "auto", n.style.backfaceVisibility = "", n.style.transformOrigin = "", n.style.contain = "", n.style.transform = "", n.style.clipPath = "";
+    const { from: n, to: s, resolved: o, input: i, physics: l, onComplete: a } = t, r = o.mode === "enter", c = r ? Xn(i) : Bn(i), p = r ? s : n, d = r ? "t" : "u";
+    c && (p.style.transformOrigin = c.transformOrigin);
+    const f = r ? v : O, u = r ? O : v, y = n.style.zIndex;
+    n.style.zIndex = f;
+    const h = s.style.zIndex, S = s.style.position;
+    return s.style.zIndex = u, s.style.position = "relative", a(() => {
+      p.style.willChange = "auto", p.style.backfaceVisibility = "", p.style.transformOrigin = "", p.style.contain = "", n.style.zIndex = y, s.style.zIndex === u && (s.style.zIndex = h), s.style.position === "relative" && (s.style.position = S), s.style.transformOrigin = "", n.style.willChange = "auto", n.style.backfaceVisibility = "", n.style.transformOrigin = "", n.style.contain = "", n.style.transform = "", n.style.clipPath = "";
     }), [
-      new m({
+      new g({
         element: p,
-        integrator: g.from(r),
+        integrator: w.from(l),
         // Enter: tile expands as `t` (0 → 1). Exit: tile shrinks as `u` —
         // the legacy convention from v5's outAnim path. Either way, feed
         // the progress that matches the tileConfig's authored direction.
-        style: d === "t" ? (y) => a.animate(y) : (y, h) => a.animate(h)
+        style: d === "t" ? (m) => c.animate(m) : (m, b) => c.animate(b)
       })
     ];
   }
 }
-class ls {
+class ds {
   contribute(t) {
-    const { resolved: n, physics: s, from: o, to: i, onComplete: r } = t, l = n.mode === "enter" ? i : o, c = os(l, n.enterEl);
-    if (c.length === 0) return [];
-    const a = c.map((p) => p.style.opacity);
+    const { resolved: n, physics: s, from: o, to: i, onComplete: l } = t, a = n.mode === "enter" ? i : o, r = as(a, n.enterEl);
+    if (r.length === 0) return [];
+    const c = r.map((p) => p.style.opacity);
     if (n.mode === "enter")
-      for (const p of c) p.style.opacity = "0";
-    return r(() => {
-      for (let p = 0; p < c.length; p++) {
-        const d = c[p];
-        d && (d.style.opacity = a[p] ?? "");
+      for (const p of r) p.style.opacity = "0";
+    return l(() => {
+      for (let p = 0; p < r.length; p++) {
+        const d = r[p];
+        d && (d.style.opacity = c[p] ?? "");
       }
-    }), c.map(
-      (p) => new m({
+    }), r.map(
+      (p) => new g({
         element: p,
-        integrator: g.from(s),
+        integrator: w.from(s),
         style: (d, f) => ({
           opacity: n.mode === "enter" ? d : f
         })
@@ -2090,35 +2105,35 @@ class ls {
     );
   }
 }
-class Ot {
+class Ft {
   contribute() {
     return [];
   }
 }
-const cs = {
-  default: () => new Ot(),
-  fade: () => new ls()
+const fs = {
+  default: () => new Ft(),
+  fade: () => new ds()
 };
-function ps(e) {
-  return cs[e]();
+function ys(e) {
+  return fs[e]();
 }
-class ds extends Ot {
+class hs extends Ft {
 }
-function fs(e) {
-  const t = ns(e.type);
+function us(e) {
+  const t = is(e.type);
   return { strategies: [
-    new as(),
+    new ps(),
     t,
-    ps(e.variant),
-    new ds(),
+    ys(e.variant),
+    new hs(),
     // Overlay is intrinsically tied to backdrop-filter-driven types. Today
     // that's only `blur`; the table-driven factory above owns the mapping
     // so this conditional is the single line that knows the relationship.
-    ...e.type === "blur" ? [new qn()] : []
+    ...e.type === "blur" ? [new Gn()] : []
   ], physics: t.physics };
 }
-const ys = (e) => {
-  const { strategies: t, physics: n } = fs(e);
+const ms = (e) => {
+  const { strategies: t, physics: n } = us(e);
   return {
     prepare: (s) => {
       const o = {
@@ -2130,26 +2145,26 @@ const ys = (e) => {
         // compatible.
         createElement: s.createElement
       }, i = {};
-      for (const r of t) {
-        if (!r.prepare) continue;
-        const l = r.prepare(o);
-        l && Object.assign(i, l);
+      for (const l of t) {
+        if (!l.prepare) continue;
+        const a = l.prepare(o);
+        a && Object.assign(i, a);
       }
       return i;
     },
-    animation: ({ from: s, to: o, context: i, ...r }) => {
-      const l = is(s, o);
-      if (!l)
-        return new C([], { mode: "parallel" });
-      const c = rs(l, s, o, i.scrollOffset), a = [], d = {
+    animation: ({ from: s, to: o, context: i, ...l }) => {
+      const a = ls(s, o);
+      if (!a)
+        return new x([], { mode: "parallel" });
+      const r = cs(a, s, o, i.scrollOffset), c = [], d = {
         from: s,
         to: o,
-        resolved: l,
-        input: c,
+        resolved: a,
+        input: r,
         physics: n,
-        extras: r,
+        extras: l,
         onComplete: (y) => {
-          a.push(y);
+          c.push(y);
         }
       }, f = [];
       for (const y of t)
@@ -2159,51 +2174,51 @@ const ys = (e) => {
         const y = u.onComplete;
         u.onComplete = () => {
           y == null || y();
-          for (const h of a)
+          for (const h of c)
             try {
               h();
-            } catch (w) {
-              console.error("[zoom] cleanup error", w);
+            } catch (S) {
+              console.error("[zoom] cleanup error", S);
             }
         };
       }
       for (const y of f) {
-        if (!(y instanceof m)) continue;
+        if (!(y instanceof g)) continue;
         const h = y.onComplete;
         y.onComplete = () => {
           h == null || h(), y.releaseFill();
         };
       }
-      return new C(f, { mode: "parallel" });
+      return new x(f, { mode: "parallel" });
     }
   };
 };
-function hs(e) {
+function gs(e) {
   const t = e.type ?? "static", n = e.variant ?? (e.fade ? "fade" : "default");
   return { type: t, variant: n };
 }
-function Ts(e) {
-  const t = hs(e);
-  return v(
+function Fs(e) {
+  const t = gs(e);
+  return D(
     e.paths,
-    () => ys(t)
+    () => ms(t)
   );
 }
 export {
-  Fs as Animation,
-  C as MultiAnimation,
-  m as WebAnimation,
-  ws as axis,
-  Ss as blind,
-  bs as drill,
-  $s as fade,
-  Cs as film,
-  Es as hero,
-  xs as jaemin,
-  Ps as rotate,
-  _s as scroll,
-  Ds as sheet,
-  vs as slide,
-  Is as strip,
-  Ts as zoom
+  Ls as Animation,
+  x as MultiAnimation,
+  g as WebAnimation,
+  $s as axis,
+  Cs as blind,
+  xs as drill,
+  Es as fade,
+  Ps as film,
+  _s as hero,
+  Is as jaemin,
+  Ds as rotate,
+  vs as scroll,
+  Os as sheet,
+  Ts as slide,
+  As as strip,
+  Fs as zoom
 };