@oj-module/cli 0.2.64 → 0.2.67

package/shell-dist/assets/react-query.js

@@ -1,3072 +0,0 @@
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/index.js
-var modern_exports = {};
-__export(modern_exports, {
-  CancelledError: () => CancelledError,
-  HydrationBoundary: () => HydrationBoundary,
-  InfiniteQueryObserver: () => InfiniteQueryObserver,
-  IsRestoringProvider: () => IsRestoringProvider,
-  Mutation: () => Mutation,
-  MutationCache: () => MutationCache,
-  MutationObserver: () => MutationObserver,
-  QueriesObserver: () => QueriesObserver,
-  Query: () => Query,
-  QueryCache: () => QueryCache,
-  QueryClient: () => QueryClient,
-  QueryClientContext: () => QueryClientContext,
-  QueryClientProvider: () => QueryClientProvider,
-  QueryErrorResetBoundary: () => QueryErrorResetBoundary,
-  QueryObserver: () => QueryObserver,
-  dataTagErrorSymbol: () => dataTagErrorSymbol,
-  dataTagSymbol: () => dataTagSymbol,
-  defaultScheduler: () => defaultScheduler,
-  defaultShouldDehydrateMutation: () => defaultShouldDehydrateMutation,
-  defaultShouldDehydrateQuery: () => defaultShouldDehydrateQuery,
-  dehydrate: () => dehydrate,
-  dehydrateQuery: () => dehydrateQuery,
-  environmentManager: () => environmentManager,
-  experimental_streamedQuery: () => streamedQuery,
-  focusManager: () => focusManager,
-  hashKey: () => hashKey,
-  hydrate: () => hydrate,
-  infiniteQueryOptions: () => infiniteQueryOptions,
-  isCancelledError: () => isCancelledError,
-  isServer: () => isServer,
-  keepPreviousData: () => keepPreviousData,
-  matchMutation: () => matchMutation,
-  matchQuery: () => matchQuery,
-  mutationOptions: () => mutationOptions,
-  noop: () => noop,
-  notifyManager: () => notifyManager,
-  onlineManager: () => onlineManager,
-  partialMatchKey: () => partialMatchKey,
-  queryOptions: () => queryOptions,
-  replaceEqualDeep: () => replaceEqualDeep,
-  shouldThrowError: () => shouldThrowError,
-  skipToken: () => skipToken,
-  timeoutManager: () => timeoutManager,
-  unsetMarker: () => unsetMarker,
-  useInfiniteQuery: () => useInfiniteQuery,
-  useIsFetching: () => useIsFetching,
-  useIsMutating: () => useIsMutating,
-  useIsRestoring: () => useIsRestoring,
-  useMutation: () => useMutation,
-  useMutationState: () => useMutationState,
-  usePrefetchInfiniteQuery: () => usePrefetchInfiniteQuery,
-  usePrefetchQuery: () => usePrefetchQuery,
-  useQueries: () => useQueries,
-  useQuery: () => useQuery,
-  useQueryClient: () => useQueryClient,
-  useQueryErrorResetBoundary: () => useQueryErrorResetBoundary,
-  useSuspenseInfiniteQuery: () => useSuspenseInfiniteQuery,
-  useSuspenseQueries: () => useSuspenseQueries,
-  useSuspenseQuery: () => useSuspenseQuery
-});
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js
-import * as React from "react";
-import { jsx } from "react/jsx-runtime";
-var QueryClientContext = React.createContext(void 0);
-var useQueryClient = (queryClient) => {
-  const client = React.useContext(QueryClientContext);
-  if (queryClient) return queryClient;
-  if (!client) throw new Error("No QueryClient set, use QueryClientProvider to set one");
-  return client;
-};
-var QueryClientProvider = ({ client, children }) => {
-  React.useEffect(() => {
-    client.mount();
-    return () => {
-      client.unmount();
-    };
-  }, [client]);
-  return /* @__PURE__ */ jsx(QueryClientContext.Provider, {
-    value: client,
-    children
-  });
-};
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/HydrationBoundary.js
-import * as React2 from "react";
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/timeoutManager.js
-var defaultTimeoutProvider = {
-  setTimeout: (callback, delay) => setTimeout(callback, delay),
-  clearTimeout: (timeoutId) => clearTimeout(timeoutId),
-  setInterval: (callback, delay) => setInterval(callback, delay),
-  clearInterval: (intervalId) => clearInterval(intervalId)
-};
-var _provider, _providerCalled, _a;
-var TimeoutManager = (_a = class {
-  constructor() {
-    __privateAdd(this, _provider, defaultTimeoutProvider);
-    __privateAdd(this, _providerCalled, false);
-  }
-  setTimeoutProvider(provider) {
-    if (false) {
-      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 (false) __privateSet(this, _providerCalled, false);
-  }
-  setTimeout(callback, delay) {
-    if (false) __privateSet(this, _providerCalled, true);
-    return __privateGet(this, _provider).setTimeout(callback, delay);
-  }
-  clearTimeout(timeoutId) {
-    __privateGet(this, _provider).clearTimeout(timeoutId);
-  }
-  setInterval(callback, delay) {
-    if (false) __privateSet(this, _providerCalled, true);
-    return __privateGet(this, _provider).setInterval(callback, delay);
-  }
-  clearInterval(intervalId) {
-    __privateGet(this, _provider).clearInterval(intervalId);
-  }
-}, _provider = new WeakMap(), _providerCalled = new WeakMap(), _a);
-var timeoutManager = new TimeoutManager();
-function systemSetTimeoutZero(callback) {
-  setTimeout(callback, 0);
-}
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/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 resolveQueryValue(value, query) {
-  return typeof value === "function" ? value(query) : value;
-}
-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) {
-  return (options?.queryKeyHashFn || hashKey)(queryKey);
-}
-function hashKey(queryKey) {
-  return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
-    result[key] = val[key];
-    return result;
-  }, {}) : val);
-}
-function partialMatchKey(a, b) {
-  if (a === b) return true;
-  if (typeof a !== typeof b) return false;
-  if (a && b && typeof a === "object" && typeof b === "object") {
-    if (Array.isArray(a) && Array.isArray(b)) {
-      for (let i = 0; i < b.length; i++) if (!partialMatchKey(a[i], b[i])) return false;
-      return true;
-    }
-    const bKeys = Object.keys(b);
-    for (const key of bKeys) if (!partialMatchKey(a[key], b[key])) return false;
-    return true;
-  }
-  return false;
-}
-var hasOwn = Object.prototype.hasOwnProperty;
-function replaceEqualDeep(a, b, depth = 0) {
-  if (a === b) return a;
-  if (depth > 500) return b;
-  const array = isPlainArray(a) && isPlainArray(b);
-  if (!array && !(isPlainObject(a) && isPlainObject(b))) return b;
-  const aSize = (array ? a : Object.keys(a)).length;
-  const bItems = array ? b : Object.keys(b);
-  const bSize = bItems.length;
-  const copy = array ? new Array(bSize) : {};
-  let equalItems = 0;
-  for (let i = 0; i < bSize; i++) {
-    const key = array ? i : bItems[i];
-    const aItem = a[key];
-    const bItem = b[key];
-    if (aItem === bItem) {
-      copy[key] = aItem;
-      if (array ? i < aSize : hasOwn.call(a, key)) equalItems++;
-      continue;
-    }
-    if (aItem === null || bItem === null || typeof aItem !== "object" || typeof bItem !== "object") {
-      copy[key] = bItem;
-      continue;
-    }
-    const v = replaceEqualDeep(aItem, bItem, depth + 1);
-    copy[key] = v;
-    if (v === aItem) equalItems++;
-  }
-  return aSize === bSize && equalItems === aSize ? a : copy;
-}
-function shallowEqualObjects(a, b) {
-  if (!b || Object.keys(a).length !== Object.keys(b).length) return false;
-  for (const key in a) if (a[key] !== b[key]) return false;
-  return true;
-}
-function isPlainArray(value) {
-  return Array.isArray(value) && value.length === Object.keys(value).length;
-}
-function isPlainObject(o) {
-  if (!hasObjectPrototype(o)) return false;
-  const ctor = o.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(o) !== Object.prototype) return false;
-  return true;
-}
-function hasObjectPrototype(o) {
-  return Object.prototype.toString.call(o) === "[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 (false) 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 keepPreviousData(previousData) {
-  return previousData;
-}
-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 (false) {
-    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(/* @__PURE__ */ 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/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/environmentManager.js
-var isServerFn = () => isServer;
-var isServer2 = () => isServerFn();
-var environmentManager = {
-  isServer: isServer2,
-  /**
-  * Overrides the server check globally.
-  */
-  setIsServer(isServerValue) {
-    isServerFn = isServerValue;
-  }
-};
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/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/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/focusManager.js
-var _focused, _cleanup, _setup, _a2;
-var FocusManager = (_a2 = 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);
-        };
-      }
-    });
-  }
-  onSubscribe() {
-    if (!__privateGet(this, _cleanup)) this.setEventListener(__privateGet(this, _setup));
-  }
-  onUnsubscribe() {
-    var _a13;
-    if (!this.hasListeners()) {
-      (_a13 = __privateGet(this, _cleanup)) == null ? void 0 : _a13.call(this);
-      __privateSet(this, _cleanup, void 0);
-    }
-  }
-  setEventListener(setup) {
-    var _a13;
-    __privateSet(this, _setup, setup);
-    (_a13 = __privateGet(this, _cleanup)) == null ? void 0 : _a13.call(this);
-    __privateSet(this, _cleanup, setup((focused) => {
-      if (typeof focused === "boolean") this.setFocused(focused);
-      else this.onFocus();
-    }));
-  }
-  setFocused(focused) {
-    if (__privateGet(this, _focused) !== focused) {
-      __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(), _a2);
-var focusManager = new FocusManager();
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/hydration.js
-function tryResolveSync(promise) {
-  let data;
-  promise.then((result) => {
-    data = result;
-    return result;
-  }, noop)?.catch?.(noop);
-  if (data !== void 0) return { data };
-}
-function dehydrateMutation(mutation) {
-  return {
-    mutationKey: mutation.options.mutationKey,
-    state: mutation.state,
-    ...mutation.options.scope && { scope: mutation.options.scope },
-    ...mutation.meta && { meta: mutation.meta }
-  };
-}
-function dehydratePromise(query, serializeData, shouldRedactErrors) {
-  const promise = query.promise?.then(serializeData).catch((error) => {
-    if (shouldRedactErrors?.(error) === false) return Promise.reject(error);
-    if (false) console.error(`A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`);
-    return Promise.reject(/* @__PURE__ */ new Error("redacted"));
-  });
-  promise?.catch(noop);
-  return promise;
-}
-function dehydrateQuery(query, serializeData, shouldRedactErrors) {
-  return {
-    dehydratedAt: Date.now(),
-    state: {
-      ...query.state,
-      ...query.state.data !== void 0 && { data: serializeData ? serializeData(query.state.data) : query.state.data }
-    },
-    queryKey: query.queryKey,
-    queryHash: query.queryHash,
-    ...query.state.status === "pending" && { promise: dehydratePromise(query, serializeData, shouldRedactErrors) },
-    ...query.meta && { meta: query.meta },
-    ...query.queryType && { queryType: query.queryType }
-  };
-}
-function defaultShouldDehydrateMutation(mutation) {
-  return mutation.state.isPaused;
-}
-function defaultShouldDehydrateQuery(query) {
-  return query.state.status === "success";
-}
-function dehydrate(client, options = {}) {
-  const filterMutation = options.shouldDehydrateMutation ?? client.getDefaultOptions().dehydrate?.shouldDehydrateMutation ?? defaultShouldDehydrateMutation;
-  const mutations = client.getMutationCache().getAll().flatMap((mutation) => filterMutation(mutation) ? [dehydrateMutation(mutation)] : []);
-  const filterQuery = options.shouldDehydrateQuery ?? client.getDefaultOptions().dehydrate?.shouldDehydrateQuery ?? defaultShouldDehydrateQuery;
-  const shouldRedactErrors = options.shouldRedactErrors ?? client.getDefaultOptions().dehydrate?.shouldRedactErrors;
-  const serializeData = options.serializeData ?? client.getDefaultOptions().dehydrate?.serializeData;
-  return {
-    mutations,
-    queries: client.getQueryCache().getAll().flatMap((query) => filterQuery(query) ? [dehydrateQuery(query, serializeData, shouldRedactErrors)] : [])
-  };
-}
-function hydrate(client, dehydratedState, options) {
-  const mutationCache = client.getMutationCache();
-  const queryCache = client.getQueryCache();
-  const deserializeData = options?.defaultOptions?.deserializeData ?? client.getDefaultOptions().hydrate?.deserializeData;
-  dehydratedState.mutations?.forEach(({ state, ...mutationOptions2 }) => {
-    mutationCache.build(client, {
-      ...client.getDefaultOptions().hydrate?.mutations,
-      ...options?.defaultOptions?.mutations,
-      ...mutationOptions2
-    }, state);
-  });
-  dehydratedState.queries?.forEach(({ queryKey, state, queryHash, meta, promise, dehydratedAt, queryType }) => {
-    const syncData = promise ? tryResolveSync(promise) : void 0;
-    const rawData = state.data === void 0 ? syncData?.data : state.data;
-    const data = rawData === void 0 ? rawData : deserializeData ? deserializeData(rawData) : rawData;
-    let query = queryCache.get(queryHash);
-    const existingQueryIsPending = query?.state.status === "pending";
-    const existingQueryIsFetching = query?.state.fetchStatus === "fetching";
-    if (query) {
-      const hasNewerSyncData = syncData && dehydratedAt !== void 0 && dehydratedAt > query.state.dataUpdatedAt;
-      if (state.dataUpdatedAt > query.state.dataUpdatedAt || hasNewerSyncData) {
-        const { fetchStatus: _ignored, ...serializedState } = state;
-        query.setState({
-          ...serializedState,
-          data,
-          ...state.status === "pending" && data !== void 0 && {
-            status: "success",
-            dataUpdatedAt: dehydratedAt ?? Date.now(),
-            ...!existingQueryIsFetching && { fetchStatus: "idle" }
-          }
-        });
-      }
-    } else query = queryCache.build(client, {
-      ...client.getDefaultOptions().hydrate?.queries,
-      ...options?.defaultOptions?.queries,
-      queryKey,
-      queryHash,
-      meta,
-      _type: queryType
-    }, {
-      ...state,
-      data,
-      fetchStatus: "idle",
-      status: state.status === "pending" && data !== void 0 ? "success" : state.status,
-      ...state.status === "pending" && data !== void 0 && { dataUpdatedAt: dehydratedAt ?? Date.now() }
-    });
-    if (promise && !syncData && !existingQueryIsPending && !existingQueryIsFetching && (dehydratedAt === void 0 || dehydratedAt > query.state.dataUpdatedAt)) query.fetch(void 0, { initialPromise: Promise.resolve(promise).then(deserializeData) }).catch(noop);
-  });
-}
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/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/.pnpm/@tanstack+query-core@5.102.8/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);
-        };
-      }
-    });
-  }
-  onSubscribe() {
-    if (!__privateGet(this, _cleanup2)) this.setEventListener(__privateGet(this, _setup2));
-  }
-  onUnsubscribe() {
-    var _a13;
-    if (!this.hasListeners()) {
-      (_a13 = __privateGet(this, _cleanup2)) == null ? void 0 : _a13.call(this);
-      __privateSet(this, _cleanup2, void 0);
-    }
-  }
-  setEventListener(setup) {
-    var _a13;
-    __privateSet(this, _setup2, setup);
-    (_a13 = __privateGet(this, _cleanup2)) == null ? void 0 : _a13.call(this);
-    __privateSet(this, _cleanup2, setup(this.setOnline.bind(this)));
-  }
-  setOnline(online) {
-    if (__privateGet(this, _online) !== online) {
-      __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/.pnpm/@tanstack+query-core@5.102.8/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 isCancelledError(value) {
-  return value instanceof CancelledError;
-}
-function createRetryer(config) {
-  let isRetryCancelled = false;
-  let failureCount = 0;
-  let continueFn;
-  let status = "pending";
-  let promiseResolve;
-  let promiseReject;
-  const promise = new Promise((resolve2, reject2) => {
-    promiseResolve = resolve2;
-    promiseReject = reject2;
-  });
-  promise.catch(noop);
-  const isResolved = () => 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?.();
-      status = "resolved";
-      promiseResolve(value);
-    }
-  };
-  const reject = (value) => {
-    if (!isResolved()) {
-      continueFn?.();
-      status = "rejected";
-      promiseReject(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 ?? (isServer2() ? 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,
-    status: () => status,
-    cancel,
-    continue: () => {
-      continueFn?.();
-      return promise;
-    },
-    cancelRetry,
-    continueRetry,
-    canStart,
-    start: () => {
-      if (canStart()) run();
-      else pause().then(run);
-      return promise;
-    }
-  };
-}
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/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 ?? (isServer2() ? Infinity : 3e5));
-  }
-  clearGcTimeout() {
-    if (__privateGet(this, _gcTimeout) !== void 0) {
-      timeoutManager.clearTimeout(__privateGet(this, _gcTimeout));
-      __privateSet(this, _gcTimeout, void 0);
-    }
-  }
-}, _gcTimeout = new WeakMap(), _a4);
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/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
-        };
-        result = await fetchPage(oldData, pageParamFn(options, oldData), 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;
-}
-function hasNextPage(options, data) {
-  if (!data) return false;
-  return getNextPageParam(options, data) != null;
-}
-function hasPreviousPage(options, data) {
-  if (!data || !options.getPreviousPageParam) return false;
-  return getPreviousPageParam(options, data) != null;
-}
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/query.js
-var _queryType, _initialState, _revertState, _cache, _client, _retryer, _defaultOptions, _abortSignalConsumed, _Query_instances, 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) => resolveQueryValue(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) => resolveQueryValue(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() {
-    this.observers.find((x) => x.shouldFetchOnWindowFocus())?.refetch({ cancelRefetch: false });
-    __privateGet(this, _retryer)?.continue();
-  }
-  onOnline() {
-    this.observers.find((x) => x.shouldFetchOnReconnect())?.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) {
-    const index = this.observers.indexOf(observer);
-    if (index !== -1) {
-      this.observers.splice(index, 1);
-      if (!this.observers.length) {
-        if (__privateGet(this, _retryer)) {
-          if (__privateGet(this, _abortSignalConsumed) || this.state.fetchStatus === "paused" && this.state.status === "pending") __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" && __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((x) => x.options.queryFn);
-      if (observer) this.setOptions(observer.options);
-    }
-    if (false) {
-      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();
-    (__privateGet(this, _queryType) === "infinite" ? infiniteQueryBehavior(this.options.pages) : this.options.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
-    });
-    const retryer = __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 retryer.start();
-      if (data === void 0) {
-        if (false) 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 {
-      if (__privateGet(this, _retryer) === retryer) __privateSet(this, _retryer, void 0);
-      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(), 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",
-          isInvalidated: true
-        };
-      case "invalidate":
-        return {
-          ...state,
-          isInvalidated: true
-        };
-      case "setState":
-        return {
-          ...state,
-          ...action.state
-        };
-    }
-  };
-  this.state = reducer(this.state);
-  notifyManager.batch(() => {
-    this.observers.slice().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/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/queryObserver.js
-var _client2, _currentQuery, _currentQueryInitialState, _currentResult, _currentResultState, _currentResultOptions, _selectError, _selectFn, _selectResult, _lastQueryWithDefinedData, _staleTimeoutId, _refetchIntervalId, _currentRefetchInterval, _trackedProps, _QueryObserver_instances, executeFetch_fn, shouldScheduleTimer_fn, updateStaleTimeout_fn, computeRefetchInterval_fn, updateRefetchInterval_fn, updateTimers_fn, clearStaleTimeout_fn, clearRefetchInterval_fn, updateQuery_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, _selectError);
-    __privateAdd(this, _selectFn);
-    __privateAdd(this, _selectResult);
-    __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);
-    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 resolveQueryValue(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 || resolveQueryValue(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveQueryValue(prevOptions.enabled, __privateGet(this, _currentQuery)) || resolveQueryValue(this.options.staleTime, __privateGet(this, _currentQuery)) !== resolveQueryValue(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 || resolveQueryValue(this.options.enabled, __privateGet(this, _currentQuery)) !== resolveQueryValue(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 (!shallowEqualObjects(this.getCurrentResult(), 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);
-      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);
-    let unsubscribe = () => {
-    };
-    let resolveEarly;
-    const cachePromise = new Promise((resolve) => {
-      resolveEarly = resolve;
-      unsubscribe = __privateGet(this, _client2).getQueryCache().subscribe((event) => {
-        if (event.type === "updated" && event.query.queryHash === query.queryHash && query.state.data !== void 0) {
-          unsubscribe();
-          resolve(this.createResult(query, defaultedOptions));
-        }
-      });
-    });
-    return Promise.race([query.fetch().then(() => {
-      const result = this.createResult(query, defaultedOptions);
-      resolveEarly?.(result);
-      return result;
-    }).finally(() => {
-      unsubscribe();
-    }), cachePromise]);
-  }
-  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 queryInitialState = query !== prevQuery ? 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);
-      }
-    } else if (data === void 0) __privateSet(this, _selectError, null);
-    if (__privateGet(this, _selectError)) {
-      error = __privateGet(this, _selectError);
-      data = __privateGet(this, _selectResult);
-      errorUpdatedAt = Date.now();
-      status = "error";
-      isPlaceholderData = false;
-    }
-    const isFetching = newState.fetchStatus === "fetching";
-    const isPending = status === "pending";
-    const isError = status === "error";
-    const isLoading = isPending && isFetching;
-    const hasData = data !== void 0;
-    return {
-      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,
-      isEnabled: resolveQueryValue(options.enabled, query) !== false
-    };
-  }
-  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;
-        return __privateGet(this, _currentResult)[typedKey] !== prevResult[typedKey] && includedProps.has(typedKey);
-      });
-    };
-    const notifyListeners = shouldNotifyListeners();
-    notifyManager.batch(() => {
-      if (notifyListeners) this.listeners.forEach((listener) => {
-        listener(__privateGet(this, _currentResult));
-      });
-      __privateGet(this, _client2).getQueryCache().notify({
-        query: __privateGet(this, _currentQuery),
-        type: "observerResultsUpdated"
-      });
-    });
-  }
-  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(), _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;
-}, shouldScheduleTimer_fn = function(timeout) {
-  return !isServer2() && resolveQueryValue(this.options.enabled, __privateGet(this, _currentQuery)) !== false && isValidTimeout(timeout);
-}, updateStaleTimeout_fn = function() {
-  __privateMethod(this, _QueryObserver_instances, clearStaleTimeout_fn).call(this);
-  const staleTime = resolveQueryValue(this.options.staleTime, __privateGet(this, _currentQuery));
-  if (__privateGet(this, _currentResult).isStale || !__privateMethod(this, _QueryObserver_instances, shouldScheduleTimer_fn).call(this, staleTime)) return;
-  const timeout = timeUntilStale(__privateGet(this, _currentResult).dataUpdatedAt, staleTime) + 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 (__privateGet(this, _currentRefetchInterval) === 0 || !__privateMethod(this, _QueryObserver_instances, shouldScheduleTimer_fn).call(this, __privateGet(this, _currentRefetchInterval))) 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);
-  }
-}, _a6);
-function shouldLoadOnMount(query, options) {
-  return resolveQueryValue(options.enabled, query) !== false && query.state.data === void 0 && !(query.state.status === "error" && resolveQueryValue(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 (resolveQueryValue(options.enabled, query) !== false && resolveQueryValue(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 || resolveQueryValue(prevOptions.enabled, query) === false) && (!options.suspense || query.state.status !== "error") && isStale(query, options);
-}
-function isStale(query, options) {
-  return resolveQueryValue(options.enabled, query) !== false && query.isStaleByTime(resolveQueryValue(options.staleTime, query));
-}
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/infiniteQueryObserver.js
-var InfiniteQueryObserver = class extends QueryObserver {
-  constructor(client, options) {
-    super(client, options);
-  }
-  bindMethods() {
-    super.bindMethods();
-    this.fetchNextPage = this.fetchNextPage.bind(this);
-    this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
-  }
-  setOptions(options) {
-    options._type = "infinite";
-    super.setOptions(options);
-  }
-  getOptimisticResult(options) {
-    options._type = "infinite";
-    return super.getOptimisticResult(options);
-  }
-  fetchNextPage(options) {
-    return this.fetch({
-      ...options,
-      meta: { fetchMore: { direction: "forward" } }
-    });
-  }
-  fetchPreviousPage(options) {
-    return this.fetch({
-      ...options,
-      meta: { fetchMore: { direction: "backward" } }
-    });
-  }
-  createResult(query, options) {
-    const { state } = query;
-    const parentResult = super.createResult(query, options);
-    const { isFetching, isRefetching, isError, isRefetchError } = parentResult;
-    const fetchDirection = state.fetchMeta?.fetchMore?.direction;
-    const isFetchNextPageError = isError && fetchDirection === "forward";
-    const isFetchingNextPage = isFetching && fetchDirection === "forward";
-    const isFetchPreviousPageError = isError && fetchDirection === "backward";
-    const isFetchingPreviousPage = isFetching && fetchDirection === "backward";
-    return {
-      ...parentResult,
-      fetchNextPage: this.fetchNextPage,
-      fetchPreviousPage: this.fetchPreviousPage,
-      hasNextPage: hasNextPage(options, state.data),
-      hasPreviousPage: hasPreviousPage(options, state.data),
-      isFetchNextPageError,
-      isFetchingNextPage,
-      isFetchPreviousPageError,
-      isFetchingPreviousPage,
-      isRefetchError: isRefetchError && !isFetchNextPageError && !isFetchPreviousPageError,
-      isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
-    };
-  }
-};
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/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
-      });
-    }
-  }
-  removeObserver(observer) {
-    __privateSet(this, _observers, __privateGet(this, _observers).filter((x) => x !== 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() ?? (this.state.status === "pending" ? this.execute(this.state.variables) : Promise.resolve());
-  }
-  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
-    };
-    const retryer = __privateSet(this, _retryer2, createRetryer({
-      fn: () => {
-        if (!this.options.mutationFn) return Promise.reject(/* @__PURE__ */ 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 = !retryer.canStart();
-    try {
-      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 retryer.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 (e) {
-        Promise.reject(e);
-      }
-      try {
-        await this.options.onError?.(error, variables, this.state.context, mutationFnContext);
-      } catch (e) {
-        Promise.reject(e);
-      }
-      try {
-        await __privateGet(this, _mutationCache).config.onSettled?.(void 0, error, this.state.variables, this.state.context, this, mutationFnContext);
-      } catch (e) {
-        Promise.reject(e);
-      }
-      try {
-        await this.options.onSettled?.(void 0, error, variables, this.state.context, mutationFnContext);
-      } catch (e) {
-        Promise.reject(e);
-      }
-      __privateMethod(this, _Mutation_instances, dispatch_fn2).call(this, {
-        type: "error",
-        error
-      });
-      throw error;
-    } finally {
-      if (__privateGet(this, _retryer2) === retryer) __privateSet(this, _retryer2, void 0);
-      __privateGet(this, _mutationCache).runNext(this);
-    }
-  }
-}, _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
-  };
-}
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/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 firstPendingMutation = __privateGet(this, _scopes).get(scope)?.find((m) => m.state.status === "pending");
-      return !firstPendingMutation || firstPendingMutation === mutation;
-    } else return true;
-  }
-  runNext(mutation) {
-    const scope = scopeFor(mutation);
-    if (typeof scope === "string") return __privateGet(this, _scopes).get(scope)?.find((m) => m !== mutation && m.state.isPaused)?.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((x) => x.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/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/mutationObserver.js
-var _client4, _currentResult2, _currentMutation, _mutateOptions, _MutationObserver_instances, updateResult_fn, notify_fn, _a9;
-var MutationObserver = (_a9 = class extends Subscribable {
-  constructor(client, options) {
-    super();
-    __privateAdd(this, _MutationObserver_instances);
-    __privateAdd(this, _client4);
-    __privateAdd(this, _currentResult2);
-    __privateAdd(this, _currentMutation);
-    __privateAdd(this, _mutateOptions);
-    __privateSet(this, _client4, client);
-    this.setOptions(options);
-    this.bindMethods();
-    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
-  }
-  bindMethods() {
-    this.mutate = this.mutate.bind(this);
-    this.reset = this.reset.bind(this);
-  }
-  setOptions(options) {
-    const prevOptions = this.options;
-    this.options = __privateGet(this, _client4).defaultMutationOptions(options);
-    if (!shallowEqualObjects(this.options, prevOptions)) __privateGet(this, _client4).getMutationCache().notify({
-      type: "observerOptionsUpdated",
-      mutation: __privateGet(this, _currentMutation),
-      observer: this
-    });
-    if (prevOptions?.mutationKey && this.options.mutationKey && hashKey(prevOptions.mutationKey) !== hashKey(this.options.mutationKey)) this.reset();
-    else if (__privateGet(this, _currentMutation)?.state.status === "pending") __privateGet(this, _currentMutation).setOptions(this.options);
-  }
-  onSubscribe() {
-    if (this.listeners.size === 1 && __privateGet(this, _currentMutation)) {
-      __privateGet(this, _currentMutation).addObserver(this);
-      __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
-    }
-  }
-  onUnsubscribe() {
-    if (!this.hasListeners()) __privateGet(this, _currentMutation)?.removeObserver(this);
-  }
-  onMutationUpdate(action) {
-    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
-    __privateMethod(this, _MutationObserver_instances, notify_fn).call(this, action);
-  }
-  getCurrentResult() {
-    return __privateGet(this, _currentResult2);
-  }
-  reset() {
-    __privateGet(this, _currentMutation)?.removeObserver(this);
-    __privateSet(this, _currentMutation, void 0);
-    __privateMethod(this, _MutationObserver_instances, updateResult_fn).call(this);
-    __privateMethod(this, _MutationObserver_instances, notify_fn).call(this);
-  }
-  mutate(variables, options) {
-    __privateSet(this, _mutateOptions, options);
-    __privateGet(this, _currentMutation)?.removeObserver(this);
-    __privateSet(this, _currentMutation, __privateGet(this, _client4).getMutationCache().build(__privateGet(this, _client4), this.options));
-    __privateGet(this, _currentMutation).addObserver(this);
-    return __privateGet(this, _currentMutation).execute(variables);
-  }
-}, _client4 = new WeakMap(), _currentResult2 = new WeakMap(), _currentMutation = new WeakMap(), _mutateOptions = new WeakMap(), _MutationObserver_instances = new WeakSet(), updateResult_fn = function() {
-  const state = __privateGet(this, _currentMutation)?.state ?? getDefaultState2();
-  __privateSet(this, _currentResult2, {
-    ...state,
-    isPending: state.status === "pending",
-    isSuccess: state.status === "success",
-    isError: state.status === "error",
-    isIdle: state.status === "idle",
-    mutate: this.mutate,
-    reset: this.reset
-  });
-}, notify_fn = function(action) {
-  notifyManager.batch(() => {
-    if (__privateGet(this, _mutateOptions) && this.hasListeners()) {
-      const variables = __privateGet(this, _currentResult2).variables;
-      const onMutateResult = __privateGet(this, _currentResult2).context;
-      const context = {
-        client: __privateGet(this, _client4),
-        meta: this.options.meta,
-        mutationKey: this.options.mutationKey
-      };
-      if (action?.type === "success") {
-        try {
-          __privateGet(this, _mutateOptions).onSuccess?.(action.data, variables, onMutateResult, context);
-        } catch (e) {
-          Promise.reject(e);
-        }
-        try {
-          __privateGet(this, _mutateOptions).onSettled?.(action.data, null, variables, onMutateResult, context);
-        } catch (e) {
-          Promise.reject(e);
-        }
-      } else if (action?.type === "error") {
-        try {
-          __privateGet(this, _mutateOptions).onError?.(action.error, variables, onMutateResult, context);
-        } catch (e) {
-          Promise.reject(e);
-        }
-        try {
-          __privateGet(this, _mutateOptions).onSettled?.(void 0, action.error, variables, onMutateResult, context);
-        } catch (e) {
-          Promise.reject(e);
-        }
-      }
-    }
-    this.listeners.forEach((listener) => {
-      listener(__privateGet(this, _currentResult2));
-    });
-  });
-}, _a9);
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/queriesObserver.js
-function difference(array1, array2) {
-  const excludeSet = new Set(array2);
-  return array1.filter((x) => !excludeSet.has(x));
-}
-var _client5, _result, _queries, _options, _observers2, _combinedResult, _lastCombine, _lastResult, _lastQueryHashes, _observerMatches, _QueriesObserver_instances, trackResult_fn, combineResult_fn, shouldSkipCombine_fn, findMatchingObservers_fn, onUpdate_fn, notify_fn2, _a10;
-var QueriesObserver = (_a10 = class extends Subscribable {
-  constructor(client, queries, options) {
-    super();
-    __privateAdd(this, _QueriesObserver_instances);
-    __privateAdd(this, _client5);
-    __privateAdd(this, _result);
-    __privateAdd(this, _queries);
-    __privateAdd(this, _options);
-    __privateAdd(this, _observers2);
-    __privateAdd(this, _combinedResult);
-    __privateAdd(this, _lastCombine);
-    __privateAdd(this, _lastResult);
-    __privateAdd(this, _lastQueryHashes);
-    __privateAdd(this, _observerMatches, []);
-    __privateSet(this, _client5, client);
-    __privateSet(this, _options, options);
-    __privateSet(this, _queries, []);
-    __privateSet(this, _observers2, []);
-    __privateSet(this, _result, []);
-    this.setQueries(queries);
-  }
-  onSubscribe() {
-    if (this.listeners.size === 1) __privateGet(this, _observers2).forEach((observer) => {
-      observer.subscribe((result) => {
-        __privateMethod(this, _QueriesObserver_instances, onUpdate_fn).call(this, observer, result);
-      });
-    });
-  }
-  onUnsubscribe() {
-    if (!this.listeners.size) this.destroy();
-  }
-  destroy() {
-    this.listeners = /* @__PURE__ */ new Set();
-    __privateGet(this, _observers2).forEach((observer) => {
-      observer.destroy();
-    });
-  }
-  setQueries(queries, options) {
-    __privateSet(this, _queries, queries);
-    __privateSet(this, _options, options);
-    if (false) {
-      const queryHashes = queries.map((query) => __privateGet(this, _client5).defaultQueryOptions(query).queryHash);
-      if (new Set(queryHashes).size !== queryHashes.length) console.warn("[QueriesObserver]: Duplicate Queries found. This might result in unexpected behavior.");
-    }
-    notifyManager.batch(() => {
-      const prevObservers = __privateGet(this, _observers2);
-      const newObserverMatches = __privateMethod(this, _QueriesObserver_instances, findMatchingObservers_fn).call(this, __privateGet(this, _queries));
-      newObserverMatches.forEach((match) => match.observer.setOptions(match.defaultedQueryOptions));
-      const newObservers = newObserverMatches.map((match) => match.observer);
-      const newResult = newObservers.map((observer) => observer.getCurrentResult());
-      const hasLengthChange = prevObservers.length !== newObservers.length;
-      const hasIndexChange = newObservers.some((observer, index) => observer !== prevObservers[index]);
-      const hasStructuralChange = hasLengthChange || hasIndexChange;
-      const hasResultChange = hasStructuralChange ? true : newResult.some((result, index) => {
-        const prev = __privateGet(this, _result)[index];
-        return !prev || !shallowEqualObjects(result, prev);
-      });
-      if (!hasStructuralChange && !hasResultChange) return;
-      if (hasStructuralChange) {
-        __privateSet(this, _observerMatches, newObserverMatches);
-        __privateSet(this, _observers2, newObservers);
-      }
-      __privateSet(this, _result, newResult);
-      if (!this.hasListeners()) return;
-      if (hasStructuralChange) {
-        difference(prevObservers, newObservers).forEach((observer) => {
-          observer.destroy();
-        });
-        difference(newObservers, prevObservers).forEach((observer) => {
-          observer.subscribe((result) => {
-            __privateMethod(this, _QueriesObserver_instances, onUpdate_fn).call(this, observer, result);
-          });
-        });
-      }
-      __privateMethod(this, _QueriesObserver_instances, notify_fn2).call(this);
-    });
-  }
-  getCurrentResult() {
-    return __privateGet(this, _result);
-  }
-  getQueries() {
-    return __privateGet(this, _observers2).map((observer) => observer.getCurrentQuery());
-  }
-  getObservers() {
-    return __privateGet(this, _observers2);
-  }
-  getOptimisticResult(queries, combine) {
-    const matches = __privateMethod(this, _QueriesObserver_instances, findMatchingObservers_fn).call(this, queries);
-    const result = matches.map((match) => match.observer.getOptimisticResult(match.defaultedQueryOptions));
-    const queryHashes = matches.map((match) => match.defaultedQueryOptions.queryHash);
-    return [
-      result,
-      (r) => {
-        return __privateMethod(this, _QueriesObserver_instances, combineResult_fn).call(this, r ?? result, combine, queryHashes);
-      },
-      () => {
-        return __privateMethod(this, _QueriesObserver_instances, trackResult_fn).call(this, result, matches);
-      }
-    ];
-  }
-}, _client5 = new WeakMap(), _result = new WeakMap(), _queries = new WeakMap(), _options = new WeakMap(), _observers2 = new WeakMap(), _combinedResult = new WeakMap(), _lastCombine = new WeakMap(), _lastResult = new WeakMap(), _lastQueryHashes = new WeakMap(), _observerMatches = new WeakMap(), _QueriesObserver_instances = new WeakSet(), trackResult_fn = function(result, matches) {
-  const trackedProps = /* @__PURE__ */ new Set();
-  return matches.map((match, index) => {
-    const observerResult = result[index];
-    return !match.defaultedQueryOptions.notifyOnChangeProps ? match.observer.trackResult(observerResult, (accessedProp) => {
-      if (!trackedProps.has(accessedProp)) {
-        trackedProps.add(accessedProp);
-        matches.forEach((m) => {
-          m.observer.trackProp(accessedProp);
-        });
-      }
-    }) : observerResult;
-  });
-}, combineResult_fn = function(input, combine, queryHashes) {
-  if (combine) {
-    const lastHashes = __privateGet(this, _lastQueryHashes);
-    const queryHashesChanged = queryHashes !== void 0 && lastHashes !== void 0 && (lastHashes.length !== queryHashes.length || queryHashes.some((hash, i) => hash !== lastHashes[i]));
-    if (__privateGet(this, _result) !== __privateGet(this, _lastResult) || queryHashesChanged || combine !== __privateGet(this, _lastCombine)) {
-      __privateSet(this, _lastCombine, combine);
-      __privateSet(this, _lastResult, __privateGet(this, _result));
-      if (queryHashes !== void 0) __privateSet(this, _lastQueryHashes, queryHashes);
-      __privateSet(this, _combinedResult, replaceEqualDeep(__privateGet(this, _combinedResult), combine(input)));
-    }
-    return __privateGet(this, _combinedResult);
-  }
-  return input;
-}, shouldSkipCombine_fn = function() {
-  return !__privateGet(this, _options)?.combine || __privateGet(this, _observers2).some((observer, index) => {
-    return observer.options.suspense && __privateGet(this, _result)[index]?.data === void 0;
-  });
-}, findMatchingObservers_fn = function(queries) {
-  const prevObserversMap = /* @__PURE__ */ new Map();
-  __privateGet(this, _observers2).forEach((observer) => {
-    const key = observer.options.queryHash;
-    if (!key) return;
-    const previousObservers = prevObserversMap.get(key);
-    if (previousObservers) previousObservers.push(observer);
-    else prevObserversMap.set(key, [observer]);
-  });
-  const observers = [];
-  queries.forEach((options) => {
-    const defaultedOptions = __privateGet(this, _client5).defaultQueryOptions(options);
-    const observer = prevObserversMap.get(defaultedOptions.queryHash)?.shift() ?? new QueryObserver(__privateGet(this, _client5), defaultedOptions);
-    observers.push({
-      defaultedQueryOptions: defaultedOptions,
-      observer
-    });
-  });
-  return observers;
-}, onUpdate_fn = function(observer, result) {
-  const index = __privateGet(this, _observers2).indexOf(observer);
-  if (index !== -1) {
-    __privateSet(this, _result, __privateGet(this, _result).slice());
-    __privateGet(this, _result)[index] = result;
-    __privateMethod(this, _QueriesObserver_instances, notify_fn2).call(this);
-  }
-}, notify_fn2 = function() {
-  if (this.hasListeners()) {
-    const shouldSkipCombine = __privateMethod(this, _QueriesObserver_instances, shouldSkipCombine_fn).call(this);
-    const previousResult = __privateGet(this, _combinedResult);
-    const newResult = shouldSkipCombine ? previousResult : __privateMethod(this, _QueriesObserver_instances, combineResult_fn).call(this, __privateMethod(this, _QueriesObserver_instances, trackResult_fn).call(this, __privateGet(this, _result), __privateGet(this, _observerMatches)), __privateGet(this, _options)?.combine);
-    if (shouldSkipCombine || previousResult !== newResult) notifyManager.batch(() => {
-      this.listeners.forEach((listener) => {
-        listener(__privateGet(this, _result));
-      });
-    });
-  }
-}, _a10);
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/queryCache.js
-var _queries2, _a11;
-var QueryCache = (_a11 = class extends Subscribable {
-  constructor(config = {}) {
-    super();
-    __privateAdd(this, _queries2);
-    this.config = config;
-    __privateSet(this, _queries2, /* @__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, _queries2).has(query.queryHash)) {
-      __privateGet(this, _queries2).set(query.queryHash, query);
-      this.notify({
-        type: "added",
-        query
-      });
-    }
-  }
-  remove(query) {
-    const queryInMap = __privateGet(this, _queries2).get(query.queryHash);
-    if (queryInMap) {
-      query.destroy();
-      if (queryInMap === query) __privateGet(this, _queries2).delete(query.queryHash);
-      this.notify({
-        type: "removed",
-        query
-      });
-    }
-  }
-  clear() {
-    notifyManager.batch(() => {
-      this.getAll().forEach((query) => {
-        this.remove(query);
-      });
-    });
-  }
-  get(queryHash) {
-    return __privateGet(this, _queries2).get(queryHash);
-  }
-  getAll() {
-    return [...__privateGet(this, _queries2).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();
-      });
-    });
-  }
-}, _queries2 = new WeakMap(), _a11);
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/queryClient.js
-var _queryCache, _mutationCache2, _defaultOptions2, _queryDefaults, _mutationDefaults, _mountCount, _unsubscribeFocus, _unsubscribeOnline, _a12;
-var QueryClient = (_a12 = 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 _a13, _b;
-    __privateWrapper(this, _mountCount)._--;
-    if (__privateGet(this, _mountCount) !== 0) return;
-    (_a13 = __privateGet(this, _unsubscribeFocus)) == null ? void 0 : _a13.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;
-  }
-  /**
-  * @deprecated Use queryClient.query({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
-  */
-  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(resolveQueryValue(defaultedOptions.staleTime, query))) this.prefetchQuery(defaultedOptions);
-    return Promise.resolve(cachedData);
-  }
-  getQueriesData(filters) {
-    return __privateGet(this, _queryCache).findAll(filters).map(({ queryKey, state }) => {
-      return [queryKey, state.data];
-    });
-  }
-  setQueryData(queryKey, updater, options) {
-    const defaultedOptions = this.defaultQueryOptions({ queryKey });
-    const prevData = __privateGet(this, _queryCache).get(defaultedOptions.queryHash)?.state.data;
-    const data = functionalUpdate(updater, prevData);
-    if (data === void 0) return;
-    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(() => {
-      const matched = queryCache.findAll(filters);
-      const queriesToRefetch = new Set(matched);
-      matched.forEach((query) => {
-        query.reset();
-      });
-      return this.refetchQueries({
-        type: "active",
-        predicate: (query) => queriesToRefetch.has(query)
-      }, 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);
-  }
-  async query(options) {
-    const defaultedOptions = this.defaultQueryOptions(options);
-    if (defaultedOptions.retry === void 0) defaultedOptions.retry = false;
-    const query = __privateGet(this, _queryCache).build(this, defaultedOptions);
-    const queryData = query.isStaleByTime(resolveQueryValue(defaultedOptions.staleTime, query)) ? await query.fetch(defaultedOptions) : query.state.data;
-    const select = defaultedOptions.select;
-    if (select) return select(queryData);
-    return queryData;
-  }
-  /**
-  * @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.
-  */
-  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(resolveQueryValue(defaultedOptions.staleTime, query)) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
-  }
-  /**
-  * @deprecated Use queryClient.query(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
-  */
-  prefetchQuery(options) {
-    return this.fetchQuery(options).then(noop).catch(noop);
-  }
-  infiniteQuery(options) {
-    options._type = "infinite";
-    return this.query(options);
-  }
-  /**
-  * @deprecated Use queryClient.infiniteQuery(options) instead. This method will be removed in the next major version.
-  */
-  fetchInfiniteQuery(options) {
-    options._type = "infinite";
-    return this.fetchQuery(options);
-  }
-  /**
-  * @deprecated Use queryClient.infiniteQuery(options) instead. You can swallow errors with `.catch(noop)`. This method will be removed in the next major version.
-  */
-  prefetchInfiniteQuery(options) {
-    return this.fetchInfiniteQuery(options).then(noop).catch(noop);
-  }
-  /**
-  * @deprecated Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead. This method will be removed in the next major version.
-  */
-  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(), _a12);
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/streamedQuery.js
-function streamedQuery({ streamFn, refetchMode = "reset", reducer = (items, chunk) => addToEnd(items, chunk), initialValue = [] }) {
-  return async (context) => {
-    const query = context.client.getQueryCache().find({
-      queryKey: context.queryKey,
-      exact: true
-    });
-    const isRefetch = !!query && query.isFetched();
-    if (isRefetch && refetchMode === "reset") query.setState({
-      ...query.resetState,
-      fetchStatus: "fetching"
-    });
-    let result = initialValue;
-    let cancelled = false;
-    const stream = await streamFn(addConsumeAwareSignal({
-      client: context.client,
-      meta: context.meta,
-      queryKey: context.queryKey,
-      pageParam: context.pageParam,
-      direction: context.direction
-    }, () => context.signal, () => cancelled = true));
-    const isReplaceRefetch = isRefetch && refetchMode === "replace";
-    for await (const chunk of stream) {
-      if (cancelled) break;
-      if (isReplaceRefetch) result = reducer(result, chunk);
-      else context.client.setQueryData(context.queryKey, (prev) => reducer(prev === void 0 ? initialValue : prev, chunk));
-    }
-    if (isReplaceRefetch && !cancelled) context.client.setQueryData(context.queryKey, result);
-    return context.client.getQueryData(context.queryKey) ?? initialValue;
-  };
-}
-
-// ../../node_modules/.pnpm/@tanstack+query-core@5.102.8/node_modules/@tanstack/query-core/build/modern/types.js
-var dataTagSymbol = /* @__PURE__ */ Symbol();
-var dataTagErrorSymbol = /* @__PURE__ */ Symbol();
-var unsetMarker = /* @__PURE__ */ Symbol();
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/HydrationBoundary.js
-var HydrationBoundary = ({ children, options = {}, state, queryClient }) => {
-  const client = useQueryClient(queryClient);
-  const optionsRef = React2.useRef(options);
-  React2.useEffect(() => {
-    optionsRef.current = options;
-  });
-  const hydrationQueue = React2.useMemo(() => {
-    if (state) {
-      if (typeof state !== "object") return;
-      const queryCache = client.getQueryCache();
-      const queries = state.queries || [];
-      const newQueries = [];
-      const existingQueries = [];
-      for (const dehydratedQuery of queries) {
-        const existingQuery = queryCache.get(dehydratedQuery.queryHash);
-        if (!existingQuery) newQueries.push(dehydratedQuery);
-        else if (dehydratedQuery.state.dataUpdatedAt > existingQuery.state.dataUpdatedAt || dehydratedQuery.promise && existingQuery.state.status !== "pending" && existingQuery.state.fetchStatus !== "fetching" && dehydratedQuery.dehydratedAt !== void 0 && dehydratedQuery.dehydratedAt > existingQuery.state.dataUpdatedAt) existingQueries.push(dehydratedQuery);
-      }
-      if (newQueries.length > 0) hydrate(client, { queries: newQueries }, optionsRef.current);
-      if (existingQueries.length > 0) return existingQueries;
-    }
-  }, [client, state]);
-  React2.useEffect(() => {
-    if (hydrationQueue) hydrate(client, { queries: hydrationQueue }, optionsRef.current);
-  }, [client, hydrationQueue]);
-  return children;
-};
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/IsRestoringProvider.js
-import * as React3 from "react";
-var IsRestoringContext = React3.createContext(false);
-var useIsRestoring = () => React3.useContext(IsRestoringContext);
-var IsRestoringProvider = IsRestoringContext.Provider;
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js
-import * as React4 from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-function createValue() {
-  let isReset = false;
-  return {
-    clearReset: () => {
-      isReset = false;
-    },
-    reset: () => {
-      isReset = true;
-    },
-    isReset: () => {
-      return isReset;
-    }
-  };
-}
-var QueryErrorResetBoundaryContext = React4.createContext(createValue());
-var useQueryErrorResetBoundary = () => React4.useContext(QueryErrorResetBoundaryContext);
-var QueryErrorResetBoundary = ({ children }) => {
-  const [value] = React4.useState(() => createValue());
-  return /* @__PURE__ */ jsx2(QueryErrorResetBoundaryContext.Provider, {
-    value,
-    children: typeof children === "function" ? children(value) : children
-  });
-};
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js
-import * as React5 from "react";
-var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
-  const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
-  if (options.suspense || throwOnError) {
-    if (!errorResetBoundary.isReset()) options.retryOnMount = false;
-  }
-};
-var useClearResetErrorBoundary = (errorResetBoundary) => {
-  React5.useEffect(() => {
-    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/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/suspense.js
-var defaultThrowOnError = (_error, query) => query.state.data === void 0;
-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 shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;
-var fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {
-  errorResetBoundary.clearReset();
-});
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useQueries.js
-import * as React6 from "react";
-function useQueries({ queries, ...options }, queryClient) {
-  const client = useQueryClient(queryClient);
-  const isRestoring = useIsRestoring();
-  const errorResetBoundary = useQueryErrorResetBoundary();
-  const subscribed = options.subscribed !== false;
-  const defaultedQueries = React6.useMemo(() => queries.map((opts) => {
-    const defaultedOptions = client.defaultQueryOptions(opts);
-    defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
-    return defaultedOptions;
-  }), [
-    queries,
-    client,
-    isRestoring,
-    subscribed
-  ]);
-  defaultedQueries.forEach((queryOptions2) => {
-    ensureSuspenseTimers(queryOptions2);
-    const query = client.getQueryCache().get(queryOptions2.queryHash);
-    ensurePreventErrorBoundaryRetry(queryOptions2, errorResetBoundary, query);
-  });
-  useClearResetErrorBoundary(errorResetBoundary);
-  const [observer] = React6.useState(() => new QueriesObserver(client, defaultedQueries, options));
-  const [optimisticResult, getCombinedResult, trackResult] = observer.getOptimisticResult(defaultedQueries, options.combine);
-  const shouldSubscribe = !isRestoring && subscribed;
-  React6.useSyncExternalStore(React6.useCallback((onStoreChange) => shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
-  React6.useEffect(() => {
-    observer.setQueries(defaultedQueries, options);
-  }, [
-    defaultedQueries,
-    options,
-    observer
-  ]);
-  const suspensePromises = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result)) ? optimisticResult.flatMap((result, index) => {
-    const opts = defaultedQueries[index];
-    if (opts && shouldSuspend(opts, result)) {
-      const queryObserver = new QueryObserver(client, opts);
-      return fetchOptimistic(opts, queryObserver, errorResetBoundary);
-    }
-    return [];
-  }) : [];
-  if (suspensePromises.length > 0) throw Promise.all(suspensePromises);
-  const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
-    const query = defaultedQueries[index];
-    return query && getHasError({
-      result,
-      errorResetBoundary,
-      throwOnError: query.throwOnError,
-      query: client.getQueryCache().get(query.queryHash),
-      suspense: query.suspense
-    });
-  });
-  if (firstSingleResultWhichShouldThrow) throw firstSingleResultWhichShouldThrow.error;
-  return getCombinedResult(trackResult());
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js
-import * as React7 from "react";
-function useBaseQuery(options, Observer, queryClient) {
-  if (false) {
-    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);
-  const query = client.getQueryCache().get(defaultedOptions.queryHash);
-  if (false) {
-    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`);
-  }
-  const subscribed = options.subscribed !== false;
-  defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : subscribed ? "optimistic" : void 0;
-  ensureSuspenseTimers(defaultedOptions);
-  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
-  useClearResetErrorBoundary(errorResetBoundary);
-  const [observer] = React7.useState(() => new Observer(client, defaultedOptions));
-  const result = observer.getOptimisticResult(defaultedOptions);
-  const shouldSubscribe = !isRestoring && subscribed;
-  React7.useSyncExternalStore(React7.useCallback((onStoreChange) => {
-    const unsubscribe = shouldSubscribe ? observer.subscribe(notifyManager.batchCalls(onStoreChange)) : noop;
-    observer.updateResult();
-    return unsubscribe;
-  }, [observer, shouldSubscribe]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
-  React7.useEffect(() => {
-    observer.setOptions(defaultedOptions);
-  }, [defaultedOptions, observer]);
-  if (shouldSuspend(defaultedOptions, result)) throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
-  if (getHasError({
-    result,
-    errorResetBoundary,
-    throwOnError: defaultedOptions.throwOnError,
-    query,
-    suspense: defaultedOptions.suspense
-  })) throw result.error;
-  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useQuery.js
-function useQuery(options, queryClient) {
-  return useBaseQuery(options, QueryObserver, queryClient);
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useSuspenseQuery.js
-function useSuspenseQuery(options, queryClient) {
-  if (false) {
-    if (options.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseQuery");
-  }
-  return useBaseQuery({
-    ...options,
-    enabled: true,
-    suspense: true,
-    throwOnError: defaultThrowOnError,
-    placeholderData: void 0
-  }, QueryObserver, queryClient);
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useSuspenseInfiniteQuery.js
-function useSuspenseInfiniteQuery(options, queryClient) {
-  if (false) {
-    if (options.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseInfiniteQuery");
-  }
-  return useBaseQuery({
-    ...options,
-    enabled: true,
-    suspense: true,
-    throwOnError: defaultThrowOnError,
-    placeholderData: void 0
-  }, InfiniteQueryObserver, queryClient);
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useSuspenseQueries.js
-function useSuspenseQueries(options, queryClient) {
-  return useQueries({
-    ...options,
-    queries: options.queries.map((query) => {
-      if (false) {
-        if (query.queryFn === skipToken) console.error("skipToken is not allowed for useSuspenseQueries");
-      }
-      return {
-        ...query,
-        suspense: true,
-        throwOnError: defaultThrowOnError,
-        enabled: true,
-        placeholderData: void 0
-      };
-    })
-  }, queryClient);
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/usePrefetchQuery.js
-function usePrefetchQuery(options, queryClient) {
-  const client = useQueryClient(queryClient);
-  if (!client.getQueryState(options.queryKey)) client.query(options).catch(noop);
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/usePrefetchInfiniteQuery.js
-function usePrefetchInfiniteQuery(options, queryClient) {
-  const client = useQueryClient(queryClient);
-  if (!client.getQueryState(options.queryKey)) client.infiniteQuery(options).catch(noop);
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/queryOptions.js
-function queryOptions(options) {
-  return options;
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/infiniteQueryOptions.js
-function infiniteQueryOptions(options) {
-  return options;
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useIsFetching.js
-import * as React8 from "react";
-function useIsFetching(filters, queryClient) {
-  const client = useQueryClient(queryClient);
-  const queryCache = client.getQueryCache();
-  return React8.useSyncExternalStore(React8.useCallback((onStoreChange) => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)), [queryCache]), () => client.isFetching(filters), () => client.isFetching(filters));
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useMutationState.js
-import * as React9 from "react";
-function useIsMutating(filters, queryClient) {
-  const client = useQueryClient(queryClient);
-  return useMutationState({ filters: {
-    ...filters,
-    status: "pending"
-  } }, client).length;
-}
-function getResult(mutationCache, options) {
-  return mutationCache.findAll(options.filters).map((mutation) => options.select ? options.select(mutation) : mutation.state);
-}
-function useMutationState(options = {}, queryClient) {
-  const mutationCache = useQueryClient(queryClient).getMutationCache();
-  const optionsRef = React9.useRef(options);
-  const result = React9.useRef(null);
-  if (result.current === null) result.current = getResult(mutationCache, options);
-  React9.useEffect(() => {
-    optionsRef.current = options;
-  });
-  return React9.useSyncExternalStore(React9.useCallback((onStoreChange) => mutationCache.subscribe(() => {
-    const nextResult = replaceEqualDeep(result.current, getResult(mutationCache, optionsRef.current));
-    if (result.current !== nextResult) {
-      result.current = nextResult;
-      notifyManager.schedule(onStoreChange);
-    }
-  }), [mutationCache]), () => result.current, () => result.current);
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useMutation.js
-import * as React10 from "react";
-function useMutation(options, queryClient) {
-  const client = useQueryClient(queryClient);
-  const [observer] = React10.useState(() => new MutationObserver(client, options));
-  React10.useEffect(() => {
-    observer.setOptions(options);
-  }, [observer, options]);
-  const result = React10.useSyncExternalStore(React10.useCallback((onStoreChange) => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
-  const mutate = React10.useCallback((...args) => {
-    observer.mutate(args[0], args[1]).catch(noop);
-  }, [observer]);
-  if (result.error && shouldThrowError(observer.options.throwOnError, [result.error])) throw result.error;
-  return {
-    ...result,
-    mutate,
-    mutateAsync: result.mutate
-  };
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/mutationOptions.js
-function mutationOptions(options) {
-  return options;
-}
-
-// ../../node_modules/.pnpm/@tanstack+react-query@5.102.8_react@19.2.8/node_modules/@tanstack/react-query/build/modern/useInfiniteQuery.js
-function useInfiniteQuery(options, queryClient) {
-  return useBaseQuery(options, InfiniteQueryObserver, queryClient);
-}
-
-// shell/.ojm-shim-react-query.mjs
-var ojm_shim_react_query_default = void 0 ?? modern_exports;
-export {
-  CancelledError,
-  HydrationBoundary,
-  InfiniteQueryObserver,
-  IsRestoringProvider,
-  Mutation,
-  MutationCache,
-  MutationObserver,
-  QueriesObserver,
-  Query,
-  QueryCache,
-  QueryClient,
-  QueryClientContext,
-  QueryClientProvider,
-  QueryErrorResetBoundary,
-  QueryObserver,
-  dataTagErrorSymbol,
-  dataTagSymbol,
-  ojm_shim_react_query_default as default,
-  defaultScheduler,
-  defaultShouldDehydrateMutation,
-  defaultShouldDehydrateQuery,
-  dehydrate,
-  dehydrateQuery,
-  environmentManager,
-  streamedQuery as experimental_streamedQuery,
-  focusManager,
-  hashKey,
-  hydrate,
-  infiniteQueryOptions,
-  isCancelledError,
-  isServer,
-  keepPreviousData,
-  matchMutation,
-  matchQuery,
-  mutationOptions,
-  noop,
-  notifyManager,
-  onlineManager,
-  partialMatchKey,
-  queryOptions,
-  replaceEqualDeep,
-  shouldThrowError,
-  skipToken,
-  timeoutManager,
-  unsetMarker,
-  useInfiniteQuery,
-  useIsFetching,
-  useIsMutating,
-  useIsRestoring,
-  useMutation,
-  useMutationState,
-  usePrefetchInfiniteQuery,
-  usePrefetchQuery,
-  useQueries,
-  useQuery,
-  useQueryClient,
-  useQueryErrorResetBoundary,
-  useSuspenseInfiniteQuery,
-  useSuspenseQueries,
-  useSuspenseQuery
-};