@ssgoi/core 5.2.2 → 6.0.0

package/dist/index.js

@@ -1,1291 +1,1370 @@
-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 ht = Object.defineProperty;
+var mt = (e, t, n) => t in e ? ht(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var S = (e, t, n) => mt(e, typeof t != "symbol" ? t + "" : t, n);
+import { P as B, V as nt, W as w, M as $, S as ut } from "./multi-animation-CST6aZ8y.js";
+import { A as Xe } from "./multi-animation-CST6aZ8y.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 a = e[s], i = e[o];
+      !a || !i || n.push({
+        from: a,
+        to: i,
+        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 st(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 ot(e, t, n) {
+  const s = [];
+  for (let o = 0; o < e.length; o++)
+    for (let a = o + 1; a < e.length; a++) {
+      const i = e[o], l = e[a];
+      !i || !l || s.push(
+        {
+          from: i,
+          to: l,
+          transition: n(t.forward)
+        },
+        {
+          from: l,
+          to: i,
+          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 v {
   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);
+    S(this, "omega");
+    // Angular frequency
+    S(this, "zeta");
+    // Damping ratio
+    S(this, "restDelta");
+    S(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 ?? B, this.restSpeed = t.restSpeed ?? nt;
   }
-  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();
-      }
-    });
-  }
-  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: a, zeta: i } = this, { position: l, velocity: c } = t, r = -2 * o * i * a * c, p = o * a * a * (n - l), d = c + r + 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 yt {
   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);
+    S(this, "leader");
+    S(this, "follower");
+    S(this, "restDelta");
+    S(this, "restSpeed");
+    this.restDelta = t.restDelta ?? B, this.restSpeed = t.restSpeed ?? nt, this.leader = new v({
+      stiffness: t.stiffness,
+      damping: t.damping,
+      restDelta: this.restDelta,
+      restSpeed: this.restSpeed
+    });
+    let n, s, o, a;
+    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, a = t.follower.restSpeed) : (n = t.stiffness, s = t.damping), this.follower = new v({
+      stiffness: n,
+      damping: s,
+      restDelta: o ?? this.restDelta,
+      restSpeed: a ?? 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;
-  }
-  /**
-   * 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();
-  }
-  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)));
-  }
-  /**
-   * 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);
-    }
-  }
-  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));
+  step(t, n, s) {
+    const a = t._leader ?? {
+      position: t.position,
+      velocity: t.velocity
+    }, i = this.leader.step(a, n, s), l = this.follower.step(
+      t,
+      i.position,
+      s
+    );
+    return {
+      position: l.position,
+      velocity: l.velocity,
+      _leader: i
     };
-    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;
-    });
+  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;
   }
-  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();
-    });
+}
+const gt = 0.01, wt = 500, bt = 10;
+class St {
+  constructor(t) {
+    S(this, "acceleration");
+    S(this, "resistance");
+    S(this, "resistanceType");
+    S(this, "min");
+    S(this, "max");
+    S(this, "bounceStiffness");
+    S(this, "bounceDamping");
+    S(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 ?? wt, this.bounceDamping = t.bounceDamping ?? bt, this.restDelta = t.restDelta ?? gt;
   }
-  getCurrentState() {
-    const t = this.getFirstAnimator();
-    return t ? t.getCurrentState() : {
-      position: 0,
-      velocity: 0,
-      from: 0,
-      to: 1
+  step(t, n, s) {
+    const o = Math.min(s, 0.033), { acceleration: a, resistance: i, resistanceType: l, min: c, max: r } = this, { position: p, velocity: d } = t, h = c !== void 0 && p < c, u = r !== void 0 && p > r;
+    let f;
+    if (h || u) {
+      const b = p - (h ? c : r), C = -this.bounceStiffness * b, E = -this.bounceDamping * d;
+      f = C + E;
+    } else {
+      const x = n > p ? 1 : -1;
+      let b;
+      l === "linear" ? b = i * d : b = i * d * Math.abs(d), f = x * a - b;
+    }
+    const m = d + f * o;
+    let y = p + m * o;
+    if (!h && !u) {
+      const x = n > p ? 1 : -1;
+      (x > 0 && y > n || x < 0 && y < n) && (y = n);
+    }
+    return {
+      position: y,
+      velocity: y === n ? 0 : m
     };
   }
-  /**
-   * 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 St({
+        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 yt({
+        stiffness: n.stiffness,
+        damping: n.damping,
+        follower: o,
+        restDelta: n.restDelta,
+        restSpeed: n.restSpeed
+      });
+    }
+    return new v({
+      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 $t {
+  constructor(t) {
+    S(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 a = Math.sign(o), i = Math.abs(o) / this.durationSec, l = a * i * s, c = t.position + l;
+    return (a > 0 ? c >= n : c <= n) ? { position: n, velocity: 0 } : { position: c, velocity: a * i };
   }
-  /**
-   * 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) < B;
   }
 }
-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
-      },
-      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')
-        };
+const xt = {
+  spring: { stiffness: 200, damping: 22 }
+}, Ct = 10, Et = "horizontal", Pt = "#000000";
+function N(e, t, n, s, o, a) {
+  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 r = 0; r < t; r++) {
+    const p = document.createElement("div");
+    if (n === "horizontal") {
+      const d = 100 / t;
+      p.style.cssText = `
+        position: absolute;
+        top: ${d * r}%;
+        left: 0;
+        width: 100%;
+        height: calc(${d}% + 1px);
+        background: ${s};
+        transform: scaleX(${o === "hidden" ? 0 : 1});
+        transform-origin: ${a} center;
+        will-change: transform;
+      `;
+    } else {
+      const d = 100 / t;
+      p.style.cssText = `
+        position: absolute;
+        top: 0;
+        left: ${d * r}%;
+        width: calc(${d}% + 1px);
+        height: 100%;
+        background: ${s};
+        transform: scaleY(${o === "hidden" ? 0 : 1});
+        transform-origin: ${a === "left" ? "top" : "bottom"} center;
+        will-change: transform;
+      `;
     }
-    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"
-    };
+    c.push(p), l.appendChild(p);
   }
-}), 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
+  return e.appendChild(l), { container: l, blinds: c };
+}
+const Dt = (e = {}) => {
+  const t = e.blindCount ?? Ct, n = e.direction ?? Et, s = e.blindColor ?? Pt, o = e.physics ?? xt;
+  return {
+    prepare: async ({ from: a, to: i }) => {
+      const l = await a, c = await i;
+      l.style.zIndex = "1000";
+      const r = N(
+        l,
+        t,
+        n,
+        s,
+        "hidden",
+        "left"
+      );
+      c.style.position = "relative", c.style.zIndex = "0";
+      const p = N(
+        c,
+        t,
+        n,
+        s,
+        "closed",
+        "right"
+      );
+      return {
+        fromBlinds: r.blinds,
+        fromContainer: r.container,
+        toBlinds: p.blinds,
+        toContainer: p.container
+      };
     },
-    from: 0,
-    to: 1,
-    direction: "forward"
-  },
-  runOut: async (e) => e.out ? {
-    config: await e.out,
-    state: {
-      position: 1,
-      velocity: 0
+    animation: ({ fromBlinds: a, fromContainer: i, toBlinds: l, toContainer: c }) => {
+      const r = a.map(
+        (u) => new w({
+          element: u,
+          integrator: g.from(o),
+          style: (f) => ({
+            transform: n === "horizontal" ? `scaleX(${f})` : `scaleY(${f})`
+          })
+        })
+      ), p = l.map(
+        (u, f) => new w({
+          element: u,
+          integrator: g.from(o),
+          style: (m, y) => ({
+            transform: n === "horizontal" ? `scaleX(${y})` : `scaleY(${y})`
+          }),
+          onComplete: f === l.length - 1 ? () => {
+            c.remove(), i.remove();
+          } : void 0
+        })
+      ), d = new $(r, { mode: "parallel" }), h = new $(p, { mode: "parallel" });
+      return new $([d, h], { mode: "sequence" });
+    }
+  };
+};
+function Ie({ paths: e }) {
+  return P(e, () => Dt());
+}
+const Ot = {
+  spring: { stiffness: 200, damping: 20, doubleSpring: 0.7 }
+}, I = 0.5;
+function It(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: `${I + (1 - I) * (1 - s)}`
+      })
     },
-    from: 1,
-    to: 0,
-    direction: "forward"
-  } : {
-    state: {
-      position: 1,
-      velocity: 0
+    in: {
+      willChange: "transform, opacity",
+      startStyle: {
+        transform: `translate3d(${n}%, 0, 0)`,
+        opacity: `${I}`
+      },
+      animate: (s) => ({
+        transform: `translate3d(${n * (1 - s)}%, 0, 0)`,
+        opacity: `${I + (1 - I) * s}`
+      })
+    }
+  };
+}
+function Tt() {
+  return {
+    physics: Ot,
+    build: It
+  };
+}
+const At = {
+  spring: { stiffness: 170, damping: 22 }
+};
+function _t(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)`
+      })
     },
-    from: 1,
-    to: 0,
-    direction: "forward"
-  }
-}), tt = "data-ssgoi-scope", et = "data-ssgoi-scope-ready";
-function Xt() {
-  return (e) => {
-    if (e)
-      return e.setAttribute(tt, ""), queueMicrotask(() => {
-        queueMicrotask(() => {
-          e.setAttribute(et, "true");
-        });
-      }), () => {
-      };
+    in: {
+      willChange: "transform",
+      startStyle: {
+        transform: `translate3d(${n}%, 0, 0)`
+      },
+      animate: (s) => ({
+        transform: `translate3d(${n * (1 - s)}%, 0, 0)`
+      })
+    }
   };
 }
-function pt(e) {
-  return e.hasAttribute(et);
+function kt() {
+  return {
+    physics: At,
+    build: _t
+  };
 }
-function vt(e) {
-  return e.closest(`[${tt}]`);
+const vt = {
+  parallax: kt(),
+  crossfade: Tt()
+}, Lt = "parallax";
+function Z(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();
+const Yt = (e = {}) => {
+  const t = e.direction ?? "enter", n = vt[e.type ?? Lt], s = n.physics, o = n.build(t);
+  return {
+    prepare: ({ from: a, to: i }) => (a.then((l) => {
+      Z(l, o.out), l.style.pointerEvents = "none", l.style.zIndex = t === "enter" ? "-1" : "100";
+    }), i.then((l) => {
+      Z(l, o.in);
+    }), {}),
+    animation: ({ from: a, to: i }) => {
+      const l = new w({
+        element: a,
+        integrator: g.from(s),
+        style: (r) => o.out.animate(r)
+      }), c = new w({
+        element: i,
+        integrator: g.from(s),
+        style: (r) => o.in.animate(r),
+        onComplete: () => {
+          i.style.willChange = "auto", i.style.backfaceVisibility = "", i.style.contain = "", i.style.transform = "", i.style.opacity = "";
+        }
       });
-    });
-  });
-}
-function At(e, i) {
-  var S;
-  let t = null, n = null, r = null, o = null;
-  const s = {
-    get currentAnimation() {
-      return t;
-    }
-  }, 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;
+      return new $([l, c], { mode: "parallel" });
     }
-    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 Te({ type: e, ...t }) {
+  return st(
+    t,
+    (n) => Yt({ direction: n, type: e })
+  );
+}
+const Ft = {
+  spring: { stiffness: 180, damping: 20, doubleSpring: !0 }
+}, Mt = {
+  spring: { stiffness: 170, damping: 20, doubleSpring: !0 }
+}, Ht = (e = {}) => {
+  const t = e.physics ?? Mt, n = e.physics ?? Ft;
+  return {
+    prepare: ({ to: s }) => (s.then((o) => {
+      o.style.opacity = "0", o.style.willChange = "opacity";
+    }), {}),
+    animation: ({ from: s, to: o }) => {
+      const a = new w({
+        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";
         }
-      },
-      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;
-    }
-    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);
+      }), i = new w({
+        element: o,
+        integrator: g.from(t),
+        style: (l) => ({ opacity: l }),
+        onComplete: () => {
+          o.style.willChange = "auto", o.style.opacity = "";
         }
-      },
-      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));
+      });
+      return new $([a, i], { mode: "sequence" });
     }
   };
-  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({ paths: e }) {
+  return P(e, () => Ht());
 }
-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();
-    });
+function O(e, t) {
+  function n(a) {
+    let i = 0, l = 0;
+    const c = a.offsetWidth, r = a.offsetHeight;
+    let p = a;
+    for (; p; )
+      i += p.offsetTop, l += p.offsetLeft, p = p.offsetParent;
+    return i -= window.scrollY, l -= window.scrollX, { top: i, left: l, width: c, height: r };
   }
-  const i = e.childNodes;
-  for (let t = 0; t < i.length; t++) {
-    const n = i[t];
-    n && nt(n);
+  const s = n(e), o = n(t);
+  return new DOMRect(
+    o.left - s.left,
+    o.top - s.top,
+    o.width,
+    o.height
+  );
+}
+function T(e, t) {
+  const { scrollingElement: n, positionedParent: s } = e, o = n !== s && n.contains(s) ? O(n, s).top : 0;
+  return {
+    top: e[t].scroll.y,
+    left: 0,
+    width: n.clientWidth,
+    height: n.clientHeight - o
+  };
+}
+const M = {
+  scaleDown: { stiffness: 20, damping: 7 },
+  translate: { stiffness: 15, damping: 7 },
+  scaleUp: { stiffness: 20, damping: 7 }
+}, D = {
+  scaleDown: 0,
+  translate: 0.2,
+  scaleUp: 0.8
+}, Ut = 0.8, zt = "white", q = 1e3 / 60, Vt = 600;
+function Xt(e) {
+  const { items: t, from: n, to: s, recordFrame: o } = e, a = q / 1e3, i = Math.abs(s - n), l = t.map((r) => ({
+    item: r,
+    integrator: new v({
+      stiffness: r.spring.stiffness,
+      damping: r.spring.damping
+    }),
+    state: { position: n, velocity: 0 },
+    started: !1,
+    settled: !1,
+    settleTime: 0
+  }));
+  for (let r = 0; r < l.length; r++)
+    (r === 0 || l[r].item.offset === 0) && (l[r].started = !0);
+  o(0);
+  let c = 0;
+  for (let r = 1; r <= Vt; r++) {
+    const p = r * q;
+    c = p;
+    for (const d of l)
+      !d.started || d.settled || (d.state = d.integrator.step(d.state, s, a), d.integrator.isSettled(d.state, s) ? (d.settleTime += a, d.settleTime >= ut && (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 h = l[d];
+      if (h.started) continue;
+      const u = l[d - 1];
+      if (!u.started) continue;
+      (i === 0 ? 1 : Math.abs(u.state.position - n) / i) >= h.item.offset && (h.started = !0);
+    }
+    if (o(p), l.every((d) => d.settled)) return p;
   }
+  return c;
 }
-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);
+function H(e, t) {
+  return e != null && e.spring ? {
+    stiffness: e.spring.stiffness,
+    damping: e.spring.damping
+  } : t;
+}
+function j(e) {
+  const { rect: t, scale: n, direction: s, override: o } = e, a = s === "out" ? { scale: 1, translateY: -t.top } : { scale: n, translateY: -t.top + t.height }, i = H(o, M.scaleDown), l = H(o, M.translate), c = H(o, M.scaleUp), r = s === "out" ? 1 : 0, p = s === "out" ? 0 : 1, d = s === "out" ? [
+    {
+      spring: i,
+      offset: D.scaleDown,
+      tick: (f) => {
+        const m = 1 - f;
+        a.scale = 1 - (1 - n) * m;
+      }
+    },
+    {
+      spring: l,
+      offset: D.translate,
+      tick: (f) => {
+        const m = 1 - f;
+        a.translateY = -t.top - t.height * m;
+      }
+    },
+    {
+      spring: c,
+      offset: D.scaleUp,
+      tick: (f) => {
+        const m = 1 - f;
+        a.scale = n + (1 - n) * m;
       }
     }
-  }), document.body ? I.observe(document.body, {
-    childList: !0,
-    subtree: !0
-  }) : document.addEventListener(
-    "DOMContentLoaded",
-    () => {
-      I == null || I.observe(document.body, {
-        childList: !0,
-        subtree: !0
-      });
+  ] : [
+    {
+      spring: i,
+      offset: D.scaleDown,
+      tick: (f) => {
+        a.scale = 1 - (1 - n) * f;
+      }
+    },
+    {
+      spring: l,
+      offset: D.translate,
+      tick: (f) => {
+        a.translateY = -t.top + t.height * (1 - f);
+      }
     },
-    { once: !0 }
-  ));
+    {
+      spring: c,
+      offset: D.scaleUp,
+      tick: (f) => {
+        a.scale = n + (1 - n) * f;
+      }
+    }
+  ], h = [], u = Xt({
+    items: d,
+    from: r,
+    to: p,
+    recordFrame: (f) => h.push({
+      time: f,
+      scale: a.scale,
+      translateY: a.translateY
+    })
+  });
+  return { snapshots: h, totalDuration: u };
 }
-function Tt(e, i) {
-  Ct(), P.set(e, i);
+function Bt(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 a = e[s], i = e[o], l = n - s;
+  return {
+    time: a.time + (i.time - a.time) * l,
+    scale: a.scale + (i.scale - a.scale) * l,
+    translateY: a.translateY + (i.translateY - a.translateY) * l
+  };
 }
-function Wt(e) {
-  return P.has(e);
+const Wt = [
+  [1, 1],
+  [-1, 1],
+  [1, -1],
+  [-1, -1]
+];
+function Nt(e, t) {
+  const o = (a, i, l) => {
+    const c = document.createElement("div");
+    Object.assign(c.style, {
+      position: "fixed",
+      pointerEvents: "none",
+      zIndex: "9999",
+      width: "15px",
+      height: "15px",
+      ...a
+    });
+    const r = document.createElement("div");
+    Object.assign(r.style, {
+      position: "absolute",
+      width: "15px",
+      height: "1px",
+      backgroundColor: e,
+      [l]: "0",
+      [i]: "0"
+    });
+    const p = document.createElement("div");
+    return Object.assign(p.style, {
+      position: "absolute",
+      width: "1px",
+      height: "15px",
+      backgroundColor: e,
+      [l]: "0",
+      [i]: "0"
+    }), c.appendChild(r), c.appendChild(p), c;
+  };
+  return {
+    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 Ut() {
-  return P.size;
+function G(e, t) {
+  const n = t.left + t.width / 2, s = t.top + t.height / 2;
+  e.style.transformOrigin = `${n}px ${s}px`;
 }
-function Bt(e) {
-  const i = P.get(e);
-  return i ? (P.delete(e), i(), !0) : !1;
+function K(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 Ht() {
-  P.clear(), I == null || I.disconnect(), I = null, q = !1;
+function U(e, t, n, s, o) {
+  const a = n / 1e3;
+  return new w({
+    element: e,
+    integrator: new $t({ durationSec: a }),
+    lowerBound: 0,
+    upperBound: 1,
+    style: (i) => s(Bt(t, i)),
+    onComplete: o
+  });
 }
-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`), {});
+const Zt = (e = {}) => {
+  var o;
+  const t = ((o = e.border) == null ? void 0 : o.color) ?? zt, n = Ut, s = e.physics;
+  return {
+    prepare: ({ from: a, to: i, context: l }) => {
+      const c = T(l, "from"), r = T(l, "to"), p = O(document.body, l.positionedParent), d = Nt(t, {
+        ...c,
+        top: p.top
+      });
+      for (const h of [
+        "topLeft",
+        "topRight",
+        "bottomLeft",
+        "bottomRight"
+      ])
+        l.positionedParent.appendChild(d[h]);
+      return a.then((h) => {
+        G(h, c), K(h, c), h.style.transform = `translateY(${-c.top}px)`;
+      }), i.then((h) => {
+        G(h, r), K(h, r), h.style.transform = `translateY(${-r.top + r.height}px) scale(${n})`;
+      }), { borders: d, fromRect: c, toRect: r };
     },
-    {
-      strategy: t == null ? void 0 : t.strategy,
-      scope: t == null ? void 0 : t.scope,
-      onCleanupEnd: () => {
-        O.get(e) === r && kt(e);
-      }
+    animation: ({ from: a, to: i, context: l, borders: c, fromRect: r, toRect: p }) => {
+      const d = j({
+        rect: r,
+        scale: n,
+        direction: "out",
+        override: s
+      }), h = j({
+        rect: p,
+        scale: n,
+        direction: "in",
+        override: s
+      }), u = U(
+        a,
+        d.snapshots,
+        d.totalDuration,
+        (b) => ({
+          transform: `translateY(${b.translateY}px) scale(${b.scale})`
+        }),
+        () => {
+          a.style.clipPath = "", a.style.transformOrigin = "";
+        }
+      ), f = U(
+        i,
+        h.snapshots,
+        h.totalDuration,
+        (b) => ({
+          transform: `translateY(${b.translateY}px) scale(${b.scale})`
+        }),
+        () => {
+          i.style.clipPath = "", i.style.transformOrigin = "", i.style.transform = "";
+        }
+      ), m = Wt.map(([b, C], E) => {
+        const L = ["topLeft", "topRight", "bottomLeft", "bottomRight"][E];
+        return U(
+          c[L],
+          d.snapshots,
+          d.totalDuration,
+          (A) => {
+            const Y = (r.width - r.width * A.scale) / 2 * 0.7 * b, F = (r.height - r.height * A.scale) / 2 * 0.7 * C;
+            return { transform: `translate(${Y}px, ${F}px)` };
+          }
+        );
+      }), y = new $([u, f, ...m], {
+        mode: "parallel"
+      }), x = y.onComplete;
+      return y.onComplete = () => {
+        x == null || x();
+        const b = l.positionedParent;
+        for (const C of [
+          "topLeft",
+          "topRight",
+          "bottomLeft",
+          "bottomRight"
+        ]) {
+          const E = c[C];
+          E.parentElement === b && b.removeChild(E);
+        }
+      }, y;
     }
-  ), N.set(e, n), n;
+  };
+};
+function _e({ paths: e }) {
+  return P(e, () => Zt());
 }
-function kt(e) {
-  O.delete(e), N.delete(e), X.delete(e);
+const qt = {
+  spring: { stiffness: 300, damping: 30 }
+};
+function jt(e, t) {
+  return e.querySelector(`[data-hero-key="${t}"]`);
 }
-function Kt(e, i = "manual") {
-  const t = bt(
-    e.key,
-    {
-      in: e.in,
-      out: e.out
-    },
-    {
-      strategy: e[Q],
-      scope: e.scope
+const Gt = (e = {}) => {
+  const t = e.physics ?? qt, n = e.maxDistance ?? 700;
+  return {
+    prepare: ({ from: s }) => (s.then((o) => {
+      o.style.opacity = "0";
+    }), {}),
+    animation: ({ from: s, to: o, context: a }) => {
+      const i = s, l = o, c = Array.from(
+        l.querySelectorAll("[data-hero-key]")
+      ), r = [];
+      for (const f of c) {
+        const m = f.getAttribute("data-hero-key");
+        if (!m) continue;
+        const y = jt(i, m);
+        y && r.push({ key: m, fromEl: y, toEl: f });
+      }
+      if (r.length === 0)
+        return new $([], { mode: "parallel" });
+      const p = [], d = [];
+      for (const { fromEl: f, toEl: m } of r) {
+        const y = O(i, f), x = O(l, m), b = y.left - x.left - a.scrollOffset.x, C = y.top - x.top - a.scrollOffset.y, E = y.width / x.width, L = y.height / x.height;
+        if (Math.abs(C) > n) continue;
+        const A = m.style.transform, Y = m.style.position, F = m.style.transformOrigin, at = m.style.zIndex, lt = m.style.willChange;
+        m.style.position = "relative", m.style.transformOrigin = "top left", m.style.zIndex = "1000", m.style.willChange = "transform", p.push(
+          new w({
+            element: m,
+            integrator: g.from(t),
+            style: (W, _) => {
+              const ct = _ * b, pt = _ * C, dt = W + _ * E, ft = W + _ * L;
+              return {
+                transform: `translate(${ct}px, ${pt}px) scale(${dt}, ${ft})`
+              };
+            }
+          })
+        ), d.push(() => {
+          m.style.transform = A, m.style.position = Y, m.style.transformOrigin = F, m.style.zIndex = at, m.style.willChange = lt;
+        });
+      }
+      const h = new $(p, {
+        mode: "parallel"
+      }), u = h.onComplete;
+      return h.onComplete = () => {
+        for (const f of d) f();
+        u == null || u();
+      }, 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);
+  };
+};
+function ke({ paths: e }) {
+  return P(e, () => Gt());
+}
+const Kt = {
+  spring: { stiffness: 50, damping: 30 }
+}, Jt = {
+  spring: { stiffness: 80, damping: 25 }
+}, Qt = (e = {}) => {
+  const t = e.physics ?? Kt, n = e.initialRotation ?? 45, s = e.initialScale ?? 0.01, o = e.rotationTriggerPoint ?? 0.8;
+  return {
+    prepare: ({ from: a, to: i, context: l }) => (a.then((c) => {
+      c.style.opacity = "1";
+    }), i.then((c) => {
+      const r = T(l, "to"), p = Math.min(r.width, r.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 = r.left + r.width / 2, h = r.top + r.height / 2;
+      c.style.transformOrigin = `${d}px ${h}px`, c.style.position = "fixed", c.style.top = `${r.top}px`, c.style.left = `${r.left}px`, c.style.width = `${r.width}px`, c.style.height = `${r.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: a, to: i }) => {
+      const l = new w({
+        element: a,
+        integrator: g.from(Jt),
+        style: (r, p) => ({ opacity: p })
+      }), c = new w({
+        element: i,
+        integrator: g.from(t),
+        style: (r) => {
+          let p;
+          if (r <= 0.05)
+            p = s;
+          else if (r <= o) {
+            const f = (r - 0.05) / (o - 0.05), m = Math.pow(f, 9);
+            p = s + (0.8 - s) * m;
+          } else {
+            const f = (r - o) / (1 - o);
+            p = 0.8 + 0.2 * (1 - Math.pow(1 - f, 3));
+          }
+          const d = 0.7;
+          let h;
+          if (r <= d)
+            h = n;
+          else {
+            const f = (r - d) / (1 - d), m = 1 - Math.pow(1 - f, 2);
+            h = n * (1 - m);
+          }
+          let u;
+          if (r <= d)
+            u = 1;
+          else {
+            const f = (r - d) / (1 - d);
+            u = 1 - Math.pow(f, 0.5);
+          }
+          return {
+            transform: `rotate(${h.toFixed(2)}deg) scale(${p.toFixed(4)}) translateZ(0)`,
+            "--border-radius-scale": u.toFixed(4)
+          };
+        },
+        onComplete: () => {
+          i.style.willChange = "", i.style.backfaceVisibility = "", i.style.removeProperty("--max-border-radius"), i.style.removeProperty("--border-radius-scale"), i.style.transform = "", i.style.transformOrigin = "", i.style.position = "", i.style.zIndex = "", i.style.top = "", i.style.left = "", i.style.width = "", i.style.height = "", i.style.overflow = "", i.style.borderRadius = "";
+        }
+      });
+      return new $([l, c], { mode: "parallel" });
     }
-  }, X.set(e.key, n), n);
+  };
+};
+function ve({ paths: e }) {
+  return P(e, () => Qt());
 }
-function Rt(e) {
-  const i = e.filter((t) => t.symmetric).map((t) => ({
-    from: t.to,
-    to: t.from,
-    transition: t.transition
-  }));
-  return [...e, ...i];
+const Rt = {
+  spring: { stiffness: 100, damping: 30 }
+}, te = (e = {}) => {
+  const t = e.physics ?? Rt;
+  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 w({
+        element: n,
+        integrator: g.from(t),
+        style: (i) => ({
+          transform: `rotate(${i * 180}deg)`,
+          opacity: i < 0.5 ? 1 : 0
+        })
+      }), a = new w({
+        element: s,
+        integrator: g.from(t),
+        // u runs 1→0, so -u*180 unwinds -180→0.
+        style: (i, l) => ({
+          transform: `rotate(${-l * 180}deg)`,
+          opacity: i > 0.5 ? 1 : 0
+        }),
+        onComplete: () => {
+          s.style.willChange = "auto", s.style.transform = "", s.style.transformOrigin = "", s.style.opacity = "";
+        }
+      });
+      return new $([o, a], { mode: "parallel" });
+    }
+  };
+};
+function Le({ paths: e }) {
+  return P(e, () => te());
 }
-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;
+const ee = {
+  spring: {
+    stiffness: 20,
+    damping: 8,
+    doubleSpring: 1,
+    restDelta: 1e-3,
+    restSpeed: 1e-3
   }
-  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;
+}, J = (e = {}) => {
+  const t = e.direction ?? "up", n = e.physics ?? ee, s = t === "up";
+  return {
+    prepare: ({ from: o, to: a }) => (o.then((i) => {
+      i.style.zIndex = s ? "-1" : "1", i.style.willChange = "transform", i.style.backfaceVisibility = "hidden", i.style.contain = "layout paint", i.style.pointerEvents = "none";
+    }), a.then((i) => {
+      i.style.willChange = "transform", i.style.backfaceVisibility = "hidden", i.style.contain = "layout paint";
+    }), {}),
+    animation: ({ from: o, to: a }) => {
+      const i = o.offsetHeight, l = a.offsetHeight, c = window.innerHeight, r = Math.max(Math.min(i, l), c), p = new w({
+        element: o,
+        integrator: g.from(n),
+        style: (h) => ({ transform: `translate3d(0, ${s ? -r * h : r * h}px, 0)` })
+      }), d = new w({
+        element: a,
+        integrator: g.from(n),
+        style: (h, u) => ({ transform: `translate3d(0, ${s ? u * r : u * -r}px, 0)` }),
+        onComplete: () => {
+          a.style.willChange = "auto", a.style.backfaceVisibility = "", a.style.contain = "", a.style.transform = "";
+        }
+      });
+      return new $([p, d], { mode: "parallel" });
+    }
+  };
+};
+function Ye({
+  paths: e,
+  type: t = "directional",
+  direction: n = "up"
+}) {
+  return t === "non-directional" ? P(
+    e,
+    () => J({ direction: n })
+  ) : ot(
+    e,
+    { forward: "up", backward: "down" },
+    (s) => J({ direction: s })
+  );
 }
-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));
+const ne = {
+  spring: { stiffness: 200, damping: 24 }
+}, se = {
+  inertia: { acceleration: 25, resistance: 1.2 }
+}, z = 0.2;
+function oe() {
+  return {
+    enterPhysics: ne,
+    exitPhysics: se,
+    background: {
+      willChange: "transform, opacity",
+      enterStyle: (e, t) => ({
+        transform: `scale(${1 - z * e})`,
+        opacity: t
+      }),
+      exitStyle: (e) => ({
+        transform: `scale(${1 - z + z * e})`,
+        opacity: e
+      })
+    }
   };
-  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
-    });
-  }, 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 ie = {
+  spring: { stiffness: 200, damping: 24 }
+}, re = {
+  inertia: { acceleration: 25, resistance: 1.2 }
+};
+function ae() {
+  return {
+    enterPhysics: ie,
+    exitPhysics: re,
+    background: {
+      willChange: "",
+      enterStyle: () => ({}),
+      exitStyle: () => ({})
+    }
   };
+}
+const le = {
+  static: ae(),
+  "background-scale": oe()
+}, ce = "static", pe = "transform", de = (e = {}) => {
+  const t = e.direction ?? "enter", n = le[e.type ?? ce], s = t === "enter" ? n.enterPhysics : n.exitPhysics, o = n.background, a = o.willChange !== "";
   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);
+    prepare: ({ from: i, to: l }) => {
+      const c = t === "enter" ? l : i, r = t === "enter" ? i : l;
+      return c.then((p) => {
+        p.style.willChange = pe, p.style.backfaceVisibility = "hidden", p.style.contain = "layout paint", t === "exit" && (p.style.pointerEvents = "none", p.style.zIndex = "100");
+      }), r.then((p) => {
+        a && (p.style.willChange = o.willChange, p.style.backfaceVisibility = "hidden", p.style.contain = "layout paint"), t === "enter" && (p.style.pointerEvents = "none", p.style.zIndex = "-1");
+      }), {};
     },
-    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);
-    },
-    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: l, context: c }) => {
+      const r = t === "enter" ? l : i, p = t === "enter" ? i : l, d = T(
+        c,
+        t === "enter" ? "to" : "from"
+      );
+      r.style.clipPath = `inset(${d.top}px 0 calc(100% - ${d.top + d.height}px) 0)`;
+      const h = t === "enter" ? (C, E) => ({
+        transform: `translate3d(0, ${E * d.height}px, 0)`
+      }) : (C) => ({
+        transform: `translate3d(0, ${C * d.height}px, 0)`
+      }), u = new w({
+        element: r,
+        integrator: g.from(s),
+        style: h,
+        onComplete: () => {
+          r.style.willChange = "auto", r.style.backfaceVisibility = "", r.style.contain = "", r.style.clipPath = "", r.style.transform = "";
+        }
+      });
+      if (!a)
+        return new $([u], { mode: "parallel" });
+      const f = T(
+        c,
+        t === "enter" ? "from" : "to"
+      ), m = 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 = `${m}px ${y}px`;
+      const x = t === "enter" ? (C, E) => o.enterStyle(C, E) : (C) => o.exitStyle(C), b = new w({
+        element: p,
+        integrator: g.from(s),
+        style: x,
+        onComplete: t === "exit" ? () => {
+          p.style.willChange = "auto", p.style.backfaceVisibility = "", p.style.contain = "", p.style.clipPath = "", p.style.transformOrigin = "";
+        } : void 0
+      });
+      return new $([u, b], { mode: "parallel" });
+    }
   };
+};
+function Fe({ type: e, ...t }) {
+  return st(
+    t,
+    (n) => de({ direction: n, type: e })
+  );
 }
-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;
-    }
-    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;
-    }
-    const f = w.touches.item(0);
-    if (!f) {
-      e = null;
-      return;
-    }
-    const a = window.innerWidth, A = f.clientX <= j, c = f.clientX >= a - j;
-    if (!A && !c) {
-      e = null;
-      return;
-    }
-    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 f = s(w.touches, e.identifier);
-    if (!f) {
-      e = null;
-      return;
+const fe = {
+  spring: { stiffness: 170, damping: 22, doubleSpring: 0.8 }
+}, he = (e = {}) => {
+  const t = e.direction ?? "left", n = e.physics ?? fe, s = t === "left";
+  return {
+    prepare: ({ from: o, to: a }) => (o.then((i) => {
+      i.style.willChange = "transform", i.style.backfaceVisibility = "hidden", i.style.contain = "layout paint", i.style.pointerEvents = "none";
+    }), a.then((i) => {
+      const l = s ? 100 : -100;
+      i.style.transform = `translate3d(${l}%, 0, 0)`, i.style.willChange = "transform", i.style.backfaceVisibility = "hidden", i.style.contain = "layout paint";
+    }), {}),
+    animation: ({ from: o, to: a }) => {
+      const i = new w({
+        element: o,
+        integrator: g.from(n),
+        style: (c) => ({ transform: `translate3d(${s ? -100 * c : 100 * c}%, 0, 0)` })
+      }), l = new w({
+        element: a,
+        integrator: g.from(n),
+        style: (c, r) => ({ transform: `translate3d(${s ? r * 100 : r * -100}%, 0, 0)` }),
+        onComplete: () => {
+          a.style.willChange = "auto", a.style.backfaceVisibility = "", a.style.contain = "", a.style.transform = "";
+        }
+      });
+      return new $([i, 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 Me({ paths: e }) {
+  return ot(
+    e,
+    { forward: "left", backward: "right" },
+    (t) => he({ direction: t })
+  );
+}
+const me = {
+  spring: { stiffness: 17, damping: 6 }
+}, V = 20, k = 800, ue = (e = {}) => {
+  const t = e.physics ?? me;
+  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(${k}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(${k}px) rotateY(${V}deg) translate3d(-100%, 0, 0)`;
+    }), {}),
+    animation: ({ from: n, to: s }) => {
+      const o = new w({
+        element: n,
+        integrator: g.from(t),
+        style: (i) => {
+          const l = -i * V, c = i * 100;
+          return {
+            transform: `perspective(${k}px) rotateY(${l}deg) translate3d(${c}%, 0, 0)`
+          };
+        }
+      }), a = new w({
+        element: s,
+        integrator: g.from(t),
+        style: (i, l) => {
+          const c = l * V, r = -l * 100;
+          return {
+            transform: `perspective(${k}px) rotateY(${c}deg) translate3d(${r}%, 0, 0)`
+          };
+        },
+        onComplete: () => {
+          s.style.transform = "", s.style.willChange = "auto", s.style.backfaceVisibility = "", s.style.contain = "";
+        }
+      });
+      return new $([o, a], { 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 He({ paths: e }) {
+  return P(e, () => ue());
+}
+function it({
+  enterRect: e,
+  exitRect: t,
+  pageRect: n,
+  scrollOffset: s
+}) {
+  const o = t.left - e.left + (t.width - e.width) / 2 - s.x, a = t.top - e.top + (t.height - e.height) / 2 - s.y, i = t.width / e.width, l = t.height / e.height, c = Math.max(i, l), r = e.top / n.height * 100, p = (n.width - (e.left + e.width)) / n.width * 100, d = (n.height - (e.top + e.height)) / n.height * 100, h = e.left / n.width * 100;
+  return {
+    transformOrigin: `${e.left + e.width / 2}px ${e.top + e.height / 2}px`,
+    animate: (u) => {
+      const f = 1 - u;
+      return {
+        clipPath: `inset(${r * f}% ${p * f}% ${d * f}% ${h * f}%)`,
+        transform: `translate(${o * f}px, ${a * f}px) scale(${1 + (c - 1) * f})`
+      };
     }
-    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 rt({
+  enterRect: e,
+  exitRect: t,
+  pageRect: n,
+  scrollOffset: s
+}) {
+  const o = t.left - e.left + (t.width - e.width) / 2 + s.x, a = t.top - e.top + (t.height - e.height) / 2 + s.y, i = t.width / e.width, l = t.height / e.height, c = Math.min(i, l), r = e.top / n.height * 100, p = (n.width - (e.left + e.width)) / n.width * 100, d = (n.height - (e.top + e.height)) / n.height * 100, h = e.left / n.width * 100;
+  return {
+    transformOrigin: `${e.left + e.width / 2}px ${e.top + e.height / 2}px`,
+    animate: (u) => {
+      const f = 1 - u;
+      return {
+        clipPath: `inset(${r * f}% ${p * f}% ${d * f}% ${h * f}%)`,
+        transform: `translate(${o * f - s.x}px, ${a * f}px) scale(${1 + (c - 1) * f})`
+      };
     }
-    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 ye = {
+  spring: { stiffness: 340, damping: 30, doubleSpring: 1 }
+};
+function ge({
+  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, a = e.width / t.width, i = e.height / t.height, l = Math.max(a, i);
+  return {
+    transformOrigin: `${t.left + t.width / 2}px ${t.top + t.height / 2}px`,
+    animate: (c) => {
+      const r = 1 - c;
+      return {
+        transform: `translate(${s * r - n.x}px, ${o * r}px) scale(${1 + (l - 1) * r})`,
+        opacity: `${1 - r}`
+      };
     }
-  }
+  };
+}
+function we({
+  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, a = e.width / t.width, i = e.height / t.height, l = Math.max(a, i);
   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: `${t.left + t.width / 2}px ${t.top + t.height / 2}px`,
+    animate: (c) => {
+      const r = 1 - c;
+      return {
+        transform: `translate(${s * r}px, ${o * r}px) scale(${1 + (l - 1) * r})`,
+        opacity: `${c}`
+      };
     }
   };
 }
-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);
+function be() {
+  return {
+    physics: ye,
+    in: it,
+    out: rt,
+    backgroundIn: we,
+    backgroundOut: ge
+  };
+}
+const Se = {
+  spring: { stiffness: 420, damping: 34 }
+};
+function Q() {
+  return {
+    transformOrigin: "",
+    animate: () => ({})
+  };
+}
+function $e() {
+  return {
+    physics: Se,
+    in: it,
+    out: rt,
+    backgroundIn: () => Q(),
+    backgroundOut: () => Q()
+  };
+}
+const xe = {
+  expand: be(),
+  static: $e()
+}, X = "data-zoom-enter-key", R = "data-zoom-exit-key";
+function tt(e) {
+  const t = e.querySelectorAll(`[${X}]`);
+  return t.length !== 1 ? null : t[0];
+}
+function et(e, t) {
+  const n = e.querySelectorAll(`[${R}]`);
+  for (const s of n)
+    if (s.getAttribute(R) === t)
+      return s;
+  return null;
+}
+function Ce(e, t) {
+  const n = tt(e), s = tt(t);
+  if (!n && s) {
+    const o = s.getAttribute(X);
+    if (!o) return null;
+    const a = et(e, o);
+    return a ? { mode: "enter", enterEl: s, exitEl: a } : null;
   }
-  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;
-    }
+  if (n && !s) {
+    const o = n.getAttribute(X);
+    if (!o) return null;
+    const a = et(t, o);
+    return a ? { mode: "exit", enterEl: n, exitEl: a } : null;
   }
+  return null;
+}
+function Ee(e, t, n, s) {
   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();
-      });
-    }
+    enterRect: O(
+      e.mode === "enter" ? n : t,
+      e.enterEl
+    ),
+    exitRect: O(
+      e.mode === "enter" ? t : n,
+      e.exitEl
+    ),
+    pageRect: e.mode === "enter" ? n.getBoundingClientRect() : t.getBoundingClientRect(),
+    scrollOffset: s
   };
 }
-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();
-        }
-      };
-      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();
+const Pe = (e) => {
+  const t = xe[e.type], n = t.physics;
+  return {
+    prepare: ({ from: s }) => (s.then((o) => {
+      o.style.willChange = "transform, clip-path, opacity", o.style.backfaceVisibility = "hidden", o.style.contain = "layout paint";
+    }), {}),
+    animation: ({ from: s, to: o, context: a }) => {
+      const i = Ce(s, o);
+      if (!i)
+        return new $([], { mode: "parallel" });
+      const l = Ee(i, s, o, a.scrollOffset), c = i.mode === "enter" ? t.in(l) : t.backgroundIn(l), r = i.mode === "enter" ? t.backgroundOut(l) : t.out(l);
+      c && (o.style.transformOrigin = c.transformOrigin), r && (s.style.transformOrigin = r.transformOrigin);
+      const p = i.mode === "enter" ? o : s, d = p.style.zIndex;
+      p.style.zIndex = "9999";
+      const h = new w({
+        element: s,
+        integrator: g.from(n),
+        // The provider's `animate` was authored against legacy convention
+        // where OUT runs `progress: 1 → 0`. Our `u` mirrors that, so feeding
+        // `u` keeps the visual direction (full page → shrunk to tile) intact.
+        style: (f, m) => r.animate(m)
+      }), u = new w({
+        element: o,
+        integrator: g.from(n),
+        style: (f) => c.animate(f),
+        onComplete: () => {
+          o.style.willChange = "auto", o.style.backfaceVisibility = "", o.style.transformOrigin = "", o.style.contain = "", p.style.zIndex = d;
         }
-      };
-      return (D) => R.in(D, x);
+      });
+      return new $([h, 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 Ue({ paths: e, type: t }) {
+  return P(e, () => Pe({ type: 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
+  Xe as Animation,
+  $ as MultiAnimation,
+  w as WebAnimation,
+  Ie as blind,
+  Te as drill,
+  Ae as fade,
+  _e as film,
+  ke as hero,
+  ve as jaemin,
+  Le as rotate,
+  Ye as scroll,
+  Fe as sheet,
+  Me as slide,
+  He as strip,
+  Ue as zoom
 };