(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
  (global = global || self, factory(global.ReactQuery = {}, global.React));
}(this, (function (exports, React) { 'use strict';

  var React__default = 'default' in React ? React['default'] : React;

  function _inheritsLoose(subClass, superClass) {
    subClass.prototype = Object.create(superClass.prototype);
    subClass.prototype.constructor = subClass;
    subClass.__proto__ = superClass;
  }

  var Subscribable = /*#__PURE__*/function () {
    function Subscribable() {
      this.listeners = [];
    }

    var _proto = Subscribable.prototype;

    _proto.subscribe = function subscribe(listener) {
      var _this = this;

      var callback = listener || function () {
        return undefined;
      };

      this.listeners.push(callback);
      this.onSubscribe();
      return function () {
        _this.listeners = _this.listeners.filter(function (x) {
          return x !== callback;
        });

        _this.onUnsubscribe();
      };
    };

    _proto.hasListeners = function hasListeners() {
      return this.listeners.length > 0;
    };

    _proto.onSubscribe = function onSubscribe() {// Do nothing
    };

    _proto.onUnsubscribe = function onUnsubscribe() {// Do nothing
    };

    return Subscribable;
  }();

  function _extends() {
    _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };

    return _extends.apply(this, arguments);
  }

  // TYPES
  // UTILS
  var isServer = typeof window === 'undefined';
  function noop() {
    return undefined;
  }
  function functionalUpdate(updater, input) {
    return typeof updater === 'function' ? updater(input) : updater;
  }
  function isValidTimeout(value) {
    return typeof value === 'number' && value >= 0 && value !== Infinity;
  }
  function ensureQueryKeyArray(value) {
    return Array.isArray(value) ? value : [value];
  }
  function difference(array1, array2) {
    return array1.filter(function (x) {
      return array2.indexOf(x) === -1;
    });
  }
  function replaceAt(array, index, value) {
    var 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 _extends({}, arg3, {
        queryKey: arg1,
        queryFn: arg2
      });
    }

    return _extends({}, arg2, {
      queryKey: arg1
    });
  }
  function parseMutationArgs(arg1, arg2, arg3) {
    if (isQueryKey(arg1)) {
      if (typeof arg2 === 'function') {
        return _extends({}, arg3, {
          mutationKey: arg1,
          mutationFn: arg2
        });
      }

      return _extends({}, arg2, {
        mutationKey: arg1
      });
    }

    if (typeof arg1 === 'function') {
      return _extends({}, arg2, {
        mutationFn: arg1
      });
    }

    return _extends({}, arg1);
  }
  function parseFilterArgs(arg1, arg2, arg3) {
    return isQueryKey(arg1) ? [_extends({}, arg2, {
      queryKey: arg1
    }), arg3] : [arg1 || {}, arg2];
  }
  function parseMutationFilterArgs(arg1, arg2) {
    return isQueryKey(arg1) ? _extends({}, arg2, {
      mutationKey: arg1
    }) : arg1;
  }
  function mapQueryStatusFilter(active, inactive) {
    if (active === true && inactive === true || active == null && inactive == null) {
      return 'all';
    } else if (active === false && inactive === false) {
      return 'none';
    } else {
      // At this point, active|inactive can only be true|false or false|true
      // so, when only one value is provided, the missing one has to be the negated value
      var isActive = active != null ? active : !inactive;
      return isActive ? 'active' : 'inactive';
    }
  }
  function matchQuery(filters, query) {
    var active = filters.active,
        exact = filters.exact,
        fetching = filters.fetching,
        inactive = filters.inactive,
        predicate = filters.predicate,
        queryKey = filters.queryKey,
        stale = filters.stale;

    if (isQueryKey(queryKey)) {
      if (exact) {
        if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
          return false;
        }
      } else if (!partialMatchKey(query.queryKey, queryKey)) {
        return false;
      }
    }

    var queryStatusFilter = mapQueryStatusFilter(active, inactive);

    if (queryStatusFilter === 'none') {
      return false;
    } else if (queryStatusFilter !== 'all') {
      var isActive = query.isActive();

      if (queryStatusFilter === 'active' && !isActive) {
        return false;
      }

      if (queryStatusFilter === 'inactive' && isActive) {
        return false;
      }
    }

    if (typeof stale === 'boolean' && query.isStale() !== stale) {
      return false;
    }

    if (typeof fetching === 'boolean' && query.isFetching() !== fetching) {
      return false;
    }

    if (predicate && !predicate(query)) {
      return false;
    }

    return true;
  }
  function matchMutation(filters, mutation) {
    var exact = filters.exact,
        fetching = filters.fetching,
        predicate = filters.predicate,
        mutationKey = filters.mutationKey;

    if (isQueryKey(mutationKey)) {
      if (!mutation.options.mutationKey) {
        return false;
      }

      if (exact) {
        if (hashQueryKey(mutation.options.mutationKey) !== hashQueryKey(mutationKey)) {
          return false;
        }
      } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {
        return false;
      }
    }

    if (typeof fetching === 'boolean' && mutation.state.status === 'loading' !== fetching) {
      return false;
    }

    if (predicate && !predicate(mutation)) {
      return false;
    }

    return true;
  }
  function hashQueryKeyByOptions(queryKey, options) {
    var hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashQueryKey;
    return hashFn(queryKey);
  }
  /**
   * Default query keys hash function.
   */

  function hashQueryKey(queryKey) {
    var asArray = ensureQueryKeyArray(queryKey);
    return stableValueHash(asArray);
  }
  /**
   * Hashes the value into a stable hash.
   */

  function stableValueHash(value) {
    return JSON.stringify(value, function (_, val) {
      return isPlainObject(val) ? Object.keys(val).sort().reduce(function (result, key) {
        result[key] = val[key];
        return result;
      }, {}) : val;
    });
  }
  /**
   * Checks if key `b` partially matches with key `a`.
   */

  function partialMatchKey(a, b) {
    return partialDeepEqual(ensureQueryKeyArray(a), ensureQueryKeyArray(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(function (key) {
        return !partialDeepEqual(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`.
   * This can be used for structural sharing between JSON values for example.
   */

  function replaceEqualDeep(a, b) {
    if (a === b) {
      return a;
    }

    var array = Array.isArray(a) && Array.isArray(b);

    if (array || isPlainObject(a) && isPlainObject(b)) {
      var aSize = array ? a.length : Object.keys(a).length;
      var bItems = array ? b : Object.keys(b);
      var bSize = bItems.length;
      var copy = array ? [] : {};
      var equalItems = 0;

      for (var i = 0; i < bSize; i++) {
        var 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 (var key in a) {
      if (a[key] !== b[key]) {
        return false;
      }
    }

    return true;
  } // Copied from: https://github.com/jonschlinkert/is-plain-object

  function isPlainObject(o) {
    if (!hasObjectPrototype(o)) {
      return false;
    } // If has modified constructor


    var ctor = o.constructor;

    if (typeof ctor === 'undefined') {
      return true;
    } // If has modified prototype


    var prot = ctor.prototype;

    if (!hasObjectPrototype(prot)) {
      return false;
    } // If constructor does not have an Object-specific method


    if (!prot.hasOwnProperty('isPrototypeOf')) {
      return false;
    } // Most likely a plain Object


    return true;
  }

  function hasObjectPrototype(o) {
    return Object.prototype.toString.call(o) === '[object Object]';
  }

  function isQueryKey(value) {
    return typeof value === 'string' || Array.isArray(value);
  }
  function isError(value) {
    return value instanceof Error;
  }
  function sleep(timeout) {
    return new Promise(function (resolve) {
      setTimeout(resolve, timeout);
    });
  }
  /**
   * Schedules a microtask.
   * This can be useful to schedule state updates after rendering.
   */

  function scheduleMicrotask(callback) {
    Promise.resolve().then(callback).catch(function (error) {
      return setTimeout(function () {
        throw error;
      });
    });
  }
  function getAbortController() {
    if (typeof AbortController === 'function') {
      return new AbortController();
    }
  }

  var FocusManager = /*#__PURE__*/function (_Subscribable) {
    _inheritsLoose(FocusManager, _Subscribable);

    function FocusManager() {
      var _this;

      _this = _Subscribable.call(this) || this;

      _this.setup = function (onFocus) {
        var _window;

        if (!isServer && ((_window = window) == null ? void 0 : _window.addEventListener)) {
          var listener = function listener() {
            return onFocus();
          }; // Listen to visibillitychange and focus


          window.addEventListener('visibilitychange', listener, false);
          window.addEventListener('focus', listener, false);
          return function () {
            // Be sure to unsubscribe if a new handler is set
            window.removeEventListener('visibilitychange', listener);
            window.removeEventListener('focus', listener);
          };
        }
      };

      return _this;
    }

    var _proto = FocusManager.prototype;

    _proto.onSubscribe = function onSubscribe() {
      if (!this.cleanup) {
        this.setEventListener(this.setup);
      }
    };

    _proto.onUnsubscribe = function onUnsubscribe() {
      if (!this.hasListeners()) {
        var _this$cleanup;

        (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
        this.cleanup = undefined;
      }
    };

    _proto.setEventListener = function setEventListener(setup) {
      var _this$cleanup2,
          _this2 = this;

      this.setup = setup;
      (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
      this.cleanup = setup(function (focused) {
        if (typeof focused === 'boolean') {
          _this2.setFocused(focused);
        } else {
          _this2.onFocus();
        }
      });
    };

    _proto.setFocused = function setFocused(focused) {
      this.focused = focused;

      if (focused) {
        this.onFocus();
      }
    };

    _proto.onFocus = function onFocus() {
      this.listeners.forEach(function (listener) {
        listener();
      });
    };

    _proto.isFocused = function isFocused() {
      if (typeof this.focused === 'boolean') {
        return this.focused;
      } // document global can be unavailable in react native


      if (typeof document === 'undefined') {
        return true;
      }

      return [undefined, 'visible', 'prerender'].includes(document.visibilityState);
    };

    return FocusManager;
  }(Subscribable);
  var focusManager = new FocusManager();

  var OnlineManager = /*#__PURE__*/function (_Subscribable) {
    _inheritsLoose(OnlineManager, _Subscribable);

    function OnlineManager() {
      var _this;

      _this = _Subscribable.call(this) || this;

      _this.setup = function (onOnline) {
        var _window;

        if (!isServer && ((_window = window) == null ? void 0 : _window.addEventListener)) {
          var listener = function listener() {
            return onOnline();
          }; // Listen to online


          window.addEventListener('online', listener, false);
          window.addEventListener('offline', listener, false);
          return function () {
            // Be sure to unsubscribe if a new handler is set
            window.removeEventListener('online', listener);
            window.removeEventListener('offline', listener);
          };
        }
      };

      return _this;
    }

    var _proto = OnlineManager.prototype;

    _proto.onSubscribe = function onSubscribe() {
      if (!this.cleanup) {
        this.setEventListener(this.setup);
      }
    };

    _proto.onUnsubscribe = function onUnsubscribe() {
      if (!this.hasListeners()) {
        var _this$cleanup;

        (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
        this.cleanup = undefined;
      }
    };

    _proto.setEventListener = function setEventListener(setup) {
      var _this$cleanup2,
          _this2 = this;

      this.setup = setup;
      (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
      this.cleanup = setup(function (online) {
        if (typeof online === 'boolean') {
          _this2.setOnline(online);
        } else {
          _this2.onOnline();
        }
      });
    };

    _proto.setOnline = function setOnline(online) {
      this.online = online;

      if (online) {
        this.onOnline();
      }
    };

    _proto.onOnline = function onOnline() {
      this.listeners.forEach(function (listener) {
        listener();
      });
    };

    _proto.isOnline = function isOnline() {
      if (typeof this.online === 'boolean') {
        return this.online;
      }

      if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
        return true;
      }

      return navigator.onLine;
    };

    return OnlineManager;
  }(Subscribable);
  var onlineManager = new OnlineManager();

  function defaultRetryDelay(failureCount) {
    return Math.min(1000 * Math.pow(2, failureCount), 30000);
  }

  function isCancelable(value) {
    return typeof (value == null ? void 0 : value.cancel) === 'function';
  }
  var CancelledError = function CancelledError(options) {
    this.revert = options == null ? void 0 : options.revert;
    this.silent = options == null ? void 0 : options.silent;
  };
  function isCancelledError(value) {
    return value instanceof CancelledError;
  } // CLASS

  var Retryer = function Retryer(config) {
    var _this = this;

    var cancelRetry = false;
    var cancelFn;
    var continueFn;
    var promiseResolve;
    var promiseReject;
    this.abort = config.abort;

    this.cancel = function (cancelOptions) {
      return cancelFn == null ? void 0 : cancelFn(cancelOptions);
    };

    this.cancelRetry = function () {
      cancelRetry = true;
    };

    this.continueRetry = function () {
      cancelRetry = false;
    };

    this.continue = function () {
      return continueFn == null ? void 0 : continueFn();
    };

    this.failureCount = 0;
    this.isPaused = false;
    this.isResolved = false;
    this.isTransportCancelable = false;
    this.promise = new Promise(function (outerResolve, outerReject) {
      promiseResolve = outerResolve;
      promiseReject = outerReject;
    });

    var resolve = function resolve(value) {
      if (!_this.isResolved) {
        _this.isResolved = true;
        config.onSuccess == null ? void 0 : config.onSuccess(value);
        continueFn == null ? void 0 : continueFn();
        promiseResolve(value);
      }
    };

    var reject = function reject(value) {
      if (!_this.isResolved) {
        _this.isResolved = true;
        config.onError == null ? void 0 : config.onError(value);
        continueFn == null ? void 0 : continueFn();
        promiseReject(value);
      }
    };

    var pause = function pause() {
      return new Promise(function (continueResolve) {
        continueFn = continueResolve;
        _this.isPaused = true;
        config.onPause == null ? void 0 : config.onPause();
      }).then(function () {
        continueFn = undefined;
        _this.isPaused = false;
        config.onContinue == null ? void 0 : config.onContinue();
      });
    }; // Create loop function


    var run = function run() {
      // Do nothing if already resolved
      if (_this.isResolved) {
        return;
      }

      var promiseOrValue; // Execute query

      try {
        promiseOrValue = config.fn();
      } catch (error) {
        promiseOrValue = Promise.reject(error);
      } // Create callback to cancel this fetch


      cancelFn = function cancelFn(cancelOptions) {
        if (!_this.isResolved) {
          reject(new CancelledError(cancelOptions));
          _this.abort == null ? void 0 : _this.abort(); // Cancel transport if supported

          if (isCancelable(promiseOrValue)) {
            try {
              promiseOrValue.cancel();
            } catch (_unused) {}
          }
        }
      }; // Check if the transport layer support cancellation


      _this.isTransportCancelable = isCancelable(promiseOrValue);
      Promise.resolve(promiseOrValue).then(resolve).catch(function (error) {
        var _config$retry, _config$retryDelay;

        // Stop if the fetch is already resolved
        if (_this.isResolved) {
          return;
        } // Do we need to retry the request?


        var retry = (_config$retry = config.retry) != null ? _config$retry : 3;
        var retryDelay = (_config$retryDelay = config.retryDelay) != null ? _config$retryDelay : defaultRetryDelay;
        var delay = typeof retryDelay === 'function' ? retryDelay(_this.failureCount, error) : retryDelay;
        var shouldRetry = retry === true || typeof retry === 'number' && _this.failureCount < retry || typeof retry === 'function' && retry(_this.failureCount, error);

        if (cancelRetry || !shouldRetry) {
          // We are done if the query does not need to be retried
          reject(error);
          return;
        }

        _this.failureCount++; // Notify on fail

        config.onFail == null ? void 0 : config.onFail(_this.failureCount, error); // Delay

        sleep(delay) // Pause if the document is not visible or when the device is offline
        .then(function () {
          if (!focusManager.isFocused() || !onlineManager.isOnline()) {
            return pause();
          }
        }).then(function () {
          if (cancelRetry) {
            reject(error);
          } else {
            run();
          }
        });
      });
    }; // Start loop


    run();
  };

  // CLASS
  var NotifyManager = /*#__PURE__*/function () {
    function NotifyManager() {
      this.queue = [];
      this.transactions = 0;

      this.notifyFn = function (callback) {
        callback();
      };

      this.batchNotifyFn = function (callback) {
        callback();
      };
    }

    var _proto = NotifyManager.prototype;

    _proto.batch = function batch(callback) {
      var result;
      this.transactions++;

      try {
        result = callback();
      } finally {
        this.transactions--;

        if (!this.transactions) {
          this.flush();
        }
      }

      return result;
    };

    _proto.schedule = function schedule(callback) {
      var _this = this;

      if (this.transactions) {
        this.queue.push(callback);
      } else {
        scheduleMicrotask(function () {
          _this.notifyFn(callback);
        });
      }
    }
    /**
     * All calls to the wrapped function will be batched.
     */
    ;

    _proto.batchCalls = function batchCalls(callback) {
      var _this2 = this;

      return function () {
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this2.schedule(function () {
          callback.apply(void 0, args);
        });
      };
    };

    _proto.flush = function flush() {
      var _this3 = this;

      var queue = this.queue;
      this.queue = [];

      if (queue.length) {
        scheduleMicrotask(function () {
          _this3.batchNotifyFn(function () {
            queue.forEach(function (callback) {
              _this3.notifyFn(callback);
            });
          });
        });
      }
    }
    /**
     * Use this method to set a custom notify function.
     * This can be used to for example wrap notifications with `React.act` while running tests.
     */
    ;

    _proto.setNotifyFunction = function setNotifyFunction(fn) {
      this.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.
     */
    ;

    _proto.setBatchNotifyFunction = function setBatchNotifyFunction(fn) {
      this.batchNotifyFn = fn;
    };

    return NotifyManager;
  }(); // SINGLETON

  var notifyManager = new NotifyManager();

  // TYPES
  // FUNCTIONS
  var logger = console;
  function getLogger() {
    return logger;
  }
  function setLogger(newLogger) {
    logger = newLogger;
  }

  // CLASS
  var Query = /*#__PURE__*/function () {
    function Query(config) {
      this.abortSignalConsumed = false;
      this.hadObservers = 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 || this.getDefaultState(this.options);
      this.state = this.initialState;
      this.meta = config.meta;
      this.scheduleGc();
    }

    var _proto = Query.prototype;

    _proto.setOptions = function setOptions(options) {
      var _this$options$cacheTi;

      this.options = _extends({}, this.defaultOptions, options);
      this.meta = options == null ? void 0 : options.meta; // Default to 5 minutes if not cache time is set

      this.cacheTime = Math.max(this.cacheTime || 0, (_this$options$cacheTi = this.options.cacheTime) != null ? _this$options$cacheTi : 5 * 60 * 1000);
    };

    _proto.setDefaultOptions = function setDefaultOptions(options) {
      this.defaultOptions = options;
    };

    _proto.scheduleGc = function scheduleGc() {
      var _this = this;

      this.clearGcTimeout();

      if (isValidTimeout(this.cacheTime)) {
        this.gcTimeout = setTimeout(function () {
          _this.optionalRemove();
        }, this.cacheTime);
      }
    };

    _proto.clearGcTimeout = function clearGcTimeout() {
      if (this.gcTimeout) {
        clearTimeout(this.gcTimeout);
        this.gcTimeout = undefined;
      }
    };

    _proto.optionalRemove = function optionalRemove() {
      if (!this.observers.length) {
        if (this.state.isFetching) {
          if (this.hadObservers) {
            this.scheduleGc();
          }
        } else {
          this.cache.remove(this);
        }
      }
    };

    _proto.setData = function setData(updater, options) {
      var _this$options$isDataE, _this$options;

      var prevData = this.state.data; // Get the new data

      var data = functionalUpdate(updater, prevData); // Use prev data if an isDataEqual function is defined and returns `true`

      if ((_this$options$isDataE = (_this$options = this.options).isDataEqual) == null ? void 0 : _this$options$isDataE.call(_this$options, prevData, data)) {
        data = prevData;
      } else if (this.options.structuralSharing !== false) {
        // Structurally share data between prev and new data if needed
        data = replaceEqualDeep(prevData, data);
      } // Set data and mark it as cached


      this.dispatch({
        data: data,
        type: 'success',
        dataUpdatedAt: options == null ? void 0 : options.updatedAt
      });
      return data;
    };

    _proto.setState = function setState(state, setStateOptions) {
      this.dispatch({
        type: 'setState',
        state: state,
        setStateOptions: setStateOptions
      });
    };

    _proto.cancel = function cancel(options) {
      var _this$retryer;

      var promise = this.promise;
      (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.cancel(options);
      return promise ? promise.then(noop).catch(noop) : Promise.resolve();
    };

    _proto.destroy = function destroy() {
      this.clearGcTimeout();
      this.cancel({
        silent: true
      });
    };

    _proto.reset = function reset() {
      this.destroy();
      this.setState(this.initialState);
    };

    _proto.isActive = function isActive() {
      return this.observers.some(function (observer) {
        return observer.options.enabled !== false;
      });
    };

    _proto.isFetching = function isFetching() {
      return this.state.isFetching;
    };

    _proto.isStale = function isStale() {
      return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observers.some(function (observer) {
        return observer.getCurrentResult().isStale;
      });
    };

    _proto.isStaleByTime = function isStaleByTime(staleTime) {
      if (staleTime === void 0) {
        staleTime = 0;
      }

      return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
    };

    _proto.onFocus = function onFocus() {
      var _this$retryer2;

      var observer = this.observers.find(function (x) {
        return x.shouldFetchOnWindowFocus();
      });

      if (observer) {
        observer.refetch();
      } // Continue fetch if currently paused


      (_this$retryer2 = this.retryer) == null ? void 0 : _this$retryer2.continue();
    };

    _proto.onOnline = function onOnline() {
      var _this$retryer3;

      var observer = this.observers.find(function (x) {
        return x.shouldFetchOnReconnect();
      });

      if (observer) {
        observer.refetch();
      } // Continue fetch if currently paused


      (_this$retryer3 = this.retryer) == null ? void 0 : _this$retryer3.continue();
    };

    _proto.addObserver = function addObserver(observer) {
      if (this.observers.indexOf(observer) === -1) {
        this.observers.push(observer);
        this.hadObservers = true; // Stop the query from being garbage collected

        this.clearGcTimeout();
        this.cache.notify({
          type: 'observerAdded',
          query: this,
          observer: observer
        });
      }
    };

    _proto.removeObserver = function removeObserver(observer) {
      if (this.observers.indexOf(observer) !== -1) {
        this.observers = this.observers.filter(function (x) {
          return 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.retryer.isTransportCancelable || this.abortSignalConsumed) {
              this.retryer.cancel({
                revert: true
              });
            } else {
              this.retryer.cancelRetry();
            }
          }

          if (this.cacheTime) {
            this.scheduleGc();
          } else {
            this.cache.remove(this);
          }
        }

        this.cache.notify({
          type: 'observerRemoved',
          query: this,
          observer: observer
        });
      }
    };

    _proto.getObserversCount = function getObserversCount() {
      return this.observers.length;
    };

    _proto.invalidate = function invalidate() {
      if (!this.state.isInvalidated) {
        this.dispatch({
          type: 'invalidate'
        });
      }
    };

    _proto.fetch = function fetch(options, fetchOptions) {
      var _this2 = this,
          _this$options$behavio,
          _context$fetchOptions,
          _abortController$abor;

      if (this.state.isFetching) {
        if (this.state.dataUpdatedAt && (fetchOptions == null ? void 0 : fetchOptions.cancelRefetch)) {
          // Silently cancel current fetch if the user wants to cancel refetches
          this.cancel({
            silent: true
          });
        } else if (this.promise) {
          var _this$retryer4;

          // 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;
        }
      } // 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.


      if (!this.options.queryFn) {
        var observer = this.observers.find(function (x) {
          return x.options.queryFn;
        });

        if (observer) {
          this.setOptions(observer.options);
        }
      }

      var queryKey = ensureQueryKeyArray(this.queryKey);
      var abortController = getAbortController(); // Create query function context

      var queryFnContext = {
        queryKey: queryKey,
        pageParam: undefined,
        meta: this.meta
      };
      Object.defineProperty(queryFnContext, 'signal', {
        enumerable: true,
        get: function get() {
          if (abortController) {
            _this2.abortSignalConsumed = true;
            return abortController.signal;
          }

          return undefined;
        }
      }); // Create fetch function

      var fetchFn = function fetchFn() {
        if (!_this2.options.queryFn) {
          return Promise.reject('Missing queryFn');
        }

        _this2.abortSignalConsumed = false;
        return _this2.options.queryFn(queryFnContext);
      }; // Trigger behavior hook


      var context = {
        fetchOptions: fetchOptions,
        options: this.options,
        queryKey: queryKey,
        state: this.state,
        fetchFn: fetchFn,
        meta: this.meta
      };

      if ((_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch) {
        var _this$options$behavio2;

        (_this$options$behavio2 = this.options.behavior) == null ? void 0 : _this$options$behavio2.onFetch(context);
      } // Store state in case the current fetch needs to be reverted


      this.revertState = this.state; // Set to fetching state if not already in it

      if (!this.state.isFetching || this.state.fetchMeta !== ((_context$fetchOptions = context.fetchOptions) == null ? void 0 : _context$fetchOptions.meta)) {
        var _context$fetchOptions2;

        this.dispatch({
          type: 'fetch',
          meta: (_context$fetchOptions2 = context.fetchOptions) == null ? void 0 : _context$fetchOptions2.meta
        });
      } // Try to fetch the data


      this.retryer = new Retryer({
        fn: context.fetchFn,
        abort: abortController == null ? void 0 : (_abortController$abor = abortController.abort) == null ? void 0 : _abortController$abor.bind(abortController),
        onSuccess: function onSuccess(data) {
          _this2.setData(data); // Notify cache callback


          _this2.cache.config.onSuccess == null ? void 0 : _this2.cache.config.onSuccess(data, _this2); // Remove query after fetching if cache time is 0

          if (_this2.cacheTime === 0) {
            _this2.optionalRemove();
          }
        },
        onError: function onError(error) {
          // Optimistically update state if needed
          if (!(isCancelledError(error) && error.silent)) {
            _this2.dispatch({
              type: 'error',
              error: error
            });
          }

          if (!isCancelledError(error)) {
            // Notify cache callback
            _this2.cache.config.onError == null ? void 0 : _this2.cache.config.onError(error, _this2); // Log error

            getLogger().error(error);
          } // Remove query after fetching if cache time is 0


          if (_this2.cacheTime === 0) {
            _this2.optionalRemove();
          }
        },
        onFail: function onFail() {
          _this2.dispatch({
            type: 'failed'
          });
        },
        onPause: function onPause() {
          _this2.dispatch({
            type: 'pause'
          });
        },
        onContinue: function onContinue() {
          _this2.dispatch({
            type: 'continue'
          });
        },
        retry: context.options.retry,
        retryDelay: context.options.retryDelay
      });
      this.promise = this.retryer.promise;
      return this.promise;
    };

    _proto.dispatch = function dispatch(action) {
      var _this3 = this;

      this.state = this.reducer(this.state, action);
      notifyManager.batch(function () {
        _this3.observers.forEach(function (observer) {
          observer.onQueryUpdate(action);
        });

        _this3.cache.notify({
          query: _this3,
          type: 'queryUpdated',
          action: action
        });
      });
    };

    _proto.getDefaultState = function getDefaultState(options) {
      var data = typeof options.initialData === 'function' ? options.initialData() : options.initialData;
      var hasInitialData = typeof options.initialData !== 'undefined';
      var initialDataUpdatedAt = hasInitialData ? typeof options.initialDataUpdatedAt === 'function' ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
      var hasData = typeof data !== 'undefined';
      return {
        data: data,
        dataUpdateCount: 0,
        dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,
        error: null,
        errorUpdateCount: 0,
        errorUpdatedAt: 0,
        fetchFailureCount: 0,
        fetchMeta: null,
        isFetching: false,
        isInvalidated: false,
        isPaused: false,
        status: hasData ? 'success' : 'idle'
      };
    };

    _proto.reducer = function reducer(state, action) {
      var _action$meta, _action$dataUpdatedAt;

      switch (action.type) {
        case 'failed':
          return _extends({}, state, {
            fetchFailureCount: state.fetchFailureCount + 1
          });

        case 'pause':
          return _extends({}, state, {
            isPaused: true
          });

        case 'continue':
          return _extends({}, state, {
            isPaused: false
          });

        case 'fetch':
          return _extends({}, state, {
            fetchFailureCount: 0,
            fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,
            isFetching: true,
            isPaused: false
          }, !state.dataUpdatedAt && {
            error: null,
            status: 'loading'
          });

        case 'success':
          return _extends({}, state, {
            data: action.data,
            dataUpdateCount: state.dataUpdateCount + 1,
            dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),
            error: null,
            fetchFailureCount: 0,
            isFetching: false,
            isInvalidated: false,
            isPaused: false,
            status: 'success'
          });

        case 'error':
          var error = action.error;

          if (isCancelledError(error) && error.revert && this.revertState) {
            return _extends({}, this.revertState);
          }

          return _extends({}, state, {
            error: error,
            errorUpdateCount: state.errorUpdateCount + 1,
            errorUpdatedAt: Date.now(),
            fetchFailureCount: state.fetchFailureCount + 1,
            isFetching: false,
            isPaused: false,
            status: 'error'
          });

        case 'invalidate':
          return _extends({}, state, {
            isInvalidated: true
          });

        case 'setState':
          return _extends({}, state, action.state);

        default:
          return state;
      }
    };

    return Query;
  }();

  // CLASS
  var QueryCache = /*#__PURE__*/function (_Subscribable) {
    _inheritsLoose(QueryCache, _Subscribable);

    function QueryCache(config) {
      var _this;

      _this = _Subscribable.call(this) || this;
      _this.config = config || {};
      _this.queries = [];
      _this.queriesMap = {};
      return _this;
    }

    var _proto = QueryCache.prototype;

    _proto.build = function build(client, options, state) {
      var _options$queryHash;

      var queryKey = options.queryKey;
      var queryHash = (_options$queryHash = options.queryHash) != null ? _options$queryHash : hashQueryKeyByOptions(queryKey, options);
      var query = this.get(queryHash);

      if (!query) {
        query = new Query({
          cache: this,
          queryKey: queryKey,
          queryHash: queryHash,
          options: client.defaultQueryOptions(options),
          state: state,
          defaultOptions: client.getQueryDefaults(queryKey),
          meta: options.meta
        });
        this.add(query);
      }

      return query;
    };

    _proto.add = function add(query) {
      if (!this.queriesMap[query.queryHash]) {
        this.queriesMap[query.queryHash] = query;
        this.queries.push(query);
        this.notify({
          type: 'queryAdded',
          query: query
        });
      }
    };

    _proto.remove = function remove(query) {
      var queryInMap = this.queriesMap[query.queryHash];

      if (queryInMap) {
        query.destroy();
        this.queries = this.queries.filter(function (x) {
          return x !== query;
        });

        if (queryInMap === query) {
          delete this.queriesMap[query.queryHash];
        }

        this.notify({
          type: 'queryRemoved',
          query: query
        });
      }
    };

    _proto.clear = function clear() {
      var _this2 = this;

      notifyManager.batch(function () {
        _this2.queries.forEach(function (query) {
          _this2.remove(query);
        });
      });
    };

    _proto.get = function get(queryHash) {
      return this.queriesMap[queryHash];
    };

    _proto.getAll = function getAll() {
      return this.queries;
    };

    _proto.find = function find(arg1, arg2) {
      var _parseFilterArgs = parseFilterArgs(arg1, arg2),
          filters = _parseFilterArgs[0];

      if (typeof filters.exact === 'undefined') {
        filters.exact = true;
      }

      return this.queries.find(function (query) {
        return matchQuery(filters, query);
      });
    };

    _proto.findAll = function findAll(arg1, arg2) {
      var _parseFilterArgs2 = parseFilterArgs(arg1, arg2),
          filters = _parseFilterArgs2[0];

      return Object.keys(filters).length > 0 ? this.queries.filter(function (query) {
        return matchQuery(filters, query);
      }) : this.queries;
    };

    _proto.notify = function notify(event) {
      var _this3 = this;

      notifyManager.batch(function () {
        _this3.listeners.forEach(function (listener) {
          listener(event);
        });
      });
    };

    _proto.onFocus = function onFocus() {
      var _this4 = this;

      notifyManager.batch(function () {
        _this4.queries.forEach(function (query) {
          query.onFocus();
        });
      });
    };

    _proto.onOnline = function onOnline() {
      var _this5 = this;

      notifyManager.batch(function () {
        _this5.queries.forEach(function (query) {
          query.onOnline();
        });
      });
    };

    return QueryCache;
  }(Subscribable);

  // CLASS
  var Mutation = /*#__PURE__*/function () {
    function Mutation(config) {
      this.options = _extends({}, config.defaultOptions, config.options);
      this.mutationId = config.mutationId;
      this.mutationCache = config.mutationCache;
      this.observers = [];
      this.state = config.state || getDefaultState();
      this.meta = config.meta;
    }

    var _proto = Mutation.prototype;

    _proto.setState = function setState(state) {
      this.dispatch({
        type: 'setState',
        state: state
      });
    };

    _proto.addObserver = function addObserver(observer) {
      if (this.observers.indexOf(observer) === -1) {
        this.observers.push(observer);
      }
    };

    _proto.removeObserver = function removeObserver(observer) {
      this.observers = this.observers.filter(function (x) {
        return x !== observer;
      });
    };

    _proto.cancel = function cancel() {
      if (this.retryer) {
        this.retryer.cancel();
        return this.retryer.promise.then(noop).catch(noop);
      }

      return Promise.resolve();
    };

    _proto.continue = function _continue() {
      if (this.retryer) {
        this.retryer.continue();
        return this.retryer.promise;
      }

      return this.execute();
    };

    _proto.execute = function execute() {
      var _this = this;

      var data;
      var restored = this.state.status === 'loading';
      var promise = Promise.resolve();

      if (!restored) {
        this.dispatch({
          type: 'loading',
          variables: this.options.variables
        });
        promise = promise.then(function () {
          // Notify cache callback
          _this.mutationCache.config.onMutate == null ? void 0 : _this.mutationCache.config.onMutate(_this.state.variables, _this);
        }).then(function () {
          return _this.options.onMutate == null ? void 0 : _this.options.onMutate(_this.state.variables);
        }).then(function (context) {
          if (context !== _this.state.context) {
            _this.dispatch({
              type: 'loading',
              context: context,
              variables: _this.state.variables
            });
          }
        });
      }

      return promise.then(function () {
        return _this.executeMutation();
      }).then(function (result) {
        data = result; // Notify cache callback

        _this.mutationCache.config.onSuccess == null ? void 0 : _this.mutationCache.config.onSuccess(data, _this.state.variables, _this.state.context, _this);
      }).then(function () {
        return _this.options.onSuccess == null ? void 0 : _this.options.onSuccess(data, _this.state.variables, _this.state.context);
      }).then(function () {
        return _this.options.onSettled == null ? void 0 : _this.options.onSettled(data, null, _this.state.variables, _this.state.context);
      }).then(function () {
        _this.dispatch({
          type: 'success',
          data: data
        });

        return data;
      }).catch(function (error) {
        // Notify cache callback
        _this.mutationCache.config.onError == null ? void 0 : _this.mutationCache.config.onError(error, _this.state.variables, _this.state.context, _this); // Log error

        getLogger().error(error);
        return Promise.resolve().then(function () {
          return _this.options.onError == null ? void 0 : _this.options.onError(error, _this.state.variables, _this.state.context);
        }).then(function () {
          return _this.options.onSettled == null ? void 0 : _this.options.onSettled(undefined, error, _this.state.variables, _this.state.context);
        }).then(function () {
          _this.dispatch({
            type: 'error',
            error: error
          });

          throw error;
        });
      });
    };

    _proto.executeMutation = function executeMutation() {
      var _this2 = this,
          _this$options$retry;

      this.retryer = new Retryer({
        fn: function fn() {
          if (!_this2.options.mutationFn) {
            return Promise.reject('No mutationFn found');
          }

          return _this2.options.mutationFn(_this2.state.variables);
        },
        onFail: function onFail() {
          _this2.dispatch({
            type: 'failed'
          });
        },
        onPause: function onPause() {
          _this2.dispatch({
            type: 'pause'
          });
        },
        onContinue: function onContinue() {
          _this2.dispatch({
            type: 'continue'
          });
        },
        retry: (_this$options$retry = this.options.retry) != null ? _this$options$retry : 0,
        retryDelay: this.options.retryDelay
      });
      return this.retryer.promise;
    };

    _proto.dispatch = function dispatch(action) {
      var _this3 = this;

      this.state = reducer(this.state, action);
      notifyManager.batch(function () {
        _this3.observers.forEach(function (observer) {
          observer.onMutationUpdate(action);
        });

        _this3.mutationCache.notify(_this3);
      });
    };

    return Mutation;
  }();
  function getDefaultState() {
    return {
      context: undefined,
      data: undefined,
      error: null,
      failureCount: 0,
      isPaused: false,
      status: 'idle',
      variables: undefined
    };
  }

  function reducer(state, action) {
    switch (action.type) {
      case 'failed':
        return _extends({}, state, {
          failureCount: state.failureCount + 1
        });

      case 'pause':
        return _extends({}, state, {
          isPaused: true
        });

      case 'continue':
        return _extends({}, state, {
          isPaused: false
        });

      case 'loading':
        return _extends({}, state, {
          context: action.context,
          data: undefined,
          error: null,
          isPaused: false,
          status: 'loading',
          variables: action.variables
        });

      case 'success':
        return _extends({}, state, {
          data: action.data,
          error: null,
          status: 'success',
          isPaused: false
        });

      case 'error':
        return _extends({}, state, {
          data: undefined,
          error: action.error,
          failureCount: state.failureCount + 1,
          isPaused: false,
          status: 'error'
        });

      case 'setState':
        return _extends({}, state, action.state);

      default:
        return state;
    }
  }

  // CLASS
  var MutationCache = /*#__PURE__*/function (_Subscribable) {
    _inheritsLoose(MutationCache, _Subscribable);

    function MutationCache(config) {
      var _this;

      _this = _Subscribable.call(this) || this;
      _this.config = config || {};
      _this.mutations = [];
      _this.mutationId = 0;
      return _this;
    }

    var _proto = MutationCache.prototype;

    _proto.build = function build(client, options, state) {
      var mutation = new Mutation({
        mutationCache: this,
        mutationId: ++this.mutationId,
        options: client.defaultMutationOptions(options),
        state: state,
        defaultOptions: options.mutationKey ? client.getMutationDefaults(options.mutationKey) : undefined,
        meta: options.meta
      });
      this.add(mutation);
      return mutation;
    };

    _proto.add = function add(mutation) {
      this.mutations.push(mutation);
      this.notify(mutation);
    };

    _proto.remove = function remove(mutation) {
      this.mutations = this.mutations.filter(function (x) {
        return x !== mutation;
      });
      mutation.cancel();
      this.notify(mutation);
    };

    _proto.clear = function clear() {
      var _this2 = this;

      notifyManager.batch(function () {
        _this2.mutations.forEach(function (mutation) {
          _this2.remove(mutation);
        });
      });
    };

    _proto.getAll = function getAll() {
      return this.mutations;
    };

    _proto.find = function find(filters) {
      if (typeof filters.exact === 'undefined') {
        filters.exact = true;
      }

      return this.mutations.find(function (mutation) {
        return matchMutation(filters, mutation);
      });
    };

    _proto.findAll = function findAll(filters) {
      return this.mutations.filter(function (mutation) {
        return matchMutation(filters, mutation);
      });
    };

    _proto.notify = function notify(mutation) {
      var _this3 = this;

      notifyManager.batch(function () {
        _this3.listeners.forEach(function (listener) {
          listener(mutation);
        });
      });
    };

    _proto.onFocus = function onFocus() {
      this.resumePausedMutations();
    };

    _proto.onOnline = function onOnline() {
      this.resumePausedMutations();
    };

    _proto.resumePausedMutations = function resumePausedMutations() {
      var pausedMutations = this.mutations.filter(function (x) {
        return x.state.isPaused;
      });
      return notifyManager.batch(function () {
        return pausedMutations.reduce(function (promise, mutation) {
          return promise.then(function () {
            return mutation.continue().catch(noop);
          });
        }, Promise.resolve());
      });
    };

    return MutationCache;
  }(Subscribable);

  function infiniteQueryBehavior() {
    return {
      onFetch: function onFetch(context) {
        context.fetchFn = function () {
          var _context$fetchOptions, _context$fetchOptions2, _context$fetchOptions3, _context$fetchOptions4, _context$state$data, _context$state$data2;

          var refetchPage = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.refetchPage;
          var fetchMore = (_context$fetchOptions3 = context.fetchOptions) == null ? void 0 : (_context$fetchOptions4 = _context$fetchOptions3.meta) == null ? void 0 : _context$fetchOptions4.fetchMore;
          var pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;
          var isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'forward';
          var isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'backward';
          var oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) || [];
          var oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) || [];
          var abortController = getAbortController();
          var abortSignal = abortController == null ? void 0 : abortController.signal;
          var newPageParams = oldPageParams;
          var cancelled = false; // Get query function

          var queryFn = context.options.queryFn || function () {
            return Promise.reject('Missing queryFn');
          };

          var buildNewPages = function buildNewPages(pages, param, page, previous) {
            newPageParams = previous ? [param].concat(newPageParams) : [].concat(newPageParams, [param]);
            return previous ? [page].concat(pages) : [].concat(pages, [page]);
          }; // Create function to fetch a page


          var fetchPage = function fetchPage(pages, manual, param, previous) {
            if (cancelled) {
              return Promise.reject('Cancelled');
            }

            if (typeof param === 'undefined' && !manual && pages.length) {
              return Promise.resolve(pages);
            }

            var queryFnContext = {
              queryKey: context.queryKey,
              signal: abortSignal,
              pageParam: param,
              meta: context.meta
            };
            var queryFnResult = queryFn(queryFnContext);
            var promise = Promise.resolve(queryFnResult).then(function (page) {
              return buildNewPages(pages, param, page, previous);
            });

            if (isCancelable(queryFnResult)) {
              var promiseAsAny = promise;
              promiseAsAny.cancel = queryFnResult.cancel;
            }

            return promise;
          };

          var promise; // Fetch first page?

          if (!oldPages.length) {
            promise = fetchPage([]);
          } // Fetch next page?
          else if (isFetchingNextPage) {
              var manual = typeof pageParam !== 'undefined';
              var param = manual ? pageParam : getNextPageParam(context.options, oldPages);
              promise = fetchPage(oldPages, manual, param);
            } // Fetch previous page?
            else if (isFetchingPreviousPage) {
                var _manual = typeof pageParam !== 'undefined';

                var _param = _manual ? pageParam : getPreviousPageParam(context.options, oldPages);

                promise = fetchPage(oldPages, _manual, _param, true);
              } // Refetch pages
              else {
                  (function () {
                    newPageParams = [];
                    var manual = typeof context.options.getNextPageParam === 'undefined';
                    var 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

                    var _loop = function _loop(i) {
                      promise = promise.then(function (pages) {
                        var shouldFetchNextPage = refetchPage && oldPages[i] ? refetchPage(oldPages[i], i, oldPages) : true;

                        if (shouldFetchNextPage) {
                          var _param2 = manual ? oldPageParams[i] : getNextPageParam(context.options, pages);

                          return fetchPage(pages, manual, _param2);
                        }

                        return Promise.resolve(buildNewPages(pages, oldPageParams[i], oldPages[i]));
                      });
                    };

                    for (var i = 1; i < oldPages.length; i++) {
                      _loop(i);
                    }
                  })();
                }

          var finalPromise = promise.then(function (pages) {
            return {
              pages: pages,
              pageParams: newPageParams
            };
          });
          var finalPromiseAsAny = finalPromise;

          finalPromiseAsAny.cancel = function () {
            cancelled = true;
            abortController == null ? void 0 : abortController.abort();

            if (isCancelable(promise)) {
              promise.cancel();
            }
          };

          return finalPromise;
        };
      }
    };
  }
  function getNextPageParam(options, pages) {
    return options.getNextPageParam == null ? void 0 : options.getNextPageParam(pages[pages.length - 1], pages);
  }
  function getPreviousPageParam(options, pages) {
    return options.getPreviousPageParam == null ? void 0 : 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)) {
      var nextPageParam = getNextPageParam(options, pages);
      return typeof nextPageParam !== 'undefined' && nextPageParam !== null && nextPageParam !== false;
    }
  }
  /**
   * Checks if there is a previous page.
   * Returns `undefined` if it cannot be determined.
   */

  function hasPreviousPage(options, pages) {
    if (options.getPreviousPageParam && Array.isArray(pages)) {
      var previousPageParam = getPreviousPageParam(options, pages);
      return typeof previousPageParam !== 'undefined' && previousPageParam !== null && previousPageParam !== false;
    }
  }

  // CLASS
  var QueryClient = /*#__PURE__*/function () {
    function QueryClient(config) {
      if (config === void 0) {
        config = {};
      }

      this.queryCache = config.queryCache || new QueryCache();
      this.mutationCache = config.mutationCache || new MutationCache();
      this.defaultOptions = config.defaultOptions || {};
      this.queryDefaults = [];
      this.mutationDefaults = [];
    }

    var _proto = QueryClient.prototype;

    _proto.mount = function mount() {
      var _this = this;

      this.unsubscribeFocus = focusManager.subscribe(function () {
        if (focusManager.isFocused() && onlineManager.isOnline()) {
          _this.mutationCache.onFocus();

          _this.queryCache.onFocus();
        }
      });
      this.unsubscribeOnline = onlineManager.subscribe(function () {
        if (focusManager.isFocused() && onlineManager.isOnline()) {
          _this.mutationCache.onOnline();

          _this.queryCache.onOnline();
        }
      });
    };

    _proto.unmount = function unmount() {
      var _this$unsubscribeFocu, _this$unsubscribeOnli;

      (_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);
      (_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);
    };

    _proto.isFetching = function isFetching(arg1, arg2) {
      var _parseFilterArgs = parseFilterArgs(arg1, arg2),
          filters = _parseFilterArgs[0];

      filters.fetching = true;
      return this.queryCache.findAll(filters).length;
    };

    _proto.isMutating = function isMutating(filters) {
      return this.mutationCache.findAll(_extends({}, filters, {
        fetching: true
      })).length;
    };

    _proto.getQueryData = function getQueryData(queryKey, filters) {
      var _this$queryCache$find;

      return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;
    };

    _proto.getQueriesData = function getQueriesData(queryKeyOrFilters) {
      return this.getQueryCache().findAll(queryKeyOrFilters).map(function (_ref) {
        var queryKey = _ref.queryKey,
            state = _ref.state;
        var data = state.data;
        return [queryKey, data];
      });
    };

    _proto.setQueryData = function setQueryData(queryKey, updater, options) {
      var parsedOptions = parseQueryArgs(queryKey);
      var defaultedOptions = this.defaultQueryOptions(parsedOptions);
      return this.queryCache.build(this, defaultedOptions).setData(updater, options);
    };

    _proto.setQueriesData = function setQueriesData(queryKeyOrFilters, updater, options) {
      var _this2 = this;

      return notifyManager.batch(function () {
        return _this2.getQueryCache().findAll(queryKeyOrFilters).map(function (_ref2) {
          var queryKey = _ref2.queryKey;
          return [queryKey, _this2.setQueryData(queryKey, updater, options)];
        });
      });
    };

    _proto.getQueryState = function getQueryState(queryKey, filters) {
      var _this$queryCache$find2;

      return (_this$queryCache$find2 = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find2.state;
    };

    _proto.removeQueries = function removeQueries(arg1, arg2) {
      var _parseFilterArgs2 = parseFilterArgs(arg1, arg2),
          filters = _parseFilterArgs2[0];

      var queryCache = this.queryCache;
      notifyManager.batch(function () {
        queryCache.findAll(filters).forEach(function (query) {
          queryCache.remove(query);
        });
      });
    };

    _proto.resetQueries = function resetQueries(arg1, arg2, arg3) {
      var _this3 = this;

      var _parseFilterArgs3 = parseFilterArgs(arg1, arg2, arg3),
          filters = _parseFilterArgs3[0],
          options = _parseFilterArgs3[1];

      var queryCache = this.queryCache;

      var refetchFilters = _extends({}, filters, {
        active: true
      });

      return notifyManager.batch(function () {
        queryCache.findAll(filters).forEach(function (query) {
          query.reset();
        });
        return _this3.refetchQueries(refetchFilters, options);
      });
    };

    _proto.cancelQueries = function cancelQueries(arg1, arg2, arg3) {
      var _this4 = this;

      var _parseFilterArgs4 = parseFilterArgs(arg1, arg2, arg3),
          filters = _parseFilterArgs4[0],
          _parseFilterArgs4$ = _parseFilterArgs4[1],
          cancelOptions = _parseFilterArgs4$ === void 0 ? {} : _parseFilterArgs4$;

      if (typeof cancelOptions.revert === 'undefined') {
        cancelOptions.revert = true;
      }

      var promises = notifyManager.batch(function () {
        return _this4.queryCache.findAll(filters).map(function (query) {
          return query.cancel(cancelOptions);
        });
      });
      return Promise.all(promises).then(noop).catch(noop);
    };

    _proto.invalidateQueries = function invalidateQueries(arg1, arg2, arg3) {
      var _ref3,
          _filters$refetchActiv,
          _filters$refetchInact,
          _this5 = this;

      var _parseFilterArgs5 = parseFilterArgs(arg1, arg2, arg3),
          filters = _parseFilterArgs5[0],
          options = _parseFilterArgs5[1];

      var refetchFilters = _extends({}, filters, {
        // if filters.refetchActive is not provided and filters.active is explicitly false,
        // e.g. invalidateQueries({ active: false }), we don't want to refetch active queries
        active: (_ref3 = (_filters$refetchActiv = filters.refetchActive) != null ? _filters$refetchActiv : filters.active) != null ? _ref3 : true,
        inactive: (_filters$refetchInact = filters.refetchInactive) != null ? _filters$refetchInact : false
      });

      return notifyManager.batch(function () {
        _this5.queryCache.findAll(filters).forEach(function (query) {
          query.invalidate();
        });

        return _this5.refetchQueries(refetchFilters, options);
      });
    };

    _proto.refetchQueries = function refetchQueries(arg1, arg2, arg3) {
      var _this6 = this;

      var _parseFilterArgs6 = parseFilterArgs(arg1, arg2, arg3),
          filters = _parseFilterArgs6[0],
          options = _parseFilterArgs6[1];

      var promises = notifyManager.batch(function () {
        return _this6.queryCache.findAll(filters).map(function (query) {
          return query.fetch(undefined, _extends({}, options, {
            meta: {
              refetchPage: filters == null ? void 0 : filters.refetchPage
            }
          }));
        });
      });
      var promise = Promise.all(promises).then(noop);

      if (!(options == null ? void 0 : options.throwOnError)) {
        promise = promise.catch(noop);
      }

      return promise;
    };

    _proto.fetchQuery = function fetchQuery(arg1, arg2, arg3) {
      var parsedOptions = parseQueryArgs(arg1, arg2, arg3);
      var defaultedOptions = this.defaultQueryOptions(parsedOptions); // https://github.com/tannerlinsley/react-query/issues/652

      if (typeof defaultedOptions.retry === 'undefined') {
        defaultedOptions.retry = false;
      }

      var query = this.queryCache.build(this, defaultedOptions);
      return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
    };

    _proto.prefetchQuery = function prefetchQuery(arg1, arg2, arg3) {
      return this.fetchQuery(arg1, arg2, arg3).then(noop).catch(noop);
    };

    _proto.fetchInfiniteQuery = function fetchInfiniteQuery(arg1, arg2, arg3) {
      var parsedOptions = parseQueryArgs(arg1, arg2, arg3);
      parsedOptions.behavior = infiniteQueryBehavior();
      return this.fetchQuery(parsedOptions);
    };

    _proto.prefetchInfiniteQuery = function prefetchInfiniteQuery(arg1, arg2, arg3) {
      return this.fetchInfiniteQuery(arg1, arg2, arg3).then(noop).catch(noop);
    };

    _proto.cancelMutations = function cancelMutations() {
      var _this7 = this;

      var promises = notifyManager.batch(function () {
        return _this7.mutationCache.getAll().map(function (mutation) {
          return mutation.cancel();
        });
      });
      return Promise.all(promises).then(noop).catch(noop);
    };

    _proto.resumePausedMutations = function resumePausedMutations() {
      return this.getMutationCache().resumePausedMutations();
    };

    _proto.executeMutation = function executeMutation(options) {
      return this.mutationCache.build(this, options).execute();
    };

    _proto.getQueryCache = function getQueryCache() {
      return this.queryCache;
    };

    _proto.getMutationCache = function getMutationCache() {
      return this.mutationCache;
    };

    _proto.getDefaultOptions = function getDefaultOptions() {
      return this.defaultOptions;
    };

    _proto.setDefaultOptions = function setDefaultOptions(options) {
      this.defaultOptions = options;
    };

    _proto.setQueryDefaults = function setQueryDefaults(queryKey, options) {
      var result = this.queryDefaults.find(function (x) {
        return hashQueryKey(queryKey) === hashQueryKey(x.queryKey);
      });

      if (result) {
        result.defaultOptions = options;
      } else {
        this.queryDefaults.push({
          queryKey: queryKey,
          defaultOptions: options
        });
      }
    };

    _proto.getQueryDefaults = function getQueryDefaults(queryKey) {
      var _this$queryDefaults$f;

      return queryKey ? (_this$queryDefaults$f = this.queryDefaults.find(function (x) {
        return partialMatchKey(queryKey, x.queryKey);
      })) == null ? void 0 : _this$queryDefaults$f.defaultOptions : undefined;
    };

    _proto.setMutationDefaults = function setMutationDefaults(mutationKey, options) {
      var result = this.mutationDefaults.find(function (x) {
        return hashQueryKey(mutationKey) === hashQueryKey(x.mutationKey);
      });

      if (result) {
        result.defaultOptions = options;
      } else {
        this.mutationDefaults.push({
          mutationKey: mutationKey,
          defaultOptions: options
        });
      }
    };

    _proto.getMutationDefaults = function getMutationDefaults(mutationKey) {
      var _this$mutationDefault;

      return mutationKey ? (_this$mutationDefault = this.mutationDefaults.find(function (x) {
        return partialMatchKey(mutationKey, x.mutationKey);
      })) == null ? void 0 : _this$mutationDefault.defaultOptions : undefined;
    };

    _proto.defaultQueryOptions = function defaultQueryOptions(options) {
      if (options == null ? void 0 : options._defaulted) {
        return options;
      }

      var defaultedOptions = _extends({}, this.defaultOptions.queries, this.getQueryDefaults(options == null ? void 0 : options.queryKey), options, {
        _defaulted: true
      });

      if (!defaultedOptions.queryHash && defaultedOptions.queryKey) {
        defaultedOptions.queryHash = hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);
      }

      return defaultedOptions;
    };

    _proto.defaultQueryObserverOptions = function defaultQueryObserverOptions(options) {
      return this.defaultQueryOptions(options);
    };

    _proto.defaultMutationOptions = function defaultMutationOptions(options) {
      if (options == null ? void 0 : options._defaulted) {
        return options;
      }

      return _extends({}, this.defaultOptions.mutations, this.getMutationDefaults(options == null ? void 0 : options.mutationKey), options, {
        _defaulted: true
      });
    };

    _proto.clear = function clear() {
      this.queryCache.clear();
      this.mutationCache.clear();
    };

    return QueryClient;
  }();

  var QueryObserver = /*#__PURE__*/function (_Subscribable) {
    _inheritsLoose(QueryObserver, _Subscribable);

    function QueryObserver(client, options) {
      var _this;

      _this = _Subscribable.call(this) || this;
      _this.client = client;
      _this.options = options;
      _this.trackedProps = [];
      _this.selectError = null;

      _this.bindMethods();

      _this.setOptions(options);

      return _this;
    }

    var _proto = QueryObserver.prototype;

    _proto.bindMethods = function bindMethods() {
      this.remove = this.remove.bind(this);
      this.refetch = this.refetch.bind(this);
    };

    _proto.onSubscribe = function onSubscribe() {
      if (this.listeners.length === 1) {
        this.currentQuery.addObserver(this);

        if (shouldFetchOnMount(this.currentQuery, this.options)) {
          this.executeFetch();
        }

        this.updateTimers();
      }
    };

    _proto.onUnsubscribe = function onUnsubscribe() {
      if (!this.listeners.length) {
        this.destroy();
      }
    };

    _proto.shouldFetchOnReconnect = function shouldFetchOnReconnect() {
      return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnReconnect);
    };

    _proto.shouldFetchOnWindowFocus = function shouldFetchOnWindowFocus() {
      return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnWindowFocus);
    };

    _proto.destroy = function destroy() {
      this.listeners = [];
      this.clearTimers();
      this.currentQuery.removeObserver(this);
    };

    _proto.setOptions = function setOptions(options, notifyOptions) {
      var prevOptions = this.options;
      var prevQuery = this.currentQuery;
      this.options = this.client.defaultQueryObserverOptions(options);

      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


      if (!this.options.queryKey) {
        this.options.queryKey = prevOptions.queryKey;
      }

      this.updateQuery();
      var mounted = this.hasListeners(); // Fetch if there are subscribers

      if (mounted && shouldFetchOptionally(this.currentQuery, prevQuery, this.options, prevOptions)) {
        this.executeFetch();
      } // Update result


      this.updateResult(notifyOptions); // Update stale interval if needed

      if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {
        this.updateStaleTimeout();
      }

      var nextRefetchInterval = this.computeRefetchInterval(); // Update refetch interval if needed

      if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.currentRefetchInterval)) {
        this.updateRefetchInterval(nextRefetchInterval);
      }
    };

    _proto.getOptimisticResult = function getOptimisticResult(options) {
      var defaultedOptions = this.client.defaultQueryObserverOptions(options);
      var query = this.client.getQueryCache().build(this.client, defaultedOptions);
      return this.createResult(query, defaultedOptions);
    };

    _proto.getCurrentResult = function getCurrentResult() {
      return this.currentResult;
    };

    _proto.trackResult = function trackResult(result, defaultedOptions) {
      var _this2 = this;

      var trackedResult = {};

      var trackProp = function trackProp(key) {
        if (!_this2.trackedProps.includes(key)) {
          _this2.trackedProps.push(key);
        }
      };

      Object.keys(result).forEach(function (key) {
        Object.defineProperty(trackedResult, key, {
          configurable: false,
          enumerable: true,
          get: function get() {
            trackProp(key);
            return result[key];
          }
        });
      });

      if (defaultedOptions.useErrorBoundary || defaultedOptions.suspense) {
        trackProp('error');
      }

      return trackedResult;
    };

    _proto.getNextResult = function getNextResult(options) {
      var _this3 = this;

      return new Promise(function (resolve, reject) {
        var unsubscribe = _this3.subscribe(function (result) {
          if (!result.isFetching) {
            unsubscribe();

            if (result.isError && (options == null ? void 0 : options.throwOnError)) {
              reject(result.error);
            } else {
              resolve(result);
            }
          }
        });
      });
    };

    _proto.getCurrentQuery = function getCurrentQuery() {
      return this.currentQuery;
    };

    _proto.remove = function remove() {
      this.client.getQueryCache().remove(this.currentQuery);
    };

    _proto.refetch = function refetch(options) {
      return this.fetch(_extends({}, options, {
        meta: {
          refetchPage: options == null ? void 0 : options.refetchPage
        }
      }));
    };

    _proto.fetchOptimistic = function fetchOptimistic(options) {
      var _this4 = this;

      var defaultedOptions = this.client.defaultQueryObserverOptions(options);
      var query = this.client.getQueryCache().build(this.client, defaultedOptions);
      return query.fetch().then(function () {
        return _this4.createResult(query, defaultedOptions);
      });
    };

    _proto.fetch = function fetch(fetchOptions) {
      var _this5 = this;

      return this.executeFetch(fetchOptions).then(function () {
        _this5.updateResult();

        return _this5.currentResult;
      });
    };

    _proto.executeFetch = function executeFetch(fetchOptions) {
      // Make sure we reference the latest query as the current one might have been removed
      this.updateQuery(); // Fetch

      var promise = this.currentQuery.fetch(this.options, fetchOptions);

      if (!(fetchOptions == null ? void 0 : fetchOptions.throwOnError)) {
        promise = promise.catch(noop);
      }

      return promise;
    };

    _proto.updateStaleTimeout = function updateStaleTimeout() {
      var _this6 = this;

      this.clearStaleTimeout();

      if (isServer || this.currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
        return;
      }

      var time = timeUntilStale(this.currentResult.dataUpdatedAt, this.options.staleTime); // The timeout is sometimes triggered 1 ms before the stale time expiration.
      // To mitigate this issue we always add 1 ms to the timeout.

      var timeout = time + 1;
      this.staleTimeoutId = setTimeout(function () {
        if (!_this6.currentResult.isStale) {
          _this6.updateResult();
        }
      }, timeout);
    };

    _proto.computeRefetchInterval = function 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;
    };

    _proto.updateRefetchInterval = function updateRefetchInterval(nextInterval) {
      var _this7 = this;

      this.clearRefetchInterval();
      this.currentRefetchInterval = nextInterval;

      if (isServer || this.options.enabled === false || !isValidTimeout(this.currentRefetchInterval) || this.currentRefetchInterval === 0) {
        return;
      }

      this.refetchIntervalId = setInterval(function () {
        if (_this7.options.refetchIntervalInBackground || focusManager.isFocused()) {
          _this7.executeFetch();
        }
      }, this.currentRefetchInterval);
    };

    _proto.updateTimers = function updateTimers() {
      this.updateStaleTimeout();
      this.updateRefetchInterval(this.computeRefetchInterval());
    };

    _proto.clearTimers = function clearTimers() {
      this.clearStaleTimeout();
      this.clearRefetchInterval();
    };

    _proto.clearStaleTimeout = function clearStaleTimeout() {
      if (this.staleTimeoutId) {
        clearTimeout(this.staleTimeoutId);
        this.staleTimeoutId = undefined;
      }
    };

    _proto.clearRefetchInterval = function clearRefetchInterval() {
      if (this.refetchIntervalId) {
        clearInterval(this.refetchIntervalId);
        this.refetchIntervalId = undefined;
      }
    };

    _proto.createResult = function createResult(query, options) {
      var prevQuery = this.currentQuery;
      var prevOptions = this.options;
      var prevResult = this.currentResult;
      var prevResultState = this.currentResultState;
      var prevResultOptions = this.currentResultOptions;
      var queryChange = query !== prevQuery;
      var queryInitialState = queryChange ? query.state : this.currentQueryInitialState;
      var prevQueryResult = queryChange ? this.currentResult : this.previousQueryResult;
      var state = query.state;
      var dataUpdatedAt = state.dataUpdatedAt,
          error = state.error,
          errorUpdatedAt = state.errorUpdatedAt,
          isFetching = state.isFetching,
          status = state.status;
      var isPreviousData = false;
      var isPlaceholderData = false;
      var data; // Optimistically set result in fetching state if needed

      if (options.optimisticResults) {
        var mounted = this.hasListeners();
        var fetchOnMount = !mounted && shouldFetchOnMount(query, options);
        var fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);

        if (fetchOnMount || fetchOptionally) {
          isFetching = true;

          if (!dataUpdatedAt) {
            status = 'loading';
          }
        }
      } // Keep previous data if needed


      if (options.keepPreviousData && !state.dataUpdateCount && (prevQueryResult == null ? void 0 : 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') {
          // Memoize select result
          if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === this.selectFn) {
            data = this.selectResult;
          } else {
            try {
              this.selectFn = options.select;
              data = options.select(state.data);

              if (options.structuralSharing !== false) {
                data = replaceEqualDeep(prevResult == null ? void 0 : prevResult.data, data);
              }

              this.selectResult = data;
              this.selectError = null;
            } catch (selectError) {
              getLogger().error(selectError);
              this.selectError = selectError;
            }
          }
        } // Use query data
        else {
            data = state.data;
          } // Show placeholder data if needed


      if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && (status === 'loading' || status === 'idle')) {
        var placeholderData; // Memoize placeholder data

        if ((prevResult == null ? void 0 : prevResult.isPlaceholderData) && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {
          placeholderData = prevResult.data;
        } else {
          placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData() : options.placeholderData;

          if (options.select && typeof placeholderData !== 'undefined') {
            try {
              placeholderData = options.select(placeholderData);

              if (options.structuralSharing !== false) {
                placeholderData = replaceEqualDeep(prevResult == null ? void 0 : prevResult.data, placeholderData);
              }

              this.selectError = null;
            } catch (selectError) {
              getLogger().error(selectError);
              this.selectError = selectError;
            }
          }
        }

        if (typeof placeholderData !== 'undefined') {
          status = 'success';
          data = placeholderData;
          isPlaceholderData = true;
        }
      }

      if (this.selectError) {
        error = this.selectError;
        data = this.selectResult;
        errorUpdatedAt = Date.now();
        status = 'error';
      }

      var result = {
        status: status,
        isLoading: status === 'loading',
        isSuccess: status === 'success',
        isError: status === 'error',
        isIdle: status === 'idle',
        data: data,
        dataUpdatedAt: dataUpdatedAt,
        error: error,
        errorUpdatedAt: errorUpdatedAt,
        failureCount: state.fetchFailureCount,
        errorUpdateCount: state.errorUpdateCount,
        isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
        isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,
        isFetching: isFetching,
        isRefetching: isFetching && status !== 'loading',
        isLoadingError: status === 'error' && state.dataUpdatedAt === 0,
        isPlaceholderData: isPlaceholderData,
        isPreviousData: isPreviousData,
        isRefetchError: status === 'error' && state.dataUpdatedAt !== 0,
        isStale: isStale(query, options),
        refetch: this.refetch,
        remove: this.remove
      };
      return result;
    };

    _proto.shouldNotifyListeners = function shouldNotifyListeners(result, prevResult) {
      if (!prevResult) {
        return true;
      }

      var _this$options = this.options,
          notifyOnChangeProps = _this$options.notifyOnChangeProps,
          notifyOnChangePropsExclusions = _this$options.notifyOnChangePropsExclusions;

      if (!notifyOnChangeProps && !notifyOnChangePropsExclusions) {
        return true;
      }

      if (notifyOnChangeProps === 'tracked' && !this.trackedProps.length) {
        return true;
      }

      var includedProps = notifyOnChangeProps === 'tracked' ? this.trackedProps : notifyOnChangeProps;
      return Object.keys(result).some(function (key) {
        var typedKey = key;
        var changed = result[typedKey] !== prevResult[typedKey];
        var isIncluded = includedProps == null ? void 0 : includedProps.some(function (x) {
          return x === key;
        });
        var isExcluded = notifyOnChangePropsExclusions == null ? void 0 : notifyOnChangePropsExclusions.some(function (x) {
          return x === key;
        });
        return changed && !isExcluded && (!includedProps || isIncluded);
      });
    };

    _proto.updateResult = function updateResult(notifyOptions) {
      var prevResult = this.currentResult;
      this.currentResult = this.createResult(this.currentQuery, this.options);
      this.currentResultState = this.currentQuery.state;
      this.currentResultOptions = this.options; // Only notify if something has changed

      if (shallowEqualObjects(this.currentResult, prevResult)) {
        return;
      } // Determine which callbacks to trigger


      var defaultNotifyOptions = {
        cache: true
      };

      if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && this.shouldNotifyListeners(this.currentResult, prevResult)) {
        defaultNotifyOptions.listeners = true;
      }

      this.notify(_extends({}, defaultNotifyOptions, notifyOptions));
    };

    _proto.updateQuery = function updateQuery() {
      var query = this.client.getQueryCache().build(this.client, this.options);

      if (query === this.currentQuery) {
        return;
      }

      var prevQuery = this.currentQuery;
      this.currentQuery = query;
      this.currentQueryInitialState = query.state;
      this.previousQueryResult = this.currentResult;

      if (this.hasListeners()) {
        prevQuery == null ? void 0 : prevQuery.removeObserver(this);
        query.addObserver(this);
      }
    };

    _proto.onQueryUpdate = function onQueryUpdate(action) {
      var notifyOptions = {};

      if (action.type === 'success') {
        notifyOptions.onSuccess = true;
      } else if (action.type === 'error' && !isCancelledError(action.error)) {
        notifyOptions.onError = true;
      }

      this.updateResult(notifyOptions);

      if (this.hasListeners()) {
        this.updateTimers();
      }
    };

    _proto.notify = function notify(notifyOptions) {
      var _this8 = this;

      notifyManager.batch(function () {
        // First trigger the configuration callbacks
        if (notifyOptions.onSuccess) {
          _this8.options.onSuccess == null ? void 0 : _this8.options.onSuccess(_this8.currentResult.data);
          _this8.options.onSettled == null ? void 0 : _this8.options.onSettled(_this8.currentResult.data, null);
        } else if (notifyOptions.onError) {
          _this8.options.onError == null ? void 0 : _this8.options.onError(_this8.currentResult.error);
          _this8.options.onSettled == null ? void 0 : _this8.options.onSettled(undefined, _this8.currentResult.error);
        } // Then trigger the listeners


        if (notifyOptions.listeners) {
          _this8.listeners.forEach(function (listener) {
            listener(_this8.currentResult);
          });
        } // Then the cache listeners


        if (notifyOptions.cache) {
          _this8.client.getQueryCache().notify({
            query: _this8.currentQuery,
            type: 'observerResultsUpdated'
          });
        }
      });
    };

    return QueryObserver;
  }(Subscribable);

  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) {
      var 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);
  }

  var QueriesObserver = /*#__PURE__*/function (_Subscribable) {
    _inheritsLoose(QueriesObserver, _Subscribable);

    function QueriesObserver(client, queries) {
      var _this;

      _this = _Subscribable.call(this) || this;
      _this.client = client;
      _this.queries = [];
      _this.result = [];
      _this.observers = [];
      _this.observersMap = {};

      if (queries) {
        _this.setQueries(queries);
      }

      return _this;
    }

    var _proto = QueriesObserver.prototype;

    _proto.onSubscribe = function onSubscribe() {
      var _this2 = this;

      if (this.listeners.length === 1) {
        this.observers.forEach(function (observer) {
          observer.subscribe(function (result) {
            _this2.onUpdate(observer, result);
          });
        });
      }
    };

    _proto.onUnsubscribe = function onUnsubscribe() {
      if (!this.listeners.length) {
        this.destroy();
      }
    };

    _proto.destroy = function destroy() {
      this.listeners = [];
      this.observers.forEach(function (observer) {
        observer.destroy();
      });
    };

    _proto.setQueries = function setQueries(queries, notifyOptions) {
      this.queries = queries;
      this.updateObservers(notifyOptions);
    };

    _proto.getCurrentResult = function getCurrentResult() {
      return this.result;
    };

    _proto.getOptimisticResult = function getOptimisticResult(queries) {
      return this.findMatchingObservers(queries).map(function (match) {
        return match.observer.getOptimisticResult(match.defaultedQueryOptions);
      });
    };

    _proto.findMatchingObservers = function findMatchingObservers(queries) {
      var _this3 = this;

      var prevObservers = this.observers;
      var defaultedQueryOptions = queries.map(function (options) {
        return _this3.client.defaultQueryObserverOptions(options);
      });
      var matchingObservers = defaultedQueryOptions.flatMap(function (defaultedOptions) {
        var match = prevObservers.find(function (observer) {
          return observer.options.queryHash === defaultedOptions.queryHash;
        });

        if (match != null) {
          return [{
            defaultedQueryOptions: defaultedOptions,
            observer: match
          }];
        }

        return [];
      });
      var matchedQueryHashes = matchingObservers.map(function (match) {
        return match.defaultedQueryOptions.queryHash;
      });
      var unmatchedQueries = defaultedQueryOptions.filter(function (defaultedOptions) {
        return !matchedQueryHashes.includes(defaultedOptions.queryHash);
      });
      var unmatchedObservers = prevObservers.filter(function (prevObserver) {
        return !matchingObservers.some(function (match) {
          return match.observer === prevObserver;
        });
      });
      var newOrReusedObservers = unmatchedQueries.map(function (options, index) {
        if (options.keepPreviousData) {
          // return previous data from one of the observers that no longer match
          var previouslyUsedObserver = unmatchedObservers[index];

          if (previouslyUsedObserver !== undefined) {
            return {
              defaultedQueryOptions: options,
              observer: previouslyUsedObserver
            };
          }
        }

        return {
          defaultedQueryOptions: options,
          observer: _this3.getObserver(options)
        };
      });

      var sortMatchesByOrderOfQueries = function sortMatchesByOrderOfQueries(a, b) {
        return defaultedQueryOptions.indexOf(a.defaultedQueryOptions) - defaultedQueryOptions.indexOf(b.defaultedQueryOptions);
      };

      return matchingObservers.concat(newOrReusedObservers).sort(sortMatchesByOrderOfQueries);
    };

    _proto.getObserver = function getObserver(options) {
      var defaultedOptions = this.client.defaultQueryObserverOptions(options);
      var currentObserver = this.observersMap[defaultedOptions.queryHash];
      return currentObserver != null ? currentObserver : new QueryObserver(this.client, defaultedOptions);
    };

    _proto.updateObservers = function updateObservers(notifyOptions) {
      var _this4 = this;

      notifyManager.batch(function () {
        var prevObservers = _this4.observers;

        var newObserverMatches = _this4.findMatchingObservers(_this4.queries); // set options for the new observers to notify of changes


        newObserverMatches.forEach(function (match) {
          return match.observer.setOptions(match.defaultedQueryOptions, notifyOptions);
        });
        var newObservers = newObserverMatches.map(function (match) {
          return match.observer;
        });
        var newObserversMap = Object.fromEntries(newObservers.map(function (observer) {
          return [observer.options.queryHash, observer];
        }));
        var newResult = newObservers.map(function (observer) {
          return observer.getCurrentResult();
        });
        var hasIndexChange = newObservers.some(function (observer, index) {
          return observer !== prevObservers[index];
        });

        if (prevObservers.length === newObservers.length && !hasIndexChange) {
          return;
        }

        _this4.observers = newObservers;
        _this4.observersMap = newObserversMap;
        _this4.result = newResult;

        if (!_this4.hasListeners()) {
          return;
        }

        difference(prevObservers, newObservers).forEach(function (observer) {
          observer.destroy();
        });
        difference(newObservers, prevObservers).forEach(function (observer) {
          observer.subscribe(function (result) {
            _this4.onUpdate(observer, result);
          });
        });

        _this4.notify();
      });
    };

    _proto.onUpdate = function onUpdate(observer, result) {
      var index = this.observers.indexOf(observer);

      if (index !== -1) {
        this.result = replaceAt(this.result, index, result);
        this.notify();
      }
    };

    _proto.notify = function notify() {
      var _this5 = this;

      notifyManager.batch(function () {
        _this5.listeners.forEach(function (listener) {
          listener(_this5.result);
        });
      });
    };

    return QueriesObserver;
  }(Subscribable);

  var InfiniteQueryObserver = /*#__PURE__*/function (_QueryObserver) {
    _inheritsLoose(InfiniteQueryObserver, _QueryObserver);

    // Type override
    // Type override
    // Type override
    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
    function InfiniteQueryObserver(client, options) {
      return _QueryObserver.call(this, client, options) || this;
    }

    var _proto = InfiniteQueryObserver.prototype;

    _proto.bindMethods = function bindMethods() {
      _QueryObserver.prototype.bindMethods.call(this);

      this.fetchNextPage = this.fetchNextPage.bind(this);
      this.fetchPreviousPage = this.fetchPreviousPage.bind(this);
    };

    _proto.setOptions = function setOptions(options, notifyOptions) {
      _QueryObserver.prototype.setOptions.call(this, _extends({}, options, {
        behavior: infiniteQueryBehavior()
      }), notifyOptions);
    };

    _proto.getOptimisticResult = function getOptimisticResult(options) {
      options.behavior = infiniteQueryBehavior();
      return _QueryObserver.prototype.getOptimisticResult.call(this, options);
    };

    _proto.fetchNextPage = function fetchNextPage(options) {
      var _options$cancelRefetc;

      return this.fetch({
        // TODO consider removing `?? true` in future breaking change, to be consistent with `refetch` API (see https://github.com/tannerlinsley/react-query/issues/2617)
        cancelRefetch: (_options$cancelRefetc = options == null ? void 0 : options.cancelRefetch) != null ? _options$cancelRefetc : true,
        throwOnError: options == null ? void 0 : options.throwOnError,
        meta: {
          fetchMore: {
            direction: 'forward',
            pageParam: options == null ? void 0 : options.pageParam
          }
        }
      });
    };

    _proto.fetchPreviousPage = function fetchPreviousPage(options) {
      var _options$cancelRefetc2;

      return this.fetch({
        // TODO consider removing `?? true` in future breaking change, to be consistent with `refetch` API (see https://github.com/tannerlinsley/react-query/issues/2617)
        cancelRefetch: (_options$cancelRefetc2 = options == null ? void 0 : options.cancelRefetch) != null ? _options$cancelRefetc2 : true,
        throwOnError: options == null ? void 0 : options.throwOnError,
        meta: {
          fetchMore: {
            direction: 'backward',
            pageParam: options == null ? void 0 : options.pageParam
          }
        }
      });
    };

    _proto.createResult = function createResult(query, options) {
      var _state$data, _state$data2, _state$fetchMeta, _state$fetchMeta$fetc, _state$fetchMeta2, _state$fetchMeta2$fet;

      var state = query.state;

      var result = _QueryObserver.prototype.createResult.call(this, query, options);

      return _extends({}, 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),
        isFetchingNextPage: state.isFetching && ((_state$fetchMeta = state.fetchMeta) == null ? void 0 : (_state$fetchMeta$fetc = _state$fetchMeta.fetchMore) == null ? void 0 : _state$fetchMeta$fetc.direction) === 'forward',
        isFetchingPreviousPage: state.isFetching && ((_state$fetchMeta2 = state.fetchMeta) == null ? void 0 : (_state$fetchMeta2$fet = _state$fetchMeta2.fetchMore) == null ? void 0 : _state$fetchMeta2$fet.direction) === 'backward'
      });
    };

    return InfiniteQueryObserver;
  }(QueryObserver);

  // CLASS
  var MutationObserver = /*#__PURE__*/function (_Subscribable) {
    _inheritsLoose(MutationObserver, _Subscribable);

    function MutationObserver(client, options) {
      var _this;

      _this = _Subscribable.call(this) || this;
      _this.client = client;

      _this.setOptions(options);

      _this.bindMethods();

      _this.updateResult();

      return _this;
    }

    var _proto = MutationObserver.prototype;

    _proto.bindMethods = function bindMethods() {
      this.mutate = this.mutate.bind(this);
      this.reset = this.reset.bind(this);
    };

    _proto.setOptions = function setOptions(options) {
      this.options = this.client.defaultMutationOptions(options);
    };

    _proto.onUnsubscribe = function onUnsubscribe() {
      if (!this.listeners.length) {
        var _this$currentMutation;

        (_this$currentMutation = this.currentMutation) == null ? void 0 : _this$currentMutation.removeObserver(this);
      }
    };

    _proto.onMutationUpdate = function onMutationUpdate(action) {
      this.updateResult(); // Determine which callbacks to trigger

      var notifyOptions = {
        listeners: true
      };

      if (action.type === 'success') {
        notifyOptions.onSuccess = true;
      } else if (action.type === 'error') {
        notifyOptions.onError = true;
      }

      this.notify(notifyOptions);
    };

    _proto.getCurrentResult = function getCurrentResult() {
      return this.currentResult;
    };

    _proto.reset = function reset() {
      this.currentMutation = undefined;
      this.updateResult();
      this.notify({
        listeners: true
      });
    };

    _proto.mutate = function mutate(variables, options) {
      this.mutateOptions = options;

      if (this.currentMutation) {
        this.currentMutation.removeObserver(this);
      }

      this.currentMutation = this.client.getMutationCache().build(this.client, _extends({}, this.options, {
        variables: typeof variables !== 'undefined' ? variables : this.options.variables
      }));
      this.currentMutation.addObserver(this);
      return this.currentMutation.execute();
    };

    _proto.updateResult = function updateResult() {
      var state = this.currentMutation ? this.currentMutation.state : getDefaultState();

      var result = _extends({}, state, {
        isLoading: state.status === 'loading',
        isSuccess: state.status === 'success',
        isError: state.status === 'error',
        isIdle: state.status === 'idle',
        mutate: this.mutate,
        reset: this.reset
      });

      this.currentResult = result;
    };

    _proto.notify = function notify(options) {
      var _this2 = this;

      notifyManager.batch(function () {
        // First trigger the mutate callbacks
        if (_this2.mutateOptions) {
          if (options.onSuccess) {
            _this2.mutateOptions.onSuccess == null ? void 0 : _this2.mutateOptions.onSuccess(_this2.currentResult.data, _this2.currentResult.variables, _this2.currentResult.context);
            _this2.mutateOptions.onSettled == null ? void 0 : _this2.mutateOptions.onSettled(_this2.currentResult.data, null, _this2.currentResult.variables, _this2.currentResult.context);
          } else if (options.onError) {
            _this2.mutateOptions.onError == null ? void 0 : _this2.mutateOptions.onError(_this2.currentResult.error, _this2.currentResult.variables, _this2.currentResult.context);
            _this2.mutateOptions.onSettled == null ? void 0 : _this2.mutateOptions.onSettled(undefined, _this2.currentResult.error, _this2.currentResult.variables, _this2.currentResult.context);
          }
        } // Then trigger the listeners


        if (options.listeners) {
          _this2.listeners.forEach(function (listener) {
            listener(_this2.currentResult);
          });
        }
      });
    };

    return MutationObserver;
  }(Subscribable);

  // 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
  // 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,
      queryKey: query.queryKey,
      queryHash: query.queryHash
    };
  }

  function defaultShouldDehydrateMutation(mutation) {
    return mutation.state.isPaused;
  }

  function defaultShouldDehydrateQuery(query) {
    return query.state.status === 'success';
  }

  function dehydrate(client, options) {
    var _options, _options2;

    options = options || {};
    var mutations = [];
    var queries = [];

    if (((_options = options) == null ? void 0 : _options.dehydrateMutations) !== false) {
      var shouldDehydrateMutation = options.shouldDehydrateMutation || defaultShouldDehydrateMutation;
      client.getMutationCache().getAll().forEach(function (mutation) {
        if (shouldDehydrateMutation(mutation)) {
          mutations.push(dehydrateMutation(mutation));
        }
      });
    }

    if (((_options2 = options) == null ? void 0 : _options2.dehydrateQueries) !== false) {
      var shouldDehydrateQuery = options.shouldDehydrateQuery || defaultShouldDehydrateQuery;
      client.getQueryCache().getAll().forEach(function (query) {
        if (shouldDehydrateQuery(query)) {
          queries.push(dehydrateQuery(query));
        }
      });
    }

    return {
      mutations: mutations,
      queries: queries
    };
  }
  function hydrate(client, dehydratedState, options) {
    if (typeof dehydratedState !== 'object' || dehydratedState === null) {
      return;
    }

    var mutationCache = client.getMutationCache();
    var queryCache = client.getQueryCache();
    var mutations = dehydratedState.mutations || [];
    var queries = dehydratedState.queries || [];
    mutations.forEach(function (dehydratedMutation) {
      var _options$defaultOptio;

      mutationCache.build(client, _extends({}, options == null ? void 0 : (_options$defaultOptio = options.defaultOptions) == null ? void 0 : _options$defaultOptio.mutations, {
        mutationKey: dehydratedMutation.mutationKey
      }), dehydratedMutation.state);
    });
    queries.forEach(function (dehydratedQuery) {
      var _options$defaultOptio2;

      var query = queryCache.get(dehydratedQuery.queryHash); // Do not hydrate if an existing query exists with newer data

      if (query) {
        if (query.state.dataUpdatedAt < dehydratedQuery.state.dataUpdatedAt) {
          query.setState(dehydratedQuery.state);
        }

        return;
      } // Restore query


      queryCache.build(client, _extends({}, options == null ? void 0 : (_options$defaultOptio2 = options.defaultOptions) == null ? void 0 : _options$defaultOptio2.queries, {
        queryKey: dehydratedQuery.queryKey,
        queryHash: dehydratedQuery.queryHash
      }), dehydratedQuery.state);
    });
  }

  var defaultContext = /*#__PURE__*/React__default.createContext(undefined);
  var QueryClientSharingContext = /*#__PURE__*/React__default.createContext(false); // 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(contextSharing) {
    if (contextSharing && typeof window !== 'undefined') {
      if (!window.ReactQueryClientContext) {
        window.ReactQueryClientContext = defaultContext;
      }

      return window.ReactQueryClientContext;
    }

    return defaultContext;
  }

  var useQueryClient = function useQueryClient() {
    var queryClient = React__default.useContext(getQueryClientContext(React__default.useContext(QueryClientSharingContext)));

    if (!queryClient) {
      throw new Error('No QueryClient set, use QueryClientProvider to set one');
    }

    return queryClient;
  };
  var QueryClientProvider = function QueryClientProvider(_ref) {
    var client = _ref.client,
        _ref$contextSharing = _ref.contextSharing,
        contextSharing = _ref$contextSharing === void 0 ? false : _ref$contextSharing,
        children = _ref.children;
    React__default.useEffect(function () {
      client.mount();
      return function () {
        client.unmount();
      };
    }, [client]);
    var Context = getQueryClientContext(contextSharing);
    return /*#__PURE__*/React__default.createElement(QueryClientSharingContext.Provider, {
      value: contextSharing
    }, /*#__PURE__*/React__default.createElement(Context.Provider, {
      value: client
    }, children));
  };

  function createValue() {
    var _isReset = false;
    return {
      clearReset: function clearReset() {
        _isReset = false;
      },
      reset: function reset() {
        _isReset = true;
      },
      isReset: function isReset() {
        return _isReset;
      }
    };
  }

  var QueryErrorResetBoundaryContext = /*#__PURE__*/React__default.createContext(createValue()); // HOOK

  var useQueryErrorResetBoundary = function useQueryErrorResetBoundary() {
    return React__default.useContext(QueryErrorResetBoundaryContext);
  }; // COMPONENT

  var QueryErrorResetBoundary = function QueryErrorResetBoundary(_ref) {
    var children = _ref.children;
    var value = React__default.useMemo(function () {
      return createValue();
    }, []);
    return /*#__PURE__*/React__default.createElement(QueryErrorResetBoundaryContext.Provider, {
      value: value
    }, typeof children === 'function' ? children(value) : children);
  };

  var checkIsFetching = function checkIsFetching(queryClient, filters, isFetching, setIsFetching) {
    var newIsFetching = queryClient.isFetching(filters);

    if (isFetching !== newIsFetching) {
      setIsFetching(newIsFetching);
    }
  };

  function useIsFetching(arg1, arg2) {
    var mountedRef = React__default.useRef(false);
    var queryClient = useQueryClient();

    var _parseFilterArgs = parseFilterArgs(arg1, arg2),
        filters = _parseFilterArgs[0];

    var _React$useState = React__default.useState(queryClient.isFetching(filters)),
        isFetching = _React$useState[0],
        setIsFetching = _React$useState[1];

    var filtersRef = React__default.useRef(filters);
    filtersRef.current = filters;
    var isFetchingRef = React__default.useRef(isFetching);
    isFetchingRef.current = isFetching;
    React__default.useEffect(function () {
      mountedRef.current = true;
      checkIsFetching(queryClient, filtersRef.current, isFetchingRef.current, setIsFetching);
      var unsubscribe = queryClient.getQueryCache().subscribe(notifyManager.batchCalls(function () {
        if (mountedRef.current) {
          checkIsFetching(queryClient, filtersRef.current, isFetchingRef.current, setIsFetching);
        }
      }));
      return function () {
        mountedRef.current = false;
        unsubscribe();
      };
    }, [queryClient]);
    return isFetching;
  }

  function useIsMutating(arg1, arg2) {
    var mountedRef = React__default.useRef(false);
    var filters = parseMutationFilterArgs(arg1, arg2);
    var queryClient = useQueryClient();

    var _React$useState = React__default.useState(queryClient.isMutating(filters)),
        isMutating = _React$useState[0],
        setIsMutating = _React$useState[1];

    var filtersRef = React__default.useRef(filters);
    filtersRef.current = filters;
    var isMutatingRef = React__default.useRef(isMutating);
    isMutatingRef.current = isMutating;
    React__default.useEffect(function () {
      mountedRef.current = true;
      var unsubscribe = queryClient.getMutationCache().subscribe(notifyManager.batchCalls(function () {
        if (mountedRef.current) {
          var newIsMutating = queryClient.isMutating(filtersRef.current);

          if (isMutatingRef.current !== newIsMutating) {
            setIsMutating(newIsMutating);
          }
        }
      }));
      return function () {
        mountedRef.current = false;
        unsubscribe();
      };
    }, [queryClient]);
    return isMutating;
  }

  function shouldThrowError(suspense, _useErrorBoundary, params) {
    // Allow useErrorBoundary function to override throwing behavior on a per-error basis
    if (typeof _useErrorBoundary === 'function') {
      return _useErrorBoundary.apply(void 0, params);
    } // Allow useErrorBoundary to override suspense's throwing behavior


    if (typeof _useErrorBoundary === 'boolean') return _useErrorBoundary; // If suspense is enabled default to throwing errors

    return !!suspense;
  }

  function useMutation(arg1, arg2, arg3) {
    var mountedRef = React__default.useRef(false);

    var _React$useState = React__default.useState(0),
        forceUpdate = _React$useState[1];

    var options = parseMutationArgs(arg1, arg2, arg3);
    var queryClient = useQueryClient();
    var obsRef = React__default.useRef();

    if (!obsRef.current) {
      obsRef.current = new MutationObserver(queryClient, options);
    } else {
      obsRef.current.setOptions(options);
    }

    var currentResult = obsRef.current.getCurrentResult();
    React__default.useEffect(function () {
      mountedRef.current = true;
      var unsubscribe = obsRef.current.subscribe(notifyManager.batchCalls(function () {
        if (mountedRef.current) {
          forceUpdate(function (x) {
            return x + 1;
          });
        }
      }));
      return function () {
        mountedRef.current = false;
        unsubscribe();
      };
    }, []);
    var mutate = React__default.useCallback(function (variables, mutateOptions) {
      obsRef.current.mutate(variables, mutateOptions).catch(noop);
    }, []);

    if (currentResult.error && shouldThrowError(undefined, obsRef.current.options.useErrorBoundary, [currentResult.error])) {
      throw currentResult.error;
    }

    return _extends({}, currentResult, {
      mutate: mutate,
      mutateAsync: currentResult.mutate
    });
  }

  function useBaseQuery(options, Observer) {
    var mountedRef = React__default.useRef(false);

    var _React$useState = React__default.useState(0),
        forceUpdate = _React$useState[1];

    var queryClient = useQueryClient();
    var errorResetBoundary = useQueryErrorResetBoundary();
    var defaultedOptions = queryClient.defaultQueryObserverOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options

    defaultedOptions.optimisticResults = true; // 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);
    }

    if (defaultedOptions.suspense) {
      // Always set stale time when using suspense to prevent
      // fetching again when directly mounting after suspending
      if (typeof defaultedOptions.staleTime !== 'number') {
        defaultedOptions.staleTime = 1000;
      } // Set cache time to 1 if the option has been set to 0
      // when using suspense to prevent infinite loop of fetches


      if (defaultedOptions.cacheTime === 0) {
        defaultedOptions.cacheTime = 1;
      }
    }

    if (defaultedOptions.suspense || defaultedOptions.useErrorBoundary) {
      // Prevent retrying failed query if the error boundary has not been reset yet
      if (!errorResetBoundary.isReset()) {
        defaultedOptions.retryOnMount = false;
      }
    }

    var _React$useState2 = React__default.useState(function () {
      return new Observer(queryClient, defaultedOptions);
    }),
        observer = _React$useState2[0];

    var result = observer.getOptimisticResult(defaultedOptions);
    React__default.useEffect(function () {
      mountedRef.current = true;
      errorResetBoundary.clearReset();
      var unsubscribe = observer.subscribe(notifyManager.batchCalls(function () {
        if (mountedRef.current) {
          forceUpdate(function (x) {
            return x + 1;
          });
        }
      })); // Update result to make sure we did not miss any query updates
      // between creating the observer and subscribing to it.

      observer.updateResult();
      return function () {
        mountedRef.current = false;
        unsubscribe();
      };
    }, [errorResetBoundary, observer]);
    React__default.useEffect(function () {
      // 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

    if (defaultedOptions.suspense && result.isLoading) {
      throw observer.fetchOptimistic(defaultedOptions).then(function (_ref) {
        var data = _ref.data;
        defaultedOptions.onSuccess == null ? void 0 : defaultedOptions.onSuccess(data);
        defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(data, null);
      }).catch(function (error) {
        errorResetBoundary.clearReset();
        defaultedOptions.onError == null ? void 0 : defaultedOptions.onError(error);
        defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(undefined, error);
      });
    } // Handle error boundary


    if (result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(defaultedOptions.suspense, defaultedOptions.useErrorBoundary, [result.error, observer.getCurrentQuery()])) {
      throw result.error;
    } // Handle result property usage tracking


    if (defaultedOptions.notifyOnChangeProps === 'tracked') {
      result = observer.trackResult(result, defaultedOptions);
    }

    return result;
  }

  function useQuery(arg1, arg2, arg3) {
    var parsedOptions = parseQueryArgs(arg1, arg2, arg3);
    return useBaseQuery(parsedOptions, QueryObserver);
  }

  function useQueries(queries) {
    var mountedRef = React__default.useRef(false);

    var _React$useState = React__default.useState(0),
        forceUpdate = _React$useState[1];

    var queryClient = useQueryClient();
    var defaultedQueries = React.useMemo(function () {
      return queries.map(function (options) {
        var defaultedOptions = queryClient.defaultQueryObserverOptions(options); // Make sure the results are already in fetching state before subscribing or updating options

        defaultedOptions.optimisticResults = true;
        return defaultedOptions;
      });
    }, [queries, queryClient]);

    var _React$useState2 = React__default.useState(function () {
      return new QueriesObserver(queryClient, defaultedQueries);
    }),
        observer = _React$useState2[0];

    var result = observer.getOptimisticResult(defaultedQueries);
    React__default.useEffect(function () {
      mountedRef.current = true;
      var unsubscribe = observer.subscribe(notifyManager.batchCalls(function () {
        if (mountedRef.current) {
          forceUpdate(function (x) {
            return x + 1;
          });
        }
      }));
      return function () {
        mountedRef.current = false;
        unsubscribe();
      };
    }, [observer]);
    React__default.useEffect(function () {
      // Do not notify on updates because of changes in the options because
      // these changes should already be reflected in the optimistic result.
      observer.setQueries(defaultedQueries, {
        listeners: false
      });
    }, [defaultedQueries, observer]);
    return result;
  }

  function useInfiniteQuery(arg1, arg2, arg3) {
    var options = parseQueryArgs(arg1, arg2, arg3);
    return useBaseQuery(options, InfiniteQueryObserver);
  }

  function useHydrate(state, options) {
    var queryClient = useQueryClient();
    var optionsRef = React__default.useRef(options);
    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__default.useMemo(function () {
      if (state) {
        hydrate(queryClient, state, optionsRef.current);
      }
    }, [queryClient, state]);
  }
  var Hydrate = function Hydrate(_ref) {
    var children = _ref.children,
        options = _ref.options,
        state = _ref.state;
    useHydrate(state, options);
    return children;
  };

  exports.CancelledError = CancelledError;
  exports.Hydrate = Hydrate;
  exports.InfiniteQueryObserver = InfiniteQueryObserver;
  exports.MutationCache = MutationCache;
  exports.MutationObserver = MutationObserver;
  exports.QueriesObserver = QueriesObserver;
  exports.QueryCache = QueryCache;
  exports.QueryClient = QueryClient;
  exports.QueryClientProvider = QueryClientProvider;
  exports.QueryErrorResetBoundary = QueryErrorResetBoundary;
  exports.QueryObserver = QueryObserver;
  exports.dehydrate = dehydrate;
  exports.focusManager = focusManager;
  exports.hashQueryKey = hashQueryKey;
  exports.hydrate = hydrate;
  exports.isCancelledError = isCancelledError;
  exports.isError = isError;
  exports.notifyManager = notifyManager;
  exports.onlineManager = onlineManager;
  exports.setLogger = setLogger;
  exports.useHydrate = useHydrate;
  exports.useInfiniteQuery = useInfiniteQuery;
  exports.useIsFetching = useIsFetching;
  exports.useIsMutating = useIsMutating;
  exports.useMutation = useMutation;
  exports.useQueries = useQueries;
  exports.useQuery = useQuery;
  exports.useQueryClient = useQueryClient;
  exports.useQueryErrorResetBoundary = useQueryErrorResetBoundary;

  Object.defineProperty(exports, '__esModule', { value: true });

})));
//# sourceMappingURL=react-query.development.js.map