@rankingcoach/vanguard 1.10.0 → 1.12.0

package/dist/index-react-spring_core.modern.js

@@ -1,12 +1,12 @@
-import { is as o, useIsomorphicLayoutEffect as ue, useOnce as Xe, each as I, toArray as M, useForceUpdate as Ze, usePrev as we, createInterpolator as It, isEqual as K, getFluidValue as z, Globals as H, frameLoop as Oe, FluidValue as wt, deprecateInterpolate as At, callFluidObservers as ye, hasFluidValue as W, addFluidObserver as ve, removeFluidObserver as et, eachProp as se, flush as _e, deprecateDirectCall as Ct, flushCalls as ce, isAnimatedString as tt, getFluidObservers as Qe, easings as Rt, noop as Ne, createStringInterpolator as xt } from "./index-react-spring_shared.modern.js";
+import { useIsomorphicLayoutEffect as ue, useOnce as Xe, each as S, is as o, useForceUpdate as Ze, usePrev as we, toArray as j, createInterpolator as It, isEqual as K, getFluidValue as Q, Globals as W, frameLoop as Oe, hasFluidValue as Y, addFluidObserver as ye, removeFluidObserver as et, deprecateDirectCall as wt, eachProp as se, flush as pe, FluidValue as At, deprecateInterpolate as Rt, callFluidObservers as _e, flushCalls as ce, isAnimatedString as tt, getFluidObservers as Ne, easings as Ct, noop as Qe, createStringInterpolator as Tt } from "./index-react-spring_shared.modern.js";
 import * as fe from "react";
-import { useMemo as le, useRef as te, useContext as it } from "react";
-import { getAnimatedType as Ae, setAnimated as st, getAnimated as $, getPayload as qe, AnimatedValue as Tt, AnimatedString as ze } from "./index-react-spring_animated.modern.js";
-import { raf as U } from "./index-react-spring_rafz.modern.js";
-function E(e, ...t) {
+import { useMemo as le, useRef as Z, useContext as it } from "react";
+import { getAnimatedType as Ae, setAnimated as st, getAnimated as $, getPayload as je, AnimatedValue as xt, AnimatedString as ze } from "./index-react-spring_animated.modern.js";
+import { raf as N } from "./index-react-spring_rafz.modern.js";
+function O(e, ...t) {
   return o.fun(e) ? e(...t) : e;
 }
-var he = (e, t) => e === !0 || !!(t && e && (o.fun(e) ? e(t) : M(e).includes(t))), nt = (e, t) => o.obj(e) ? t && e[t] : e, at = (e, t) => e.default === !0 ? e[t] : e.default ? e.default[t] : void 0, Vt = (e) => e, Pe = (e, t = Vt) => {
+var he = (e, t) => e === !0 || !!(t && e && (o.fun(e) ? e(t) : j(e).includes(t))), nt = (e, t) => o.obj(e) ? t && e[t] : e, at = (e, t) => e.default === !0 ? e[t] : e.default ? e.default[t] : void 0, Vt = (e) => e, ve = (e, t = Vt) => {
   let i = Ft;
   e.default && e.default !== !0 && (e = e.default, i = Object.keys(e));
   const s = {};
@@ -23,7 +23,7 @@ var he = (e, t) => e === !0 || !!(t && e && (o.fun(e) ? e(t) : M(e).includes(t))
   "onPause",
   "onResume",
   "onRest"
-], Et = {
+], Mt = {
   config: 1,
   from: 1,
   to: 1,
@@ -59,16 +59,16 @@ var he = (e, t) => e === !0 || !!(t && e && (o.fun(e) ? e(t) : M(e).includes(t))
   callId: 1,
   parentId: 1
 };
-function Mt(e) {
+function Et(e) {
   const t = {};
   let i = 0;
   if (se(e, (s, n) => {
-    Et[n] || (t[n] = s, i++);
+    Mt[n] || (t[n] = s, i++);
   }), i)
     return t;
 }
-function je(e) {
-  const t = Mt(e);
+function qe(e) {
+  const t = Et(e);
   if (t) {
     const i = { to: t };
     return se(e, (s, n) => n in t || (i[n] = s)), i;
@@ -76,7 +76,7 @@ function je(e) {
   return { ...e };
 }
 function de(e) {
-  return e = z(e), o.arr(e) ? e.map(de) : tt(e) ? H.createStringInterpolator({
+  return e = Q(e), o.arr(e) ? e.map(de) : tt(e) ? W.createStringInterpolator({
     range: [0, 1],
     output: [e, e]
   })(1) : e;
@@ -85,10 +85,10 @@ function ot(e) {
   for (const t in e) return !0;
   return !1;
 }
-function Ce(e) {
+function Re(e) {
   return o.fun(e) || o.arr(e) && o.obj(e[0]);
 }
-function Re(e, t) {
+function Ce(e, t) {
   var i;
   (i = e.ref) == null || i.delete(e), t == null || t.delete(e);
 }
@@ -99,26 +99,26 @@ function rt(e, t) {
 var Ot = {
   default: { tension: 170, friction: 26 },
   wobbly: { tension: 180, friction: 12 }
-}, xe = {
+}, Te = {
   ...Ot.default,
   mass: 1,
   damping: 1,
-  easing: Rt.linear,
+  easing: Ct.linear,
   clamp: !1
-}, qt = class {
+}, jt = class {
   constructor() {
-    this.velocity = 0, Object.assign(this, xe);
+    this.velocity = 0, Object.assign(this, Te);
   }
 };
-function jt(e, t, i) {
-  i && (i = { ...i }, Be(i, t), t = { ...i, ...t }), Be(e, t), Object.assign(e, t);
-  for (const u in xe)
-    e[u] == null && (e[u] = xe[u]);
+function qt(e, t, i) {
+  i && (i = { ...i }, Le(i, t), t = { ...i, ...t }), Le(e, t), Object.assign(e, t);
+  for (const c in Te)
+    e[c] == null && (e[c] = Te[c]);
   let { frequency: s, damping: n } = e;
   const { mass: a } = e;
   return o.und(s) || (s < 0.01 && (s = 0.01), n < 0 && (n = 0), e.tension = Math.pow(2 * Math.PI / s, 2) * a, e.friction = 4 * Math.PI * n * a / s), e;
 }
-function Be(e, t) {
+function Le(e, t) {
   if (!o.und(t.decay))
     e.duration = void 0;
   else {
@@ -126,38 +126,38 @@ function Be(e, t) {
     (i || !o.und(t.frequency) || !o.und(t.damping) || !o.und(t.mass)) && (e.duration = void 0, e.decay = void 0), i && (e.frequency = void 0);
   }
 }
-var Le = [], kt = class {
+var Be = [], Ut = class {
   constructor() {
-    this.changed = !1, this.values = Le, this.toValues = null, this.fromValues = Le, this.config = new qt(), this.immediate = !1;
+    this.changed = !1, this.values = Be, this.toValues = null, this.fromValues = Be, this.config = new jt(), this.immediate = !1;
   }
 };
 function ut(e, { key: t, props: i, defaultProps: s, state: n, actions: a }) {
-  return new Promise((u, r) => {
-    let p, f, S = he(i.cancel ?? (s == null ? void 0 : s.cancel), t);
-    if (S)
+  return new Promise((c, u) => {
+    let g, f, b = he(i.cancel ?? (s == null ? void 0 : s.cancel), t);
+    if (b)
       y();
     else {
       o.und(i.pause) || (n.paused = he(i.pause, t));
-      let _ = s == null ? void 0 : s.pause;
-      _ !== !0 && (_ = n.paused || he(_, t)), p = E(i.delay || 0, t), _ ? (n.resumeQueue.add(P), a.pause()) : (a.resume(), P());
+      let d = s == null ? void 0 : s.pause;
+      d !== !0 && (d = n.paused || he(d, t)), g = O(i.delay || 0, t), d ? (n.resumeQueue.add(_), a.pause()) : (a.resume(), _());
     }
-    function l() {
-      n.resumeQueue.add(P), n.timeouts.delete(f), f.cancel(), p = f.time - U.now();
+    function h() {
+      n.resumeQueue.add(_), n.timeouts.delete(f), f.cancel(), g = f.time - N.now();
     }
-    function P() {
-      p > 0 && !H.skipAnimation ? (n.delayed = !0, f = U.setTimeout(y, p), n.pauseQueue.add(l), n.timeouts.add(f)) : y();
+    function _() {
+      g > 0 && !W.skipAnimation ? (n.delayed = !0, f = N.setTimeout(y, g), n.pauseQueue.add(h), n.timeouts.add(f)) : y();
     }
     function y() {
-      n.delayed && (n.delayed = !1), n.pauseQueue.delete(l), n.timeouts.delete(f), e <= (n.cancelId || 0) && (S = !0);
+      n.delayed && (n.delayed = !1), n.pauseQueue.delete(h), n.timeouts.delete(f), e <= (n.cancelId || 0) && (b = !0);
       try {
-        a.start({ ...i, callId: e, cancel: S }, u);
-      } catch (_) {
-        r(_);
+        a.start({ ...i, callId: e, cancel: b }, c);
+      } catch (d) {
+        u(d);
       }
     }
   });
 }
-var ke = (e, t) => t.length == 1 ? t[0] : t.some((i) => i.cancelled) ? ie(e.get()) : t.every((i) => i.noop) ? ct(e.get()) : D(
+var Ue = (e, t) => t.length == 1 ? t[0] : t.some((i) => i.cancelled) ? ie(e.get()) : t.every((i) => i.noop) ? ct(e.get()) : z(
   e.get(),
   t.every((i) => i.finished)
 ), ct = (e) => ({
@@ -165,7 +165,7 @@ var ke = (e, t) => t.length == 1 ? t[0] : t.some((i) => i.cancelled) ? ie(e.get(
   noop: !0,
   finished: !0,
   cancelled: !1
-}), D = (e, t, i = !1) => ({
+}), z = (e, t, i = !1) => ({
   value: e,
   finished: t,
   cancelled: i
@@ -175,69 +175,71 @@ var ke = (e, t) => t.length == 1 ? t[0] : t.some((i) => i.cancelled) ? ie(e.get(
   finished: !1
 });
 function ft(e, t, i, s) {
-  const { callId: n, parentId: a, onRest: u } = t, { asyncTo: r, promise: p } = i;
-  return !a && e === r && !t.reset ? p : i.promise = (async () => {
+  const { callId: n, parentId: a, onRest: c } = t, { asyncTo: u, promise: g } = i;
+  return !a && e === u && !t.reset ? g : i.promise = (async () => {
     i.asyncId = n, i.asyncTo = e;
-    const f = Pe(
+    const f = ve(
       t,
-      (m, c) => (
+      (r, l) => (
         // The `onRest` prop is only called when the `runAsync` promise is resolved.
-        c === "onRest" ? void 0 : m
+        l === "onRest" ? void 0 : r
       )
     );
-    let S, l;
-    const P = new Promise(
-      (m, c) => (S = m, l = c)
-    ), y = (m) => {
-      const c = (
+    let b, h;
+    const _ = new Promise(
+      (r, l) => (b = r, h = l)
+    ), y = (r) => {
+      const l = (
         // The `cancel` prop or `stop` method was used.
         n <= (i.cancelId || 0) && ie(s) || // The async `to` prop was replaced.
-        n !== i.asyncId && D(s, !1)
+        n !== i.asyncId && z(s, !1)
       );
-      if (c)
-        throw m.result = c, l(m), m;
-    }, _ = (m, c) => {
-      const v = new Ge(), h = new Ke();
+      if (l)
+        throw r.result = l, h(r), r;
+    };
+    let d = 0;
+    const A = 1024, I = (r, l) => {
+      const p = new Ge(), R = new Ke();
       return (async () => {
-        if (H.skipAnimation)
-          throw me(i), h.result = D(s, !1), l(h), h;
-        y(v);
-        const w = o.obj(m) ? { ...m } : { ...c, to: m };
-        w.parentId = n, se(f, (Q, R) => {
-          o.und(w[R]) && (w[R] = Q);
-        });
-        const C = await s.start(w);
-        return y(v), i.paused && await new Promise((Q) => {
-          i.resumeQueue.add(Q);
-        }), C;
+        y(p);
+        const w = o.obj(r) ? { ...r } : { ...l, to: r };
+        if (w.parentId = n, se(f, (E, T) => {
+          o.und(w[T]) && (w[T] = E);
+        }), W.skipAnimation) {
+          if (++d > A)
+            throw Pe(i), R.result = z(s, !1), h(R), R;
+          return w.immediate = !0, await s.start(w);
+        }
+        const x = await s.start(w);
+        return y(p), i.paused && await new Promise((E) => {
+          i.resumeQueue.add(E);
+        }), x;
       })();
     };
-    let d;
-    if (H.skipAnimation)
-      return me(i), D(s, !1);
+    let v;
     try {
-      let m;
-      o.arr(e) ? m = (async (c) => {
-        for (const v of c)
-          await _(v);
-      })(e) : m = Promise.resolve(e(_, s.stop.bind(s))), await Promise.all([m.then(S), P]), d = D(s.get(), !0, !1);
-    } catch (m) {
-      if (m instanceof Ge)
-        d = m.result;
-      else if (m instanceof Ke)
-        d = m.result;
+      let r;
+      o.arr(e) ? r = (async (l) => {
+        for (const p of l)
+          await I(p);
+      })(e) : r = Promise.resolve(e(I, s.stop.bind(s))), await Promise.all([r.then(b), _]), v = z(s.get(), !0, !1);
+    } catch (r) {
+      if (r instanceof Ge)
+        v = r.result;
+      else if (r instanceof Ke)
+        v = r.result;
       else
-        throw m;
+        throw r;
     } finally {
-      n == i.asyncId && (i.asyncId = a, i.asyncTo = a ? r : void 0, i.promise = a ? p : void 0);
+      n == i.asyncId && (i.asyncId = a, i.asyncTo = a ? u : void 0, i.promise = a ? g : void 0);
     }
-    return o.fun(u) && U.batchedUpdates(() => {
-      u(d, s, s.item);
-    }), d;
+    return o.fun(c) && N.batchedUpdates(() => {
+      c(v, s, s.item);
+    }), v;
   })();
 }
-function me(e, t) {
-  _e(e.timeouts, (i) => i.cancel()), e.pauseQueue.clear(), e.resumeQueue.clear(), e.asyncId = e.asyncTo = e.promise = void 0, t && (e.cancelId = t);
+function Pe(e, t) {
+  pe(e.timeouts, (i) => i.cancel()), e.pauseQueue.clear(), e.resumeQueue.clear(), e.asyncId = e.asyncTo = e.promise = void 0, t && (e.cancelId = t);
 }
 var Ge = class extends Error {
   constructor() {
@@ -249,9 +251,9 @@ var Ge = class extends Error {
   constructor() {
     super("SkipAnimationSignal");
   }
-}, Te = (e) => e instanceof De, Dt = 1, De = class extends wt {
+}, xe = (e) => e instanceof ke, kt = 1, ke = class extends At {
   constructor() {
-    super(...arguments), this.id = Dt++, this._priority = 0;
+    super(...arguments), this.id = kt++, this._priority = 0;
   }
   get priority() {
     return this._priority;
@@ -266,11 +268,11 @@ var Ge = class extends Error {
   }
   /** Create a spring that maps our value to another value */
   to(...e) {
-    return H.to(this, e);
+    return W.to(this, e);
   }
   /** @deprecated Use the `to` method instead. */
   interpolate(...e) {
-    return At(), H.to(this, e);
+    return Rt(), W.to(this, e);
   }
   toJSON() {
     return this.get();
@@ -289,7 +291,7 @@ var Ge = class extends Error {
   }
   /** Tell our children about our new value */
   _onChange(e, t = !1) {
-    ye(this, {
+    _e(this, {
       type: "change",
       parent: this,
       value: e,
@@ -298,15 +300,15 @@ var Ge = class extends Error {
   }
   /** Tell our children about our new priority */
   _onPriorityChange(e) {
-    this.idle || Oe.sort(this), ye(this, {
+    this.idle || Oe.sort(this), _e(this, {
       type: "priority",
       parent: this,
       priority: e
     });
   }
-}, Z = Symbol.for("SpringPhase"), lt = 1, Ve = 2, Fe = 4, Se = (e) => (e[Z] & lt) > 0, Y = (e) => (e[Z] & Ve) > 0, ae = (e) => (e[Z] & Fe) > 0, $e = (e, t) => t ? e[Z] |= Ve | lt : e[Z] &= ~Ve, He = (e, t) => t ? e[Z] |= Fe : e[Z] &= ~Fe, Ut = class extends De {
+}, ee = Symbol.for("SpringPhase"), lt = 1, Ve = 2, Fe = 4, Se = (e) => (e[ee] & lt) > 0, J = (e) => (e[ee] & Ve) > 0, ae = (e) => (e[ee] & Fe) > 0, $e = (e, t) => t ? e[ee] |= Ve | lt : e[ee] &= ~Ve, He = (e, t) => t ? e[ee] |= Fe : e[ee] &= ~Fe, Dt = class extends ke {
   constructor(e, t) {
-    if (super(), this.animation = new kt(), this.defaultProps = {}, this._state = {
+    if (super(), this.animation = new Ut(), this.defaultProps = {}, this._state = {
       paused: !1,
       delayed: !1,
       pauseQueue: /* @__PURE__ */ new Set(),
@@ -319,14 +321,14 @@ var Ge = class extends Error {
   }
   /** Equals true when not advancing on each frame. */
   get idle() {
-    return !(Y(this) || this._state.asyncTo) || ae(this);
+    return !(J(this) || this._state.asyncTo) || ae(this);
   }
   get goal() {
-    return z(this.animation.to);
+    return Q(this.animation.to);
   }
   get velocity() {
     const e = $(this);
-    return e instanceof Tt ? e.lastVelocity || 0 : e.getPayload().map((t) => t.lastVelocity || 0);
+    return e instanceof xt ? e.lastVelocity || 0 : e.getPayload().map((t) => t.lastVelocity || 0);
   }
   /**
    * When true, this value has been animated at least once.
@@ -339,7 +341,7 @@ var Ge = class extends Error {
    * which is either active or paused.
    */
   get isAnimating() {
-    return Y(this);
+    return J(this);
   }
   /**
    * When true, all current and future animations are paused.
@@ -359,55 +361,55 @@ var Ge = class extends Error {
     let t = !0, i = !1;
     const s = this.animation;
     let { toValues: n } = s;
-    const { config: a } = s, u = qe(s.to);
-    !u && W(s.to) && (n = M(z(s.to))), s.values.forEach((f, S) => {
+    const { config: a } = s, c = je(s.to);
+    !c && Y(s.to) && (n = j(Q(s.to))), s.values.forEach((f, b) => {
       if (f.done) return;
-      const l = (
+      const h = (
         // Animated strings always go from 0 to 1.
-        f.constructor == ze ? 1 : u ? u[S].lastPosition : n[S]
+        f.constructor == ze ? 1 : c ? c[b].lastPosition : n[b]
       );
-      let P = s.immediate, y = l;
-      if (!P) {
+      let _ = s.immediate, y = h;
+      if (!_) {
         if (y = f.lastPosition, a.tension <= 0) {
           f.done = !0;
           return;
         }
-        let _ = f.elapsedTime += e;
-        const d = s.fromValues[S], m = f.v0 != null ? f.v0 : f.v0 = o.arr(a.velocity) ? a.velocity[S] : a.velocity;
-        let c;
-        const v = a.precision || (d == l ? 5e-3 : Math.min(1, Math.abs(l - d) * 1e-3));
+        let d = f.elapsedTime += e;
+        const A = s.fromValues[b], I = f.v0 != null ? f.v0 : f.v0 = o.arr(a.velocity) ? a.velocity[b] : a.velocity;
+        let v;
+        const r = a.precision || (A == h ? 5e-3 : Math.min(1, Math.abs(h - A) * 1e-3));
         if (o.und(a.duration))
           if (a.decay) {
-            const h = a.decay === !0 ? 0.998 : a.decay, w = Math.exp(-(1 - h) * _);
-            y = d + m / (1 - h) * (1 - w), P = Math.abs(f.lastPosition - y) <= v, c = m * w;
+            const l = a.decay === !0 ? 0.998 : a.decay, p = Math.exp(-(1 - l) * d);
+            y = A + I / (1 - l) * (1 - p), _ = Math.abs(f.lastPosition - y) <= r, v = I * p;
           } else {
-            c = f.lastVelocity == null ? m : f.lastVelocity;
-            const h = a.restVelocity || v / 10, w = a.clamp ? 0 : a.bounce, C = !o.und(w), Q = d == l ? f.v0 > 0 : d < l;
-            let R, N = !1;
-            const x = 1, q = Math.ceil(e / x);
-            for (let O = 0; O < q && (R = Math.abs(c) > h, !(!R && (P = Math.abs(l - y) <= v, P))); ++O) {
-              C && (N = y == l || y > l == Q, N && (c = -c * w, y = l));
-              const B = -a.tension * 1e-6 * (y - l), L = -a.friction * 1e-3 * c, g = (B + L) / a.mass;
-              c = c + g * x, y = y + c * x;
+            v = f.lastVelocity == null ? I : f.lastVelocity;
+            const l = a.restVelocity || r / 10, p = a.clamp ? 0 : a.bounce, R = !o.und(p), w = A == h ? f.v0 > 0 : A < h;
+            let x, E = !1;
+            const T = 1, U = Math.ceil(e / T);
+            for (let q = 0; q < U && (x = Math.abs(v) > l, !(!x && (_ = Math.abs(h - y) <= r, _))); ++q) {
+              R && (E = y == h || y > h == w, E && (v = -v * p, y = h));
+              const L = -a.tension * 1e-6 * (y - h), B = -a.friction * 1e-3 * v, m = (L + B) / a.mass;
+              v = v + m * T, y = y + v * T;
             }
           }
         else {
-          let h = 1;
-          a.duration > 0 && (this._memoizedDuration !== a.duration && (this._memoizedDuration = a.duration, f.durationProgress > 0 && (f.elapsedTime = a.duration * f.durationProgress, _ = f.elapsedTime += e)), h = (a.progress || 0) + _ / this._memoizedDuration, h = h > 1 ? 1 : h < 0 ? 0 : h, f.durationProgress = h), y = d + a.easing(h) * (l - d), c = (y - f.lastPosition) / e, P = h == 1;
+          let l = 1;
+          a.duration > 0 && (this._memoizedDuration !== a.duration && (this._memoizedDuration = a.duration, f.durationProgress > 0 && (f.elapsedTime = a.duration * f.durationProgress, d = f.elapsedTime += e)), l = (a.progress || 0) + d / this._memoizedDuration, l = l > 1 ? 1 : l < 0 ? 0 : l, f.durationProgress = l), y = A + a.easing(l) * (h - A), v = (y - f.lastPosition) / e, _ = l == 1;
         }
-        f.lastVelocity = c, Number.isNaN(y) && (P = !0);
+        f.lastVelocity = v, Number.isNaN(y) && (_ = !0);
       }
-      u && !u[S].done && (P = !1), P ? f.done = !0 : t = !1, f.setValue(y, a.round) && (i = !0);
+      c && !c[b].done && (_ = !1), _ ? f.done = !0 : t = !1, f.setValue(y, a.round) && (i = !0);
     });
-    const r = $(this), p = r.getValue();
+    const u = $(this), g = u.getValue();
     if (t) {
-      const f = z(s.to);
-      (p !== f || i) && !a.decay ? (r.setValue(f), this._onChange(f)) : i && a.decay && this._onChange(p), this._stop();
-    } else i && this._onChange(p);
+      const f = Q(s.to);
+      (g !== f || i) && !a.decay ? (u.setValue(f), this._onChange(f)) : i && a.decay && this._onChange(g), this._stop();
+    } else i && this._onChange(g);
   }
   /** Set the current value, while stopping the current animation */
   set(e) {
-    return U.batchedUpdates(() => {
+    return N.batchedUpdates(() => {
       this._stop(), this._focus(e), this._set(e);
     }), this;
   }
@@ -424,9 +426,9 @@ var Ge = class extends Error {
   }
   /** Skip to the end of the current animation. */
   finish() {
-    if (Y(this)) {
+    if (J(this)) {
       const { to: e, config: t } = this.animation;
-      U.batchedUpdates(() => {
+      N.batchedUpdates(() => {
         this._onStart(), t.decay || this._set(e, !1), this._stop();
       });
     }
@@ -440,7 +442,7 @@ var Ge = class extends Error {
     let i;
     return o.und(e) ? (i = this.queue || [], this.queue = []) : i = [o.obj(e) ? e : { ...t, to: e }], Promise.all(
       i.map((s) => this._update(s))
-    ).then((s) => ke(this, s));
+    ).then((s) => Ue(this, s));
   }
   /**
    * Stop the current animation, and cancel any delayed updates.
@@ -449,7 +451,7 @@ var Ge = class extends Error {
    */
   stop(e) {
     const { to: t } = this.animation;
-    return this._focus(this.get()), me(this._state, e && this._lastCallId), U.batchedUpdates(() => this._stop(t, e)), this;
+    return o.und(t) || this._focus(this.get()), Pe(this._state, e && this._lastCallId), N.batchedUpdates(() => this._stop(t, e)), this;
   }
   /** Restart the animation. */
   reset() {
@@ -468,18 +470,18 @@ var Ge = class extends Error {
   _prepareNode(e) {
     const t = this.key || "";
     let { to: i, from: s } = e;
-    i = o.obj(i) ? i[t] : i, (i == null || Ce(i)) && (i = void 0), s = o.obj(s) ? s[t] : s, s == null && (s = void 0);
+    i = o.obj(i) ? i[t] : i, (i == null || Re(i)) && (i = void 0), s = o.obj(s) ? s[t] : s, s == null && (s = void 0);
     const n = { to: i, from: s };
-    return Se(this) || (e.reverse && ([i, s] = [s, i]), s = z(s), o.und(s) ? $(this) || this._set(i) : this._set(s)), n;
+    return Se(this) || (e.reverse && ([i, s] = [s, i]), s = Q(s), o.und(s) ? $(this) || this._set(i) : this._set(s)), n;
   }
   /** Every update is processed by this method before merging. */
   _update({ ...e }, t) {
     const { key: i, defaultProps: s } = this;
     e.default && Object.assign(
       s,
-      Pe(
+      ve(
         e,
-        (u, r) => /^on/.test(r) ? nt(u, i) : u
+        (c, u) => /^on/.test(u) ? nt(c, i) : c
       )
     ), Ye(this, e, "onProps"), re(this, "onProps", e, this);
     const n = this._prepareNode(e);
@@ -498,27 +500,27 @@ var Ge = class extends Error {
           ae(this) || (He(this, !0), ce(a.pauseQueue), re(
             this,
             "onPause",
-            D(this, oe(this, this.animation.to)),
+            z(this, oe(this, this.animation.to)),
             this
           ));
         },
         resume: () => {
-          ae(this) && (He(this, !1), Y(this) && this._resume(), ce(a.resumeQueue), re(
+          ae(this) && (He(this, !1), J(this) && this._resume(), ce(a.resumeQueue), re(
             this,
             "onResume",
-            D(this, oe(this, this.animation.to)),
+            z(this, oe(this, this.animation.to)),
             this
           ));
         },
         start: this._merge.bind(this, n)
       }
-    }).then((u) => {
-      if (e.loop && u.finished && !(t && u.noop)) {
-        const r = ht(e);
-        if (r)
-          return this._update(r, !0);
+    }).then((c) => {
+      if (e.loop && c.finished && !(t && c.noop)) {
+        const u = ht(e);
+        if (u)
+          return this._update(u, !0);
       }
-      return u;
+      return c;
     });
   }
   /** Merge props into the current animation */
@@ -531,81 +533,81 @@ var Ge = class extends Error {
         this._lastToId = t.callId;
       else
         return i(ie(this));
-    const { key: a, defaultProps: u, animation: r } = this, { to: p, from: f } = r;
-    let { to: S = p, from: l = f } = e;
-    n && !s && (!t.default || o.und(S)) && (S = l), t.reverse && ([S, l] = [l, S]);
-    const P = !K(l, f);
-    P && (r.from = l), l = z(l);
-    const y = !K(S, p);
-    y && this._focus(S);
-    const _ = Ce(t.to), { config: d } = r, { decay: m, velocity: c } = d;
-    (s || n) && (d.velocity = 0), t.config && !_ && jt(
-      d,
-      E(t.config, a),
+    const { key: a, defaultProps: c, animation: u } = this, { to: g, from: f } = u;
+    let { to: b = g, from: h = f } = e;
+    n && !s && (!t.default || o.und(b)) && (b = h), t.reverse && ([b, h] = [h, b]);
+    const _ = !K(h, f);
+    _ && (u.from = h), h = Q(h);
+    const y = !K(b, g);
+    y && this._focus(b);
+    const d = Re(t.to), { config: A } = u, { decay: I, velocity: v } = A;
+    (s || n) && (A.velocity = 0), t.config && !d && qt(
+      A,
+      O(t.config, a),
       // Avoid calling the same "config" prop twice.
-      t.config !== u.config ? E(u.config, a) : void 0
+      t.config !== c.config ? O(c.config, a) : void 0
     );
-    let v = $(this);
-    if (!v || o.und(S))
-      return i(D(this, !0));
-    const h = (
+    let r = $(this);
+    if (!r || o.und(b))
+      return i(z(this, !0));
+    const l = (
       // When `reset` is undefined, the `from` prop implies `reset: true`,
       // except for declarative updates. When `reset` is defined, there
       // must exist a value to animate from.
-      o.und(t.reset) ? n && !t.default : !o.und(l) && he(t.reset, a)
-    ), w = h ? l : this.get(), C = de(S), Q = o.num(C) || o.arr(C) || tt(C), R = !_ && (!Q || he(u.immediate || t.immediate, a));
+      o.und(t.reset) ? n && !t.default : !o.und(h) && he(t.reset, a)
+    ), p = l ? h : this.get(), R = de(b), w = o.num(R) || o.arr(R) || tt(R), x = !d && (!w || he(c.immediate || t.immediate, a));
     if (y) {
-      const O = Ae(S);
-      if (O !== v.constructor)
-        if (R)
-          v = this._set(C);
+      const q = Ae(b);
+      if (q !== r.constructor)
+        if (x)
+          r = this._set(R);
         else
           throw Error(
-            `Cannot animate between ${v.constructor.name} and ${O.name}, as the "to" prop suggests`
+            `Cannot animate between ${r.constructor.name} and ${q.name}, as the "to" prop suggests`
           );
     }
-    const N = v.constructor;
-    let x = W(S), q = !1;
-    if (!x) {
-      const O = h || !Se(this) && P;
-      (y || O) && (q = K(de(w), C), x = !q), (!K(r.immediate, R) && !R || !K(d.decay, m) || !K(d.velocity, c)) && (x = !0);
+    const E = r.constructor;
+    let T = Y(b), U = !1;
+    if (!T) {
+      const q = l || !Se(this) && _;
+      (y || q) && (U = K(de(p), R), T = !U), (!K(u.immediate, x) && !x || !K(A.decay, I) || !K(A.velocity, v)) && (T = !0);
     }
-    if (q && Y(this) && (r.changed && !h ? x = !0 : x || this._stop(p)), !_ && ((x || W(p)) && (r.values = v.getPayload(), r.toValues = W(S) ? null : N == ze ? [1] : M(C)), r.immediate != R && (r.immediate = R, !R && !h && this._set(p)), x)) {
-      const { onRest: O } = r;
-      I(Nt, (L) => Ye(this, t, L));
-      const B = D(this, oe(this, p));
-      ce(this._pendingCalls, B), this._pendingCalls.add(i), r.changed && U.batchedUpdates(() => {
-        var L;
-        r.changed = !h, O == null || O(B, this), h ? E(u.onRest, B) : (L = r.onStart) == null || L.call(r, B, this);
+    if (U && J(this) && (u.changed && !l ? T = !0 : T || this._stop(g)), !d && ((T || Y(g)) && (u.values = r.getPayload(), u.toValues = Y(b) ? null : E == ze ? [1] : j(R)), u.immediate != x && (u.immediate = x, !x && !l && this._set(g)), T)) {
+      const { onRest: q } = u;
+      S(Qt, (B) => Ye(this, t, B));
+      const L = z(this, oe(this, g));
+      ce(this._pendingCalls, L), this._pendingCalls.add(i), u.changed && N.batchedUpdates(() => {
+        var B;
+        u.changed = !l, q == null || q(L, this), l ? O(c.onRest, L) : (B = u.onStart) == null || B.call(u, L, this);
       });
     }
-    h && this._set(w), _ ? i(ft(t.to, t, this._state, this)) : x ? this._start() : Y(this) && !y ? this._pendingCalls.add(i) : i(ct(w));
+    l && this._set(p), d ? i(ft(t.to, t, this._state, this)) : T ? this._start() : J(this) && !y ? this._pendingCalls.add(i) : i(ct(p));
   }
   /** Update the `animation.to` value, which might be a `FluidValue` */
   _focus(e) {
     const t = this.animation;
-    e !== t.to && (Qe(this) && this._detach(), t.to = e, Qe(this) && this._attach());
+    e !== t.to && (Ne(this) && this._detach(), t.to = e, Ne(this) && this._attach());
   }
   _attach() {
     let e = 0;
     const { to: t } = this.animation;
-    W(t) && (ve(t, this), Te(t) && (e = t.priority + 1)), this.priority = e;
+    Y(t) && (ye(t, this), xe(t) && (e = t.priority + 1)), this.priority = e;
   }
   _detach() {
     const { to: e } = this.animation;
-    W(e) && et(e, this);
+    Y(e) && et(e, this);
   }
   /**
    * Update the current value from outside the frameloop,
    * and return the `Animated` node.
    */
   _set(e, t = !0) {
-    const i = z(e);
+    const i = Q(e);
     if (!o.und(i)) {
       const s = $(this);
       if (!s || !K(i, s.getValue())) {
         const n = Ae(i);
-        !s || s.constructor != n ? st(this, n.create(i)) : s.setValue(i), s && U.batchedUpdates(() => {
+        !s || s.constructor != n ? st(this, n.create(i)) : s.setValue(i), s && N.batchedUpdates(() => {
           this._onChange(i, t);
         });
       }
@@ -617,22 +619,22 @@ var Ge = class extends Error {
     e.changed || (e.changed = !0, re(
       this,
       "onStart",
-      D(this, oe(this, e.to)),
+      z(this, oe(this, e.to)),
       this
     ));
   }
   _onChange(e, t) {
-    t || (this._onStart(), E(this.animation.onChange, e, this)), E(this.defaultProps.onChange, e, this), super._onChange(e, t);
+    t || (this._onStart(), O(this.animation.onChange, e, this)), O(this.defaultProps.onChange, e, this), super._onChange(e, t);
   }
   // This method resets the animation state (even if already animating) to
   // ensure the latest from/to range is used, and it also ensures this spring
   // is added to the frameloop.
   _start() {
     const e = this.animation;
-    $(this).reset(z(e.to)), e.immediate || (e.fromValues = e.values.map((t) => t.lastPosition)), Y(this) || ($e(this, !0), ae(this) || this._resume());
+    $(this).reset(Q(e.to)), e.immediate || (e.fromValues = e.values.map((t) => t.lastPosition)), J(this) || ($e(this, !0), ae(this) || this._resume());
   }
   _resume() {
-    H.skipAnimation ? this.finish() : Oe.start(this);
+    W.skipAnimation ? this.finish() : Oe.start(this);
   }
   /**
    * Exit the frameloop and notify `onRest` listeners.
@@ -640,16 +642,16 @@ var Ge = class extends Error {
    * Always wrap `_stop` calls with `batchedUpdates`.
    */
   _stop(e, t) {
-    if (Y(this)) {
+    if (J(this)) {
       $e(this, !1);
       const i = this.animation;
-      I(i.values, (n) => {
+      S(i.values, (n) => {
         n.done = !0;
-      }), i.toValues && (i.onChange = i.onPause = i.onResume = void 0), ye(this, {
+      }), i.toValues && (i.onChange = i.onPause = i.onResume = void 0), _e(this, {
         type: "idle",
         parent: this
       });
-      const s = t ? ie(this.get()) : D(this.get(), oe(this, e ?? i.to));
+      const s = t ? ie(this.get()) : z(this.get(), oe(this, e ?? i.to));
       ce(this._pendingCalls, s), i.changed && (i.changed = !1, re(this, "onRest", s, this));
     }
   }
@@ -659,10 +661,10 @@ function oe(e, t) {
   return K(s, i);
 }
 function ht(e, t = e.loop, i = e.to) {
-  const s = E(t);
+  const s = O(t);
   if (s) {
-    const n = s !== !0 && je(s), a = (n || e).reverse, u = !n || n.reset;
-    return ge({
+    const n = s !== !0 && qe(s), a = (n || e).reverse, c = !n || n.reset;
+    return me({
       ...e,
       loop: t,
       // Avoid updating default props when looping.
@@ -672,28 +674,28 @@ function ht(e, t = e.loop, i = e.to) {
       // For the "reverse" prop to loop as expected, the "to" prop
       // must be undefined. The "reverse" prop is ignored when the
       // "to" prop is an array or function.
-      to: !a || Ce(i) ? i : void 0,
+      to: !a || Re(i) ? i : void 0,
       // Ignore the "from" prop except on reset.
-      from: u ? e.from : void 0,
-      reset: u,
+      from: c ? e.from : void 0,
+      reset: c,
       // The "loop" prop can return a "useSpring" props object to
       // override any of the original props.
       ...n
     });
   }
 }
-function ge(e) {
-  const { to: t, from: i } = e = je(e), s = /* @__PURE__ */ new Set();
+function me(e) {
+  const { to: t, from: i } = e = qe(e), s = /* @__PURE__ */ new Set();
   return o.obj(t) && Je(t, s), o.obj(i) && Je(i, s), e.keys = s.size ? Array.from(s) : null, e;
 }
-function Qt(e) {
-  const t = ge(e);
-  return o.und(t.default) && (t.default = Pe(t)), t;
+function Nt(e) {
+  const t = me(e);
+  return o.und(t.default) && (t.default = ve(t)), t;
 }
 function Je(e, t) {
   se(e, (i, s) => i != null && t.add(s));
 }
-var Nt = [
+var Qt = [
   "onStart",
   "onRest",
   "onChange",
@@ -704,12 +706,12 @@ function Ye(e, t, i) {
   e.animation[i] = t[i] !== at(t, i) ? nt(t[i], e.key) : void 0;
 }
 function re(e, t, ...i) {
-  var s, n, a, u;
-  (n = (s = e.animation)[t]) == null || n.call(s, ...i), (u = (a = e.defaultProps)[t]) == null || u.call(a, ...i);
+  var s, n, a, c;
+  (n = (s = e.animation)[t]) == null || n.call(s, ...i), (c = (a = e.defaultProps)[t]) == null || c.call(a, ...i);
 }
-var zt = ["onStart", "onChange", "onRest"], Bt = 1, dt = class {
+var zt = ["onStart", "onChange", "onRest"], Lt = 1, dt = class {
   constructor(e, t) {
-    this.id = Bt++, this.springs = {}, this.queue = [], this._lastAsyncId = 0, this._active = /* @__PURE__ */ new Set(), this._changed = /* @__PURE__ */ new Set(), this._started = !1, this._state = {
+    this.id = Lt++, this.springs = {}, this.queue = [], this._lastAsyncId = 0, this._active = /* @__PURE__ */ new Set(), this._changed = /* @__PURE__ */ new Set(), this._started = !1, this._state = {
       paused: !1,
       pauseQueue: /* @__PURE__ */ new Set(),
       resumeQueue: /* @__PURE__ */ new Set(),
@@ -747,7 +749,7 @@ var zt = ["onStart", "onChange", "onRest"], Bt = 1, dt = class {
   }
   /** Push an update onto the queue of each value. */
   update(e) {
-    return e && this.queue.push(ge(e)), this;
+    return e && this.queue.push(me(e)), this;
   }
   /**
    * Start the queued animations for every spring, and resolve the returned
@@ -758,15 +760,15 @@ var zt = ["onStart", "onChange", "onRest"], Bt = 1, dt = class {
    */
   start(e) {
     let { queue: t } = this;
-    return e ? t = M(e).map(ge) : this.queue = [], this._flush ? this._flush(this, t) : (yt(this, t), Ee(this, t));
+    return e ? t = j(e).map(me) : this.queue = [], this._flush ? this._flush(this, t) : (yt(this, t), Me(this, t));
   }
   /** @internal */
   stop(e, t) {
     if (e !== !!e && (t = e), t) {
       const i = this.springs;
-      I(M(t), (s) => i[s].stop(!!e));
+      S(j(t), (s) => i[s].stop(!!e));
     } else
-      me(this._state, this._lastAsyncId), this.each((i) => i.stop(!!e));
+      Pe(this._state, this._lastAsyncId), this.each((i) => i.stop(!!e));
     return this;
   }
   /** Freeze the active animation in time */
@@ -775,7 +777,7 @@ var zt = ["onStart", "onChange", "onRest"], Bt = 1, dt = class {
       this.start({ pause: !0 });
     else {
       const t = this.springs;
-      I(M(e), (i) => t[i].pause());
+      S(j(e), (i) => t[i].pause());
     }
     return this;
   }
@@ -785,7 +787,7 @@ var zt = ["onStart", "onChange", "onRest"], Bt = 1, dt = class {
       this.start({ pause: !1 });
     else {
       const t = this.springs;
-      I(M(e), (i) => t[i].resume());
+      S(j(e), (i) => t[i].resume());
     }
     return this;
   }
@@ -793,17 +795,29 @@ var zt = ["onStart", "onChange", "onRest"], Bt = 1, dt = class {
   each(e) {
     se(this.springs, e);
   }
+  /**
+   * Subscribe to loop iteration restarts on this controller. Returns an
+   * unsubscribe function. Listeners fire synchronously inside `flushUpdate`
+   * just before the next iteration is dispatched.
+   * @internal
+   */
+  onLoopReset(e) {
+    const t = this._onLoopReset ?? (this._onLoopReset = /* @__PURE__ */ new Set());
+    return t.add(e), () => {
+      t.delete(e);
+    };
+  }
   /** @internal Called at the end of every animation frame */
   _onFrame() {
     const { onStart: e, onChange: t, onRest: i } = this._events, s = this._active.size > 0, n = this._changed.size > 0;
-    (s && !this._started || n && !this._started) && (this._started = !0, _e(e, ([r, p]) => {
-      p.value = this.get(), r(p, this, this._item);
+    (s && !this._started || n && !this._started) && (this._started = !0, pe(e, ([u, g]) => {
+      g.value = this.get(), u(g, this, this._item);
     }));
-    const a = !s && this._started, u = n || a && i.size ? this.get() : null;
-    n && t.size && _e(t, ([r, p]) => {
-      p.value = u, r(p, this, this._item);
-    }), a && (this._started = !1, _e(i, ([r, p]) => {
-      p.value = u, r(p, this, this._item);
+    const a = !s && this._started, c = n || a && i.size ? this.get() : null;
+    n && t.size && pe(t, ([u, g]) => {
+      g.value = c, u(g, this, this._item);
+    }), a && (this._started = !1, pe(i, ([u, g]) => {
+      g.value = c, u(g, this, this._item);
     }));
   }
   /** @internal */
@@ -813,89 +827,90 @@ var zt = ["onStart", "onChange", "onRest"], Bt = 1, dt = class {
     else if (e.type == "idle")
       this._active.delete(e.parent);
     else return;
-    U.onFrame(this._onFrame);
+    N.onFrame(this._onFrame);
   }
 };
-function Ee(e, t) {
+function Me(e, t) {
   return Promise.all(t.map((i) => mt(e, i))).then(
-    (i) => ke(e, i)
+    (i) => Ue(e, i)
   );
 }
 async function mt(e, t, i) {
-  const { keys: s, to: n, from: a, loop: u, onRest: r, onResolve: p } = t, f = o.obj(t.default) && t.default;
-  u && (t.loop = !1), n === !1 && (t.to = null), a === !1 && (t.from = null);
-  const S = o.arr(n) || o.fun(n) ? n : void 0;
-  S ? (t.to = void 0, t.onRest = void 0, f && (f.onRest = void 0)) : I(zt, (d) => {
-    const m = t[d];
-    if (o.fun(m)) {
-      const c = e._events[d];
-      t[d] = ({ finished: v, cancelled: h }) => {
-        const w = c.get(m);
-        w ? (v || (w.finished = !1), h && (w.cancelled = !0)) : c.set(m, {
+  var A;
+  const { keys: s, to: n, from: a, loop: c, onRest: u, onResolve: g } = t, f = o.obj(t.default) && t.default;
+  c && (t.loop = !1), n === !1 && (t.to = null), a === !1 && (t.from = null);
+  const b = o.arr(n) || o.fun(n) ? n : void 0;
+  b ? (t.to = void 0, t.onRest = void 0, f && (f.onRest = void 0)) : S(zt, (I) => {
+    const v = t[I];
+    if (o.fun(v)) {
+      const r = e._events[I];
+      t[I] = ({ finished: l, cancelled: p }) => {
+        const R = r.get(v);
+        R ? (l || (R.finished = !1), p && (R.cancelled = !0)) : r.set(v, {
           value: null,
-          finished: v || !1,
-          cancelled: h || !1
+          finished: l || !1,
+          cancelled: p || !1
         });
-      }, f && (f[d] = t[d]);
+      }, f && (f[I] = t[I]);
     }
   });
-  const l = e._state;
-  t.pause === !l.paused ? (l.paused = t.pause, ce(t.pause ? l.pauseQueue : l.resumeQueue)) : l.paused && (t.pause = !0);
-  const P = (s || Object.keys(e.springs)).map(
-    (d) => e.springs[d].start(t)
+  const h = e._state;
+  t.pause === !h.paused ? (h.paused = t.pause, ce(t.pause ? h.pauseQueue : h.resumeQueue)) : h.paused && (t.pause = !0);
+  const _ = (s || Object.keys(e.springs)).map(
+    (I) => e.springs[I].start(t)
   ), y = t.cancel === !0 || at(t, "cancel") === !0;
-  (S || y && l.asyncId) && P.push(
+  (b || y && h.asyncId) && _.push(
     ut(++e._lastAsyncId, {
       props: t,
-      state: l,
+      state: h,
       actions: {
-        pause: Ne,
-        resume: Ne,
-        start(d, m) {
-          y ? (me(l, e._lastAsyncId), m(ie(e))) : (d.onRest = r, m(
+        pause: Qe,
+        resume: Qe,
+        start(I, v) {
+          y ? (Pe(h, e._lastAsyncId), v(ie(e))) : (I.onRest = u, v(
             ft(
-              S,
-              d,
-              l,
+              b,
+              I,
+              h,
               e
             )
           ));
         }
       }
     })
-  ), l.paused && await new Promise((d) => {
-    l.resumeQueue.add(d);
+  ), h.paused && await new Promise((I) => {
+    h.resumeQueue.add(I);
   });
-  const _ = ke(e, await Promise.all(P));
-  if (u && _.finished && !(i && _.noop)) {
-    const d = ht(t, u, n);
-    if (d)
-      return yt(e, [d]), mt(e, d, !0);
+  const d = Ue(e, await Promise.all(_));
+  if (c && d.finished && !(i && d.noop)) {
+    const I = ht(t, c, n);
+    if (I)
+      return (A = e._onLoopReset) == null || A.forEach((v) => v()), yt(e, [I]), mt(e, I, !0);
   }
-  return p && U.batchedUpdates(() => p(_, e, e.item)), _;
+  return g && N.batchedUpdates(() => g(d, e, e.item)), d;
 }
-function Me(e, t) {
+function Ee(e, t) {
   const i = { ...e.springs };
-  return t && I(M(t), (s) => {
-    o.und(s.keys) && (s = ge(s)), o.obj(s.to) || (s = { ...s, to: void 0 }), _t(i, s, (n) => pt(n));
+  return t && S(j(t), (s) => {
+    o.und(s.keys) && (s = me(s)), o.obj(s.to) || (s = { ...s, to: void 0 }), _t(i, s, (n) => pt(n));
   }), gt(e, i), i;
 }
 function gt(e, t) {
   se(t, (i, s) => {
-    e.springs[s] || (e.springs[s] = i, ve(i, e));
+    e.springs[s] || (e.springs[s] = i, ye(i, e));
   });
 }
 function pt(e, t) {
-  const i = new Ut();
-  return i.key = e, t && ve(i, t), i;
+  const i = new Dt();
+  return i.key = e, t && ye(i, t), i;
 }
 function _t(e, t, i) {
-  t.keys && I(t.keys, (s) => {
+  t.keys && S(t.keys, (s) => {
     (e[s] || (e[s] = i(s)))._prepareNode(t);
   });
 }
 function yt(e, t) {
-  I(t, (i) => {
+  S(t, (i) => {
     _t(e.springs, i, (s) => pt(s, e));
   });
 }
@@ -904,14 +919,14 @@ var vt = fe.createContext({
   immediate: !1
 }), Pt = () => {
   const e = [], t = function(s) {
-    Ct();
+    wt();
     const n = [];
-    return I(e, (a, u) => {
+    return S(e, (a, c) => {
       if (o.und(s))
         n.push(a.start());
       else {
-        const r = i(s, a, u);
-        r && n.push(a.start(r));
+        const u = i(s, a, c);
+        u && n.push(a.start(u));
       }
     }), n;
   };
@@ -921,87 +936,94 @@ var vt = fe.createContext({
     const n = e.indexOf(s);
     ~n && e.splice(n, 1);
   }, t.pause = function() {
-    return I(e, (s) => s.pause(...arguments)), this;
+    return S(e, (s) => s.pause(...arguments)), this;
   }, t.resume = function() {
-    return I(e, (s) => s.resume(...arguments)), this;
+    return S(e, (s) => s.resume(...arguments)), this;
   }, t.set = function(s) {
-    I(e, (n, a) => {
-      const u = o.fun(s) ? s(a, n) : s;
-      u && n.set(u);
+    S(e, (n, a) => {
+      const c = o.fun(s) ? s(a, n) : s;
+      c && n.set(c);
     });
   }, t.start = function(s) {
     const n = [];
-    return I(e, (a, u) => {
+    return S(e, (a, c) => {
       if (o.und(s))
         n.push(a.start());
       else {
-        const r = this._getProps(s, a, u);
-        r && n.push(a.start(r));
+        const u = this._getProps(s, a, c);
+        u && n.push(a.start(u));
       }
     }), n;
   }, t.stop = function() {
-    return I(e, (s) => s.stop(...arguments)), this;
+    return S(e, (s) => s.stop(...arguments)), this;
   }, t.update = function(s) {
-    return I(e, (n, a) => n.update(this._getProps(s, n, a))), this;
+    return S(e, (n, a) => n.update(this._getProps(s, n, a))), this;
   };
   const i = function(s, n, a) {
     return o.fun(s) ? s(a, n) : s;
   };
   return t._getProps = i, t;
 };
-function Lt(e, t, i) {
+function Bt(e, t, i) {
   const s = o.fun(t) && t;
   s && !i && (i = []);
   const n = le(
     () => s || arguments.length == 3 ? Pt() : void 0,
     []
-  ), a = te(0), u = Ze(), r = le(
+  ), a = Z(0), c = Ze(), u = le(
     () => ({
       ctrls: [],
       queue: [],
-      flush(c, v) {
-        const h = Me(c, v);
-        return a.current > 0 && !r.queue.length && !Object.keys(h).some((C) => !c.springs[C]) ? Ee(c, v) : new Promise((C) => {
-          gt(c, h), r.queue.push(() => {
-            C(Ee(c, v));
-          }), u();
+      flush(r, l) {
+        const p = Ee(r, l);
+        return a.current > 0 && !u.queue.length && !Object.keys(p).some((w) => !r.springs[w]) ? Me(r, l) : new Promise((w) => {
+          gt(r, p), u.queue.push(() => {
+            w(Me(r, l));
+          }), c();
         });
       }
     }),
     []
-  ), p = te([...r.ctrls]), f = te([]), S = we(e) || 0;
+  ), g = Z([...u.ctrls]), f = Z([]), b = Z([]);
+  b.current = [];
+  const h = we(e) || 0;
   le(() => {
-    I(p.current.slice(e, S), (c) => {
-      Re(c, n), c.stop(!0);
-    }), p.current.length = e, l(S, e);
+    S(g.current.slice(e, h), (r) => {
+      Ce(r, n), r.stop(!0);
+    }), g.current.length = e, _(h, e);
   }, [e]), le(() => {
-    l(0, Math.min(S, e));
+    _(0, Math.min(h, e));
   }, i);
-  function l(c, v) {
-    for (let h = c; h < v; h++) {
-      const w = p.current[h] || (p.current[h] = new dt(null, r.flush)), C = s ? s(h, w) : t[h];
-      C && (f.current[h] = Qt(C));
+  function _(r, l) {
+    for (let p = r; p < l; p++) {
+      const R = g.current[p] || (g.current[p] = new dt(null, u.flush)), w = s ? s(p, R) : t[p];
+      w && (f.current[p] = Nt(w));
     }
   }
-  const P = p.current.map(
-    (c, v) => Me(c, f.current[v])
-  ), y = it(vt), _ = we(y), d = y !== _ && ot(y);
+  const y = g.current.map(
+    (r, l) => Ee(r, f.current[l])
+  ), d = it(vt), A = we(d), I = d !== A && ot(d);
   ue(() => {
-    a.current++, r.ctrls = p.current;
-    const { queue: c } = r;
-    c.length && (r.queue = [], I(c, (v) => v())), I(p.current, (v, h) => {
-      n == null || n.add(v), d && v.start({ default: y });
-      const w = f.current[h];
-      w && (rt(v, w.ref), v.ref ? v.queue.push(w) : v.start(w));
-    });
+    a.current++, u.ctrls = g.current;
+    const { queue: r } = u;
+    r.length && (u.queue = [], S(r, (p) => p()));
+    const l = f.current.length > 0 ? f.current : b.current;
+    S(g.current, (p, R) => {
+      n == null || n.add(p), I && p.start({ default: d });
+      const w = l[R];
+      w && (rt(p, w.ref), p.ref ? p.queue.push({
+        ...w,
+        default: o.obj(w.default) ? { ...w.default } : w.default
+      }) : p.start(w));
+    }), f.current.length > 0 && (b.current = f.current), f.current = [];
   }), Xe(() => () => {
-    I(r.ctrls, (c) => c.stop(!0));
+    S(u.ctrls, (r) => r.stop(!0));
   });
-  const m = P.map((c) => ({ ...c }));
-  return n ? [m, n] : m;
+  const v = y.map((r) => ({ ...r }));
+  return n ? [v, n] : v;
 }
 function Xt(e, t) {
-  const i = o.fun(e), [[s], n] = Lt(
+  const i = o.fun(e), [[s], n] = Bt(
     1,
     i ? e : [e],
     i ? [] : t
@@ -1012,154 +1034,155 @@ function Zt(e, t, i) {
   const s = o.fun(t) && t, {
     reset: n,
     sort: a,
-    trail: u = 0,
-    expires: r = !0,
-    exitBeforeEnter: p = !1,
+    trail: c = 0,
+    expires: u = !0,
+    exitBeforeEnter: g = !1,
     onDestroyed: f,
-    ref: S,
-    config: l
-  } = s ? s() : t, P = le(
+    ref: b,
+    config: h
+  } = s ? s() : t, _ = le(
     () => s || arguments.length == 3 ? Pt() : void 0,
     []
-  ), y = M(e), _ = [], d = te(null), m = n ? null : d.current;
+  ), y = j(e), d = [], A = Z(null), I = n ? null : A.current;
   ue(() => {
-    d.current = _;
-  }), Xe(() => (I(_, (g) => {
-    P == null || P.add(g.ctrl), g.ctrl.ref = P;
+    A.current = d;
+  }), Xe(() => (S(d, (m) => {
+    _ == null || _.add(m.ctrl), m.ctrl.ref = _;
   }), () => {
-    I(d.current, (g) => {
-      g.expired && clearTimeout(g.expirationId), Re(g.ctrl, P), g.ctrl.stop(!0);
+    S(A.current, (m) => {
+      m.expired && clearTimeout(m.expirationId), Ce(m.ctrl, _), m.ctrl.stop(!0);
     });
   }));
-  const c = Kt(y, s ? s() : t, m), v = n && d.current || [];
+  const v = Kt(y, s ? s() : t, I), r = n && A.current || [];
   ue(
-    () => I(v, ({ ctrl: g, item: b, key: T }) => {
-      Re(g, P), E(f, b, T);
+    () => S(r, ({ ctrl: m, item: P, key: V }) => {
+      Ce(m, _), O(f, P, V);
     })
   );
-  const h = [];
-  if (m && I(m, (g, b) => {
-    g.expired ? (clearTimeout(g.expirationId), v.push(g)) : (b = h[b] = c.indexOf(g.key), ~b && (_[b] = g));
-  }), I(y, (g, b) => {
-    _[b] || (_[b] = {
-      key: c[b],
-      item: g,
+  const l = [];
+  if (I && S(I, (m, P) => {
+    m.expired ? (clearTimeout(m.expirationId), r.push(m)) : (P = l[P] = v.indexOf(m.key), ~P && (d[P] = m));
+  }), S(y, (m, P) => {
+    d[P] || (d[P] = {
+      key: v[P],
+      item: m,
       phase: "mount",
       ctrl: new dt()
-    }, _[b].ctrl.item = g);
-  }), h.length) {
-    let g = -1;
-    const { leave: b } = s ? s() : t;
-    I(h, (T, V) => {
-      const A = m[V];
-      ~T ? (g = _.indexOf(A), _[g] = { ...A, item: y[T] }) : b && _.splice(++g, 0, A);
+    }, d[P].ctrl.item = m);
+  }), l.length) {
+    let m = -1;
+    const { leave: P } = s ? s() : t;
+    S(l, (V, F) => {
+      const C = I[F];
+      ~V ? (m = d.indexOf(C), d[m] = { ...C, item: y[V] }) : P && d.splice(++m, 0, C);
     });
   }
-  o.fun(a) && _.sort((g, b) => a(g.item, b.item));
-  let w = -u;
-  const C = Ze(), Q = Pe(t), R = /* @__PURE__ */ new Map(), N = te(/* @__PURE__ */ new Map()), x = te(!1);
-  I(_, (g, b) => {
-    const T = g.key, V = g.phase, A = s ? s() : t;
-    let F, j;
-    const ee = E(A.delay || 0, T);
-    if (V == "mount")
-      F = A.enter, j = "enter";
+  o.fun(a) && d.sort((m, P) => a(m.item, P.item));
+  let p = -c;
+  const R = Ze(), w = ve(t), x = /* @__PURE__ */ new Map(), E = Z(/* @__PURE__ */ new Map()), T = Z(!1);
+  S(d, (m, P) => {
+    const V = m.key, F = m.phase, C = s ? s() : t;
+    let M, k;
+    const te = O(C.delay || 0, V);
+    if (F == "mount")
+      M = C.enter, k = "enter";
     else {
-      const k = c.indexOf(T) < 0;
-      if (V != "leave")
-        if (k)
-          F = A.leave, j = "leave";
-        else if (F = A.update)
-          j = "update";
+      const D = v.indexOf(V) < 0;
+      if (F != "leave")
+        if (D)
+          M = C.leave, k = "leave";
+        else if (M = C.update)
+          k = "update";
         else return;
-      else if (!k)
-        F = A.enter, j = "enter";
+      else if (!D)
+        M = C.enter, k = "enter";
       else return;
     }
-    if (F = E(F, g.item, b), F = o.obj(F) ? je(F) : { to: F }, !F.config) {
-      const k = l || Q.config;
-      F.config = E(k, g.item, b, j);
+    if (M = O(M, m.item, P), M = o.obj(M) ? qe(M) : { to: M }, !M.config) {
+      const D = h || w.config;
+      M.config = O(D, m.item, P, k);
     }
-    w += u;
+    p += c;
     const G = {
-      ...Q,
+      ...w,
       // we need to add our props.delay value you here.
-      delay: ee + w,
-      ref: S,
-      immediate: A.immediate,
+      delay: te + p,
+      ref: b,
+      immediate: C.immediate,
       // This prevents implied resets.
       reset: !1,
       // Merge any phase-specific props.
-      ...F
+      ...M
     };
-    if (j == "enter" && o.und(G.from)) {
-      const k = s ? s() : t, ne = o.und(k.initial) || m ? k.from : k.initial;
-      G.from = E(ne, g.item, b);
+    if (k == "enter" && o.und(G.from)) {
+      const D = s ? s() : t, ne = o.und(D.initial) || I ? D.from : D.initial;
+      G.from = O(ne, m.item, P);
     }
     const { onResolve: St } = G;
-    G.onResolve = (k) => {
-      E(St, k);
-      const ne = d.current, J = ne.find((pe) => pe.key === T);
-      if (J && !(k.cancelled && J.phase != "update") && J.ctrl.idle) {
-        const pe = ne.every((X) => X.ctrl.idle);
-        if (J.phase == "leave") {
-          const X = E(r, J.item);
+    G.onResolve = (D) => {
+      O(St, D);
+      const ne = A.current, H = ne.find((ge) => ge.key === V);
+      if (H && !(D.cancelled && H.phase != "update") && H.ctrl.idle) {
+        const ge = ne.every((X) => X.ctrl.idle);
+        if (H.phase == "leave") {
+          E.current.delete(H);
+          const X = O(u, H.item);
           if (X !== !1) {
             const be = X === !0 ? 0 : X;
-            if (J.expired = !0, !pe && be > 0) {
-              be <= 2147483647 && (J.expirationId = setTimeout(C, be));
+            if (H.expired = !0, !ge && be > 0) {
+              be <= 2147483647 && (H.expirationId = setTimeout(R, be));
               return;
             }
           }
         }
-        pe && ne.some((X) => X.expired) && (N.current.delete(J), p && (x.current = !0), C());
+        ge && ne.some((X) => X.expired) && (g && (T.current = !0), R());
       }
     };
-    const Ue = Me(g.ctrl, G);
-    j === "leave" && p ? N.current.set(g, { phase: j, springs: Ue, payload: G }) : R.set(g, { phase: j, springs: Ue, payload: G });
+    const De = Ee(m.ctrl, G);
+    k === "leave" && g ? E.current.set(m, { phase: k, springs: De, payload: G }) : x.set(m, { phase: k, springs: De, payload: G });
   });
-  const q = it(vt), O = we(q), B = q !== O && ot(q);
+  const U = it(vt), q = we(U), L = U !== q && ot(U);
   ue(() => {
-    B && I(_, (g) => {
-      g.ctrl.start({ default: q });
+    L && S(d, (m) => {
+      m.ctrl.start({ default: U });
     });
-  }, [q]), I(R, (g, b) => {
-    if (N.current.size) {
-      const T = _.findIndex((V) => V.key === b.key);
-      _.splice(T, 1);
+  }, [U]), S(x, (m, P) => {
+    if (E.current.size) {
+      const V = d.findIndex((F) => F.key === P.key);
+      d.splice(V, 1);
     }
   }), ue(
     () => {
-      I(
-        N.current.size ? N.current : R,
-        ({ phase: g, payload: b }, T) => {
-          const { ctrl: V } = T;
-          T.phase = g, P == null || P.add(V), B && g == "enter" && V.start({ default: q }), b && (rt(V, b.ref), (V.ref || P) && !x.current ? V.update(b) : (V.start(b), x.current && (x.current = !1)));
+      S(
+        E.current.size ? E.current : x,
+        ({ phase: m, payload: P }, V) => {
+          const { ctrl: F } = V;
+          V.phase = m, _ == null || _.add(F), L && m == "enter" && F.start({ default: U }), P && (rt(F, P.ref), (F.ref || _) && !T.current ? F.update(P) : (F.start(P), T.current && (T.current = !1)));
         }
       );
     },
     n ? void 0 : i
   );
-  const L = (g) => /* @__PURE__ */ fe.createElement(fe.Fragment, null, _.map((b, T) => {
-    const { springs: V } = R.get(b) || b.ctrl, A = g({ ...V }, b.item, b, T), F = o.str(b.key) || o.num(b.key) ? b.key : b.ctrl.id, j = fe.version < "19.0.0", ee = (A == null ? void 0 : A.props) ?? {}, G = j ? A == null ? void 0 : A.ref : ee == null ? void 0 : ee.ref;
-    return A && A.type ? /* @__PURE__ */ fe.createElement(A.type, { ...ee, key: F, ref: G }) : A;
+  const B = (m) => /* @__PURE__ */ fe.createElement(fe.Fragment, null, d.map((P, V) => {
+    const { springs: F } = x.get(P) || P.ctrl, C = m({ ...F }, P.item, P, V), M = o.str(P.key) || o.num(P.key) ? P.key : P.ctrl.id, k = fe.version < "19.0.0", te = (C == null ? void 0 : C.props) ?? {}, G = k ? C == null ? void 0 : C.ref : te == null ? void 0 : te.ref;
+    return C && C.type ? /* @__PURE__ */ fe.createElement(C.type, { ...te, key: M, ref: G }) : C;
   }));
-  return P ? [L, P] : L;
+  return _ ? [B, _] : B;
 }
 var Gt = 1;
 function Kt(e, { key: t, keys: i = t }, s) {
   if (i === null) {
     const n = /* @__PURE__ */ new Set();
     return e.map((a) => {
-      const u = s && s.find(
-        (r) => r.item === a && r.phase !== "leave" && !n.has(r)
+      const c = s && s.find(
+        (u) => u.item === a && u.phase !== "leave" && !n.has(u)
       );
-      return u ? (n.add(u), u.key) : Gt++;
+      return c ? (n.add(c), c.key) : Gt++;
     });
   }
-  return o.und(i) ? e : o.fun(i) ? e.map(i) : M(i);
+  return o.und(i) ? e : o.fun(i) ? e.map(i) : j(i);
 }
-var bt = class extends De {
+var bt = class extends ke {
   constructor(e, t) {
     super(), this.source = e, this.idle = !0, this._active = /* @__PURE__ */ new Set(), this.calc = It(...t);
     const i = this._get(), s = Ae(i);
@@ -1170,31 +1193,31 @@ var bt = class extends De {
     K(t, i) || ($(this).setValue(t), this._onChange(t, this.idle)), !this.idle && We(this._active) && Ie(this);
   }
   _get() {
-    const e = o.arr(this.source) ? this.source.map(z) : M(z(this.source));
+    const e = o.arr(this.source) ? this.source.map(Q) : j(Q(this.source));
     return this.calc(...e);
   }
   _start() {
-    this.idle && !We(this._active) && (this.idle = !1, I(qe(this), (e) => {
+    this.idle && !We(this._active) && (this.idle = !1, S(je(this), (e) => {
       e.done = !1;
-    }), H.skipAnimation ? (U.batchedUpdates(() => this.advance()), Ie(this)) : Oe.start(this));
+    }), W.skipAnimation ? (N.batchedUpdates(() => this.advance()), Ie(this)) : Oe.start(this));
   }
   // Observe our sources only when we're observed.
   _attach() {
     let e = 1;
-    I(M(this.source), (t) => {
-      W(t) && ve(t, this), Te(t) && (t.idle || this._active.add(t), e = Math.max(e, t.priority + 1));
+    S(j(this.source), (t) => {
+      Y(t) && ye(t, this), xe(t) && (t.idle || this._active.add(t), e = Math.max(e, t.priority + 1));
     }), this.priority = e, this._start();
   }
   // Stop observing our sources once we have no observers.
   _detach() {
-    I(M(this.source), (e) => {
-      W(e) && et(e, this);
+    S(j(this.source), (e) => {
+      Y(e) && et(e, this);
     }), this._active.clear(), Ie(this);
   }
   /** @internal */
   eventObserved(e) {
-    e.type == "change" ? e.idle ? this.advance() : (this._active.add(e.parent), this._start()) : e.type == "idle" ? this._active.delete(e.parent) : e.type == "priority" && (this.priority = M(this.source).reduce(
-      (t, i) => Math.max(t, (Te(i) ? i.priority : 0) + 1),
+    e.type == "change" ? e.idle ? this.advance() : (this._active.add(e.parent), this._start()) : e.type == "idle" ? this._active.delete(e.parent) : e.type == "priority" && (this.priority = j(this.source).reduce(
+      (t, i) => Math.max(t, (xe(i) ? i.priority : 0) + 1),
       0
     ));
   }
@@ -1206,34 +1229,34 @@ function We(e) {
   return !e.size || Array.from(e).every($t);
 }
 function Ie(e) {
-  e.idle || (e.idle = !0, I(qe(e), (t) => {
+  e.idle || (e.idle = !0, S(je(e), (t) => {
     t.done = !0;
-  }), ye(e, {
+  }), _e(e, {
     type: "idle",
     parent: e
   }));
 }
 var ei = (e, ...t) => new bt(e, t);
-H.assign({
-  createStringInterpolator: xt,
+W.assign({
+  createStringInterpolator: Tt,
   to: (e, t) => new bt(e, t)
 });
 export {
   Ge as BailSignal,
   dt as Controller,
-  De as FrameValue,
-  H as Globals,
+  ke as FrameValue,
+  W as Globals,
   bt as Interpolation,
   vt as SpringContext,
   Pt as SpringRef,
-  Ut as SpringValue,
+  Dt as SpringValue,
   Ot as config,
   It as createInterpolator,
-  Rt as easings,
-  je as inferTo,
+  Ct as easings,
+  qe as inferTo,
   ei as to,
   ue as useIsomorphicLayoutEffect,
   Xt as useSpring,
-  Lt as useSprings,
+  Bt as useSprings,
   Zt as useTransition
 };