rails-profiler 0.26.0 → 0.27.1

data/app/assets/builds/profiler-toolbar.js

@@ -1,5 +1,22 @@
 "use strict";
 (() => {
+  var __typeError = (msg) => {
+    throw TypeError(msg);
+  };
+  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+  var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+  var __privateWrapper = (obj, member, setter, getter) => ({
+    set _(value) {
+      __privateSet(obj, member, value, setter);
+    },
+    get _() {
+      return __privateGet(obj, member, getter);
+    }
+  });
+
   // node_modules/preact/dist/preact.module.js
   var n;
   var l;
@@ -184,25 +201,25 @@
     return "object" != typeof n2 || null == n2 || n2.__b > 0 ? n2 : d(n2) ? n2.map(q) : w({}, n2);
   }
   function B(u4, t3, i3, r3, o3, e3, f4, c3, s3) {
-    var a3, h3, v3, y3, w3, _3, m3, b = i3.props || p, k3 = t3.props, x2 = t3.type;
-    if ("svg" == x2 ? o3 = "http://www.w3.org/2000/svg" : "math" == x2 ? o3 = "http://www.w3.org/1998/Math/MathML" : o3 || (o3 = "http://www.w3.org/1999/xhtml"), null != e3) {
-      for (a3 = 0; a3 < e3.length; a3++) if ((w3 = e3[a3]) && "setAttribute" in w3 == !!x2 && (x2 ? w3.localName == x2 : 3 == w3.nodeType)) {
+    var a3, h3, v3, y3, w3, _3, m3, b = i3.props || p, k3 = t3.props, x3 = t3.type;
+    if ("svg" == x3 ? o3 = "http://www.w3.org/2000/svg" : "math" == x3 ? o3 = "http://www.w3.org/1998/Math/MathML" : o3 || (o3 = "http://www.w3.org/1999/xhtml"), null != e3) {
+      for (a3 = 0; a3 < e3.length; a3++) if ((w3 = e3[a3]) && "setAttribute" in w3 == !!x3 && (x3 ? w3.localName == x3 : 3 == w3.nodeType)) {
         u4 = w3, e3[a3] = null;
         break;
       }
     }
     if (null == u4) {
-      if (null == x2) return document.createTextNode(k3);
-      u4 = document.createElementNS(o3, x2, k3.is && k3), c3 && (l.__m && l.__m(t3, e3), c3 = false), e3 = null;
+      if (null == x3) return document.createTextNode(k3);
+      u4 = document.createElementNS(o3, x3, k3.is && k3), c3 && (l.__m && l.__m(t3, e3), c3 = false), e3 = null;
     }
-    if (null == x2) b === k3 || c3 && u4.data == k3 || (u4.data = k3);
+    if (null == x3) b === k3 || c3 && u4.data == k3 || (u4.data = k3);
     else {
       if (e3 = e3 && n.call(u4.childNodes), !c3 && null != e3) for (b = {}, a3 = 0; a3 < u4.attributes.length; a3++) b[(w3 = u4.attributes[a3]).name] = w3.value;
       for (a3 in b) w3 = b[a3], "dangerouslySetInnerHTML" == a3 ? v3 = w3 : "children" == a3 || a3 in k3 || "value" == a3 && "defaultValue" in k3 || "checked" == a3 && "defaultChecked" in k3 || F(u4, a3, null, w3, o3);
       for (a3 in k3) w3 = k3[a3], "children" == a3 ? y3 = w3 : "dangerouslySetInnerHTML" == a3 ? h3 = w3 : "value" == a3 ? _3 = w3 : "checked" == a3 ? m3 = w3 : c3 && "function" != typeof w3 || b[a3] === w3 || F(u4, a3, w3, b[a3], o3);
       if (h3) c3 || v3 && (h3.__html == v3.__html || h3.__html == u4.innerHTML) || (u4.innerHTML = h3.__html), t3.__k = [];
-      else if (v3 && (u4.innerHTML = ""), P("template" == t3.type ? u4.content : u4, d(y3) ? y3 : [y3], t3, i3, r3, "foreignObject" == x2 ? "http://www.w3.org/1999/xhtml" : o3, e3, f4, e3 ? e3[0] : i3.__k && S(i3, 0), c3, s3), null != e3) for (a3 = e3.length; a3--; ) g(e3[a3]);
-      c3 || (a3 = "value", "progress" == x2 && null == _3 ? u4.removeAttribute("value") : null != _3 && (_3 !== u4[a3] || "progress" == x2 && !_3 || "option" == x2 && _3 != b[a3]) && F(u4, a3, _3, b[a3], o3), a3 = "checked", null != m3 && m3 != u4[a3] && F(u4, a3, m3, b[a3], o3));
+      else if (v3 && (u4.innerHTML = ""), P("template" == t3.type ? u4.content : u4, d(y3) ? y3 : [y3], t3, i3, r3, "foreignObject" == x3 ? "http://www.w3.org/1999/xhtml" : o3, e3, f4, e3 ? e3[0] : i3.__k && S(i3, 0), c3, s3), null != e3) for (a3 = e3.length; a3--; ) g(e3[a3]);
+      c3 || (a3 = "value", "progress" == x3 && null == _3 ? u4.removeAttribute("value") : null != _3 && (_3 !== u4[a3] || "progress" == x3 && !_3 || "option" == x3 && _3 != b[a3]) && F(u4, a3, _3, b[a3], o3), a3 = "checked", null != m3 && m3 != u4[a3] && F(u4, a3, m3, b[a3], o3));
     }
     return u4;
   }
@@ -236,6 +253,29 @@
     var r3, o3, e3, f4;
     t3 == document && (t3 = document.documentElement), l.__ && l.__(u4, t3), o3 = (r3 = "function" == typeof i3) ? null : i3 && i3.__k || t3.__k, e3 = [], f4 = [], z(t3, u4 = (!r3 && i3 || t3).__k = _(k, null, [u4]), o3 || p, p, t3.namespaceURI, !r3 && i3 ? [i3] : o3 ? null : t3.firstChild ? n.call(t3.childNodes) : null, e3, !r3 && i3 ? i3 : o3 ? o3.__e : t3.firstChild, r3, f4), V(e3, u4, f4);
   }
+  function R(n2) {
+    function l3(n3) {
+      var u4, t3;
+      return this.getChildContext || (u4 = /* @__PURE__ */ new Set(), (t3 = {})[l3.__c] = this, this.getChildContext = function() {
+        return t3;
+      }, this.componentWillUnmount = function() {
+        u4 = null;
+      }, this.shouldComponentUpdate = function(n4) {
+        this.props.value != n4.value && u4.forEach(function(n5) {
+          n5.__e = true, $(n5);
+        });
+      }, this.sub = function(n4) {
+        u4.add(n4);
+        var l4 = n4.componentWillUnmount;
+        n4.componentWillUnmount = function() {
+          u4 && u4.delete(n4), l4 && l4.call(n4);
+        };
+      }), n3.children;
+    }
+    return l3.__c = "__cC" + h++, l3.__ = n2, l3.Provider = l3.__l = (l3.Consumer = function(n3, l4) {
+      return n3.children(l4);
+    }).contextType = l3, l3;
+  }
   n = v.slice, l = { __e: function(n2, l3, u4, t3) {
     for (var i3, r3, o3; l3 = l3.__; ) if ((i3 = l3.__c) && !i3.__) try {
       if ((r3 = i3.constructor) && null != r3.getDerivedStateFromError && (i3.setState(r3.getDerivedStateFromError(n2)), o3 = i3.__d), null != i3.componentDidCatch && (i3.componentDidCatch(n2, t3 || {}), o3 = i3.__d), o3) return i3.__E = i3;
@@ -327,6 +367,15 @@
     var u4 = p2(t2++, 7);
     return C2(u4.__H, r3) && (u4.__ = n2(), u4.__H = r3, u4.__h = n2), u4.__;
   }
+  function q2(n2, t3) {
+    return o2 = 8, T2(function() {
+      return n2;
+    }, t3);
+  }
+  function x2(n2) {
+    var u4 = r2.context[n2.__c], i3 = p2(t2++, 9);
+    return i3.c = n2, u4 ? (null == i3.__ && (i3.__ = true, u4.sub(r2)), u4.props.value) : n2.__;
+  }
   function j2() {
     for (var n2; n2 = f2.shift(); ) {
       var t3 = n2.__H;
@@ -337,69 +386,2575 @@
       }
     }
   }
-  c2.__b = function(n2) {
-    r2 = null, e2 && e2(n2);
-  }, c2.__ = function(n2, t3) {
-    n2 && t3.__k && t3.__k.__m && (n2.__m = t3.__k.__m), s2 && s2(n2, t3);
-  }, c2.__r = function(n2) {
-    a2 && a2(n2), t2 = 0;
-    var i3 = (r2 = n2.__c).__H;
-    i3 && (u2 === r2 ? (i3.__h = [], r2.__h = [], i3.__.some(function(n3) {
-      n3.__N && (n3.__ = n3.__N), n3.u = n3.__N = void 0;
-    })) : (i3.__h.some(z2), i3.__h.some(B2), i3.__h = [], t2 = 0)), u2 = r2;
-  }, c2.diffed = function(n2) {
-    v2 && v2(n2);
-    var t3 = n2.__c;
-    t3 && t3.__H && (t3.__H.__h.length && (1 !== f2.push(t3) && i2 === c2.requestAnimationFrame || ((i2 = c2.requestAnimationFrame) || w2)(j2)), t3.__H.__.some(function(n3) {
-      n3.u && (n3.__H = n3.u), n3.u = void 0;
-    })), u2 = r2 = null;
-  }, c2.__c = function(n2, t3) {
-    t3.some(function(n3) {
-      try {
-        n3.__h.some(z2), n3.__h = n3.__h.filter(function(n4) {
-          return !n4.__ || B2(n4);
+  c2.__b = function(n2) {
+    r2 = null, e2 && e2(n2);
+  }, c2.__ = function(n2, t3) {
+    n2 && t3.__k && t3.__k.__m && (n2.__m = t3.__k.__m), s2 && s2(n2, t3);
+  }, c2.__r = function(n2) {
+    a2 && a2(n2), t2 = 0;
+    var i3 = (r2 = n2.__c).__H;
+    i3 && (u2 === r2 ? (i3.__h = [], r2.__h = [], i3.__.some(function(n3) {
+      n3.__N && (n3.__ = n3.__N), n3.u = n3.__N = void 0;
+    })) : (i3.__h.some(z2), i3.__h.some(B2), i3.__h = [], t2 = 0)), u2 = r2;
+  }, c2.diffed = function(n2) {
+    v2 && v2(n2);
+    var t3 = n2.__c;
+    t3 && t3.__H && (t3.__H.__h.length && (1 !== f2.push(t3) && i2 === c2.requestAnimationFrame || ((i2 = c2.requestAnimationFrame) || w2)(j2)), t3.__H.__.some(function(n3) {
+      n3.u && (n3.__H = n3.u), n3.u = void 0;
+    })), u2 = r2 = null;
+  }, c2.__c = function(n2, t3) {
+    t3.some(function(n3) {
+      try {
+        n3.__h.some(z2), n3.__h = n3.__h.filter(function(n4) {
+          return !n4.__ || B2(n4);
+        });
+      } catch (r3) {
+        t3.some(function(n4) {
+          n4.__h && (n4.__h = []);
+        }), t3 = [], c2.__e(r3, n3.__v);
+      }
+    }), l2 && l2(n2, t3);
+  }, c2.unmount = function(n2) {
+    m2 && m2(n2);
+    var t3, r3 = n2.__c;
+    r3 && r3.__H && (r3.__H.__.some(function(n3) {
+      try {
+        z2(n3);
+      } catch (n4) {
+        t3 = n4;
+      }
+    }), r3.__H = void 0, t3 && c2.__e(t3, r3.__v));
+  };
+  var k2 = "function" == typeof requestAnimationFrame;
+  function w2(n2) {
+    var t3, r3 = function() {
+      clearTimeout(u4), k2 && cancelAnimationFrame(t3), setTimeout(n2);
+    }, u4 = setTimeout(r3, 35);
+    k2 && (t3 = requestAnimationFrame(r3));
+  }
+  function z2(n2) {
+    var t3 = r2, u4 = n2.__c;
+    "function" == typeof u4 && (n2.__c = void 0, u4()), r2 = t3;
+  }
+  function B2(n2) {
+    var t3 = r2;
+    n2.__c = n2.__(), r2 = t3;
+  }
+  function C2(n2, t3) {
+    return !n2 || n2.length !== t3.length || t3.some(function(t4, r3) {
+      return t4 !== n2[r3];
+    });
+  }
+  function D2(n2, t3) {
+    return "function" == typeof t3 ? t3(n2) : t3;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/subscribable.js
+  var Subscribable = class {
+    constructor() {
+      this.listeners = /* @__PURE__ */ new Set();
+      this.subscribe = this.subscribe.bind(this);
+    }
+    subscribe(listener) {
+      this.listeners.add(listener);
+      this.onSubscribe();
+      return () => {
+        this.listeners.delete(listener);
+        this.onUnsubscribe();
+      };
+    }
+    hasListeners() {
+      return this.listeners.size > 0;
+    }
+    onSubscribe() {
+    }
+    onUnsubscribe() {
+    }
+  };
+
+  // node_modules/@tanstack/query-core/build/modern/focusManager.js
+  var _focused, _cleanup, _setup, _a;
+  var FocusManager = (_a = class extends Subscribable {
+    constructor() {
+      super();
+      __privateAdd(this, _focused);
+      __privateAdd(this, _cleanup);
+      __privateAdd(this, _setup);
+      __privateSet(this, _setup, (onFocus) => {
+        if (typeof window !== "undefined" && window.addEventListener) {
+          const listener = () => onFocus();
+          window.addEventListener("visibilitychange", listener, false);
+          return () => {
+            window.removeEventListener("visibilitychange", listener);
+          };
+        }
+        return;
+      });
+    }
+    onSubscribe() {
+      if (!__privateGet(this, _cleanup)) {
+        this.setEventListener(__privateGet(this, _setup));
+      }
+    }
+    onUnsubscribe() {
+      var _a11;
+      if (!this.hasListeners()) {
+        (_a11 = __privateGet(this, _cleanup)) == null ? void 0 : _a11.call(this);
+        __privateSet(this, _cleanup, void 0);
+      }
+    }
+    setEventListener(setup) {
+      var _a11;
+      __privateSet(this, _setup, setup);
+      (_a11 = __privateGet(this, _cleanup)) == null ? void 0 : _a11.call(this);
+      __privateSet(this, _cleanup, setup((focused) => {
+        if (typeof focused === "boolean") {
+          this.setFocused(focused);
+        } else {
+          this.onFocus();
+        }
+      }));
+    }
+    setFocused(focused) {
+      const changed = __privateGet(this, _focused) !== focused;
+      if (changed) {
+        __privateSet(this, _focused, focused);
+        this.onFocus();
+      }
+    }
+    onFocus() {
+      const isFocused = this.isFocused();
+      this.listeners.forEach((listener) => {
+        listener(isFocused);
+      });
+    }
+    isFocused() {
+      if (typeof __privateGet(this, _focused) === "boolean") {
+        return __privateGet(this, _focused);
+      }
+      return globalThis.document?.visibilityState !== "hidden";
+    }
+  }, _focused = new WeakMap(), _cleanup = new WeakMap(), _setup = new WeakMap(), _a);
+  var focusManager = new FocusManager();
+
+  // node_modules/@tanstack/query-core/build/modern/timeoutManager.js
+  var defaultTimeoutProvider = {
+    // We need the wrapper function syntax below instead of direct references to
+    // global setTimeout etc.
+    //
+    // BAD: `setTimeout: setTimeout`
+    // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`
+    //
+    // If we use direct references here, then anything that wants to spy on or
+    // replace the global setTimeout (like tests) won't work since we'll already
+    // have a hard reference to the original implementation at the time when this
+    // file was imported.
+    setTimeout: (callback, delay) => setTimeout(callback, delay),
+    clearTimeout: (timeoutId) => clearTimeout(timeoutId),
+    setInterval: (callback, delay) => setInterval(callback, delay),
+    clearInterval: (intervalId) => clearInterval(intervalId)
+  };
+  var _provider, _providerCalled, _a2;
+  var TimeoutManager = (_a2 = class {
+    constructor() {
+      // We cannot have TimeoutManager<T> as we must instantiate it with a concrete
+      // type at app boot; and if we leave that type, then any new timer provider
+      // would need to support the default provider's concrete timer ID, which is
+      // infeasible across environments.
+      //
+      // We settle for type safety for the TimeoutProvider type, and accept that
+      // this class is unsafe internally to allow for extension.
+      __privateAdd(this, _provider, defaultTimeoutProvider);
+      __privateAdd(this, _providerCalled, false);
+    }
+    setTimeoutProvider(provider) {
+      if (true) {
+        if (__privateGet(this, _providerCalled) && provider !== __privateGet(this, _provider)) {
+          console.error(
+            `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,
+            { previous: __privateGet(this, _provider), provider }
+          );
+        }
+      }
+      __privateSet(this, _provider, provider);
+      if (true) {
+        __privateSet(this, _providerCalled, false);
+      }
+    }
+    setTimeout(callback, delay) {
+      if (true) {
+        __privateSet(this, _providerCalled, true);
+      }
+      return __privateGet(this, _provider).setTimeout(callback, delay);
+    }
+    clearTimeout(timeoutId) {
+      __privateGet(this, _provider).clearTimeout(timeoutId);
+    }
+    setInterval(callback, delay) {
+      if (true) {
+        __privateSet(this, _providerCalled, true);
+      }
+      return __privateGet(this, _provider).setInterval(callback, delay);
+    }
+    clearInterval(intervalId) {
+      __privateGet(this, _provider).clearInterval(intervalId);
+    }
+  }, _provider = new WeakMap(), _providerCalled = new WeakMap(), _a2);
+  var timeoutManager = new TimeoutManager();
+  function systemSetTimeoutZero(callback) {
+    setTimeout(callback, 0);
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/utils.js
+  var isServer = typeof window === "undefined" || "Deno" in globalThis;
+  function noop() {
+  }
+  function functionalUpdate(updater, input) {
+    return typeof updater === "function" ? updater(input) : updater;
+  }
+  function isValidTimeout(value) {
+    return typeof value === "number" && value >= 0 && value !== Infinity;
+  }
+  function timeUntilStale(updatedAt, staleTime) {
+    return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+  }
+  function resolveStaleTime(staleTime, query) {
+    return typeof staleTime === "function" ? staleTime(query) : staleTime;
+  }
+  function resolveQueryBoolean(option, query) {
+    return typeof option === "function" ? option(query) : option;
+  }
+  function matchQuery(filters, query) {
+    const {
+      type = "all",
+      exact,
+      fetchStatus,
+      predicate,
+      queryKey,
+      stale
+    } = filters;
+    if (queryKey) {
+      if (exact) {
+        if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
+          return false;
+        }
+      } else if (!partialMatchKey(query.queryKey, queryKey)) {
+        return false;
+      }
+    }
+    if (type !== "all") {
+      const isActive = query.isActive();
+      if (type === "active" && !isActive) {
+        return false;
+      }
+      if (type === "inactive" && isActive) {
+        return false;
+      }
+    }
+    if (typeof stale === "boolean" && query.isStale() !== stale) {
+      return false;
+    }
+    if (fetchStatus && fetchStatus !== query.state.fetchStatus) {
+      return false;
+    }
+    if (predicate && !predicate(query)) {
+      return false;
+    }
+    return true;
+  }
+  function matchMutation(filters, mutation) {
+    const { exact, status, predicate, mutationKey } = filters;
+    if (mutationKey) {
+      if (!mutation.options.mutationKey) {
+        return false;
+      }
+      if (exact) {
+        if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) {
+          return false;
+        }
+      } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
+        return false;
+      }
+    }
+    if (status && mutation.state.status !== status) {
+      return false;
+    }
+    if (predicate && !predicate(mutation)) {
+      return false;
+    }
+    return true;
+  }
+  function hashQueryKeyByOptions(queryKey, options) {
+    const hashFn = options?.queryKeyHashFn || hashKey;
+    return hashFn(queryKey);
+  }
+  function hashKey(queryKey) {
+    return JSON.stringify(
+      queryKey,
+      (_3, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+        result[key] = val[key];
+        return result;
+      }, {}) : val
+    );
+  }
+  function partialMatchKey(a3, b) {
+    if (a3 === b) {
+      return true;
+    }
+    if (typeof a3 !== typeof b) {
+      return false;
+    }
+    if (a3 && b && typeof a3 === "object" && typeof b === "object") {
+      return Object.keys(b).every((key) => partialMatchKey(a3[key], b[key]));
+    }
+    return false;
+  }
+  var hasOwn = Object.prototype.hasOwnProperty;
+  function replaceEqualDeep(a3, b, depth = 0) {
+    if (a3 === b) {
+      return a3;
+    }
+    if (depth > 500) return b;
+    const array = isPlainArray(a3) && isPlainArray(b);
+    if (!array && !(isPlainObject(a3) && isPlainObject(b))) return b;
+    const aItems = array ? a3 : Object.keys(a3);
+    const aSize = aItems.length;
+    const bItems = array ? b : Object.keys(b);
+    const bSize = bItems.length;
+    const copy = array ? new Array(bSize) : {};
+    let equalItems = 0;
+    for (let i3 = 0; i3 < bSize; i3++) {
+      const key = array ? i3 : bItems[i3];
+      const aItem = a3[key];
+      const bItem = b[key];
+      if (aItem === bItem) {
+        copy[key] = aItem;
+        if (array ? i3 < aSize : hasOwn.call(a3, key)) equalItems++;
+        continue;
+      }
+      if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
+        copy[key] = bItem;
+        continue;
+      }
+      const v3 = replaceEqualDeep(aItem, bItem, depth + 1);
+      copy[key] = v3;
+      if (v3 === aItem) equalItems++;
+    }
+    return aSize === bSize && equalItems === aSize ? a3 : copy;
+  }
+  function shallowEqualObjects(a3, b) {
+    if (!b || Object.keys(a3).length !== Object.keys(b).length) {
+      return false;
+    }
+    for (const key in a3) {
+      if (a3[key] !== b[key]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function isPlainArray(value) {
+    return Array.isArray(value) && value.length === Object.keys(value).length;
+  }
+  function isPlainObject(o3) {
+    if (!hasObjectPrototype(o3)) {
+      return false;
+    }
+    const ctor = o3.constructor;
+    if (ctor === void 0) {
+      return true;
+    }
+    const prot = ctor.prototype;
+    if (!hasObjectPrototype(prot)) {
+      return false;
+    }
+    if (!prot.hasOwnProperty("isPrototypeOf")) {
+      return false;
+    }
+    if (Object.getPrototypeOf(o3) !== Object.prototype) {
+      return false;
+    }
+    return true;
+  }
+  function hasObjectPrototype(o3) {
+    return Object.prototype.toString.call(o3) === "[object Object]";
+  }
+  function sleep(timeout) {
+    return new Promise((resolve) => {
+      timeoutManager.setTimeout(resolve, timeout);
+    });
+  }
+  function replaceData(prevData, data, options) {
+    if (typeof options.structuralSharing === "function") {
+      return options.structuralSharing(prevData, data);
+    } else if (options.structuralSharing !== false) {
+      if (true) {
+        try {
+          return replaceEqualDeep(prevData, data);
+        } catch (error) {
+          console.error(
+            `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}`
+          );
+          throw error;
+        }
+      }
+      return replaceEqualDeep(prevData, data);
+    }
+    return data;
+  }
+  function addToEnd(items, item, max = 0) {
+    const newItems = [...items, item];
+    return max && newItems.length > max ? newItems.slice(1) : newItems;
+  }
+  function addToStart(items, item, max = 0) {
+    const newItems = [item, ...items];
+    return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
+  }
+  var skipToken = /* @__PURE__ */ Symbol();
+  function ensureQueryFn(options, fetchOptions) {
+    if (true) {
+      if (options.queryFn === skipToken) {
+        console.error(
+          `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'`
+        );
+      }
+    }
+    if (!options.queryFn && fetchOptions?.initialPromise) {
+      return () => fetchOptions.initialPromise;
+    }
+    if (!options.queryFn || options.queryFn === skipToken) {
+      return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`));
+    }
+    return options.queryFn;
+  }
+  function shouldThrowError(throwOnError, params) {
+    if (typeof throwOnError === "function") {
+      return throwOnError(...params);
+    }
+    return !!throwOnError;
+  }
+  function addConsumeAwareSignal(object, getSignal, onCancelled) {
+    let consumed = false;
+    let signal;
+    Object.defineProperty(object, "signal", {
+      enumerable: true,
+      get: () => {
+        signal ?? (signal = getSignal());
+        if (consumed) {
+          return signal;
+        }
+        consumed = true;
+        if (signal.aborted) {
+          onCancelled();
+        } else {
+          signal.addEventListener("abort", onCancelled, { once: true });
+        }
+        return signal;
+      }
+    });
+    return object;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/environmentManager.js
+  var environmentManager = /* @__PURE__ */ (() => {
+    let isServerFn = () => isServer;
+    return {
+      /**
+       * Returns whether the current runtime should be treated as a server environment.
+       */
+      isServer() {
+        return isServerFn();
+      },
+      /**
+       * Overrides the server check globally.
+       */
+      setIsServer(isServerValue) {
+        isServerFn = isServerValue;
+      }
+    };
+  })();
+
+  // node_modules/@tanstack/query-core/build/modern/thenable.js
+  function pendingThenable() {
+    let resolve;
+    let reject;
+    const thenable = new Promise((_resolve, _reject) => {
+      resolve = _resolve;
+      reject = _reject;
+    });
+    thenable.status = "pending";
+    thenable.catch(() => {
+    });
+    function finalize(data) {
+      Object.assign(thenable, data);
+      delete thenable.resolve;
+      delete thenable.reject;
+    }
+    thenable.resolve = (value) => {
+      finalize({
+        status: "fulfilled",
+        value
+      });
+      resolve(value);
+    };
+    thenable.reject = (reason) => {
+      finalize({
+        status: "rejected",
+        reason
+      });
+      reject(reason);
+    };
+    return thenable;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/notifyManager.js
+  var defaultScheduler = systemSetTimeoutZero;
+  function createNotifyManager() {
+    let queue = [];
+    let transactions = 0;
+    let notifyFn = (callback) => {
+      callback();
+    };
+    let batchNotifyFn = (callback) => {
+      callback();
+    };
+    let scheduleFn = defaultScheduler;
+    const schedule = (callback) => {
+      if (transactions) {
+        queue.push(callback);
+      } else {
+        scheduleFn(() => {
+          notifyFn(callback);
+        });
+      }
+    };
+    const flush = () => {
+      const originalQueue = queue;
+      queue = [];
+      if (originalQueue.length) {
+        scheduleFn(() => {
+          batchNotifyFn(() => {
+            originalQueue.forEach((callback) => {
+              notifyFn(callback);
+            });
+          });
+        });
+      }
+    };
+    return {
+      batch: (callback) => {
+        let result;
+        transactions++;
+        try {
+          result = callback();
+        } finally {
+          transactions--;
+          if (!transactions) {
+            flush();
+          }
+        }
+        return result;
+      },
+      /**
+       * All calls to the wrapped function will be batched.
+       */
+      batchCalls: (callback) => {
+        return (...args) => {
+          schedule(() => {
+            callback(...args);
+          });
+        };
+      },
+      schedule,
+      /**
+       * Use this method to set a custom notify function.
+       * This can be used to for example wrap notifications with `React.act` while running tests.
+       */
+      setNotifyFunction: (fn) => {
+        notifyFn = fn;
+      },
+      /**
+       * Use this method to set a custom function to batch notifications together into a single tick.
+       * By default React Query will use the batch function provided by ReactDOM or React Native.
+       */
+      setBatchNotifyFunction: (fn) => {
+        batchNotifyFn = fn;
+      },
+      setScheduler: (fn) => {
+        scheduleFn = fn;
+      }
+    };
+  }
+  var notifyManager = createNotifyManager();
+
+  // node_modules/@tanstack/query-core/build/modern/onlineManager.js
+  var _online, _cleanup2, _setup2, _a3;
+  var OnlineManager = (_a3 = class extends Subscribable {
+    constructor() {
+      super();
+      __privateAdd(this, _online, true);
+      __privateAdd(this, _cleanup2);
+      __privateAdd(this, _setup2);
+      __privateSet(this, _setup2, (onOnline) => {
+        if (typeof window !== "undefined" && window.addEventListener) {
+          const onlineListener = () => onOnline(true);
+          const offlineListener = () => onOnline(false);
+          window.addEventListener("online", onlineListener, false);
+          window.addEventListener("offline", offlineListener, false);
+          return () => {
+            window.removeEventListener("online", onlineListener);
+            window.removeEventListener("offline", offlineListener);
+          };
+        }
+        return;
+      });
+    }
+    onSubscribe() {
+      if (!__privateGet(this, _cleanup2)) {
+        this.setEventListener(__privateGet(this, _setup2));
+      }
+    }
+    onUnsubscribe() {
+      var _a11;
+      if (!this.hasListeners()) {
+        (_a11 = __privateGet(this, _cleanup2)) == null ? void 0 : _a11.call(this);
+        __privateSet(this, _cleanup2, void 0);
+      }
+    }
+    setEventListener(setup) {
+      var _a11;
+      __privateSet(this, _setup2, setup);
+      (_a11 = __privateGet(this, _cleanup2)) == null ? void 0 : _a11.call(this);
+      __privateSet(this, _cleanup2, setup(this.setOnline.bind(this)));
+    }
+    setOnline(online) {
+      const changed = __privateGet(this, _online) !== online;
+      if (changed) {
+        __privateSet(this, _online, online);
+        this.listeners.forEach((listener) => {
+          listener(online);
+        });
+      }
+    }
+    isOnline() {
+      return __privateGet(this, _online);
+    }
+  }, _online = new WeakMap(), _cleanup2 = new WeakMap(), _setup2 = new WeakMap(), _a3);
+  var onlineManager = new OnlineManager();
+
+  // node_modules/@tanstack/query-core/build/modern/retryer.js
+  function defaultRetryDelay(failureCount) {
+    return Math.min(1e3 * 2 ** failureCount, 3e4);
+  }
+  function canFetch(networkMode) {
+    return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true;
+  }
+  var CancelledError = class extends Error {
+    constructor(options) {
+      super("CancelledError");
+      this.revert = options?.revert;
+      this.silent = options?.silent;
+    }
+  };
+  function createRetryer(config) {
+    let isRetryCancelled = false;
+    let failureCount = 0;
+    let continueFn;
+    const thenable = pendingThenable();
+    const isResolved = () => thenable.status !== "pending";
+    const cancel = (cancelOptions) => {
+      if (!isResolved()) {
+        const error = new CancelledError(cancelOptions);
+        reject(error);
+        config.onCancel?.(error);
+      }
+    };
+    const cancelRetry = () => {
+      isRetryCancelled = true;
+    };
+    const continueRetry = () => {
+      isRetryCancelled = false;
+    };
+    const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun();
+    const canStart = () => canFetch(config.networkMode) && config.canRun();
+    const resolve = (value) => {
+      if (!isResolved()) {
+        continueFn?.();
+        thenable.resolve(value);
+      }
+    };
+    const reject = (value) => {
+      if (!isResolved()) {
+        continueFn?.();
+        thenable.reject(value);
+      }
+    };
+    const pause = () => {
+      return new Promise((continueResolve) => {
+        continueFn = (value) => {
+          if (isResolved() || canContinue()) {
+            continueResolve(value);
+          }
+        };
+        config.onPause?.();
+      }).then(() => {
+        continueFn = void 0;
+        if (!isResolved()) {
+          config.onContinue?.();
+        }
+      });
+    };
+    const run = () => {
+      if (isResolved()) {
+        return;
+      }
+      let promiseOrValue;
+      const initialPromise = failureCount === 0 ? config.initialPromise : void 0;
+      try {
+        promiseOrValue = initialPromise ?? config.fn();
+      } catch (error) {
+        promiseOrValue = Promise.reject(error);
+      }
+      Promise.resolve(promiseOrValue).then(resolve).catch((error) => {
+        if (isResolved()) {
+          return;
+        }
+        const retry = config.retry ?? (environmentManager.isServer() ? 0 : 3);
+        const retryDelay = config.retryDelay ?? defaultRetryDelay;
+        const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay;
+        const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error);
+        if (isRetryCancelled || !shouldRetry) {
+          reject(error);
+          return;
+        }
+        failureCount++;
+        config.onFail?.(failureCount, error);
+        sleep(delay).then(() => {
+          return canContinue() ? void 0 : pause();
+        }).then(() => {
+          if (isRetryCancelled) {
+            reject(error);
+          } else {
+            run();
+          }
+        });
+      });
+    };
+    return {
+      promise: thenable,
+      status: () => thenable.status,
+      cancel,
+      continue: () => {
+        continueFn?.();
+        return thenable;
+      },
+      cancelRetry,
+      continueRetry,
+      canStart,
+      start: () => {
+        if (canStart()) {
+          run();
+        } else {
+          pause().then(run);
+        }
+        return thenable;
+      }
+    };
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/removable.js
+  var _gcTimeout, _a4;
+  var Removable = (_a4 = class {
+    constructor() {
+      __privateAdd(this, _gcTimeout);
+    }
+    destroy() {
+      this.clearGcTimeout();
+    }
+    scheduleGc() {
+      this.clearGcTimeout();
+      if (isValidTimeout(this.gcTime)) {
+        __privateSet(this, _gcTimeout, timeoutManager.setTimeout(() => {
+          this.optionalRemove();
+        }, this.gcTime));
+      }
+    }
+    updateGcTime(newGcTime) {
+      this.gcTime = Math.max(
+        this.gcTime || 0,
+        newGcTime ?? (environmentManager.isServer() ? Infinity : 5 * 60 * 1e3)
+      );
+    }
+    clearGcTimeout() {
+      if (__privateGet(this, _gcTimeout) !== void 0) {
+        timeoutManager.clearTimeout(__privateGet(this, _gcTimeout));
+        __privateSet(this, _gcTimeout, void 0);
+      }
+    }
+  }, _gcTimeout = new WeakMap(), _a4);
+
+  // node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js
+  function infiniteQueryBehavior(pages) {
+    return {
+      onFetch: (context, query) => {
+        const options = context.options;
+        const direction = context.fetchOptions?.meta?.fetchMore?.direction;
+        const oldPages = context.state.data?.pages || [];
+        const oldPageParams = context.state.data?.pageParams || [];
+        let result = { pages: [], pageParams: [] };
+        let currentPage = 0;
+        const fetchFn = async () => {
+          let cancelled = false;
+          const addSignalProperty = (object) => {
+            addConsumeAwareSignal(
+              object,
+              () => context.signal,
+              () => cancelled = true
+            );
+          };
+          const queryFn = ensureQueryFn(context.options, context.fetchOptions);
+          const fetchPage = async (data, param, previous) => {
+            if (cancelled) {
+              return Promise.reject(context.signal.reason);
+            }
+            if (param == null && data.pages.length) {
+              return Promise.resolve(data);
+            }
+            const createQueryFnContext = () => {
+              const queryFnContext2 = {
+                client: context.client,
+                queryKey: context.queryKey,
+                pageParam: param,
+                direction: previous ? "backward" : "forward",
+                meta: context.options.meta
+              };
+              addSignalProperty(queryFnContext2);
+              return queryFnContext2;
+            };
+            const queryFnContext = createQueryFnContext();
+            const page = await queryFn(queryFnContext);
+            const { maxPages } = context.options;
+            const addTo = previous ? addToStart : addToEnd;
+            return {
+              pages: addTo(data.pages, page, maxPages),
+              pageParams: addTo(data.pageParams, param, maxPages)
+            };
+          };
+          if (direction && oldPages.length) {
+            const previous = direction === "backward";
+            const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;
+            const oldData = {
+              pages: oldPages,
+              pageParams: oldPageParams
+            };
+            const param = pageParamFn(options, oldData);
+            result = await fetchPage(oldData, param, previous);
+          } else {
+            const remainingPages = pages ?? oldPages.length;
+            do {
+              const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result);
+              if (currentPage > 0 && param == null) {
+                break;
+              }
+              result = await fetchPage(result, param);
+              currentPage++;
+            } while (currentPage < remainingPages);
+          }
+          return result;
+        };
+        if (context.options.persister) {
+          context.fetchFn = () => {
+            return context.options.persister?.(
+              fetchFn,
+              {
+                client: context.client,
+                queryKey: context.queryKey,
+                meta: context.options.meta,
+                signal: context.signal
+              },
+              query
+            );
+          };
+        } else {
+          context.fetchFn = fetchFn;
+        }
+      }
+    };
+  }
+  function getNextPageParam(options, { pages, pageParams }) {
+    const lastIndex = pages.length - 1;
+    return pages.length > 0 ? options.getNextPageParam(
+      pages[lastIndex],
+      pages,
+      pageParams[lastIndex],
+      pageParams
+    ) : void 0;
+  }
+  function getPreviousPageParam(options, { pages, pageParams }) {
+    return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/query.js
+  var _queryType, _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, isInitialPausedFetch_fn, dispatch_fn, _a5;
+  var Query = (_a5 = class extends Removable {
+    constructor(config) {
+      super();
+      __privateAdd(this, _Query_instances);
+      __privateAdd(this, _queryType);
+      __privateAdd(this, _initialState);
+      __privateAdd(this, _revertState);
+      __privateAdd(this, _cache);
+      __privateAdd(this, _client);
+      __privateAdd(this, _retryer);
+      __privateAdd(this, _defaultOptions);
+      __privateAdd(this, _abortSignalConsumed);
+      __privateSet(this, _abortSignalConsumed, false);
+      __privateSet(this, _defaultOptions, config.defaultOptions);
+      this.setOptions(config.options);
+      this.observers = [];
+      __privateSet(this, _client, config.client);
+      __privateSet(this, _cache, __privateGet(this, _client).getQueryCache());
+      this.queryKey = config.queryKey;
+      this.queryHash = config.queryHash;
+      __privateSet(this, _initialState, getDefaultState(this.options));
+      this.state = config.state ?? __privateGet(this, _initialState);
+      this.scheduleGc();
+    }
+    get meta() {
+      return this.options.meta;
+    }
+    get queryType() {
+      return __privateGet(this, _queryType);
+    }
+    get promise() {
+      return __privateGet(this, _retryer)?.promise;
+    }
+    setOptions(options) {
+      this.options = { ...__privateGet(this, _defaultOptions), ...options };
+      if (options?._type) {
+        __privateSet(this, _queryType, options._type);
+      }
+      this.updateGcTime(this.options.gcTime);
+      if (this.state && this.state.data === void 0) {
+        const defaultState = getDefaultState(this.options);
+        if (defaultState.data !== void 0) {
+          this.setState(
+            successState(defaultState.data, defaultState.dataUpdatedAt)
+          );
+          __privateSet(this, _initialState, defaultState);
+        }
+      }
+    }
+    optionalRemove() {
+      if (!this.observers.length && this.state.fetchStatus === "idle") {
+        __privateGet(this, _cache).remove(this);
+      }
+    }
+    setData(newData, options) {
+      const data = replaceData(this.state.data, newData, this.options);
+      __privateMethod(this, _Query_instances, dispatch_fn).call(this, {
+        data,
+        type: "success",
+        dataUpdatedAt: options?.updatedAt,
+        manual: options?.manual
+      });
+      return data;
+    }
+    setState(state) {
+      __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "setState", state });
+    }
+    cancel(options) {
+      const promise = __privateGet(this, _retryer)?.promise;
+      __privateGet(this, _retryer)?.cancel(options);
+      return promise ? promise.then(noop).catch(noop) : Promise.resolve();
+    }
+    destroy() {
+      super.destroy();
+      this.cancel({ silent: true });
+    }
+    get resetState() {
+      return __privateGet(this, _initialState);
+    }
+    reset() {
+      this.destroy();
+      this.setState(this.resetState);
+    }
+    isActive() {
+      return this.observers.some(
+        (observer) => resolveQueryBoolean(observer.options.enabled, this) !== false
+      );
+    }
+    isDisabled() {
+      if (this.getObserversCount() > 0) {
+        return !this.isActive();
+      }
+      return this.options.queryFn === skipToken || !this.isFetched();
+    }
+    isFetched() {
+      return this.state.dataUpdateCount + this.state.errorUpdateCount > 0;
+    }
+    isStatic() {
+      if (this.getObserversCount() > 0) {
+        return this.observers.some(
+          (observer) => resolveStaleTime(observer.options.staleTime, this) === "static"
+        );
+      }
+      return false;
+    }
+    isStale() {
+      if (this.getObserversCount() > 0) {
+        return this.observers.some(
+          (observer) => observer.getCurrentResult().isStale
+        );
+      }
+      return this.state.data === void 0 || this.state.isInvalidated;
+    }
+    isStaleByTime(staleTime = 0) {
+      if (this.state.data === void 0) {
+        return true;
+      }
+      if (staleTime === "static") {
+        return false;
+      }
+      if (this.state.isInvalidated) {
+        return true;
+      }
+      return !timeUntilStale(this.state.dataUpdatedAt, staleTime);
+    }
+    onFocus() {
+      const observer = this.observers.find((x3) => x3.shouldFetchOnWindowFocus());
+      observer?.refetch({ cancelRefetch: false });
+      __privateGet(this, _retryer)?.continue();
+    }
+    onOnline() {
+      const observer = this.observers.find((x3) => x3.shouldFetchOnReconnect());
+      observer?.refetch({ cancelRefetch: false });
+      __privateGet(this, _retryer)?.continue();
+    }
+    addObserver(observer) {
+      if (!this.observers.includes(observer)) {
+        this.observers.push(observer);
+        this.clearGcTimeout();
+        __privateGet(this, _cache).notify({ type: "observerAdded", query: this, observer });
+      }
+    }
+    removeObserver(observer) {
+      if (this.observers.includes(observer)) {
+        this.observers = this.observers.filter((x3) => x3 !== observer);
+        if (!this.observers.length) {
+          if (__privateGet(this, _retryer)) {
+            if (__privateGet(this, _abortSignalConsumed) || __privateMethod(this, _Query_instances, isInitialPausedFetch_fn).call(this)) {
+              __privateGet(this, _retryer).cancel({ revert: true });
+            } else {
+              __privateGet(this, _retryer).cancelRetry();
+            }
+          }
+          this.scheduleGc();
+        }
+        __privateGet(this, _cache).notify({ type: "observerRemoved", query: this, observer });
+      }
+    }
+    getObserversCount() {
+      return this.observers.length;
+    }
+    invalidate() {
+      if (!this.state.isInvalidated) {
+        __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "invalidate" });
+      }
+    }
+    async fetch(options, fetchOptions) {
+      if (this.state.fetchStatus !== "idle" && // If the promise in the retryer is already rejected, we have to definitely
+      // re-start the fetch; there is a chance that the query is still in a
+      // pending state when that happens
+      __privateGet(this, _retryer)?.status() !== "rejected") {
+        if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) {
+          this.cancel({ silent: true });
+        } else if (__privateGet(this, _retryer)) {
+          __privateGet(this, _retryer).continueRetry();
+          return __privateGet(this, _retryer).promise;
+        }
+      }
+      if (options) {
+        this.setOptions(options);
+      }
+      if (!this.options.queryFn) {
+        const observer = this.observers.find((x3) => x3.options.queryFn);
+        if (observer) {
+          this.setOptions(observer.options);
+        }
+      }
+      if (true) {
+        if (!Array.isArray(this.options.queryKey)) {
+          console.error(
+            `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`
+          );
+        }
+      }
+      const abortController = new AbortController();
+      const addSignalProperty = (object) => {
+        Object.defineProperty(object, "signal", {
+          enumerable: true,
+          get: () => {
+            __privateSet(this, _abortSignalConsumed, true);
+            return abortController.signal;
+          }
+        });
+      };
+      const fetchFn = () => {
+        const queryFn = ensureQueryFn(this.options, fetchOptions);
+        const createQueryFnContext = () => {
+          const queryFnContext2 = {
+            client: __privateGet(this, _client),
+            queryKey: this.queryKey,
+            meta: this.meta
+          };
+          addSignalProperty(queryFnContext2);
+          return queryFnContext2;
+        };
+        const queryFnContext = createQueryFnContext();
+        __privateSet(this, _abortSignalConsumed, false);
+        if (this.options.persister) {
+          return this.options.persister(
+            queryFn,
+            queryFnContext,
+            this
+          );
+        }
+        return queryFn(queryFnContext);
+      };
+      const createFetchContext = () => {
+        const context2 = {
+          fetchOptions,
+          options: this.options,
+          queryKey: this.queryKey,
+          client: __privateGet(this, _client),
+          state: this.state,
+          fetchFn
+        };
+        addSignalProperty(context2);
+        return context2;
+      };
+      const context = createFetchContext();
+      const behavior = __privateGet(this, _queryType) === "infinite" ? infiniteQueryBehavior(
+        this.options.pages
+      ) : this.options.behavior;
+      behavior?.onFetch(context, this);
+      __privateSet(this, _revertState, this.state);
+      if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) {
+        __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "fetch", meta: context.fetchOptions?.meta });
+      }
+      __privateSet(this, _retryer, createRetryer({
+        initialPromise: fetchOptions?.initialPromise,
+        fn: context.fetchFn,
+        onCancel: (error) => {
+          if (error instanceof CancelledError && error.revert) {
+            this.setState({
+              ...__privateGet(this, _revertState),
+              fetchStatus: "idle"
+            });
+          }
+          abortController.abort();
+        },
+        onFail: (failureCount, error) => {
+          __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "failed", failureCount, error });
+        },
+        onPause: () => {
+          __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "pause" });
+        },
+        onContinue: () => {
+          __privateMethod(this, _Query_instances, dispatch_fn).call(this, { type: "continue" });
+        },
+        retry: context.options.retry,
+        retryDelay: context.options.retryDelay,
+        networkMode: context.options.networkMode,
+        canRun: () => true
+      }));
+      try {
+        const data = await __privateGet(this, _retryer).start();
+        if (data === void 0) {
+          if (true) {
+            console.error(
+              `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`
+            );
+          }
+          throw new Error(`${this.queryHash} data is undefined`);
+        }
+        this.setData(data);
+        __privateGet(this, _cache).config.onSuccess?.(data, this);
+        __privateGet(this, _cache).config.onSettled?.(
+          data,
+          this.state.error,
+          this
+        );
+        return data;
+      } catch (error) {
+        if (error instanceof CancelledError) {
+          if (error.silent) {
+            return __privateGet(this, _retryer).promise;
+          } else if (error.revert) {
+            if (this.state.data === void 0) {
+              throw error;
+            }
+            return this.state.data;
+          }
+        }
+        __privateMethod(this, _Query_instances, dispatch_fn).call(this, {
+          type: "error",
+          error
+        });
+        __privateGet(this, _cache).config.onError?.(
+          error,
+          this
+        );
+        __privateGet(this, _cache).config.onSettled?.(
+          this.state.data,
+          error,
+          this
+        );
+        throw error;
+      } finally {
+        this.scheduleGc();
+      }
+    }
+  }, _queryType = new WeakMap(), _initialState = new WeakMap(), _revertState = new WeakMap(), _cache = new WeakMap(), _client = new WeakMap(), _retryer = new WeakMap(), _defaultOptions = new WeakMap(), _abortSignalConsumed = new WeakMap(), _Query_instances = new WeakSet(), isInitialPausedFetch_fn = function() {
+    return this.state.fetchStatus === "paused" && this.state.status === "pending";
+  }, dispatch_fn = function(action) {
+    const reducer = (state) => {
+      switch (action.type) {
+        case "failed":
+          return {
+            ...state,
+            fetchFailureCount: action.failureCount,
+            fetchFailureReason: action.error
+          };
+        case "pause":
+          return {
+            ...state,
+            fetchStatus: "paused"
+          };
+        case "continue":
+          return {
+            ...state,
+            fetchStatus: "fetching"
+          };
+        case "fetch":
+          return {
+            ...state,
+            ...fetchState(state.data, this.options),
+            fetchMeta: action.meta ?? null
+          };
+        case "success":
+          const newState = {
+            ...state,
+            ...successState(action.data, action.dataUpdatedAt),
+            dataUpdateCount: state.dataUpdateCount + 1,
+            ...!action.manual && {
+              fetchStatus: "idle",
+              fetchFailureCount: 0,
+              fetchFailureReason: null
+            }
+          };
+          __privateSet(this, _revertState, action.manual ? newState : void 0);
+          return newState;
+        case "error":
+          const error = action.error;
+          return {
+            ...state,
+            error,
+            errorUpdateCount: state.errorUpdateCount + 1,
+            errorUpdatedAt: Date.now(),
+            fetchFailureCount: state.fetchFailureCount + 1,
+            fetchFailureReason: error,
+            fetchStatus: "idle",
+            status: "error",
+            // flag existing data as invalidated if we get a background error
+            // note that "no data" always means stale so we can set unconditionally here
+            isInvalidated: true
+          };
+        case "invalidate":
+          return {
+            ...state,
+            isInvalidated: true
+          };
+        case "setState":
+          return {
+            ...state,
+            ...action.state
+          };
+      }
+    };
+    this.state = reducer(this.state);
+    notifyManager.batch(() => {
+      this.observers.forEach((observer) => {
+        observer.onQueryUpdate();
+      });
+      __privateGet(this, _cache).notify({ query: this, type: "updated", action });
+    });
+  }, _a5);
+  function fetchState(data, options) {
+    return {
+      fetchFailureCount: 0,
+      fetchFailureReason: null,
+      fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused",
+      ...data === void 0 && {
+        error: null,
+        status: "pending"
+      }
+    };
+  }
+  function successState(data, dataUpdatedAt) {
+    return {
+      data,
+      dataUpdatedAt: dataUpdatedAt ?? Date.now(),
+      error: null,
+      isInvalidated: false,
+      status: "success"
+    };
+  }
+  function getDefaultState(options) {
+    const data = typeof options.initialData === "function" ? options.initialData() : options.initialData;
+    const hasData = data !== void 0;
+    const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
+    return {
+      data,
+      dataUpdateCount: 0,
+      dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
+      error: null,
+      errorUpdateCount: 0,
+      errorUpdatedAt: 0,
+      fetchFailureCount: 0,
+      fetchFailureReason: null,
+      fetchMeta: null,
+      isInvalidated: false,
+      status: hasData ? "success" : "pending",
+      fetchStatus: "idle"
+    };
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/queryObserver.js
+  var _client2, _currentQuery, _currentQueryInitialState, _currentResult, _currentResultState, _currentResultOptions, _currentThenable, _selectError, _selectFn, _selectResult, _lastQueryWithDefinedData, _staleTimeoutId, _refetchIntervalId, _currentRefetchInterval, _trackedProps, _QueryObserver_instances, executeFetch_fn, updateStaleTimeout_fn, computeRefetchInterval_fn, updateRefetchInterval_fn, updateTimers_fn, clearStaleTimeout_fn, clearRefetchInterval_fn, updateQuery_fn, notify_fn, _a6;
+  var QueryObserver = (_a6 = class extends Subscribable {
+    constructor(client, options) {
+      super();
+      __privateAdd(this, _QueryObserver_instances);
+      __privateAdd(this, _client2);
+      __privateAdd(this, _currentQuery);
+      __privateAdd(this, _currentQueryInitialState);
+      __privateAdd(this, _currentResult);
+      __privateAdd(this, _currentResultState);
+      __privateAdd(this, _currentResultOptions);
+      __privateAdd(this, _currentThenable);
+      __privateAdd(this, _selectError);
+      __privateAdd(this, _selectFn);
+      __privateAdd(this, _selectResult);
+      // This property keeps track of the last query with defined data.
+      // It will be used to pass the previous data and query to the placeholder function between renders.
+      __privateAdd(this, _lastQueryWithDefinedData);
+      __privateAdd(this, _staleTimeoutId);
+      __privateAdd(this, _refetchIntervalId);
+      __privateAdd(this, _currentRefetchInterval);
+      __privateAdd(this, _trackedProps, /* @__PURE__ */ new Set());
+      this.options = options;
+      __privateSet(this, _client2, client);
+      __privateSet(this, _selectError, null);
+      __privateSet(this, _currentThenable, pendingThenable());
+      this.bindMethods();
+      this.setOptions(options);
+    }
+    bindMethods() {
+      this.refetch = this.refetch.bind(this);
+    }
+    onSubscribe() {
+      if (this.listeners.size === 1) {
+        __privateGet(this, _currentQuery).addObserver(this);
+        if (shouldFetchOnMount(__privateGet(this, _currentQuery), this.options)) {
+          __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+        } else {
+          this.updateResult();
+        }
+        __privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
+      }
+    }
+    onUnsubscribe() {
+      if (!this.hasListeners()) {
+        this.destroy();
+      }
+    }
+    shouldFetchOnReconnect() {
+      return shouldFetchOn(
+        __privateGet(this, _currentQuery),
+        this.options,
+        this.options.refetchOnReconnect
+      );
+    }
+    shouldFetchOnWindowFocus() {
+      return shouldFetchOn(
+        __privateGet(this, _currentQuery),
+        this.options,
+        this.options.refetchOnWindowFocus
+      );
+    }
+    destroy() {
+      this.listeners = /* @__PURE__ */ new Set();
+      __privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
+      __privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
+      __privateGet(this, _currentQuery).removeObserver(this);
+    }
+    setOptions(options) {
+      const prevOptions = this.options;
+      const prevQuery = __privateGet(this, _currentQuery);
+      this.options = __privateGet(this, _client2).defaultQueryOptions(options);
+      if (this.options.enabled !== void 0 && typeof this.options.enabled !== "boolean" && typeof this.options.enabled !== "function" && typeof resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) !== "boolean") {
+        throw new Error(
+          "Expected enabled to be a boolean or a callback that returns a boolean"
+        );
+      }
+      __privateMethod(this, _QueryObserver_instances, updateQuery_fn).call(this);
+      __privateGet(this, _currentQuery).setOptions(this.options);
+      if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {
+        __privateGet(this, _client2).getQueryCache().notify({
+          type: "observerOptionsUpdated",
+          query: __privateGet(this, _currentQuery),
+          observer: this
+        });
+      }
+      const mounted = this.hasListeners();
+      if (mounted && shouldFetchOptionally(
+        __privateGet(this, _currentQuery),
+        prevQuery,
+        this.options,
+        prevOptions
+      )) {
+        __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+      }
+      this.updateResult();
+      if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveQueryBoolean(prevOptions.enabled, __privateGet(this, _currentQuery)) || resolveStaleTime(this.options.staleTime, __privateGet(this, _currentQuery)) !== resolveStaleTime(prevOptions.staleTime, __privateGet(this, _currentQuery)))) {
+        __privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
+      }
+      const nextRefetchInterval = __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this);
+      if (mounted && (__privateGet(this, _currentQuery) !== prevQuery || resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveQueryBoolean(prevOptions.enabled, __privateGet(this, _currentQuery)) || nextRefetchInterval !== __privateGet(this, _currentRefetchInterval))) {
+        __privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, nextRefetchInterval);
+      }
+    }
+    getOptimisticResult(options) {
+      const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), options);
+      const result = this.createResult(query, options);
+      if (shouldAssignObserverCurrentProperties(this, result)) {
+        __privateSet(this, _currentResult, result);
+        __privateSet(this, _currentResultOptions, this.options);
+        __privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
+      }
+      return result;
+    }
+    getCurrentResult() {
+      return __privateGet(this, _currentResult);
+    }
+    trackResult(result, onPropTracked) {
+      return new Proxy(result, {
+        get: (target, key) => {
+          this.trackProp(key);
+          onPropTracked?.(key);
+          if (key === "promise") {
+            this.trackProp("data");
+            if (!this.options.experimental_prefetchInRender && __privateGet(this, _currentThenable).status === "pending") {
+              __privateGet(this, _currentThenable).reject(
+                new Error(
+                  "experimental_prefetchInRender feature flag is not enabled"
+                )
+              );
+            }
+          }
+          return Reflect.get(target, key);
+        }
+      });
+    }
+    trackProp(key) {
+      __privateGet(this, _trackedProps).add(key);
+    }
+    getCurrentQuery() {
+      return __privateGet(this, _currentQuery);
+    }
+    refetch({ ...options } = {}) {
+      return this.fetch({
+        ...options
+      });
+    }
+    fetchOptimistic(options) {
+      const defaultedOptions = __privateGet(this, _client2).defaultQueryOptions(options);
+      const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), defaultedOptions);
+      return query.fetch().then(() => this.createResult(query, defaultedOptions));
+    }
+    fetch(fetchOptions) {
+      return __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this, {
+        ...fetchOptions,
+        cancelRefetch: fetchOptions.cancelRefetch ?? true
+      }).then(() => {
+        this.updateResult();
+        return __privateGet(this, _currentResult);
+      });
+    }
+    createResult(query, options) {
+      const prevQuery = __privateGet(this, _currentQuery);
+      const prevOptions = this.options;
+      const prevResult = __privateGet(this, _currentResult);
+      const prevResultState = __privateGet(this, _currentResultState);
+      const prevResultOptions = __privateGet(this, _currentResultOptions);
+      const queryChange = query !== prevQuery;
+      const queryInitialState = queryChange ? query.state : __privateGet(this, _currentQueryInitialState);
+      const { state } = query;
+      let newState = { ...state };
+      let isPlaceholderData = false;
+      let data;
+      if (options._optimisticResults) {
+        const mounted = this.hasListeners();
+        const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+        const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+        if (fetchOnMount || fetchOptionally) {
+          newState = {
+            ...newState,
+            ...fetchState(state.data, query.options)
+          };
+        }
+        if (options._optimisticResults === "isRestoring") {
+          newState.fetchStatus = "idle";
+        }
+      }
+      let { error, errorUpdatedAt, status } = newState;
+      data = newState.data;
+      let skipSelect = false;
+      if (options.placeholderData !== void 0 && data === void 0 && status === "pending") {
+        let placeholderData;
+        if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
+          placeholderData = prevResult.data;
+          skipSelect = true;
+        } else {
+          placeholderData = typeof options.placeholderData === "function" ? options.placeholderData(
+            __privateGet(this, _lastQueryWithDefinedData)?.state.data,
+            __privateGet(this, _lastQueryWithDefinedData)
+          ) : options.placeholderData;
+        }
+        if (placeholderData !== void 0) {
+          status = "success";
+          data = replaceData(
+            prevResult?.data,
+            placeholderData,
+            options
+          );
+          isPlaceholderData = true;
+        }
+      }
+      if (options.select && data !== void 0 && !skipSelect) {
+        if (prevResult && data === prevResultState?.data && options.select === __privateGet(this, _selectFn)) {
+          data = __privateGet(this, _selectResult);
+        } else {
+          try {
+            __privateSet(this, _selectFn, options.select);
+            data = options.select(data);
+            data = replaceData(prevResult?.data, data, options);
+            __privateSet(this, _selectResult, data);
+            __privateSet(this, _selectError, null);
+          } catch (selectError) {
+            __privateSet(this, _selectError, selectError);
+          }
+        }
+      }
+      if (__privateGet(this, _selectError)) {
+        error = __privateGet(this, _selectError);
+        data = __privateGet(this, _selectResult);
+        errorUpdatedAt = Date.now();
+        status = "error";
+      }
+      const isFetching = newState.fetchStatus === "fetching";
+      const isPending = status === "pending";
+      const isError = status === "error";
+      const isLoading = isPending && isFetching;
+      const hasData = data !== void 0;
+      const result = {
+        status,
+        fetchStatus: newState.fetchStatus,
+        isPending,
+        isSuccess: status === "success",
+        isError,
+        isInitialLoading: isLoading,
+        isLoading,
+        data,
+        dataUpdatedAt: newState.dataUpdatedAt,
+        error,
+        errorUpdatedAt,
+        failureCount: newState.fetchFailureCount,
+        failureReason: newState.fetchFailureReason,
+        errorUpdateCount: newState.errorUpdateCount,
+        isFetched: query.isFetched(),
+        isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,
+        isFetching,
+        isRefetching: isFetching && !isPending,
+        isLoadingError: isError && !hasData,
+        isPaused: newState.fetchStatus === "paused",
+        isPlaceholderData,
+        isRefetchError: isError && hasData,
+        isStale: isStale(query, options),
+        refetch: this.refetch,
+        promise: __privateGet(this, _currentThenable),
+        isEnabled: resolveQueryBoolean(options.enabled, query) !== false
+      };
+      const nextResult = result;
+      if (this.options.experimental_prefetchInRender) {
+        const hasResultData = nextResult.data !== void 0;
+        const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
+        const finalizeThenableIfPossible = (thenable) => {
+          if (isErrorWithoutData) {
+            thenable.reject(nextResult.error);
+          } else if (hasResultData) {
+            thenable.resolve(nextResult.data);
+          }
+        };
+        const recreateThenable = () => {
+          const pending = __privateSet(this, _currentThenable, nextResult.promise = pendingThenable());
+          finalizeThenableIfPossible(pending);
+        };
+        const prevThenable = __privateGet(this, _currentThenable);
+        switch (prevThenable.status) {
+          case "pending":
+            if (query.queryHash === prevQuery.queryHash) {
+              finalizeThenableIfPossible(prevThenable);
+            }
+            break;
+          case "fulfilled":
+            if (isErrorWithoutData || nextResult.data !== prevThenable.value) {
+              recreateThenable();
+            }
+            break;
+          case "rejected":
+            if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {
+              recreateThenable();
+            }
+            break;
+        }
+      }
+      return nextResult;
+    }
+    updateResult() {
+      const prevResult = __privateGet(this, _currentResult);
+      const nextResult = this.createResult(__privateGet(this, _currentQuery), this.options);
+      __privateSet(this, _currentResultState, __privateGet(this, _currentQuery).state);
+      __privateSet(this, _currentResultOptions, this.options);
+      if (__privateGet(this, _currentResultState).data !== void 0) {
+        __privateSet(this, _lastQueryWithDefinedData, __privateGet(this, _currentQuery));
+      }
+      if (shallowEqualObjects(nextResult, prevResult)) {
+        return;
+      }
+      __privateSet(this, _currentResult, nextResult);
+      const shouldNotifyListeners = () => {
+        if (!prevResult) {
+          return true;
+        }
+        const { notifyOnChangeProps } = this.options;
+        const notifyOnChangePropsValue = typeof notifyOnChangeProps === "function" ? notifyOnChangeProps() : notifyOnChangeProps;
+        if (notifyOnChangePropsValue === "all" || !notifyOnChangePropsValue && !__privateGet(this, _trackedProps).size) {
+          return true;
+        }
+        const includedProps = new Set(
+          notifyOnChangePropsValue ?? __privateGet(this, _trackedProps)
+        );
+        if (this.options.throwOnError) {
+          includedProps.add("error");
+        }
+        return Object.keys(__privateGet(this, _currentResult)).some((key) => {
+          const typedKey = key;
+          const changed = __privateGet(this, _currentResult)[typedKey] !== prevResult[typedKey];
+          return changed && includedProps.has(typedKey);
+        });
+      };
+      __privateMethod(this, _QueryObserver_instances, notify_fn).call(this, { listeners: shouldNotifyListeners() });
+    }
+    onQueryUpdate() {
+      this.updateResult();
+      if (this.hasListeners()) {
+        __privateMethod(this, _QueryObserver_instances, updateTimers_fn).call(this);
+      }
+    }
+  }, _client2 = new WeakMap(), _currentQuery = new WeakMap(), _currentQueryInitialState = new WeakMap(), _currentResult = new WeakMap(), _currentResultState = new WeakMap(), _currentResultOptions = new WeakMap(), _currentThenable = new WeakMap(), _selectError = new WeakMap(), _selectFn = new WeakMap(), _selectResult = new WeakMap(), _lastQueryWithDefinedData = new WeakMap(), _staleTimeoutId = new WeakMap(), _refetchIntervalId = new WeakMap(), _currentRefetchInterval = new WeakMap(), _trackedProps = new WeakMap(), _QueryObserver_instances = new WeakSet(), executeFetch_fn = function(fetchOptions) {
+    __privateMethod(this, _QueryObserver_instances, updateQuery_fn).call(this);
+    let promise = __privateGet(this, _currentQuery).fetch(
+      this.options,
+      fetchOptions
+    );
+    if (!fetchOptions?.throwOnError) {
+      promise = promise.catch(noop);
+    }
+    return promise;
+  }, updateStaleTimeout_fn = function() {
+    __privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
+    const staleTime = resolveStaleTime(
+      this.options.staleTime,
+      __privateGet(this, _currentQuery)
+    );
+    if (environmentManager.isServer() || __privateGet(this, _currentResult).isStale || !isValidTimeout(staleTime)) {
+      return;
+    }
+    const time = timeUntilStale(__privateGet(this, _currentResult).dataUpdatedAt, staleTime);
+    const timeout = time + 1;
+    __privateSet(this, _staleTimeoutId, timeoutManager.setTimeout(() => {
+      if (!__privateGet(this, _currentResult).isStale) {
+        this.updateResult();
+      }
+    }, timeout));
+  }, computeRefetchInterval_fn = function() {
+    return (typeof this.options.refetchInterval === "function" ? this.options.refetchInterval(__privateGet(this, _currentQuery)) : this.options.refetchInterval) ?? false;
+  }, updateRefetchInterval_fn = function(nextInterval) {
+    __privateMethod(this, _QueryObserver_instances, clearRefetchInterval_fn).call(this);
+    __privateSet(this, _currentRefetchInterval, nextInterval);
+    if (environmentManager.isServer() || resolveQueryBoolean(this.options.enabled, __privateGet(this, _currentQuery)) === false || !isValidTimeout(__privateGet(this, _currentRefetchInterval)) || __privateGet(this, _currentRefetchInterval) === 0) {
+      return;
+    }
+    __privateSet(this, _refetchIntervalId, timeoutManager.setInterval(() => {
+      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+        __privateMethod(this, _QueryObserver_instances, executeFetch_fn).call(this);
+      }
+    }, __privateGet(this, _currentRefetchInterval)));
+  }, updateTimers_fn = function() {
+    __privateMethod(this, _QueryObserver_instances, updateStaleTimeout_fn).call(this);
+    __privateMethod(this, _QueryObserver_instances, updateRefetchInterval_fn).call(this, __privateMethod(this, _QueryObserver_instances, computeRefetchInterval_fn).call(this));
+  }, clearStaleTimeout_fn = function() {
+    if (__privateGet(this, _staleTimeoutId) !== void 0) {
+      timeoutManager.clearTimeout(__privateGet(this, _staleTimeoutId));
+      __privateSet(this, _staleTimeoutId, void 0);
+    }
+  }, clearRefetchInterval_fn = function() {
+    if (__privateGet(this, _refetchIntervalId) !== void 0) {
+      timeoutManager.clearInterval(__privateGet(this, _refetchIntervalId));
+      __privateSet(this, _refetchIntervalId, void 0);
+    }
+  }, updateQuery_fn = function() {
+    const query = __privateGet(this, _client2).getQueryCache().build(__privateGet(this, _client2), this.options);
+    if (query === __privateGet(this, _currentQuery)) {
+      return;
+    }
+    const prevQuery = __privateGet(this, _currentQuery);
+    __privateSet(this, _currentQuery, query);
+    __privateSet(this, _currentQueryInitialState, query.state);
+    if (this.hasListeners()) {
+      prevQuery?.removeObserver(this);
+      query.addObserver(this);
+    }
+  }, notify_fn = function(notifyOptions) {
+    notifyManager.batch(() => {
+      if (notifyOptions.listeners) {
+        this.listeners.forEach((listener) => {
+          listener(__privateGet(this, _currentResult));
+        });
+      }
+      __privateGet(this, _client2).getQueryCache().notify({
+        query: __privateGet(this, _currentQuery),
+        type: "observerResultsUpdated"
+      });
+    });
+  }, _a6);
+  function shouldLoadOnMount(query, options) {
+    return resolveQueryBoolean(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && resolveQueryBoolean(options.retryOnMount, query) === false);
+  }
+  function shouldFetchOnMount(query, options) {
+    return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);
+  }
+  function shouldFetchOn(query, options, field) {
+    if (resolveQueryBoolean(options.enabled, query) !== false && resolveStaleTime(options.staleTime, query) !== "static") {
+      const value = typeof field === "function" ? field(query) : field;
+      return value === "always" || value !== false && isStale(query, options);
+    }
+    return false;
+  }
+  function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+    return (query !== prevQuery || resolveQueryBoolean(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
+  }
+  function isStale(query, options) {
+    return resolveQueryBoolean(options.enabled, query) !== false && query.isStaleByTime(resolveStaleTime(options.staleTime, query));
+  }
+  function shouldAssignObserverCurrentProperties(observer, optimisticResult) {
+    if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+      return true;
+    }
+    return false;
+  }
+
+  // node_modules/@tanstack/query-core/build/modern/mutation.js
+  var _client3, _observers, _mutationCache, _retryer2, _Mutation_instances, dispatch_fn2, _a7;
+  var Mutation = (_a7 = class extends Removable {
+    constructor(config) {
+      super();
+      __privateAdd(this, _Mutation_instances);
+      __privateAdd(this, _client3);
+      __privateAdd(this, _observers);
+      __privateAdd(this, _mutationCache);
+      __privateAdd(this, _retryer2);
+      __privateSet(this, _client3, config.client);
+      this.mutationId = config.mutationId;
+      __privateSet(this, _mutationCache, config.mutationCache);
+      __privateSet(this, _observers, []);
+      this.state = config.state || getDefaultState2();
+      this.setOptions(config.options);
+      this.scheduleGc();
+    }
+    setOptions(options) {
+      this.options = options;
+      this.updateGcTime(this.options.gcTime);
+    }
+    get meta() {
+      return this.options.meta;
+    }
+    addObserver(observer) {
+      if (!__privateGet(this, _observers).includes(observer)) {
+        __privateGet(this, _observers).push(observer);
+        this.clearGcTimeout();
+        __privateGet(this, _mutationCache).notify({
+          type: "observerAdded",
+          mutation: this,
+          observer
         });
-      } catch (r3) {
-        t3.some(function(n4) {
-          n4.__h && (n4.__h = []);
-        }), t3 = [], c2.__e(r3, n3.__v);
       }
-    }), l2 && l2(n2, t3);
-  }, c2.unmount = function(n2) {
-    m2 && m2(n2);
-    var t3, r3 = n2.__c;
-    r3 && r3.__H && (r3.__H.__.some(function(n3) {
+    }
+    removeObserver(observer) {
+      __privateSet(this, _observers, __privateGet(this, _observers).filter((x3) => x3 !== observer));
+      this.scheduleGc();
+      __privateGet(this, _mutationCache).notify({
+        type: "observerRemoved",
+        mutation: this,
+        observer
+      });
+    }
+    optionalRemove() {
+      if (!__privateGet(this, _observers).length) {
+        if (this.state.status === "pending") {
+          this.scheduleGc();
+        } else {
+          __privateGet(this, _mutationCache).remove(this);
+        }
+      }
+    }
+    continue() {
+      return __privateGet(this, _retryer2)?.continue() ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+      this.execute(this.state.variables);
+    }
+    async execute(variables) {
+      const onContinue = () => {
+        __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "continue" });
+      };
+      const mutationFnContext = {
+        client: __privateGet(this, _client3),
+        meta: this.options.meta,
+        mutationKey: this.options.mutationKey
+      };
+      __privateSet(this, _retryer2, createRetryer({
+        fn: () => {
+          if (!this.options.mutationFn) {
+            return Promise.reject(new Error("No mutationFn found"));
+          }
+          return this.options.mutationFn(variables, mutationFnContext);
+        },
+        onFail: (failureCount, error) => {
+          __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "failed", failureCount, error });
+        },
+        onPause: () => {
+          __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "pause" });
+        },
+        onContinue,
+        retry: this.options.retry ?? 0,
+        retryDelay: this.options.retryDelay,
+        networkMode: this.options.networkMode,
+        canRun: () => __privateGet(this, _mutationCache).canRun(this)
+      }));
+      const restored = this.state.status === "pending";
+      const isPaused = !__privateGet(this, _retryer2).canStart();
       try {
-        z2(n3);
-      } catch (n4) {
-        t3 = n4;
+        if (restored) {
+          onContinue();
+        } else {
+          __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "pending", variables, isPaused });
+          if (__privateGet(this, _mutationCache).config.onMutate) {
+            await __privateGet(this, _mutationCache).config.onMutate(
+              variables,
+              this,
+              mutationFnContext
+            );
+          }
+          const context = await this.options.onMutate?.(
+            variables,
+            mutationFnContext
+          );
+          if (context !== this.state.context) {
+            __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, {
+              type: "pending",
+              context,
+              variables,
+              isPaused
+            });
+          }
+        }
+        const data = await __privateGet(this, _retryer2).start();
+        await __privateGet(this, _mutationCache).config.onSuccess?.(
+          data,
+          variables,
+          this.state.context,
+          this,
+          mutationFnContext
+        );
+        await this.options.onSuccess?.(
+          data,
+          variables,
+          this.state.context,
+          mutationFnContext
+        );
+        await __privateGet(this, _mutationCache).config.onSettled?.(
+          data,
+          null,
+          this.state.variables,
+          this.state.context,
+          this,
+          mutationFnContext
+        );
+        await this.options.onSettled?.(
+          data,
+          null,
+          variables,
+          this.state.context,
+          mutationFnContext
+        );
+        __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "success", data });
+        return data;
+      } catch (error) {
+        try {
+          await __privateGet(this, _mutationCache).config.onError?.(
+            error,
+            variables,
+            this.state.context,
+            this,
+            mutationFnContext
+          );
+        } catch (e3) {
+          void Promise.reject(e3);
+        }
+        try {
+          await this.options.onError?.(
+            error,
+            variables,
+            this.state.context,
+            mutationFnContext
+          );
+        } catch (e3) {
+          void Promise.reject(e3);
+        }
+        try {
+          await __privateGet(this, _mutationCache).config.onSettled?.(
+            void 0,
+            error,
+            this.state.variables,
+            this.state.context,
+            this,
+            mutationFnContext
+          );
+        } catch (e3) {
+          void Promise.reject(e3);
+        }
+        try {
+          await this.options.onSettled?.(
+            void 0,
+            error,
+            variables,
+            this.state.context,
+            mutationFnContext
+          );
+        } catch (e3) {
+          void Promise.reject(e3);
+        }
+        __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, { type: "error", error });
+        throw error;
+      } finally {
+        __privateGet(this, _mutationCache).runNext(this);
       }
-    }), r3.__H = void 0, t3 && c2.__e(t3, r3.__v));
-  };
-  var k2 = "function" == typeof requestAnimationFrame;
-  function w2(n2) {
-    var t3, r3 = function() {
-      clearTimeout(u4), k2 && cancelAnimationFrame(t3), setTimeout(n2);
-    }, u4 = setTimeout(r3, 35);
-    k2 && (t3 = requestAnimationFrame(r3));
-  }
-  function z2(n2) {
-    var t3 = r2, u4 = n2.__c;
-    "function" == typeof u4 && (n2.__c = void 0, u4()), r2 = t3;
-  }
-  function B2(n2) {
-    var t3 = r2;
-    n2.__c = n2.__(), r2 = t3;
-  }
-  function C2(n2, t3) {
-    return !n2 || n2.length !== t3.length || t3.some(function(t4, r3) {
-      return t4 !== n2[r3];
+    }
+  }, _client3 = new WeakMap(), _observers = new WeakMap(), _mutationCache = new WeakMap(), _retryer2 = new WeakMap(), _Mutation_instances = new WeakSet(), dispatch_fn2 = function(action) {
+    const reducer = (state) => {
+      switch (action.type) {
+        case "failed":
+          return {
+            ...state,
+            failureCount: action.failureCount,
+            failureReason: action.error
+          };
+        case "pause":
+          return {
+            ...state,
+            isPaused: true
+          };
+        case "continue":
+          return {
+            ...state,
+            isPaused: false
+          };
+        case "pending":
+          return {
+            ...state,
+            context: action.context,
+            data: void 0,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            isPaused: action.isPaused,
+            status: "pending",
+            variables: action.variables,
+            submittedAt: Date.now()
+          };
+        case "success":
+          return {
+            ...state,
+            data: action.data,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            status: "success",
+            isPaused: false
+          };
+        case "error":
+          return {
+            ...state,
+            data: void 0,
+            error: action.error,
+            failureCount: state.failureCount + 1,
+            failureReason: action.error,
+            isPaused: false,
+            status: "error"
+          };
+      }
+    };
+    this.state = reducer(this.state);
+    notifyManager.batch(() => {
+      __privateGet(this, _observers).forEach((observer) => {
+        observer.onMutationUpdate(action);
+      });
+      __privateGet(this, _mutationCache).notify({
+        mutation: this,
+        type: "updated",
+        action
+      });
     });
+  }, _a7);
+  function getDefaultState2() {
+    return {
+      context: void 0,
+      data: void 0,
+      error: null,
+      failureCount: 0,
+      failureReason: null,
+      isPaused: false,
+      status: "idle",
+      variables: void 0,
+      submittedAt: 0
+    };
   }
-  function D2(n2, t3) {
-    return "function" == typeof t3 ? t3(n2) : t3;
+
+  // node_modules/@tanstack/query-core/build/modern/mutationCache.js
+  var _mutations, _scopes, _mutationId, _a8;
+  var MutationCache = (_a8 = class extends Subscribable {
+    constructor(config = {}) {
+      super();
+      __privateAdd(this, _mutations);
+      __privateAdd(this, _scopes);
+      __privateAdd(this, _mutationId);
+      this.config = config;
+      __privateSet(this, _mutations, /* @__PURE__ */ new Set());
+      __privateSet(this, _scopes, /* @__PURE__ */ new Map());
+      __privateSet(this, _mutationId, 0);
+    }
+    build(client, options, state) {
+      const mutation = new Mutation({
+        client,
+        mutationCache: this,
+        mutationId: ++__privateWrapper(this, _mutationId)._,
+        options: client.defaultMutationOptions(options),
+        state
+      });
+      this.add(mutation);
+      return mutation;
+    }
+    add(mutation) {
+      __privateGet(this, _mutations).add(mutation);
+      const scope = scopeFor(mutation);
+      if (typeof scope === "string") {
+        const scopedMutations = __privateGet(this, _scopes).get(scope);
+        if (scopedMutations) {
+          scopedMutations.push(mutation);
+        } else {
+          __privateGet(this, _scopes).set(scope, [mutation]);
+        }
+      }
+      this.notify({ type: "added", mutation });
+    }
+    remove(mutation) {
+      if (__privateGet(this, _mutations).delete(mutation)) {
+        const scope = scopeFor(mutation);
+        if (typeof scope === "string") {
+          const scopedMutations = __privateGet(this, _scopes).get(scope);
+          if (scopedMutations) {
+            if (scopedMutations.length > 1) {
+              const index = scopedMutations.indexOf(mutation);
+              if (index !== -1) {
+                scopedMutations.splice(index, 1);
+              }
+            } else if (scopedMutations[0] === mutation) {
+              __privateGet(this, _scopes).delete(scope);
+            }
+          }
+        }
+      }
+      this.notify({ type: "removed", mutation });
+    }
+    canRun(mutation) {
+      const scope = scopeFor(mutation);
+      if (typeof scope === "string") {
+        const mutationsWithSameScope = __privateGet(this, _scopes).get(scope);
+        const firstPendingMutation = mutationsWithSameScope?.find(
+          (m3) => m3.state.status === "pending"
+        );
+        return !firstPendingMutation || firstPendingMutation === mutation;
+      } else {
+        return true;
+      }
+    }
+    runNext(mutation) {
+      const scope = scopeFor(mutation);
+      if (typeof scope === "string") {
+        const foundMutation = __privateGet(this, _scopes).get(scope)?.find((m3) => m3 !== mutation && m3.state.isPaused);
+        return foundMutation?.continue() ?? Promise.resolve();
+      } else {
+        return Promise.resolve();
+      }
+    }
+    clear() {
+      notifyManager.batch(() => {
+        __privateGet(this, _mutations).forEach((mutation) => {
+          this.notify({ type: "removed", mutation });
+        });
+        __privateGet(this, _mutations).clear();
+        __privateGet(this, _scopes).clear();
+      });
+    }
+    getAll() {
+      return Array.from(__privateGet(this, _mutations));
+    }
+    find(filters) {
+      const defaultedFilters = { exact: true, ...filters };
+      return this.getAll().find(
+        (mutation) => matchMutation(defaultedFilters, mutation)
+      );
+    }
+    findAll(filters = {}) {
+      return this.getAll().filter((mutation) => matchMutation(filters, mutation));
+    }
+    notify(event) {
+      notifyManager.batch(() => {
+        this.listeners.forEach((listener) => {
+          listener(event);
+        });
+      });
+    }
+    resumePausedMutations() {
+      const pausedMutations = this.getAll().filter((x3) => x3.state.isPaused);
+      return notifyManager.batch(
+        () => Promise.all(
+          pausedMutations.map((mutation) => mutation.continue().catch(noop))
+        )
+      );
+    }
+  }, _mutations = new WeakMap(), _scopes = new WeakMap(), _mutationId = new WeakMap(), _a8);
+  function scopeFor(mutation) {
+    return mutation.options.scope?.id;
   }
 
+  // node_modules/@tanstack/query-core/build/modern/queryCache.js
+  var _queries, _a9;
+  var QueryCache = (_a9 = class extends Subscribable {
+    constructor(config = {}) {
+      super();
+      __privateAdd(this, _queries);
+      this.config = config;
+      __privateSet(this, _queries, /* @__PURE__ */ new Map());
+    }
+    build(client, options, state) {
+      const queryKey = options.queryKey;
+      const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);
+      let query = this.get(queryHash);
+      if (!query) {
+        query = new Query({
+          client,
+          queryKey,
+          queryHash,
+          options: client.defaultQueryOptions(options),
+          state,
+          defaultOptions: client.getQueryDefaults(queryKey)
+        });
+        this.add(query);
+      }
+      return query;
+    }
+    add(query) {
+      if (!__privateGet(this, _queries).has(query.queryHash)) {
+        __privateGet(this, _queries).set(query.queryHash, query);
+        this.notify({
+          type: "added",
+          query
+        });
+      }
+    }
+    remove(query) {
+      const queryInMap = __privateGet(this, _queries).get(query.queryHash);
+      if (queryInMap) {
+        query.destroy();
+        if (queryInMap === query) {
+          __privateGet(this, _queries).delete(query.queryHash);
+        }
+        this.notify({ type: "removed", query });
+      }
+    }
+    clear() {
+      notifyManager.batch(() => {
+        this.getAll().forEach((query) => {
+          this.remove(query);
+        });
+      });
+    }
+    get(queryHash) {
+      return __privateGet(this, _queries).get(queryHash);
+    }
+    getAll() {
+      return [...__privateGet(this, _queries).values()];
+    }
+    find(filters) {
+      const defaultedFilters = { exact: true, ...filters };
+      return this.getAll().find(
+        (query) => matchQuery(defaultedFilters, query)
+      );
+    }
+    findAll(filters = {}) {
+      const queries = this.getAll();
+      return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;
+    }
+    notify(event) {
+      notifyManager.batch(() => {
+        this.listeners.forEach((listener) => {
+          listener(event);
+        });
+      });
+    }
+    onFocus() {
+      notifyManager.batch(() => {
+        this.getAll().forEach((query) => {
+          query.onFocus();
+        });
+      });
+    }
+    onOnline() {
+      notifyManager.batch(() => {
+        this.getAll().forEach((query) => {
+          query.onOnline();
+        });
+      });
+    }
+  }, _queries = new WeakMap(), _a9);
+
+  // node_modules/@tanstack/query-core/build/modern/queryClient.js
+  var _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _a10;
+  var QueryClient = (_a10 = class {
+    constructor(config = {}) {
+      __privateAdd(this, _queryCache);
+      __privateAdd(this, _mutationCache2);
+      __privateAdd(this, _defaultOptions2);
+      __privateAdd(this, _queryDefaults);
+      __privateAdd(this, _mutationDefaults);
+      __privateAdd(this, _mountCount);
+      __privateAdd(this, _unsubscribeFocus);
+      __privateAdd(this, _unsubscribeOnline);
+      __privateSet(this, _queryCache, config.queryCache || new QueryCache());
+      __privateSet(this, _mutationCache2, config.mutationCache || new MutationCache());
+      __privateSet(this, _defaultOptions2, config.defaultOptions || {});
+      __privateSet(this, _queryDefaults, /* @__PURE__ */ new Map());
+      __privateSet(this, _mutationDefaults, /* @__PURE__ */ new Map());
+      __privateSet(this, _mountCount, 0);
+    }
+    mount() {
+      __privateWrapper(this, _mountCount)._++;
+      if (__privateGet(this, _mountCount) !== 1) return;
+      __privateSet(this, _unsubscribeFocus, focusManager.subscribe(async (focused) => {
+        if (focused) {
+          await this.resumePausedMutations();
+          __privateGet(this, _queryCache).onFocus();
+        }
+      }));
+      __privateSet(this, _unsubscribeOnline, onlineManager.subscribe(async (online) => {
+        if (online) {
+          await this.resumePausedMutations();
+          __privateGet(this, _queryCache).onOnline();
+        }
+      }));
+    }
+    unmount() {
+      var _a11, _b;
+      __privateWrapper(this, _mountCount)._--;
+      if (__privateGet(this, _mountCount) !== 0) return;
+      (_a11 = __privateGet(this, _unsubscribeFocus)) == null ? void 0 : _a11.call(this);
+      __privateSet(this, _unsubscribeFocus, void 0);
+      (_b = __privateGet(this, _unsubscribeOnline)) == null ? void 0 : _b.call(this);
+      __privateSet(this, _unsubscribeOnline, void 0);
+    }
+    isFetching(filters) {
+      return __privateGet(this, _queryCache).findAll({ ...filters, fetchStatus: "fetching" }).length;
+    }
+    isMutating(filters) {
+      return __privateGet(this, _mutationCache2).findAll({ ...filters, status: "pending" }).length;
+    }
+    /**
+     * Imperative (non-reactive) way to retrieve data for a QueryKey.
+     * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates.
+     *
+     * Hint: Do not use this function inside a component, because it won't receive updates.
+     * Use `useQuery` to create a `QueryObserver` that subscribes to changes.
+     */
+    getQueryData(queryKey) {
+      const options = this.defaultQueryOptions({ queryKey });
+      return __privateGet(this, _queryCache).get(options.queryHash)?.state.data;
+    }
+    ensureQueryData(options) {
+      const defaultedOptions = this.defaultQueryOptions(options);
+      const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
+      const cachedData = query.state.data;
+      if (cachedData === void 0) {
+        return this.fetchQuery(options);
+      }
+      if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) {
+        void this.prefetchQuery(defaultedOptions);
+      }
+      return Promise.resolve(cachedData);
+    }
+    getQueriesData(filters) {
+      return __privateGet(this, _queryCache).findAll(filters).map(({ queryKey, state }) => {
+        const data = state.data;
+        return [queryKey, data];
+      });
+    }
+    setQueryData(queryKey, updater, options) {
+      const defaultedOptions = this.defaultQueryOptions({ queryKey });
+      const query = __privateGet(this, _queryCache).get(
+        defaultedOptions.queryHash
+      );
+      const prevData = query?.state.data;
+      const data = functionalUpdate(updater, prevData);
+      if (data === void 0) {
+        return void 0;
+      }
+      return __privateGet(this, _queryCache).build(this, defaultedOptions).setData(data, { ...options, manual: true });
+    }
+    setQueriesData(filters, updater, options) {
+      return notifyManager.batch(
+        () => __privateGet(this, _queryCache).findAll(filters).map(({ queryKey }) => [
+          queryKey,
+          this.setQueryData(queryKey, updater, options)
+        ])
+      );
+    }
+    getQueryState(queryKey) {
+      const options = this.defaultQueryOptions({ queryKey });
+      return __privateGet(this, _queryCache).get(
+        options.queryHash
+      )?.state;
+    }
+    removeQueries(filters) {
+      const queryCache = __privateGet(this, _queryCache);
+      notifyManager.batch(() => {
+        queryCache.findAll(filters).forEach((query) => {
+          queryCache.remove(query);
+        });
+      });
+    }
+    resetQueries(filters, options) {
+      const queryCache = __privateGet(this, _queryCache);
+      return notifyManager.batch(() => {
+        queryCache.findAll(filters).forEach((query) => {
+          query.reset();
+        });
+        return this.refetchQueries(
+          {
+            type: "active",
+            ...filters
+          },
+          options
+        );
+      });
+    }
+    cancelQueries(filters, cancelOptions = {}) {
+      const defaultedCancelOptions = { revert: true, ...cancelOptions };
+      const promises = notifyManager.batch(
+        () => __privateGet(this, _queryCache).findAll(filters).map((query) => query.cancel(defaultedCancelOptions))
+      );
+      return Promise.all(promises).then(noop).catch(noop);
+    }
+    invalidateQueries(filters, options = {}) {
+      return notifyManager.batch(() => {
+        __privateGet(this, _queryCache).findAll(filters).forEach((query) => {
+          query.invalidate();
+        });
+        if (filters?.refetchType === "none") {
+          return Promise.resolve();
+        }
+        return this.refetchQueries(
+          {
+            ...filters,
+            type: filters?.refetchType ?? filters?.type ?? "active"
+          },
+          options
+        );
+      });
+    }
+    refetchQueries(filters, options = {}) {
+      const fetchOptions = {
+        ...options,
+        cancelRefetch: options.cancelRefetch ?? true
+      };
+      const promises = notifyManager.batch(
+        () => __privateGet(this, _queryCache).findAll(filters).filter((query) => !query.isDisabled() && !query.isStatic()).map((query) => {
+          let promise = query.fetch(void 0, fetchOptions);
+          if (!fetchOptions.throwOnError) {
+            promise = promise.catch(noop);
+          }
+          return query.state.fetchStatus === "paused" ? Promise.resolve() : promise;
+        })
+      );
+      return Promise.all(promises).then(noop);
+    }
+    fetchQuery(options) {
+      const defaultedOptions = this.defaultQueryOptions(options);
+      if (defaultedOptions.retry === void 0) {
+        defaultedOptions.retry = false;
+      }
+      const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
+      return query.isStaleByTime(
+        resolveStaleTime(defaultedOptions.staleTime, query)
+      ) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
+    }
+    prefetchQuery(options) {
+      return this.fetchQuery(options).then(noop).catch(noop);
+    }
+    fetchInfiniteQuery(options) {
+      options._type = "infinite";
+      return this.fetchQuery(options);
+    }
+    prefetchInfiniteQuery(options) {
+      return this.fetchInfiniteQuery(options).then(noop).catch(noop);
+    }
+    ensureInfiniteQueryData(options) {
+      options._type = "infinite";
+      return this.ensureQueryData(options);
+    }
+    resumePausedMutations() {
+      if (onlineManager.isOnline()) {
+        return __privateGet(this, _mutationCache2).resumePausedMutations();
+      }
+      return Promise.resolve();
+    }
+    getQueryCache() {
+      return __privateGet(this, _queryCache);
+    }
+    getMutationCache() {
+      return __privateGet(this, _mutationCache2);
+    }
+    getDefaultOptions() {
+      return __privateGet(this, _defaultOptions2);
+    }
+    setDefaultOptions(options) {
+      __privateSet(this, _defaultOptions2, options);
+    }
+    setQueryDefaults(queryKey, options) {
+      __privateGet(this, _queryDefaults).set(hashKey(queryKey), {
+        queryKey,
+        defaultOptions: options
+      });
+    }
+    getQueryDefaults(queryKey) {
+      const defaults = [...__privateGet(this, _queryDefaults).values()];
+      const result = {};
+      defaults.forEach((queryDefault) => {
+        if (partialMatchKey(queryKey, queryDefault.queryKey)) {
+          Object.assign(result, queryDefault.defaultOptions);
+        }
+      });
+      return result;
+    }
+    setMutationDefaults(mutationKey, options) {
+      __privateGet(this, _mutationDefaults).set(hashKey(mutationKey), {
+        mutationKey,
+        defaultOptions: options
+      });
+    }
+    getMutationDefaults(mutationKey) {
+      const defaults = [...__privateGet(this, _mutationDefaults).values()];
+      const result = {};
+      defaults.forEach((queryDefault) => {
+        if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {
+          Object.assign(result, queryDefault.defaultOptions);
+        }
+      });
+      return result;
+    }
+    defaultQueryOptions(options) {
+      if (options._defaulted) {
+        return options;
+      }
+      const defaultedOptions = {
+        ...__privateGet(this, _defaultOptions2).queries,
+        ...this.getQueryDefaults(options.queryKey),
+        ...options,
+        _defaulted: true
+      };
+      if (!defaultedOptions.queryHash) {
+        defaultedOptions.queryHash = hashQueryKeyByOptions(
+          defaultedOptions.queryKey,
+          defaultedOptions
+        );
+      }
+      if (defaultedOptions.refetchOnReconnect === void 0) {
+        defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always";
+      }
+      if (defaultedOptions.throwOnError === void 0) {
+        defaultedOptions.throwOnError = !!defaultedOptions.suspense;
+      }
+      if (!defaultedOptions.networkMode && defaultedOptions.persister) {
+        defaultedOptions.networkMode = "offlineFirst";
+      }
+      if (defaultedOptions.queryFn === skipToken) {
+        defaultedOptions.enabled = false;
+      }
+      return defaultedOptions;
+    }
+    defaultMutationOptions(options) {
+      if (options?._defaulted) {
+        return options;
+      }
+      return {
+        ...__privateGet(this, _defaultOptions2).mutations,
+        ...options?.mutationKey && this.getMutationDefaults(options.mutationKey),
+        ...options,
+        _defaulted: true
+      };
+    }
+    clear() {
+      __privateGet(this, _queryCache).clear();
+      __privateGet(this, _mutationCache2).clear();
+    }
+  }, _queryCache = new WeakMap(), _mutationCache2 = new WeakMap(), _defaultOptions2 = new WeakMap(), _queryDefaults = new WeakMap(), _mutationDefaults = new WeakMap(), _mountCount = new WeakMap(), _unsubscribeFocus = new WeakMap(), _unsubscribeOnline = new WeakMap(), _a10);
+
+  // node_modules/@tanstack/preact-query/build/modern/IsRestoringProvider.js
+  var IsRestoringContext = R(false);
+  var useIsRestoring = () => x2(IsRestoringContext);
+  var IsRestoringProvider = IsRestoringContext.Provider;
+
   // node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js
   var f3 = 0;
   function u3(e3, t3, n2, o3, i3, u4) {
@@ -411,6 +2966,218 @@
     return l.vnode && l.vnode(l3), l3;
   }
 
+  // node_modules/@tanstack/preact-query/build/modern/QueryClientProvider.js
+  var QueryClientContext = R(
+    void 0
+  );
+  var useQueryClient = (queryClient) => {
+    const client = x2(QueryClientContext);
+    if (queryClient) {
+      return queryClient;
+    }
+    if (!client) {
+      throw new Error("No QueryClient set, use QueryClientProvider to set one");
+    }
+    return client;
+  };
+  var QueryClientProvider = ({
+    client,
+    children
+  }) => {
+    y2(() => {
+      client.mount();
+      return () => {
+        client.unmount();
+      };
+    }, [client]);
+    return /* @__PURE__ */ u3(QueryClientContext.Provider, { value: client, children });
+  };
+
+  // node_modules/@tanstack/preact-query/build/modern/QueryErrorResetBoundary.js
+  function createValue() {
+    let isReset = false;
+    return {
+      clearReset: () => {
+        isReset = false;
+      },
+      reset: () => {
+        isReset = true;
+      },
+      isReset: () => {
+        return isReset;
+      }
+    };
+  }
+  var QueryErrorResetBoundaryContext = R(createValue());
+  var useQueryErrorResetBoundary = () => x2(QueryErrorResetBoundaryContext);
+
+  // node_modules/@tanstack/preact-query/build/modern/errorBoundaryUtils.js
+  var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
+    if (options.suspense || options.throwOnError || options.experimental_prefetchInRender) {
+      if (!errorResetBoundary.isReset()) {
+        options.retryOnMount = false;
+      }
+    }
+  };
+  var useClearResetErrorBoundary = (errorResetBoundary) => {
+    y2(() => {
+      errorResetBoundary.clearReset();
+    }, [errorResetBoundary]);
+  };
+  var getHasError = ({
+    result,
+    errorResetBoundary,
+    throwOnError,
+    query,
+    suspense
+  }) => {
+    return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && (suspense && result.data === void 0 || shouldThrowError(throwOnError, [result.error, query]));
+  };
+
+  // node_modules/@tanstack/preact-query/build/modern/suspense.js
+  var ensureSuspenseTimers = (defaultedOptions) => {
+    if (defaultedOptions.suspense) {
+      const MIN_SUSPENSE_TIME_MS = 1e3;
+      const clamp = (value) => value === "static" ? value : Math.max(value ?? MIN_SUSPENSE_TIME_MS, MIN_SUSPENSE_TIME_MS);
+      const originalStaleTime = defaultedOptions.staleTime;
+      defaultedOptions.staleTime = typeof originalStaleTime === "function" ? (...args) => clamp(originalStaleTime(...args)) : clamp(originalStaleTime);
+      if (typeof defaultedOptions.gcTime === "number") {
+        defaultedOptions.gcTime = Math.max(
+          defaultedOptions.gcTime,
+          MIN_SUSPENSE_TIME_MS
+        );
+      }
+    }
+  };
+  var willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+  var shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
+  var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
+    errorResetBoundary.clearReset();
+  });
+
+  // node_modules/@tanstack/preact-query/build/modern/utils.js
+  function useSyncExternalStore(subscribe, getSnapshot) {
+    const value = getSnapshot();
+    const [{ _instance }, forceUpdate] = d2({
+      _instance: { _value: value, _getSnapshot: getSnapshot }
+    });
+    _2(() => {
+      _instance._value = value;
+      _instance._getSnapshot = getSnapshot;
+      if (didSnapshotChange(_instance)) {
+        forceUpdate({ _instance });
+      }
+    }, [subscribe, value, getSnapshot]);
+    y2(() => {
+      if (didSnapshotChange(_instance)) {
+        forceUpdate({ _instance });
+      }
+      return subscribe(() => {
+        if (didSnapshotChange(_instance)) {
+          forceUpdate({ _instance });
+        }
+      });
+    }, [subscribe]);
+    return value;
+  }
+  function didSnapshotChange(inst) {
+    const latestGetSnapshot = inst._getSnapshot;
+    const prevValue = inst._value;
+    try {
+      const nextValue = latestGetSnapshot();
+      return !Object.is(prevValue, nextValue);
+    } catch (_error) {
+      return true;
+    }
+  }
+
+  // node_modules/@tanstack/preact-query/build/modern/useBaseQuery.js
+  function useBaseQuery(options, Observer, queryClient) {
+    if (true) {
+      if (typeof options !== "object" || Array.isArray(options)) {
+        throw new Error(
+          'Bad argument type. Starting with v5, only the "Object" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'
+        );
+      }
+    }
+    const isRestoring = useIsRestoring();
+    const errorResetBoundary = useQueryErrorResetBoundary();
+    const client = useQueryClient(queryClient);
+    const defaultedOptions = client.defaultQueryOptions(options);
+    client.getDefaultOptions().queries?._experimental_beforeQuery?.(
+      defaultedOptions
+    );
+    if (true) {
+      if (!defaultedOptions.queryFn) {
+        console.error(
+          `[${defaultedOptions.queryHash}]: No queryFn was passed as an option, and no default queryFn was found. The queryFn parameter is only optional when using a default queryFn. More info here: https://tanstack.com/query/latest/docs/framework/react/guides/default-query-function`
+        );
+      }
+    }
+    defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
+    ensureSuspenseTimers(defaultedOptions);
+    ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+    useClearResetErrorBoundary(errorResetBoundary);
+    const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
+    const [observer] = d2(
+      () => new Observer(
+        client,
+        defaultedOptions
+      )
+    );
+    const result = observer.getOptimisticResult(defaultedOptions);
+    const shouldSubscribe = !isRestoring && options.subscribed !== false;
+    useSyncExternalStore(
+      q2(
+        (onStoreChange) => {
+          const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
+          observer.updateResult();
+          return unsubscribe;
+        },
+        [observer, shouldSubscribe]
+      ),
+      () => observer.getCurrentResult()
+    );
+    y2(() => {
+      observer.setOptions(defaultedOptions);
+    }, [defaultedOptions, observer]);
+    if (shouldSuspend(defaultedOptions, result)) {
+      throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+    }
+    if (getHasError({
+      result,
+      errorResetBoundary,
+      throwOnError: defaultedOptions.throwOnError,
+      query: client.getQueryCache().get(defaultedOptions.queryHash),
+      suspense: defaultedOptions.suspense
+    })) {
+      throw result.error;
+    }
+    ;
+    client.getDefaultOptions().queries?._experimental_afterQuery?.(
+      defaultedOptions,
+      result
+    );
+    if (defaultedOptions.experimental_prefetchInRender && !environmentManager.isServer() && willFetch(result, isRestoring)) {
+      const promise = isNewCacheEntry ? (
+        // Fetch immediately on render in order to ensure `.promise` is resolved even if the component is unmounted
+        fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
+      ) : (
+        // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
+        client.getQueryCache().get(defaultedOptions.queryHash)?.promise
+      );
+      promise?.catch(noop).finally(() => {
+        observer.updateResult();
+      });
+    }
+    return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+  }
+
+  // node_modules/@tanstack/preact-query/build/modern/useQuery.js
+  function useQuery(options, queryClient) {
+    return useBaseQuery(options, QueryObserver, queryClient);
+  }
+
   // app/assets/typescript/profiler/components/toolbar/ToolbarItem.tsx
   function ToolbarItem({ children, panel, href, className, panelLarge }) {
     const [visible, setVisible] = d2(false);
@@ -1379,6 +4146,52 @@
     ] }) });
   }
 
+  // app/assets/typescript/profiler/api-fetcher.ts
+  async function apiFetch(config) {
+    const { url, method, params, data, headers = {}, signal } = config;
+    const qs = params ? "?" + new URLSearchParams(Object.entries(params).map(([k3, v3]) => [k3, String(v3)])).toString() : "";
+    const res = await fetch(url + qs, {
+      method,
+      signal,
+      headers: data !== void 0 ? { "Content-Type": "application/json", ...headers } : headers,
+      body: data !== void 0 ? JSON.stringify(data) : void 0
+    });
+    if (res.status === 204) return {};
+    const json = await res.json();
+    if (!res.ok) {
+      throw Object.assign(new Error(json?.error ?? `HTTP ${res.status}`), { status: res.status, data: json });
+    }
+    return json;
+  }
+
+  // app/assets/typescript/profiler/generated/api.ts
+  var getToolbar = (token, signal) => {
+    return apiFetch(
+      {
+        url: `/_profiler/api/toolbar/${token}`,
+        method: "GET",
+        signal
+      }
+    );
+  };
+  var getGetToolbarQueryKey = (token) => {
+    return [
+      `/_profiler/api/toolbar/${token}`
+    ];
+  };
+  var getGetToolbarQueryOptions = (token, options) => {
+    const { query: queryOptions } = options ?? {};
+    const queryKey = queryOptions?.queryKey ?? getGetToolbarQueryKey(token);
+    const queryFn = ({ signal }) => getToolbar(token, signal);
+    return { queryKey, queryFn, enabled: !!token, ...queryOptions };
+  };
+  function useGetToolbar(token, options) {
+    const queryOptions = getGetToolbarQueryOptions(token, options);
+    const query = useQuery(queryOptions);
+    query.queryKey = queryOptions.queryKey;
+    return query;
+  }
+
   // app/assets/typescript/profiler/toolbar-bundle.tsx
   var ANIM_MS = 280;
   function applyTheme(elements) {
@@ -1386,17 +4199,17 @@
     const theme = stored === "light" ? "light" : stored === "dark" ? "dark" : window.matchMedia("(prefers-color-scheme: light)").matches ? "light" : "dark";
     elements.forEach((el) => el.setAttribute("data-theme", theme));
   }
+  var toolbarQueryClient = new QueryClient({
+    defaultOptions: { queries: { staleTime: 3e4, retry: 1 } }
+  });
   function ToolbarMount({ token }) {
-    const [profile, setProfile] = d2(null);
+    const { data, refetch } = useGetToolbar(token, { query: { refetchOnWindowFocus: false } });
     y2(() => {
-      const load = () => {
-        fetch(`/_profiler/api/toolbar/${token}`).then((res) => res.json()).then((data) => {
-          if (data.profile) setProfile(data.profile);
-        }).catch((err) => console.debug("Profiler toolbar load failed:", err));
+      window.__PROFILER_REFRESH_TOOLBAR__ = () => {
+        refetch();
       };
-      window.__PROFILER_REFRESH_TOOLBAR__ = load;
-      load();
-    }, [token]);
+    }, [refetch]);
+    const profile = data?.profile ?? null;
     if (!profile) return null;
     return /* @__PURE__ */ u3(ToolbarApp, { profile, token });
   }
@@ -1452,7 +4265,10 @@
         toggleCollapse();
       }
     });
-    J(/* @__PURE__ */ u3(ToolbarMount, { token }), el);
+    J(
+      /* @__PURE__ */ u3(QueryClientProvider, { client: toolbarQueryClient, children: /* @__PURE__ */ u3(ToolbarMount, { token }) }),
+      el
+    );
   }
   if (document.readyState === "loading") {
     document.addEventListener("DOMContentLoaded", mountToolbar);