@tanstack/react-query 4.24.9 → 5.0.0-alpha.0

package/build/umd/index.development.js

@@ -1,13 +1,10 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react-dom'), require('react')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react-dom', 'react'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactQuery = {}, global.ReactDOM, global.React));
-})(this, (function (exports, ReactDOM, React) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReactQuery = {}, global.React));
+})(this, (function (exports, React) { 'use strict';
 
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-  function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
+  function _interopNamespaceDefault(e) {
     var n = Object.create(null);
     if (e) {
       Object.keys(e).forEach(function (k) {
@@ -20,20 +17,17 @@
         }
       });
     }
-    n["default"] = e;
+    n.default = e;
     return Object.freeze(n);
   }
 
-  var ReactDOM__namespace = /*#__PURE__*/_interopNamespace(ReactDOM);
-  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-  var React__namespace = /*#__PURE__*/_interopNamespace(React);
+  var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
   class Subscribable {
     constructor() {
       this.listeners = [];
       this.subscribe = this.subscribe.bind(this);
     }
-
     subscribe(listener) {
       this.listeners.push(listener);
       this.onSubscribe();
@@ -42,21 +36,21 @@
         this.onUnsubscribe();
       };
     }
-
     hasListeners() {
       return this.listeners.length > 0;
     }
-
-    onSubscribe() {// Do nothing
+    onSubscribe() {
+      // Do nothing
     }
-
-    onUnsubscribe() {// Do nothing
+    onUnsubscribe() {
+      // Do nothing
     }
-
   }
 
   // TYPES
+
   // UTILS
+
   const isServer = typeof window === 'undefined' || 'Deno' in window;
   function noop$1() {
     return undefined;
@@ -67,66 +61,9 @@
   function isValidTimeout(value) {
     return typeof value === 'number' && value >= 0 && value !== Infinity;
   }
-  function difference(array1, array2) {
-    return array1.filter(x => array2.indexOf(x) === -1);
-  }
-  function replaceAt(array, index, value) {
-    const copy = array.slice(0);
-    copy[index] = value;
-    return copy;
-  }
   function timeUntilStale(updatedAt, staleTime) {
     return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
   }
-  function parseQueryArgs(arg1, arg2, arg3) {
-    if (!isQueryKey(arg1)) {
-      return arg1;
-    }
-
-    if (typeof arg2 === 'function') {
-      return { ...arg3,
-        queryKey: arg1,
-        queryFn: arg2
-      };
-    }
-
-    return { ...arg2,
-      queryKey: arg1
-    };
-  }
-  function parseMutationArgs(arg1, arg2, arg3) {
-    if (isQueryKey(arg1)) {
-      if (typeof arg2 === 'function') {
-        return { ...arg3,
-          mutationKey: arg1,
-          mutationFn: arg2
-        };
-      }
-
-      return { ...arg2,
-        mutationKey: arg1
-      };
-    }
-
-    if (typeof arg1 === 'function') {
-      return { ...arg2,
-        mutationFn: arg1
-      };
-    }
-
-    return { ...arg1
-    };
-  }
-  function parseFilterArgs(arg1, arg2, arg3) {
-    return isQueryKey(arg1) ? [{ ...arg2,
-      queryKey: arg1
-    }, arg3] : [arg1 || {}, arg2];
-  }
-  function parseMutationFilterArgs(arg1, arg2, arg3) {
-    return isQueryKey(arg1) ? [{ ...arg2,
-      mutationKey: arg1
-    }, arg3] : [arg1 || {}, arg2];
-  }
   function matchQuery(filters, query) {
     const {
       type = 'all',
@@ -136,8 +73,7 @@
       queryKey,
       stale
     } = filters;
-
-    if (isQueryKey(queryKey)) {
+    if (queryKey) {
       if (exact) {
         if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
           return false;
@@ -146,106 +82,86 @@
         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 (typeof fetchStatus !== 'undefined' && fetchStatus !== query.state.fetchStatus) {
       return false;
     }
-
     if (predicate && !predicate(query)) {
       return false;
     }
-
     return true;
   }
   function matchMutation(filters, mutation) {
     const {
       exact,
-      fetching,
+      status,
       predicate,
       mutationKey
     } = filters;
-
-    if (isQueryKey(mutationKey)) {
+    if (mutationKey) {
       if (!mutation.options.mutationKey) {
         return false;
       }
-
       if (exact) {
-        if (hashQueryKey(mutation.options.mutationKey) !== hashQueryKey(mutationKey)) {
+        if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) {
           return false;
         }
       } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
         return false;
       }
     }
-
-    if (typeof fetching === 'boolean' && mutation.state.status === 'loading' !== fetching) {
+    if (status && mutation.state.status !== status) {
       return false;
     }
-
     if (predicate && !predicate(mutation)) {
       return false;
     }
-
     return true;
   }
   function hashQueryKeyByOptions(queryKey, options) {
-    const hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashQueryKey;
+    const hashFn = options?.queryKeyHashFn || hashKey;
     return hashFn(queryKey);
   }
+
   /**
-   * Default query keys hash function.
+   * Default query & mutation keys hash function.
    * Hashes the value into a stable hash.
    */
-
-  function hashQueryKey(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);
   }
+
   /**
    * Checks if key `b` partially matches with key `a`.
    */
 
   function partialMatchKey(a, b) {
-    return partialDeepEqual(a, b);
-  }
-  /**
-   * Checks if `b` partially matches with `a`.
-   */
-
-  function partialDeepEqual(a, b) {
     if (a === b) {
       return true;
     }
-
     if (typeof a !== typeof b) {
       return false;
     }
-
     if (a && b && typeof a === 'object' && typeof b === 'object') {
-      return !Object.keys(b).some(key => !partialDeepEqual(a[key], b[key]));
+      return !Object.keys(b).some(key => !partialMatchKey(a[key], b[key]));
     }
-
     return false;
   }
+
   /**
    * This function returns `a` if `b` is deeply equal.
    * If not, it will replace any deeply equal children of `b` with those of `a`.
@@ -256,168 +172,142 @@
     if (a === b) {
       return a;
     }
-
     const array = isPlainArray(a) && isPlainArray(b);
-
     if (array || isPlainObject(a) && isPlainObject(b)) {
       const aSize = array ? a.length : Object.keys(a).length;
       const bItems = array ? b : Object.keys(b);
       const bSize = bItems.length;
       const copy = array ? [] : {};
       let equalItems = 0;
-
       for (let i = 0; i < bSize; i++) {
         const key = array ? i : bItems[i];
         copy[key] = replaceEqualDeep(a[key], b[key]);
-
         if (copy[key] === a[key]) {
           equalItems++;
         }
       }
-
       return aSize === bSize && equalItems === aSize ? a : copy;
     }
-
     return b;
   }
+
   /**
    * Shallow compare objects. Only works with objects that always have the same properties.
    */
-
   function shallowEqualObjects(a, b) {
     if (a && !b || b && !a) {
       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;
-  } // Copied from: https://github.com/jonschlinkert/is-plain-object
+  }
 
+  // Copied from: https://github.com/jonschlinkert/is-plain-object
   function isPlainObject(o) {
     if (!hasObjectPrototype(o)) {
       return false;
-    } // If has modified constructor
-
+    }
 
+    // If has modified constructor
     const ctor = o.constructor;
-
     if (typeof ctor === 'undefined') {
       return true;
-    } // If has modified prototype
-
+    }
 
+    // If has modified prototype
     const prot = ctor.prototype;
-
     if (!hasObjectPrototype(prot)) {
       return false;
-    } // If constructor does not have an Object-specific method
-
+    }
 
+    // If constructor does not have an Object-specific method
     if (!prot.hasOwnProperty('isPrototypeOf')) {
       return false;
-    } // Most likely a plain Object
-
+    }
 
+    // Most likely a plain Object
     return true;
   }
-
   function hasObjectPrototype(o) {
     return Object.prototype.toString.call(o) === '[object Object]';
   }
-
-  function isQueryKey(value) {
-    return Array.isArray(value);
-  }
-  function isError(value) {
-    return value instanceof Error;
-  }
   function sleep(timeout) {
     return new Promise(resolve => {
       setTimeout(resolve, timeout);
     });
   }
+
   /**
    * Schedules a microtask.
    * This can be useful to schedule state updates after rendering.
    */
-
   function scheduleMicrotask(callback) {
     sleep(0).then(callback);
   }
-  function getAbortController() {
-    if (typeof AbortController === 'function') {
-      return new AbortController();
-    }
-
-    return;
-  }
   function replaceData(prevData, data, options) {
-    // Use prev data if an isDataEqual function is defined and returns `true`
-    if (options.isDataEqual != null && options.isDataEqual(prevData, data)) {
-      return prevData;
-    } else if (typeof options.structuralSharing === 'function') {
+    if (typeof options.structuralSharing === 'function') {
       return options.structuralSharing(prevData, data);
     } else if (options.structuralSharing !== false) {
       // Structurally share data between prev and new data if needed
       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;
+  }
 
   class FocusManager extends Subscribable {
+    #focused;
+    #cleanup;
+    #setup;
     constructor() {
       super();
-
-      this.setup = onFocus => {
+      this.#setup = onFocus => {
         // addEventListener does not exist in React Native, but window does
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (!isServer && window.addEventListener) {
-          const listener = () => onFocus(); // Listen to visibillitychange and focus
-
-
+          const listener = () => onFocus();
+          // Listen to visibilitychange
           window.addEventListener('visibilitychange', listener, false);
-          window.addEventListener('focus', listener, false);
           return () => {
             // Be sure to unsubscribe if a new handler is set
             window.removeEventListener('visibilitychange', listener);
-            window.removeEventListener('focus', listener);
           };
         }
-
         return;
       };
     }
-
     onSubscribe() {
-      if (!this.cleanup) {
-        this.setEventListener(this.setup);
+      if (!this.#cleanup) {
+        this.setEventListener(this.#setup);
       }
     }
-
     onUnsubscribe() {
       if (!this.hasListeners()) {
-        var _this$cleanup;
-
-        (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
-        this.cleanup = undefined;
+        this.#cleanup?.();
+        this.#cleanup = undefined;
       }
     }
-
     setEventListener(setup) {
-      var _this$cleanup2;
-
-      this.setup = setup;
-      (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
-      this.cleanup = setup(focused => {
+      this.#setup = setup;
+      this.#cleanup?.();
+      this.#cleanup = setup(focused => {
         if (typeof focused === 'boolean') {
           this.setFocused(focused);
         } else {
@@ -425,48 +315,41 @@
         }
       });
     }
-
     setFocused(focused) {
-      this.focused = focused;
-
+      this.#focused = focused;
       if (focused) {
         this.onFocus();
       }
     }
-
     onFocus() {
       this.listeners.forEach(listener => {
         listener();
       });
     }
-
     isFocused() {
-      if (typeof this.focused === 'boolean') {
-        return this.focused;
-      } // document global can be unavailable in react native
-
-
-      if (typeof document === 'undefined') {
-        return true;
+      if (typeof this.#focused === 'boolean') {
+        return this.#focused;
       }
 
-      return [undefined, 'visible', 'prerender'].includes(document.visibilityState);
+      // document global can be unavailable in react native
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      return globalThis.document?.visibilityState !== 'hidden';
     }
-
   }
   const focusManager = new FocusManager();
 
   class OnlineManager extends Subscribable {
+    #online;
+    #cleanup;
+    #setup;
     constructor() {
       super();
-
-      this.setup = onOnline => {
+      this.#setup = onOnline => {
         // addEventListener does not exist in React Native, but window does
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (!isServer && window.addEventListener) {
-          const listener = () => onOnline(); // Listen to online
-
-
+          const listener = () => onOnline();
+          // Listen to online
           window.addEventListener('online', listener, false);
           window.addEventListener('offline', listener, false);
           return () => {
@@ -475,32 +358,24 @@
             window.removeEventListener('offline', listener);
           };
         }
-
         return;
       };
     }
-
     onSubscribe() {
-      if (!this.cleanup) {
-        this.setEventListener(this.setup);
+      if (!this.#cleanup) {
+        this.setEventListener(this.#setup);
       }
     }
-
     onUnsubscribe() {
       if (!this.hasListeners()) {
-        var _this$cleanup;
-
-        (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
-        this.cleanup = undefined;
+        this.#cleanup?.();
+        this.#cleanup = undefined;
       }
     }
-
     setEventListener(setup) {
-      var _this$cleanup2;
-
-      this.setup = setup;
-      (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
-      this.cleanup = setup(online => {
+      this.#setup = setup;
+      this.#cleanup?.();
+      this.#cleanup = setup(online => {
         if (typeof online === 'boolean') {
           this.setOnline(online);
         } else {
@@ -508,49 +383,40 @@
         }
       });
     }
-
     setOnline(online) {
-      this.online = online;
-
+      this.#online = online;
       if (online) {
         this.onOnline();
       }
     }
-
     onOnline() {
       this.listeners.forEach(listener => {
         listener();
       });
     }
-
     isOnline() {
-      if (typeof this.online === 'boolean') {
-        return this.online;
+      if (typeof this.#online === 'boolean') {
+        return this.#online;
       }
-
       if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
         return true;
       }
-
       return navigator.onLine;
     }
-
   }
   const onlineManager = new OnlineManager();
 
   function defaultRetryDelay(failureCount) {
     return Math.min(1000 * 2 ** failureCount, 30000);
   }
-
   function canFetch(networkMode) {
-    return (networkMode != null ? networkMode : 'online') === 'online' ? onlineManager.isOnline() : true;
+    return (networkMode ?? 'online') === 'online' ? onlineManager.isOnline() : true;
   }
   class CancelledError {
     constructor(options) {
-      this.revert = options == null ? void 0 : options.revert;
-      this.silent = options == null ? void 0 : options.silent;
+      this.revert = options?.revert;
+      this.silent = options?.silent;
     }
-
   }
   function isCancelledError(value) {
     return value instanceof CancelledError;
@@ -566,109 +432,95 @@
       promiseResolve = outerResolve;
       promiseReject = outerReject;
     });
-
     const cancel = cancelOptions => {
       if (!isResolved) {
         reject(new CancelledError(cancelOptions));
-        config.abort == null ? void 0 : config.abort();
+        config.abort?.();
       }
     };
-
     const cancelRetry = () => {
       isRetryCancelled = true;
     };
-
     const continueRetry = () => {
       isRetryCancelled = false;
     };
-
     const shouldPause = () => !focusManager.isFocused() || config.networkMode !== 'always' && !onlineManager.isOnline();
-
     const resolve = value => {
       if (!isResolved) {
         isResolved = true;
-        config.onSuccess == null ? void 0 : config.onSuccess(value);
-        continueFn == null ? void 0 : continueFn();
+        config.onSuccess?.(value);
+        continueFn?.();
         promiseResolve(value);
       }
     };
-
     const reject = value => {
       if (!isResolved) {
         isResolved = true;
-        config.onError == null ? void 0 : config.onError(value);
-        continueFn == null ? void 0 : continueFn();
+        config.onError?.(value);
+        continueFn?.();
         promiseReject(value);
       }
     };
-
     const pause = () => {
       return new Promise(continueResolve => {
         continueFn = value => {
           const canContinue = isResolved || !shouldPause();
-
           if (canContinue) {
             continueResolve(value);
           }
-
           return canContinue;
         };
-
-        config.onPause == null ? void 0 : config.onPause();
+        config.onPause?.();
       }).then(() => {
         continueFn = undefined;
-
         if (!isResolved) {
-          config.onContinue == null ? void 0 : config.onContinue();
+          config.onContinue?.();
         }
       });
-    }; // Create loop function
-
+    };
 
+    // Create loop function
     const run = () => {
       // Do nothing if already resolved
       if (isResolved) {
         return;
       }
+      let promiseOrValue;
 
-      let promiseOrValue; // Execute query
-
+      // Execute query
       try {
         promiseOrValue = config.fn();
       } catch (error) {
         promiseOrValue = Promise.reject(error);
       }
-
       Promise.resolve(promiseOrValue).then(resolve).catch(error => {
-        var _config$retry, _config$retryDelay;
-
         // Stop if the fetch is already resolved
         if (isResolved) {
           return;
-        } // Do we need to retry the request?
-
+        }
 
-        const retry = (_config$retry = config.retry) != null ? _config$retry : 3;
-        const retryDelay = (_config$retryDelay = config.retryDelay) != null ? _config$retryDelay : defaultRetryDelay;
+        // Do we need to retry the request?
+        const retry = config.retry ?? 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) {
           // We are done if the query does not need to be retried
           reject(error);
           return;
         }
+        failureCount++;
 
-        failureCount++; // Notify on fail
+        // Notify on fail
+        config.onFail?.(failureCount, error);
 
-        config.onFail == null ? void 0 : config.onFail(failureCount, error); // Delay
-
-        sleep(delay) // Pause if the document is not visible or when the device is offline
+        // Delay
+        sleep(delay)
+        // Pause if the document is not visible or when the device is offline
         .then(() => {
           if (shouldPause()) {
             return pause();
           }
-
           return;
         }).then(() => {
           if (isRetryCancelled) {
@@ -678,20 +530,19 @@
           }
         });
       });
-    }; // Start loop
-
+    };
 
+    // Start loop
     if (canFetch(config.networkMode)) {
       run();
     } else {
       pause().then(run);
     }
-
     return {
       promise,
       cancel,
       continue: () => {
-        const didContinue = continueFn == null ? void 0 : continueFn();
+        const didContinue = continueFn?.();
         return didContinue ? promise : Promise.resolve();
       },
       cancelRetry,
@@ -699,37 +550,30 @@
     };
   }
 
-  const defaultLogger = console;
+  // TYPES
 
   function createNotifyManager() {
     let queue = [];
     let transactions = 0;
-
     let notifyFn = callback => {
       callback();
     };
-
     let batchNotifyFn = callback => {
       callback();
     };
-
     const batch = callback => {
       let result;
       transactions++;
-
       try {
         result = callback();
       } finally {
         transactions--;
-
         if (!transactions) {
           flush();
         }
       }
-
       return result;
     };
-
     const schedule = callback => {
       if (transactions) {
         queue.push(callback);
@@ -739,11 +583,10 @@
         });
       }
     };
+
     /**
      * All calls to the wrapped function will be batched.
      */
-
-
     const batchCalls = callback => {
       return (...args) => {
         schedule(() => {
@@ -751,11 +594,9 @@
         });
       };
     };
-
     const flush = () => {
       const originalQueue = queue;
       queue = [];
-
       if (originalQueue.length) {
         scheduleMicrotask(() => {
           batchNotifyFn(() => {
@@ -766,25 +607,22 @@
         });
       }
     };
+
     /**
      * Use this method to set a custom notify function.
      * This can be used to for example wrap notifications with `React.act` while running tests.
      */
-
-
     const 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.
      */
-
-
     const setBatchNotifyFunction = fn => {
       batchNotifyFn = fn;
     };
-
     return {
       batch,
       batchCalls,
@@ -792,288 +630,253 @@
       setNotifyFunction,
       setBatchNotifyFunction
     };
-  } // SINGLETON
+  }
 
+  // SINGLETON
   const notifyManager = createNotifyManager();
 
   class Removable {
+    #gcTimeout;
     destroy() {
       this.clearGcTimeout();
     }
-
     scheduleGc() {
       this.clearGcTimeout();
-
-      if (isValidTimeout(this.cacheTime)) {
-        this.gcTimeout = setTimeout(() => {
+      if (isValidTimeout(this.gcTime)) {
+        this.#gcTimeout = setTimeout(() => {
           this.optionalRemove();
-        }, this.cacheTime);
+        }, this.gcTime);
       }
     }
-
-    updateCacheTime(newCacheTime) {
-      // Default to 5 minutes (Infinity for server-side) if no cache time is set
-      this.cacheTime = Math.max(this.cacheTime || 0, newCacheTime != null ? newCacheTime : isServer ? Infinity : 5 * 60 * 1000);
+    updateGcTime(newGcTime) {
+      // Default to 5 minutes (Infinity for server-side) if no gcTime is set
+      this.gcTime = Math.max(this.gcTime || 0, newGcTime ?? (isServer ? Infinity : 5 * 60 * 1000));
     }
-
     clearGcTimeout() {
-      if (this.gcTimeout) {
-        clearTimeout(this.gcTimeout);
-        this.gcTimeout = undefined;
+      if (this.#gcTimeout) {
+        clearTimeout(this.#gcTimeout);
+        this.#gcTimeout = undefined;
       }
     }
-
   }
 
+  // TYPES
+
   // CLASS
+
   class Query extends Removable {
+    #initialState;
+    #revertState;
+    #cache;
+    #promise;
+    #retryer;
+    #observers;
+    #defaultOptions;
+    #abortSignalConsumed;
     constructor(config) {
       super();
-      this.abortSignalConsumed = false;
-      this.defaultOptions = config.defaultOptions;
-      this.setOptions(config.options);
-      this.observers = [];
-      this.cache = config.cache;
-      this.logger = config.logger || defaultLogger;
+      this.#abortSignalConsumed = false;
+      this.#defaultOptions = config.defaultOptions;
+      this.#setOptions(config.options);
+      this.#observers = [];
+      this.#cache = config.cache;
       this.queryKey = config.queryKey;
       this.queryHash = config.queryHash;
-      this.initialState = config.state || getDefaultState$1(this.options);
-      this.state = this.initialState;
+      this.#initialState = config.state || getDefaultState$1(this.options);
+      this.state = this.#initialState;
       this.scheduleGc();
     }
-
     get meta() {
       return this.options.meta;
     }
-
-    setOptions(options) {
-      this.options = { ...this.defaultOptions,
+    #setOptions(options) {
+      this.options = {
+        ...this.#defaultOptions,
         ...options
       };
-      this.updateCacheTime(this.options.cacheTime);
+      this.updateGcTime(this.options.gcTime);
     }
-
     optionalRemove() {
-      if (!this.observers.length && this.state.fetchStatus === 'idle') {
-        this.cache.remove(this);
+      if (!this.#observers.length && this.state.fetchStatus === 'idle') {
+        this.#cache.remove(this);
       }
     }
-
     setData(newData, options) {
-      const data = replaceData(this.state.data, newData, this.options); // Set data and mark it as cached
+      const data = replaceData(this.state.data, newData, this.options);
 
-      this.dispatch({
+      // Set data and mark it as cached
+      this.#dispatch({
         data,
         type: 'success',
-        dataUpdatedAt: options == null ? void 0 : options.updatedAt,
-        manual: options == null ? void 0 : options.manual
+        dataUpdatedAt: options?.updatedAt,
+        manual: options?.manual
       });
       return data;
     }
-
     setState(state, setStateOptions) {
-      this.dispatch({
+      this.#dispatch({
         type: 'setState',
         state,
         setStateOptions
       });
     }
-
     cancel(options) {
-      var _this$retryer;
-
-      const promise = this.promise;
-      (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.cancel(options);
+      const promise = this.#promise;
+      this.#retryer?.cancel(options);
       return promise ? promise.then(noop$1).catch(noop$1) : Promise.resolve();
     }
-
     destroy() {
       super.destroy();
       this.cancel({
         silent: true
       });
     }
-
     reset() {
       this.destroy();
-      this.setState(this.initialState);
+      this.setState(this.#initialState);
     }
-
     isActive() {
-      return this.observers.some(observer => observer.options.enabled !== false);
+      return this.#observers.some(observer => observer.options.enabled !== false);
     }
-
     isDisabled() {
       return this.getObserversCount() > 0 && !this.isActive();
     }
-
     isStale() {
-      return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observers.some(observer => observer.getCurrentResult().isStale);
+      return this.state.isInvalidated || !this.state.dataUpdatedAt || this.#observers.some(observer => observer.getCurrentResult().isStale);
     }
-
     isStaleByTime(staleTime = 0) {
       return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
     }
-
     onFocus() {
-      var _this$retryer2;
-
-      const observer = this.observers.find(x => x.shouldFetchOnWindowFocus());
-
-      if (observer) {
-        observer.refetch({
-          cancelRefetch: false
-        });
-      } // Continue fetch if currently paused
-
+      const observer = this.#observers.find(x => x.shouldFetchOnWindowFocus());
+      observer?.refetch({
+        cancelRefetch: false
+      });
 
-      (_this$retryer2 = this.retryer) == null ? void 0 : _this$retryer2.continue();
+      // Continue fetch if currently paused
+      this.#retryer?.continue();
     }
-
     onOnline() {
-      var _this$retryer3;
-
-      const observer = this.observers.find(x => x.shouldFetchOnReconnect());
-
-      if (observer) {
-        observer.refetch({
-          cancelRefetch: false
-        });
-      } // Continue fetch if currently paused
-
+      const observer = this.#observers.find(x => x.shouldFetchOnReconnect());
+      observer?.refetch({
+        cancelRefetch: false
+      });
 
-      (_this$retryer3 = this.retryer) == null ? void 0 : _this$retryer3.continue();
+      // Continue fetch if currently paused
+      this.#retryer?.continue();
     }
-
     addObserver(observer) {
-      if (this.observers.indexOf(observer) === -1) {
-        this.observers.push(observer); // Stop the query from being garbage collected
+      if (this.#observers.indexOf(observer) === -1) {
+        this.#observers.push(observer);
 
+        // Stop the query from being garbage collected
         this.clearGcTimeout();
-        this.cache.notify({
+        this.#cache.notify({
           type: 'observerAdded',
           query: this,
           observer
         });
       }
     }
-
     removeObserver(observer) {
-      if (this.observers.indexOf(observer) !== -1) {
-        this.observers = this.observers.filter(x => x !== observer);
-
-        if (!this.observers.length) {
+      if (this.#observers.indexOf(observer) !== -1) {
+        this.#observers = this.#observers.filter(x => x !== observer);
+        if (!this.#observers.length) {
           // If the transport layer does not support cancellation
           // we'll let the query continue so the result can be cached
-          if (this.retryer) {
-            if (this.abortSignalConsumed) {
-              this.retryer.cancel({
+          if (this.#retryer) {
+            if (this.#abortSignalConsumed) {
+              this.#retryer.cancel({
                 revert: true
               });
             } else {
-              this.retryer.cancelRetry();
+              this.#retryer.cancelRetry();
             }
           }
-
           this.scheduleGc();
         }
-
-        this.cache.notify({
+        this.#cache.notify({
           type: 'observerRemoved',
           query: this,
           observer
         });
       }
     }
-
     getObserversCount() {
-      return this.observers.length;
+      return this.#observers.length;
     }
-
     invalidate() {
       if (!this.state.isInvalidated) {
-        this.dispatch({
+        this.#dispatch({
           type: 'invalidate'
         });
       }
     }
-
     fetch(options, fetchOptions) {
-      var _this$options$behavio, _context$fetchOptions;
-
       if (this.state.fetchStatus !== 'idle') {
-        if (this.state.dataUpdatedAt && fetchOptions != null && fetchOptions.cancelRefetch) {
+        if (this.state.dataUpdatedAt && fetchOptions?.cancelRefetch) {
           // Silently cancel current fetch if the user wants to cancel refetches
           this.cancel({
             silent: true
           });
-        } else if (this.promise) {
-          var _this$retryer4;
-
+        } else if (this.#promise) {
           // make sure that retries that were potentially cancelled due to unmounts can continue
-          (_this$retryer4 = this.retryer) == null ? void 0 : _this$retryer4.continueRetry(); // Return current promise if we are already fetching
-
-          return this.promise;
+          this.#retryer?.continueRetry();
+          // Return current promise if we are already fetching
+          return this.#promise;
         }
-      } // Update config if passed, otherwise the config from the last execution is used
-
+      }
 
+      // Update config if passed, otherwise the config from the last execution is used
       if (options) {
-        this.setOptions(options);
-      } // Use the options from the first observer with a query function if no function is found.
-      // This can happen when the query is hydrated or created with setQueryData.
-
+        this.#setOptions(options);
+      }
 
+      // Use the options from the first observer with a query function if no function is found.
+      // This can happen when the query is hydrated or created with setQueryData.
       if (!this.options.queryFn) {
-        const observer = this.observers.find(x => x.options.queryFn);
-
+        const observer = this.#observers.find(x => x.options.queryFn);
         if (observer) {
-          this.setOptions(observer.options);
+          this.#setOptions(observer.options);
         }
       }
-
-      if (!Array.isArray(this.options.queryKey)) {
-        {
-          this.logger.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']");
+      {
+        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 abortController = getAbortController(); // Create query function context
-
+      // Create query function context
       const queryFnContext = {
         queryKey: this.queryKey,
-        pageParam: undefined,
         meta: this.meta
-      }; // Adds an enumerable signal property to the object that
+      };
+
+      // Adds an enumerable signal property to the object that
       // which sets abortSignalConsumed to true when the signal
       // is read.
-
       const addSignalProperty = object => {
         Object.defineProperty(object, 'signal', {
           enumerable: true,
           get: () => {
-            if (abortController) {
-              this.abortSignalConsumed = true;
-              return abortController.signal;
-            }
-
-            return undefined;
+            this.#abortSignalConsumed = true;
+            return abortController.signal;
           }
         });
       };
+      addSignalProperty(queryFnContext);
 
-      addSignalProperty(queryFnContext); // Create fetch function
-
+      // Create fetch function
       const fetchFn = () => {
         if (!this.options.queryFn) {
-          return Promise.reject('Missing queryFn');
+          return Promise.reject(new Error('Missing queryFn'));
         }
-
-        this.abortSignalConsumed = false;
+        this.#abortSignalConsumed = false;
         return this.options.queryFn(queryFnContext);
-      }; // Trigger behavior hook
-
+      };
 
+      // Trigger behavior hook
       const context = {
         fetchOptions,
         options: this.options,
@@ -1082,89 +885,74 @@
         fetchFn
       };
       addSignalProperty(context);
-      (_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch(context); // Store state in case the current fetch needs to be reverted
+      this.options.behavior?.onFetch(context);
 
-      this.revertState = this.state; // Set to fetching state if not already in it
+      // Store state in case the current fetch needs to be reverted
+      this.#revertState = this.state;
 
-      if (this.state.fetchStatus === 'idle' || this.state.fetchMeta !== ((_context$fetchOptions = context.fetchOptions) == null ? void 0 : _context$fetchOptions.meta)) {
-        var _context$fetchOptions2;
-
-        this.dispatch({
+      // Set to fetching state if not already in it
+      if (this.state.fetchStatus === 'idle' || this.state.fetchMeta !== context.fetchOptions?.meta) {
+        this.#dispatch({
           type: 'fetch',
-          meta: (_context$fetchOptions2 = context.fetchOptions) == null ? void 0 : _context$fetchOptions2.meta
+          meta: context.fetchOptions?.meta
         });
       }
-
       const onError = error => {
         // Optimistically update state if needed
         if (!(isCancelledError(error) && error.silent)) {
-          this.dispatch({
+          this.#dispatch({
             type: 'error',
             error: error
           });
         }
-
         if (!isCancelledError(error)) {
-          var _this$cache$config$on, _this$cache$config;
-
           // Notify cache callback
-          (_this$cache$config$on = (_this$cache$config = this.cache.config).onError) == null ? void 0 : _this$cache$config$on.call(_this$cache$config, error, this);
-
-          {
-            this.logger.error(error);
-          }
+          this.#cache.config.onError?.(error, this);
         }
-
         if (!this.isFetchingOptimistic) {
           // Schedule query gc after fetching
           this.scheduleGc();
         }
-
         this.isFetchingOptimistic = false;
-      }; // Try to fetch the data
-
+      };
 
-      this.retryer = createRetryer({
+      // Try to fetch the data
+      this.#retryer = createRetryer({
         fn: context.fetchFn,
-        abort: abortController == null ? void 0 : abortController.abort.bind(abortController),
+        abort: abortController.abort.bind(abortController),
         onSuccess: data => {
-          var _this$cache$config$on2, _this$cache$config2;
-
           if (typeof data === 'undefined') {
             {
-              this.logger.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);
+              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}`);
             }
-
             onError(new Error('undefined'));
             return;
           }
+          this.setData(data);
 
-          this.setData(data); // Notify cache callback
-
-          (_this$cache$config$on2 = (_this$cache$config2 = this.cache.config).onSuccess) == null ? void 0 : _this$cache$config$on2.call(_this$cache$config2, data, this);
-
+          // Notify cache callback
+          this.#cache.config.onSuccess?.(data, this);
           if (!this.isFetchingOptimistic) {
             // Schedule query gc after fetching
             this.scheduleGc();
           }
-
           this.isFetchingOptimistic = false;
         },
         onError,
         onFail: (failureCount, error) => {
-          this.dispatch({
+          this.#dispatch({
             type: 'failed',
             failureCount,
             error
           });
         },
         onPause: () => {
-          this.dispatch({
+          this.#dispatch({
             type: 'pause'
           });
         },
         onContinue: () => {
-          this.dispatch({
+          this.#dispatch({
             type: 'continue'
           });
         },
@@ -1172,48 +960,46 @@
         retryDelay: context.options.retryDelay,
         networkMode: context.options.networkMode
       });
-      this.promise = this.retryer.promise;
-      return this.promise;
+      this.#promise = this.#retryer.promise;
+      return this.#promise;
     }
-
-    dispatch(action) {
+    #dispatch(action) {
       const reducer = state => {
-        var _action$meta, _action$dataUpdatedAt;
-
         switch (action.type) {
           case 'failed':
-            return { ...state,
+            return {
+              ...state,
               fetchFailureCount: action.failureCount,
               fetchFailureReason: action.error
             };
-
           case 'pause':
-            return { ...state,
+            return {
+              ...state,
               fetchStatus: 'paused'
             };
-
           case 'continue':
-            return { ...state,
+            return {
+              ...state,
               fetchStatus: 'fetching'
             };
-
           case 'fetch':
-            return { ...state,
+            return {
+              ...state,
               fetchFailureCount: 0,
               fetchFailureReason: null,
-              fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,
+              fetchMeta: action.meta ?? null,
               fetchStatus: canFetch(this.options.networkMode) ? 'fetching' : 'paused',
               ...(!state.dataUpdatedAt && {
                 error: null,
-                status: 'loading'
+                status: 'pending'
               })
             };
-
           case 'success':
-            return { ...state,
+            return {
+              ...state,
               data: action.data,
               dataUpdateCount: state.dataUpdateCount + 1,
-              dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),
+              dataUpdatedAt: action.dataUpdatedAt ?? Date.now(),
               error: null,
               isInvalidated: false,
               status: 'success',
@@ -1223,16 +1009,15 @@
                 fetchFailureReason: null
               })
             };
-
           case 'error':
             const error = action.error;
-
-            if (isCancelledError(error) && error.revert && this.revertState) {
-              return { ...this.revertState
+            if (isCancelledError(error) && error.revert && this.#revertState) {
+              return {
+                ...this.#revertState
               };
             }
-
-            return { ...state,
+            return {
+              ...state,
               error: error,
               errorUpdateCount: state.errorUpdateCount + 1,
               errorUpdatedAt: Date.now(),
@@ -1241,34 +1026,31 @@
               fetchStatus: 'idle',
               status: 'error'
             };
-
           case 'invalidate':
-            return { ...state,
+            return {
+              ...state,
               isInvalidated: true
             };
-
           case 'setState':
-            return { ...state,
+            return {
+              ...state,
               ...action.state
             };
         }
       };
-
       this.state = reducer(this.state);
       notifyManager.batch(() => {
-        this.observers.forEach(observer => {
+        this.#observers.forEach(observer => {
           observer.onQueryUpdate(action);
         });
-        this.cache.notify({
+        this.#cache.notify({
           query: this,
           type: 'updated',
           action
         });
       });
     }
-
   }
-
   function getDefaultState$1(options) {
     const data = typeof options.initialData === 'function' ? options.initialData() : options.initialData;
     const hasData = typeof data !== 'undefined';
@@ -1276,7 +1058,7 @@
     return {
       data,
       dataUpdateCount: 0,
-      dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,
+      dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,
       error: null,
       errorUpdateCount: 0,
       errorUpdatedAt: 0,
@@ -1284,31 +1066,27 @@
       fetchFailureReason: null,
       fetchMeta: null,
       isInvalidated: false,
-      status: hasData ? 'success' : 'loading',
+      status: hasData ? 'success' : 'pending',
       fetchStatus: 'idle'
     };
   }
 
   // CLASS
+
   class QueryCache extends Subscribable {
-    constructor(config) {
+    #queries;
+    constructor(config = {}) {
       super();
-      this.config = config || {};
-      this.queries = [];
-      this.queriesMap = {};
+      this.config = config;
+      this.#queries = config.createStore?.() ?? new Map();
     }
-
     build(client, options, state) {
-      var _options$queryHash;
-
       const queryKey = options.queryKey;
-      const queryHash = (_options$queryHash = options.queryHash) != null ? _options$queryHash : hashQueryKeyByOptions(queryKey, options);
+      const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);
       let query = this.get(queryHash);
-
       if (!query) {
         query = new Query({
           cache: this,
-          logger: client.getLogger(),
           queryKey,
           queryHash,
           options: client.defaultQueryOptions(options),
@@ -1317,70 +1095,53 @@
         });
         this.add(query);
       }
-
       return query;
     }
-
     add(query) {
-      if (!this.queriesMap[query.queryHash]) {
-        this.queriesMap[query.queryHash] = query;
-        this.queries.push(query);
+      if (!this.#queries.has(query.queryHash)) {
+        this.#queries.set(query.queryHash, query);
         this.notify({
           type: 'added',
           query
         });
       }
     }
-
     remove(query) {
-      const queryInMap = this.queriesMap[query.queryHash];
-
+      const queryInMap = this.#queries.get(query.queryHash);
       if (queryInMap) {
         query.destroy();
-        this.queries = this.queries.filter(x => x !== query);
-
         if (queryInMap === query) {
-          delete this.queriesMap[query.queryHash];
+          this.#queries.delete(query.queryHash);
         }
-
         this.notify({
           type: 'removed',
           query
         });
       }
     }
-
     clear() {
       notifyManager.batch(() => {
-        this.queries.forEach(query => {
+        this.getAll().forEach(query => {
           this.remove(query);
         });
       });
     }
-
     get(queryHash) {
-      return this.queriesMap[queryHash];
+      return this.#queries.get(queryHash);
     }
-
     getAll() {
-      return this.queries;
+      return [...this.#queries.values()];
     }
-
-    find(arg1, arg2) {
-      const [filters] = parseFilterArgs(arg1, arg2);
-
+    find(filters) {
       if (typeof filters.exact === 'undefined') {
         filters.exact = true;
       }
-
-      return this.queries.find(query => matchQuery(filters, query));
+      return this.getAll().find(query => matchQuery(filters, query));
     }
-
-    findAll(arg1, arg2) {
-      const [filters] = parseFilterArgs(arg1, arg2);
-      return Object.keys(filters).length > 0 ? this.queries.filter(query => matchQuery(filters, query)) : this.queries;
+    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 => {
@@ -1388,218 +1149,190 @@
         });
       });
     }
-
     onFocus() {
       notifyManager.batch(() => {
-        this.queries.forEach(query => {
+        this.getAll().forEach(query => {
           query.onFocus();
         });
       });
     }
-
     onOnline() {
       notifyManager.batch(() => {
-        this.queries.forEach(query => {
+        this.getAll().forEach(query => {
           query.onOnline();
         });
       });
     }
-
   }
 
+  // TYPES
+
   // CLASS
+
   class Mutation extends Removable {
+    #observers;
+    #mutationCache;
+    #retryer;
     constructor(config) {
       super();
-      this.options = { ...config.defaultOptions,
-        ...config.options
-      };
+      this.options = config.options;
       this.mutationId = config.mutationId;
-      this.mutationCache = config.mutationCache;
-      this.logger = config.logger || defaultLogger;
-      this.observers = [];
+      this.#mutationCache = config.mutationCache;
+      this.#observers = [];
       this.state = config.state || getDefaultState();
-      this.updateCacheTime(this.options.cacheTime);
+      this.updateGcTime(this.options.gcTime);
       this.scheduleGc();
     }
-
     get meta() {
       return this.options.meta;
     }
-
-    setState(state) {
-      this.dispatch({
-        type: 'setState',
-        state
-      });
-    }
-
     addObserver(observer) {
-      if (this.observers.indexOf(observer) === -1) {
-        this.observers.push(observer); // Stop the mutation from being garbage collected
+      if (this.#observers.indexOf(observer) === -1) {
+        this.#observers.push(observer);
 
+        // Stop the mutation from being garbage collected
         this.clearGcTimeout();
-        this.mutationCache.notify({
+        this.#mutationCache.notify({
           type: 'observerAdded',
           mutation: this,
           observer
         });
       }
     }
-
     removeObserver(observer) {
-      this.observers = this.observers.filter(x => x !== observer);
+      this.#observers = this.#observers.filter(x => x !== observer);
       this.scheduleGc();
-      this.mutationCache.notify({
+      this.#mutationCache.notify({
         type: 'observerRemoved',
         mutation: this,
         observer
       });
     }
-
     optionalRemove() {
-      if (!this.observers.length) {
-        if (this.state.status === 'loading') {
+      if (!this.#observers.length) {
+        if (this.state.status === 'pending') {
           this.scheduleGc();
         } else {
-          this.mutationCache.remove(this);
+          this.#mutationCache.remove(this);
         }
       }
     }
-
     continue() {
-      var _this$retryer$continu, _this$retryer;
-
-      return (_this$retryer$continu = (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.continue()) != null ? _this$retryer$continu : this.execute();
+      return this.#retryer?.continue() ??
+      // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+      this.execute(this.state.variables);
     }
-
-    async execute() {
+    async execute(variables) {
       const executeMutation = () => {
-        var _this$options$retry;
-
-        this.retryer = createRetryer({
+        this.#retryer = createRetryer({
           fn: () => {
             if (!this.options.mutationFn) {
-              return Promise.reject('No mutationFn found');
+              return Promise.reject(new Error('No mutationFn found'));
             }
-
-            return this.options.mutationFn(this.state.variables);
+            return this.options.mutationFn(variables);
           },
           onFail: (failureCount, error) => {
-            this.dispatch({
+            this.#dispatch({
               type: 'failed',
               failureCount,
               error
             });
           },
           onPause: () => {
-            this.dispatch({
+            this.#dispatch({
               type: 'pause'
             });
           },
           onContinue: () => {
-            this.dispatch({
+            this.#dispatch({
               type: 'continue'
             });
           },
-          retry: (_this$options$retry = this.options.retry) != null ? _this$options$retry : 0,
+          retry: this.options.retry ?? 0,
           retryDelay: this.options.retryDelay,
           networkMode: this.options.networkMode
         });
-        return this.retryer.promise;
+        return this.#retryer.promise;
       };
-
-      const restored = this.state.status === 'loading';
-
+      const restored = this.state.status === 'pending';
       try {
-        var _this$mutationCache$c3, _this$mutationCache$c4, _this$options$onSucce, _this$options2, _this$options$onSettl, _this$options3;
-
         if (!restored) {
-          var _this$mutationCache$c, _this$mutationCache$c2, _this$options$onMutat, _this$options;
-
-          this.dispatch({
-            type: 'loading',
-            variables: this.options.variables
-          }); // Notify cache callback
-
-          await ((_this$mutationCache$c = (_this$mutationCache$c2 = this.mutationCache.config).onMutate) == null ? void 0 : _this$mutationCache$c.call(_this$mutationCache$c2, this.state.variables, this));
-          const context = await ((_this$options$onMutat = (_this$options = this.options).onMutate) == null ? void 0 : _this$options$onMutat.call(_this$options, this.state.variables));
-
+          this.#dispatch({
+            type: 'pending',
+            variables
+          });
+          // Notify cache callback
+          await this.#mutationCache.config.onMutate?.(variables, this);
+          const context = await this.options.onMutate?.(variables);
           if (context !== this.state.context) {
-            this.dispatch({
-              type: 'loading',
+            this.#dispatch({
+              type: 'pending',
               context,
-              variables: this.state.variables
+              variables
             });
           }
         }
+        const data = await executeMutation();
 
-        const data = await executeMutation(); // Notify cache callback
-
-        await ((_this$mutationCache$c3 = (_this$mutationCache$c4 = this.mutationCache.config).onSuccess) == null ? void 0 : _this$mutationCache$c3.call(_this$mutationCache$c4, data, this.state.variables, this.state.context, this));
-        await ((_this$options$onSucce = (_this$options2 = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options2, data, this.state.variables, this.state.context));
-        await ((_this$options$onSettl = (_this$options3 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options3, data, null, this.state.variables, this.state.context));
-        this.dispatch({
+        // Notify cache callback
+        await this.#mutationCache.config.onSuccess?.(data, variables, this.state.context, this);
+        await this.options.onSuccess?.(data, variables, this.state.context);
+        await this.options.onSettled?.(data, null, variables, this.state.context);
+        this.#dispatch({
           type: 'success',
           data
         });
         return data;
       } catch (error) {
         try {
-          var _this$mutationCache$c5, _this$mutationCache$c6, _this$options$onError, _this$options4, _this$options$onSettl2, _this$options5;
-
           // Notify cache callback
-          await ((_this$mutationCache$c5 = (_this$mutationCache$c6 = this.mutationCache.config).onError) == null ? void 0 : _this$mutationCache$c5.call(_this$mutationCache$c6, error, this.state.variables, this.state.context, this));
-
-          if ("development" !== 'production') {
-            this.logger.error(error);
-          }
-
-          await ((_this$options$onError = (_this$options4 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options4, error, this.state.variables, this.state.context));
-          await ((_this$options$onSettl2 = (_this$options5 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options5, undefined, error, this.state.variables, this.state.context));
+          await this.#mutationCache.config.onError?.(error, variables, this.state.context, this);
+          await this.options.onError?.(error, variables, this.state.context);
+          await this.options.onSettled?.(undefined, error, variables, this.state.context);
           throw error;
         } finally {
-          this.dispatch({
+          this.#dispatch({
             type: 'error',
             error: error
           });
         }
       }
     }
-
-    dispatch(action) {
+    #dispatch(action) {
       const reducer = state => {
         switch (action.type) {
           case 'failed':
-            return { ...state,
+            return {
+              ...state,
               failureCount: action.failureCount,
               failureReason: action.error
             };
-
           case 'pause':
-            return { ...state,
+            return {
+              ...state,
               isPaused: true
             };
-
           case 'continue':
-            return { ...state,
+            return {
+              ...state,
               isPaused: false
             };
-
-          case 'loading':
-            return { ...state,
+          case 'pending':
+            return {
+              ...state,
               context: action.context,
               data: undefined,
               failureCount: 0,
               failureReason: null,
               error: null,
               isPaused: !canFetch(this.options.networkMode),
-              status: 'loading',
-              variables: action.variables
+              status: 'pending',
+              variables: action.variables,
+              submittedAt: Date.now()
             };
-
           case 'success':
-            return { ...state,
+            return {
+              ...state,
               data: action.data,
               failureCount: 0,
               failureReason: null,
@@ -1607,9 +1340,9 @@
               status: 'success',
               isPaused: false
             };
-
           case 'error':
-            return { ...state,
+            return {
+              ...state,
               data: undefined,
               error: action.error,
               failureCount: state.failureCount + 1,
@@ -1617,27 +1350,20 @@
               isPaused: false,
               status: 'error'
             };
-
-          case 'setState':
-            return { ...state,
-              ...action.state
-            };
         }
       };
-
       this.state = reducer(this.state);
       notifyManager.batch(() => {
-        this.observers.forEach(observer => {
+        this.#observers.forEach(observer => {
           observer.onMutationUpdate(action);
         });
-        this.mutationCache.notify({
+        this.#mutationCache.notify({
           mutation: this,
           type: 'updated',
           action
         });
       });
     }
-
   }
   function getDefaultState() {
     return {
@@ -1648,72 +1374,68 @@
       failureReason: null,
       isPaused: false,
       status: 'idle',
-      variables: undefined
+      variables: undefined,
+      submittedAt: 0
     };
   }
 
+  // TYPES
+
   // CLASS
+
   class MutationCache extends Subscribable {
-    constructor(config) {
+    #mutations;
+    #mutationId;
+    #resuming;
+    constructor(config = {}) {
       super();
-      this.config = config || {};
-      this.mutations = [];
-      this.mutationId = 0;
+      this.config = config;
+      this.#mutations = [];
+      this.#mutationId = 0;
     }
-
     build(client, options, state) {
       const mutation = new Mutation({
         mutationCache: this,
-        logger: client.getLogger(),
-        mutationId: ++this.mutationId,
+        mutationId: ++this.#mutationId,
         options: client.defaultMutationOptions(options),
-        state,
-        defaultOptions: options.mutationKey ? client.getMutationDefaults(options.mutationKey) : undefined
+        state
       });
       this.add(mutation);
       return mutation;
     }
-
     add(mutation) {
-      this.mutations.push(mutation);
+      this.#mutations.push(mutation);
       this.notify({
         type: 'added',
         mutation
       });
     }
-
     remove(mutation) {
-      this.mutations = this.mutations.filter(x => x !== mutation);
+      this.#mutations = this.#mutations.filter(x => x !== mutation);
       this.notify({
         type: 'removed',
         mutation
       });
     }
-
     clear() {
       notifyManager.batch(() => {
-        this.mutations.forEach(mutation => {
+        this.#mutations.forEach(mutation => {
           this.remove(mutation);
         });
       });
     }
-
     getAll() {
-      return this.mutations;
+      return this.#mutations;
     }
-
     find(filters) {
       if (typeof filters.exact === 'undefined') {
         filters.exact = true;
       }
-
-      return this.mutations.find(mutation => matchMutation(filters, mutation));
+      return this.#mutations.find(mutation => matchMutation(filters, mutation));
     }
-
-    findAll(filters) {
-      return this.mutations.filter(mutation => matchMutation(filters, mutation));
+    findAll(filters = {}) {
+      return this.#mutations.filter(mutation => matchMutation(filters, mutation));
     }
-
     notify(event) {
       notifyManager.batch(() => {
         this.listeners.forEach(listener => {
@@ -1721,76 +1443,65 @@
         });
       });
     }
-
     resumePausedMutations() {
-      var _this$resuming;
-
-      this.resuming = ((_this$resuming = this.resuming) != null ? _this$resuming : Promise.resolve()).then(() => {
-        const pausedMutations = this.mutations.filter(x => x.state.isPaused);
+      this.#resuming = (this.#resuming ?? Promise.resolve()).then(() => {
+        const pausedMutations = this.#mutations.filter(x => x.state.isPaused);
         return notifyManager.batch(() => pausedMutations.reduce((promise, mutation) => promise.then(() => mutation.continue().catch(noop$1)), Promise.resolve()));
       }).then(() => {
-        this.resuming = undefined;
+        this.#resuming = undefined;
       });
-      return this.resuming;
+      return this.#resuming;
     }
-
   }
 
   function infiniteQueryBehavior() {
     return {
       onFetch: context => {
         context.fetchFn = () => {
-          var _context$fetchOptions, _context$fetchOptions2, _context$fetchOptions3, _context$fetchOptions4, _context$state$data, _context$state$data2;
-
-          const refetchPage = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.refetchPage;
-          const fetchMore = (_context$fetchOptions3 = context.fetchOptions) == null ? void 0 : (_context$fetchOptions4 = _context$fetchOptions3.meta) == null ? void 0 : _context$fetchOptions4.fetchMore;
-          const pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;
-          const isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'forward';
-          const isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'backward';
-          const oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) || [];
-          const oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) || [];
+          const options = context.options;
+          const direction = context.fetchOptions?.meta?.fetchMore?.direction;
+          const oldPages = context.state.data?.pages || [];
+          const oldPageParams = context.state.data?.pageParams || [];
           let newPageParams = oldPageParams;
           let cancelled = false;
-
           const addSignalProperty = object => {
             Object.defineProperty(object, 'signal', {
               enumerable: true,
               get: () => {
-                var _context$signal;
-
-                if ((_context$signal = context.signal) != null && _context$signal.aborted) {
+                if (context.signal.aborted) {
                   cancelled = true;
                 } else {
-                  var _context$signal2;
-
-                  (_context$signal2 = context.signal) == null ? void 0 : _context$signal2.addEventListener('abort', () => {
+                  context.signal.addEventListener('abort', () => {
                     cancelled = true;
                   });
                 }
-
                 return context.signal;
               }
             });
-          }; // Get query function
-
-
-          const queryFn = context.options.queryFn || (() => Promise.reject('Missing queryFn'));
+          };
 
+          // Get query function
+          const queryFn = context.options.queryFn || (() => Promise.reject(new Error('Missing queryFn')));
           const buildNewPages = (pages, param, page, previous) => {
-            newPageParams = previous ? [param, ...newPageParams] : [...newPageParams, param];
-            return previous ? [page, ...pages] : [...pages, page];
-          }; // Create function to fetch a page
-
+            const {
+              maxPages
+            } = context.options;
+            if (previous) {
+              newPageParams = addToStart(newPageParams, param, maxPages);
+              return addToStart(pages, page, maxPages);
+            }
+            newPageParams = addToEnd(newPageParams, param, maxPages);
+            return addToEnd(pages, page, maxPages);
+          };
 
-          const fetchPage = (pages, manual, param, previous) => {
+          // Create function to fetch a page
+          const fetchPage = (pages, param, previous) => {
             if (cancelled) {
-              return Promise.reject('Cancelled');
+              return Promise.reject();
             }
-
-            if (typeof param === 'undefined' && !manual && pages.length) {
+            if (typeof param === 'undefined' && pages.length) {
               return Promise.resolve(pages);
             }
-
             const queryFnContext = {
               queryKey: context.queryKey,
               pageParam: param,
@@ -1801,43 +1512,35 @@
             const promise = Promise.resolve(queryFnResult).then(page => buildNewPages(pages, param, page, previous));
             return promise;
           };
+          let promise;
 
-          let promise; // Fetch first page?
-
+          // Fetch first page?
           if (!oldPages.length) {
-            promise = fetchPage([]);
-          } // Fetch next page?
-          else if (isFetchingNextPage) {
-            const manual = typeof pageParam !== 'undefined';
-            const param = manual ? pageParam : getNextPageParam(context.options, oldPages);
-            promise = fetchPage(oldPages, manual, param);
-          } // Fetch previous page?
-          else if (isFetchingPreviousPage) {
-            const manual = typeof pageParam !== 'undefined';
-            const param = manual ? pageParam : getPreviousPageParam(context.options, oldPages);
-            promise = fetchPage(oldPages, manual, param, true);
-          } // Refetch pages
+            promise = fetchPage([], options.defaultPageParam);
+          }
+
+          // fetch next / previous page?
+          else if (direction) {
+            const previous = direction === 'backward';
+            const param = previous ? getPreviousPageParam(options, oldPages) : getNextPageParam(options, oldPages);
+            promise = fetchPage(oldPages, param, previous);
+          }
+
+          // Refetch pages
           else {
             newPageParams = [];
-            const manual = typeof context.options.getNextPageParam === 'undefined';
-            const shouldFetchFirstPage = refetchPage && oldPages[0] ? refetchPage(oldPages[0], 0, oldPages) : true; // Fetch first page
 
-            promise = shouldFetchFirstPage ? fetchPage([], manual, oldPageParams[0]) : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0])); // Fetch remaining pages
+            // Fetch first page
+            promise = fetchPage([], oldPageParams[0]);
 
+            // Fetch remaining pages
             for (let i = 1; i < oldPages.length; i++) {
               promise = promise.then(pages => {
-                const shouldFetchNextPage = refetchPage && oldPages[i] ? refetchPage(oldPages[i], i, oldPages) : true;
-
-                if (shouldFetchNextPage) {
-                  const param = manual ? oldPageParams[i] : getNextPageParam(context.options, pages);
-                  return fetchPage(pages, manual, param);
-                }
-
-                return Promise.resolve(buildNewPages(pages, oldPageParams[i], oldPages[i]));
+                const param = getNextPageParam(options, pages);
+                return fetchPage(pages, param);
               });
             }
           }
-
           const finalPromise = promise.then(pages => ({
             pages,
             pageParams: newPageParams
@@ -1848,108 +1551,94 @@
     };
   }
   function getNextPageParam(options, pages) {
-    return options.getNextPageParam == null ? void 0 : options.getNextPageParam(pages[pages.length - 1], pages);
+    return options.getNextPageParam(pages[pages.length - 1], pages);
   }
   function getPreviousPageParam(options, pages) {
-    return options.getPreviousPageParam == null ? void 0 : options.getPreviousPageParam(pages[0], pages);
+    return options.getPreviousPageParam?.(pages[0], pages);
   }
+
   /**
    * Checks if there is a next page.
-   * Returns `undefined` if it cannot be determined.
    */
-
   function hasNextPage(options, pages) {
-    if (options.getNextPageParam && Array.isArray(pages)) {
-      const nextPageParam = getNextPageParam(options, pages);
-      return typeof nextPageParam !== 'undefined' && nextPageParam !== null && nextPageParam !== false;
-    }
-
-    return;
+    if (!pages) return false;
+    return typeof getNextPageParam(options, pages) !== 'undefined';
   }
+
   /**
    * Checks if there is a previous page.
-   * Returns `undefined` if it cannot be determined.
    */
-
   function hasPreviousPage(options, pages) {
-    if (options.getPreviousPageParam && Array.isArray(pages)) {
-      const previousPageParam = getPreviousPageParam(options, pages);
-      return typeof previousPageParam !== 'undefined' && previousPageParam !== null && previousPageParam !== false;
-    }
-
-    return;
+    if (!pages || !options.getPreviousPageParam) return false;
+    return typeof getPreviousPageParam(options, pages) !== 'undefined';
   }
 
   // CLASS
+
   class QueryClient {
+    #queryCache;
+    #mutationCache;
+    #defaultOptions;
+    #queryDefaults;
+    #mutationDefaults;
+    #mountCount;
+    #unsubscribeFocus;
+    #unsubscribeOnline;
     constructor(config = {}) {
-      this.queryCache = config.queryCache || new QueryCache();
-      this.mutationCache = config.mutationCache || new MutationCache();
-      this.logger = config.logger || defaultLogger;
-      this.defaultOptions = config.defaultOptions || {};
-      this.queryDefaults = [];
-      this.mutationDefaults = [];
-      this.mountCount = 0;
-
-      if (config.logger) {
-        this.logger.error("Passing a custom logger has been deprecated and will be removed in the next major version.");
-      }
+      this.#queryCache = config.queryCache || new QueryCache();
+      this.#mutationCache = config.mutationCache || new MutationCache();
+      this.#defaultOptions = config.defaultOptions || {};
+      this.#queryDefaults = new Map();
+      this.#mutationDefaults = new Map();
+      this.#mountCount = 0;
     }
-
     mount() {
-      this.mountCount++;
-      if (this.mountCount !== 1) return;
-      this.unsubscribeFocus = focusManager.subscribe(() => {
+      this.#mountCount++;
+      if (this.#mountCount !== 1) return;
+      this.#unsubscribeFocus = focusManager.subscribe(() => {
         if (focusManager.isFocused()) {
           this.resumePausedMutations();
-          this.queryCache.onFocus();
+          this.#queryCache.onFocus();
         }
       });
-      this.unsubscribeOnline = onlineManager.subscribe(() => {
+      this.#unsubscribeOnline = onlineManager.subscribe(() => {
         if (onlineManager.isOnline()) {
           this.resumePausedMutations();
-          this.queryCache.onOnline();
+          this.#queryCache.onOnline();
         }
       });
     }
-
     unmount() {
-      var _this$unsubscribeFocu, _this$unsubscribeOnli;
-
-      this.mountCount--;
-      if (this.mountCount !== 0) return;
-      (_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);
-      this.unsubscribeFocus = undefined;
-      (_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);
-      this.unsubscribeOnline = undefined;
-    }
-
-    isFetching(arg1, arg2) {
-      const [filters] = parseFilterArgs(arg1, arg2);
-      filters.fetchStatus = 'fetching';
-      return this.queryCache.findAll(filters).length;
+      this.#mountCount--;
+      if (this.#mountCount !== 0) return;
+      this.#unsubscribeFocus?.();
+      this.#unsubscribeFocus = undefined;
+      this.#unsubscribeOnline?.();
+      this.#unsubscribeOnline = undefined;
+    }
+    isFetching(filters) {
+      return this.#queryCache.findAll({
+        ...filters,
+        fetchStatus: 'fetching'
+      }).length;
     }
-
     isMutating(filters) {
-      return this.mutationCache.findAll({ ...filters,
-        fetching: true
+      return this.#mutationCache.findAll({
+        ...filters,
+        status: 'pending'
       }).length;
     }
-
-    getQueryData(queryKey, filters) {
-      var _this$queryCache$find;
-
-      return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;
+    getQueryData(queryKey) {
+      return this.#queryCache.find({
+        queryKey
+      })?.state.data;
     }
-
-    ensureQueryData(arg1, arg2, arg3) {
-      const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
-      const cachedData = this.getQueryData(parsedOptions.queryKey);
-      return cachedData ? Promise.resolve(cachedData) : this.fetchQuery(parsedOptions);
+    ensureQueryData(options) {
+      const cachedData = this.getQueryData(options.queryKey);
+      return cachedData ? Promise.resolve(cachedData) : this.fetchQuery(options);
     }
-
-    getQueriesData(queryKeyOrFilters) {
-      return this.getQueryCache().findAll(queryKeyOrFilters).map(({
+    getQueriesData(filters) {
+      return this.getQueryCache().findAll(filters).map(({
         queryKey,
         state
       }) => {
@@ -1957,48 +1646,43 @@
         return [queryKey, data];
       });
     }
-
     setQueryData(queryKey, updater, options) {
-      const query = this.queryCache.find(queryKey);
-      const prevData = query == null ? void 0 : query.state.data;
+      const query = this.#queryCache.find({
+        queryKey
+      });
+      const prevData = query?.state.data;
       const data = functionalUpdate(updater, prevData);
-
       if (typeof data === 'undefined') {
         return undefined;
       }
-
-      const parsedOptions = parseQueryArgs(queryKey);
-      const defaultedOptions = this.defaultQueryOptions(parsedOptions);
-      return this.queryCache.build(this, defaultedOptions).setData(data, { ...options,
+      const defaultedOptions = this.defaultQueryOptions({
+        queryKey
+      });
+      return this.#queryCache.build(this, defaultedOptions).setData(data, {
+        ...options,
         manual: true
       });
     }
-
-    setQueriesData(queryKeyOrFilters, updater, options) {
-      return notifyManager.batch(() => this.getQueryCache().findAll(queryKeyOrFilters).map(({
+    setQueriesData(filters, updater, options) {
+      return notifyManager.batch(() => this.getQueryCache().findAll(filters).map(({
         queryKey
       }) => [queryKey, this.setQueryData(queryKey, updater, options)]));
     }
-
-    getQueryState(queryKey, filters) {
-      var _this$queryCache$find2;
-
-      return (_this$queryCache$find2 = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find2.state;
+    getQueryState(queryKey) {
+      return this.#queryCache.find({
+        queryKey
+      })?.state;
     }
-
-    removeQueries(arg1, arg2) {
-      const [filters] = parseFilterArgs(arg1, arg2);
-      const queryCache = this.queryCache;
+    removeQueries(filters) {
+      const queryCache = this.#queryCache;
       notifyManager.batch(() => {
         queryCache.findAll(filters).forEach(query => {
           queryCache.remove(query);
         });
       });
     }
-
-    resetQueries(arg1, arg2, arg3) {
-      const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
-      const queryCache = this.queryCache;
+    resetQueries(filters, options) {
+      const queryCache = this.#queryCache;
       const refetchFilters = {
         type: 'active',
         ...filters
@@ -2010,326 +1694,252 @@
         return this.refetchQueries(refetchFilters, options);
       });
     }
-
-    cancelQueries(arg1, arg2, arg3) {
-      const [filters, cancelOptions = {}] = parseFilterArgs(arg1, arg2, arg3);
-
+    cancelQueries(filters = {}, cancelOptions = {}) {
       if (typeof cancelOptions.revert === 'undefined') {
         cancelOptions.revert = true;
       }
-
-      const promises = notifyManager.batch(() => this.queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
+      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
       return Promise.all(promises).then(noop$1).catch(noop$1);
     }
-
-    invalidateQueries(arg1, arg2, arg3) {
-      const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
+    invalidateQueries(filters = {}, options = {}) {
       return notifyManager.batch(() => {
-        var _ref, _filters$refetchType;
-
-        this.queryCache.findAll(filters).forEach(query => {
+        this.#queryCache.findAll(filters).forEach(query => {
           query.invalidate();
         });
-
         if (filters.refetchType === 'none') {
           return Promise.resolve();
         }
-
-        const refetchFilters = { ...filters,
-          type: (_ref = (_filters$refetchType = filters.refetchType) != null ? _filters$refetchType : filters.type) != null ? _ref : 'active'
+        const refetchFilters = {
+          ...filters,
+          type: filters.refetchType ?? filters.type ?? 'active'
         };
         return this.refetchQueries(refetchFilters, options);
       });
     }
-
-    refetchQueries(arg1, arg2, arg3) {
-      const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
-      const promises = notifyManager.batch(() => this.queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {
-        var _options$cancelRefetc;
-
-        return query.fetch(undefined, { ...options,
-          cancelRefetch: (_options$cancelRefetc = options == null ? void 0 : options.cancelRefetch) != null ? _options$cancelRefetc : true,
-          meta: {
-            refetchPage: filters.refetchPage
-          }
-        });
-      }));
+    refetchQueries(filters = {}, options) {
+      const promises = notifyManager.batch(() => this.#queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => query.fetch(undefined, {
+        ...options,
+        cancelRefetch: options?.cancelRefetch ?? true
+      })));
       let promise = Promise.all(promises).then(noop$1);
-
-      if (!(options != null && options.throwOnError)) {
+      if (!options?.throwOnError) {
         promise = promise.catch(noop$1);
       }
-
       return promise;
     }
+    fetchQuery(options) {
+      const defaultedOptions = this.defaultQueryOptions(options);
 
-    fetchQuery(arg1, arg2, arg3) {
-      const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
-      const defaultedOptions = this.defaultQueryOptions(parsedOptions); // https://github.com/tannerlinsley/react-query/issues/652
-
+      // https://github.com/tannerlinsley/react-query/issues/652
       if (typeof defaultedOptions.retry === 'undefined') {
         defaultedOptions.retry = false;
       }
-
-      const query = this.queryCache.build(this, defaultedOptions);
+      const query = this.#queryCache.build(this, defaultedOptions);
       return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
     }
-
-    prefetchQuery(arg1, arg2, arg3) {
-      return this.fetchQuery(arg1, arg2, arg3).then(noop$1).catch(noop$1);
+    prefetchQuery(options) {
+      return this.fetchQuery(options).then(noop$1).catch(noop$1);
     }
-
-    fetchInfiniteQuery(arg1, arg2, arg3) {
-      const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
-      parsedOptions.behavior = infiniteQueryBehavior();
-      return this.fetchQuery(parsedOptions);
+    fetchInfiniteQuery(options) {
+      options.behavior = infiniteQueryBehavior();
+      return this.fetchQuery(options);
     }
-
-    prefetchInfiniteQuery(arg1, arg2, arg3) {
-      return this.fetchInfiniteQuery(arg1, arg2, arg3).then(noop$1).catch(noop$1);
+    prefetchInfiniteQuery(options) {
+      return this.fetchInfiniteQuery(options).then(noop$1).catch(noop$1);
     }
-
     resumePausedMutations() {
-      return this.mutationCache.resumePausedMutations();
+      return this.#mutationCache.resumePausedMutations();
     }
-
     getQueryCache() {
-      return this.queryCache;
+      return this.#queryCache;
     }
-
     getMutationCache() {
-      return this.mutationCache;
-    }
-
-    getLogger() {
-      return this.logger;
+      return this.#mutationCache;
     }
-
     getDefaultOptions() {
-      return this.defaultOptions;
+      return this.#defaultOptions;
     }
-
     setDefaultOptions(options) {
-      this.defaultOptions = options;
+      this.#defaultOptions = options;
     }
-
     setQueryDefaults(queryKey, options) {
-      const result = this.queryDefaults.find(x => hashQueryKey(queryKey) === hashQueryKey(x.queryKey));
-
-      if (result) {
-        result.defaultOptions = options;
-      } else {
-        this.queryDefaults.push({
-          queryKey,
-          defaultOptions: options
-        });
-      }
+      this.#queryDefaults.set(hashKey(queryKey), {
+        queryKey,
+        defaultOptions: options
+      });
     }
-
     getQueryDefaults(queryKey) {
-      if (!queryKey) {
-        return undefined;
-      } // Get the first matching defaults
-
-
-      const firstMatchingDefaults = this.queryDefaults.find(x => partialMatchKey(queryKey, x.queryKey)); // Additional checks and error in dev mode
-
-      {
-        // Retrieve all matching defaults for the given key
-        const matchingDefaults = this.queryDefaults.filter(x => partialMatchKey(queryKey, x.queryKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key
-
-        if (matchingDefaults.length > 1) {
-          this.logger.error("[QueryClient] Several query defaults match with key '" + JSON.stringify(queryKey) + "'. The first matching query defaults are used. Please check how query defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetquerydefaults.");
+      const defaults = [...this.#queryDefaults.values()];
+      let result = {};
+      defaults.forEach(queryDefault => {
+        if (partialMatchKey(queryKey, queryDefault.queryKey)) {
+          result = {
+            ...result,
+            ...queryDefault.defaultOptions
+          };
         }
-      }
-
-      return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
+      });
+      return result;
     }
-
     setMutationDefaults(mutationKey, options) {
-      const result = this.mutationDefaults.find(x => hashQueryKey(mutationKey) === hashQueryKey(x.mutationKey));
-
-      if (result) {
-        result.defaultOptions = options;
-      } else {
-        this.mutationDefaults.push({
-          mutationKey,
-          defaultOptions: options
-        });
-      }
+      this.#mutationDefaults.set(hashKey(mutationKey), {
+        mutationKey,
+        defaultOptions: options
+      });
     }
-
     getMutationDefaults(mutationKey) {
-      if (!mutationKey) {
-        return undefined;
-      } // Get the first matching defaults
-
-
-      const firstMatchingDefaults = this.mutationDefaults.find(x => partialMatchKey(mutationKey, x.mutationKey)); // Additional checks and error in dev mode
-
-      {
-        // Retrieve all matching defaults for the given key
-        const matchingDefaults = this.mutationDefaults.filter(x => partialMatchKey(mutationKey, x.mutationKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key
-
-        if (matchingDefaults.length > 1) {
-          this.logger.error("[QueryClient] Several mutation defaults match with key '" + JSON.stringify(mutationKey) + "'. The first matching mutation defaults are used. Please check how mutation defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetmutationdefaults.");
+      const defaults = [...this.#mutationDefaults.values()];
+      let result = {};
+      defaults.forEach(queryDefault => {
+        if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {
+          result = {
+            ...result,
+            ...queryDefault.defaultOptions
+          };
         }
-      }
-
-      return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
+      });
+      return result;
     }
-
     defaultQueryOptions(options) {
-      if (options != null && options._defaulted) {
+      if (options?._defaulted) {
         return options;
       }
-
-      const defaultedOptions = { ...this.defaultOptions.queries,
-        ...this.getQueryDefaults(options == null ? void 0 : options.queryKey),
+      const defaultedOptions = {
+        ...this.#defaultOptions.queries,
+        ...(options?.queryKey && this.getQueryDefaults(options.queryKey)),
         ...options,
         _defaulted: true
       };
-
-      if (!defaultedOptions.queryHash && defaultedOptions.queryKey) {
+      if (!defaultedOptions.queryHash) {
         defaultedOptions.queryHash = hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);
-      } // dependent default values
-
+      }
 
+      // dependent default values
       if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {
         defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';
       }
-
-      if (typeof defaultedOptions.useErrorBoundary === 'undefined') {
-        defaultedOptions.useErrorBoundary = !!defaultedOptions.suspense;
+      if (typeof defaultedOptions.throwErrors === 'undefined') {
+        defaultedOptions.throwErrors = !!defaultedOptions.suspense;
       }
-
       return defaultedOptions;
     }
-
     defaultMutationOptions(options) {
-      if (options != null && options._defaulted) {
+      if (options?._defaulted) {
         return options;
       }
-
-      return { ...this.defaultOptions.mutations,
-        ...this.getMutationDefaults(options == null ? void 0 : options.mutationKey),
+      return {
+        ...this.#defaultOptions.mutations,
+        ...(options?.mutationKey && this.getMutationDefaults(options.mutationKey)),
         ...options,
         _defaulted: true
       };
     }
-
     clear() {
-      this.queryCache.clear();
-      this.mutationCache.clear();
+      this.#queryCache.clear();
+      this.#mutationCache.clear();
     }
-
   }
 
   class QueryObserver extends Subscribable {
+    #client;
+    #currentQuery = undefined;
+    #currentQueryInitialState = undefined;
+    #currentResult = undefined;
+    #currentResultState;
+    #currentResultOptions;
+    #previousQueryResult;
+    #selectError;
+    #selectFn;
+    #selectResult;
+    #staleTimeoutId;
+    #refetchIntervalId;
+    #currentRefetchInterval;
+    #trackedProps = new Set();
     constructor(client, options) {
       super();
-      this.client = client;
+      this.#client = client;
       this.options = options;
-      this.trackedProps = new Set();
-      this.selectError = null;
+      this.#selectError = null;
       this.bindMethods();
       this.setOptions(options);
     }
-
     bindMethods() {
-      this.remove = this.remove.bind(this);
       this.refetch = this.refetch.bind(this);
     }
-
     onSubscribe() {
       if (this.listeners.length === 1) {
-        this.currentQuery.addObserver(this);
-
-        if (shouldFetchOnMount(this.currentQuery, this.options)) {
-          this.executeFetch();
+        this.#currentQuery.addObserver(this);
+        if (shouldFetchOnMount(this.#currentQuery, this.options)) {
+          this.#executeFetch();
         }
-
-        this.updateTimers();
+        this.#updateTimers();
       }
     }
-
     onUnsubscribe() {
       if (!this.listeners.length) {
         this.destroy();
       }
     }
-
     shouldFetchOnReconnect() {
-      return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnReconnect);
+      return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnReconnect);
     }
-
     shouldFetchOnWindowFocus() {
-      return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnWindowFocus);
+      return shouldFetchOn(this.#currentQuery, this.options, this.options.refetchOnWindowFocus);
     }
-
     destroy() {
       this.listeners = [];
-      this.clearStaleTimeout();
-      this.clearRefetchInterval();
-      this.currentQuery.removeObserver(this);
+      this.#clearStaleTimeout();
+      this.#clearRefetchInterval();
+      this.#currentQuery.removeObserver(this);
     }
-
     setOptions(options, notifyOptions) {
       const prevOptions = this.options;
-      const prevQuery = this.currentQuery;
-      this.options = this.client.defaultQueryOptions(options);
-
-      if (typeof (options == null ? void 0 : options.isDataEqual) !== 'undefined') {
-        this.client.getLogger().error("The isDataEqual option has been deprecated and will be removed in the next major version. You can achieve the same functionality by passing a function as the structuralSharing option");
-      }
-
+      const prevQuery = this.#currentQuery;
+      this.options = this.#client.defaultQueryOptions(options);
       if (!shallowEqualObjects(prevOptions, this.options)) {
-        this.client.getQueryCache().notify({
+        this.#client.getQueryCache().notify({
           type: 'observerOptionsUpdated',
-          query: this.currentQuery,
+          query: this.#currentQuery,
           observer: this
         });
       }
-
       if (typeof this.options.enabled !== 'undefined' && typeof this.options.enabled !== 'boolean') {
         throw new Error('Expected enabled to be a boolean');
-      } // Keep previous query key if the user does not supply one
-
+      }
 
+      // Keep previous query key if the user does not supply one
       if (!this.options.queryKey) {
         this.options.queryKey = prevOptions.queryKey;
       }
+      this.#updateQuery();
+      const mounted = this.hasListeners();
 
-      this.updateQuery();
-      const mounted = this.hasListeners(); // Fetch if there are subscribers
-
-      if (mounted && shouldFetchOptionally(this.currentQuery, prevQuery, this.options, prevOptions)) {
-        this.executeFetch();
-      } // Update result
-
+      // Fetch if there are subscribers
+      if (mounted && shouldFetchOptionally(this.#currentQuery, prevQuery, this.options, prevOptions)) {
+        this.#executeFetch();
+      }
 
-      this.updateResult(notifyOptions); // Update stale interval if needed
+      // Update result
+      this.#updateResult(notifyOptions);
 
-      if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
-        this.updateStaleTimeout();
+      // Update stale interval if needed
+      if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
+        this.#updateStaleTimeout();
       }
+      const nextRefetchInterval = this.#computeRefetchInterval();
 
-      const nextRefetchInterval = this.computeRefetchInterval(); // Update refetch interval if needed
-
-      if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.currentRefetchInterval)) {
-        this.updateRefetchInterval(nextRefetchInterval);
+      // Update refetch interval if needed
+      if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.#currentRefetchInterval)) {
+        this.#updateRefetchInterval(nextRefetchInterval);
       }
     }
-
     getOptimisticResult(options) {
-      const query = this.client.getQueryCache().build(this.client, options);
+      const query = this.#client.getQueryCache().build(this.#client, options);
       return this.createResult(query, options);
     }
-
     getCurrentResult() {
-      return this.currentResult;
+      return this.#currentResult;
     }
-
     trackResult(result) {
       const trackedResult = {};
       Object.keys(result).forEach(key => {
@@ -2337,243 +1947,199 @@
           configurable: false,
           enumerable: true,
           get: () => {
-            this.trackedProps.add(key);
+            this.#trackedProps.add(key);
             return result[key];
           }
         });
       });
       return trackedResult;
     }
-
     getCurrentQuery() {
-      return this.currentQuery;
+      return this.#currentQuery;
     }
-
-    remove() {
-      this.client.getQueryCache().remove(this.currentQuery);
-    }
-
     refetch({
-      refetchPage,
       ...options
     } = {}) {
-      return this.fetch({ ...options,
-        meta: {
-          refetchPage
-        }
+      return this.fetch({
+        ...options
       });
     }
-
     fetchOptimistic(options) {
-      const defaultedOptions = this.client.defaultQueryOptions(options);
-      const query = this.client.getQueryCache().build(this.client, defaultedOptions);
+      const defaultedOptions = this.#client.defaultQueryOptions(options);
+      const query = this.#client.getQueryCache().build(this.#client, defaultedOptions);
       query.isFetchingOptimistic = true;
       return query.fetch().then(() => this.createResult(query, defaultedOptions));
     }
-
     fetch(fetchOptions) {
-      var _fetchOptions$cancelR;
-
-      return this.executeFetch({ ...fetchOptions,
-        cancelRefetch: (_fetchOptions$cancelR = fetchOptions.cancelRefetch) != null ? _fetchOptions$cancelR : true
+      return this.#executeFetch({
+        ...fetchOptions,
+        cancelRefetch: fetchOptions.cancelRefetch ?? true
       }).then(() => {
-        this.updateResult();
-        return this.currentResult;
+        this.#updateResult();
+        return this.#currentResult;
       });
     }
-
-    executeFetch(fetchOptions) {
+    #executeFetch(fetchOptions) {
       // Make sure we reference the latest query as the current one might have been removed
-      this.updateQuery(); // Fetch
+      this.#updateQuery();
 
-      let promise = this.currentQuery.fetch(this.options, fetchOptions);
-
-      if (!(fetchOptions != null && fetchOptions.throwOnError)) {
+      // Fetch
+      let promise = this.#currentQuery.fetch(this.options, fetchOptions);
+      if (!fetchOptions?.throwOnError) {
         promise = promise.catch(noop$1);
       }
-
       return promise;
     }
-
-    updateStaleTimeout() {
-      this.clearStaleTimeout();
-
-      if (isServer || this.currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
+    #updateStaleTimeout() {
+      this.#clearStaleTimeout();
+      if (isServer || this.#currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
         return;
       }
+      const time = timeUntilStale(this.#currentResult.dataUpdatedAt, this.options.staleTime);
 
-      const time = timeUntilStale(this.currentResult.dataUpdatedAt, this.options.staleTime); // The timeout is sometimes triggered 1 ms before the stale time expiration.
+      // The timeout is sometimes triggered 1 ms before the stale time expiration.
       // To mitigate this issue we always add 1 ms to the timeout.
-
       const timeout = time + 1;
-      this.staleTimeoutId = setTimeout(() => {
-        if (!this.currentResult.isStale) {
-          this.updateResult();
+      this.#staleTimeoutId = setTimeout(() => {
+        if (!this.#currentResult.isStale) {
+          this.#updateResult();
         }
       }, timeout);
     }
-
-    computeRefetchInterval() {
-      var _this$options$refetch;
-
-      return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.currentResult.data, this.currentQuery) : (_this$options$refetch = this.options.refetchInterval) != null ? _this$options$refetch : false;
+    #computeRefetchInterval() {
+      return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.#currentResult.data, this.#currentQuery) : this.options.refetchInterval ?? false;
     }
-
-    updateRefetchInterval(nextInterval) {
-      this.clearRefetchInterval();
-      this.currentRefetchInterval = nextInterval;
-
-      if (isServer || this.options.enabled === false || !isValidTimeout(this.currentRefetchInterval) || this.currentRefetchInterval === 0) {
+    #updateRefetchInterval(nextInterval) {
+      this.#clearRefetchInterval();
+      this.#currentRefetchInterval = nextInterval;
+      if (isServer || this.options.enabled === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {
         return;
       }
-
-      this.refetchIntervalId = setInterval(() => {
+      this.#refetchIntervalId = setInterval(() => {
         if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
-          this.executeFetch();
+          this.#executeFetch();
         }
-      }, this.currentRefetchInterval);
+      }, this.#currentRefetchInterval);
     }
-
-    updateTimers() {
-      this.updateStaleTimeout();
-      this.updateRefetchInterval(this.computeRefetchInterval());
+    #updateTimers() {
+      this.#updateStaleTimeout();
+      this.#updateRefetchInterval(this.#computeRefetchInterval());
     }
-
-    clearStaleTimeout() {
-      if (this.staleTimeoutId) {
-        clearTimeout(this.staleTimeoutId);
-        this.staleTimeoutId = undefined;
+    #clearStaleTimeout() {
+      if (this.#staleTimeoutId) {
+        clearTimeout(this.#staleTimeoutId);
+        this.#staleTimeoutId = undefined;
       }
     }
-
-    clearRefetchInterval() {
-      if (this.refetchIntervalId) {
-        clearInterval(this.refetchIntervalId);
-        this.refetchIntervalId = undefined;
+    #clearRefetchInterval() {
+      if (this.#refetchIntervalId) {
+        clearInterval(this.#refetchIntervalId);
+        this.#refetchIntervalId = undefined;
       }
     }
-
     createResult(query, options) {
-      const prevQuery = this.currentQuery;
+      const prevQuery = this.#currentQuery;
       const prevOptions = this.options;
-      const prevResult = this.currentResult;
-      const prevResultState = this.currentResultState;
-      const prevResultOptions = this.currentResultOptions;
+      const prevResult = this.#currentResult;
+      const prevResultState = this.#currentResultState;
+      const prevResultOptions = this.#currentResultOptions;
       const queryChange = query !== prevQuery;
-      const queryInitialState = queryChange ? query.state : this.currentQueryInitialState;
-      const prevQueryResult = queryChange ? this.currentResult : this.previousQueryResult;
+      const queryInitialState = queryChange ? query.state : this.#currentQueryInitialState;
+      const prevQueryResult = queryChange ? this.#currentResult : this.#previousQueryResult;
       const {
         state
       } = query;
       let {
-        dataUpdatedAt,
         error,
         errorUpdatedAt,
         fetchStatus,
         status
       } = state;
-      let isPreviousData = false;
       let isPlaceholderData = false;
-      let data; // Optimistically set result in fetching state if needed
+      let data;
 
+      // Optimistically set result in fetching state if needed
       if (options._optimisticResults) {
         const mounted = this.hasListeners();
         const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
         const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
-
         if (fetchOnMount || fetchOptionally) {
           fetchStatus = canFetch(query.options.networkMode) ? 'fetching' : 'paused';
-
-          if (!dataUpdatedAt) {
-            status = 'loading';
+          if (!state.dataUpdatedAt) {
+            status = 'pending';
           }
         }
-
         if (options._optimisticResults === 'isRestoring') {
           fetchStatus = 'idle';
         }
-      } // Keep previous data if needed
-
+      }
 
-      if (options.keepPreviousData && !state.dataUpdatedAt && prevQueryResult != null && prevQueryResult.isSuccess && status !== 'error') {
-        data = prevQueryResult.data;
-        dataUpdatedAt = prevQueryResult.dataUpdatedAt;
-        status = prevQueryResult.status;
-        isPreviousData = true;
-      } // Select data if needed
-      else if (options.select && typeof state.data !== 'undefined') {
+      // Select data if needed
+      if (options.select && typeof state.data !== 'undefined') {
         // Memoize select result
-        if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === this.selectFn) {
-          data = this.selectResult;
+        if (prevResult && state.data === prevResultState?.data && options.select === this.#selectFn) {
+          data = this.#selectResult;
         } else {
           try {
-            this.selectFn = options.select;
+            this.#selectFn = options.select;
             data = options.select(state.data);
-            data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
-            this.selectResult = data;
-            this.selectError = null;
+            data = replaceData(prevResult?.data, data, options);
+            this.#selectResult = data;
+            this.#selectError = null;
           } catch (selectError) {
-            {
-              this.client.getLogger().error(selectError);
-            }
-
-            this.selectError = selectError;
+            this.#selectError = selectError;
           }
         }
-      } // Use query data
+      }
+      // Use query data
       else {
         data = state.data;
-      } // Show placeholder data if needed
-
+      }
 
-      if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'loading') {
-        let placeholderData; // Memoize placeholder data
+      // Show placeholder data if needed
+      if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'pending') {
+        let placeholderData;
 
-        if (prevResult != null && prevResult.isPlaceholderData && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
+        // Memoize placeholder data
+        if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {
           placeholderData = prevResult.data;
         } else {
-          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData() : options.placeholderData;
-
+          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData(prevQueryResult?.data) : options.placeholderData;
           if (options.select && typeof placeholderData !== 'undefined') {
             try {
               placeholderData = options.select(placeholderData);
-              this.selectError = null;
+              this.#selectError = null;
             } catch (selectError) {
-              {
-                this.client.getLogger().error(selectError);
-              }
-
-              this.selectError = selectError;
+              this.#selectError = selectError;
             }
           }
         }
-
         if (typeof placeholderData !== 'undefined') {
           status = 'success';
-          data = replaceData(prevResult == null ? void 0 : prevResult.data, placeholderData, options);
+          data = replaceData(prevResult?.data, placeholderData, options);
           isPlaceholderData = true;
         }
       }
-
-      if (this.selectError) {
-        error = this.selectError;
-        data = this.selectResult;
+      if (this.#selectError) {
+        error = this.#selectError;
+        data = this.#selectResult;
         errorUpdatedAt = Date.now();
         status = 'error';
       }
-
       const isFetching = fetchStatus === 'fetching';
-      const isLoading = status === 'loading';
+      const isPending = status === 'pending';
       const isError = status === 'error';
+      const isLoading = isPending && isFetching;
       const result = {
         status,
         fetchStatus,
-        isLoading,
+        isPending,
         isSuccess: status === 'success',
         isError,
-        isInitialLoading: isLoading && isFetching,
+        isInitialLoading: isLoading,
+        isLoading,
         data,
-        dataUpdatedAt,
+        dataUpdatedAt: state.dataUpdatedAt,
         error,
         errorUpdatedAt,
         failureCount: state.fetchFailureCount,
@@ -2582,377 +2148,313 @@
         isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
         isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,
         isFetching,
-        isRefetching: isFetching && !isLoading,
+        isRefetching: isFetching && !isPending,
         isLoadingError: isError && state.dataUpdatedAt === 0,
         isPaused: fetchStatus === 'paused',
         isPlaceholderData,
-        isPreviousData,
         isRefetchError: isError && state.dataUpdatedAt !== 0,
         isStale: isStale(query, options),
-        refetch: this.refetch,
-        remove: this.remove
+        refetch: this.refetch
       };
       return result;
     }
+    #updateResult(notifyOptions) {
+      const prevResult = this.#currentResult;
+      const nextResult = this.createResult(this.#currentQuery, this.options);
+      this.#currentResultState = this.#currentQuery.state;
+      this.#currentResultOptions = this.options;
 
-    updateResult(notifyOptions) {
-      const prevResult = this.currentResult;
-      const nextResult = this.createResult(this.currentQuery, this.options);
-      this.currentResultState = this.currentQuery.state;
-      this.currentResultOptions = this.options; // Only notify and update result if something has changed
-
+      // Only notify and update result if something has changed
       if (shallowEqualObjects(nextResult, prevResult)) {
         return;
       }
+      this.#currentResult = nextResult;
 
-      this.currentResult = nextResult; // Determine which callbacks to trigger
-
-      const defaultNotifyOptions = {
-        cache: true
-      };
-
+      // Determine which callbacks to trigger
+      const defaultNotifyOptions = {};
       const shouldNotifyListeners = () => {
         if (!prevResult) {
           return true;
         }
-
         const {
           notifyOnChangeProps
         } = this.options;
-
-        if (notifyOnChangeProps === 'all' || !notifyOnChangeProps && !this.trackedProps.size) {
+        if (notifyOnChangeProps === 'all' || !notifyOnChangeProps && !this.#trackedProps.size) {
           return true;
         }
-
-        const includedProps = new Set(notifyOnChangeProps != null ? notifyOnChangeProps : this.trackedProps);
-
-        if (this.options.useErrorBoundary) {
+        const includedProps = new Set(notifyOnChangeProps ?? this.#trackedProps);
+        if (this.options.throwErrors) {
           includedProps.add('error');
         }
-
-        return Object.keys(this.currentResult).some(key => {
+        return Object.keys(this.#currentResult).some(key => {
           const typedKey = key;
-          const changed = this.currentResult[typedKey] !== prevResult[typedKey];
+          const changed = this.#currentResult[typedKey] !== prevResult[typedKey];
           return changed && includedProps.has(typedKey);
         });
       };
-
-      if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && shouldNotifyListeners()) {
+      if (notifyOptions?.listeners !== false && shouldNotifyListeners()) {
         defaultNotifyOptions.listeners = true;
       }
-
-      this.notify({ ...defaultNotifyOptions,
+      this.#notify({
+        ...defaultNotifyOptions,
         ...notifyOptions
       });
     }
-
-    updateQuery() {
-      const query = this.client.getQueryCache().build(this.client, this.options);
-
-      if (query === this.currentQuery) {
+    #updateQuery() {
+      const query = this.#client.getQueryCache().build(this.#client, this.options);
+      if (query === this.#currentQuery) {
         return;
       }
-
-      const prevQuery = this.currentQuery;
-      this.currentQuery = query;
-      this.currentQueryInitialState = query.state;
-      this.previousQueryResult = this.currentResult;
-
+      const prevQuery = this.#currentQuery;
+      this.#currentQuery = query;
+      this.#currentQueryInitialState = query.state;
+      this.#previousQueryResult = this.#currentResult;
       if (this.hasListeners()) {
-        prevQuery == null ? void 0 : prevQuery.removeObserver(this);
+        prevQuery?.removeObserver(this);
         query.addObserver(this);
       }
     }
-
     onQueryUpdate(action) {
       const notifyOptions = {};
-
       if (action.type === 'success') {
         notifyOptions.onSuccess = !action.manual;
       } else if (action.type === 'error' && !isCancelledError(action.error)) {
         notifyOptions.onError = true;
       }
-
-      this.updateResult(notifyOptions);
-
+      this.#updateResult(notifyOptions);
       if (this.hasListeners()) {
-        this.updateTimers();
+        this.#updateTimers();
       }
     }
-
-    notify(notifyOptions) {
+    #notify(notifyOptions) {
       notifyManager.batch(() => {
         // First trigger the configuration callbacks
         if (notifyOptions.onSuccess) {
-          var _this$options$onSucce, _this$options, _this$options$onSettl, _this$options2;
-
-          (_this$options$onSucce = (_this$options = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options, this.currentResult.data);
-          (_this$options$onSettl = (_this$options2 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options2, this.currentResult.data, null);
+          this.options.onSuccess?.(this.#currentResult.data);
+          this.options.onSettled?.(this.#currentResult.data, null);
         } else if (notifyOptions.onError) {
-          var _this$options$onError, _this$options3, _this$options$onSettl2, _this$options4;
-
-          (_this$options$onError = (_this$options3 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options3, this.currentResult.error);
-          (_this$options$onSettl2 = (_this$options4 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options4, undefined, this.currentResult.error);
-        } // Then trigger the listeners
-
+          this.options.onError?.(this.#currentResult.error);
+          this.options.onSettled?.(undefined, this.#currentResult.error);
+        }
 
+        // Then trigger the listeners
         if (notifyOptions.listeners) {
           this.listeners.forEach(listener => {
-            listener(this.currentResult);
-          });
-        } // Then the cache listeners
-
-
-        if (notifyOptions.cache) {
-          this.client.getQueryCache().notify({
-            query: this.currentQuery,
-            type: 'observerResultsUpdated'
+            listener(this.#currentResult);
           });
         }
+
+        // Then the cache listeners
+        this.#client.getQueryCache().notify({
+          query: this.#currentQuery,
+          type: 'observerResultsUpdated'
+        });
       });
     }
-
   }
-
   function shouldLoadOnMount(query, options) {
     return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === 'error' && options.retryOnMount === false);
   }
-
   function shouldFetchOnMount(query, options) {
     return shouldLoadOnMount(query, options) || query.state.dataUpdatedAt > 0 && shouldFetchOn(query, options, options.refetchOnMount);
   }
-
   function shouldFetchOn(query, options, field) {
     if (options.enabled !== false) {
       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 options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== 'error') && isStale(query, options);
   }
-
   function isStale(query, options) {
     return query.isStaleByTime(options.staleTime);
   }
 
+  function difference(array1, array2) {
+    return array1.filter(x => array2.indexOf(x) === -1);
+  }
+  function replaceAt(array, index, value) {
+    const copy = array.slice(0);
+    copy[index] = value;
+    return copy;
+  }
   class QueriesObserver extends Subscribable {
+    #client;
+    #result;
+    #queries;
+    #observers;
+    #observersMap;
     constructor(client, queries) {
       super();
-      this.client = client;
-      this.queries = [];
-      this.result = [];
-      this.observers = [];
-      this.observersMap = {};
-
+      this.#client = client;
+      this.#queries = [];
+      this.#result = [];
+      this.#observers = [];
+      this.#observersMap = {};
       if (queries) {
         this.setQueries(queries);
       }
     }
-
     onSubscribe() {
       if (this.listeners.length === 1) {
-        this.observers.forEach(observer => {
+        this.#observers.forEach(observer => {
           observer.subscribe(result => {
-            this.onUpdate(observer, result);
+            this.#onUpdate(observer, result);
           });
         });
       }
     }
-
     onUnsubscribe() {
       if (!this.listeners.length) {
         this.destroy();
       }
     }
-
     destroy() {
       this.listeners = [];
-      this.observers.forEach(observer => {
+      this.#observers.forEach(observer => {
         observer.destroy();
       });
     }
-
     setQueries(queries, notifyOptions) {
-      this.queries = queries;
+      this.#queries = queries;
       notifyManager.batch(() => {
-        const prevObservers = this.observers;
-        const newObserverMatches = this.findMatchingObservers(this.queries); // set options for the new observers to notify of changes
+        const prevObservers = this.#observers;
+        const newObserverMatches = this.#findMatchingObservers(this.#queries);
 
+        // set options for the new observers to notify of changes
         newObserverMatches.forEach(match => match.observer.setOptions(match.defaultedQueryOptions, notifyOptions));
         const newObservers = newObserverMatches.map(match => match.observer);
         const newObserversMap = Object.fromEntries(newObservers.map(observer => [observer.options.queryHash, observer]));
         const newResult = newObservers.map(observer => observer.getCurrentResult());
         const hasIndexChange = newObservers.some((observer, index) => observer !== prevObservers[index]);
-
         if (prevObservers.length === newObservers.length && !hasIndexChange) {
           return;
         }
-
-        this.observers = newObservers;
-        this.observersMap = newObserversMap;
-        this.result = newResult;
-
+        this.#observers = newObservers;
+        this.#observersMap = newObserversMap;
+        this.#result = newResult;
         if (!this.hasListeners()) {
           return;
         }
-
         difference(prevObservers, newObservers).forEach(observer => {
           observer.destroy();
         });
         difference(newObservers, prevObservers).forEach(observer => {
           observer.subscribe(result => {
-            this.onUpdate(observer, result);
+            this.#onUpdate(observer, result);
           });
         });
-        this.notify();
+        this.#notify();
       });
     }
-
     getCurrentResult() {
-      return this.result;
+      return this.#result;
     }
-
     getQueries() {
-      return this.observers.map(observer => observer.getCurrentQuery());
+      return this.#observers.map(observer => observer.getCurrentQuery());
     }
-
     getObservers() {
-      return this.observers;
+      return this.#observers;
     }
-
     getOptimisticResult(queries) {
-      return this.findMatchingObservers(queries).map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+      return this.#findMatchingObservers(queries).map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
     }
-
-    findMatchingObservers(queries) {
-      const prevObservers = this.observers;
-      const defaultedQueryOptions = queries.map(options => this.client.defaultQueryOptions(options));
+    #findMatchingObservers(queries) {
+      const prevObservers = this.#observers;
+      const defaultedQueryOptions = queries.map(options => this.#client.defaultQueryOptions(options));
       const matchingObservers = defaultedQueryOptions.flatMap(defaultedOptions => {
         const match = prevObservers.find(observer => observer.options.queryHash === defaultedOptions.queryHash);
-
         if (match != null) {
           return [{
             defaultedQueryOptions: defaultedOptions,
             observer: match
           }];
         }
-
         return [];
       });
       const matchedQueryHashes = matchingObservers.map(match => match.defaultedQueryOptions.queryHash);
       const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.includes(defaultedOptions.queryHash));
-      const unmatchedObservers = prevObservers.filter(prevObserver => !matchingObservers.some(match => match.observer === prevObserver));
-
       const getObserver = options => {
-        const defaultedOptions = this.client.defaultQueryOptions(options);
-        const currentObserver = this.observersMap[defaultedOptions.queryHash];
-        return currentObserver != null ? currentObserver : new QueryObserver(this.client, defaultedOptions);
+        const defaultedOptions = this.#client.defaultQueryOptions(options);
+        const currentObserver = this.#observersMap[defaultedOptions.queryHash];
+        return currentObserver ?? new QueryObserver(this.#client, defaultedOptions);
       };
-
-      const newOrReusedObservers = unmatchedQueries.map((options, index) => {
-        if (options.keepPreviousData) {
-          // return previous data from one of the observers that no longer match
-          const previouslyUsedObserver = unmatchedObservers[index];
-
-          if (previouslyUsedObserver !== undefined) {
-            return {
-              defaultedQueryOptions: options,
-              observer: previouslyUsedObserver
-            };
-          }
-        }
-
+      const newOrReusedObservers = unmatchedQueries.map(options => {
         return {
           defaultedQueryOptions: options,
           observer: getObserver(options)
         };
       });
-
       const sortMatchesByOrderOfQueries = (a, b) => defaultedQueryOptions.indexOf(a.defaultedQueryOptions) - defaultedQueryOptions.indexOf(b.defaultedQueryOptions);
-
       return matchingObservers.concat(newOrReusedObservers).sort(sortMatchesByOrderOfQueries);
     }
-
-    onUpdate(observer, result) {
-      const index = this.observers.indexOf(observer);
-
+    #onUpdate(observer, result) {
+      const index = this.#observers.indexOf(observer);
       if (index !== -1) {
-        this.result = replaceAt(this.result, index, result);
-        this.notify();
+        this.#result = replaceAt(this.#result, index, result);
+        this.#notify();
       }
     }
-
-    notify() {
+    #notify() {
       notifyManager.batch(() => {
         this.listeners.forEach(listener => {
-          listener(this.result);
+          listener(this.#result);
         });
       });
     }
-
   }
 
   class InfiniteQueryObserver extends QueryObserver {
     // Type override
+
     // Type override
+
     // Type override
+
     // eslint-disable-next-line @typescript-eslint/no-useless-constructor
     constructor(client, options) {
       super(client, options);
     }
-
     bindMethods() {
       super.bindMethods();
       this.fetchNextPage = this.fetchNextPage.bind(this);
       this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
     }
-
     setOptions(options, notifyOptions) {
-      super.setOptions({ ...options,
+      super.setOptions({
+        ...options,
         behavior: infiniteQueryBehavior()
       }, notifyOptions);
     }
-
     getOptimisticResult(options) {
       options.behavior = infiniteQueryBehavior();
       return super.getOptimisticResult(options);
     }
-
-    fetchNextPage({
-      pageParam,
-      ...options
-    } = {}) {
-      return this.fetch({ ...options,
+    fetchNextPage(options = {}) {
+      return this.fetch({
+        ...options,
         meta: {
           fetchMore: {
-            direction: 'forward',
-            pageParam
+            direction: 'forward'
           }
         }
       });
     }
-
     fetchPreviousPage({
-      pageParam,
       ...options
     } = {}) {
-      return this.fetch({ ...options,
+      return this.fetch({
+        ...options,
         meta: {
           fetchMore: {
-            direction: 'backward',
-            pageParam
+            direction: 'backward'
           }
         }
       });
     }
-
     createResult(query, options) {
-      var _state$fetchMeta, _state$fetchMeta$fetc, _state$fetchMeta2, _state$fetchMeta2$fet, _state$data, _state$data2;
-
       const {
         state
       } = query;
@@ -2961,153 +2463,126 @@
         isFetching,
         isRefetching
       } = result;
-      const isFetchingNextPage = isFetching && ((_state$fetchMeta = state.fetchMeta) == null ? void 0 : (_state$fetchMeta$fetc = _state$fetchMeta.fetchMore) == null ? void 0 : _state$fetchMeta$fetc.direction) === 'forward';
-      const isFetchingPreviousPage = isFetching && ((_state$fetchMeta2 = state.fetchMeta) == null ? void 0 : (_state$fetchMeta2$fet = _state$fetchMeta2.fetchMore) == null ? void 0 : _state$fetchMeta2$fet.direction) === 'backward';
-      return { ...result,
+      const isFetchingNextPage = isFetching && state.fetchMeta?.fetchMore?.direction === 'forward';
+      const isFetchingPreviousPage = isFetching && state.fetchMeta?.fetchMore?.direction === 'backward';
+      return {
+        ...result,
         fetchNextPage: this.fetchNextPage,
         fetchPreviousPage: this.fetchPreviousPage,
-        hasNextPage: hasNextPage(options, (_state$data = state.data) == null ? void 0 : _state$data.pages),
-        hasPreviousPage: hasPreviousPage(options, (_state$data2 = state.data) == null ? void 0 : _state$data2.pages),
+        hasNextPage: hasNextPage(options, state.data?.pages),
+        hasPreviousPage: hasPreviousPage(options, state.data?.pages),
         isFetchingNextPage,
         isFetchingPreviousPage,
         isRefetching: isRefetching && !isFetchingNextPage && !isFetchingPreviousPage
       };
     }
-
   }
 
+  // TYPES
+
   // CLASS
+
   class MutationObserver extends Subscribable {
+    #client;
+    #currentResult = undefined;
+    #currentMutation;
+    #mutateOptions;
     constructor(client, options) {
       super();
-      this.client = client;
+      this.#client = client;
       this.setOptions(options);
       this.bindMethods();
-      this.updateResult();
+      this.#updateResult();
     }
-
     bindMethods() {
       this.mutate = this.mutate.bind(this);
       this.reset = this.reset.bind(this);
     }
-
     setOptions(options) {
       const prevOptions = this.options;
-      this.options = this.client.defaultMutationOptions(options);
-
+      this.options = this.#client.defaultMutationOptions(options);
       if (!shallowEqualObjects(prevOptions, this.options)) {
-        this.client.getMutationCache().notify({
+        this.#client.getMutationCache().notify({
           type: 'observerOptionsUpdated',
-          mutation: this.currentMutation,
+          mutation: this.#currentMutation,
           observer: this
         });
       }
     }
-
     onUnsubscribe() {
       if (!this.listeners.length) {
-        var _this$currentMutation;
-
-        (_this$currentMutation = this.currentMutation) == null ? void 0 : _this$currentMutation.removeObserver(this);
+        this.#currentMutation?.removeObserver(this);
       }
     }
-
     onMutationUpdate(action) {
-      this.updateResult(); // Determine which callbacks to trigger
-
-      const notifyOptions = {
-        listeners: true
-      };
-
-      if (action.type === 'success') {
-        notifyOptions.onSuccess = true;
-      } else if (action.type === 'error') {
-        notifyOptions.onError = true;
-      }
-
-      this.notify(notifyOptions);
+      this.#updateResult();
+      this.#notify(action);
     }
-
     getCurrentResult() {
-      return this.currentResult;
+      return this.#currentResult;
     }
-
     reset() {
-      this.currentMutation = undefined;
-      this.updateResult();
-      this.notify({
-        listeners: true
-      });
+      this.#currentMutation = undefined;
+      this.#updateResult();
+      this.#notify();
     }
-
     mutate(variables, options) {
-      this.mutateOptions = options;
-
-      if (this.currentMutation) {
-        this.currentMutation.removeObserver(this);
-      }
-
-      this.currentMutation = this.client.getMutationCache().build(this.client, { ...this.options,
-        variables: typeof variables !== 'undefined' ? variables : this.options.variables
+      this.#mutateOptions = options;
+      this.#currentMutation?.removeObserver(this);
+      this.#currentMutation = this.#client.getMutationCache().build(this.#client, {
+        ...this.options
       });
-      this.currentMutation.addObserver(this);
-      return this.currentMutation.execute();
-    }
-
-    updateResult() {
-      const state = this.currentMutation ? this.currentMutation.state : getDefaultState();
-      const result = { ...state,
-        isLoading: state.status === 'loading',
+      this.#currentMutation.addObserver(this);
+      return this.#currentMutation.execute(variables);
+    }
+    #updateResult() {
+      const state = this.#currentMutation?.state ?? getDefaultState();
+      this.#currentResult = {
+        ...state,
+        isPending: state.status === 'pending',
         isSuccess: state.status === 'success',
         isError: state.status === 'error',
         isIdle: state.status === 'idle',
         mutate: this.mutate,
         reset: this.reset
       };
-      this.currentResult = result;
     }
-
-    notify(options) {
+    #notify(action) {
       notifyManager.batch(() => {
         // First trigger the mutate callbacks
-        if (this.mutateOptions && this.hasListeners()) {
-          if (options.onSuccess) {
-            var _this$mutateOptions$o, _this$mutateOptions, _this$mutateOptions$o2, _this$mutateOptions2;
-
-            (_this$mutateOptions$o = (_this$mutateOptions = this.mutateOptions).onSuccess) == null ? void 0 : _this$mutateOptions$o.call(_this$mutateOptions, this.currentResult.data, this.currentResult.variables, this.currentResult.context);
-            (_this$mutateOptions$o2 = (_this$mutateOptions2 = this.mutateOptions).onSettled) == null ? void 0 : _this$mutateOptions$o2.call(_this$mutateOptions2, this.currentResult.data, null, this.currentResult.variables, this.currentResult.context);
-          } else if (options.onError) {
-            var _this$mutateOptions$o3, _this$mutateOptions3, _this$mutateOptions$o4, _this$mutateOptions4;
-
-            (_this$mutateOptions$o3 = (_this$mutateOptions3 = this.mutateOptions).onError) == null ? void 0 : _this$mutateOptions$o3.call(_this$mutateOptions3, this.currentResult.error, this.currentResult.variables, this.currentResult.context);
-            (_this$mutateOptions$o4 = (_this$mutateOptions4 = this.mutateOptions).onSettled) == null ? void 0 : _this$mutateOptions$o4.call(_this$mutateOptions4, undefined, this.currentResult.error, this.currentResult.variables, this.currentResult.context);
+        if (this.#mutateOptions && this.hasListeners()) {
+          if (action?.type === 'success') {
+            this.#mutateOptions.onSuccess?.(action.data, this.#currentResult.variables, this.#currentResult.context);
+            this.#mutateOptions.onSettled?.(action.data, null, this.#currentResult.variables, this.#currentResult.context);
+          } else if (action?.type === 'error') {
+            this.#mutateOptions.onError?.(action.error, this.#currentResult.variables, this.#currentResult.context);
+            this.#mutateOptions.onSettled?.(undefined, action.error, this.#currentResult.variables, this.#currentResult.context);
           }
-        } // Then trigger the listeners
-
-
-        if (options.listeners) {
-          this.listeners.forEach(listener => {
-            listener(this.currentResult);
-          });
         }
+
+        // Then trigger the listeners
+        this.listeners.forEach(listener => {
+          listener(this.#currentResult);
+        });
       });
     }
-
   }
 
   // TYPES
+
   // FUNCTIONS
+
   function dehydrateMutation(mutation) {
     return {
       mutationKey: mutation.options.mutationKey,
       state: mutation.state
     };
-  } // Most config is not dehydrated but instead meant to configure again when
+  }
+
+  // Most config is not dehydrated but instead meant to configure again when
   // consuming the de/rehydrated data, typically with useQuery on the client.
   // Sometimes it might make sense to prefetch data on the server and include
   // in the html-payload, but not consume it on the initial render.
-
-
   function dehydrateQuery(query) {
     return {
       state: query.state,
@@ -3115,7 +2590,6 @@
       queryHash: query.queryHash
     };
   }
-
   function defaultShouldDehydrateMutation(mutation) {
     return mutation.state.isPaused;
   }
@@ -3125,7 +2599,6 @@
   function dehydrate(client, options = {}) {
     const mutations = [];
     const queries = [];
-
     if (options.dehydrateMutations !== false) {
       const shouldDehydrateMutation = options.shouldDehydrateMutation || defaultShouldDehydrateMutation;
       client.getMutationCache().getAll().forEach(mutation => {
@@ -3134,7 +2607,6 @@
         }
       });
     }
-
     if (options.dehydrateQueries !== false) {
       const shouldDehydrateQuery = options.shouldDehydrateQuery || defaultShouldDehydrateQuery;
       client.getQueryCache().getAll().forEach(query => {
@@ -3143,7 +2615,6 @@
         }
       });
     }
-
     return {
       mutations,
       queries
@@ -3153,344 +2624,60 @@
     if (typeof dehydratedState !== 'object' || dehydratedState === null) {
       return;
     }
-
     const mutationCache = client.getMutationCache();
-    const queryCache = client.getQueryCache(); // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-
-    const mutations = dehydratedState.mutations || []; // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    const queryCache = client.getQueryCache();
 
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    const mutations = dehydratedState.mutations || [];
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     const queries = dehydratedState.queries || [];
     mutations.forEach(dehydratedMutation => {
-      var _options$defaultOptio;
-
-      mutationCache.build(client, { ...(options == null ? void 0 : (_options$defaultOptio = options.defaultOptions) == null ? void 0 : _options$defaultOptio.mutations),
+      mutationCache.build(client, {
+        ...options?.defaultOptions?.mutations,
         mutationKey: dehydratedMutation.mutationKey
       }, dehydratedMutation.state);
     });
     queries.forEach(dehydratedQuery => {
-      var _options$defaultOptio2;
+      const query = queryCache.get(dehydratedQuery.queryHash);
 
-      const query = queryCache.get(dehydratedQuery.queryHash); // Do not hydrate if an existing query exists with newer data
+      // Reset fetch status to idle in the dehydrated state to avoid
+      // query being stuck in fetching state upon hydration
+      const dehydratedQueryState = {
+        ...dehydratedQuery.state,
+        fetchStatus: 'idle'
+      };
 
+      // Do not hydrate if an existing query exists with newer data
       if (query) {
-        if (query.state.dataUpdatedAt < dehydratedQuery.state.dataUpdatedAt) {
-          query.setState(dehydratedQuery.state);
+        if (query.state.dataUpdatedAt < dehydratedQueryState.dataUpdatedAt) {
+          query.setState(dehydratedQueryState);
         }
-
         return;
-      } // Restore query
-
+      }
 
-      queryCache.build(client, { ...(options == null ? void 0 : (_options$defaultOptio2 = options.defaultOptions) == null ? void 0 : _options$defaultOptio2.queries),
+      // Restore query
+      queryCache.build(client, {
+        ...options?.defaultOptions?.queries,
         queryKey: dehydratedQuery.queryKey,
         queryHash: dehydratedQuery.queryHash
-      }, dehydratedQuery.state);
+      }, dehydratedQueryState);
     });
   }
 
-  const unstable_batchedUpdates = ReactDOM__namespace.unstable_batchedUpdates;
-
-  notifyManager.setBatchNotifyFunction(unstable_batchedUpdates);
-
-  var shim = {exports: {}};
-
-  var useSyncExternalStoreShim_development = {};
-
-  /**
-   * @license React
-   * use-sync-external-store-shim.development.js
-   *
-   * Copyright (c) Facebook, Inc. and its affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   */
-
-  var hasRequiredUseSyncExternalStoreShim_development;
-
-  function requireUseSyncExternalStoreShim_development () {
-  	if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
-  	hasRequiredUseSyncExternalStoreShim_development = 1;
-
-  	{
-  	  (function() {
-
-  	/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-  	if (
-  	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-  	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
-  	    'function'
-  	) {
-  	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
-  	}
-  	          var React = React__default["default"];
-
-  	var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-
-  	function error(format) {
-  	  {
-  	    {
-  	      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-  	        args[_key2 - 1] = arguments[_key2];
-  	      }
-
-  	      printWarning('error', format, args);
-  	    }
-  	  }
-  	}
-
-  	function printWarning(level, format, args) {
-  	  // When changing this logic, you might want to also
-  	  // update consoleWithStackDev.www.js as well.
-  	  {
-  	    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-  	    var stack = ReactDebugCurrentFrame.getStackAddendum();
-
-  	    if (stack !== '') {
-  	      format += '%s';
-  	      args = args.concat([stack]);
-  	    } // eslint-disable-next-line react-internal/safe-string-coercion
-
-
-  	    var argsWithFormat = args.map(function (item) {
-  	      return String(item);
-  	    }); // Careful: RN currently depends on this prefix
-
-  	    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
-  	    // breaks IE9: https://github.com/facebook/react/issues/13610
-  	    // eslint-disable-next-line react-internal/no-production-logging
-
-  	    Function.prototype.apply.call(console[level], console, argsWithFormat);
-  	  }
-  	}
-
-  	/**
-  	 * inlined Object.is polyfill to avoid requiring consumers ship their own
-  	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
-  	 */
-  	function is(x, y) {
-  	  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
-  	  ;
-  	}
-
-  	var objectIs = typeof Object.is === 'function' ? Object.is : is;
-
-  	// dispatch for CommonJS interop named imports.
-
-  	var useState = React.useState,
-  	    useEffect = React.useEffect,
-  	    useLayoutEffect = React.useLayoutEffect,
-  	    useDebugValue = React.useDebugValue;
-  	var didWarnOld18Alpha = false;
-  	var didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
-  	// because of a very particular set of implementation details and assumptions
-  	// -- change any one of them and it will break. The most important assumption
-  	// is that updates are always synchronous, because concurrent rendering is
-  	// only available in versions of React that also have a built-in
-  	// useSyncExternalStore API. And we only use this shim when the built-in API
-  	// does not exist.
-  	//
-  	// Do not assume that the clever hacks used by this hook also work in general.
-  	// The point of this shim is to replace the need for hacks by other libraries.
-
-  	function useSyncExternalStore(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
-  	// React do not expose a way to check if we're hydrating. So users of the shim
-  	// will need to track that themselves and return the correct value
-  	// from `getSnapshot`.
-  	getServerSnapshot) {
-  	  {
-  	    if (!didWarnOld18Alpha) {
-  	      if (React.startTransition !== undefined) {
-  	        didWarnOld18Alpha = true;
-
-  	        error('You are using an outdated, pre-release alpha of React 18 that ' + 'does not support useSyncExternalStore. The ' + 'use-sync-external-store shim will not work correctly. Upgrade ' + 'to a newer pre-release.');
-  	      }
-  	    }
-  	  } // Read the current snapshot from the store on every render. Again, this
-  	  // breaks the rules of React, and only works here because of specific
-  	  // implementation details, most importantly that updates are
-  	  // always synchronous.
-
-
-  	  var value = getSnapshot();
-
-  	  {
-  	    if (!didWarnUncachedGetSnapshot) {
-  	      var cachedValue = getSnapshot();
-
-  	      if (!objectIs(value, cachedValue)) {
-  	        error('The result of getSnapshot should be cached to avoid an infinite loop');
-
-  	        didWarnUncachedGetSnapshot = true;
-  	      }
-  	    }
-  	  } // Because updates are synchronous, we don't queue them. Instead we force a
-  	  // re-render whenever the subscribed state changes by updating an some
-  	  // arbitrary useState hook. Then, during render, we call getSnapshot to read
-  	  // the current value.
-  	  //
-  	  // Because we don't actually use the state returned by the useState hook, we
-  	  // can save a bit of memory by storing other stuff in that slot.
-  	  //
-  	  // To implement the early bailout, we need to track some things on a mutable
-  	  // object. Usually, we would put that in a useRef hook, but we can stash it in
-  	  // our useState hook instead.
-  	  //
-  	  // To force a re-render, we call forceUpdate({inst}). That works because the
-  	  // new object always fails an equality check.
-
-
-  	  var _useState = useState({
-  	    inst: {
-  	      value: value,
-  	      getSnapshot: getSnapshot
-  	    }
-  	  }),
-  	      inst = _useState[0].inst,
-  	      forceUpdate = _useState[1]; // Track the latest getSnapshot function with a ref. This needs to be updated
-  	  // in the layout phase so we can access it during the tearing check that
-  	  // happens on subscribe.
-
-
-  	  useLayoutEffect(function () {
-  	    inst.value = value;
-  	    inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
-  	    // commit phase if there was an interleaved mutation. In concurrent mode
-  	    // this can happen all the time, but even in synchronous mode, an earlier
-  	    // effect may have mutated the store.
-
-  	    if (checkIfSnapshotChanged(inst)) {
-  	      // Force a re-render.
-  	      forceUpdate({
-  	        inst: inst
-  	      });
-  	    }
-  	  }, [subscribe, value, getSnapshot]);
-  	  useEffect(function () {
-  	    // Check for changes right before subscribing. Subsequent changes will be
-  	    // detected in the subscription handler.
-  	    if (checkIfSnapshotChanged(inst)) {
-  	      // Force a re-render.
-  	      forceUpdate({
-  	        inst: inst
-  	      });
-  	    }
-
-  	    var handleStoreChange = function () {
-  	      // TODO: Because there is no cross-renderer API for batching updates, it's
-  	      // up to the consumer of this library to wrap their subscription event
-  	      // with unstable_batchedUpdates. Should we try to detect when this isn't
-  	      // the case and print a warning in development?
-  	      // The store changed. Check if the snapshot changed since the last time we
-  	      // read from the store.
-  	      if (checkIfSnapshotChanged(inst)) {
-  	        // Force a re-render.
-  	        forceUpdate({
-  	          inst: inst
-  	        });
-  	      }
-  	    }; // Subscribe to the store and return a clean-up function.
-
-
-  	    return subscribe(handleStoreChange);
-  	  }, [subscribe]);
-  	  useDebugValue(value);
-  	  return value;
-  	}
-
-  	function checkIfSnapshotChanged(inst) {
-  	  var latestGetSnapshot = inst.getSnapshot;
-  	  var prevValue = inst.value;
-
-  	  try {
-  	    var nextValue = latestGetSnapshot();
-  	    return !objectIs(prevValue, nextValue);
-  	  } catch (error) {
-  	    return true;
-  	  }
-  	}
-
-  	function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
-  	  // Note: The shim does not use getServerSnapshot, because pre-18 versions of
-  	  // React do not expose a way to check if we're hydrating. So users of the shim
-  	  // will need to track that themselves and return the correct value
-  	  // from `getSnapshot`.
-  	  return getSnapshot();
-  	}
-
-  	var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
-
-  	var isServerEnvironment = !canUseDOM;
-
-  	var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
-  	var useSyncExternalStore$2 = React.useSyncExternalStore !== undefined ? React.useSyncExternalStore : shim;
-
-  	useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
-  	          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-  	if (
-  	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-  	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
-  	    'function'
-  	) {
-  	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
-  	}
-  	        
-  	  })();
-  	}
-  	return useSyncExternalStoreShim_development;
-  }
-
-  (function (module) {
-
-  	{
-  	  module.exports = requireUseSyncExternalStoreShim_development();
-  	}
-  } (shim));
-
-  // Temporary workaround due to an issue with react-native uSES - https://github.com/TanStack/query/pull/3601
-  const useSyncExternalStore = shim.exports.useSyncExternalStore;
-
-  const defaultContext = /*#__PURE__*/React__namespace.createContext(undefined);
-  const QueryClientSharingContext = /*#__PURE__*/React__namespace.createContext(false); // If we are given a context, we will use it.
-  // Otherwise, if contextSharing is on, we share the first and at least one
-  // instance of the context across the window
-  // to ensure that if React Query is used across
-  // different bundles or microfrontends they will
-  // all use the same **instance** of context, regardless
-  // of module scoping.
-
-  function getQueryClientContext(context, contextSharing) {
-    if (context) {
-      return context;
-    }
-
-    if (contextSharing && typeof window !== 'undefined') {
-      if (!window.ReactQueryClientContext) {
-        window.ReactQueryClientContext = defaultContext;
-      }
-
-      return window.ReactQueryClientContext;
-    }
-
-    return defaultContext;
-  }
-
-  const useQueryClient = ({
-    context
-  } = {}) => {
-    const queryClient = React__namespace.useContext(getQueryClientContext(context, React__namespace.useContext(QueryClientSharingContext)));
-
-    if (!queryClient) {
+  const QueryClientContext = /*#__PURE__*/React__namespace.createContext(undefined);
+  const useQueryClient = queryClient => {
+    const client = React__namespace.useContext(QueryClientContext);
+    if (queryClient) {
+      return queryClient;
+    }
+    if (!client) {
       throw new Error('No QueryClient set, use QueryClientProvider to set one');
     }
-
-    return queryClient;
+    return client;
   };
   const QueryClientProvider = ({
     client,
-    children,
-    context,
-    contextSharing = false
+    children
   }) => {
     React__namespace.useEffect(() => {
       client.mount();
@@ -3498,23 +2685,17 @@
         client.unmount();
       };
     }, [client]);
-
-    if (contextSharing) {
-      client.getLogger().error("The contextSharing option has been deprecated and will be removed in the next major version");
-    }
-
-    const Context = getQueryClientContext(context, contextSharing);
-    return /*#__PURE__*/React__namespace.createElement(QueryClientSharingContext.Provider, {
-      value: !context && contextSharing
-    }, /*#__PURE__*/React__namespace.createElement(Context.Provider, {
+    return /*#__PURE__*/React__namespace.createElement(QueryClientContext.Provider, {
       value: client
-    }, children));
+    }, children);
   };
 
   const IsRestoringContext = /*#__PURE__*/React__namespace.createContext(false);
   const useIsRestoring = () => React__namespace.useContext(IsRestoringContext);
   const IsRestoringProvider = IsRestoringContext.Provider;
 
+  // CONTEXT
+
   function createValue() {
     let isReset = false;
     return {
@@ -3529,10 +2710,13 @@
       }
     };
   }
+  const QueryErrorResetBoundaryContext = /*#__PURE__*/React__namespace.createContext(createValue());
 
-  const QueryErrorResetBoundaryContext = /*#__PURE__*/React__namespace.createContext(createValue()); // HOOK
+  // HOOK
 
-  const useQueryErrorResetBoundary = () => React__namespace.useContext(QueryErrorResetBoundaryContext); // COMPONENT
+  const useQueryErrorResetBoundary = () => React__namespace.useContext(QueryErrorResetBoundaryContext);
+
+  // COMPONENT
 
   const QueryErrorResetBoundary = ({
     children
@@ -3543,17 +2727,16 @@
     }, typeof children === 'function' ? children(value) : children);
   };
 
-  function shouldThrowError(_useErrorBoundary, params) {
-    // Allow useErrorBoundary function to override throwing behavior on a per-error basis
-    if (typeof _useErrorBoundary === 'function') {
-      return _useErrorBoundary(...params);
+  function shouldThrowError(throwError, params) {
+    // Allow throwError function to override throwing behavior on a per-error basis
+    if (typeof throwError === 'function') {
+      return throwError(...params);
     }
-
-    return !!_useErrorBoundary;
+    return !!throwError;
   }
 
   const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
-    if (options.suspense || options.useErrorBoundary) {
+    if (options.suspense || options.throwErrors) {
       // Prevent retrying failed query if the error boundary has not been reset yet
       if (!errorResetBoundary.isReset()) {
         options.retryOnMount = false;
@@ -3568,10 +2751,10 @@
   const getHasError = ({
     result,
     errorResetBoundary,
-    useErrorBoundary,
+    throwErrors,
     query
   }) => {
-    return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(useErrorBoundary, [result.error, query]);
+    return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(throwErrors, [result.error, query]);
   };
 
   const ensureStaleTime = defaultedOptions => {
@@ -3584,37 +2767,37 @@
     }
   };
   const willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
-  const shouldSuspend = (defaultedOptions, result, isRestoring) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && willFetch(result, isRestoring);
+  const shouldSuspend = (defaultedOptions, result, isRestoring) => defaultedOptions?.suspense && willFetch(result, isRestoring);
   const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).then(({
     data
   }) => {
-    defaultedOptions.onSuccess == null ? void 0 : defaultedOptions.onSuccess(data);
-    defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(data, null);
+    defaultedOptions.onSuccess?.(data);
+    defaultedOptions.onSettled?.(data, null);
   }).catch(error => {
     errorResetBoundary.clearReset();
-    defaultedOptions.onError == null ? void 0 : defaultedOptions.onError(error);
-    defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(undefined, error);
+    defaultedOptions.onError?.(error);
+    defaultedOptions.onSettled?.(undefined, error);
   });
 
-  // - `context` is omitted as it is passed as a root-level option to `useQueries` instead.
+  // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
+  // `placeholderData` function does not have a parameter
 
   function useQueries({
     queries,
-    context
+    queryClient
   }) {
-    const queryClient = useQueryClient({
-      context
-    });
+    const client = useQueryClient(queryClient);
     const isRestoring = useIsRestoring();
     const defaultedQueries = React__namespace.useMemo(() => queries.map(options => {
-      const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure the results are already in fetching state before subscribing or updating options
+      const defaultedOptions = client.defaultQueryOptions(options);
 
+      // Make sure the results are already in fetching state before subscribing or updating options
       defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
       return defaultedOptions;
-    }), [queries, queryClient, isRestoring]);
-    const [observer] = React__namespace.useState(() => new QueriesObserver(queryClient, defaultedQueries));
+    }), [queries, client, isRestoring]);
+    const [observer] = React__namespace.useState(() => new QueriesObserver(client, defaultedQueries));
     const optimisticResult = observer.getOptimisticResult(defaultedQueries);
-    useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+    React__namespace.useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
     React__namespace.useEffect(() => {
       // Do not notify on updates because of changes in the options because
       // these changes should already be reflected in the optimistic result.
@@ -3632,7 +2815,6 @@
     const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
       const options = defaultedQueries[index];
       const queryObserver = observer.getObservers()[index];
-
       if (options && queryObserver) {
         if (shouldSuspend(options, result, isRestoring)) {
           return fetchOptimistic(options, queryObserver, errorResetBoundary);
@@ -3640,167 +2822,172 @@
           void fetchOptimistic(options, queryObserver, errorResetBoundary);
         }
       }
-
       return [];
     }) : [];
-
     if (suspensePromises.length > 0) {
       throw Promise.all(suspensePromises);
     }
-
-    const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
-      var _defaultedQueries$ind, _defaultedQueries$ind2;
-
-      return getHasError({
-        result,
-        errorResetBoundary,
-        useErrorBoundary: (_defaultedQueries$ind = (_defaultedQueries$ind2 = defaultedQueries[index]) == null ? void 0 : _defaultedQueries$ind2.useErrorBoundary) != null ? _defaultedQueries$ind : false,
-        query: observer.getQueries()[index]
-      });
-    });
-
-    if (firstSingleResultWhichShouldThrow != null && firstSingleResultWhichShouldThrow.error) {
+    const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => getHasError({
+      result,
+      errorResetBoundary,
+      throwErrors: defaultedQueries[index]?.throwErrors ?? false,
+      query: observer.getQueries()[index]
+    }));
+    if (firstSingleResultWhichShouldThrow?.error) {
       throw firstSingleResultWhichShouldThrow.error;
     }
-
     return optimisticResult;
   }
 
-  function useBaseQuery(options, Observer) {
-    const queryClient = useQueryClient({
-      context: options.context
-    });
+  function useBaseQuery(options, Observer, queryClient) {
+    const client = useQueryClient(queryClient);
     const isRestoring = useIsRestoring();
     const errorResetBoundary = useQueryErrorResetBoundary();
-    const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options
+    const defaultedOptions = client.defaultQueryOptions(options);
 
-    defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic'; // Include callbacks in batch renders
+    // Make sure results are optimistically set in fetching state before subscribing or updating options
+    defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
 
+    // Include callbacks in batch renders
     if (defaultedOptions.onError) {
       defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);
     }
-
     if (defaultedOptions.onSuccess) {
       defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);
     }
-
     if (defaultedOptions.onSettled) {
       defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);
     }
-
     ensureStaleTime(defaultedOptions);
     ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
     useClearResetErrorBoundary(errorResetBoundary);
-    const [observer] = React__namespace.useState(() => new Observer(queryClient, defaultedOptions));
+    const [observer] = React__namespace.useState(() => new Observer(client, defaultedOptions));
     const result = observer.getOptimisticResult(defaultedOptions);
-    useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+    React__namespace.useSyncExternalStore(React__namespace.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
     React__namespace.useEffect(() => {
       // Do not notify on updates because of changes in the options because
       // these changes should already be reflected in the optimistic result.
       observer.setOptions(defaultedOptions, {
         listeners: false
       });
-    }, [defaultedOptions, observer]); // Handle suspense
+    }, [defaultedOptions, observer]);
 
+    // Handle suspense
     if (shouldSuspend(defaultedOptions, result, isRestoring)) {
       throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
-    } // Handle error boundary
-
+    }
 
+    // Handle error boundary
     if (getHasError({
       result,
       errorResetBoundary,
-      useErrorBoundary: defaultedOptions.useErrorBoundary,
+      throwErrors: defaultedOptions.throwErrors,
       query: observer.getCurrentQuery()
     })) {
       throw result.error;
-    } // Handle result property usage tracking
-
+    }
 
+    // Handle result property usage tracking
     return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
   }
 
-  function useQuery(arg1, arg2, arg3) {
-    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
-    return useBaseQuery(parsedOptions, QueryObserver);
+  // HOOK
+
+  function useQuery(options, queryClient) {
+    return useBaseQuery(options, QueryObserver, queryClient);
   }
 
-  function useHydrate(state, options = {}) {
-    const queryClient = useQueryClient({
-      context: options.context
-    });
+  const HydrationBoundary = ({
+    children,
+    options = {},
+    state,
+    queryClient
+  }) => {
+    const client = useQueryClient(queryClient);
     const optionsRef = React__namespace.useRef(options);
-    optionsRef.current = options; // Running hydrate again with the same queries is safe,
+    optionsRef.current = options;
+
+    // Running hydrate again with the same queries is safe,
     // it wont overwrite or initialize existing queries,
     // relying on useMemo here is only a performance optimization.
     // hydrate can and should be run *during* render here for SSR to work properly
-
     React__namespace.useMemo(() => {
       if (state) {
-        hydrate(queryClient, state, optionsRef.current);
+        hydrate(client, state, optionsRef.current);
       }
-    }, [queryClient, state]);
-  }
-  const Hydrate = ({
-    children,
-    options,
-    state
-  }) => {
-    useHydrate(state, options);
+    }, [client, state]);
     return children;
   };
 
-  function useIsFetching(arg1, arg2, arg3) {
-    const [filters, options = {}] = parseFilterArgs(arg1, arg2, arg3);
-    const queryClient = useQueryClient({
-      context: options.context
-    });
-    const queryCache = queryClient.getQueryCache();
-    return useSyncExternalStore(React__namespace.useCallback(onStoreChange => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)), [queryCache]), () => queryClient.isFetching(filters), () => queryClient.isFetching(filters));
+  function useIsFetching(filters, queryClient) {
+    const client = useQueryClient(queryClient);
+    const queryCache = client.getQueryCache();
+    return React__namespace.useSyncExternalStore(React__namespace.useCallback(onStoreChange => queryCache.subscribe(notifyManager.batchCalls(onStoreChange)), [queryCache]), () => client.isFetching(filters), () => client.isFetching(filters));
   }
 
-  function useIsMutating(arg1, arg2, arg3) {
-    const [filters, options = {}] = parseMutationFilterArgs(arg1, arg2, arg3);
-    const queryClient = useQueryClient({
-      context: options.context
+  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 = React__namespace.useRef(options);
+    const result = React__namespace.useRef();
+    if (!result.current) {
+      result.current = getResult(mutationCache, options);
+    }
+    React__namespace.useEffect(() => {
+      optionsRef.current = options;
     });
-    const mutationCache = queryClient.getMutationCache();
-    return useSyncExternalStore(React__namespace.useCallback(onStoreChange => mutationCache.subscribe(notifyManager.batchCalls(onStoreChange)), [mutationCache]), () => queryClient.isMutating(filters), () => queryClient.isMutating(filters));
+    return React__namespace.useSyncExternalStore(React__namespace.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);
   }
 
-  function useMutation(arg1, arg2, arg3) {
-    const options = parseMutationArgs(arg1, arg2, arg3);
-    const queryClient = useQueryClient({
-      context: options.context
-    });
-    const [observer] = React__namespace.useState(() => new MutationObserver(queryClient, options));
+  // HOOK
+
+  function useMutation(options, queryClient) {
+    const client = useQueryClient(queryClient);
+    const [observer] = React__namespace.useState(() => new MutationObserver(client, options));
     React__namespace.useEffect(() => {
       observer.setOptions(options);
     }, [observer, options]);
-    const result = useSyncExternalStore(React__namespace.useCallback(onStoreChange => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+    const result = React__namespace.useSyncExternalStore(React__namespace.useCallback(onStoreChange => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
     const mutate = React__namespace.useCallback((variables, mutateOptions) => {
       observer.mutate(variables, mutateOptions).catch(noop);
     }, [observer]);
-
-    if (result.error && shouldThrowError(observer.options.useErrorBoundary, [result.error])) {
+    if (result.error && shouldThrowError(observer.options.throwErrors, [result.error])) {
       throw result.error;
     }
-
-    return { ...result,
+    return {
+      ...result,
       mutate,
       mutateAsync: result.mutate
     };
-  } // eslint-disable-next-line @typescript-eslint/no-empty-function
+  }
 
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
   function noop() {}
 
-  function useInfiniteQuery(arg1, arg2, arg3) {
-    const options = parseQueryArgs(arg1, arg2, arg3);
-    return useBaseQuery(options, InfiniteQueryObserver);
+  // HOOK
+  function useInfiniteQuery(options, queryClient) {
+    return useBaseQuery(options, InfiniteQueryObserver, queryClient);
   }
 
   exports.CancelledError = CancelledError;
-  exports.Hydrate = Hydrate;
+  exports.HydrationBoundary = HydrationBoundary;
   exports.InfiniteQueryObserver = InfiniteQueryObserver;
   exports.IsRestoringProvider = IsRestoringProvider;
   exports.MutationCache = MutationCache;
@@ -3808,38 +2995,32 @@
   exports.QueriesObserver = QueriesObserver;
   exports.QueryCache = QueryCache;
   exports.QueryClient = QueryClient;
+  exports.QueryClientContext = QueryClientContext;
   exports.QueryClientProvider = QueryClientProvider;
   exports.QueryErrorResetBoundary = QueryErrorResetBoundary;
   exports.QueryObserver = QueryObserver;
-  exports.defaultContext = defaultContext;
   exports.defaultShouldDehydrateMutation = defaultShouldDehydrateMutation;
   exports.defaultShouldDehydrateQuery = defaultShouldDehydrateQuery;
   exports.dehydrate = dehydrate;
   exports.focusManager = focusManager;
-  exports.hashQueryKey = hashQueryKey;
+  exports.hashKey = hashKey;
   exports.hydrate = hydrate;
   exports.isCancelledError = isCancelledError;
-  exports.isError = isError;
   exports.isServer = isServer;
+  exports.keepPreviousData = keepPreviousData;
   exports.notifyManager = notifyManager;
   exports.onlineManager = onlineManager;
-  exports.parseFilterArgs = parseFilterArgs;
-  exports.parseMutationArgs = parseMutationArgs;
-  exports.parseMutationFilterArgs = parseMutationFilterArgs;
-  exports.parseQueryArgs = parseQueryArgs;
   exports.replaceEqualDeep = replaceEqualDeep;
-  exports.useHydrate = useHydrate;
   exports.useInfiniteQuery = useInfiniteQuery;
   exports.useIsFetching = useIsFetching;
   exports.useIsMutating = useIsMutating;
   exports.useIsRestoring = useIsRestoring;
   exports.useMutation = useMutation;
+  exports.useMutationState = useMutationState;
   exports.useQueries = useQueries;
   exports.useQuery = useQuery;
   exports.useQueryClient = useQueryClient;
   exports.useQueryErrorResetBoundary = useQueryErrorResetBoundary;
 
-  Object.defineProperty(exports, '__esModule', { value: true });
-
 }));
 //# sourceMappingURL=index.development.js.map