@blockbite/ui 1.0.0

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

@@ -0,0 +1,960 @@
+import { is as o, toArray as V, each as I, eachProp as K, flush as W, flushCalls as L, Globals as j, noop as mt, createStringInterpolator as Gt, useMemoOne as Lt, createInterpolator as $t, isEqual as x, getFluidValue as T, frameLoop as ut, hasFluidValue as O, addFluidObserver as ht, removeFluidObserver as wt, FluidValue as Ht, deprecateInterpolate as Jt, callFluidObservers as X, isAnimatedString as Vt, getFluidObservers as _t, easings as Kt } from "../../shared/dist/react-spring_shared.modern.js";
+import { useIsomorphicLayoutEffect as Ie } from "../../shared/dist/react-spring_shared.modern.js";
+import * as Rt from "react";
+import { useContext as Yt } from "react";
+import { getAnimatedType as st, setAnimated as Tt, getAnimated as E, getPayload as ct, AnimatedValue as Wt, AnimatedString as gt } from "../../animated/dist/react-spring_animated.modern.js";
+import { raf as w } from "../../rafz/dist/react-spring_rafz.modern.js";
+function q(t, ...e) {
+  return o.fun(t) ? t(...e) : t;
+}
+var $ = (t, e) => t === !0 || !!(e && t && (o.fun(t) ? t(e) : V(t).includes(e))), Ft = (t, e) => o.obj(t) ? e && t[e] : t, xt = (t, e) => t.default === !0 ? t[e] : t.default ? t.default[e] : void 0, Xt = (t) => t, Et = (t, e = Xt) => {
+  let i = Zt;
+  t.default && t.default !== !0 && (t = t.default, i = Object.keys(t));
+  const s = {};
+  for (const n of i) {
+    const a = e(t[n], n);
+    o.und(a) || (s[n] = a);
+  }
+  return s;
+}, Zt = [
+  "config",
+  "onProps",
+  "onStart",
+  "onChange",
+  "onPause",
+  "onResume",
+  "onRest"
+], te = {
+  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 ee(t) {
+  const e = {};
+  let i = 0;
+  if (K(t, (s, n) => {
+    te[n] || (e[n] = s, i++);
+  }), i)
+    return e;
+}
+function jt(t) {
+  const e = ee(t);
+  if (e) {
+    const i = { to: e };
+    return K(t, (s, n) => n in e || (i[n] = s)), i;
+  }
+  return { ...t };
+}
+function H(t) {
+  return t = T(t), o.arr(t) ? t.map(H) : Vt(t) ? j.createStringInterpolator({
+    range: [0, 1],
+    output: [t, t]
+  })(1) : t;
+}
+function nt(t) {
+  return o.fun(t) || o.arr(t) && o.obj(t[0]);
+}
+var ie = {
+  default: { tension: 170, friction: 26 }
+}, at = {
+  ...ie.default,
+  mass: 1,
+  damping: 1,
+  easing: Kt.linear,
+  clamp: !1
+}, se = class {
+  constructor() {
+    this.velocity = 0, Object.assign(this, at);
+  }
+};
+function ne(t, e, i) {
+  i && (i = { ...i }, yt(i, e), e = { ...i, ...e }), yt(t, e), Object.assign(t, e);
+  for (const h in at)
+    t[h] == null && (t[h] = at[h]);
+  let { frequency: s, damping: n } = t;
+  const { mass: a } = t;
+  return o.und(s) || (s < 0.01 && (s = 0.01), n < 0 && (n = 0), t.tension = Math.pow(2 * Math.PI / s, 2) * a, t.friction = 4 * Math.PI * n * a / s), t;
+}
+function yt(t, e) {
+  if (!o.und(e.decay))
+    t.duration = void 0;
+  else {
+    const i = !o.und(e.tension) || !o.und(e.friction);
+    (i || !o.und(e.frequency) || !o.und(e.damping) || !o.und(e.mass)) && (t.duration = void 0, t.decay = void 0), i && (t.frequency = void 0);
+  }
+}
+var vt = [], ae = class {
+  constructor() {
+    this.changed = !1, this.values = vt, this.toValues = null, this.fromValues = vt, this.config = new se(), this.immediate = !1;
+  }
+};
+function Mt(t, { key: e, props: i, defaultProps: s, state: n, actions: a }) {
+  return new Promise((h, l) => {
+    let f, r, _ = $(i.cancel ?? s?.cancel, e);
+    if (_)
+      m();
+    else {
+      o.und(i.pause) || (n.paused = $(i.pause, e));
+      let v = s?.pause;
+      v !== !0 && (v = n.paused || $(v, e)), f = q(i.delay || 0, e), v ? (n.resumeQueue.add(p), a.pause()) : (a.resume(), p());
+    }
+    function u() {
+      n.resumeQueue.add(p), n.timeouts.delete(r), r.cancel(), f = r.time - w.now();
+    }
+    function p() {
+      f > 0 && !j.skipAnimation ? (n.delayed = !0, r = w.setTimeout(m, f), n.pauseQueue.add(u), n.timeouts.add(r)) : m();
+    }
+    function m() {
+      n.delayed && (n.delayed = !1), n.pauseQueue.delete(u), n.timeouts.delete(r), t <= (n.cancelId || 0) && (_ = !0);
+      try {
+        a.start({ ...i, callId: t, cancel: _ }, h);
+      } catch (v) {
+        l(v);
+      }
+    }
+  });
+}
+var lt = (t, e) => e.length == 1 ? e[0] : e.some((i) => i.cancelled) ? U(t.get()) : e.every((i) => i.noop) ? Ot(t.get()) : C(
+  t.get(),
+  e.every((i) => i.finished)
+), Ot = (t) => ({
+  value: t,
+  noop: !0,
+  finished: !0,
+  cancelled: !1
+}), C = (t, e, i = !1) => ({
+  value: t,
+  finished: e,
+  cancelled: i
+}), U = (t) => ({
+  value: t,
+  cancelled: !0,
+  finished: !1
+});
+function Qt(t, e, i, s) {
+  const { callId: n, parentId: a, onRest: h } = e, { asyncTo: l, promise: f } = i;
+  return !a && t === l && !e.reset ? f : i.promise = (async () => {
+    i.asyncId = n, i.asyncTo = t;
+    const r = Et(
+      e,
+      (d, y) => (
+        // The `onRest` prop is only called when the `runAsync` promise is resolved.
+        y === "onRest" ? void 0 : d
+      )
+    );
+    let _, u;
+    const p = new Promise(
+      (d, y) => (_ = d, u = y)
+    ), m = (d) => {
+      const y = (
+        // The `cancel` prop or `stop` method was used.
+        n <= (i.cancelId || 0) && U(s) || // The async `to` prop was replaced.
+        n !== i.asyncId && C(s, !1)
+      );
+      if (y)
+        throw d.result = y, u(d), d;
+    }, v = (d, y) => {
+      const P = new pt(), g = new Pt();
+      return (async () => {
+        if (j.skipAnimation)
+          throw J(i), g.result = C(s, !1), u(g), g;
+        m(P);
+        const b = o.obj(d) ? { ...d } : { ...y, to: d };
+        b.parentId = n, K(r, (Q, S) => {
+          o.und(b[S]) && (b[S] = Q);
+        });
+        const R = await s.start(b);
+        return m(P), i.paused && await new Promise((Q) => {
+          i.resumeQueue.add(Q);
+        }), R;
+      })();
+    };
+    let c;
+    if (j.skipAnimation)
+      return J(i), C(s, !1);
+    try {
+      let d;
+      o.arr(t) ? d = (async (y) => {
+        for (const P of y)
+          await v(P);
+      })(t) : d = Promise.resolve(t(v, s.stop.bind(s))), await Promise.all([d.then(_), p]), c = C(s.get(), !0, !1);
+    } catch (d) {
+      if (d instanceof pt)
+        c = d.result;
+      else if (d instanceof Pt)
+        c = d.result;
+      else
+        throw d;
+    } finally {
+      n == i.asyncId && (i.asyncId = a, i.asyncTo = a ? l : void 0, i.promise = a ? f : void 0);
+    }
+    return o.fun(h) && w.batchedUpdates(() => {
+      h(c, s, s.item);
+    }), c;
+  })();
+}
+function J(t, e) {
+  W(t.timeouts, (i) => i.cancel()), t.pauseQueue.clear(), t.resumeQueue.clear(), t.asyncId = t.asyncTo = t.promise = void 0, e && (t.cancelId = e);
+}
+var pt = 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."
+    );
+  }
+}, Pt = class extends Error {
+  constructor() {
+    super("SkipAnimationSignal");
+  }
+}, ot = (t) => t instanceof dt, oe = 1, dt = class extends Ht {
+  constructor() {
+    super(...arguments), this.id = oe++, this._priority = 0;
+  }
+  get priority() {
+    return this._priority;
+  }
+  set priority(t) {
+    this._priority != t && (this._priority = t, this._onPriorityChange(t));
+  }
+  /** Get the current value */
+  get() {
+    const t = E(this);
+    return t && t.getValue();
+  }
+  /** Create a spring that maps our value to another value */
+  to(...t) {
+    return j.to(this, t);
+  }
+  /** @deprecated Use the `to` method instead. */
+  interpolate(...t) {
+    return Jt(), j.to(this, t);
+  }
+  toJSON() {
+    return this.get();
+  }
+  observerAdded(t) {
+    t == 1 && this._attach();
+  }
+  observerRemoved(t) {
+    t == 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(t, e = !1) {
+    X(this, {
+      type: "change",
+      parent: this,
+      value: t,
+      idle: e
+    });
+  }
+  /** Tell our children about our new priority */
+  _onPriorityChange(t) {
+    this.idle || ut.sort(this), X(this, {
+      type: "priority",
+      parent: this,
+      priority: t
+    });
+  }
+}, D = Symbol.for("SpringPhase"), qt = 1, Dt = 2, Nt = 4, et = (t) => (t[D] & qt) > 0, M = (t) => (t[D] & Dt) > 0, k = (t) => (t[D] & Nt) > 0, bt = (t, e) => e ? t[D] |= Dt | qt : t[D] &= -3, St = (t, e) => e ? t[D] |= Nt : t[D] &= -5, re = class extends dt {
+  constructor(t, e) {
+    if (super(), this.animation = new ae(), 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, !o.und(t) || !o.und(e)) {
+      const i = o.obj(t) ? { ...t } : { ...e, from: t };
+      o.und(i.default) && (i.default = !0), this.start(i);
+    }
+  }
+  /** Equals true when not advancing on each frame. */
+  get idle() {
+    return !(M(this) || this._state.asyncTo) || k(this);
+  }
+  get goal() {
+    return T(this.animation.to);
+  }
+  get velocity() {
+    const t = E(this);
+    return t instanceof Wt ? t.lastVelocity || 0 : t.getPayload().map((e) => e.lastVelocity || 0);
+  }
+  /**
+   * When true, this value has been animated at least once.
+   */
+  get hasAnimated() {
+    return et(this);
+  }
+  /**
+   * When true, this value has an unfinished animation,
+   * which is either active or paused.
+   */
+  get isAnimating() {
+    return M(this);
+  }
+  /**
+   * When true, all current and future animations are paused.
+   */
+  get isPaused() {
+    return k(this);
+  }
+  /**
+   *
+   *
+   */
+  get isDelayed() {
+    return this._state.delayed;
+  }
+  /** Advance the current animation by a number of milliseconds */
+  advance(t) {
+    let e = !0, i = !1;
+    const s = this.animation;
+    let { toValues: n } = s;
+    const { config: a } = s, h = ct(s.to);
+    !h && O(s.to) && (n = V(T(s.to))), s.values.forEach((r, _) => {
+      if (r.done)
+        return;
+      const u = (
+        // Animated strings always go from 0 to 1.
+        r.constructor == gt ? 1 : h ? h[_].lastPosition : n[_]
+      );
+      let p = s.immediate, m = u;
+      if (!p) {
+        if (m = r.lastPosition, a.tension <= 0) {
+          r.done = !0;
+          return;
+        }
+        let v = r.elapsedTime += t;
+        const c = s.fromValues[_], d = r.v0 != null ? r.v0 : r.v0 = o.arr(a.velocity) ? a.velocity[_] : a.velocity;
+        let y;
+        const P = a.precision || (c == u ? 5e-3 : Math.min(1, Math.abs(u - c) * 1e-3));
+        if (o.und(a.duration))
+          if (a.decay) {
+            const g = a.decay === !0 ? 0.998 : a.decay, b = Math.exp(-(1 - g) * v);
+            m = c + d / (1 - g) * (1 - b), p = Math.abs(r.lastPosition - m) <= P, y = d * b;
+          } else {
+            y = r.lastVelocity == null ? d : r.lastVelocity;
+            const g = a.restVelocity || P / 10, b = a.clamp ? 0 : a.bounce, R = !o.und(b), Q = c == u ? r.v0 > 0 : c < u;
+            let S, Y = !1;
+            const A = 1, z = Math.ceil(t / A);
+            for (let F = 0; F < z && (S = Math.abs(y) > g, !(!S && (p = Math.abs(u - m) <= P, p))); ++F) {
+              R && (Y = m == u || m > u == Q, Y && (y = -y * b, m = u));
+              const N = -a.tension * 1e-6 * (m - u), tt = -a.friction * 1e-3 * y, Bt = (N + tt) / a.mass;
+              y = y + Bt * A, m = m + y * A;
+            }
+          }
+        else {
+          let g = 1;
+          a.duration > 0 && (this._memoizedDuration !== a.duration && (this._memoizedDuration = a.duration, r.durationProgress > 0 && (r.elapsedTime = a.duration * r.durationProgress, v = r.elapsedTime += t)), g = (a.progress || 0) + v / this._memoizedDuration, g = g > 1 ? 1 : g < 0 ? 0 : g, r.durationProgress = g), m = c + a.easing(g) * (u - c), y = (m - r.lastPosition) / t, p = g == 1;
+        }
+        r.lastVelocity = y, Number.isNaN(m) && (console.warn("Got NaN while animating:", this), p = !0);
+      }
+      h && !h[_].done && (p = !1), p ? r.done = !0 : e = !1, r.setValue(m, a.round) && (i = !0);
+    });
+    const l = E(this), f = l.getValue();
+    if (e) {
+      const r = T(s.to);
+      (f !== r || i) && !a.decay ? (l.setValue(r), this._onChange(r)) : i && a.decay && this._onChange(f), this._stop();
+    } else i && this._onChange(f);
+  }
+  /** Set the current value, while stopping the current animation */
+  set(t) {
+    return w.batchedUpdates(() => {
+      this._stop(), this._focus(t), this._set(t);
+    }), 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 (M(this)) {
+      const { to: t, config: e } = this.animation;
+      w.batchedUpdates(() => {
+        this._onStart(), e.decay || this._set(t, !1), this._stop();
+      });
+    }
+    return this;
+  }
+  /** Push props into the pending queue. */
+  update(t) {
+    return (this.queue || (this.queue = [])).push(t), this;
+  }
+  start(t, e) {
+    let i;
+    return o.und(t) ? (i = this.queue || [], this.queue = []) : i = [o.obj(t) ? t : { ...e, to: t }], Promise.all(
+      i.map((s) => this._update(s))
+    ).then((s) => lt(this, s));
+  }
+  /**
+   * Stop the current animation, and cancel any delayed updates.
+   *
+   * Pass `true` to call `onRest` with `cancelled: true`.
+   */
+  stop(t) {
+    const { to: e } = this.animation;
+    return this._focus(this.get()), J(this._state, t && this._lastCallId), w.batchedUpdates(() => this._stop(e, t)), this;
+  }
+  /** Restart the animation. */
+  reset() {
+    this._update({ reset: !0 });
+  }
+  /** @internal */
+  eventObserved(t) {
+    t.type == "change" ? this._start() : t.type == "priority" && (this.priority = t.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(t) {
+    const e = this.key || "";
+    let { to: i, from: s } = t;
+    i = o.obj(i) ? i[e] : i, (i == null || nt(i)) && (i = void 0), s = o.obj(s) ? s[e] : s, s == null && (s = void 0);
+    const n = { to: i, from: s };
+    return et(this) || (t.reverse && ([i, s] = [s, i]), s = T(s), o.und(s) ? E(this) || this._set(i) : this._set(s)), n;
+  }
+  /** Every update is processed by this method before merging. */
+  _update({ ...t }, e) {
+    const { key: i, defaultProps: s } = this;
+    t.default && Object.assign(
+      s,
+      Et(
+        t,
+        (h, l) => /^on/.test(l) ? Ft(h, i) : h
+      )
+    ), It(this, t, "onProps"), G(this, "onProps", t, this);
+    const n = this._prepareNode(t);
+    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 Mt(++this._lastCallId, {
+      key: i,
+      props: t,
+      defaultProps: s,
+      state: a,
+      actions: {
+        pause: () => {
+          k(this) || (St(this, !0), L(a.pauseQueue), G(
+            this,
+            "onPause",
+            C(this, B(this, this.animation.to)),
+            this
+          ));
+        },
+        resume: () => {
+          k(this) && (St(this, !1), M(this) && this._resume(), L(a.resumeQueue), G(
+            this,
+            "onResume",
+            C(this, B(this, this.animation.to)),
+            this
+          ));
+        },
+        start: this._merge.bind(this, n)
+      }
+    }).then((h) => {
+      if (t.loop && h.finished && !(e && h.noop)) {
+        const l = Ut(t);
+        if (l)
+          return this._update(l, !0);
+      }
+      return h;
+    });
+  }
+  /** Merge props into the current animation */
+  _merge(t, e, i) {
+    if (e.cancel)
+      return this.stop(!0), i(U(this));
+    const s = !o.und(t.to), n = !o.und(t.from);
+    if (s || n)
+      if (e.callId > this._lastToId)
+        this._lastToId = e.callId;
+      else
+        return i(U(this));
+    const { key: a, defaultProps: h, animation: l } = this, { to: f, from: r } = l;
+    let { to: _ = f, from: u = r } = t;
+    n && !s && (!e.default || o.und(_)) && (_ = u), e.reverse && ([_, u] = [u, _]);
+    const p = !x(u, r);
+    p && (l.from = u), u = T(u);
+    const m = !x(_, f);
+    m && this._focus(_);
+    const v = nt(e.to), { config: c } = l, { decay: d, velocity: y } = c;
+    (s || n) && (c.velocity = 0), e.config && !v && ne(
+      c,
+      q(e.config, a),
+      // Avoid calling the same "config" prop twice.
+      e.config !== h.config ? q(h.config, a) : void 0
+    );
+    let P = E(this);
+    if (!P || o.und(_))
+      return i(C(this, !0));
+    const g = (
+      // 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(e.reset) ? n && !e.default : !o.und(u) && $(e.reset, a)
+    ), b = g ? u : this.get(), R = H(_), Q = o.num(R) || o.arr(R) || Vt(R), S = !v && (!Q || $(h.immediate || e.immediate, a));
+    if (m) {
+      const F = st(_);
+      if (F !== P.constructor)
+        if (S)
+          P = this._set(R);
+        else
+          throw Error(
+            `Cannot animate between ${P.constructor.name} and ${F.name}, as the "to" prop suggests`
+          );
+    }
+    const Y = P.constructor;
+    let A = O(_), z = !1;
+    if (!A) {
+      const F = g || !et(this) && p;
+      (m || F) && (z = x(H(b), R), A = !z), (!x(l.immediate, S) && !S || !x(c.decay, d) || !x(c.velocity, y)) && (A = !0);
+    }
+    if (z && M(this) && (l.changed && !g ? A = !0 : A || this._stop(f)), !v && ((A || O(f)) && (l.values = P.getPayload(), l.toValues = O(_) ? null : Y == gt ? [1] : V(R)), l.immediate != S && (l.immediate = S, !S && !g && this._set(f)), A)) {
+      const { onRest: F } = l;
+      I(ue, (tt) => It(this, e, tt));
+      const N = C(this, B(this, f));
+      L(this._pendingCalls, N), this._pendingCalls.add(i), l.changed && w.batchedUpdates(() => {
+        l.changed = !g, F?.(N, this), g ? q(h.onRest, N) : l.onStart?.(N, this);
+      });
+    }
+    g && this._set(b), v ? i(Qt(e.to, e, this._state, this)) : A ? this._start() : M(this) && !m ? this._pendingCalls.add(i) : i(Ot(b));
+  }
+  /** Update the `animation.to` value, which might be a `FluidValue` */
+  _focus(t) {
+    const e = this.animation;
+    t !== e.to && (_t(this) && this._detach(), e.to = t, _t(this) && this._attach());
+  }
+  _attach() {
+    let t = 0;
+    const { to: e } = this.animation;
+    O(e) && (ht(e, this), ot(e) && (t = e.priority + 1)), this.priority = t;
+  }
+  _detach() {
+    const { to: t } = this.animation;
+    O(t) && wt(t, this);
+  }
+  /**
+   * Update the current value from outside the frameloop,
+   * and return the `Animated` node.
+   */
+  _set(t, e = !0) {
+    const i = T(t);
+    if (!o.und(i)) {
+      const s = E(this);
+      if (!s || !x(i, s.getValue())) {
+        const n = st(i);
+        !s || s.constructor != n ? Tt(this, n.create(i)) : s.setValue(i), s && w.batchedUpdates(() => {
+          this._onChange(i, e);
+        });
+      }
+    }
+    return E(this);
+  }
+  _onStart() {
+    const t = this.animation;
+    t.changed || (t.changed = !0, G(
+      this,
+      "onStart",
+      C(this, B(this, t.to)),
+      this
+    ));
+  }
+  _onChange(t, e) {
+    e || (this._onStart(), q(this.animation.onChange, t, this)), q(this.defaultProps.onChange, t, this), super._onChange(t, e);
+  }
+  // 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 t = this.animation;
+    E(this).reset(T(t.to)), t.immediate || (t.fromValues = t.values.map((e) => e.lastPosition)), M(this) || (bt(this, !0), k(this) || this._resume());
+  }
+  _resume() {
+    j.skipAnimation ? this.finish() : ut.start(this);
+  }
+  /**
+   * Exit the frameloop and notify `onRest` listeners.
+   *
+   * Always wrap `_stop` calls with `batchedUpdates`.
+   */
+  _stop(t, e) {
+    if (M(this)) {
+      bt(this, !1);
+      const i = this.animation;
+      I(i.values, (n) => {
+        n.done = !0;
+      }), i.toValues && (i.onChange = i.onPause = i.onResume = void 0), X(this, {
+        type: "idle",
+        parent: this
+      });
+      const s = e ? U(this.get()) : C(this.get(), B(this, t ?? i.to));
+      L(this._pendingCalls, s), i.changed && (i.changed = !1, G(this, "onRest", s, this));
+    }
+  }
+};
+function B(t, e) {
+  const i = H(e), s = H(t.get());
+  return x(s, i);
+}
+function Ut(t, e = t.loop, i = t.to) {
+  const s = q(e);
+  if (s) {
+    const n = s !== !0 && jt(s), a = (n || t).reverse, h = !n || n.reset;
+    return rt({
+      ...t,
+      loop: e,
+      // 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 || nt(i) ? i : void 0,
+      // Ignore the "from" prop except on reset.
+      from: h ? t.from : void 0,
+      reset: h,
+      // The "loop" prop can return a "useSpring" props object to
+      // override any of the original props.
+      ...n
+    });
+  }
+}
+function rt(t) {
+  const { to: e, from: i } = t = jt(t), s = /* @__PURE__ */ new Set();
+  return o.obj(e) && At(e, s), o.obj(i) && At(i, s), t.keys = s.size ? Array.from(s) : null, t;
+}
+function At(t, e) {
+  K(t, (i, s) => i != null && e.add(s));
+}
+var ue = [
+  "onStart",
+  "onRest",
+  "onChange",
+  "onPause",
+  "onResume"
+];
+function It(t, e, i) {
+  t.animation[i] = e[i] !== xt(e, i) ? Ft(e[i], t.key) : void 0;
+}
+function G(t, e, ...i) {
+  t.animation[e]?.(...i), t.defaultProps[e]?.(...i);
+}
+var he = ["onStart", "onChange", "onRest"], ce = 1, be = class {
+  constructor(t, e) {
+    this.id = ce++, 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), e && (this._flush = e), t && this.start({ default: !0, ...t });
+  }
+  /**
+   * 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((t) => t.idle && !t.isDelayed && !t.isPaused);
+  }
+  get item() {
+    return this._item;
+  }
+  set item(t) {
+    this._item = t;
+  }
+  /** Get the current values of our springs */
+  get() {
+    const t = {};
+    return this.each((e, i) => t[i] = e.get()), t;
+  }
+  /** Set the current values without animating. */
+  set(t) {
+    for (const e in t) {
+      const i = t[e];
+      o.und(i) || this.springs[e].set(i);
+    }
+  }
+  /** Push an update onto the queue of each value. */
+  update(t) {
+    return t && this.queue.push(rt(t)), 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(t) {
+    let { queue: e } = this;
+    return t ? e = V(t).map(rt) : this.queue = [], this._flush ? this._flush(this, e) : (kt(this, e), le(this, e));
+  }
+  /** @internal */
+  stop(t, e) {
+    if (t !== !!t && (e = t), e) {
+      const i = this.springs;
+      I(V(e), (s) => i[s].stop(!!t));
+    } else
+      J(this._state, this._lastAsyncId), this.each((i) => i.stop(!!t));
+    return this;
+  }
+  /** Freeze the active animation in time */
+  pause(t) {
+    if (o.und(t))
+      this.start({ pause: !0 });
+    else {
+      const e = this.springs;
+      I(V(t), (i) => e[i].pause());
+    }
+    return this;
+  }
+  /** Resume the animation if paused. */
+  resume(t) {
+    if (o.und(t))
+      this.start({ pause: !1 });
+    else {
+      const e = this.springs;
+      I(V(t), (i) => e[i].resume());
+    }
+    return this;
+  }
+  /** Call a function once per spring value */
+  each(t) {
+    K(this.springs, t);
+  }
+  /** @internal Called at the end of every animation frame */
+  _onFrame() {
+    const { onStart: t, onChange: e, onRest: i } = this._events, s = this._active.size > 0, n = this._changed.size > 0;
+    (s && !this._started || n && !this._started) && (this._started = !0, W(t, ([l, f]) => {
+      f.value = this.get(), l(f, this, this._item);
+    }));
+    const a = !s && this._started, h = n || a && i.size ? this.get() : null;
+    n && e.size && W(e, ([l, f]) => {
+      f.value = h, l(f, this, this._item);
+    }), a && (this._started = !1, W(i, ([l, f]) => {
+      f.value = h, l(f, this, this._item);
+    }));
+  }
+  /** @internal */
+  eventObserved(t) {
+    if (t.type == "change")
+      this._changed.add(t.parent), t.idle || this._active.add(t.parent);
+    else if (t.type == "idle")
+      this._active.delete(t.parent);
+    else
+      return;
+    w.onFrame(this._onFrame);
+  }
+};
+function le(t, e) {
+  return Promise.all(e.map((i) => zt(t, i))).then(
+    (i) => lt(t, i)
+  );
+}
+async function zt(t, e, i) {
+  const { keys: s, to: n, from: a, loop: h, onRest: l, onResolve: f } = e, r = o.obj(e.default) && e.default;
+  h && (e.loop = !1), n === !1 && (e.to = null), a === !1 && (e.from = null);
+  const _ = o.arr(n) || o.fun(n) ? n : void 0;
+  _ ? (e.to = void 0, e.onRest = void 0, r && (r.onRest = void 0)) : I(he, (c) => {
+    const d = e[c];
+    if (o.fun(d)) {
+      const y = t._events[c];
+      e[c] = ({ finished: P, cancelled: g }) => {
+        const b = y.get(d);
+        b ? (P || (b.finished = !1), g && (b.cancelled = !0)) : y.set(d, {
+          value: null,
+          finished: P || !1,
+          cancelled: g || !1
+        });
+      }, r && (r[c] = e[c]);
+    }
+  });
+  const u = t._state;
+  e.pause === !u.paused ? (u.paused = e.pause, L(e.pause ? u.pauseQueue : u.resumeQueue)) : u.paused && (e.pause = !0);
+  const p = (s || Object.keys(t.springs)).map(
+    (c) => t.springs[c].start(e)
+  ), m = e.cancel === !0 || xt(e, "cancel") === !0;
+  (_ || m && u.asyncId) && p.push(
+    Mt(++t._lastAsyncId, {
+      props: e,
+      state: u,
+      actions: {
+        pause: mt,
+        resume: mt,
+        start(c, d) {
+          m ? (J(u, t._lastAsyncId), d(U(t))) : (c.onRest = l, d(
+            Qt(
+              _,
+              c,
+              u,
+              t
+            )
+          ));
+        }
+      }
+    })
+  ), u.paused && await new Promise((c) => {
+    u.resumeQueue.add(c);
+  });
+  const v = lt(t, await Promise.all(p));
+  if (h && v.finished && !(i && v.noop)) {
+    const c = Ut(e, h, n);
+    if (c)
+      return kt(t, [c]), zt(t, c, !0);
+  }
+  return f && w.batchedUpdates(() => f(v, t, t.item)), v;
+}
+function de(t, e) {
+  const i = new re();
+  return i.key = t, e && ht(i, e), i;
+}
+function fe(t, e, i) {
+  e.keys && I(e.keys, (s) => {
+    (t[s] || (t[s] = i(s)))._prepareNode(e);
+  });
+}
+function kt(t, e) {
+  I(e, (i) => {
+    fe(t.springs, i, (s) => de(s, t));
+  });
+}
+var ft = ({
+  children: t,
+  ...e
+}) => {
+  const i = Yt(Z), s = e.pause || !!i.pause, n = e.immediate || !!i.immediate;
+  e = Lt(() => ({ pause: s, immediate: n }), [s, n]);
+  const { Provider: a } = Z;
+  return /* @__PURE__ */ Rt.createElement(a, { value: e }, t);
+}, Z = me(ft, {});
+ft.Provider = Z.Provider;
+ft.Consumer = Z.Consumer;
+function me(t, e) {
+  return Object.assign(t, Rt.createContext(e)), t.Provider._context = t, t.Consumer._context = t, t;
+}
+var _e = class extends dt {
+  constructor(t, e) {
+    super(), this.source = t, this.idle = !0, this._active = /* @__PURE__ */ new Set(), this.calc = $t(...e);
+    const i = this._get(), s = st(i);
+    Tt(this, s.create(i));
+  }
+  advance(t) {
+    const e = this._get(), i = this.get();
+    x(e, i) || (E(this).setValue(e), this._onChange(e, this.idle)), !this.idle && Ct(this._active) && it(this);
+  }
+  _get() {
+    const t = o.arr(this.source) ? this.source.map(T) : V(T(this.source));
+    return this.calc(...t);
+  }
+  _start() {
+    this.idle && !Ct(this._active) && (this.idle = !1, I(ct(this), (t) => {
+      t.done = !1;
+    }), j.skipAnimation ? (w.batchedUpdates(() => this.advance()), it(this)) : ut.start(this));
+  }
+  // Observe our sources only when we're observed.
+  _attach() {
+    let t = 1;
+    I(V(this.source), (e) => {
+      O(e) && ht(e, this), ot(e) && (e.idle || this._active.add(e), t = Math.max(t, e.priority + 1));
+    }), this.priority = t, this._start();
+  }
+  // Stop observing our sources once we have no observers.
+  _detach() {
+    I(V(this.source), (t) => {
+      O(t) && wt(t, this);
+    }), this._active.clear(), it(this);
+  }
+  /** @internal */
+  eventObserved(t) {
+    t.type == "change" ? t.idle ? this.advance() : (this._active.add(t.parent), this._start()) : t.type == "idle" ? this._active.delete(t.parent) : t.type == "priority" && (this.priority = V(this.source).reduce(
+      (e, i) => Math.max(e, (ot(i) ? i.priority : 0) + 1),
+      0
+    ));
+  }
+};
+function ge(t) {
+  return t.idle !== !1;
+}
+function Ct(t) {
+  return !t.size || Array.from(t).every(ge);
+}
+function it(t) {
+  t.idle || (t.idle = !0, I(ct(t), (e) => {
+    e.done = !0;
+  }), X(t, {
+    type: "idle",
+    parent: t
+  }));
+}
+j.assign({
+  createStringInterpolator: Gt,
+  to: (t, e) => new _e(t, e)
+});
+export {
+  pt as BailSignal,
+  be as Controller,
+  dt as FrameValue,
+  j as Globals,
+  _e as Interpolation,
+  ft as SpringContext,
+  re as SpringValue,
+  ie as config,
+  $t as createInterpolator,
+  Kt as easings,
+  jt as inferTo,
+  Ie as useIsomorphicLayoutEffect
+};