qaema-ui 0.0.1

package/dist/node_modules/@react-spring/core/dist/react-spring_core.modern.js

@@ -0,0 +1,1236 @@
+import { is as r, useIsomorphicLayoutEffect as ue, useOnce as Xe, each as I, toArray as M, useForceUpdate as Ze, usePrev as we, eachProp as se, addFluidObserver as ve, flush as _e, deprecateDirectCall as St, flushCalls as ce, Globals as H, getFluidValue as z, hasFluidValue as W, isEqual as K, isAnimatedString as et, getFluidObservers as Qe, removeFluidObserver as tt, frameLoop as Oe, callFluidObservers as ye, FluidValue as It, deprecateInterpolate as wt, easings as At, noop as Ne, createStringInterpolator as Ct, createInterpolator as Rt } from "../../shared/dist/react-spring_shared.modern.js";
+import * as fe from "react";
+import { useMemo as le, useRef as te, useContext as it } from "react";
+import { getAnimated as $, AnimatedValue as xt, getPayload as qe, AnimatedString as ze, getAnimatedType as Ae, setAnimated as st } from "../../animated/dist/react-spring_animated.modern.js";
+import { raf as U } from "../../rafz/dist/react-spring_rafz.modern.js";
+function E(e, ...t) {
+  return r.fun(e) ? e(...t) : e;
+}
+var he = (e, t) => e === !0 || !!(t && e && (r.fun(e) ? e(t) : M(e).includes(t))), nt = (e, t) => r.obj(e) ? t && e[t] : e, at = (e, t) => e.default === !0 ? e[t] : e.default ? e.default[t] : void 0, Tt = (e) => e, Pe = (e, t = Tt) => {
+  let i = Vt;
+  e.default && e.default !== !0 && (e = e.default, i = Object.keys(e));
+  const s = {};
+  for (const n of i) {
+    const a = t(e[n], n);
+    r.und(a) || (s[n] = a);
+  }
+  return s;
+}, Vt = [
+  "config",
+  "onProps",
+  "onStart",
+  "onChange",
+  "onPause",
+  "onResume",
+  "onRest"
+], Ft = {
+  config: 1,
+  from: 1,
+  to: 1,
+  ref: 1,
+  loop: 1,
+  reset: 1,
+  pause: 1,
+  cancel: 1,
+  reverse: 1,
+  immediate: 1,
+  default: 1,
+  delay: 1,
+  onProps: 1,
+  onStart: 1,
+  onChange: 1,
+  onPause: 1,
+  onResume: 1,
+  onRest: 1,
+  onResolve: 1,
+  // Transition props
+  items: 1,
+  trail: 1,
+  sort: 1,
+  expires: 1,
+  initial: 1,
+  enter: 1,
+  update: 1,
+  leave: 1,
+  children: 1,
+  onDestroyed: 1,
+  // Internal props
+  keys: 1,
+  callId: 1,
+  parentId: 1
+};
+function Et(e) {
+  const t = {};
+  let i = 0;
+  if (se(e, (s, n) => {
+    Ft[n] || (t[n] = s, i++);
+  }), i)
+    return t;
+}
+function je(e) {
+  const t = Et(e);
+  if (t) {
+    const i = { to: t };
+    return se(e, (s, n) => n in t || (i[n] = s)), i;
+  }
+  return { ...e };
+}
+function de(e) {
+  return e = z(e), r.arr(e) ? e.map(de) : et(e) ? H.createStringInterpolator({
+    range: [0, 1],
+    output: [e, e]
+  })(1) : e;
+}
+function rt(e) {
+  for (const t in e) return !0;
+  return !1;
+}
+function Ce(e) {
+  return r.fun(e) || r.arr(e) && r.obj(e[0]);
+}
+function Re(e, t) {
+  var i;
+  (i = e.ref) == null || i.delete(e), t == null || t.delete(e);
+}
+function ot(e, t) {
+  var i;
+  t && e.ref !== t && ((i = e.ref) == null || i.delete(e), t.add(e), e.ref = t);
+}
+var Mt = {
+  default: { tension: 170, friction: 26 }
+}, xe = {
+  ...Mt.default,
+  mass: 1,
+  damping: 1,
+  easing: At.linear,
+  clamp: !1
+}, Ot = class {
+  constructor() {
+    this.velocity = 0, Object.assign(this, xe);
+  }
+};
+function qt(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]);
+  let { frequency: s, damping: n } = e;
+  const { mass: a } = e;
+  return r.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) {
+  if (!r.und(t.decay))
+    e.duration = void 0;
+  else {
+    const i = !r.und(t.tension) || !r.und(t.friction);
+    (i || !r.und(t.frequency) || !r.und(t.damping) || !r.und(t.mass)) && (e.duration = void 0, e.decay = void 0), i && (e.frequency = void 0);
+  }
+}
+var Le = [], jt = class {
+  constructor() {
+    this.changed = !1, this.values = Le, this.toValues = null, this.fromValues = Le, this.config = new Ot(), this.immediate = !1;
+  }
+};
+function ut(e, { key: t, props: i, defaultProps: s, state: n, actions: a }) {
+  return new Promise((u, o) => {
+    let p, f, S = he(i.cancel ?? (s == null ? void 0 : s.cancel), t);
+    if (S)
+      y();
+    else {
+      r.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());
+    }
+    function l() {
+      n.resumeQueue.add(P), n.timeouts.delete(f), f.cancel(), p = f.time - U.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 y() {
+      n.delayed && (n.delayed = !1), n.pauseQueue.delete(l), n.timeouts.delete(f), e <= (n.cancelId || 0) && (S = !0);
+      try {
+        a.start({ ...i, callId: e, cancel: S }, u);
+      } catch (_) {
+        o(_);
+      }
+    }
+  });
+}
+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(
+  e.get(),
+  t.every((i) => i.finished)
+), ct = (e) => ({
+  value: e,
+  noop: !0,
+  finished: !0,
+  cancelled: !1
+}), D = (e, t, i = !1) => ({
+  value: e,
+  finished: t,
+  cancelled: i
+}), ie = (e) => ({
+  value: e,
+  cancelled: !0,
+  finished: !1
+});
+function ft(e, t, i, s) {
+  const { callId: n, parentId: a, onRest: u } = t, { asyncTo: o, promise: p } = i;
+  return !a && e === o && !t.reset ? p : i.promise = (async () => {
+    i.asyncId = n, i.asyncTo = e;
+    const f = Pe(
+      t,
+      (m, c) => (
+        // The `onRest` prop is only called when the `runAsync` promise is resolved.
+        c === "onRest" ? void 0 : m
+      )
+    );
+    let S, l;
+    const P = new Promise(
+      (m, c) => (S = m, l = c)
+    ), y = (m) => {
+      const c = (
+        // 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)
+      );
+      if (c)
+        throw m.result = c, l(m), m;
+    }, _ = (m, c) => {
+      const v = new Ge(), h = new Ke();
+      return (async () => {
+        if (H.skipAnimation)
+          throw me(i), h.result = D(s, !1), l(h), h;
+        y(v);
+        const w = r.obj(m) ? { ...m } : { ...c, to: m };
+        w.parentId = n, se(f, (Q, R) => {
+          r.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;
+      })();
+    };
+    let d;
+    if (H.skipAnimation)
+      return me(i), D(s, !1);
+    try {
+      let m;
+      r.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;
+      else
+        throw m;
+    } finally {
+      n == i.asyncId && (i.asyncId = a, i.asyncTo = a ? o : void 0, i.promise = a ? p : void 0);
+    }
+    return r.fun(u) && U.batchedUpdates(() => {
+      u(d, s, s.item);
+    }), d;
+  })();
+}
+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);
+}
+var Ge = class extends Error {
+  constructor() {
+    super(
+      "An async animation has been interrupted. You see this error because you forgot to use `await` or `.catch(...)` on its returned promise."
+    );
+  }
+}, Ke = class extends Error {
+  constructor() {
+    super("SkipAnimationSignal");
+  }
+}, Te = (e) => e instanceof De, kt = 1, De = class extends It {
+  constructor() {
+    super(...arguments), this.id = kt++, this._priority = 0;
+  }
+  get priority() {
+    return this._priority;
+  }
+  set priority(e) {
+    this._priority != e && (this._priority = e, this._onPriorityChange(e));
+  }
+  /** Get the current value */
+  get() {
+    const e = $(this);
+    return e && e.getValue();
+  }
+  /** Create a spring that maps our value to another value */
+  to(...e) {
+    return H.to(this, e);
+  }
+  /** @deprecated Use the `to` method instead. */
+  interpolate(...e) {
+    return wt(), H.to(this, e);
+  }
+  toJSON() {
+    return this.get();
+  }
+  observerAdded(e) {
+    e == 1 && this._attach();
+  }
+  observerRemoved(e) {
+    e == 0 && this._detach();
+  }
+  /** Called when the first child is added. */
+  _attach() {
+  }
+  /** Called when the last child is removed. */
+  _detach() {
+  }
+  /** Tell our children about our new value */
+  _onChange(e, t = !1) {
+    ye(this, {
+      type: "change",
+      parent: this,
+      value: e,
+      idle: t
+    });
+  }
+  /** Tell our children about our new priority */
+  _onPriorityChange(e) {
+    this.idle || Oe.sort(this), ye(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, Dt = class extends De {
+  constructor(e, t) {
+    if (super(), this.animation = new jt(), this.defaultProps = {}, this._state = {
+      paused: !1,
+      delayed: !1,
+      pauseQueue: /* @__PURE__ */ new Set(),
+      resumeQueue: /* @__PURE__ */ new Set(),
+      timeouts: /* @__PURE__ */ new Set()
+    }, this._pendingCalls = /* @__PURE__ */ new Set(), this._lastCallId = 0, this._lastToId = 0, this._memoizedDuration = 0, !r.und(e) || !r.und(t)) {
+      const i = r.obj(e) ? { ...e } : { ...t, from: e };
+      r.und(i.default) && (i.default = !0), this.start(i);
+    }
+  }
+  /** Equals true when not advancing on each frame. */
+  get idle() {
+    return !(Y(this) || this._state.asyncTo) || ae(this);
+  }
+  get goal() {
+    return z(this.animation.to);
+  }
+  get velocity() {
+    const e = $(this);
+    return e instanceof xt ? e.lastVelocity || 0 : e.getPayload().map((t) => t.lastVelocity || 0);
+  }
+  /**
+   * When true, this value has been animated at least once.
+   */
+  get hasAnimated() {
+    return Se(this);
+  }
+  /**
+   * When true, this value has an unfinished animation,
+   * which is either active or paused.
+   */
+  get isAnimating() {
+    return Y(this);
+  }
+  /**
+   * When true, all current and future animations are paused.
+   */
+  get isPaused() {
+    return ae(this);
+  }
+  /**
+   *
+   *
+   */
+  get isDelayed() {
+    return this._state.delayed;
+  }
+  /** Advance the current animation by a number of milliseconds */
+  advance(e) {
+    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) => {
+      if (f.done) return;
+      const l = (
+        // Animated strings always go from 0 to 1.
+        f.constructor == ze ? 1 : u ? u[S].lastPosition : n[S]
+      );
+      let P = s.immediate, y = l;
+      if (!P) {
+        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 = r.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));
+        if (r.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;
+          } else {
+            c = f.lastVelocity == null ? m : f.lastVelocity;
+            const h = a.restVelocity || v / 10, w = a.clamp ? 0 : a.bounce, C = !r.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;
+            }
+          }
+        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;
+        }
+        f.lastVelocity = c, Number.isNaN(y) && (console.warn("Got NaN while animating:", this), P = !0);
+      }
+      u && !u[S].done && (P = !1), P ? f.done = !0 : t = !1, f.setValue(y, a.round) && (i = !0);
+    });
+    const o = $(this), p = o.getValue();
+    if (t) {
+      const f = z(s.to);
+      (p !== f || i) && !a.decay ? (o.setValue(f), this._onChange(f)) : i && a.decay && this._onChange(p), this._stop();
+    } else i && this._onChange(p);
+  }
+  /** Set the current value, while stopping the current animation */
+  set(e) {
+    return U.batchedUpdates(() => {
+      this._stop(), this._focus(e), this._set(e);
+    }), this;
+  }
+  /**
+   * Freeze the active animation in time, as well as any updates merged
+   * before `resume` is called.
+   */
+  pause() {
+    this._update({ pause: !0 });
+  }
+  /** Resume the animation if paused. */
+  resume() {
+    this._update({ pause: !1 });
+  }
+  /** Skip to the end of the current animation. */
+  finish() {
+    if (Y(this)) {
+      const { to: e, config: t } = this.animation;
+      U.batchedUpdates(() => {
+        this._onStart(), t.decay || this._set(e, !1), this._stop();
+      });
+    }
+    return this;
+  }
+  /** Push props into the pending queue. */
+  update(e) {
+    return (this.queue || (this.queue = [])).push(e), this;
+  }
+  start(e, t) {
+    let i;
+    return r.und(e) ? (i = this.queue || [], this.queue = []) : i = [r.obj(e) ? e : { ...t, to: e }], Promise.all(
+      i.map((s) => this._update(s))
+    ).then((s) => ke(this, s));
+  }
+  /**
+   * Stop the current animation, and cancel any delayed updates.
+   *
+   * Pass `true` to call `onRest` with `cancelled: true`.
+   */
+  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;
+  }
+  /** Restart the animation. */
+  reset() {
+    this._update({ reset: !0 });
+  }
+  /** @internal */
+  eventObserved(e) {
+    e.type == "change" ? this._start() : e.type == "priority" && (this.priority = e.priority + 1);
+  }
+  /**
+   * Parse the `to` and `from` range from the given `props` object.
+   *
+   * This also ensures the initial value is available to animated components
+   * during the render phase.
+   */
+  _prepareNode(e) {
+    const t = this.key || "";
+    let { to: i, from: s } = e;
+    i = r.obj(i) ? i[t] : i, (i == null || Ce(i)) && (i = void 0), s = r.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), r.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(
+        e,
+        (u, o) => /^on/.test(o) ? nt(u, i) : u
+      )
+    ), Ye(this, e, "onProps"), oe(this, "onProps", e, this);
+    const n = this._prepareNode(e);
+    if (Object.isFrozen(this))
+      throw Error(
+        "Cannot animate a `SpringValue` object that is frozen. Did you forget to pass your component to `animated(...)` before animating its props?"
+      );
+    const a = this._state;
+    return ut(++this._lastCallId, {
+      key: i,
+      props: e,
+      defaultProps: s,
+      state: a,
+      actions: {
+        pause: () => {
+          ae(this) || (He(this, !0), ce(a.pauseQueue), oe(
+            this,
+            "onPause",
+            D(this, re(this, this.animation.to)),
+            this
+          ));
+        },
+        resume: () => {
+          ae(this) && (He(this, !1), Y(this) && this._resume(), ce(a.resumeQueue), oe(
+            this,
+            "onResume",
+            D(this, re(this, this.animation.to)),
+            this
+          ));
+        },
+        start: this._merge.bind(this, n)
+      }
+    }).then((u) => {
+      if (e.loop && u.finished && !(t && u.noop)) {
+        const o = ht(e);
+        if (o)
+          return this._update(o, !0);
+      }
+      return u;
+    });
+  }
+  /** Merge props into the current animation */
+  _merge(e, t, i) {
+    if (t.cancel)
+      return this.stop(!0), i(ie(this));
+    const s = !r.und(e.to), n = !r.und(e.from);
+    if (s || n)
+      if (t.callId > this._lastToId)
+        this._lastToId = t.callId;
+      else
+        return i(ie(this));
+    const { key: a, defaultProps: u, animation: o } = this, { to: p, from: f } = o;
+    let { to: S = p, from: l = f } = e;
+    n && !s && (!t.default || r.und(S)) && (S = l), t.reverse && ([S, l] = [l, S]);
+    const P = !K(l, f);
+    P && (o.from = l), l = z(l);
+    const y = !K(S, p);
+    y && this._focus(S);
+    const _ = Ce(t.to), { config: d } = o, { decay: m, velocity: c } = d;
+    (s || n) && (d.velocity = 0), t.config && !_ && qt(
+      d,
+      E(t.config, a),
+      // Avoid calling the same "config" prop twice.
+      t.config !== u.config ? E(u.config, a) : void 0
+    );
+    let v = $(this);
+    if (!v || r.und(S))
+      return i(D(this, !0));
+    const h = (
+      // 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.
+      r.und(t.reset) ? n && !t.default : !r.und(l) && he(t.reset, a)
+    ), w = h ? l : this.get(), C = de(S), Q = r.num(C) || r.arr(C) || et(C), R = !_ && (!Q || he(u.immediate || t.immediate, a));
+    if (y) {
+      const O = Ae(S);
+      if (O !== v.constructor)
+        if (R)
+          v = this._set(C);
+        else
+          throw Error(
+            `Cannot animate between ${v.constructor.name} and ${O.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(o.immediate, R) && !R || !K(d.decay, m) || !K(d.velocity, c)) && (x = !0);
+    }
+    if (q && Y(this) && (o.changed && !h ? x = !0 : x || this._stop(p)), !_ && ((x || W(p)) && (o.values = v.getPayload(), o.toValues = W(S) ? null : N == ze ? [1] : M(C)), o.immediate != R && (o.immediate = R, !R && !h && this._set(p)), x)) {
+      const { onRest: O } = o;
+      I(Qt, (L) => Ye(this, t, L));
+      const B = D(this, re(this, p));
+      ce(this._pendingCalls, B), this._pendingCalls.add(i), o.changed && U.batchedUpdates(() => {
+        var L;
+        o.changed = !h, O == null || O(B, this), h ? E(u.onRest, B) : (L = o.onStart) == null || L.call(o, B, 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));
+  }
+  /** 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());
+  }
+  _attach() {
+    let e = 0;
+    const { to: t } = this.animation;
+    W(t) && (ve(t, this), Te(t) && (e = t.priority + 1)), this.priority = e;
+  }
+  _detach() {
+    const { to: e } = this.animation;
+    W(e) && tt(e, this);
+  }
+  /**
+   * Update the current value from outside the frameloop,
+   * and return the `Animated` node.
+   */
+  _set(e, t = !0) {
+    const i = z(e);
+    if (!r.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(() => {
+          this._onChange(i, t);
+        });
+      }
+    }
+    return $(this);
+  }
+  _onStart() {
+    const e = this.animation;
+    e.changed || (e.changed = !0, oe(
+      this,
+      "onStart",
+      D(this, re(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);
+  }
+  // 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());
+  }
+  _resume() {
+    H.skipAnimation ? this.finish() : Oe.start(this);
+  }
+  /**
+   * Exit the frameloop and notify `onRest` listeners.
+   *
+   * Always wrap `_stop` calls with `batchedUpdates`.
+   */
+  _stop(e, t) {
+    if (Y(this)) {
+      $e(this, !1);
+      const i = this.animation;
+      I(i.values, (n) => {
+        n.done = !0;
+      }), i.toValues && (i.onChange = i.onPause = i.onResume = void 0), ye(this, {
+        type: "idle",
+        parent: this
+      });
+      const s = t ? ie(this.get()) : D(this.get(), re(this, e ?? i.to));
+      ce(this._pendingCalls, s), i.changed && (i.changed = !1, oe(this, "onRest", s, this));
+    }
+  }
+};
+function re(e, t) {
+  const i = de(t), s = de(e.get());
+  return K(s, i);
+}
+function ht(e, t = e.loop, i = e.to) {
+  const s = E(t);
+  if (s) {
+    const n = s !== !0 && je(s), a = (n || e).reverse, u = !n || n.reset;
+    return ge({
+      ...e,
+      loop: t,
+      // Avoid updating default props when looping.
+      default: !1,
+      // Never loop the `pause` prop.
+      pause: void 0,
+      // 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,
+      // Ignore the "from" prop except on reset.
+      from: u ? e.from : void 0,
+      reset: u,
+      // 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();
+  return r.obj(t) && Je(t, s), r.obj(i) && Je(i, s), e.keys = s.size ? Array.from(s) : null, e;
+}
+function Ut(e) {
+  const t = ge(e);
+  return r.und(t.default) && (t.default = Pe(t)), t;
+}
+function Je(e, t) {
+  se(e, (i, s) => i != null && t.add(s));
+}
+var Qt = [
+  "onStart",
+  "onRest",
+  "onChange",
+  "onPause",
+  "onResume"
+];
+function Ye(e, t, i) {
+  e.animation[i] = t[i] !== at(t, i) ? nt(t[i], e.key) : void 0;
+}
+function oe(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 Nt = ["onStart", "onChange", "onRest"], zt = 1, dt = class {
+  constructor(e, t) {
+    this.id = zt++, 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(),
+      timeouts: /* @__PURE__ */ new Set()
+    }, this._events = {
+      onStart: /* @__PURE__ */ new Map(),
+      onChange: /* @__PURE__ */ new Map(),
+      onRest: /* @__PURE__ */ new Map()
+    }, this._onFrame = this._onFrame.bind(this), t && (this._flush = t), e && this.start({ default: !0, ...e });
+  }
+  /**
+   * Equals `true` when no spring values are in the frameloop, and
+   * no async animation is currently active.
+   */
+  get idle() {
+    return !this._state.asyncTo && Object.values(this.springs).every((e) => e.idle && !e.isDelayed && !e.isPaused);
+  }
+  get item() {
+    return this._item;
+  }
+  set item(e) {
+    this._item = e;
+  }
+  /** Get the current values of our springs */
+  get() {
+    const e = {};
+    return this.each((t, i) => e[i] = t.get()), e;
+  }
+  /** Set the current values without animating. */
+  set(e) {
+    for (const t in e) {
+      const i = e[t];
+      r.und(i) || this.springs[t].set(i);
+    }
+  }
+  /** Push an update onto the queue of each value. */
+  update(e) {
+    return e && this.queue.push(ge(e)), this;
+  }
+  /**
+   * Start the queued animations for every spring, and resolve the returned
+   * promise once all queued animations have finished or been cancelled.
+   *
+   * When you pass a queue (instead of nothing), that queue is used instead of
+   * the queued animations added with the `update` method, which are left alone.
+   */
+  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));
+  }
+  /** @internal */
+  stop(e, t) {
+    if (e !== !!e && (t = e), t) {
+      const i = this.springs;
+      I(M(t), (s) => i[s].stop(!!e));
+    } else
+      me(this._state, this._lastAsyncId), this.each((i) => i.stop(!!e));
+    return this;
+  }
+  /** Freeze the active animation in time */
+  pause(e) {
+    if (r.und(e))
+      this.start({ pause: !0 });
+    else {
+      const t = this.springs;
+      I(M(e), (i) => t[i].pause());
+    }
+    return this;
+  }
+  /** Resume the animation if paused. */
+  resume(e) {
+    if (r.und(e))
+      this.start({ pause: !1 });
+    else {
+      const t = this.springs;
+      I(M(e), (i) => t[i].resume());
+    }
+    return this;
+  }
+  /** Call a function once per spring value */
+  each(e) {
+    se(this.springs, 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, ([o, p]) => {
+      p.value = this.get(), o(p, this, this._item);
+    }));
+    const a = !s && this._started, u = n || a && i.size ? this.get() : null;
+    n && t.size && _e(t, ([o, p]) => {
+      p.value = u, o(p, this, this._item);
+    }), a && (this._started = !1, _e(i, ([o, p]) => {
+      p.value = u, o(p, this, this._item);
+    }));
+  }
+  /** @internal */
+  eventObserved(e) {
+    if (e.type == "change")
+      this._changed.add(e.parent), e.idle || this._active.add(e.parent);
+    else if (e.type == "idle")
+      this._active.delete(e.parent);
+    else return;
+    U.onFrame(this._onFrame);
+  }
+};
+function Ee(e, t) {
+  return Promise.all(t.map((i) => mt(e, i))).then(
+    (i) => ke(e, i)
+  );
+}
+async function mt(e, t, i) {
+  const { keys: s, to: n, from: a, loop: u, onRest: o, onResolve: p } = t, f = r.obj(t.default) && t.default;
+  u && (t.loop = !1), n === !1 && (t.to = null), a === !1 && (t.from = null);
+  const S = r.arr(n) || r.fun(n) ? n : void 0;
+  S ? (t.to = void 0, t.onRest = void 0, f && (f.onRest = void 0)) : I(Nt, (d) => {
+    const m = t[d];
+    if (r.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, {
+          value: null,
+          finished: v || !1,
+          cancelled: h || !1
+        });
+      }, f && (f[d] = t[d]);
+    }
+  });
+  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)
+  ), y = t.cancel === !0 || at(t, "cancel") === !0;
+  (S || y && l.asyncId) && P.push(
+    ut(++e._lastAsyncId, {
+      props: t,
+      state: l,
+      actions: {
+        pause: Ne,
+        resume: Ne,
+        start(d, m) {
+          y ? (me(l, e._lastAsyncId), m(ie(e))) : (d.onRest = o, m(
+            ft(
+              S,
+              d,
+              l,
+              e
+            )
+          ));
+        }
+      }
+    })
+  ), l.paused && await new Promise((d) => {
+    l.resumeQueue.add(d);
+  });
+  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);
+  }
+  return p && U.batchedUpdates(() => p(_, e, e.item)), _;
+}
+function Me(e, t) {
+  const i = { ...e.springs };
+  return t && I(M(t), (s) => {
+    r.und(s.keys) && (s = ge(s)), r.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));
+  });
+}
+function pt(e, t) {
+  const i = new Dt();
+  return i.key = e, t && ve(i, t), i;
+}
+function _t(e, t, i) {
+  t.keys && I(t.keys, (s) => {
+    (e[s] || (e[s] = i(s)))._prepareNode(t);
+  });
+}
+function yt(e, t) {
+  I(t, (i) => {
+    _t(e.springs, i, (s) => pt(s, e));
+  });
+}
+var vt = fe.createContext({
+  pause: !1,
+  immediate: !1
+}), Pt = () => {
+  const e = [], t = function(s) {
+    St();
+    const n = [];
+    return I(e, (a, u) => {
+      if (r.und(s))
+        n.push(a.start());
+      else {
+        const o = i(s, a, u);
+        o && n.push(a.start(o));
+      }
+    }), n;
+  };
+  t.current = e, t.add = function(s) {
+    e.includes(s) || e.push(s);
+  }, t.delete = function(s) {
+    const n = e.indexOf(s);
+    ~n && e.splice(n, 1);
+  }, t.pause = function() {
+    return I(e, (s) => s.pause(...arguments)), this;
+  }, t.resume = function() {
+    return I(e, (s) => s.resume(...arguments)), this;
+  }, t.set = function(s) {
+    I(e, (n, a) => {
+      const u = r.fun(s) ? s(a, n) : s;
+      u && n.set(u);
+    });
+  }, t.start = function(s) {
+    const n = [];
+    return I(e, (a, u) => {
+      if (r.und(s))
+        n.push(a.start());
+      else {
+        const o = this._getProps(s, a, u);
+        o && n.push(a.start(o));
+      }
+    }), n;
+  }, t.stop = function() {
+    return I(e, (s) => s.stop(...arguments)), this;
+  }, t.update = function(s) {
+    return I(e, (n, a) => n.update(this._getProps(s, n, a))), this;
+  };
+  const i = function(s, n, a) {
+    return r.fun(s) ? s(a, n) : s;
+  };
+  return t._getProps = i, t;
+};
+function Bt(e, t, i) {
+  const s = r.fun(t) && t;
+  s && !i && (i = []);
+  const n = le(
+    () => s || arguments.length == 3 ? Pt() : void 0,
+    []
+  ), a = te(0), u = Ze(), o = le(
+    () => ({
+      ctrls: [],
+      queue: [],
+      flush(c, v) {
+        const h = Me(c, v);
+        return a.current > 0 && !o.queue.length && !Object.keys(h).some((C) => !c.springs[C]) ? Ee(c, v) : new Promise((C) => {
+          gt(c, h), o.queue.push(() => {
+            C(Ee(c, v));
+          }), u();
+        });
+      }
+    }),
+    []
+  ), p = te([...o.ctrls]), f = te([]), S = we(e) || 0;
+  le(() => {
+    I(p.current.slice(e, S), (c) => {
+      Re(c, n), c.stop(!0);
+    }), p.current.length = e, l(S, e);
+  }, [e]), le(() => {
+    l(0, Math.min(S, e));
+  }, i);
+  function l(c, v) {
+    for (let h = c; h < v; h++) {
+      const w = p.current[h] || (p.current[h] = new dt(null, o.flush)), C = s ? s(h, w) : t[h];
+      C && (f.current[h] = Ut(C));
+    }
+  }
+  const P = p.current.map(
+    (c, v) => Me(c, f.current[v])
+  ), y = it(vt), _ = we(y), d = y !== _ && rt(y);
+  ue(() => {
+    a.current++, o.ctrls = p.current;
+    const { queue: c } = o;
+    c.length && (o.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 && (ot(v, w.ref), v.ref ? v.queue.push(w) : v.start(w));
+    });
+  }), Xe(() => () => {
+    I(o.ctrls, (c) => c.stop(!0));
+  });
+  const m = P.map((c) => ({ ...c }));
+  return n ? [m, n] : m;
+}
+function Xt(e, t) {
+  const i = r.fun(e), [[s], n] = Bt(
+    1,
+    i ? e : [e],
+    i ? [] : t
+  );
+  return i || arguments.length == 2 ? [s, n] : s;
+}
+function Zt(e, t, i) {
+  const s = r.fun(t) && t, {
+    reset: n,
+    sort: a,
+    trail: u = 0,
+    expires: o = !0,
+    exitBeforeEnter: p = !1,
+    onDestroyed: f,
+    ref: S,
+    config: l
+  } = s ? s() : t, P = le(
+    () => s || arguments.length == 3 ? Pt() : void 0,
+    []
+  ), y = M(e), _ = [], d = te(null), m = n ? null : d.current;
+  ue(() => {
+    d.current = _;
+  }), Xe(() => (I(_, (g) => {
+    P == null || P.add(g.ctrl), g.ctrl.ref = P;
+  }), () => {
+    I(d.current, (g) => {
+      g.expired && clearTimeout(g.expirationId), Re(g.ctrl, P), g.ctrl.stop(!0);
+    });
+  }));
+  const c = Gt(y, s ? s() : t, m), v = n && d.current || [];
+  ue(
+    () => I(v, ({ ctrl: g, item: b, key: T }) => {
+      Re(g, P), E(f, b, T);
+    })
+  );
+  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,
+      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);
+    });
+  }
+  r.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";
+    else {
+      const k = c.indexOf(T) < 0;
+      if (V != "leave")
+        if (k)
+          F = A.leave, j = "leave";
+        else if (F = A.update)
+          j = "update";
+        else return;
+      else if (!k)
+        F = A.enter, j = "enter";
+      else return;
+    }
+    if (F = E(F, g.item, b), F = r.obj(F) ? je(F) : { to: F }, !F.config) {
+      const k = l || Q.config;
+      F.config = E(k, g.item, b, j);
+    }
+    w += u;
+    const G = {
+      ...Q,
+      // we need to add our props.delay value you here.
+      delay: ee + w,
+      ref: S,
+      immediate: A.immediate,
+      // This prevents implied resets.
+      reset: !1,
+      // Merge any phase-specific props.
+      ...F
+    };
+    if (j == "enter" && r.und(G.from)) {
+      const k = s ? s() : t, ne = r.und(k.initial) || m ? k.from : k.initial;
+      G.from = E(ne, g.item, b);
+    }
+    const { onResolve: bt } = G;
+    G.onResolve = (k) => {
+      E(bt, 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(o, J.item);
+          if (X !== !1) {
+            const be = X === !0 ? 0 : X;
+            if (J.expired = !0, !pe && be > 0) {
+              be <= 2147483647 && (J.expirationId = setTimeout(C, be));
+              return;
+            }
+          }
+        }
+        pe && ne.some((X) => X.expired) && (N.current.delete(J), p && (x.current = !0), C());
+      }
+    };
+    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 q = it(vt), O = we(q), B = q !== O && rt(q);
+  ue(() => {
+    B && I(_, (g) => {
+      g.ctrl.start({ default: q });
+    });
+  }, [q]), I(R, (g, b) => {
+    if (N.current.size) {
+      const T = _.findIndex((V) => V.key === b.key);
+      _.splice(T, 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 && (ot(V, b.ref), (V.ref || P) && !x.current ? V.update(b) : (V.start(b), x.current && (x.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 = r.str(b.key) || r.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;
+  }));
+  return P ? [L, P] : L;
+}
+var Lt = 1;
+function Gt(e, { key: t, keys: i = t }, s) {
+  if (i === null) {
+    const n = /* @__PURE__ */ new Set();
+    return e.map((a) => {
+      const u = s && s.find(
+        (o) => o.item === a && o.phase !== "leave" && !n.has(o)
+      );
+      return u ? (n.add(u), u.key) : Lt++;
+    });
+  }
+  return r.und(i) ? e : r.fun(i) ? e.map(i) : M(i);
+}
+var Kt = class extends De {
+  constructor(e, t) {
+    super(), this.source = e, this.idle = !0, this._active = /* @__PURE__ */ new Set(), this.calc = Rt(...t);
+    const i = this._get(), s = Ae(i);
+    st(this, s.create(i));
+  }
+  advance(e) {
+    const t = this._get(), i = this.get();
+    K(t, i) || ($(this).setValue(t), this._onChange(t, this.idle)), !this.idle && We(this._active) && Ie(this);
+  }
+  _get() {
+    const e = r.arr(this.source) ? this.source.map(z) : M(z(this.source));
+    return this.calc(...e);
+  }
+  _start() {
+    this.idle && !We(this._active) && (this.idle = !1, I(qe(this), (e) => {
+      e.done = !1;
+    }), H.skipAnimation ? (U.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));
+    }), this.priority = e, this._start();
+  }
+  // Stop observing our sources once we have no observers.
+  _detach() {
+    I(M(this.source), (e) => {
+      W(e) && tt(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),
+      0
+    ));
+  }
+};
+function $t(e) {
+  return e.idle !== !1;
+}
+function We(e) {
+  return !e.size || Array.from(e).every($t);
+}
+function Ie(e) {
+  e.idle || (e.idle = !0, I(qe(e), (t) => {
+    t.done = !0;
+  }), ye(e, {
+    type: "idle",
+    parent: e
+  }));
+}
+H.assign({
+  createStringInterpolator: Ct,
+  to: (e, t) => new Kt(e, t)
+});
+export {
+  Ge as BailSignal,
+  dt as Controller,
+  De as FrameValue,
+  H as Globals,
+  Kt as Interpolation,
+  vt as SpringContext,
+  Pt as SpringRef,
+  Dt as SpringValue,
+  Mt as config,
+  Rt as createInterpolator,
+  At as easings,
+  je as inferTo,
+  ue as useIsomorphicLayoutEffect,
+  Xt as useSpring,
+  Bt as useSprings,
+  Zt as useTransition
+};