@ssgoi/core 2.5.0 → 2.5.2

package/dist/index.js

@@ -1,109 +1,207 @@
-var I = Object.defineProperty;
-var _ = (e, t, n) => t in e ? I(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
-var v = (e, t, n) => _(e, typeof t != "symbol" ? t + "" : t, n);
-import { animate as x } from "popmotion";
-import { j as nt } from "./jaemin-BAi8PTrj.js";
-class A {
+var _ = Object.defineProperty;
+var $ = (n, t, e) => t in n ? _(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var d = (n, t, e) => $(n, typeof t != "symbol" ? t + "" : t, e);
+import { isMultiSpring as R } from "./types.js";
+import { isSingleSpring as at } from "./types.js";
+import { j as lt } from "./jaemin-BAi8PTrj.js";
+class F {
+  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
+    // FPS throttling
+    d(this, "gap", 1e3 / 240);
+    // max 240fps
+    d(this, "nextTime", this.gap);
+    d(this, "tick", () => {
+      const t = Date.now();
+      let e = t - this.lastUpdate;
+      (e > this.lagThreshold || e < 0) && (this.startTime += e - this.adjustedLag, e = this.adjustedLag), this.lastUpdate = t;
+      const i = t - this.startTime, r = i - this.nextTime;
+      if (r > 0) {
+        const o = e / 1e3;
+        this.elapsed = i / 1e3, this.nextTime += r + (r >= this.gap ? 4 : this.gap - r), this.listeners.forEach((s) => {
+          s(o, this.elapsed);
+        });
+      }
+      this.listeners.size > 0 ? this.rafId = requestAnimationFrame(this.tick) : (this.isRunning = !1, this.rafId = null);
+    });
+  }
+  subscribe(t) {
+    return this.listeners.add(t), this.isRunning || (this.isRunning = !0, this.rafId = requestAnimationFrame(this.tick)), () => {
+      this.unsubscribe(t);
+    };
+  }
+  unsubscribe(t) {
+    this.listeners.delete(t), 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(t, e) {
+    this.lagThreshold = t, this.adjustedLag = Math.min(e, t);
+  }
+  /**
+   * Set maximum FPS
+   * @param fps - Target FPS (default: 240)
+   */
+  fps(t) {
+    this.gap = 1e3 / t, this.nextTime = this.elapsed * 1e3 + this.gap;
+  }
+  getListenerCount() {
+    return this.listeners.size;
+  }
+  getElapsed() {
+    return this.elapsed;
+  }
+}
+const I = new F();
+function k(n) {
+  const {
+    from: t,
+    to: e,
+    stiffness: i,
+    damping: r,
+    mass: o,
+    velocity: s = 0,
+    onUpdate: m,
+    onComplete: l
+  } = n;
+  let h = t, u = s, a = !0;
+  const p = Math.sqrt(i / o), c = r / (2 * Math.sqrt(i * o)), S = 0.01, w = 0.01;
+  let f = 0;
+  const g = 0.05, v = (A) => {
+    if (!a) return;
+    const C = Math.min(A, 0.033), y = -2 * C * c * p * u, b = C * p * p * (e - h);
+    u += y + b, h += C * u;
+    const E = Math.abs(e - h), T = Math.abs(u);
+    if (E < S && T < w) {
+      if (f += C, f >= g) {
+        h = e, u = 0, a = !1, m(h), I.unsubscribe(v), l();
+        return;
+      }
+    } else
+      f = 0;
+    m(h);
+  };
+  return I.subscribe(v), {
+    stop: () => {
+      a && (a = !1, I.unsubscribe(v));
+    }
+  };
+}
+class O {
   constructor(t) {
-    v(this, "options");
-    v(this, "currentValue");
-    v(this, "velocity");
-    v(this, "isAnimating", !1);
-    v(this, "controls", null);
+    d(this, "options");
+    d(this, "currentValue");
+    d(this, "velocity");
+    d(this, "isAnimating", !1);
+    d(this, "controls", null);
     // For object animations
-    v(this, "animationMap", null);
-    v(this, "activeAnimations", /* @__PURE__ */ new Set());
-    v(this, "completedAnimations", /* @__PURE__ */ new Set());
-    v(this, "updatedProperties", /* @__PURE__ */ new Set());
-    v(this, "animate", (t = !1) => {
+    d(this, "animationMap", null);
+    d(this, "activeAnimations", /* @__PURE__ */ new Set());
+    d(this, "completedAnimations", /* @__PURE__ */ new Set());
+    d(this, "updatedProperties", /* @__PURE__ */ new Set());
+    d(this, "animate", (t = !1) => {
       !this.isAnimating && this.options.onStart && this.options.onStart(), this.isAnimating = !0;
-      const n = t ? this.options.from : this.options.to;
+      const e = t ? this.options.from : this.options.to;
       if (typeof this.currentValue == "object" && this.currentValue !== null) {
-        this.animateObject(n);
+        this.animateObject(e);
         return;
       }
-      let o = this.currentValue, s = performance.now();
-      const i = {
+      let i = this.currentValue, r = performance.now();
+      const o = {
         from: this.currentValue,
-        to: n,
+        to: e,
         stiffness: this.options.spring.stiffness,
         damping: this.options.spring.damping,
         mass: 1
       };
-      typeof this.velocity == "number" && (i.velocity = this.velocity * 1e3), this.controls = x({
-        ...i,
-        onUpdate: (u) => {
-          const d = performance.now(), a = (d - s) / 1e3;
-          if (a > 0) {
-            if (typeof u == "number" && typeof o == "number") {
-              const m = (u - o) / a;
-              this.velocity = m / 1e3;
-            } else if (typeof u == "object" && u !== null) {
-              const m = {};
-              Object.keys(u).forEach((l) => {
-                const r = u[l], f = o[l];
-                if (typeof r == "number" && typeof f == "number") {
-                  const g = (r - f) / a;
-                  m[l] = g / 1e3;
+      typeof this.velocity == "number" && (o.velocity = this.velocity * 1e3), this.controls = k({
+        ...o,
+        onUpdate: (s) => {
+          const m = performance.now(), l = (m - r) / 1e3;
+          if (l > 0) {
+            if (typeof s == "number" && typeof i == "number") {
+              const h = (s - i) / l;
+              this.velocity = h / 1e3;
+            } else if (typeof s == "object" && s !== null) {
+              const h = {};
+              Object.keys(s).forEach((u) => {
+                const a = s[u], p = i[u];
+                if (typeof a == "number" && typeof p == "number") {
+                  const c = (a - p) / l;
+                  h[u] = c / 1e3;
                 }
-              }), this.velocity = m;
+              }), this.velocity = h;
             }
-            o = u, s = d;
+            i = s, r = m;
           }
-          this.currentValue = u, this.options.onUpdate(u);
+          this.currentValue = s, this.options.onUpdate(s);
         },
         onComplete: () => {
-          this.currentValue = n, this.isAnimating = !1, this.controls = null, typeof this.velocity == "object" && this.velocity !== null ? Object.keys(this.velocity).forEach((u) => {
-            this.velocity[u] = 0;
+          this.currentValue = e, this.isAnimating = !1, this.controls = null, typeof this.velocity == "object" && this.velocity !== null ? Object.keys(this.velocity).forEach((s) => {
+            this.velocity[s] = 0;
           }) : this.velocity = 0, this.options.onComplete();
         }
       });
     });
-    v(this, "animateObject", (t) => {
-      const n = this.currentValue, o = Object.keys(n);
+    d(this, "animateObject", (t) => {
+      const e = this.currentValue, i = Object.keys(e);
       this.animationMap = /* @__PURE__ */ new Map(), this.activeAnimations.clear(), this.completedAnimations.clear(), this.updatedProperties.clear();
-      const s = { ...n }, i = {};
-      let u = !1;
-      const d = () => {
-        const a = o.filter((l) => !this.completedAnimations.has(l));
-        if (a.every(
-          (l) => this.updatedProperties.has(l)
-        ) && a.length > 0) {
+      const r = { ...e }, o = {};
+      let s = !1;
+      const m = () => {
+        const l = i.filter((u) => !this.completedAnimations.has(u));
+        if (l.every(
+          (u) => this.updatedProperties.has(u)
+        ) && l.length > 0) {
           if (typeof this.velocity == "object" && this.velocity) {
-            const l = performance.now();
-            Object.keys(s).forEach((r) => {
-              if (i[r]) {
-                const f = (l - i[r]) / 1e3, g = this.currentValue[r], c = s[r];
-                typeof g == "number" && typeof c == "number" && f > 0 && (this.velocity[r] = (c - g) / f / 1e3);
+            const u = performance.now();
+            Object.keys(r).forEach((a) => {
+              if (o[a]) {
+                const p = (u - o[a]) / 1e3, c = this.currentValue[a], S = r[a];
+                typeof c == "number" && typeof S == "number" && p > 0 && (this.velocity[a] = (S - c) / p / 1e3);
               }
-              i[r] = l;
+              o[a] = u;
             });
           }
-          this.currentValue = { ...s }, this.options.onUpdate(this.currentValue), this.updatedProperties.clear(), !u && this.options.onStart && (u = !0, this.options.onStart());
+          this.currentValue = { ...r }, this.options.onUpdate(this.currentValue), this.updatedProperties.clear(), !s && this.options.onStart && (s = !0, this.options.onStart());
         }
       };
-      o.forEach((a) => {
-        this.activeAnimations.add(a);
-        const m = {
-          from: n[a],
-          to: t[a],
+      i.forEach((l) => {
+        this.activeAnimations.add(l);
+        const h = {
+          from: e[l],
+          to: t[l],
           stiffness: this.options.spring.stiffness,
           damping: this.options.spring.damping,
           mass: 1
         };
-        typeof this.velocity == "object" && this.velocity && a in this.velocity && (m.velocity = this.velocity[a] * 1e3);
-        const l = x({
-          ...m,
-          onUpdate: (r) => {
-            s[a] = r, this.updatedProperties.add(a), d();
+        typeof this.velocity == "object" && this.velocity && l in this.velocity && (h.velocity = this.velocity[l] * 1e3);
+        const u = k({
+          ...h,
+          onUpdate: (a) => {
+            r[l] = a, this.updatedProperties.add(l), m();
           },
           onComplete: () => {
-            this.completedAnimations.add(a), this.updatedProperties.delete(a), this.completedAnimations.size === o.length && (this.currentValue = t, this.isAnimating = !1, this.animationMap = null, typeof this.velocity == "object" && this.velocity && Object.keys(this.velocity).forEach((r) => {
-              this.velocity[r] = 0;
+            this.completedAnimations.add(l), this.updatedProperties.delete(l), this.completedAnimations.size === i.length && (this.currentValue = t, this.isAnimating = !1, this.animationMap = null, typeof this.velocity == "object" && this.velocity && Object.keys(this.velocity).forEach((a) => {
+              this.velocity[a] = 0;
             }), this.options.onComplete());
           }
         });
-        this.animationMap.set(a, l);
+        this.animationMap.set(l, u);
       });
     });
     if (this.options = {
@@ -116,10 +214,10 @@ class A {
       }),
       onStart: t.onStart
     }, this.currentValue = this.options.from, typeof this.options.from == "object" && this.options.from !== null) {
-      const n = {};
-      Object.keys(this.options.from).forEach((o) => {
-        n[o] = 0;
-      }), this.velocity = n;
+      const e = {};
+      Object.keys(this.options.from).forEach((i) => {
+        e[i] = 0;
+      }), this.velocity = e;
     } else
       this.velocity = 0;
   }
@@ -133,8 +231,8 @@ class A {
   reverse() {
     const t = this.options.from;
     if (this.options.from = this.options.to, this.options.to = t, this.isAnimating) {
-      const n = this.shouldReverse();
-      this.stop(), this.animate(!n);
+      const e = this.shouldReverse();
+      this.stop(), this.animate(!e);
     }
   }
   shouldReverse() {
@@ -157,6 +255,7 @@ class A {
   }
   getCurrentState() {
     return {
+      type: "single",
       position: this.currentValue,
       velocity: this.velocity,
       from: this.options.from,
@@ -173,38 +272,287 @@ class A {
   // Configuration
   updateOptions(t) {
     if (this.options = { ...this.options, ...t }, this.isAnimating && this.controls) {
-      const n = this.shouldReverse();
-      this.stop(), this.animate(!n);
+      const e = this.shouldReverse();
+      this.stop(), this.animate(!e);
     }
   }
   // Static factory method
-  static fromState(t, n) {
-    const o = new A(n);
-    return o.setValue(t.position), o.setVelocity(t.velocity), o;
+  static fromState(t, e) {
+    const i = new O(e);
+    return i.setValue(t.position), i.setVelocity(t.velocity), i;
+  }
+}
+class j {
+  constructor(t) {
+    d(this, "config");
+    d(this, "animators", /* @__PURE__ */ new Map());
+    d(this, "springOrder", []);
+    d(this, "completedCount", 0);
+    d(this, "completedAnimators", /* @__PURE__ */ new Set());
+    d(this, "direction", "forward");
+    d(this, "idCounter", 0);
+    d(this, "timeoutIds", []);
+    this.config = t, this.initializeAnimators();
+  }
+  generateId() {
+    return `spring_${this.idCounter++}`;
+  }
+  initializeAnimators() {
+    this.config.springs.forEach((t) => {
+      const e = this.generateId(), i = new O({
+        from: t.from,
+        to: t.to,
+        spring: t.spring,
+        onUpdate: t.tick,
+        onComplete: () => this.onAnimatorComplete(e),
+        onStart: t.onStart
+      });
+      this.animators.set(e, {
+        id: e,
+        item: t,
+        animator: i,
+        startTime: null
+      }), this.springOrder.push(e);
+    });
+  }
+  /**
+   * Normalize schedule configuration to unified internal representation
+   * Uses discriminated union and early return pattern
+   *
+   * @param direction - "forward" or "backward" direction
+   */
+  normalizeSchedule(t) {
+    const e = this.config.schedule ?? "overlap";
+    return this.springOrder.map((i, r) => {
+      const o = this.animators.get(i);
+      if (!o)
+        throw new Error(
+          `AnimationScheduler: animator with id "${i}" not found during normalization`
+        );
+      if (e === "overlap")
+        return {
+          type: "offset",
+          id: i,
+          delay: 0
+        };
+      if (e === "wait")
+        return t === "forward" && r === 0 ? {
+          type: "offset",
+          id: i,
+          delay: 0
+        } : t === "backward" && r === this.springOrder.length - 1 ? {
+          type: "offset",
+          id: i,
+          delay: 0
+        } : {
+          type: "wait",
+          id: i
+        };
+      const s = o.item.offset ?? 0;
+      if (t === "forward")
+        return {
+          type: "offset",
+          id: i,
+          delay: s
+        };
+      const m = this.animators.size === 0 ? 0 : Math.max(
+        ...Array.from(this.animators.values()).map(
+          (l) => l.item.offset ?? 0
+        )
+      );
+      return {
+        type: "offset",
+        id: i,
+        delay: m - s
+      };
+    });
+  }
+  onAnimatorComplete(t) {
+    var i, r, o, s, m, l;
+    const e = this.animators.get(t);
+    if (!e) {
+      console.warn(
+        `AnimationScheduler: animator with id "${t}" not found on completion`
+      );
+      return;
+    }
+    this.completedAnimators.has(t) || (this.completedAnimators.add(t), this.completedCount++, (r = (i = e.item).onComplete) == null || r.call(i), (s = (o = this.config).onProgress) == null || s.call(o, this.completedCount, this.config.springs.length), this.handleWaitModeChaining(t), this.completedCount === this.config.springs.length && ((l = (m = this.config).onEnd) == null || l.call(m)));
+  }
+  /**
+   * Handle wait mode chaining: start next/previous spring after completion
+   */
+  handleWaitModeChaining(t) {
+    if (this.config.schedule !== "wait")
+      return;
+    const e = this.springOrder.indexOf(t);
+    if (this.direction === "forward") {
+      const o = this.springOrder[e + 1];
+      if (!o)
+        return;
+      const s = this.animators.get(o);
+      s && s.startTime === null && this.startAnimator(o);
+      return;
+    }
+    const i = this.springOrder[e - 1];
+    if (!i)
+      return;
+    const r = this.animators.get(i);
+    r && r.startTime === null && this.startBackwardAnimator(i);
+  }
+  startAnimator(t) {
+    const e = this.animators.get(t);
+    if (!e) {
+      console.warn(
+        `AnimationScheduler: animator with id "${t}" not found on start`
+      );
+      return;
+    }
+    if (e.startTime !== null) {
+      console.warn(
+        `AnimationScheduler: animator with id "${t}" already started`
+      );
+      return;
+    }
+    e.startTime = Date.now(), e.animator.forward();
+  }
+  startBackwardAnimator(t) {
+    const e = this.animators.get(t);
+    if (!e) {
+      console.warn(
+        `AnimationScheduler: animator with id "${t}" not found on backward start`
+      );
+      return;
+    }
+    if (e.startTime !== null) {
+      console.warn(
+        `AnimationScheduler: animator with id "${t}" already started`
+      );
+      return;
+    }
+    e.startTime = Date.now(), e.animator.backward();
+  }
+  forward() {
+    var e, i;
+    this.stop(), this.direction = "forward", this.completedCount = 0, this.completedAnimators.clear(), (i = (e = this.config).onStart) == null || i.call(e), this.normalizeSchedule("forward").forEach((r) => {
+      if (r.type === "wait")
+        return;
+      if (r.delay === 0) {
+        this.startAnimator(r.id);
+        return;
+      }
+      const o = window.setTimeout(
+        () => this.startAnimator(r.id),
+        r.delay
+      );
+      this.timeoutIds.push(o);
+    });
+  }
+  backward() {
+    var e, i;
+    this.stop(), this.direction = "backward", this.completedCount = 0, this.completedAnimators.clear(), (i = (e = this.config).onStart) == null || i.call(e), this.normalizeSchedule("backward").forEach((r) => {
+      if (r.type === "wait")
+        return;
+      if (r.delay === 0) {
+        this.startBackwardAnimator(r.id);
+        return;
+      }
+      const o = window.setTimeout(
+        () => this.startBackwardAnimator(r.id),
+        r.delay
+      );
+      this.timeoutIds.push(o);
+    });
+  }
+  stop() {
+    this.timeoutIds.forEach((t) => clearTimeout(t)), this.timeoutIds = [], this.animators.forEach((t) => {
+      t.animator.stop(), t.startTime = null;
+    });
+  }
+  reverse(t) {
+    ((t == null ? void 0 : t.offsetMode) ?? "immediate") !== "immediate" && console.warn(
+      'AnimationScheduler.reverse(): Only "immediate" offsetMode is currently supported. Falling back to "immediate".'
+    ), this.direction = this.direction === "forward" ? "backward" : "forward", this.animators.forEach((i) => {
+      if (i.startTime === null)
+        return;
+      const r = i.animator.getCurrentState();
+      if (r.type !== "single")
+        return;
+      if (r.position === r.to) {
+        const s = O.fromState(
+          {
+            position: 1,
+            velocity: 0
+          },
+          {
+            from: i.item.to ?? 1,
+            to: i.item.from ?? 0,
+            spring: i.item.spring,
+            onUpdate: i.item.tick,
+            onComplete: () => this.onAnimatorComplete(i.id),
+            onStart: i.item.onStart
+          }
+        );
+        s.forward(), i.animator = s;
+        return;
+      }
+      i.animator.reverse();
+    });
+  }
+  getCurrentState() {
+    return {
+      type: "multi",
+      completed: this.completedCount,
+      total: this.config.springs.length,
+      direction: this.direction
+    };
   }
 }
-const j = Symbol.for("TRANSITION_STRATEGY"), D = (e) => ({
+const L = Symbol.for("TRANSITION_STRATEGY"), N = (n) => ({
   runIn: async (t) => {
-    const { currentAnimation: n } = e;
-    if (n && n.direction === "out") {
-      const u = n.animator.getCurrentState();
-      if (n.animator.stop(), t.out) {
-        const d = await t.out, { from: a = 1, to: m = 0 } = d;
+    const { currentAnimation: e } = n;
+    if (e && e.direction === "out") {
+      const s = e.controller.getCurrentState();
+      if (e.controller.stop(), s.type === "multi")
+        return e.controller.reverse(), {
+          state: {
+            position: 0,
+            velocity: 0
+          },
+          from: 0,
+          to: 1,
+          direction: "forward"
+        };
+      if (t.out) {
+        const m = await t.out, { from: l = 1, to: h = 0 } = m;
         return {
-          config: d,
-          state: u,
-          from: a,
+          config: m,
+          state: {
+            position: s.position,
+            velocity: s.velocity
+          },
+          from: l,
           // OUT animation's from
-          to: m,
+          to: h,
           // OUT animation's to
           direction: "backward"
           // Will actually go 0→1
         };
       }
     }
-    const o = await t.in;
-    if (!o)
+    const i = await t.in;
+    if (!i)
+      return {
+        state: {
+          position: 0,
+          velocity: 0
+        },
+        from: 0,
+        to: 1,
+        direction: "forward"
+      };
+    if ("springs" in i)
       return {
+        config: i,
         state: {
           position: 0,
           velocity: 0
@@ -213,42 +561,63 @@ const j = Symbol.for("TRANSITION_STRATEGY"), D = (e) => ({
         to: 1,
         direction: "forward"
       };
-    const { from: s = 0, to: i = 1 } = o;
+    const { from: r = 0, to: o = 1 } = i;
     return {
-      config: o,
+      config: i,
       state: {
-        position: s,
+        position: r,
         velocity: 0
       },
-      from: s,
-      to: i,
+      from: r,
+      to: o,
       direction: "forward"
     };
   },
   runOut: async (t) => {
-    const { currentAnimation: n } = e;
-    if (n && n.direction === "in") {
-      const u = n.animator.getCurrentState();
-      if (n.animator.stop(), t.in) {
-        const d = await t.in, { from: a = 0, to: m = 1 } = d;
+    const { currentAnimation: e } = n;
+    if (e && e.direction === "in") {
+      const s = e.controller.getCurrentState();
+      if (e.controller.stop(), s.type === "multi")
+        return e.controller.reverse(), {
+          state: {
+            position: 1,
+            velocity: 0
+          },
+          from: 1,
+          to: 0,
+          direction: "forward"
+        };
+      if (t.in) {
+        const m = await t.in, { from: l = 0, to: h = 1 } = m;
         return {
-          config: d,
+          config: m,
           state: {
-            position: u.position,
-            velocity: u.velocity
+            position: s.position,
+            velocity: s.velocity
           },
-          from: a,
+          from: l,
           // IN animation's from
-          to: m,
+          to: h,
           // IN animation's to
           direction: "backward"
           // Will actually go 1→0
         };
       }
     }
-    const o = await t.out;
-    if (!o)
+    const i = await t.out;
+    if (!i)
+      return {
+        state: {
+          position: 1,
+          velocity: 0
+        },
+        from: 1,
+        to: 0,
+        direction: "forward"
+      };
+    if ("springs" in i)
       return {
+        config: i,
         state: {
           position: 1,
           velocity: 0
@@ -257,21 +626,21 @@ const j = Symbol.for("TRANSITION_STRATEGY"), D = (e) => ({
         to: 0,
         direction: "forward"
       };
-    const { from: s = 1, to: i = 0 } = o;
+    const { from: r = 1, to: o = 0 } = i;
     return {
-      config: o,
+      config: i,
       state: {
-        position: s,
+        position: r,
         velocity: 0
       },
-      from: s,
-      to: i,
+      from: r,
+      to: o,
       direction: "forward"
     };
   }
-}), z = () => ({
-  runIn: async (e) => {
-    const t = await e.in;
+}), H = () => ({
+  runIn: async (n) => {
+    const t = await n.in;
     if (!t)
       return {
         state: {
@@ -282,20 +651,31 @@ const j = Symbol.for("TRANSITION_STRATEGY"), D = (e) => ({
         to: 1,
         direction: "forward"
       };
-    const { from: n = 0, to: o = 1 } = t;
+    if ("springs" in t)
+      return {
+        config: t,
+        state: {
+          position: 0,
+          velocity: 0
+        },
+        from: 0,
+        to: 1,
+        direction: "forward"
+      };
+    const { from: e = 0, to: i = 1 } = t;
     return {
       config: t,
       state: {
-        position: n,
+        position: e,
         velocity: 0
       },
-      from: n,
-      to: o,
+      from: e,
+      to: i,
       direction: "forward"
     };
   },
-  runOut: async (e) => {
-    const t = await e.out;
+  runOut: async (n) => {
+    const t = await n.out;
     if (!t)
       return {
         state: {
@@ -306,309 +686,384 @@ const j = Symbol.for("TRANSITION_STRATEGY"), D = (e) => ({
         to: 0,
         direction: "forward"
       };
-    const { from: n = 1, to: o = 0 } = t;
+    if ("springs" in t)
+      return {
+        config: t,
+        state: {
+          position: 1,
+          velocity: 0
+        },
+        from: 1,
+        to: 0,
+        direction: "forward"
+      };
+    const { from: e = 1, to: i = 0 } = t;
     return {
       config: t,
       state: {
-        position: n,
+        position: e,
         velocity: 0
       },
-      from: n,
-      to: o,
+      from: e,
+      to: i,
       direction: "forward"
     };
   }
 });
-function N(e, t) {
-  var l;
-  let n = null, o = null, s = null, i = null;
-  const u = {
+function W(n, t) {
+  var u;
+  let e = null, i = null, r = null, o = null;
+  const s = {
     get currentAnimation() {
-      return n;
+      return e;
     }
-  }, d = ((l = t == null ? void 0 : t.strategy) == null ? void 0 : l.call(t, u)) || D(u), a = async (r) => {
-    var p, h;
-    o && (o.remove(), o = null);
-    const f = e(), g = {
-      in: f.in && Promise.resolve(f.in(r)),
-      out: f.out && Promise.resolve(f.out(r))
-    }, c = await d.runIn(g);
-    if (!c.config)
+  }, m = ((u = t == null ? void 0 : t.strategy) == null ? void 0 : u.call(t, s)) || N(s), l = async (a) => {
+    var v, A, C;
+    i && (i.remove(), i = null);
+    const p = n(), c = p.in && await p.in(a), S = !(t != null && t.strategy) && p.out ? await p.out(a) : void 0;
+    if (!c)
       return;
-    (h = (p = c.config).prepare) == null || h.call(p, r), c.config.wait && await c.config.wait();
-    const S = A.fromState(c.state, {
-      from: c.from,
-      to: c.to,
-      spring: c.config.spring,
-      onStart: c.config.onStart,
-      onUpdate: c.config.tick,
+    if (R(c)) {
+      const y = {
+        in: Promise.resolve(c),
+        out: S && Promise.resolve(S)
+      };
+      if (!(await m.runIn(y)).config) {
+        e && (e.direction = "in");
+        return;
+      }
+      (v = c.prepare) == null || v.call(c, a), c.wait && await c.wait();
+      const E = new j({
+        ...c,
+        onEnd: () => {
+          var T;
+          e = null, (T = c.onEnd) == null || T.call(c);
+        }
+      });
+      e = {
+        controller: E,
+        direction: "in"
+      }, E.forward();
+      return;
+    }
+    const w = {
+      in: Promise.resolve(c),
+      out: S && Promise.resolve(S)
+    }, f = await m.runIn(w);
+    if (!f.config)
+      return;
+    if ("springs" in f.config) {
+      console.error("Unexpected MultiSpringConfig in single-spring path");
+      return;
+    }
+    (C = (A = f.config).prepare) == null || C.call(A, a), f.config.wait && await f.config.wait();
+    const g = O.fromState(f.state, {
+      from: f.from,
+      to: f.to,
+      spring: f.config.spring,
+      onStart: f.config.onStart,
+      onUpdate: f.config.tick,
       onComplete: () => {
-        var y, w;
-        n = null, (w = (y = c.config) == null ? void 0 : y.onEnd) == null || w.call(y);
+        var y, b;
+        e = null, (b = (y = f.config) == null ? void 0 : y.onEnd) == null || b.call(y);
       }
     });
-    n = { animator: S, direction: "in" }, c.direction === "forward" ? S.forward() : S.backward();
-  }, m = async (r) => {
-    var h, y;
-    o = r;
-    const f = e(), g = {
-      in: f.in && Promise.resolve(f.in(r)),
-      out: f.out && Promise.resolve(f.out(r))
-    }, c = await d.runOut(g);
-    if (!c.config)
+    e = { controller: g, direction: "in" }, f.direction === "forward" ? g.forward() : g.backward();
+  }, h = async (a) => {
+    var v, A, C;
+    i = a;
+    const p = n(), c = p.out && await p.out(a);
+    if (!c)
       return;
-    (y = (h = c.config).prepare) == null || y.call(h, r), p(), c.config.wait && await c.config.wait();
-    const S = A.fromState(c.state, {
-      from: c.from,
-      to: c.to,
-      spring: c.config.spring,
-      onStart: c.config.onStart,
-      onUpdate: c.config.tick,
+    if (R(c)) {
+      const y = {
+        in: void 0,
+        // Don't fetch IN config for exit transitions
+        out: Promise.resolve(c)
+      };
+      if (!(await m.runOut(y)).config) {
+        e && (e.direction = "out"), i && (i.remove(), i = null);
+        return;
+      }
+      (v = c.prepare) == null || v.call(c, a), g(), c.wait && await c.wait();
+      const E = new j({
+        ...c,
+        onEnd: () => {
+          var T, x;
+          (T = c.onEnd) == null || T.call(c), i && (i.remove(), i = null), e = null, (x = t == null ? void 0 : t.onCleanupEnd) == null || x.call(t);
+        }
+      });
+      e = {
+        controller: E,
+        direction: "out"
+      }, E.forward();
+      return;
+    }
+    const S = {
+      in: void 0,
+      // Don't fetch IN config for exit transitions
+      out: Promise.resolve(c)
+    }, w = await m.runOut(S);
+    if (!w.config)
+      return;
+    if ("springs" in w.config) {
+      console.error("Unexpected MultiSpringConfig in single-spring path");
+      return;
+    }
+    (C = (A = w.config).prepare) == null || C.call(A, a), g(), w.config.wait && await w.config.wait();
+    const f = O.fromState(w.state, {
+      from: w.from,
+      to: w.to,
+      spring: w.config.spring,
+      onStart: w.config.onStart,
+      onUpdate: w.config.tick,
       onComplete: () => {
-        var w, b, C;
-        (b = (w = c.config) == null ? void 0 : w.onEnd) == null || b.call(w), o && (o.remove(), o = null), n = null, (C = t == null ? void 0 : t.onCleanupEnd) == null || C.call(t);
+        var y, b, E;
+        (b = (y = w.config) == null ? void 0 : y.onEnd) == null || b.call(y), i && (i.remove(), i = null), e = null, (E = t == null ? void 0 : t.onCleanupEnd) == null || E.call(t);
       }
     });
-    n = { animator: S, direction: "out" }, c.direction === "forward" ? S.forward() : S.backward();
-    function p() {
-      !s || !o || (i && s.contains(i) ? s.insertBefore(o, i) : s.appendChild(o));
+    e = { controller: f, direction: "out" }, w.direction === "forward" ? f.forward() : f.backward();
+    function g() {
+      !r || !i || (o && r.contains(o) ? r.insertBefore(i, o) : r.appendChild(i));
     }
   };
-  return (r) => {
-    if (r)
-      return s = r.parentElement, i = r.nextElementSibling, a(r), () => {
-        const f = r.cloneNode(!0);
-        m(f);
+  return (a) => {
+    if (a)
+      return r = a.parentElement, o = a.nextElementSibling, l(a), () => {
+        const p = a.cloneNode(!0);
+        h(p);
       };
   };
 }
-const L = 3, $ = (e) => {
-  if (!e) return null;
-  const t = e.split(`
-`).map((n) => n.trim());
-  for (let n = L; n < Math.min(t.length, 6); n++) {
-    const o = t[n], s = o == null ? void 0 : o.match(/\(?([^):]+):(\d+):(\d+)\)?$/);
-    if (!s)
+const B = 3, K = (n) => {
+  if (!n) return null;
+  const t = n.split(`
+`).map((e) => e.trim());
+  for (let e = B; e < Math.min(t.length, 6); e++) {
+    const i = t[e], r = i == null ? void 0 : i.match(/\(?([^):]+):(\d+):(\d+)\)?$/);
+    if (!r)
       continue;
-    const i = s[1] ?? "", u = s[2] ?? "0", d = s[3] ?? "0";
-    return { file: i.split(/[\\/]/).pop() || i, line: u, column: d };
+    const o = r[1] ?? "", s = r[2] ?? "0", m = r[3] ?? "0";
+    return { file: o.split(/[\\/]/).pop() || o, line: s, column: m };
   }
   return null;
-}, V = /* @__PURE__ */ new Map(), T = /* @__PURE__ */ new Map();
-function k(e, t, n) {
-  V.set(e, t);
-  let o = T.get(e);
-  return o || (o = N(
+}, V = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map();
+function q(n, t, e) {
+  V.set(n, t);
+  let i = M.get(n);
+  return i || (i = W(
     () => {
-      const s = V.get(e);
-      return s || (console.warn(`Transition "${String(e)}" not found`), {});
+      const r = V.get(n);
+      return r || (console.warn(`Transition "${String(n)}" not found`), {});
     },
     {
-      strategy: n,
-      onCleanupEnd: () => M(e)
+      strategy: e,
+      onCleanupEnd: () => D(n)
     }
-  ), T.set(e, o), o);
+  ), M.set(n, i), i);
 }
-function M(e) {
-  V.delete(e), T.delete(e);
+function D(n) {
+  V.delete(n), M.delete(n);
 }
-function F() {
-  const e = $(new Error().stack);
-  return e ? `auto_${e.file}_${e.line}_${e.column}` : Symbol(`ssgoi_auto_${Date.now()}`);
+function Y() {
+  const n = K(new Error().stack);
+  return n ? `auto_${n.file}_${n.line}_${n.column}` : Symbol(`ssgoi_auto_${Date.now()}`);
 }
-const O = globalThis.FinalizationRegistry, R = O ? new O((e) => {
+const U = globalThis.FinalizationRegistry, z = U ? new U((n) => {
   try {
-    M(e);
+    D(n);
   } catch {
   }
 }) : void 0;
-function J(e) {
-  const t = e.key ?? F();
-  if (e.ref && R)
+function nt(n) {
+  const t = n.key ?? Y();
+  if (n.ref && z)
     try {
-      R.register(e.ref, t);
+      z.register(n.ref, t);
     } catch {
     }
-  return k(
+  return q(
     t,
     {
-      in: e.in,
-      out: e.out
+      in: n.in,
+      out: n.out
     },
-    e[j]
+    n[L]
   );
 }
-const K = (e) => {
-  let t = e.parentElement;
+const X = (n) => {
+  let t = n.parentElement;
   for (; t && t !== document.body; ) {
-    const n = window.getComputedStyle(t), o = n.overflow + n.overflowY + n.overflowX;
-    if (o.includes("auto") || o.includes("scroll") || t.scrollHeight > t.clientHeight || t.scrollWidth > t.clientWidth)
+    const e = window.getComputedStyle(t), i = e.overflow + e.overflowY + e.overflowX;
+    if (i.includes("auto") || i.includes("scroll") || t.scrollHeight > t.clientHeight || t.scrollWidth > t.clientWidth)
       return t;
     t = t.parentElement;
   }
   return document.documentElement;
-}, W = (e) => {
-  let t = e.parentElement;
+}, G = (n) => {
+  let t = n.parentElement;
   for (; t && t !== document.body; ) {
-    const n = window.getComputedStyle(t).position;
-    if (n === "relative" || n === "absolute" || n === "fixed" || n === "sticky")
+    const e = window.getComputedStyle(t).position;
+    if (e === "relative" || e === "absolute" || e === "fixed" || e === "sticky")
       return t;
     t = t.parentElement;
   }
   return document.body;
 };
-function X(e) {
-  const t = e.filter((n) => n.symmetric).map((n) => ({
-    from: n.to,
-    to: n.from,
-    transition: n.transition
+function J(n) {
+  const t = n.filter((e) => e.symmetric).map((e) => ({
+    from: e.to,
+    to: e.from,
+    transition: e.transition
   }));
-  return [...e, ...t];
+  return [...n, ...t];
 }
-function Y(e) {
-  let t = !1, n = !1;
-  const o = (a) => {
-    if (!e) return;
-    const m = a.touches[0];
-    m && (n = m.clientX < 50);
-  }, s = () => {
-    e && (n && (t = !0, setTimeout(() => {
+function Q(n) {
+  let t = !1, e = !1;
+  const i = (l) => {
+    if (!n) return;
+    const h = l.touches[0];
+    h && (e = h.clientX < 50);
+  }, r = () => {
+    n && (e && (t = !0, setTimeout(() => {
       t = !1;
-    }, 500)), n = !1);
+    }, 500)), e = !1);
   };
   return {
     initialize: () => {
-      typeof window > "u" || e && (window.addEventListener("touchstart", o, { passive: !0 }), window.addEventListener("touchend", s, { passive: !0 }));
+      typeof window > "u" || n && (window.addEventListener("touchstart", i, { passive: !0 }), window.addEventListener("touchend", r, { passive: !0 }));
     },
     cleanup: () => {
-      typeof window > "u" || (window.removeEventListener("touchstart", o), window.removeEventListener("touchend", s));
+      typeof window > "u" || (window.removeEventListener("touchstart", i), window.removeEventListener("touchend", r));
     },
     isSwipePending: () => t
   };
 }
-function G() {
-  let e = null, t = null;
-  const n = /* @__PURE__ */ new Map();
-  let o = null;
-  const s = () => {
-    e && o && n.set(o, {
-      x: e.scrollLeft,
-      y: e.scrollTop
+function Z() {
+  let n = null, t = null;
+  const e = /* @__PURE__ */ new Map();
+  let i = null;
+  const r = () => {
+    n && i && e.set(i, {
+      x: n.scrollLeft,
+      y: n.scrollTop
     });
   };
   return {
-    initializeContext: (l, r) => {
-      t = l, e || (e = K(l), (e === document.documentElement ? window : e).addEventListener("scroll", s, {
+    initializeContext: (u, a) => {
+      t = u, n || (n = X(u), (n === document.documentElement ? window : n).addEventListener("scroll", r, {
         passive: !0
-      })), o = r;
+      })), i = a;
     },
-    calculateScrollOffset: (l, r) => {
-      const f = l && n.has(l) ? n.get(l) : { x: 0, y: 0 }, g = r && n.has(r) ? n.get(r) : { x: 0, y: 0 };
+    calculateScrollOffset: (u, a) => {
+      const p = u && e.has(u) ? e.get(u) : { x: 0, y: 0 }, c = a && e.has(a) ? e.get(a) : { x: 0, y: 0 };
       return {
-        x: -g.x + f.x,
-        y: -g.y + f.y
+        x: -c.x + p.x,
+        y: -c.y + p.y
       };
     },
-    getScrollContainer: () => e,
-    getPositionedParentElement: () => t ? W(t) : document.body,
-    getScrollPosition: (l) => l && n.has(l) ? n.get(l) : { x: 0, y: 0 }
+    getScrollContainer: () => n,
+    getPositionedParentElement: () => t ? G(t) : document.body,
+    getScrollPosition: (u) => u && e.has(u) ? e.get(u) : { x: 0, y: 0 }
   };
 }
-function Q(e) {
+function ot(n) {
   const {
     transitions: t = [],
-    defaultTransition: n,
-    middleware: o = (p, h) => ({ from: p, to: h }),
+    defaultTransition: e,
+    middleware: i = (f, g) => ({ from: f, to: g }),
     // Identity function as default
-    skipOnIosSwipe: s = !0
+    skipOnIosSwipe: r = !1
     // Default to true - skip animations on iOS swipe
-  } = e;
-  let i = null;
-  const u = X(t), {
-    initializeContext: d,
-    calculateScrollOffset: a,
-    getScrollContainer: m,
-    getPositionedParentElement: l,
-    getScrollPosition: r
-  } = G(), f = Y(s);
-  f.initialize();
-  function g() {
-    if (i != null && i.from && (i != null && i.to)) {
-      const { from: p, to: h } = o(
-        i.from,
-        i.to
-      ), w = H(
-        p,
-        h,
-        u
-      ) || n, b = a(
-        i.from,
-        i.to
-      ), C = {
-        scrollOffset: b,
-        scroll: r(i.from),
+  } = n;
+  let o = null;
+  const s = J(t), {
+    initializeContext: m,
+    calculateScrollOffset: l,
+    getScrollContainer: h,
+    getPositionedParentElement: u,
+    getScrollPosition: a
+  } = Z(), p = Q(r);
+  p.initialize();
+  function c() {
+    if (o != null && o.from && (o != null && o.to)) {
+      const { from: f, to: g } = i(
+        o.from,
+        o.to
+      ), A = tt(
+        f,
+        g,
+        s
+      ) || e, C = l(
+        o.from,
+        o.to
+      ), y = {
+        scrollOffset: C,
+        scroll: a(o.from),
         get scrollingElement() {
-          return m() || document.documentElement;
+          return h() || document.documentElement;
         },
         get positionedParent() {
-          return l();
+          return u();
         }
-      }, U = {
-        scrollOffset: b,
+      }, b = {
+        scrollOffset: C,
         get scroll() {
-          return i ? r(i.to) : { x: 0, y: 0 };
+          return o ? a(o.to) : { x: 0, y: 0 };
         },
         get scrollingElement() {
-          return m() || document.documentElement;
+          return h() || document.documentElement;
         },
         get positionedParent() {
-          return l();
+          return u();
         }
       };
-      w && (w.out && i.outResolve && i.outResolve(
-        (P) => w.out(P, C)
-      ), w.in && i.inResolve && i.inResolve(
-        (P) => w.in(P, U)
-      )), i = null;
+      A && (A.out && o.outResolve && o.outResolve(
+        (E) => A.out(E, y)
+      ), A.in && o.inResolve && o.inResolve(
+        (E) => A.in(E, b)
+      )), o = null;
     }
   }
-  const c = async (p, h) => f.isSwipePending() ? () => ({}) : h === "in" && (!i || !i.from) ? () => ({}) : (i || (i = {}), h === "out" ? (i.from = p, new Promise((y) => {
-    i.outResolve = y, g();
-  })) : (i.to = p, new Promise((y) => {
-    i.inResolve = y, g();
+  const S = async (f, g) => p.isSwipePending() ? () => ({}) : g === "in" && (!o || !o.from) ? () => ({}) : (o || (o = {}), g === "out" ? (o.from = f, new Promise((v) => {
+    o.outResolve = v, c();
+  })) : (o.to = f, new Promise((v) => {
+    o.inResolve = v, c();
   })));
-  return (p) => ({
-    key: p,
-    in: async (h) => (d(h, p), (await c(p, "in"))(h)),
-    out: async (h) => (await c(p, "out"))(h),
+  return (f) => ({
+    key: f,
+    in: async (g) => (m(g, f), (await S(f, "in"))(g)),
+    out: async (g) => (await S(f, "out"))(g),
     // Add page transition strategy for page-level transitions
-    [j]: z
+    [L]: H
   });
 }
-function H(e, t, n) {
-  for (const o of n)
-    if (E(e, o.from) && E(t, o.to))
-      return o.transition;
-  for (const o of n)
-    if ((o.from === "*" || E(e, o.from)) && (o.to === "*" || E(t, o.to)))
-      return o.transition;
+function tt(n, t, e) {
+  for (const i of e)
+    if (P(n, i.from) && P(t, i.to))
+      return i.transition;
+  for (const i of e)
+    if ((i.from === "*" || P(n, i.from)) && (i.to === "*" || P(t, i.to)))
+      return i.transition;
   return null;
 }
-function E(e, t) {
+function P(n, t) {
   if (t === "*")
     return !0;
   if (t.endsWith("/*")) {
-    const n = t.slice(0, -2);
-    return e === n || e.startsWith(n + "/");
+    const e = t.slice(0, -2);
+    return n === e || n.startsWith(e + "/");
   }
-  return e === t;
+  return n === t;
 }
 export {
-  j as TRANSITION_STRATEGY,
-  D as createDefaultStrategy,
-  z as createPageTransitionStrategy,
-  Q as createSggoiTransitionContext,
-  F as generateAutoKey,
-  nt as jaeminInternal,
-  J as transition
+  L as TRANSITION_STRATEGY,
+  N as createDefaultStrategy,
+  H as createPageTransitionStrategy,
+  ot as createSggoiTransitionContext,
+  Y as generateAutoKey,
+  R as isMultiSpring,
+  at as isSingleSpring,
+  lt as jaeminInternal,
+  nt as transition
 };