@ssgoi/core 5.2.2 → 6.1.0

package/dist/index.js

@@ -1,1291 +1,1807 @@
-var it = Object.defineProperty;
-var rt = (e, i, t) => i in e ? it(e, i, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[i] = t;
-var d = (e, i, t) => rt(e, typeof i != "symbol" ? i + "" : i, t);
-import { normalizeToMultiAnimation as F, normalizeSchedule as W } from "./types.js";
-import { isCssAnimation as $t, isKeyframesAnimation as Zt, isMultiAnimation as Jt, isSingleAnimation as Qt, isTickAnimation as te } from "./types.js";
-import { S as Z, a as ot } from "./spring-integrator-BM4a-82c.js";
-import { I as st } from "./provider-B2B8CK6H.js";
-class at {
-  constructor() {
-    d(this, "listeners", /* @__PURE__ */ new Set());
-    d(this, "rafId", null);
-    d(this, "isRunning", !1);
-    // Timing
-    d(this, "startTime", Date.now());
-    d(this, "lastUpdate", this.startTime);
-    d(this, "elapsed", 0);
-    // Lag smoothing (mobile optimization)
-    d(this, "lagThreshold", 500);
-    // ms - detect tab switches, backgrounding
-    d(this, "adjustedLag", 33);
-    // ms - max time jump to prevent animation skip
-    d(this, "maxDeltaTime", 33);
-    // ms - clamp for physics stability (30fps minimum)
-    // FPS throttling
-    d(this, "gap", 1e3 / 240);
-    // max 240fps
-    d(this, "nextTime", this.gap);
-    d(this, "tick", () => {
-      const i = Date.now();
-      let n = i - this.lastUpdate;
-      n > this.lagThreshold || n < 0 ? (this.startTime += n - this.adjustedLag, n = this.adjustedLag) : n > this.maxDeltaTime && (n = this.maxDeltaTime), this.lastUpdate = i;
-      const r = i - this.startTime, o = r - this.nextTime;
-      if (o > 0) {
-        const s = n / 1e3;
-        this.elapsed = r / 1e3, this.nextTime += o + (o >= this.gap ? 4 : this.gap - o), this.listeners.forEach((m) => {
-          m(s, this.elapsed);
-        });
-      }
-      this.listeners.size > 0 ? this.rafId = requestAnimationFrame(this.tick) : (this.isRunning = !1, this.rafId = null);
-    });
-  }
-  subscribe(i) {
-    return this.listeners.add(i), this.isRunning || (this.isRunning = !0, this.rafId = requestAnimationFrame(this.tick)), () => {
-      this.unsubscribe(i);
-    };
-  }
-  unsubscribe(i) {
-    this.listeners.delete(i), this.listeners.size === 0 && this.rafId !== null && (cancelAnimationFrame(this.rafId), this.isRunning = !1, this.rafId = null);
-  }
-  /**
-   * Configure lag smoothing behavior
-   * @param threshold - Time threshold to detect lag (default: 500ms)
-   * @param adjustedLag - Max time jump when lag detected (default: 33ms)
-   */
-  lagSmoothing(i, t) {
-    this.lagThreshold = i, this.adjustedLag = Math.min(t, i);
-  }
-  /**
-   * Set maximum FPS
-   * @param fps - Target FPS (default: 240)
-   */
-  fps(i) {
-    this.gap = 1e3 / i, this.nextTime = this.elapsed * 1e3 + this.gap;
-  }
-  getListenerCount() {
-    return this.listeners.size;
-  }
-  getElapsed() {
-    return this.elapsed;
-  }
-}
-const z = new at();
-function ct(e) {
-  const {
-    integrator: i,
-    from: t,
-    to: n,
-    velocity: r = 0,
-    onUpdate: o,
-    onComplete: s,
-    onStart: m
-  } = e;
-  let l = { position: t, velocity: r }, u = !0, h = 0, v = !1;
-  const E = (S) => {
-    if (u) {
-      if (v || (v = !0, m == null || m()), l = i.step(l, n, S), i.isSettled(l, n)) {
-        if (h += Math.min(S, 0.033), h >= Z) {
-          l = { position: n, velocity: 0 }, u = !1, o(l.position), z.unsubscribe(E), s();
-          return;
-        }
-      } else
-        h = 0;
-      o(l.position);
+var xt = Object.defineProperty;
+var Et = (e, t, n) => t in e ? xt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var $ = (e, t, n) => Et(e, typeof t != "symbol" ? t + "" : t, n);
+import { P as Z, V as ft, W as b, M as E, S as Ct } from "./multi-animation-CnxqLEka.js";
+import { A as zn } from "./multi-animation-CnxqLEka.js";
+function P(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({
+        from: i,
+        to: r,
+        transition: t(),
+        symmetric: !0
+      });
     }
-  };
-  return z.subscribe(E), {
-    stop: () => {
-      u && (u = !1, z.unsubscribe(E));
-    },
-    getPosition: () => l.position,
-    getVelocity: () => l.velocity,
-    isRunning: () => u
-  };
+  return n;
 }
-const L = 1e3 / 60;
-function lt(e, i, t, n = 0) {
-  let o = { position: i, velocity: n }, s = 0;
-  const m = [];
-  for (let l = 0; l < 600; l++) {
-    const u = l * L;
-    if (m.push({
-      time: u,
-      position: o.position,
-      velocity: o.velocity
-    }), o = e.step(o, t, L / 1e3), e.isSettled(o, t)) {
-      if (s += L / 1e3, s >= Z) {
-        m.push({
-          time: (l + 1) * L,
-          position: t,
-          velocity: 0
-        });
-        break;
-      }
-    } else
-      s = 0;
-  }
-  return m;
-}
-function U(e, i) {
-  if (e.length === 0)
-    return { position: 0, velocity: 0 };
-  const t = e[0], n = e[e.length - 1];
-  if (i <= 0)
-    return { position: t.position, velocity: t.velocity };
-  if (i >= n.time)
-    return { position: n.position, velocity: n.velocity };
-  let r = 0, o = e.length - 1;
-  for (; r < o - 1; ) {
-    const u = Math.floor((r + o) / 2);
-    e[u].time <= i ? r = u : o = u;
-  }
-  const s = e[r], m = e[o], l = (i - s.time) / (m.time - s.time);
-  return {
-    position: s.position + (m.position - s.position) * l,
-    velocity: s.velocity + (m.velocity - s.velocity) * l
-  };
-}
-function ut(e, i) {
-  return e.map((t) => i(t.position));
-}
-function ft(e) {
-  const {
-    integrator: i,
-    element: t,
-    from: n,
-    to: r,
-    velocity: o = 0,
-    style: s,
-    onComplete: m,
-    onStart: l
-  } = e, u = lt(i, n, r, o);
-  if (u.length === 0)
-    return l == null || l(), m(), {
-      stop: () => {
-      },
-      getPosition: () => r,
-      getVelocity: () => 0,
-      isRunning: () => !1
-    };
-  const h = ut(u, s), v = u[u.length - 1], E = v.time, S = h[0];
-  if (S)
-    for (const T of Object.keys(S))
-      t.style[T] = "";
-  const y = t.animate(h, {
-    duration: E,
-    fill: "forwards",
-    easing: "linear",
-    composite: "replace"
-  });
-  let p = !0;
-  const k = performance.now();
-  return l == null || l(), y.onfinish = () => {
-    p && (p = !1, m());
-  }, {
-    stop: () => {
-      p && (p = !1, y.cancel());
-    },
-    getPosition: () => {
-      if (!p)
-        return v.position;
-      const T = performance.now() - k;
-      return U(u, T).position;
-    },
-    getVelocity: () => {
-      if (!p)
-        return 0;
-      const T = performance.now() - k;
-      return U(u, T).velocity;
-    },
-    isRunning: () => p
-  };
-}
-function mt(e) {
-  const {
-    element: i,
-    frames: t,
-    duration: n,
-    easing: r = "linear",
-    from: o,
-    to: s,
-    onComplete: m,
-    onStart: l
-  } = e, u = t[0];
-  if (u)
-    for (const S of Object.keys(u))
-      S === "offset" || S === "easing" || S === "composite" || (i.style[S] = "");
-  const h = i.animate(t, {
-    duration: n,
-    fill: "forwards",
-    easing: r,
-    composite: "replace"
-  });
-  let v = !0;
-  const E = performance.now();
-  return l == null || l(), h.onfinish = () => {
-    v && (v = !1, m());
-  }, {
-    stop: () => {
-      v && (v = !1, h.cancel());
-    },
-    // Linear progress mapped onto [from, to] — used by MultiAnimator for
-    // stagger thresholds. The actual visual motion is whatever the keyframes
-    // dictate; this mapping just gives the orchestration layer a monotonic
-    // progress signal.
-    getPosition: () => {
-      if (!v) return s;
-      const S = performance.now() - E, y = Math.min(Math.max(S / n, 0), 1);
-      return o + (s - o) * y;
-    },
-    // Baked animations don't expose velocity — interruption/resumption isn't
-    // supported here (you can stop, but can't resume mid-flight with momentum).
-    getVelocity: () => 0,
-    isRunning: () => v
-  };
-}
-function dt(e) {
-  const { to: i, onStart: t, onComplete: n } = e;
-  return t == null || t(), n(), {
-    stop: () => {
+function ht(e, t) {
+  return [
+    {
+      from: e.exit,
+      to: e.enter,
+      transition: t("enter")
     },
-    getPosition: () => i,
-    getVelocity: () => 0,
-    isRunning: () => !1
-  };
+    {
+      from: e.enter,
+      to: e.exit,
+      transition: t("exit")
+    }
+  ];
 }
-class ht {
-  /**
-   * Get bound runner based on animation mode
-   *
-   * @param options Animation mode options — exactly one of tick / css / keyframes
-   * @returns Bound runner function (empty runner if no animation mode specified)
-   * @throws Error if more than one mode is provided
-   */
-  static from(i) {
-    const { tick: t, css: n, keyframes: r } = i;
-    if ((t ? 1 : 0) + (n ? 1 : 0) + (r ? 1 : 0) > 1)
-      throw new Error(
-        "Cannot use more than one of 'tick', 'css', 'keyframes' together"
+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(
+        {
+          from: r,
+          to: l,
+          transition: n(t.forward)
+        },
+        {
+          from: l,
+          to: r,
+          transition: n(t.backward)
+        }
       );
-    return r ? (s) => mt({
-      element: r.element,
-      frames: r.frames,
-      duration: r.duration,
-      easing: r.easing,
-      from: s.from,
-      to: s.to,
-      onComplete: s.onComplete,
-      onStart: s.onStart
-    }) : n ? (s) => {
-      if (!s.integrator)
-        throw new Error("css mode requires an integrator");
-      return ft({
-        integrator: s.integrator,
-        from: s.from,
-        to: s.to,
-        velocity: s.velocity,
-        onComplete: s.onComplete,
-        onStart: s.onStart,
-        element: n.element,
-        style: n.style
-      });
-    } : t ? (s) => {
-      if (!s.integrator)
-        throw new Error("tick mode requires an integrator");
-      return ct({
-        integrator: s.integrator,
-        from: s.from,
-        to: s.to,
-        velocity: s.velocity,
-        onComplete: s.onComplete,
-        onStart: s.onStart,
-        onUpdate: t
-      });
-    } : dt;
-  }
-}
-class J {
+    }
+  return s;
 }
-const gt = { stiffness: 300, damping: 30 };
-class B extends J {
+class F {
   constructor(t) {
-    super();
-    d(this, "options");
-    d(this, "runner");
-    d(this, "controls", null);
-    d(this, "isAnimating", !1);
-    d(this, "currentValue");
-    d(this, "currentVelocity", 0);
-    d(this, "updateFn");
-    d(this, "isKeyframesMode");
-    if (this.options = {
-      from: t.from ?? 0,
-      to: t.to ?? 1,
-      physics: t.physics,
-      onComplete: t.onComplete ?? (() => {
-      }),
-      onStart: t.onStart
-    }, this.currentValue = this.options.from, this.isKeyframesMode = !!t.keyframes, t.tick)
-      this.updateFn = (n) => {
-        var r;
-        return (r = t.tick) == null ? void 0 : r.call(t, n);
-      };
-    else if (t.css) {
-      const { element: n, style: r } = t.css;
-      this.updateFn = (o) => {
-        const s = r(o);
-        for (const [m, l] of Object.entries(s))
-          n.style[m] = typeof l == "number" ? String(l) : l;
-      };
-    } else
-      this.updateFn = () => {
-      };
-    this.runner = ht.from({
-      tick: t.tick,
-      css: t.css,
-      keyframes: t.keyframes
-    });
-  }
-  /**
-   * Sync element state to current progress value
-   * Uses the update callback if provided
-   */
-  syncState() {
-    var t;
-    (t = this.updateFn) == null || t.call(this, this.currentValue);
-  }
-  /**
-   * Create Integrator from physics options
-   * Priority: integrator factory > inertia/spring config > default spring
-   */
-  createIntegrator() {
-    const t = this.options.physics;
-    return t != null && t.integrator ? t.integrator() : t != null && t.spring || t != null && t.inertia ? st.from({
-      spring: t.spring,
-      inertia: t.inertia
-    }) : new ot(gt);
-  }
-  runAnimation(t) {
-    this.isAnimating = !0, this.controls = this.runner({
-      // Keyframes mode plays a pre-baked WAAPI animation — no integrator
-      // needed. tick/css modes still require one.
-      integrator: this.isKeyframesMode ? void 0 : this.createIntegrator(),
-      from: this.currentValue,
-      to: t,
-      velocity: this.currentVelocity,
-      onStart: this.options.onStart,
-      onComplete: () => {
-        this.currentValue = t, this.currentVelocity = 0, this.isAnimating = !1, this.controls = null, this.options.onComplete();
-      }
-    });
+    $(this, "omega");
+    // Angular frequency
+    $(this, "zeta");
+    // Damping ratio
+    $(this, "restDelta");
+    $(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 ?? Z, this.restSpeed = t.restSpeed ?? ft;
   }
-  forward() {
-    this.stop(), this.runAnimation(this.options.to);
-  }
-  backward() {
-    this.stop(), this.runAnimation(this.options.from);
-  }
-  reverse() {
-    const t = this.options.from;
-    this.options.from = this.options.to, this.options.to = t, this.isAnimating && (this.stop(), this.runAnimation(this.options.to));
-  }
-  stop() {
-    this.controls && (this.currentValue = this.controls.getPosition(), this.currentVelocity = this.controls.getVelocity(), this.controls.stop(), this.controls = null), this.isAnimating = !1;
-  }
-  getVelocity() {
-    var t;
-    return ((t = this.controls) == null ? void 0 : t.getVelocity()) ?? this.currentVelocity;
-  }
-  getCurrentValue() {
-    var t;
-    return ((t = this.controls) == null ? void 0 : t.getPosition()) ?? this.currentValue;
-  }
-  getIsAnimating() {
-    return this.isAnimating;
-  }
-  getCurrentState() {
+  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;
     return {
-      position: this.getCurrentValue(),
-      velocity: this.getVelocity(),
-      from: this.options.from,
-      to: this.options.to
+      position: l + o * d,
+      velocity: d
     };
   }
-  setValue(t) {
-    this.currentValue = t;
-  }
-  setVelocity(t) {
-    this.currentVelocity = t;
-  }
-  updateOptions(t) {
-    this.options = { ...this.options, ...t };
+  isSettled(t, n) {
+    const s = Math.abs(n - t.position), o = Math.abs(t.velocity);
+    return s < this.restDelta && o < this.restSpeed;
   }
 }
-class _ extends J {
+class Pt {
   constructor(t) {
-    super();
-    d(this, "config");
-    d(this, "animators", /* @__PURE__ */ new Map());
-    d(this, "itemOrder", []);
-    d(this, "completedCount", 0);
-    d(this, "completedAnimators", /* @__PURE__ */ new Set());
-    d(this, "direction", "forward");
-    d(this, "idCounter", 0);
-    d(this, "rafId", null);
-    d(this, "from");
-    d(this, "to");
-    d(this, "initialState");
-    this.config = t.config, this.from = t.from, this.to = t.to, this.initialState = t.state ?? {
-      position: t.from,
-      velocity: 0
-    }, this.initializeAnimators();
-  }
-  generateId() {
-    return `spring_${this.idCounter++}`;
-  }
-  initializeAnimators() {
-    this.config.items.forEach((t, n) => {
-      const r = this.generateId(), o = new B({
-        from: this.from,
-        to: this.to,
-        physics: t.physics,
-        tick: t.tick,
-        css: t.css,
-        keyframes: t.keyframes,
-        onComplete: () => this.onAnimatorComplete(r),
-        onStart: t.onStart
-      });
-      (n === 0 || t.normalizedOffset === 0) && (o.setValue(this.initialState.position), o.setVelocity(this.initialState.velocity), o.syncState()), this.animators.set(r, {
-        id: r,
-        item: t,
-        animator: o,
-        started: !1
-      }), this.itemOrder.push(r);
+    $(this, "leader");
+    $(this, "follower");
+    $(this, "restDelta");
+    $(this, "restSpeed");
+    this.restDelta = t.restDelta ?? Z, this.restSpeed = t.restSpeed ?? ft, this.leader = new F({
+      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 F({
+      stiffness: n,
+      damping: s,
+      restDelta: o ?? this.restDelta,
+      restSpeed: i ?? this.restSpeed
     });
   }
-  /**
-   * Calculate progress of an animator (0-1)
-   * Progress = |position - from| / |to - from|
-   */
-  getAnimatorProgress(t) {
-    const n = t.animator.getCurrentState(), r = Math.abs(n.to - n.from);
-    return r === 0 ? 1 : Math.abs(n.position - n.from) / r;
+  step(t, n, s) {
+    const i = t._leader ?? {
+      position: t.position,
+      velocity: t.velocity
+    }, r = this.leader.step(i, n, s), l = this.follower.step(
+      t,
+      r.position,
+      s
+    );
+    return {
+      position: l.position,
+      velocity: l.velocity,
+      _leader: r
+    };
   }
-  /**
-   * Get order of springs based on direction
-   * Forward: 0, 1, 2, ...
-   * Backward: n-1, n-2, ..., 0
-   */
-  getOrderedIds() {
-    return this.direction === "forward" ? this.itemOrder : [...this.itemOrder].reverse();
+  isSettled(t, n) {
+    const s = t, o = Math.abs(n - t.position) < this.restDelta && Math.abs(t.velocity) < this.restSpeed;
+    return s._leader ? Math.abs(n - s._leader.position) < this.restDelta && Math.abs(s._leader.velocity) < this.restSpeed && o : o;
   }
-  onAnimatorComplete(t) {
-    var r, o, s, m, l, u;
-    const n = this.animators.get(t);
-    !n || this.completedAnimators.has(t) || (this.completedAnimators.add(t), this.completedCount++, (o = (r = n.item).onComplete) == null || o.call(r), (m = (s = this.config).onProgress) == null || m.call(s, this.completedCount, this.config.items.length), this.completedCount === this.config.items.length && (this.stopScheduler(), (u = (l = this.config).onEnd) == null || u.call(l)));
+}
+const vt = 0.01, Tt = 500, Dt = 10;
+class _t {
+  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 ?? Tt, this.bounceDamping = t.bounceDamping ?? Dt, this.restDelta = t.restDelta ?? vt;
   }
-  /**
-   * Check and start springs based on previous spring's progress
-   * Called on each frame while animation is running
-   */
-  checkAndStartSprings() {
-    const t = this.getOrderedIds();
-    for (let n = 0; n < t.length; n++) {
-      const r = t[n], o = this.animators.get(r);
-      if (!o || o.started) continue;
-      if (n === 0) {
-        this.startAnimator(r);
-        continue;
-      }
-      const s = t[n - 1], m = this.animators.get(s);
-      if (!m || !m.started) continue;
-      const l = this.getAnimatorProgress(m), u = o.item.normalizedOffset;
-      l >= u && this.startAnimator(r);
+  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, u = c !== void 0 && p < c, m = a !== void 0 && p > a;
+    let f;
+    if (u || m) {
+      const S = p - (u ? c : a), x = -this.bounceStiffness * S, C = -this.bounceDamping * d;
+      f = x + C;
+    } else {
+      const w = n > p ? 1 : -1;
+      let S;
+      l === "linear" ? S = r * d : S = r * d * Math.abs(d), f = w * i - S;
     }
-  }
-  startAnimator(t) {
-    const n = this.animators.get(t);
-    !n || n.started || (n.started = !0, this.direction === "forward" ? n.animator.forward() : n.animator.backward());
-  }
-  /**
-   * Start the scheduler loop that checks spring progress
-   */
-  startScheduler() {
-    const t = () => {
-      this.checkAndStartSprings(), this.getIsAnimating() && (this.rafId = requestAnimationFrame(t));
+    const h = d + f * o;
+    let y = p + h * o;
+    if (!u && !m) {
+      const w = n > p ? 1 : -1;
+      (w > 0 && y > n || w < 0 && y < n) && (y = n);
+    }
+    return {
+      position: y,
+      velocity: y === n ? 0 : h
     };
-    t();
-  }
-  stopScheduler() {
-    this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
-  }
-  getFirstAnimator() {
-    var n;
-    const t = this.itemOrder[0];
-    return t ? ((n = this.animators.get(t)) == null ? void 0 : n.animator) ?? null : null;
   }
-  forward() {
-    var t, n;
-    this.stop(), this.direction = "forward", this.completedCount = 0, this.completedAnimators.clear(), this.resetStartedFlags(), (n = (t = this.config).onStart) == null || n.call(t), this.startScheduler();
-  }
-  backward() {
-    var t, n;
-    this.stop(), this.direction = "backward", this.completedCount = 0, this.completedAnimators.clear(), this.resetStartedFlags(), (n = (t = this.config).onStart) == null || n.call(t), this.startScheduler();
-  }
-  resetStartedFlags() {
-    this.animators.forEach((t) => {
-      t.started = !1;
-    });
-  }
-  stop() {
-    this.stopScheduler(), this.animators.forEach((t) => {
-      t.animator.stop(), t.started = !1;
-    });
-  }
-  reverse() {
-    this.direction = this.direction === "forward" ? "backward" : "forward", this.animators.forEach((t) => {
-      if (!t.started)
-        return;
-      const n = t.animator.getCurrentState();
-      if (n.position === n.to) {
-        const o = new B({
-          from: this.to,
-          to: this.from,
-          physics: t.item.physics,
-          tick: t.item.tick,
-          css: t.item.css,
-          keyframes: t.item.keyframes,
-          onComplete: () => this.onAnimatorComplete(t.id),
-          onStart: t.item.onStart
-        });
-        o.setValue(this.to), o.setVelocity(0), o.syncState(), o.forward(), t.animator = o;
-      } else
-        t.animator.reverse();
-    });
-  }
-  getCurrentState() {
-    const t = this.getFirstAnimator();
-    return t ? t.getCurrentState() : {
-      position: 0,
-      velocity: 0,
-      from: 0,
-      to: 1
-    };
-  }
-  /**
-   * Get current position value from first animator
-   */
-  getCurrentValue() {
-    const t = this.getFirstAnimator();
-    return (t == null ? void 0 : t.getCurrentValue()) ?? 0;
+  isSettled(t, n) {
+    return Math.abs(n - t.position) < this.restDelta;
   }
+}
+class g {
   /**
-   * Get current velocity from first animator
+   * Create an Integrator from physics config
+   *
+   * @param config Physics configuration (spring or inertia)
+   * @returns Appropriate Integrator instance
+   * @throws Error if both spring and inertia are provided
    */
-  getVelocity() {
-    const t = this.getFirstAnimator();
-    return (t == null ? void 0 : t.getVelocity()) ?? 0;
+  static from(t) {
+    if (t.spring && t.inertia)
+      throw new Error(
+        "Cannot use both 'spring' and 'inertia' together. Choose one physics type."
+      );
+    if (t.inertia)
+      return new _t({
+        acceleration: t.inertia.acceleration,
+        resistance: t.inertia.resistance,
+        resistanceType: t.inertia.resistanceType,
+        min: t.inertia.min,
+        max: t.inertia.max,
+        bounceStiffness: t.inertia.bounceStiffness,
+        bounceDamping: t.inertia.bounceDamping,
+        restDelta: t.inertia.restDelta
+      });
+    const n = t.spring ?? { stiffness: 300, damping: 30 };
+    if (n.doubleSpring) {
+      const s = n.doubleSpring;
+      let o;
+      return typeof s == "number" ? o = s : typeof s == "object" && (o = {
+        stiffness: s.stiffness,
+        damping: s.damping
+      }), new Pt({
+        stiffness: n.stiffness,
+        damping: n.damping,
+        follower: o,
+        restDelta: n.restDelta,
+        restSpeed: n.restSpeed
+      });
+    }
+    return new F({
+      stiffness: n.stiffness,
+      damping: n.damping,
+      restDelta: n.restDelta,
+      restSpeed: n.restSpeed
+    });
   }
   /**
-   * Set position value on first animator
-   * TODO: Support per-spring control
+   * Create an Integrator from SpringConfig (legacy support)
+   * @deprecated Use from({ spring: config }) instead
    */
-  setValue(t) {
-    const n = this.getFirstAnimator();
-    n == null || n.setValue(t);
+  static fromSpring(t) {
+    return g.from({ spring: t });
   }
-  /**
-   * Set velocity on first animator
-   * TODO: Support per-spring control
-   */
-  setVelocity(t) {
-    const n = this.getFirstAnimator();
-    n == null || n.setVelocity(t);
+}
+class At {
+  constructor(t) {
+    $(this, "durationSec");
+    this.durationSec = Math.max(1 / 60, t.durationSec);
   }
-  /**
-   * Check if any animation is currently running
-   */
-  getIsAnimating() {
-    for (const t of this.animators.values())
-      if (t.animator.getIsAnimating())
-        return !0;
-    return !1;
+  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 };
   }
-  /**
-   * Create MultiAnimator from existing state
-   * Uses first animator's state for initialization
-   */
-  static fromState(t, n) {
-    return new _({ ...n, state: t });
+  isSettled(t, n) {
+    return Math.abs(t.position - n) < Z;
   }
 }
-const Q = Symbol.for("TRANSITION_STRATEGY"), yt = (e) => ({
-  runIn: async (i) => {
-    const { currentAnimation: t } = e;
-    if (t && t.direction === "out") {
-      const r = t.controller.getCurrentValue(), o = t.controller.getVelocity();
-      if (t.controller.stop(), i.out)
-        return {
-          config: await i.out,
-          state: { position: r, velocity: o },
-          from: 1,
-          to: 0,
-          direction: "backward"
-          // Will actually go 0→1 (backward means toward 'from')
-        };
-    }
-    return i.in ? {
-      config: await i.in,
-      state: {
-        position: 0,
-        velocity: 0
-      },
-      from: 0,
-      to: 1,
-      direction: "forward"
-    } : {
-      state: {
-        position: 0,
-        velocity: 0
+const G = 8, K = {
+  spring: { stiffness: 1e3, damping: 40, doubleSpring: 1.2 }
+};
+function It({
+  direction: e
+}) {
+  const t = e === "forward" ? G : -G;
+  return {
+    out: {
+      willChange: "transform, opacity",
+      startStyle: {},
+      animate: (n) => ({
+        opacity: `${1 - n}`
+      })
+    },
+    in: {
+      willChange: "transform, opacity",
+      startStyle: {
+        transform: `translate3d(${t}px, 0, 0)`,
+        opacity: "0"
       },
-      from: 0,
-      to: 1,
-      direction: "forward"
-    };
-  },
-  runOut: async (i) => {
-    const { currentAnimation: t } = e;
-    if (t && t.direction === "in") {
-      const r = t.controller.getCurrentValue(), o = t.controller.getVelocity();
-      if (t.controller.stop(), i.in)
-        return {
-          config: await i.in,
-          state: { position: r, velocity: o },
-          from: 0,
-          to: 1,
-          direction: "backward"
-          // Will actually go 1→0 (backward means toward 'from')
-        };
+      animate: (n) => ({
+        transform: `translate3d(${t * (1 - n)}px, 0, 0)`,
+        opacity: `${n}`
+      })
     }
-    return i.out ? {
-      config: await i.out,
-      state: {
-        position: 1,
-        velocity: 0
-      },
-      from: 1,
-      to: 0,
-      direction: "forward"
-    } : {
-      state: {
-        position: 1,
-        velocity: 0
-      },
-      from: 1,
-      to: 0,
-      direction: "forward"
-    };
-  }
-}), wt = () => ({
-  runIn: async (e) => e.in ? {
-    config: await e.in,
-    state: {
-      position: 0,
-      velocity: 0
-    },
-    from: 0,
-    to: 1,
-    direction: "forward"
-  } : {
-    state: {
-      position: 0,
-      velocity: 0
+  };
+}
+function Ot() {
+  return {
+    outPhysics: K,
+    inPhysics: K,
+    // 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: It
+  };
+}
+const J = 30, kt = {
+  inertia: { acceleration: 150, resistance: 1.5 }
+}, Lt = {
+  spring: { stiffness: 180, damping: 34 }
+};
+function Ft({
+  direction: e
+}) {
+  const t = e === "forward" ? 1 : -1, n = -J * t, s = J * t;
+  return {
+    out: {
+      willChange: "transform, opacity",
+      startStyle: {},
+      animate: (o) => ({
+        transform: `translate3d(${n * o}px, 0, 0)`,
+        opacity: `${1 - o}`
+      })
     },
-    from: 0,
-    to: 1,
-    direction: "forward"
-  },
-  runOut: async (e) => e.out ? {
-    config: await e.out,
-    state: {
-      position: 1,
-      velocity: 0
+    in: {
+      willChange: "transform, opacity",
+      startStyle: {
+        transform: `translate3d(${s}px, 0, 0)`,
+        opacity: "0"
+      },
+      animate: (o) => ({
+        transform: `translate3d(${s * (1 - o)}px, 0, 0)`,
+        opacity: `${o}`
+      })
+    }
+  };
+}
+function Yt() {
+  return {
+    outPhysics: kt,
+    inPhysics: Lt,
+    // 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: Ft
+  };
+}
+const Ht = {
+  snappy: Ot(),
+  fluid: Yt()
+}, Q = {
+  spring: { stiffness: 2400, damping: 65, doubleSpring: 0.7 }
+}, O = 8;
+function Mt({ direction: e }) {
+  const t = e === "forward" ? -O : O, n = e === "forward" ? O : -O;
+  return {
+    out: {
+      willChange: "transform, opacity",
+      startStyle: {},
+      animate: (s) => ({
+        transform: `translate3d(0, ${t * s}px, 0)`,
+        opacity: `${1 - s}`
+      })
     },
-    from: 1,
-    to: 0,
-    direction: "forward"
-  } : {
-    state: {
-      position: 1,
-      velocity: 0
+    in: {
+      willChange: "transform, opacity",
+      startStyle: {
+        transform: `translate3d(0, ${n}px, 0)`,
+        opacity: "0"
+      },
+      animate: (s) => ({
+        transform: `translate3d(0, ${n * (1 - s)}px, 0)`,
+        opacity: `${s}`
+      })
+    }
+  };
+}
+function zt() {
+  return {
+    outPhysics: Q,
+    inPhysics: Q,
+    composition: { mode: "parallel", startAt: [0, 0.3] },
+    build: Mt
+  };
+}
+const R = {
+  spring: { stiffness: 280, damping: 30 }
+}, k = 0.05;
+function Ut() {
+  return {
+    // Outgoing scales up slightly (1 → 1+s) while fading — recedes toward
+    // viewer feel, complementing the incoming page rising from below.
+    out: {
+      willChange: "transform, opacity",
+      startStyle: {},
+      animate: (e) => ({
+        transform: `scale(${1 + e * k})`,
+        opacity: `${1 - e}`
+      })
     },
-    from: 1,
-    to: 0,
-    direction: "forward"
-  }
-}), tt = "data-ssgoi-scope", et = "data-ssgoi-scope-ready";
+    // Incoming rises from below (1-s → 1) with fade in.
+    in: {
+      willChange: "transform, opacity",
+      startStyle: {
+        transform: `scale(${1 - k})`,
+        opacity: "0"
+      },
+      animate: (e) => ({
+        transform: `scale(${1 - k + e * k})`,
+        opacity: `${e}`
+      })
+    }
+  };
+}
 function Xt() {
-  return (e) => {
-    if (e)
-      return e.setAttribute(tt, ""), queueMicrotask(() => {
-        queueMicrotask(() => {
-          e.setAttribute(et, "true");
-        });
-      }), () => {
-      };
+  return {
+    outPhysics: R,
+    inPhysics: R,
+    // Both pages share the canvas (in-place scale+fade), so a strict
+    // fade-through-with-offset would feel disjointed. Run them together
+    // for a cleaner cross-fade.
+    composition: { mode: "parallel" },
+    build: Ut
   };
 }
-function pt(e) {
-  return e.hasAttribute(et);
+const Vt = zt(), Bt = Xt(), Nt = {
+  x: Ht,
+  // y and z don't yet have a `fluid` variant — the lookup falls back to
+  // `snappy` if asked for `fluid` on them.
+  y: { snappy: Vt },
+  z: { snappy: Bt }
+};
+function Wt(e, t) {
+  const n = Nt[e];
+  return n[t] ?? n.snappy;
 }
-function vt(e) {
-  return e.closest(`[${tt}]`);
+const Zt = "x", qt = "snappy";
+function tt(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 H = /* @__PURE__ */ new Set(["auto", "scroll", "overlay"]), St = (e) => {
-  let i = e.parentElement;
-  for (; i && i !== document.body; ) {
-    const t = window.getComputedStyle(i);
-    if (H.has(t.overflowY) || H.has(t.overflowX))
-      return i;
-    i = i.parentElement;
-  }
-  return document.documentElement;
-}, Et = (e) => {
-  let i = e.parentElement;
-  for (; i && i !== document.body; ) {
-    const t = window.getComputedStyle(i).position;
-    if (t === "relative" || t === "absolute" || t === "fixed" || t === "sticky")
-      return i;
-    i = i.parentElement;
-  }
-  return document.body;
-};
-function K(e) {
-  return new Promise((i) => {
-    requestAnimationFrame(() => {
-      requestAnimationFrame(() => {
-        i();
+function jt(e) {
+  e.style.willChange = "auto", e.style.backfaceVisibility = "", e.style.contain = "", e.style.transform = "", e.style.opacity = "";
+}
+const Gt = (e = {}) => {
+  const t = e.direction ?? "forward", n = e.type ?? Zt, s = e.feel ?? qt, o = Wt(n, s), i = o.build({ direction: t });
+  return {
+    prepare: ({ from: r, to: l }) => (r.then((c) => {
+      tt(c, i.out), c.style.pointerEvents = "none";
+    }), l.then((c) => {
+      tt(c, i.in);
+    }), {}),
+    animation: ({ from: r, to: l }) => {
+      const c = new b({
+        element: r,
+        integrator: g.from(o.outPhysics),
+        style: (p) => i.out.animate(p)
+      }), a = new b({
+        element: l,
+        integrator: g.from(o.inPhysics),
+        style: (p) => i.in.animate(p),
+        onComplete: () => jt(l)
       });
-    });
-  });
+      return new E([c, a], o.composition);
+    }
+  };
+};
+function Kt(e, t, n) {
+  return e !== "x" || t === "snappy" || n === "snappy" ? "snappy" : "fluid";
+}
+function Cn(e) {
+  const { paths: t } = e, n = e.type ?? "x", s = e.variant, o = e.feel, i = Kt(n, s, o);
+  return q(
+    t,
+    { forward: "forward", backward: "backward" },
+    (r) => Gt({ type: n, direction: r, feel: i })
+  );
 }
-function At(e, i) {
-  var S;
-  let t = null, n = null, r = null, o = null;
-  const s = {
-    get currentAnimation() {
-      return t;
+const Jt = {
+  spring: { stiffness: 200, damping: 22 }
+}, Qt = 10, Rt = "horizontal", te = "#000000";
+function et(e, t, n, s, o, i) {
+  window.getComputedStyle(e).position === "static" && (e.style.position = "relative");
+  const l = document.createElement("div");
+  l.style.cssText = `
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    pointer-events: none;
+    z-index: 9999;
+    overflow: hidden;
+  `;
+  const c = [];
+  for (let a = 0; a < t; a++) {
+    const p = document.createElement("div");
+    if (n === "horizontal") {
+      const d = 100 / t;
+      p.style.cssText = `
+        position: absolute;
+        top: ${d * a}%;
+        left: 0;
+        width: 100%;
+        height: calc(${d}% + 1px);
+        background: ${s};
+        transform: scaleX(${o === "hidden" ? 0 : 1});
+        transform-origin: ${i} center;
+        will-change: transform;
+      `;
+    } else {
+      const d = 100 / t;
+      p.style.cssText = `
+        position: absolute;
+        top: 0;
+        left: ${d * a}%;
+        width: calc(${d}% + 1px);
+        height: 100%;
+        background: ${s};
+        transform: scaleY(${o === "hidden" ? 0 : 1});
+        transform-origin: ${i === "left" ? "top" : "bottom"} center;
+        will-change: transform;
+      `;
     }
-  }, m = ((S = i == null ? void 0 : i.strategy) == null ? void 0 : S.call(i, s)) || yt(s), l = async (y) => {
-    var g, C;
-    n && (n.remove(), n = null);
-    const p = e(), k = p.in && p.in(y), T = !(i != null && i.strategy) && p.out ? p.out(y) : void 0;
-    if (!k)
-      return;
-    const w = {
-      in: F(k),
-      out: T ? F(T) : void 0
-    }, f = await m.runIn(w);
-    if (!f.config) {
-      t && (t.direction = "in");
-      return;
+    c.push(p), l.appendChild(p);
+  }
+  return e.appendChild(l), { container: l, blinds: c };
+}
+const ee = (e = {}) => {
+  const t = e.blindCount ?? Qt, n = e.direction ?? Rt, s = e.blindColor ?? te, o = e.physics ?? Jt;
+  return {
+    prepare: async ({ from: i, to: r }) => {
+      const l = await i, c = await r;
+      l.style.zIndex = "1000";
+      const a = et(
+        l,
+        t,
+        n,
+        s,
+        "hidden",
+        "left"
+      );
+      c.style.position = "relative", c.style.zIndex = "0";
+      const p = et(
+        c,
+        t,
+        n,
+        s,
+        "closed",
+        "right"
+      );
+      return {
+        fromBlinds: a.blinds,
+        fromContainer: a.container,
+        toBlinds: p.blinds,
+        toContainer: p.container
+      };
+    },
+    animation: ({ fromBlinds: i, fromContainer: r, toBlinds: l, toContainer: c }) => {
+      const a = i.map(
+        (m) => new b({
+          element: m,
+          integrator: g.from(o),
+          style: (f) => ({
+            transform: n === "horizontal" ? `scaleX(${f})` : `scaleY(${f})`
+          })
+        })
+      ), p = l.map(
+        (m, f) => new b({
+          element: m,
+          integrator: g.from(o),
+          style: (h, y) => ({
+            transform: n === "horizontal" ? `scaleX(${y})` : `scaleY(${y})`
+          }),
+          onComplete: f === l.length - 1 ? () => {
+            c.remove(), r.remove();
+          } : void 0
+        })
+      ), d = new E(a, { mode: "parallel" }), u = new E(p, { mode: "parallel" });
+      return new E([d, u], { mode: "sequence" });
     }
-    const a = f.config;
-    (g = a.prepare) == null || g.call(a);
-    const A = W(
-      {
-        ...a,
-        onEnd: () => {
-          var b;
-          t = null, (b = a.onEnd) == null || b.call(a);
-        }
+  };
+};
+function Pn(e) {
+  const { paths: t, type: n = "horizontal" } = e;
+  return P(
+    t,
+    () => ee({ direction: n })
+  );
+}
+const ne = {
+  spring: { stiffness: 200, damping: 20, doubleSpring: 0.7 }
+}, D = 0.5;
+function se(e) {
+  const t = e === "enter" ? -100 : 100, n = e === "enter" ? 100 : -100;
+  return {
+    out: {
+      willChange: "transform, opacity",
+      startStyle: {},
+      animate: (s) => ({
+        transform: `translate3d(${t * s}%, 0, 0)`,
+        opacity: `${D + (1 - D) * (1 - s)}`
+      })
+    },
+    in: {
+      willChange: "transform, opacity",
+      startStyle: {
+        transform: `translate3d(${n}%, 0, 0)`,
+        opacity: `${D}`
       },
-      y
-    );
-    a.wait && await a.wait();
-    const c = _.fromState(f.state, {
-      config: A,
-      from: f.from,
-      to: f.to
-    });
-    t = { controller: c, direction: "in" }, (C = a.onReady) == null || C.call(a), await K(), f.direction === "forward" ? c.forward() : c.backward();
-  }, u = async (y) => {
-    var C, b;
-    n = y;
-    const p = e(), k = !(i != null && i.strategy) && p.in ? p.in(y) : void 0, T = p.out && p.out(y);
-    if (!T)
-      return;
-    const w = {
-      in: k ? F(k) : void 0,
-      out: F(T)
-    }, f = await m.runOut(w);
-    if (!f.config) {
-      t && (t.direction = "out"), n && (n.remove(), n = null);
-      return;
+      animate: (s) => ({
+        transform: `translate3d(${n * (1 - s)}%, 0, 0)`,
+        opacity: `${D + (1 - D) * s}`
+      })
     }
-    const a = f.config;
-    g(), (C = a.prepare) == null || C.call(a);
-    const A = W(
-      {
-        ...a,
-        onEnd: () => {
-          var R, M;
-          (R = a.onEnd) == null || R.call(a), n && (n.remove(), n = null), t = null, (M = i == null ? void 0 : i.onCleanupEnd) == null || M.call(i);
-        }
+  };
+}
+function oe() {
+  return {
+    physics: ne,
+    build: se
+  };
+}
+const re = {
+  spring: { stiffness: 170, damping: 22 }
+};
+function ie(e) {
+  const t = e === "enter" ? -20 : 100, n = e === "enter" ? 100 : -20;
+  return {
+    out: {
+      willChange: "transform",
+      startStyle: {},
+      animate: (s) => ({
+        transform: `translate3d(${t * s}%, 0, 0)`
+      })
+    },
+    in: {
+      willChange: "transform",
+      startStyle: {
+        transform: `translate3d(${n}%, 0, 0)`
       },
-      y
-    );
-    a.wait && await a.wait();
-    const c = _.fromState(f.state, {
-      config: A,
-      from: f.from,
-      to: f.to
-    });
-    t = { controller: c, direction: "out" }, (b = a.onReady) == null || b.call(a), await K(), f.direction === "forward" ? c.forward() : c.backward();
-    function g() {
-      !r || !n || (o && r.contains(o) ? r.insertBefore(n, o) : r.appendChild(n));
+      animate: (s) => ({
+        transform: `translate3d(${n * (1 - s)}%, 0, 0)`
+      })
     }
   };
-  let h = null, v = !1;
-  const E = (y) => () => {
-    if (v) return;
-    v = !0;
-    const p = y.cloneNode(!0);
-    h ? queueMicrotask(() => {
-      document.contains(h) && u(p);
-    }) : u(p);
-  };
-  return (y) => {
-    if (y)
-      return requestAnimationFrame(() => {
-        r = y.parentElement, o = y.nextElementSibling;
-      }), v = !1, (i == null ? void 0 : i.scope) === "local" ? queueMicrotask(() => {
-        h = vt(y), !(h && !pt(h)) && l(y);
-      }) : l(y), E(y);
+}
+function ae() {
+  return {
+    physics: re,
+    build: ie
   };
 }
-const P = /* @__PURE__ */ new Map();
-let I = null, q = !1;
-function nt(e) {
-  if (e instanceof HTMLElement && P.has(e)) {
-    const t = P.get(e);
-    P.delete(e), queueMicrotask(() => {
-      t();
-    });
-  }
-  const i = e.childNodes;
-  for (let t = 0; t < i.length; t++) {
-    const n = i[t];
-    n && nt(n);
-  }
+const le = {
+  parallax: ae(),
+  crossfade: oe()
+}, ce = "parallax";
+function nt(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 Ct() {
-  q || typeof document > "u" || (q = !0, I = new MutationObserver((e) => {
-    for (const i of e) {
-      const t = i.removedNodes;
-      for (let n = 0; n < t.length; n++) {
-        const r = t[n];
-        r && nt(r);
-      }
+const pe = (e = {}) => {
+  const t = e.direction ?? "enter", n = le[e.type ?? ce], s = n.physics, o = n.build(t);
+  return {
+    prepare: ({ from: i, to: r }) => (i.then((l) => {
+      nt(l, o.out), l.style.pointerEvents = "none", l.style.zIndex = t === "enter" ? "-1" : "100";
+    }), r.then((l) => {
+      nt(l, o.in);
+    }), {}),
+    animation: ({ from: i, to: r }) => {
+      const l = new b({
+        element: i,
+        integrator: g.from(s),
+        style: (a) => o.out.animate(a)
+      }), c = new b({
+        element: r,
+        integrator: g.from(s),
+        style: (a) => o.in.animate(a),
+        onComplete: () => {
+          r.style.willChange = "auto", r.style.backfaceVisibility = "", r.style.contain = "", r.style.transform = "", r.style.opacity = "";
+        }
+      });
+      return new E([l, c], { mode: "parallel" });
     }
-  }), document.body ? I.observe(document.body, {
-    childList: !0,
-    subtree: !0
-  }) : document.addEventListener(
-    "DOMContentLoaded",
-    () => {
-      I == null || I.observe(document.body, {
-        childList: !0,
-        subtree: !0
+  };
+};
+function de(e) {
+  return e === "slide" || e === "crossfade" ? "crossfade" : "parallax";
+}
+function vn(e) {
+  const { enter: t, exit: n } = e, s = e.type, o = de(s);
+  return ht(
+    { enter: t, exit: n },
+    (i) => pe({ direction: i, type: o })
+  );
+}
+const fe = {
+  spring: { stiffness: 180, damping: 20, doubleSpring: !0 }
+}, he = {
+  spring: { stiffness: 170, damping: 20, doubleSpring: !0 }
+}, ue = (e = {}) => {
+  const t = e.physics ?? he, n = e.physics ?? fe;
+  return {
+    prepare: ({ to: s }) => (s.then((o) => {
+      o.style.opacity = "0", o.style.willChange = "opacity";
+    }), {}),
+    animation: ({ from: s, to: o }) => {
+      const i = new b({
+        element: s,
+        integrator: g.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 }),
+        onComplete: () => {
+          s.style.willChange = "auto";
+        }
+      }), r = new b({
+        element: o,
+        integrator: g.from(t),
+        style: (l) => ({ opacity: l }),
+        onComplete: () => {
+          o.style.willChange = "auto", o.style.opacity = "";
+        }
       });
-    },
-    { once: !0 }
-  ));
+      return new E([i, r], { mode: "sequence" });
+    }
+  };
+};
+function Tn(e) {
+  const { paths: t } = e;
+  return P(t, () => ue());
 }
-function Tt(e, i) {
-  Ct(), P.set(e, i);
+function T(e, t) {
+  function n(i) {
+    let r = 0, l = 0;
+    const c = i.offsetWidth, a = 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 };
+  }
+  const s = n(e), o = n(t);
+  return new DOMRect(
+    o.left - s.left,
+    o.top - s.top,
+    o.width,
+    o.height
+  );
 }
-function Wt(e) {
-  return P.has(e);
+function _(e, t) {
+  const { scrollingElement: n, positionedParent: s } = e, o = n !== s && n.contains(s) ? T(n, s).top : 0;
+  return {
+    top: e[t].scroll.y,
+    left: 0,
+    width: n.clientWidth,
+    height: n.clientHeight - o
+  };
 }
-function Ut() {
-  return P.size;
-}
-function Bt(e) {
-  const i = P.get(e);
-  return i ? (P.delete(e), i(), !0) : !1;
-}
-function Ht() {
-  P.clear(), I == null || I.disconnect(), I = null, q = !1;
-}
-const O = /* @__PURE__ */ new Map(), N = /* @__PURE__ */ new Map(), X = /* @__PURE__ */ new Map();
-function bt(e, i, t) {
-  O.set(e, i);
-  let n = N.get(e);
-  if (n)
-    return n;
-  const r = i;
-  return n = At(
-    () => {
-      const o = O.get(e);
-      return o || (console.warn(`Transition "${String(e)}" not found`), {});
-    },
-    {
-      strategy: t == null ? void 0 : t.strategy,
-      scope: t == null ? void 0 : t.scope,
-      onCleanupEnd: () => {
-        O.get(e) === r && kt(e);
-      }
+const z = {
+  scaleDown: { stiffness: 20, damping: 7 },
+  translate: { stiffness: 15, damping: 7 },
+  scaleUp: { stiffness: 20, damping: 7 }
+}, v = {
+  scaleDown: 0,
+  translate: 0.2,
+  scaleUp: 0.8
+}, me = 0.8, ye = "white", st = 1e3 / 60, ge = 600;
+function be(e) {
+  const { items: t, from: n, to: s, recordFrame: o } = e, i = st / 1e3, r = Math.abs(s - n), l = t.map((a) => ({
+    item: a,
+    integrator: new F({
+      stiffness: a.spring.stiffness,
+      damping: a.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);
+  o(0);
+  let c = 0;
+  for (let a = 1; a <= ge; a++) {
+    const p = a * st;
+    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 >= Ct && (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 u = l[d];
+      if (u.started) continue;
+      const m = l[d - 1];
+      if (!m.started) continue;
+      (r === 0 ? 1 : Math.abs(m.state.position - n) / r) >= u.item.offset && (u.started = !0);
     }
-  ), N.set(e, n), n;
+    if (o(p), l.every((d) => d.settled)) return p;
+  }
+  return c;
 }
-function kt(e) {
-  O.delete(e), N.delete(e), X.delete(e);
+function U(e, t) {
+  return e != null && e.spring ? {
+    stiffness: e.spring.stiffness,
+    damping: e.spring.damping
+  } : t;
 }
-function Kt(e, i = "manual") {
-  const t = bt(
-    e.key,
+function ot(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 = U(o, z.scaleDown), l = U(o, z.translate), c = U(o, z.scaleUp), a = s === "out" ? 1 : 0, p = s === "out" ? 0 : 1, d = s === "out" ? [
     {
-      in: e.in,
-      out: e.out
+      spring: r,
+      offset: v.scaleDown,
+      tick: (f) => {
+        const h = 1 - f;
+        i.scale = 1 - (1 - n) * h;
+      }
     },
     {
-      strategy: e[Q],
-      scope: e.scope
+      spring: l,
+      offset: v.translate,
+      tick: (f) => {
+        const h = 1 - f;
+        i.translateY = -t.top - t.height * h;
+      }
+    },
+    {
+      spring: c,
+      offset: v.scaleUp,
+      tick: (f) => {
+        const h = 1 - f;
+        i.scale = n + (1 - n) * h;
+      }
     }
-  );
-  if (i === "manual")
-    return t;
-  let n = X.get(e.key);
-  return n || (n = (r) => {
-    if (r) {
-      const o = t(r);
-      o && Tt(r, o);
+  ] : [
+    {
+      spring: r,
+      offset: v.scaleDown,
+      tick: (f) => {
+        i.scale = 1 - (1 - n) * f;
+      }
+    },
+    {
+      spring: l,
+      offset: v.translate,
+      tick: (f) => {
+        i.translateY = -t.top + t.height * (1 - f);
+      }
+    },
+    {
+      spring: c,
+      offset: v.scaleUp,
+      tick: (f) => {
+        i.scale = n + (1 - n) * f;
+      }
     }
-  }, X.set(e.key, n), n);
-}
-function Rt(e) {
-  const i = e.filter((t) => t.symmetric).map((t) => ({
-    from: t.to,
-    to: t.from,
-    transition: t.transition
-  }));
-  return [...e, ...i];
-}
-function V(e, i) {
-  if (i === "*")
-    return !0;
-  if (i.endsWith("/*")) {
-    const t = i.slice(0, -1);
-    return e.startsWith(t) && e.length > t.length;
-  }
-  return e === i;
-}
-function It(e, i, t) {
-  for (const n of t)
-    if (V(e, n.from) && V(i, n.to))
-      return n.transition;
-  for (const n of t)
-    if ((n.from === "*" || V(e, n.from)) && (n.to === "*" || V(i, n.to)))
-      return n.transition;
-  return null;
+  ], u = [], m = be({
+    items: d,
+    from: a,
+    to: p,
+    recordFrame: (f) => u.push({
+      time: f,
+      scale: i.scale,
+      translateY: i.translateY
+    })
+  });
+  return { snapshots: u, totalDuration: m };
 }
-const Pt = 768, Mt = 10, Vt = 10;
-function xt(e = {}) {
-  const { preserveScroll: i = (c) => c } = e, t = typeof i == "function" ? i : () => i;
-  let n = null, r = !1, o = !1;
-  const s = () => {
-    const c = (n == null ? void 0 : n.clientWidth) ?? 0, g = c > 0 ? c : typeof window < "u" ? window.innerWidth : 0;
-    return g > 0 && g < Pt;
-  }, m = () => (o || (r = s(), o = !0), r), l = (c) => {
-    const g = t(m());
-    return g === !1 ? !1 : g === !0 ? !0 : !g.exclude.some((C) => V(c, C));
+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;
+  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
   };
-  let u = null;
-  const h = /* @__PURE__ */ new Map();
-  let v = null, E = !1, S = 0;
-  const y = () => {
-    n && v && !E && h.set(v, {
-      x: n.scrollLeft,
-      y: n.scrollTop
+}
+const Se = [
+  [1, 1],
+  [-1, 1],
+  [1, -1],
+  [-1, -1]
+];
+function $e(e, t) {
+  const o = (i, r, l) => {
+    const c = document.createElement("div");
+    Object.assign(c.style, {
+      position: "fixed",
+      pointerEvents: "none",
+      zIndex: "9999",
+      width: "15px",
+      height: "15px",
+      ...i
     });
-  }, p = (c) => {
-    if (!n) return;
-    const g = l(c) && h.has(c) ? h.get(c) : { x: 0, y: 0 };
-    let C = 0;
-    const b = () => {
-      if (!n) return;
-      n.scrollTo({
-        top: g.y,
-        left: g.x
-      }), !(Math.abs(n.scrollTop - g.y) < 1 && Math.abs(n.scrollLeft - g.x) < 1) && C < Mt && (C++, requestAnimationFrame(b));
-    };
-    requestAnimationFrame(b);
+    const a = document.createElement("div");
+    Object.assign(a.style, {
+      position: "absolute",
+      width: "15px",
+      height: "1px",
+      backgroundColor: e,
+      [l]: "0",
+      [r]: "0"
+    });
+    const p = document.createElement("div");
+    return Object.assign(p.style, {
+      position: "absolute",
+      width: "1px",
+      height: "15px",
+      backgroundColor: e,
+      [l]: "0",
+      [r]: "0"
+    }), c.appendChild(a), c.appendChild(p), c;
   };
   return {
-    initializeContext: (c, g) => {
-      E = !0;
-      const C = ++S;
-      u = c, n || (n = St(c), r = s(), o = !0, typeof ResizeObserver < "u" && new ResizeObserver(() => {
-        r = s();
-      }).observe(n), (n === document.documentElement ? window : n).addEventListener("scroll", y, {
-        passive: !0
-      })), v = g, p(g);
-      let b = 0;
-      const R = () => {
-        C === S && (b++, b >= Vt ? E = !1 : requestAnimationFrame(R));
-      };
-      requestAnimationFrame(R);
-    },
-    calculateScrollOffset: (c, g) => {
-      const C = c && h.has(c) ? h.get(c) : { x: 0, y: 0 }, b = g && l(g) && h.has(g) ? h.get(g) : { x: 0, y: 0 };
-      return {
-        x: -b.x + C.x,
-        y: -b.y + C.y
-      };
-    },
-    evictScrollPosition: (c) => {
-      h.delete(c);
+    topLeft: o(
+      {
+        top: `${t.top - 1}px`,
+        left: `${t.left - 1}px`
+      },
+      "left",
+      "top"
+    ),
+    topRight: o(
+      {
+        top: `${t.top - 1}px`,
+        left: `${t.left + t.width - 15 + 1}px`
+      },
+      "right",
+      "top"
+    ),
+    bottomLeft: o(
+      {
+        top: `${t.top + t.height - 15 + 1}px`,
+        left: `${t.left - 1}px`
+      },
+      "left",
+      "bottom"
+    ),
+    bottomRight: o(
+      {
+        top: `${t.top + t.height - 15 + 1}px`,
+        left: `${t.left + t.width - 15 + 1}px`
+      },
+      "right",
+      "bottom"
+    )
+  };
+}
+function rt(e, t) {
+  const n = t.left + t.width / 2, s = t.top + t.height / 2;
+  e.style.transformOrigin = `${n}px ${s}px`;
+}
+function it(e, t) {
+  e.style.clipPath = `polygon(
+    ${t.left}px ${t.top}px,
+    ${t.left + t.width}px ${t.top}px,
+    ${t.left + t.width}px ${t.top + t.height}px,
+    ${t.left}px ${t.top + t.height}px
+  )`;
+}
+function X(e, t, n, s, o) {
+  const i = n / 1e3;
+  return new b({
+    element: e,
+    integrator: new At({ durationSec: i }),
+    lowerBound: 0,
+    upperBound: 1,
+    style: (r) => s(we(t, r)),
+    onComplete: o
+  });
+}
+const xe = (e = {}) => {
+  var o;
+  const t = ((o = e.border) == null ? void 0 : o.color) ?? ye, n = me, s = e.physics;
+  return {
+    prepare: ({ from: i, to: r, context: l }) => {
+      const c = _(l, "from"), a = _(l, "to"), p = T(document.body, l.positionedParent), d = $e(t, {
+        ...c,
+        top: p.top
+      });
+      for (const u of [
+        "topLeft",
+        "topRight",
+        "bottomLeft",
+        "bottomRight"
+      ])
+        l.positionedParent.appendChild(d[u]);
+      return i.then((u) => {
+        rt(u, c), it(u, c), u.style.transform = `translateY(${-c.top}px)`;
+      }), r.then((u) => {
+        rt(u, a), it(u, a), u.style.transform = `translateY(${-a.top + a.height}px) scale(${n})`;
+      }), { borders: d, fromRect: c, toRect: a };
     },
-    shouldPreserve: l,
-    getScrollContainer: () => n,
-    getPositionedParentElement: () => u ? Et(u) : document.body,
-    getScrollPosition: (c) => c && h.has(c) ? h.get(c) : { x: 0, y: 0 }
+    animation: ({ from: i, to: r, context: l, borders: c, fromRect: a, toRect: p }) => {
+      const d = ot({
+        rect: a,
+        scale: n,
+        direction: "out",
+        override: s
+      }), u = ot({
+        rect: p,
+        scale: n,
+        direction: "in",
+        override: s
+      }), m = X(
+        i,
+        d.snapshots,
+        d.totalDuration,
+        (S) => ({
+          transform: `translateY(${S.translateY}px) scale(${S.scale})`
+        }),
+        () => {
+          i.style.clipPath = "", i.style.transformOrigin = "";
+        }
+      ), f = X(
+        r,
+        u.snapshots,
+        u.totalDuration,
+        (S) => ({
+          transform: `translateY(${S.translateY}px) scale(${S.scale})`
+        }),
+        () => {
+          r.style.clipPath = "", r.style.transformOrigin = "", r.style.transform = "";
+        }
+      ), h = Se.map(([S, x], C) => {
+        const Y = ["topLeft", "topRight", "bottomLeft", "bottomRight"][C];
+        return X(
+          c[Y],
+          d.snapshots,
+          d.totalDuration,
+          (A) => {
+            const H = (a.width - a.width * A.scale) / 2 * 0.7 * S, M = (a.height - a.height * A.scale) / 2 * 0.7 * x;
+            return { transform: `translate(${H}px, ${M}px)` };
+          }
+        );
+      }), y = new E([m, f, ...h], {
+        mode: "parallel"
+      }), w = y.onComplete;
+      return y.onComplete = () => {
+        w == null || w();
+        const S = l.positionedParent;
+        for (const x of [
+          "topLeft",
+          "topRight",
+          "bottomLeft",
+          "bottomRight"
+        ]) {
+          const C = c[x];
+          C.parentElement === S && S.removeChild(C);
+        }
+      }, y;
+    }
+  };
+};
+function Dn(e) {
+  const { paths: t, options: n } = e, s = (n == null ? void 0 : n.borderColor) !== void 0 ? { border: { color: n.borderColor } } : void 0;
+  return P(t, () => xe(s));
+}
+const Ee = {
+  spring: { stiffness: 300, damping: 30 }
+};
+function Ce(e, t) {
+  return e.querySelector(`[data-hero-key="${t}"]`);
+}
+const Pe = (e = {}) => {
+  const t = e.physics ?? Ee, n = e.maxDistance ?? 700;
+  return {
+    prepare: ({ from: s }) => (s.then((o) => {
+      o.style.opacity = "0";
+    }), {}),
+    animation: ({ from: s, to: o, context: i }) => {
+      const r = s, l = o, c = Array.from(
+        l.querySelectorAll("[data-hero-key]")
+      ), a = [];
+      for (const f of c) {
+        const h = f.getAttribute("data-hero-key");
+        if (!h) continue;
+        const y = Ce(r, h);
+        y && a.push({ key: h, fromEl: y, toEl: f });
+      }
+      if (a.length === 0)
+        return new E([], { mode: "parallel" });
+      const p = [], d = [];
+      for (const { fromEl: f, toEl: h } of a) {
+        const y = T(r, f), w = T(l, h), S = y.left - w.left - i.scrollOffset.x, x = y.top - w.top - i.scrollOffset.y, C = y.width / w.width, Y = y.height / w.height;
+        if (Math.abs(x) > n) continue;
+        const A = h.style.transform, H = h.style.position, M = h.style.transformOrigin, yt = h.style.zIndex, gt = h.style.willChange;
+        h.style.position = "relative", h.style.transformOrigin = "top left", h.style.zIndex = "1000", h.style.willChange = "transform", p.push(
+          new b({
+            element: h,
+            integrator: g.from(t),
+            style: (j, I) => {
+              const bt = I * S, wt = I * x, St = j + I * C, $t = j + I * Y;
+              return {
+                transform: `translate(${bt}px, ${wt}px) scale(${St}, ${$t})`
+              };
+            }
+          })
+        ), d.push(() => {
+          h.style.transform = A, h.style.position = H, h.style.transformOrigin = M, h.style.zIndex = yt, h.style.willChange = gt;
+        });
+      }
+      const u = new E(p, {
+        mode: "parallel"
+      }), m = u.onComplete;
+      return u.onComplete = () => {
+        for (const f of d) f();
+        m == null || m();
+      }, u;
+    }
+  };
+};
+function _n(e) {
+  const { paths: t } = e;
+  return P(t, () => Pe());
+}
+const ve = {
+  spring: { stiffness: 50, damping: 30 }
+}, Te = {
+  spring: { stiffness: 80, damping: 25 }
+}, De = (e = {}) => {
+  const t = e.physics ?? ve, 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 = _(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, u = a.top + a.height / 2;
+      c.style.transformOrigin = `${d}px ${u}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";
+    }), {}),
+    animation: ({ from: i, to: r }) => {
+      const l = new b({
+        element: i,
+        integrator: g.from(Te),
+        style: (a, p) => ({ opacity: p })
+      }), c = new b({
+        element: r,
+        integrator: g.from(t),
+        style: (a) => {
+          let p;
+          if (a <= 0.05)
+            p = s;
+          else if (a <= o) {
+            const f = (a - 0.05) / (o - 0.05), h = Math.pow(f, 9);
+            p = s + (0.8 - s) * h;
+          } else {
+            const f = (a - o) / (1 - o);
+            p = 0.8 + 0.2 * (1 - Math.pow(1 - f, 3));
+          }
+          const d = 0.7;
+          let u;
+          if (a <= d)
+            u = n;
+          else {
+            const f = (a - d) / (1 - d), h = 1 - Math.pow(1 - f, 2);
+            u = n * (1 - h);
+          }
+          let m;
+          if (a <= d)
+            m = 1;
+          else {
+            const f = (a - d) / (1 - d);
+            m = 1 - Math.pow(f, 0.5);
+          }
+          return {
+            transform: `rotate(${u.toFixed(2)}deg) scale(${p.toFixed(4)}) translateZ(0)`,
+            "--border-radius-scale": m.toFixed(4)
+          };
+        },
+        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 = "";
+        }
+      });
+      return new E([l, c], { mode: "parallel" });
+    }
   };
+};
+function An(e) {
+  const { paths: t } = e;
+  return P(t, () => De());
 }
-const j = 30, Y = 8, G = 1.2, $ = 30, Ft = 600;
-function Lt() {
-  let e = null, i = !1, t = !1, n = null, r = null, o = !1;
-  const s = (w, f) => {
-    for (let a = 0; a < w.length; a++) {
-      const A = w.item(a);
-      if (A && A.identifier === f) return A;
+const _e = {
+  spring: { stiffness: 100, damping: 30 }
+}, Ae = (e = {}) => {
+  const t = e.physics ?? _e;
+  return {
+    prepare: ({ from: n, to: s }) => (n.then((o) => {
+      o.style.transformOrigin = "center center", o.style.willChange = "transform, opacity";
+    }), s.then((o) => {
+      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 b({
+        element: n,
+        integrator: g.from(t),
+        style: (r) => ({
+          transform: `rotate(${r * 180}deg)`,
+          opacity: r < 0.5 ? 1 : 0
+        })
+      }), i = new b({
+        element: s,
+        integrator: g.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
+        }),
+        onComplete: () => {
+          s.style.willChange = "auto", s.style.transform = "", s.style.transformOrigin = "", s.style.opacity = "";
+        }
+      });
+      return new E([o, i], { mode: "parallel" });
     }
-    return null;
-  }, m = () => {
-    n !== null && (clearTimeout(n), n = null);
-  }, l = () => {
-    r !== null && (clearTimeout(r), r = null);
-  }, u = () => {
-    i = !0, t = !0, m(), l(), n = setTimeout(() => {
-      i = !1, t = !1, n = null;
-    }, Ft);
-  }, h = (w) => {
-    if (w.touches.length !== 1) {
-      e = null;
-      return;
+  };
+};
+function In(e) {
+  const { paths: t } = e;
+  return P(t, () => Ae());
+}
+const Ie = {
+  spring: {
+    stiffness: 20,
+    damping: 8,
+    doubleSpring: 1,
+    restDelta: 1e-3,
+    restSpeed: 1e-3
+  }
+}, at = (e = {}) => {
+  const t = e.direction ?? "up", n = e.physics ?? Ie, s = t === "up";
+  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";
+    }), {}),
+    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 b({
+        element: o,
+        integrator: g.from(n),
+        style: (u) => ({ transform: `translate3d(0, ${s ? -a * u : a * u}px, 0)` })
+      }), d = new b({
+        element: i,
+        integrator: g.from(n),
+        style: (u, m) => ({ transform: `translate3d(0, ${s ? m * a : m * -a}px, 0)` }),
+        onComplete: () => {
+          i.style.willChange = "auto", i.style.backfaceVisibility = "", i.style.contain = "", i.style.transform = "";
+        }
+      });
+      return new E([p, d], { mode: "parallel" });
     }
-    const f = w.touches.item(0);
-    if (!f) {
-      e = null;
-      return;
+  };
+};
+function On(e) {
+  const { paths: t, type: n = "directional" } = e;
+  return n === "non-directional" ? P(
+    t,
+    () => at({ direction: "up" })
+  ) : q(
+    t,
+    { forward: "up", backward: "down" },
+    (s) => at({ direction: s })
+  );
+}
+const Oe = {
+  spring: { stiffness: 200, damping: 24 }
+}, ke = {
+  inertia: { acceleration: 25, resistance: 1.2 }
+}, V = 0.2;
+function Le() {
+  return {
+    enterPhysics: Oe,
+    exitPhysics: ke,
+    background: {
+      willChange: "transform, opacity",
+      enterStyle: (e, t) => ({
+        transform: `scale(${1 - V * e})`,
+        opacity: t
+      }),
+      exitStyle: (e) => ({
+        transform: `scale(${1 - V + V * e})`,
+        opacity: e
+      })
     }
-    const a = window.innerWidth, A = f.clientX <= j, c = f.clientX >= a - j;
-    if (!A && !c) {
-      e = null;
-      return;
+  };
+}
+const Fe = {
+  spring: { stiffness: 300, damping: 30 }
+}, Ye = {
+  inertia: { acceleration: 70, resistance: 1.2 }
+};
+function He() {
+  return {
+    enterPhysics: Fe,
+    exitPhysics: Ye,
+    background: {
+      willChange: "",
+      enterStyle: () => ({}),
+      exitStyle: () => ({})
     }
-    e = {
-      identifier: f.identifier,
-      startX: f.clientX,
-      startY: f.clientY,
-      fromLeftEdge: A,
-      moved: !1
-    };
-  }, v = (w) => {
-    if (!e) return;
-    if (w.touches.length !== 1) {
-      e = null;
-      return;
+  };
+}
+const Me = {
+  static: He(),
+  "background-scale": Le()
+}, ze = "static", Ue = "transform", Xe = (e = {}) => {
+  const t = e.direction ?? "enter", n = Me[e.type ?? ze], 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 = Ue, 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");
+      }), {};
+    },
+    animation: ({ from: r, to: l, context: c }) => {
+      const a = t === "enter" ? l : r, p = t === "enter" ? r : l, d = _(
+        c,
+        t === "enter" ? "to" : "from"
+      );
+      a.style.clipPath = `inset(${d.top}px 0 calc(100% - ${d.top + d.height}px) 0)`;
+      const u = t === "enter" ? (x, C) => ({
+        transform: `translate3d(0, ${C * d.height}px, 0)`
+      }) : (x) => ({
+        transform: `translate3d(0, ${x * d.height}px, 0)`
+      }), m = new b({
+        element: a,
+        integrator: g.from(s),
+        style: u,
+        onComplete: () => {
+          a.style.willChange = "auto", a.style.backfaceVisibility = "", a.style.contain = "", a.style.clipPath = "", a.style.transform = "";
+        }
+      });
+      if (!i)
+        return new E([m], { mode: "parallel" });
+      const f = _(
+        c,
+        t === "enter" ? "from" : "to"
+      ), h = f.left + f.width / 2, y = f.top + f.height / 2;
+      p.style.clipPath = `inset(${f.top}px 0 calc(100% - ${f.top + f.height}px) 0)`, p.style.transformOrigin = `${h}px ${y}px`;
+      const w = t === "enter" ? (x, C) => o.enterStyle(x, C) : (x) => o.exitStyle(x), S = new b({
+        element: p,
+        integrator: g.from(s),
+        style: w,
+        onComplete: t === "exit" ? () => {
+          p.style.willChange = "auto", p.style.backfaceVisibility = "", p.style.contain = "", p.style.clipPath = "", p.style.transformOrigin = "";
+        } : void 0
+      });
+      return new E([m, S], { mode: "parallel" });
     }
-    const f = s(w.touches, e.identifier);
-    if (!f) {
-      e = null;
-      return;
+  };
+};
+function Ve(e) {
+  return e === "scale" || e === "background-scale" ? "background-scale" : "static";
+}
+function kn(e) {
+  const { enter: t, exit: n } = e, s = e.type, o = Ve(s);
+  return ht(
+    { enter: t, exit: n },
+    (i) => Xe({ direction: i, type: o })
+  );
+}
+const Be = {
+  spring: { stiffness: 170, damping: 22, doubleSpring: 0.8 }
+}, Ne = (e = {}) => {
+  const t = e.direction ?? "left", n = e.physics ?? Be, 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";
+    }), {}),
+    animation: ({ from: o, to: i }) => {
+      const r = new b({
+        element: o,
+        integrator: g.from(n),
+        style: (c) => ({ transform: `translate3d(${s ? -100 * c : 100 * c}%, 0, 0)` })
+      }), l = new b({
+        element: i,
+        integrator: g.from(n),
+        style: (c, a) => ({ transform: `translate3d(${s ? a * 100 : a * -100}%, 0, 0)` }),
+        onComplete: () => {
+          i.style.willChange = "auto", i.style.backfaceVisibility = "", i.style.contain = "", i.style.transform = "";
+        }
+      });
+      return new E([r, l], { mode: "parallel" });
     }
-    const a = f.clientX - e.startX, A = f.clientY - e.startY, c = Math.abs(a), g = Math.abs(A);
-    if (g > Y && g > c * G) {
-      e = null;
-      return;
+  };
+};
+function Ln(e) {
+  const { paths: t } = e;
+  return q(
+    t,
+    { forward: "left", backward: "right" },
+    (n) => Ne({ direction: n })
+  );
+}
+const We = {
+  spring: { stiffness: 17, damping: 6 }
+}, B = 20, L = 800, Ze = (e = {}) => {
+  const t = e.physics ?? We;
+  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(${L}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(${L}px) rotateY(${B}deg) translate3d(-100%, 0, 0)`;
+    }), {}),
+    animation: ({ from: n, to: s }) => {
+      const o = new b({
+        element: n,
+        integrator: g.from(t),
+        style: (r) => {
+          const l = -r * B, c = r * 100;
+          return {
+            transform: `perspective(${L}px) rotateY(${l}deg) translate3d(${c}%, 0, 0)`
+          };
+        }
+      }), i = new b({
+        element: s,
+        integrator: g.from(t),
+        style: (r, l) => {
+          const c = l * B, a = -l * 100;
+          return {
+            transform: `perspective(${L}px) rotateY(${c}deg) translate3d(${a}%, 0, 0)`
+          };
+        },
+        onComplete: () => {
+          s.style.transform = "", s.style.willChange = "auto", s.style.backfaceVisibility = "", s.style.contain = "";
+        }
+      });
+      return new E([o, i], { mode: "sequence" });
     }
-    const C = e.fromLeftEdge ? a > 0 : a < 0;
-    c > Y && c > g * G && C && (e.moved = !0);
-  }, E = (w) => {
-    if (!e) return;
-    const f = s(w.changedTouches, e.identifier);
-    if (!f) {
-      e = null;
-      return;
+  };
+};
+function Fn(e) {
+  const { paths: t } = e;
+  return P(t, () => Ze());
+}
+function qe({
+  enterRect: e,
+  exitRect: t,
+  pageRect: n,
+  scrollOffset: s,
+  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, u = (n.height - (e.top + e.height)) / n.height * 100, m = e.left / n.width * 100;
+  return {
+    transformOrigin: `${e.left + e.width / 2}px ${e.top + e.height / 2}px`,
+    animate: (f) => {
+      const h = 1 - f, y = 1 + (c - 1) * h, w = 1 + (a - 1) * h, x = (i * h + o * (1 - h)) / ((y + w) / 2);
+      return {
+        clipPath: `inset(${p * h}% ${d * h}% ${u * h}% ${m * h}% round ${x}px)`,
+        transform: `translate(${r * h}px, ${l * h}px) scale(${y}, ${w})`
+      };
     }
-    const a = f.clientX - e.startX, A = e.fromLeftEdge ? a > 0 : a < 0;
-    if (e.moved && A && Math.abs(a) >= $) {
-      u(), e = null;
-      return;
+  };
+}
+function je({
+  enterRect: e,
+  exitRect: t,
+  pageRect: n,
+  scrollOffset: s,
+  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, u = (n.height - (e.top + e.height)) / n.height * 100, m = e.left / n.width * 100;
+  return {
+    transformOrigin: `${e.left + e.width / 2}px ${e.top + e.height / 2}px`,
+    animate: (f) => {
+      const h = 1 - f, y = 1 + (c - 1) * h, w = 1 + (a - 1) * h, x = (o * (1 - h) + i * h) / ((y + w) / 2);
+      return {
+        clipPath: `inset(${p * h}% ${d * h}% ${u * h}% ${m * h}% round ${x}px)`,
+        transform: `translate(${r * h - s.x}px, ${l * h}px) scale(${y}, ${w})`
+      };
     }
-    e.moved && Math.abs(a) >= $ && u(), e = null;
-  }, S = () => {
-    e && (e.moved && u(), e = null);
   };
-  return { initialize: () => {
-    if (typeof window > "u" || o) return;
-    o = !0;
-    const w = { passive: !0, capture: !0 };
-    window.addEventListener("touchstart", h, w), window.addEventListener("touchmove", v, w), window.addEventListener("touchend", E, w), window.addEventListener("touchcancel", S, w);
-  }, destroy: () => {
-    if (typeof window > "u" || !o) return;
-    o = !1;
-    const w = { capture: !0 };
-    window.removeEventListener("touchstart", h, w), window.removeEventListener("touchmove", v, w), window.removeEventListener("touchend", E, w), window.removeEventListener("touchcancel", S, w), m(), l(), e = null, i = !1, t = !1;
-  }, isSwipeBack: () => {
-    const w = i || t;
-    return w && m(), w;
-  }, onPageEnter: () => {
-    i = !1, m(), l(), r = setTimeout(() => {
-      t = !1, r = null;
-    }, 0);
-  } };
 }
-function Ot() {
-  let e = null;
-  function i() {
-    if (e != null && e.from && (e != null && e.to) && (e != null && e.outResolve) && (e != null && e.inResolve)) {
-      const t = { from: e.from, to: e.to };
-      e.outResolve(t), e.inResolve(t), e = null;
+const Ge = {
+  spring: { stiffness: 200, damping: 24 }
+}, ut = 0.12, Ke = 18;
+function Je() {
+  return {
+    transformOrigin: "50% 50%",
+    animate: (e) => {
+      const t = 1 - e;
+      return {
+        transform: `scale(${1 - ut * t})`
+      };
     }
-  }
+  };
+}
+function Qe() {
   return {
-    trigger(t, n) {
-      e || (e = {}), n === "out" ? e.from = t : e.to = t;
-    },
-    get(t) {
-      return t === "in" && (!e || !e.from) ? Promise.resolve(null) : new Promise((n) => {
-        e || (e = {}), t === "out" ? e.outResolve = n : e.inResolve = n, i();
-      });
+    transformOrigin: "50% 50%",
+    animate: (e) => {
+      const t = 1 - e;
+      return {
+        transform: `scale(${1 - ut * t})`
+      };
     }
   };
 }
-function _t() {
-  let e = null;
-  function i() {
-    var n, r;
-    e && ((n = e.outResolve) == null || n.call(e, null), (r = e.inResolve) == null || r.call(e, null), e = null);
+const N = {
+  willChange: "backdrop-filter",
+  initialStyle: {
+    position: "absolute",
+    inset: "0",
+    pointerEvents: "none",
+    // Sits above the background page but below the zoomed page (z-index 9999
+    // in transition.ts). backdrop-filter therefore blurs the background,
+    // while the zoom tile stays sharp as it expands on top.
+    zIndex: "5000",
+    backdropFilter: "blur(0px)",
+    WebkitBackdropFilter: "blur(0px)"
+  },
+  style: (e, t) => {
+    const n = e === "enter" ? t : 1 - t, s = `blur(${Ke * n}px)`;
+    return {
+      backdropFilter: s,
+      WebkitBackdropFilter: s
+    };
   }
-  function t() {
-    if (e != null && e.from && (e != null && e.to) && (e != null && e.outResolve) && (e != null && e.inResolve)) {
-      if (e.from === e.to) {
-        i();
-        return;
-      }
-      const n = { from: e.from, to: e.to };
-      e.outResolve(n), e.inResolve(n), e = null;
-    }
+};
+class Re {
+  constructor() {
+    $(this, "physics", Ge);
+  }
+  contribute(t) {
+    const { from: n, to: s, resolved: o, physics: i } = t, r = o.mode === "enter", l = r ? n : s, c = r ? Je() : Qe();
+    return c && (l.style.transformOrigin = c.transformOrigin), [
+      new b({
+        element: l,
+        integrator: g.from(i),
+        style: r ? (a, p) => c.animate(p) : (a) => c.animate(a)
+      })
+    ];
+  }
+}
+class tn {
+  prepare(t) {
+    const n = t.createElement("zoom-overlay");
+    return Object.assign(n.style, N.initialStyle), n.style.willChange = N.willChange, t.context.positionedParent.appendChild(n), { overlay: n };
+  }
+  contribute(t) {
+    const n = t.extras.overlay;
+    return n ? [
+      new b({
+        element: n,
+        integrator: g.from(t.physics),
+        style: (s) => N.style(t.resolved.mode, s)
+      })
+    ] : [];
   }
+}
+const en = {
+  spring: { stiffness: 340, damping: 30, doubleSpring: 1 }
+};
+function nn({
+  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);
   return {
-    trigger(n, r) {
-      e && (r === "out" && e.from && e.from !== n || r === "in" && e.to && e.to !== n) && i(), e || (e = {}), r === "out" ? e.from = n : e.to = n;
-    },
-    get(n) {
-      return new Promise((r) => {
-        e || (e = {}), n === "out" ? e.outResolve = r : e.inResolve = r, t();
-      });
+    transformOrigin: `${t.left + t.width / 2}px ${t.top + t.height / 2}px`,
+    animate: (c) => {
+      const a = 1 - c;
+      return {
+        transform: `translate(${s * a - n.x}px, ${o * a}px) scale(${1 + (l - 1) * a})`,
+        opacity: `${1 - a}`
+      };
     }
   };
 }
-function jt(e, i) {
-  const {
-    transitions: t = [],
-    defaultTransition: n,
-    middleware: r = (f, a) => ({ from: f, to: a }),
-    // Identity function as default
-    preserveScroll: o = (f) => f
-  } = e, { outFirst: s = !0 } = i || {}, m = s ? Ot() : _t(), l = Rt(t), u = Lt();
-  u.initialize();
-  const {
-    initializeContext: h,
-    calculateScrollOffset: v,
-    evictScrollPosition: E,
-    shouldPreserve: S,
-    getScrollContainer: y,
-    getPositionedParentElement: p,
-    getScrollPosition: k
-  } = xt({
-    preserveScroll: o
-  }), T = async (f, a) => {
-    const A = u.isSwipeBack();
-    m.trigger(f, a);
-    const c = await m.get(a);
-    if (a === "in" && u.onPageEnter(), !c) return () => ({});
-    if (A)
-      return a === "out" && c.from && !S(c.from) && E(c.from), () => ({});
-    const { from: g, to: C } = r(
-      c.from,
-      c.to
-    ), R = It(
-      g,
-      C,
-      l
-    ) || n;
-    if (!R) return () => ({});
-    const M = v(c.from, c.to);
-    if (a === "out") {
-      const x = {
-        scrollOffset: M,
-        scroll: k(c.from),
-        get scrollingElement() {
-          return y() || document.documentElement;
-        },
-        get positionedParent() {
-          return p();
-        }
+function sn({
+  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);
+  return {
+    transformOrigin: `${t.left + t.width / 2}px ${t.top + t.height / 2}px`,
+    animate: (c) => {
+      const a = 1 - c;
+      return {
+        transform: `translate(${s * a}px, ${o * a}px) scale(${1 + (l - 1) * a})`,
+        opacity: `${c}`
       };
-      return c.from && !S(c.from) && E(c.from), (D) => R.out(D, x);
-    } else {
-      const x = {
-        scrollOffset: M,
-        get scroll() {
-          return k(c.to);
-        },
-        get scrollingElement() {
-          return y() || document.documentElement;
-        },
-        get positionedParent() {
-          return p();
+    }
+  };
+}
+class on {
+  constructor() {
+    $(this, "physics", en);
+  }
+  contribute(t) {
+    const { from: n, to: s, resolved: o, input: i, physics: r } = t, l = o.mode === "enter", c = l ? n : s, a = l ? nn(i) : sn(i);
+    return a && (c.style.transformOrigin = a.transformOrigin), [
+      new b({
+        element: c,
+        integrator: g.from(r),
+        style: l ? (p, d) => a.animate(d) : (p) => a.animate(p)
+      })
+    ];
+  }
+}
+const rn = {
+  spring: { stiffness: 420, damping: 34 }
+};
+class an {
+  constructor() {
+    $(this, "physics", rn);
+  }
+  contribute(t) {
+    return [];
+  }
+}
+const ln = {
+  expand: () => new on(),
+  static: () => new an(),
+  blur: () => new Re()
+};
+function cn(e) {
+  return ln[e]();
+}
+const W = "data-zoom-enter-key", lt = "data-zoom-exit-key", pn = "data-zoom-radius";
+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 dn(e, t) {
+  const n = [];
+  let s = t;
+  for (; s && s !== e; ) {
+    const o = s.parentElement;
+    if (!o) break;
+    for (const i of Array.from(o.children))
+      i !== s && i instanceof HTMLElement && n.push(i);
+    s = o;
+  }
+  return n;
+}
+function pt(e) {
+  const t = e.querySelectorAll(`[${W}]`);
+  return t.length !== 1 ? null : t[0];
+}
+function dt(e, t) {
+  const n = e.querySelectorAll(`[${lt}]`);
+  for (const s of n)
+    if (s.getAttribute(lt) === t)
+      return s;
+  return null;
+}
+function fn(e, t) {
+  const n = pt(e), s = pt(t);
+  if (!n && s) {
+    const o = s.getAttribute(W);
+    if (!o) return null;
+    const i = dt(e, o);
+    return i ? { mode: "enter", enterEl: s, exitEl: i } : null;
+  }
+  if (n && !s) {
+    const o = n.getAttribute(W);
+    if (!o) return null;
+    const i = dt(t, o);
+    return i ? { mode: "exit", enterEl: n, exitEl: i } : null;
+  }
+  return null;
+}
+function hn(e, t, n, s) {
+  return {
+    enterRect: T(
+      e.mode === "enter" ? n : t,
+      e.enterEl
+    ),
+    exitRect: T(
+      e.mode === "enter" ? t : n,
+      e.exitEl
+    ),
+    pageRect: e.mode === "enter" ? n.getBoundingClientRect() : t.getBoundingClientRect(),
+    scrollOffset: s,
+    enterRadius: ct(e.enterEl),
+    exitRadius: ct(e.exitEl)
+  };
+}
+class un {
+  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 ? qe(i) : je(i), p = c ? s : n, d = c ? "t" : "u";
+    a && (p.style.transformOrigin = a.transformOrigin);
+    const u = p.style.zIndex;
+    return p.style.zIndex = "9999", l(() => {
+      p.style.willChange = "auto", p.style.backfaceVisibility = "", p.style.transformOrigin = "", p.style.contain = "", p.style.zIndex = u;
+    }), [
+      new b({
+        element: p,
+        integrator: g.from(r),
+        // 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" ? (m) => a.animate(m) : (m, f) => a.animate(f)
+      })
+    ];
+  }
+}
+class mn {
+  contribute(t) {
+    const { resolved: n, physics: s, from: o, to: i, onComplete: r } = t, l = n.mode === "enter" ? i : o, c = dn(l, n.enterEl);
+    if (c.length === 0) return [];
+    const a = c.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] ?? "");
+      }
+    }), c.map(
+      (p) => new b({
+        element: p,
+        integrator: g.from(s),
+        style: (d, u) => ({
+          opacity: n.mode === "enter" ? d : u
+        })
+      })
+    );
+  }
+}
+class mt {
+  contribute() {
+    return [];
+  }
+}
+const yn = {
+  default: () => new mt(),
+  fade: () => new mn()
+};
+function gn(e) {
+  return yn[e]();
+}
+class bn extends mt {
+}
+function wn(e) {
+  const t = cn(e.type);
+  return { strategies: [
+    new un(),
+    t,
+    gn(e.variant),
+    new bn(),
+    // 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 tn()] : []
+  ], physics: t.physics };
+}
+const Sn = (e) => {
+  const { strategies: t, physics: n } = wn(e);
+  return {
+    prepare: (s) => {
+      const o = {
+        from: s.from,
+        to: s.to,
+        context: { positionedParent: s.context.positionedParent },
+        // `createElement` from the dispatcher is generic over tag; the
+        // strategy interface narrows the cast to keep both signatures
+        // compatible.
+        createElement: s.createElement
+      }, i = {};
+      for (const r of t) {
+        if (!r.prepare) continue;
+        const l = r.prepare(o);
+        l && Object.assign(i, l);
+      }
+      return i;
+    },
+    animation: ({ from: s, to: o, context: i, ...r }) => {
+      const l = fn(s, o);
+      if (!l)
+        return new E([], { mode: "parallel" });
+      const c = hn(l, s, o, i.scrollOffset), a = [], d = {
+        from: s,
+        to: o,
+        resolved: l,
+        input: c,
+        physics: n,
+        extras: r,
+        onComplete: (f) => {
+          a.push(f);
         }
-      };
-      return (D) => R.in(D, x);
+      }, u = [];
+      for (const f of t)
+        f.contribute && u.push(...f.contribute(d));
+      const m = u[0];
+      if (m) {
+        const f = m.onComplete;
+        m.onComplete = () => {
+          f == null || f();
+          for (const h of a)
+            try {
+              h();
+            } catch (y) {
+              console.error("[zoom] cleanup error", y);
+            }
+        };
+      }
+      return new E(u, { mode: "parallel" });
     }
   };
-  return (f) => ({
-    key: f,
-    in: async (a) => (h(a, f), (await T(f, "in"))(a)),
-    out: async (a) => (await T(f, "out"))(a),
-    // Add page transition strategy for page-level transitions
-    [Q]: wt
-  });
+};
+function $n(e) {
+  const t = e.type ?? "static", n = e.variant ?? (e.fade ? "fade" : "default");
+  return { type: t, variant: n };
+}
+function Yn(e) {
+  const t = $n(e);
+  return P(
+    e.paths,
+    () => Sn(t)
+  );
 }
 export {
-  tt as SCOPE_ATTR,
-  et as SCOPE_READY_ATTR,
-  Q as TRANSITION_STRATEGY,
-  _t as createAnyOrderDetector,
-  yt as createDefaultStrategy,
-  Ot as createOutFirstDetector,
-  wt as createPageTransitionStrategy,
-  jt as createSggoiTransitionContext,
-  Xt as createTransitionScope,
-  vt as findScope,
-  Ut as getWatchedCount,
-  $t as isCssAnimation,
-  Zt as isKeyframesAnimation,
-  Jt as isMultiAnimation,
-  pt as isScopeReady,
-  Qt as isSingleAnimation,
-  te as isTickAnimation,
-  Wt as isWatched,
-  W as normalizeSchedule,
-  F as normalizeToMultiAnimation,
-  Ht as resetObserver,
-  Kt as transition,
-  Bt as triggerUnmount,
-  Tt as watchUnmount
+  zn as Animation,
+  E as MultiAnimation,
+  b as WebAnimation,
+  Cn as axis,
+  Pn as blind,
+  vn as drill,
+  Tn as fade,
+  Dn as film,
+  _n as hero,
+  An as jaemin,
+  In as rotate,
+  On as scroll,
+  kn as sheet,
+  Ln as slide,
+  Fn as strip,
+  Yn as zoom
 };