@0xsquid/react-hooks 8.3.1-beta-stellar-issued-assets.1 → 8.3.1-embed-tanstack-build.0

package/dist/{index-DPakWLan.js → index-D3LtAuC9.js}

@@ -1,7 +1,7 @@
 import { ChainType, ActionType, SquidDataType, BridgeType, BridgeProvider, FeeType } from '@0xsquid/squid-types';
 import { zeroAddress as zeroAddress$1, parseUnits, formatUnits, isAddress, SwitchChainError, UserRejectedRequestError, getAddress, defineChain, encodeFunctionData, erc20Abi } from 'viem';
-import React, { useMemo, useCallback, useState, useEffect, createContext, useContext, useRef } from 'react';
-import { useQuery, useMutation, useQueries, useQueryClient, QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import * as React from 'react';
+import React__default, { useMemo, useCallback, useState, useEffect, createContext, useContext, useRef } from 'react';
 import { fromBech32 } from '@cosmjs/encoding';
 import * as bitcoin from 'bitcoinjs-lib';
 import { address } from 'bitcoinjs-lib';
@@ -13,7 +13,7 @@ import { isValidXAddress, isValidClassicAddress } from 'ripple-address-codec';
 import { getAssociatedTokenAddress, createAssociatedTokenAccountInstruction, createTransferInstruction } from '@solana/spl-token';
 import { StandardWalletAdapter } from '@solana/wallet-standard-wallet-adapter-base';
 import { PublicKey, VersionedTransaction, Transaction, SystemProgram, Connection } from '@solana/web3.js';
-import { StrKey, Networks, nativeToScVal, Address, rpc, TransactionBuilder, BASE_FEE, Contract, TimeoutInfinite, scValToNative, Asset, Operation, Transaction as Transaction$1, xdr } from '@stellar/stellar-sdk';
+import { StrKey, Networks, nativeToScVal, Address, rpc, TransactionBuilder, BASE_FEE, Contract, TimeoutInfinite, scValToNative, Operation, Transaction as Transaction$1, xdr } from '@stellar/stellar-sdk';
 import { SUI_TESTNET_CHAIN, SUI_MAINNET_CHAIN } from '@mysten/wallet-standard';
 import { CloudflareProvider, BrowserProvider, JsonRpcSigner, JsonRpcProvider, ethers, Interface, Contract as Contract$1, isError } from 'ethers';
 import BigNumber$1, { BigNumber } from 'bignumber.js';
@@ -200,22 +200,3053 @@ const transactionEndStatuses = [
     ...transactionErrorStatuses,
 ];
 
-var TransactionErrorType;
-(function (TransactionErrorType) {
-    TransactionErrorType[TransactionErrorType["REJECTED_BY_USER"] = 0] = "REJECTED_BY_USER";
-    TransactionErrorType[TransactionErrorType["CALL_EXCEPTION"] = 1] = "CALL_EXCEPTION";
-    TransactionErrorType[TransactionErrorType["UNKNOWN"] = 2] = "UNKNOWN";
-    TransactionErrorType[TransactionErrorType["WARNING"] = 3] = "WARNING";
-})(TransactionErrorType || (TransactionErrorType = {}));
-var SquidStatusErrorType;
-(function (SquidStatusErrorType) {
-    SquidStatusErrorType["NotFoundError"] = "NotFoundError";
-})(SquidStatusErrorType || (SquidStatusErrorType = {}));
-class QrCodeGenerationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "QrCodeGenerationError";
+class Subscribable {
+  constructor() {
+    this.listeners = new Set();
+    this.subscribe = this.subscribe.bind(this);
+  }
+
+  subscribe(listener) {
+    const identity = {
+      listener
+    };
+    this.listeners.add(identity);
+    this.onSubscribe();
+    return () => {
+      this.listeners.delete(identity);
+      this.onUnsubscribe();
+    };
+  }
+
+  hasListeners() {
+    return this.listeners.size > 0;
+  }
+
+  onSubscribe() {// Do nothing
+  }
+
+  onUnsubscribe() {// Do nothing
+  }
+
+}
+
+// TYPES
+// UTILS
+const isServer = typeof window === 'undefined' || 'Deno' in window;
+function noop$1() {
+  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 difference(array1, array2) {
+  return array1.filter(x => !array2.includes(x));
+}
+function replaceAt(array, index, value) {
+  const copy = array.slice(0);
+  copy[index] = value;
+  return copy;
+}
+function timeUntilStale(updatedAt, staleTime) {
+  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);
+}
+function parseQueryArgs(arg1, arg2, arg3) {
+  if (!isQueryKey(arg1)) {
+    return arg1;
+  }
+
+  if (typeof arg2 === 'function') {
+    return { ...arg3,
+      queryKey: arg1,
+      queryFn: arg2
+    };
+  }
+
+  return { ...arg2,
+    queryKey: arg1
+  };
+}
+function parseMutationArgs(arg1, arg2, arg3) {
+  if (isQueryKey(arg1)) {
+    if (typeof arg2 === 'function') {
+      return { ...arg3,
+        mutationKey: arg1,
+        mutationFn: arg2
+      };
+    }
+
+    return { ...arg2,
+      mutationKey: arg1
+    };
+  }
+
+  if (typeof arg1 === 'function') {
+    return { ...arg2,
+      mutationFn: arg1
+    };
+  }
+
+  return { ...arg1
+  };
+}
+function parseFilterArgs(arg1, arg2, arg3) {
+  return isQueryKey(arg1) ? [{ ...arg2,
+    queryKey: arg1
+  }, arg3] : [arg1 || {}, arg2];
+}
+function matchQuery(filters, query) {
+  const {
+    type = 'all',
+    exact,
+    fetchStatus,
+    predicate,
+    queryKey,
+    stale
+  } = filters;
+
+  if (isQueryKey(queryKey)) {
+    if (exact) {
+      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {
+        return false;
+      }
+    } else if (!partialMatchKey(query.queryKey, queryKey)) {
+      return false;
+    }
+  }
+
+  if (type !== 'all') {
+    const isActive = query.isActive();
+
+    if (type === 'active' && !isActive) {
+      return false;
+    }
+
+    if (type === 'inactive' && isActive) {
+      return false;
+    }
+  }
+
+  if (typeof stale === 'boolean' && query.isStale() !== stale) {
+    return false;
+  }
+
+  if (typeof fetchStatus !== 'undefined' && fetchStatus !== query.state.fetchStatus) {
+    return false;
+  }
+
+  if (predicate && !predicate(query)) {
+    return false;
+  }
+
+  return true;
+}
+function matchMutation(filters, mutation) {
+  const {
+    exact,
+    fetching,
+    predicate,
+    mutationKey
+  } = filters;
+
+  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) {
+  const hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashQueryKey;
+  return hashFn(queryKey);
+}
+/**
+ * Default query keys hash function.
+ * Hashes the value into a stable hash.
+ */
+
+function hashQueryKey(queryKey) {
+  return JSON.stringify(queryKey, (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {
+    result[key] = val[key];
+    return result;
+  }, {}) : val);
+}
+/**
+ * Checks if key `b` partially matches with key `a`.
+ */
+
+function partialMatchKey(a, b) {
+  return partialDeepEqual(a, b);
+}
+/**
+ * Checks if `b` partially matches with `a`.
+ */
+
+function partialDeepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+
+  if (typeof a !== typeof b) {
+    return false;
+  }
+
+  if (a && b && typeof a === 'object' && typeof b === 'object') {
+    return !Object.keys(b).some(key => !partialDeepEqual(a[key], b[key]));
+  }
+
+  return 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;
+  }
+
+  const array = isPlainArray(a) && isPlainArray(b);
+
+  if (array || isPlainObject(a) && isPlainObject(b)) {
+    const aSize = array ? a.length : Object.keys(a).length;
+    const bItems = array ? b : Object.keys(b);
+    const bSize = bItems.length;
+    const copy = array ? [] : {};
+    let equalItems = 0;
+
+    for (let i = 0; i < bSize; i++) {
+      const key = array ? i : bItems[i];
+      copy[key] = replaceEqualDeep(a[key], b[key]);
+
+      if (copy[key] === a[key]) {
+        equalItems++;
+      }
+    }
+
+    return aSize === bSize && equalItems === aSize ? a : copy;
+  }
+
+  return b;
+}
+/**
+ * Shallow compare objects. Only works with objects that always have the same properties.
+ */
+
+function shallowEqualObjects(a, b) {
+  if (a && !b || b && !a) {
+    return false;
+  }
+
+  for (const key in a) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+function isPlainArray(value) {
+  return Array.isArray(value) && value.length === Object.keys(value).length;
+} // Copied from: https://github.com/jonschlinkert/is-plain-object
+
+function isPlainObject(o) {
+  if (!hasObjectPrototype(o)) {
+    return false;
+  } // If has modified constructor
+
+
+  const ctor = o.constructor;
+
+  if (typeof ctor === 'undefined') {
+    return true;
+  } // If has modified prototype
+
+
+  const 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 Array.isArray(value);
+}
+function sleep$1(timeout) {
+  return new Promise(resolve => {
+    setTimeout(resolve, timeout);
+  });
+}
+/**
+ * Schedules a microtask.
+ * This can be useful to schedule state updates after rendering.
+ */
+
+function scheduleMicrotask(callback) {
+  sleep$1(0).then(callback);
+}
+function getAbortController() {
+  if (typeof AbortController === 'function') {
+    return new AbortController();
+  }
+
+  return;
+}
+function replaceData(prevData, data, options) {
+  // Use prev data if an isDataEqual function is defined and returns `true`
+  if (options.isDataEqual != null && options.isDataEqual(prevData, data)) {
+    return prevData;
+  } else if (typeof options.structuralSharing === 'function') {
+    return options.structuralSharing(prevData, data);
+  } else if (options.structuralSharing !== false) {
+    // Structurally share data between prev and new data if needed
+    return replaceEqualDeep(prevData, data);
+  }
+
+  return data;
+}
+
+class FocusManager extends Subscribable {
+  constructor() {
+    super();
+
+    this.setup = onFocus => {
+      // addEventListener does not exist in React Native, but window does
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (!isServer && window.addEventListener) {
+        const listener = () => onFocus(); // Listen to visibillitychange and focus
+
+
+        window.addEventListener('visibilitychange', listener, false);
+        window.addEventListener('focus', listener, false);
+        return () => {
+          // Be sure to unsubscribe if a new handler is set
+          window.removeEventListener('visibilitychange', listener);
+          window.removeEventListener('focus', listener);
+        };
+      }
+
+      return;
+    };
+  }
+
+  onSubscribe() {
+    if (!this.cleanup) {
+      this.setEventListener(this.setup);
+    }
+  }
+
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      var _this$cleanup;
+
+      (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
+      this.cleanup = undefined;
+    }
+  }
+
+  setEventListener(setup) {
+    var _this$cleanup2;
+
+    this.setup = setup;
+    (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
+    this.cleanup = setup(focused => {
+      if (typeof focused === 'boolean') {
+        this.setFocused(focused);
+      } else {
+        this.onFocus();
+      }
+    });
+  }
+
+  setFocused(focused) {
+    const changed = this.focused !== focused;
+
+    if (changed) {
+      this.focused = focused;
+      this.onFocus();
+    }
+  }
+
+  onFocus() {
+    this.listeners.forEach(({
+      listener
+    }) => {
+      listener();
+    });
+  }
+
+  isFocused() {
+    if (typeof this.focused === 'boolean') {
+      return this.focused;
+    } // document global can be unavailable in react native
+
+
+    if (typeof document === 'undefined') {
+      return true;
+    }
+
+    return [undefined, 'visible', 'prerender'].includes(document.visibilityState);
+  }
+
+}
+const focusManager = new FocusManager();
+
+const onlineEvents = ['online', 'offline'];
+class OnlineManager extends Subscribable {
+  constructor() {
+    super();
+
+    this.setup = onOnline => {
+      // addEventListener does not exist in React Native, but window does
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (!isServer && window.addEventListener) {
+        const listener = () => onOnline(); // Listen to online
+
+
+        onlineEvents.forEach(event => {
+          window.addEventListener(event, listener, false);
+        });
+        return () => {
+          // Be sure to unsubscribe if a new handler is set
+          onlineEvents.forEach(event => {
+            window.removeEventListener(event, listener);
+          });
+        };
+      }
+
+      return;
+    };
+  }
+
+  onSubscribe() {
+    if (!this.cleanup) {
+      this.setEventListener(this.setup);
+    }
+  }
+
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      var _this$cleanup;
+
+      (_this$cleanup = this.cleanup) == null ? void 0 : _this$cleanup.call(this);
+      this.cleanup = undefined;
+    }
+  }
+
+  setEventListener(setup) {
+    var _this$cleanup2;
+
+    this.setup = setup;
+    (_this$cleanup2 = this.cleanup) == null ? void 0 : _this$cleanup2.call(this);
+    this.cleanup = setup(online => {
+      if (typeof online === 'boolean') {
+        this.setOnline(online);
+      } else {
+        this.onOnline();
+      }
+    });
+  }
+
+  setOnline(online) {
+    const changed = this.online !== online;
+
+    if (changed) {
+      this.online = online;
+      this.onOnline();
+    }
+  }
+
+  onOnline() {
+    this.listeners.forEach(({
+      listener
+    }) => {
+      listener();
+    });
+  }
+
+  isOnline() {
+    if (typeof this.online === 'boolean') {
+      return this.online;
+    }
+
+    if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {
+      return true;
+    }
+
+    return navigator.onLine;
+  }
+
+}
+const onlineManager = new OnlineManager();
+
+function defaultRetryDelay(failureCount) {
+  return Math.min(1000 * 2 ** failureCount, 30000);
+}
+
+function canFetch(networkMode) {
+  return (networkMode != null ? networkMode : 'online') === 'online' ? onlineManager.isOnline() : true;
+}
+class CancelledError {
+  constructor(options) {
+    this.revert = options == null ? void 0 : options.revert;
+    this.silent = options == null ? void 0 : options.silent;
+  }
+
+}
+function isCancelledError(value) {
+  return value instanceof CancelledError;
+}
+function createRetryer(config) {
+  let isRetryCancelled = false;
+  let failureCount = 0;
+  let isResolved = false;
+  let continueFn;
+  let promiseResolve;
+  let promiseReject;
+  const promise = new Promise((outerResolve, outerReject) => {
+    promiseResolve = outerResolve;
+    promiseReject = outerReject;
+  });
+
+  const cancel = cancelOptions => {
+    if (!isResolved) {
+      reject(new CancelledError(cancelOptions));
+      config.abort == null ? void 0 : config.abort();
+    }
+  };
+
+  const cancelRetry = () => {
+    isRetryCancelled = true;
+  };
+
+  const continueRetry = () => {
+    isRetryCancelled = false;
+  };
+
+  const shouldPause = () => !focusManager.isFocused() || config.networkMode !== 'always' && !onlineManager.isOnline();
+
+  const resolve = value => {
+    if (!isResolved) {
+      isResolved = true;
+      config.onSuccess == null ? void 0 : config.onSuccess(value);
+      continueFn == null ? void 0 : continueFn();
+      promiseResolve(value);
+    }
+  };
+
+  const reject = value => {
+    if (!isResolved) {
+      isResolved = true;
+      config.onError == null ? void 0 : config.onError(value);
+      continueFn == null ? void 0 : continueFn();
+      promiseReject(value);
+    }
+  };
+
+  const pause = () => {
+    return new Promise(continueResolve => {
+      continueFn = value => {
+        const canContinue = isResolved || !shouldPause();
+
+        if (canContinue) {
+          continueResolve(value);
+        }
+
+        return canContinue;
+      };
+
+      config.onPause == null ? void 0 : config.onPause();
+    }).then(() => {
+      continueFn = undefined;
+
+      if (!isResolved) {
+        config.onContinue == null ? void 0 : config.onContinue();
+      }
+    });
+  }; // Create loop function
+
+
+  const run = () => {
+    // Do nothing if already resolved
+    if (isResolved) {
+      return;
+    }
+
+    let promiseOrValue; // Execute query
+
+    try {
+      promiseOrValue = config.fn();
+    } catch (error) {
+      promiseOrValue = Promise.reject(error);
+    }
+
+    Promise.resolve(promiseOrValue).then(resolve).catch(error => {
+      var _config$retry, _config$retryDelay;
+
+      // Stop if the fetch is already resolved
+      if (isResolved) {
+        return;
+      } // Do we need to retry the request?
+
+
+      const retry = (_config$retry = config.retry) != null ? _config$retry : 3;
+      const retryDelay = (_config$retryDelay = config.retryDelay) != null ? _config$retryDelay : defaultRetryDelay;
+      const delay = typeof retryDelay === 'function' ? retryDelay(failureCount, error) : retryDelay;
+      const shouldRetry = retry === true || typeof retry === 'number' && failureCount < retry || typeof retry === 'function' && retry(failureCount, error);
+
+      if (isRetryCancelled || !shouldRetry) {
+        // We are done if the query does not need to be retried
+        reject(error);
+        return;
+      }
+
+      failureCount++; // Notify on fail
+
+      config.onFail == null ? void 0 : config.onFail(failureCount, error); // Delay
+
+      sleep$1(delay) // Pause if the document is not visible or when the device is offline
+      .then(() => {
+        if (shouldPause()) {
+          return pause();
+        }
+
+        return;
+      }).then(() => {
+        if (isRetryCancelled) {
+          reject(error);
+        } else {
+          run();
+        }
+      });
+    });
+  }; // Start loop
+
+
+  if (canFetch(config.networkMode)) {
+    run();
+  } else {
+    pause().then(run);
+  }
+
+  return {
+    promise,
+    cancel,
+    continue: () => {
+      const didContinue = continueFn == null ? void 0 : continueFn();
+      return didContinue ? promise : Promise.resolve();
+    },
+    cancelRetry,
+    continueRetry
+  };
+}
+
+const defaultLogger = console;
+
+function createNotifyManager() {
+  let queue = [];
+  let transactions = 0;
+
+  let notifyFn = callback => {
+    callback();
+  };
+
+  let batchNotifyFn = callback => {
+    callback();
+  };
+
+  const batch = callback => {
+    let result;
+    transactions++;
+
+    try {
+      result = callback();
+    } finally {
+      transactions--;
+
+      if (!transactions) {
+        flush();
+      }
+    }
+
+    return result;
+  };
+
+  const schedule = callback => {
+    if (transactions) {
+      queue.push(callback);
+    } else {
+      scheduleMicrotask(() => {
+        notifyFn(callback);
+      });
+    }
+  };
+  /**
+   * All calls to the wrapped function will be batched.
+   */
+
+
+  const batchCalls = callback => {
+    return (...args) => {
+      schedule(() => {
+        callback(...args);
+      });
+    };
+  };
+
+  const flush = () => {
+    const originalQueue = queue;
+    queue = [];
+
+    if (originalQueue.length) {
+      scheduleMicrotask(() => {
+        batchNotifyFn(() => {
+          originalQueue.forEach(callback => {
+            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.
+   */
+
+
+  const setNotifyFunction = fn => {
+    notifyFn = fn;
+  };
+  /**
+   * Use this method to set a custom function to batch notifications together into a single tick.
+   * By default React Query will use the batch function provided by ReactDOM or React Native.
+   */
+
+
+  const setBatchNotifyFunction = fn => {
+    batchNotifyFn = fn;
+  };
+
+  return {
+    batch,
+    batchCalls,
+    schedule,
+    setNotifyFunction,
+    setBatchNotifyFunction
+  };
+} // SINGLETON
+
+const notifyManager = createNotifyManager();
+
+class Removable {
+  destroy() {
+    this.clearGcTimeout();
+  }
+
+  scheduleGc() {
+    this.clearGcTimeout();
+
+    if (isValidTimeout(this.cacheTime)) {
+      this.gcTimeout = setTimeout(() => {
+        this.optionalRemove();
+      }, this.cacheTime);
+    }
+  }
+
+  updateCacheTime(newCacheTime) {
+    // Default to 5 minutes (Infinity for server-side) if no cache time is set
+    this.cacheTime = Math.max(this.cacheTime || 0, newCacheTime != null ? newCacheTime : isServer ? Infinity : 5 * 60 * 1000);
+  }
+
+  clearGcTimeout() {
+    if (this.gcTimeout) {
+      clearTimeout(this.gcTimeout);
+      this.gcTimeout = undefined;
+    }
+  }
+
+}
+
+// CLASS
+class Query extends Removable {
+  constructor(config) {
+    super();
+    this.abortSignalConsumed = false;
+    this.defaultOptions = config.defaultOptions;
+    this.setOptions(config.options);
+    this.observers = [];
+    this.cache = config.cache;
+    this.logger = config.logger || defaultLogger;
+    this.queryKey = config.queryKey;
+    this.queryHash = config.queryHash;
+    this.initialState = config.state || getDefaultState$1(this.options);
+    this.state = this.initialState;
+    this.scheduleGc();
+  }
+
+  get meta() {
+    return this.options.meta;
+  }
+
+  setOptions(options) {
+    this.options = { ...this.defaultOptions,
+      ...options
+    };
+    this.updateCacheTime(this.options.cacheTime);
+  }
+
+  optionalRemove() {
+    if (!this.observers.length && this.state.fetchStatus === 'idle') {
+      this.cache.remove(this);
+    }
+  }
+
+  setData(newData, options) {
+    const data = replaceData(this.state.data, newData, this.options); // Set data and mark it as cached
+
+    this.dispatch({
+      data,
+      type: 'success',
+      dataUpdatedAt: options == null ? void 0 : options.updatedAt,
+      manual: options == null ? void 0 : options.manual
+    });
+    return data;
+  }
+
+  setState(state, setStateOptions) {
+    this.dispatch({
+      type: 'setState',
+      state,
+      setStateOptions
+    });
+  }
+
+  cancel(options) {
+    var _this$retryer;
+
+    const promise = this.promise;
+    (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.cancel(options);
+    return promise ? promise.then(noop$1).catch(noop$1) : Promise.resolve();
+  }
+
+  destroy() {
+    super.destroy();
+    this.cancel({
+      silent: true
+    });
+  }
+
+  reset() {
+    this.destroy();
+    this.setState(this.initialState);
+  }
+
+  isActive() {
+    return this.observers.some(observer => observer.options.enabled !== false);
+  }
+
+  isDisabled() {
+    return this.getObserversCount() > 0 && !this.isActive();
+  }
+
+  isStale() {
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observers.some(observer => observer.getCurrentResult().isStale);
+  }
+
+  isStaleByTime(staleTime = 0) {
+    return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);
+  }
+
+  onFocus() {
+    var _this$retryer2;
+
+    const observer = this.observers.find(x => x.shouldFetchOnWindowFocus());
+
+    if (observer) {
+      observer.refetch({
+        cancelRefetch: false
+      });
+    } // Continue fetch if currently paused
+
+
+    (_this$retryer2 = this.retryer) == null ? void 0 : _this$retryer2.continue();
+  }
+
+  onOnline() {
+    var _this$retryer3;
+
+    const observer = this.observers.find(x => x.shouldFetchOnReconnect());
+
+    if (observer) {
+      observer.refetch({
+        cancelRefetch: false
+      });
+    } // Continue fetch if currently paused
+
+
+    (_this$retryer3 = this.retryer) == null ? void 0 : _this$retryer3.continue();
+  }
+
+  addObserver(observer) {
+    if (!this.observers.includes(observer)) {
+      this.observers.push(observer); // Stop the query from being garbage collected
+
+      this.clearGcTimeout();
+      this.cache.notify({
+        type: 'observerAdded',
+        query: this,
+        observer
+      });
+    }
+  }
+
+  removeObserver(observer) {
+    if (this.observers.includes(observer)) {
+      this.observers = this.observers.filter(x => x !== observer);
+
+      if (!this.observers.length) {
+        // If the transport layer does not support cancellation
+        // we'll let the query continue so the result can be cached
+        if (this.retryer) {
+          if (this.abortSignalConsumed) {
+            this.retryer.cancel({
+              revert: true
+            });
+          } else {
+            this.retryer.cancelRetry();
+          }
+        }
+
+        this.scheduleGc();
+      }
+
+      this.cache.notify({
+        type: 'observerRemoved',
+        query: this,
+        observer
+      });
+    }
+  }
+
+  getObserversCount() {
+    return this.observers.length;
+  }
+
+  invalidate() {
+    if (!this.state.isInvalidated) {
+      this.dispatch({
+        type: 'invalidate'
+      });
+    }
+  }
+
+  fetch(options, fetchOptions) {
+    var _this$options$behavio, _context$fetchOptions;
+
+    if (this.state.fetchStatus !== 'idle') {
+      if (this.state.dataUpdatedAt && fetchOptions != null && fetchOptions.cancelRefetch) {
+        // 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) {
+      const observer = this.observers.find(x => x.options.queryFn);
+
+      if (observer) {
+        this.setOptions(observer.options);
+      }
+    }
+
+    if (process.env.NODE_ENV !== 'production') {
+      if (!Array.isArray(this.options.queryKey)) {
+        this.logger.error("As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']");
+      }
+    }
+
+    const abortController = getAbortController(); // Create query function context
+
+    const queryFnContext = {
+      queryKey: this.queryKey,
+      pageParam: undefined,
+      meta: this.meta
+    }; // Adds an enumerable signal property to the object that
+    // which sets abortSignalConsumed to true when the signal
+    // is read.
+
+    const addSignalProperty = object => {
+      Object.defineProperty(object, 'signal', {
+        enumerable: true,
+        get: () => {
+          if (abortController) {
+            this.abortSignalConsumed = true;
+            return abortController.signal;
+          }
+
+          return undefined;
+        }
+      });
+    };
+
+    addSignalProperty(queryFnContext); // Create fetch function
+
+    const fetchFn = () => {
+      if (!this.options.queryFn) {
+        return Promise.reject("Missing queryFn for queryKey '" + this.options.queryHash + "'");
+      }
+
+      this.abortSignalConsumed = false;
+      return this.options.queryFn(queryFnContext);
+    }; // Trigger behavior hook
+
+
+    const context = {
+      fetchOptions,
+      options: this.options,
+      queryKey: this.queryKey,
+      state: this.state,
+      fetchFn
+    };
+    addSignalProperty(context);
+    (_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch(context); // Store state in case the current fetch needs to be reverted
+
+    this.revertState = this.state; // Set to fetching state if not already in it
+
+    if (this.state.fetchStatus === 'idle' || 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
+      });
+    }
+
+    const onError = error => {
+      // Optimistically update state if needed
+      if (!(isCancelledError(error) && error.silent)) {
+        this.dispatch({
+          type: 'error',
+          error: error
+        });
+      }
+
+      if (!isCancelledError(error)) {
+        var _this$cache$config$on, _this$cache$config, _this$cache$config$on2, _this$cache$config2;
+
+        // Notify cache callback
+        (_this$cache$config$on = (_this$cache$config = this.cache.config).onError) == null ? void 0 : _this$cache$config$on.call(_this$cache$config, error, this);
+        (_this$cache$config$on2 = (_this$cache$config2 = this.cache.config).onSettled) == null ? void 0 : _this$cache$config$on2.call(_this$cache$config2, this.state.data, error, this);
+
+        if (process.env.NODE_ENV !== 'production') {
+          this.logger.error(error);
+        }
+      }
+
+      if (!this.isFetchingOptimistic) {
+        // Schedule query gc after fetching
+        this.scheduleGc();
+      }
+
+      this.isFetchingOptimistic = false;
+    }; // Try to fetch the data
+
+
+    this.retryer = createRetryer({
+      fn: context.fetchFn,
+      abort: abortController == null ? void 0 : abortController.abort.bind(abortController),
+      onSuccess: data => {
+        var _this$cache$config$on3, _this$cache$config3, _this$cache$config$on4, _this$cache$config4;
+
+        if (typeof data === 'undefined') {
+          if (process.env.NODE_ENV !== 'production') {
+            this.logger.error("Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: " + this.queryHash);
+          }
+
+          onError(new Error(this.queryHash + " data is undefined"));
+          return;
+        }
+
+        this.setData(data); // Notify cache callback
+
+        (_this$cache$config$on3 = (_this$cache$config3 = this.cache.config).onSuccess) == null ? void 0 : _this$cache$config$on3.call(_this$cache$config3, data, this);
+        (_this$cache$config$on4 = (_this$cache$config4 = this.cache.config).onSettled) == null ? void 0 : _this$cache$config$on4.call(_this$cache$config4, data, this.state.error, this);
+
+        if (!this.isFetchingOptimistic) {
+          // Schedule query gc after fetching
+          this.scheduleGc();
+        }
+
+        this.isFetchingOptimistic = false;
+      },
+      onError,
+      onFail: (failureCount, error) => {
+        this.dispatch({
+          type: 'failed',
+          failureCount,
+          error
+        });
+      },
+      onPause: () => {
+        this.dispatch({
+          type: 'pause'
+        });
+      },
+      onContinue: () => {
+        this.dispatch({
+          type: 'continue'
+        });
+      },
+      retry: context.options.retry,
+      retryDelay: context.options.retryDelay,
+      networkMode: context.options.networkMode
+    });
+    this.promise = this.retryer.promise;
+    return this.promise;
+  }
+
+  dispatch(action) {
+    const reducer = state => {
+      var _action$meta, _action$dataUpdatedAt;
+
+      switch (action.type) {
+        case 'failed':
+          return { ...state,
+            fetchFailureCount: action.failureCount,
+            fetchFailureReason: action.error
+          };
+
+        case 'pause':
+          return { ...state,
+            fetchStatus: 'paused'
+          };
+
+        case 'continue':
+          return { ...state,
+            fetchStatus: 'fetching'
+          };
+
+        case 'fetch':
+          return { ...state,
+            fetchFailureCount: 0,
+            fetchFailureReason: null,
+            fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,
+            fetchStatus: canFetch(this.options.networkMode) ? 'fetching' : 'paused',
+            ...(!state.dataUpdatedAt && {
+              error: null,
+              status: 'loading'
+            })
+          };
+
+        case 'success':
+          return { ...state,
+            data: action.data,
+            dataUpdateCount: state.dataUpdateCount + 1,
+            dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),
+            error: null,
+            isInvalidated: false,
+            status: 'success',
+            ...(!action.manual && {
+              fetchStatus: 'idle',
+              fetchFailureCount: 0,
+              fetchFailureReason: null
+            })
+          };
+
+        case 'error':
+          const error = action.error;
+
+          if (isCancelledError(error) && error.revert && this.revertState) {
+            return { ...this.revertState,
+              fetchStatus: 'idle'
+            };
+          }
+
+          return { ...state,
+            error: error,
+            errorUpdateCount: state.errorUpdateCount + 1,
+            errorUpdatedAt: Date.now(),
+            fetchFailureCount: state.fetchFailureCount + 1,
+            fetchFailureReason: error,
+            fetchStatus: 'idle',
+            status: 'error'
+          };
+
+        case 'invalidate':
+          return { ...state,
+            isInvalidated: true
+          };
+
+        case 'setState':
+          return { ...state,
+            ...action.state
+          };
+      }
+    };
+
+    this.state = reducer(this.state);
+    notifyManager.batch(() => {
+      this.observers.forEach(observer => {
+        observer.onQueryUpdate(action);
+      });
+      this.cache.notify({
+        query: this,
+        type: 'updated',
+        action
+      });
+    });
+  }
+
+}
+
+function getDefaultState$1(options) {
+  const data = typeof options.initialData === 'function' ? options.initialData() : options.initialData;
+  const hasData = typeof data !== 'undefined';
+  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === 'function' ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;
+  return {
+    data,
+    dataUpdateCount: 0,
+    dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,
+    error: null,
+    errorUpdateCount: 0,
+    errorUpdatedAt: 0,
+    fetchFailureCount: 0,
+    fetchFailureReason: null,
+    fetchMeta: null,
+    isInvalidated: false,
+    status: hasData ? 'success' : 'loading',
+    fetchStatus: 'idle'
+  };
+}
+
+// CLASS
+class QueryCache extends Subscribable {
+  constructor(config) {
+    super();
+    this.config = config || {};
+    this.queries = [];
+    this.queriesMap = {};
+  }
+
+  build(client, options, state) {
+    var _options$queryHash;
+
+    const queryKey = options.queryKey;
+    const queryHash = (_options$queryHash = options.queryHash) != null ? _options$queryHash : hashQueryKeyByOptions(queryKey, options);
+    let query = this.get(queryHash);
+
+    if (!query) {
+      query = new Query({
+        cache: this,
+        logger: client.getLogger(),
+        queryKey,
+        queryHash,
+        options: client.defaultQueryOptions(options),
+        state,
+        defaultOptions: client.getQueryDefaults(queryKey)
+      });
+      this.add(query);
+    }
+
+    return query;
+  }
+
+  add(query) {
+    if (!this.queriesMap[query.queryHash]) {
+      this.queriesMap[query.queryHash] = query;
+      this.queries.push(query);
+      this.notify({
+        type: 'added',
+        query
+      });
+    }
+  }
+
+  remove(query) {
+    const queryInMap = this.queriesMap[query.queryHash];
+
+    if (queryInMap) {
+      query.destroy();
+      this.queries = this.queries.filter(x => x !== query);
+
+      if (queryInMap === query) {
+        delete this.queriesMap[query.queryHash];
+      }
+
+      this.notify({
+        type: 'removed',
+        query
+      });
+    }
+  }
+
+  clear() {
+    notifyManager.batch(() => {
+      this.queries.forEach(query => {
+        this.remove(query);
+      });
+    });
+  }
+
+  get(queryHash) {
+    return this.queriesMap[queryHash];
+  }
+
+  getAll() {
+    return this.queries;
+  }
+
+  find(arg1, arg2) {
+    const [filters] = parseFilterArgs(arg1, arg2);
+
+    if (typeof filters.exact === 'undefined') {
+      filters.exact = true;
+    }
+
+    return this.queries.find(query => matchQuery(filters, query));
+  }
+
+  findAll(arg1, arg2) {
+    const [filters] = parseFilterArgs(arg1, arg2);
+    return Object.keys(filters).length > 0 ? this.queries.filter(query => matchQuery(filters, query)) : this.queries;
+  }
+
+  notify(event) {
+    notifyManager.batch(() => {
+      this.listeners.forEach(({
+        listener
+      }) => {
+        listener(event);
+      });
+    });
+  }
+
+  onFocus() {
+    notifyManager.batch(() => {
+      this.queries.forEach(query => {
+        query.onFocus();
+      });
+    });
+  }
+
+  onOnline() {
+    notifyManager.batch(() => {
+      this.queries.forEach(query => {
+        query.onOnline();
+      });
+    });
+  }
+
+}
+
+// CLASS
+class Mutation extends Removable {
+  constructor(config) {
+    super();
+    this.defaultOptions = config.defaultOptions;
+    this.mutationId = config.mutationId;
+    this.mutationCache = config.mutationCache;
+    this.logger = config.logger || defaultLogger;
+    this.observers = [];
+    this.state = config.state || getDefaultState();
+    this.setOptions(config.options);
+    this.scheduleGc();
+  }
+
+  setOptions(options) {
+    this.options = { ...this.defaultOptions,
+      ...options
+    };
+    this.updateCacheTime(this.options.cacheTime);
+  }
+
+  get meta() {
+    return this.options.meta;
+  }
+
+  setState(state) {
+    this.dispatch({
+      type: 'setState',
+      state
+    });
+  }
+
+  addObserver(observer) {
+    if (!this.observers.includes(observer)) {
+      this.observers.push(observer); // Stop the mutation from being garbage collected
+
+      this.clearGcTimeout();
+      this.mutationCache.notify({
+        type: 'observerAdded',
+        mutation: this,
+        observer
+      });
+    }
+  }
+
+  removeObserver(observer) {
+    this.observers = this.observers.filter(x => x !== observer);
+    this.scheduleGc();
+    this.mutationCache.notify({
+      type: 'observerRemoved',
+      mutation: this,
+      observer
+    });
+  }
+
+  optionalRemove() {
+    if (!this.observers.length) {
+      if (this.state.status === 'loading') {
+        this.scheduleGc();
+      } else {
+        this.mutationCache.remove(this);
+      }
+    }
+  }
+
+  continue() {
+    var _this$retryer$continu, _this$retryer;
+
+    return (_this$retryer$continu = (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.continue()) != null ? _this$retryer$continu : this.execute();
+  }
+
+  async execute() {
+    const executeMutation = () => {
+      var _this$options$retry;
+
+      this.retryer = createRetryer({
+        fn: () => {
+          if (!this.options.mutationFn) {
+            return Promise.reject('No mutationFn found');
+          }
+
+          return this.options.mutationFn(this.state.variables);
+        },
+        onFail: (failureCount, error) => {
+          this.dispatch({
+            type: 'failed',
+            failureCount,
+            error
+          });
+        },
+        onPause: () => {
+          this.dispatch({
+            type: 'pause'
+          });
+        },
+        onContinue: () => {
+          this.dispatch({
+            type: 'continue'
+          });
+        },
+        retry: (_this$options$retry = this.options.retry) != null ? _this$options$retry : 0,
+        retryDelay: this.options.retryDelay,
+        networkMode: this.options.networkMode
+      });
+      return this.retryer.promise;
+    };
+
+    const restored = this.state.status === 'loading';
+
+    try {
+      var _this$mutationCache$c3, _this$mutationCache$c4, _this$options$onSucce, _this$options2, _this$mutationCache$c5, _this$mutationCache$c6, _this$options$onSettl, _this$options3;
+
+      if (!restored) {
+        var _this$mutationCache$c, _this$mutationCache$c2, _this$options$onMutat, _this$options;
+
+        this.dispatch({
+          type: 'loading',
+          variables: this.options.variables
+        }); // Notify cache callback
+
+        await ((_this$mutationCache$c = (_this$mutationCache$c2 = this.mutationCache.config).onMutate) == null ? void 0 : _this$mutationCache$c.call(_this$mutationCache$c2, this.state.variables, this));
+        const context = await ((_this$options$onMutat = (_this$options = this.options).onMutate) == null ? void 0 : _this$options$onMutat.call(_this$options, this.state.variables));
+
+        if (context !== this.state.context) {
+          this.dispatch({
+            type: 'loading',
+            context,
+            variables: this.state.variables
+          });
+        }
+      }
+
+      const data = await executeMutation(); // Notify cache callback
+
+      await ((_this$mutationCache$c3 = (_this$mutationCache$c4 = this.mutationCache.config).onSuccess) == null ? void 0 : _this$mutationCache$c3.call(_this$mutationCache$c4, data, this.state.variables, this.state.context, this));
+      await ((_this$options$onSucce = (_this$options2 = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options2, data, this.state.variables, this.state.context)); // Notify cache callback
+
+      await ((_this$mutationCache$c5 = (_this$mutationCache$c6 = this.mutationCache.config).onSettled) == null ? void 0 : _this$mutationCache$c5.call(_this$mutationCache$c6, data, null, this.state.variables, this.state.context, this));
+      await ((_this$options$onSettl = (_this$options3 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options3, data, null, this.state.variables, this.state.context));
+      this.dispatch({
+        type: 'success',
+        data
+      });
+      return data;
+    } catch (error) {
+      try {
+        var _this$mutationCache$c7, _this$mutationCache$c8, _this$options$onError, _this$options4, _this$mutationCache$c9, _this$mutationCache$c10, _this$options$onSettl2, _this$options5;
+
+        // Notify cache callback
+        await ((_this$mutationCache$c7 = (_this$mutationCache$c8 = this.mutationCache.config).onError) == null ? void 0 : _this$mutationCache$c7.call(_this$mutationCache$c8, error, this.state.variables, this.state.context, this));
+
+        if (process.env.NODE_ENV !== 'production') {
+          this.logger.error(error);
+        }
+
+        await ((_this$options$onError = (_this$options4 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options4, error, this.state.variables, this.state.context)); // Notify cache callback
+
+        await ((_this$mutationCache$c9 = (_this$mutationCache$c10 = this.mutationCache.config).onSettled) == null ? void 0 : _this$mutationCache$c9.call(_this$mutationCache$c10, undefined, error, this.state.variables, this.state.context, this));
+        await ((_this$options$onSettl2 = (_this$options5 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options5, undefined, error, this.state.variables, this.state.context));
+        throw error;
+      } finally {
+        this.dispatch({
+          type: 'error',
+          error: error
+        });
+      }
+    }
+  }
+
+  dispatch(action) {
+    const reducer = state => {
+      switch (action.type) {
+        case 'failed':
+          return { ...state,
+            failureCount: action.failureCount,
+            failureReason: action.error
+          };
+
+        case 'pause':
+          return { ...state,
+            isPaused: true
+          };
+
+        case 'continue':
+          return { ...state,
+            isPaused: false
+          };
+
+        case 'loading':
+          return { ...state,
+            context: action.context,
+            data: undefined,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            isPaused: !canFetch(this.options.networkMode),
+            status: 'loading',
+            variables: action.variables
+          };
+
+        case 'success':
+          return { ...state,
+            data: action.data,
+            failureCount: 0,
+            failureReason: null,
+            error: null,
+            status: 'success',
+            isPaused: false
+          };
+
+        case 'error':
+          return { ...state,
+            data: undefined,
+            error: action.error,
+            failureCount: state.failureCount + 1,
+            failureReason: action.error,
+            isPaused: false,
+            status: 'error'
+          };
+
+        case 'setState':
+          return { ...state,
+            ...action.state
+          };
+      }
+    };
+
+    this.state = reducer(this.state);
+    notifyManager.batch(() => {
+      this.observers.forEach(observer => {
+        observer.onMutationUpdate(action);
+      });
+      this.mutationCache.notify({
+        mutation: this,
+        type: 'updated',
+        action
+      });
+    });
+  }
+
+}
+function getDefaultState() {
+  return {
+    context: undefined,
+    data: undefined,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: false,
+    status: 'idle',
+    variables: undefined
+  };
+}
+
+// CLASS
+class MutationCache extends Subscribable {
+  constructor(config) {
+    super();
+    this.config = config || {};
+    this.mutations = [];
+    this.mutationId = 0;
+  }
+
+  build(client, options, state) {
+    const mutation = new Mutation({
+      mutationCache: this,
+      logger: client.getLogger(),
+      mutationId: ++this.mutationId,
+      options: client.defaultMutationOptions(options),
+      state,
+      defaultOptions: options.mutationKey ? client.getMutationDefaults(options.mutationKey) : undefined
+    });
+    this.add(mutation);
+    return mutation;
+  }
+
+  add(mutation) {
+    this.mutations.push(mutation);
+    this.notify({
+      type: 'added',
+      mutation
+    });
+  }
+
+  remove(mutation) {
+    this.mutations = this.mutations.filter(x => x !== mutation);
+    this.notify({
+      type: 'removed',
+      mutation
+    });
+  }
+
+  clear() {
+    notifyManager.batch(() => {
+      this.mutations.forEach(mutation => {
+        this.remove(mutation);
+      });
+    });
+  }
+
+  getAll() {
+    return this.mutations;
+  }
+
+  find(filters) {
+    if (typeof filters.exact === 'undefined') {
+      filters.exact = true;
+    }
+
+    return this.mutations.find(mutation => matchMutation(filters, mutation));
+  }
+
+  findAll(filters) {
+    return this.mutations.filter(mutation => matchMutation(filters, mutation));
+  }
+
+  notify(event) {
+    notifyManager.batch(() => {
+      this.listeners.forEach(({
+        listener
+      }) => {
+        listener(event);
+      });
+    });
+  }
+
+  resumePausedMutations() {
+    var _this$resuming;
+
+    this.resuming = ((_this$resuming = this.resuming) != null ? _this$resuming : Promise.resolve()).then(() => {
+      const pausedMutations = this.mutations.filter(x => x.state.isPaused);
+      return notifyManager.batch(() => pausedMutations.reduce((promise, mutation) => promise.then(() => mutation.continue().catch(noop$1)), Promise.resolve()));
+    }).then(() => {
+      this.resuming = undefined;
+    });
+    return this.resuming;
+  }
+
+}
+
+function infiniteQueryBehavior() {
+  return {
+    onFetch: context => {
+      context.fetchFn = () => {
+        var _context$fetchOptions, _context$fetchOptions2, _context$fetchOptions3, _context$fetchOptions4, _context$state$data, _context$state$data2;
+
+        const refetchPage = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.refetchPage;
+        const fetchMore = (_context$fetchOptions3 = context.fetchOptions) == null ? void 0 : (_context$fetchOptions4 = _context$fetchOptions3.meta) == null ? void 0 : _context$fetchOptions4.fetchMore;
+        const pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;
+        const isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'forward';
+        const isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'backward';
+        const oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) || [];
+        const oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) || [];
+        let newPageParams = oldPageParams;
+        let cancelled = false;
+
+        const addSignalProperty = object => {
+          Object.defineProperty(object, 'signal', {
+            enumerable: true,
+            get: () => {
+              var _context$signal;
+
+              if ((_context$signal = context.signal) != null && _context$signal.aborted) {
+                cancelled = true;
+              } else {
+                var _context$signal2;
+
+                (_context$signal2 = context.signal) == null ? void 0 : _context$signal2.addEventListener('abort', () => {
+                  cancelled = true;
+                });
+              }
+
+              return context.signal;
+            }
+          });
+        }; // Get query function
+
+
+        const queryFn = context.options.queryFn || (() => Promise.reject("Missing queryFn for queryKey '" + context.options.queryHash + "'"));
+
+        const buildNewPages = (pages, param, page, previous) => {
+          newPageParams = previous ? [param, ...newPageParams] : [...newPageParams, param];
+          return previous ? [page, ...pages] : [...pages, page];
+        }; // Create function to fetch a page
+
+
+        const fetchPage = (pages, manual, param, previous) => {
+          if (cancelled) {
+            return Promise.reject('Cancelled');
+          }
+
+          if (typeof param === 'undefined' && !manual && pages.length) {
+            return Promise.resolve(pages);
+          }
+
+          const queryFnContext = {
+            queryKey: context.queryKey,
+            pageParam: param,
+            meta: context.options.meta
+          };
+          addSignalProperty(queryFnContext);
+          const queryFnResult = queryFn(queryFnContext);
+          const promise = Promise.resolve(queryFnResult).then(page => buildNewPages(pages, param, page, previous));
+          return promise;
+        };
+
+        let promise; // Fetch first page?
+
+        if (!oldPages.length) {
+          promise = fetchPage([]);
+        } // Fetch next page?
+        else if (isFetchingNextPage) {
+          const manual = typeof pageParam !== 'undefined';
+          const param = manual ? pageParam : getNextPageParam(context.options, oldPages);
+          promise = fetchPage(oldPages, manual, param);
+        } // Fetch previous page?
+        else if (isFetchingPreviousPage) {
+          const manual = typeof pageParam !== 'undefined';
+          const param = manual ? pageParam : getPreviousPageParam(context.options, oldPages);
+          promise = fetchPage(oldPages, manual, param, true);
+        } // Refetch pages
+        else {
+          newPageParams = [];
+          const manual = typeof context.options.getNextPageParam === 'undefined';
+          const shouldFetchFirstPage = refetchPage && oldPages[0] ? refetchPage(oldPages[0], 0, oldPages) : true; // Fetch first page
+
+          promise = shouldFetchFirstPage ? fetchPage([], manual, oldPageParams[0]) : Promise.resolve(buildNewPages([], oldPageParams[0], oldPages[0])); // Fetch remaining pages
+
+          for (let i = 1; i < oldPages.length; i++) {
+            promise = promise.then(pages => {
+              const shouldFetchNextPage = refetchPage && oldPages[i] ? refetchPage(oldPages[i], i, oldPages) : true;
+
+              if (shouldFetchNextPage) {
+                const param = manual ? oldPageParams[i] : getNextPageParam(context.options, pages);
+                return fetchPage(pages, manual, param);
+              }
+
+              return Promise.resolve(buildNewPages(pages, oldPageParams[i], oldPages[i]));
+            });
+          }
+        }
+
+        const finalPromise = promise.then(pages => ({
+          pages,
+          pageParams: newPageParams
+        }));
+        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);
+}
+
+// CLASS
+class QueryClient {
+  constructor(config = {}) {
+    this.queryCache = config.queryCache || new QueryCache();
+    this.mutationCache = config.mutationCache || new MutationCache();
+    this.logger = config.logger || defaultLogger;
+    this.defaultOptions = config.defaultOptions || {};
+    this.queryDefaults = [];
+    this.mutationDefaults = [];
+    this.mountCount = 0;
+
+    if (process.env.NODE_ENV !== 'production' && config.logger) {
+      this.logger.error("Passing a custom logger has been deprecated and will be removed in the next major version.");
+    }
+  }
+
+  mount() {
+    this.mountCount++;
+    if (this.mountCount !== 1) return;
+    this.unsubscribeFocus = focusManager.subscribe(() => {
+      if (focusManager.isFocused()) {
+        this.resumePausedMutations();
+        this.queryCache.onFocus();
+      }
+    });
+    this.unsubscribeOnline = onlineManager.subscribe(() => {
+      if (onlineManager.isOnline()) {
+        this.resumePausedMutations();
+        this.queryCache.onOnline();
+      }
+    });
+  }
+
+  unmount() {
+    var _this$unsubscribeFocu, _this$unsubscribeOnli;
+
+    this.mountCount--;
+    if (this.mountCount !== 0) return;
+    (_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);
+    this.unsubscribeFocus = undefined;
+    (_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);
+    this.unsubscribeOnline = undefined;
+  }
+
+  isFetching(arg1, arg2) {
+    const [filters] = parseFilterArgs(arg1, arg2);
+    filters.fetchStatus = 'fetching';
+    return this.queryCache.findAll(filters).length;
+  }
+
+  isMutating(filters) {
+    return this.mutationCache.findAll({ ...filters,
+      fetching: true
+    }).length;
+  }
+
+  getQueryData(queryKey, filters) {
+    var _this$queryCache$find;
+
+    return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;
+  }
+
+  ensureQueryData(arg1, arg2, arg3) {
+    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
+    const cachedData = this.getQueryData(parsedOptions.queryKey);
+    return cachedData ? Promise.resolve(cachedData) : this.fetchQuery(parsedOptions);
+  }
+
+  getQueriesData(queryKeyOrFilters) {
+    return this.getQueryCache().findAll(queryKeyOrFilters).map(({
+      queryKey,
+      state
+    }) => {
+      const data = state.data;
+      return [queryKey, data];
+    });
+  }
+
+  setQueryData(queryKey, updater, options) {
+    const query = this.queryCache.find(queryKey);
+    const prevData = query == null ? void 0 : query.state.data;
+    const data = functionalUpdate(updater, prevData);
+
+    if (typeof data === 'undefined') {
+      return undefined;
+    }
+
+    const parsedOptions = parseQueryArgs(queryKey);
+    const defaultedOptions = this.defaultQueryOptions(parsedOptions);
+    return this.queryCache.build(this, defaultedOptions).setData(data, { ...options,
+      manual: true
+    });
+  }
+
+  setQueriesData(queryKeyOrFilters, updater, options) {
+    return notifyManager.batch(() => this.getQueryCache().findAll(queryKeyOrFilters).map(({
+      queryKey
+    }) => [queryKey, this.setQueryData(queryKey, updater, options)]));
+  }
+
+  getQueryState(queryKey, filters) {
+    var _this$queryCache$find2;
+
+    return (_this$queryCache$find2 = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find2.state;
+  }
+
+  removeQueries(arg1, arg2) {
+    const [filters] = parseFilterArgs(arg1, arg2);
+    const queryCache = this.queryCache;
+    notifyManager.batch(() => {
+      queryCache.findAll(filters).forEach(query => {
+        queryCache.remove(query);
+      });
+    });
+  }
+
+  resetQueries(arg1, arg2, arg3) {
+    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
+    const queryCache = this.queryCache;
+    const refetchFilters = {
+      type: 'active',
+      ...filters
+    };
+    return notifyManager.batch(() => {
+      queryCache.findAll(filters).forEach(query => {
+        query.reset();
+      });
+      return this.refetchQueries(refetchFilters, options);
+    });
+  }
+
+  cancelQueries(arg1, arg2, arg3) {
+    const [filters, cancelOptions = {}] = parseFilterArgs(arg1, arg2, arg3);
+
+    if (typeof cancelOptions.revert === 'undefined') {
+      cancelOptions.revert = true;
+    }
+
+    const promises = notifyManager.batch(() => this.queryCache.findAll(filters).map(query => query.cancel(cancelOptions)));
+    return Promise.all(promises).then(noop$1).catch(noop$1);
+  }
+
+  invalidateQueries(arg1, arg2, arg3) {
+    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
+    return notifyManager.batch(() => {
+      var _ref, _filters$refetchType;
+
+      this.queryCache.findAll(filters).forEach(query => {
+        query.invalidate();
+      });
+
+      if (filters.refetchType === 'none') {
+        return Promise.resolve();
+      }
+
+      const refetchFilters = { ...filters,
+        type: (_ref = (_filters$refetchType = filters.refetchType) != null ? _filters$refetchType : filters.type) != null ? _ref : 'active'
+      };
+      return this.refetchQueries(refetchFilters, options);
+    });
+  }
+
+  refetchQueries(arg1, arg2, arg3) {
+    const [filters, options] = parseFilterArgs(arg1, arg2, arg3);
+    const promises = notifyManager.batch(() => this.queryCache.findAll(filters).filter(query => !query.isDisabled()).map(query => {
+      var _options$cancelRefetc;
+
+      return query.fetch(undefined, { ...options,
+        cancelRefetch: (_options$cancelRefetc = options == null ? void 0 : options.cancelRefetch) != null ? _options$cancelRefetc : true,
+        meta: {
+          refetchPage: filters.refetchPage
+        }
+      });
+    }));
+    let promise = Promise.all(promises).then(noop$1);
+
+    if (!(options != null && options.throwOnError)) {
+      promise = promise.catch(noop$1);
+    }
+
+    return promise;
+  }
+
+  fetchQuery(arg1, arg2, arg3) {
+    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
+    const defaultedOptions = this.defaultQueryOptions(parsedOptions); // https://github.com/tannerlinsley/react-query/issues/652
+
+    if (typeof defaultedOptions.retry === 'undefined') {
+      defaultedOptions.retry = false;
+    }
+
+    const query = this.queryCache.build(this, defaultedOptions);
+    return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);
+  }
+
+  prefetchQuery(arg1, arg2, arg3) {
+    return this.fetchQuery(arg1, arg2, arg3).then(noop$1).catch(noop$1);
+  }
+
+  fetchInfiniteQuery(arg1, arg2, arg3) {
+    const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
+    parsedOptions.behavior = infiniteQueryBehavior();
+    return this.fetchQuery(parsedOptions);
+  }
+
+  prefetchInfiniteQuery(arg1, arg2, arg3) {
+    return this.fetchInfiniteQuery(arg1, arg2, arg3).then(noop$1).catch(noop$1);
+  }
+
+  resumePausedMutations() {
+    return this.mutationCache.resumePausedMutations();
+  }
+
+  getQueryCache() {
+    return this.queryCache;
+  }
+
+  getMutationCache() {
+    return this.mutationCache;
+  }
+
+  getLogger() {
+    return this.logger;
+  }
+
+  getDefaultOptions() {
+    return this.defaultOptions;
+  }
+
+  setDefaultOptions(options) {
+    this.defaultOptions = options;
+  }
+
+  setQueryDefaults(queryKey, options) {
+    const result = this.queryDefaults.find(x => hashQueryKey(queryKey) === hashQueryKey(x.queryKey));
+
+    if (result) {
+      result.defaultOptions = options;
+    } else {
+      this.queryDefaults.push({
+        queryKey,
+        defaultOptions: options
+      });
+    }
+  }
+
+  getQueryDefaults(queryKey) {
+    if (!queryKey) {
+      return undefined;
+    } // Get the first matching defaults
+
+
+    const firstMatchingDefaults = this.queryDefaults.find(x => partialMatchKey(queryKey, x.queryKey)); // Additional checks and error in dev mode
+
+    if (process.env.NODE_ENV !== 'production') {
+      // Retrieve all matching defaults for the given key
+      const matchingDefaults = this.queryDefaults.filter(x => partialMatchKey(queryKey, x.queryKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key
+
+      if (matchingDefaults.length > 1) {
+        this.logger.error("[QueryClient] Several query defaults match with key '" + JSON.stringify(queryKey) + "'. The first matching query defaults are used. Please check how query defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetquerydefaults.");
+      }
+    }
+
+    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
+  }
+
+  setMutationDefaults(mutationKey, options) {
+    const result = this.mutationDefaults.find(x => hashQueryKey(mutationKey) === hashQueryKey(x.mutationKey));
+
+    if (result) {
+      result.defaultOptions = options;
+    } else {
+      this.mutationDefaults.push({
+        mutationKey,
+        defaultOptions: options
+      });
+    }
+  }
+
+  getMutationDefaults(mutationKey) {
+    if (!mutationKey) {
+      return undefined;
+    } // Get the first matching defaults
+
+
+    const firstMatchingDefaults = this.mutationDefaults.find(x => partialMatchKey(mutationKey, x.mutationKey)); // Additional checks and error in dev mode
+
+    if (process.env.NODE_ENV !== 'production') {
+      // Retrieve all matching defaults for the given key
+      const matchingDefaults = this.mutationDefaults.filter(x => partialMatchKey(mutationKey, x.mutationKey)); // It is ok not having defaults, but it is error prone to have more than 1 default for a given key
+
+      if (matchingDefaults.length > 1) {
+        this.logger.error("[QueryClient] Several mutation defaults match with key '" + JSON.stringify(mutationKey) + "'. The first matching mutation defaults are used. Please check how mutation defaults are registered. Order does matter here. cf. https://react-query.tanstack.com/reference/QueryClient#queryclientsetmutationdefaults.");
+      }
+    }
+
+    return firstMatchingDefaults == null ? void 0 : firstMatchingDefaults.defaultOptions;
+  }
+
+  defaultQueryOptions(options) {
+    if (options != null && options._defaulted) {
+      return options;
+    }
+
+    const defaultedOptions = { ...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);
+    } // dependent default values
+
+
+    if (typeof defaultedOptions.refetchOnReconnect === 'undefined') {
+      defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== 'always';
+    }
+
+    if (typeof defaultedOptions.useErrorBoundary === 'undefined') {
+      defaultedOptions.useErrorBoundary = !!defaultedOptions.suspense;
+    }
+
+    return defaultedOptions;
+  }
+
+  defaultMutationOptions(options) {
+    if (options != null && options._defaulted) {
+      return options;
+    }
+
+    return { ...this.defaultOptions.mutations,
+      ...this.getMutationDefaults(options == null ? void 0 : options.mutationKey),
+      ...options,
+      _defaulted: true
+    };
+  }
+
+  clear() {
+    this.queryCache.clear();
+    this.mutationCache.clear();
+  }
+
+}
+
+class QueryObserver extends Subscribable {
+  constructor(client, options) {
+    super();
+    this.client = client;
+    this.options = options;
+    this.trackedProps = new Set();
+    this.selectError = null;
+    this.bindMethods();
+    this.setOptions(options);
+  }
+
+  bindMethods() {
+    this.remove = this.remove.bind(this);
+    this.refetch = this.refetch.bind(this);
+  }
+
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      this.currentQuery.addObserver(this);
+
+      if (shouldFetchOnMount(this.currentQuery, this.options)) {
+        this.executeFetch();
+      }
+
+      this.updateTimers();
+    }
+  }
+
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      this.destroy();
+    }
+  }
+
+  shouldFetchOnReconnect() {
+    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnReconnect);
+  }
+
+  shouldFetchOnWindowFocus() {
+    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnWindowFocus);
+  }
+
+  destroy() {
+    this.listeners = new Set();
+    this.clearStaleTimeout();
+    this.clearRefetchInterval();
+    this.currentQuery.removeObserver(this);
+  }
+
+  setOptions(options, notifyOptions) {
+    const prevOptions = this.options;
+    const prevQuery = this.currentQuery;
+    this.options = this.client.defaultQueryOptions(options);
+
+    if (process.env.NODE_ENV !== 'production' && typeof (options == null ? void 0 : options.isDataEqual) !== 'undefined') {
+      this.client.getLogger().error("The isDataEqual option has been deprecated and will be removed in the next major version. You can achieve the same functionality by passing a function as the structuralSharing option");
+    }
+
+    if (!shallowEqualObjects(prevOptions, this.options)) {
+      this.client.getQueryCache().notify({
+        type: 'observerOptionsUpdated',
+        query: this.currentQuery,
+        observer: this
+      });
+    }
+
+    if (typeof this.options.enabled !== 'undefined' && typeof this.options.enabled !== 'boolean') {
+      throw new Error('Expected enabled to be a boolean');
+    } // Keep previous query key if the user does not supply one
+
+
+    if (!this.options.queryKey) {
+      this.options.queryKey = prevOptions.queryKey;
+    }
+
+    this.updateQuery();
+    const 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();
+    }
+
+    const nextRefetchInterval = this.computeRefetchInterval(); // Update refetch interval if needed
+
+    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.currentRefetchInterval)) {
+      this.updateRefetchInterval(nextRefetchInterval);
+    }
+  }
+
+  getOptimisticResult(options) {
+    const query = this.client.getQueryCache().build(this.client, options);
+    const result = this.createResult(query, options);
+
+    if (shouldAssignObserverCurrentProperties(this, result, options)) {
+      // this assigns the optimistic result to the current Observer
+      // because if the query function changes, useQuery will be performing
+      // an effect where it would fetch again.
+      // When the fetch finishes, we perform a deep data cloning in order
+      // to reuse objects references. This deep data clone is performed against
+      // the `observer.currentResult.data` property
+      // When QueryKey changes, we refresh the query and get new `optimistic`
+      // result, while we leave the `observer.currentResult`, so when new data
+      // arrives, it finds the old `observer.currentResult` which is related
+      // to the old QueryKey. Which means that currentResult and selectData are
+      // out of sync already.
+      // To solve this, we move the cursor of the currentResult everytime
+      // an observer reads an optimistic value.
+      // When keeping the previous data, the result doesn't change until new
+      // data arrives.
+      this.currentResult = result;
+      this.currentResultOptions = this.options;
+      this.currentResultState = this.currentQuery.state;
+    }
+
+    return result;
+  }
+
+  getCurrentResult() {
+    return this.currentResult;
+  }
+
+  trackResult(result) {
+    const trackedResult = {};
+    Object.keys(result).forEach(key => {
+      Object.defineProperty(trackedResult, key, {
+        configurable: false,
+        enumerable: true,
+        get: () => {
+          this.trackedProps.add(key);
+          return result[key];
+        }
+      });
+    });
+    return trackedResult;
+  }
+
+  getCurrentQuery() {
+    return this.currentQuery;
+  }
+
+  remove() {
+    this.client.getQueryCache().remove(this.currentQuery);
+  }
+
+  refetch({
+    refetchPage,
+    ...options
+  } = {}) {
+    return this.fetch({ ...options,
+      meta: {
+        refetchPage
+      }
+    });
+  }
+
+  fetchOptimistic(options) {
+    const defaultedOptions = this.client.defaultQueryOptions(options);
+    const query = this.client.getQueryCache().build(this.client, defaultedOptions);
+    query.isFetchingOptimistic = true;
+    return query.fetch().then(() => this.createResult(query, defaultedOptions));
+  }
+
+  fetch(fetchOptions) {
+    var _fetchOptions$cancelR;
+
+    return this.executeFetch({ ...fetchOptions,
+      cancelRefetch: (_fetchOptions$cancelR = fetchOptions.cancelRefetch) != null ? _fetchOptions$cancelR : true
+    }).then(() => {
+      this.updateResult();
+      return this.currentResult;
+    });
+  }
+
+  executeFetch(fetchOptions) {
+    // Make sure we reference the latest query as the current one might have been removed
+    this.updateQuery(); // Fetch
+
+    let promise = this.currentQuery.fetch(this.options, fetchOptions);
+
+    if (!(fetchOptions != null && fetchOptions.throwOnError)) {
+      promise = promise.catch(noop$1);
+    }
+
+    return promise;
+  }
+
+  updateStaleTimeout() {
+    this.clearStaleTimeout();
+
+    if (isServer || this.currentResult.isStale || !isValidTimeout(this.options.staleTime)) {
+      return;
+    }
+
+    const 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.
+
+    const timeout = time + 1;
+    this.staleTimeoutId = setTimeout(() => {
+      if (!this.currentResult.isStale) {
+        this.updateResult();
+      }
+    }, timeout);
+  }
+
+  computeRefetchInterval() {
+    var _this$options$refetch;
+
+    return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.currentResult.data, this.currentQuery) : (_this$options$refetch = this.options.refetchInterval) != null ? _this$options$refetch : false;
+  }
+
+  updateRefetchInterval(nextInterval) {
+    this.clearRefetchInterval();
+    this.currentRefetchInterval = nextInterval;
+
+    if (isServer || this.options.enabled === false || !isValidTimeout(this.currentRefetchInterval) || this.currentRefetchInterval === 0) {
+      return;
+    }
+
+    this.refetchIntervalId = setInterval(() => {
+      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {
+        this.executeFetch();
+      }
+    }, this.currentRefetchInterval);
+  }
+
+  updateTimers() {
+    this.updateStaleTimeout();
+    this.updateRefetchInterval(this.computeRefetchInterval());
+  }
+
+  clearStaleTimeout() {
+    if (this.staleTimeoutId) {
+      clearTimeout(this.staleTimeoutId);
+      this.staleTimeoutId = undefined;
+    }
+  }
+
+  clearRefetchInterval() {
+    if (this.refetchIntervalId) {
+      clearInterval(this.refetchIntervalId);
+      this.refetchIntervalId = undefined;
+    }
+  }
+
+  createResult(query, options) {
+    const prevQuery = this.currentQuery;
+    const prevOptions = this.options;
+    const prevResult = this.currentResult;
+    const prevResultState = this.currentResultState;
+    const prevResultOptions = this.currentResultOptions;
+    const queryChange = query !== prevQuery;
+    const queryInitialState = queryChange ? query.state : this.currentQueryInitialState;
+    const prevQueryResult = queryChange ? this.currentResult : this.previousQueryResult;
+    const {
+      state
+    } = query;
+    let {
+      dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      fetchStatus,
+      status
+    } = state;
+    let isPreviousData = false;
+    let isPlaceholderData = false;
+    let data; // Optimistically set result in fetching state if needed
+
+    if (options._optimisticResults) {
+      const mounted = this.hasListeners();
+      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);
+      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);
+
+      if (fetchOnMount || fetchOptionally) {
+        fetchStatus = canFetch(query.options.networkMode) ? 'fetching' : 'paused';
+
+        if (!dataUpdatedAt) {
+          status = 'loading';
+        }
+      }
+
+      if (options._optimisticResults === 'isRestoring') {
+        fetchStatus = 'idle';
+      }
+    } // Keep previous data if needed
+
+
+    if (options.keepPreviousData && !state.dataUpdatedAt && prevQueryResult != null && prevQueryResult.isSuccess && status !== 'error') {
+      data = prevQueryResult.data;
+      dataUpdatedAt = prevQueryResult.dataUpdatedAt;
+      status = prevQueryResult.status;
+      isPreviousData = true;
+    } // Select data if needed
+    else if (options.select && typeof state.data !== 'undefined') {
+      // 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);
+          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);
+          this.selectResult = data;
+          this.selectError = null;
+        } catch (selectError) {
+          if (process.env.NODE_ENV !== 'production') {
+            this.client.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') {
+      let placeholderData; // Memoize placeholder data
+
+      if (prevResult != null && 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);
+            this.selectError = null;
+          } catch (selectError) {
+            if (process.env.NODE_ENV !== 'production') {
+              this.client.getLogger().error(selectError);
+            }
+
+            this.selectError = selectError;
+          }
+        }
+      }
+
+      if (typeof placeholderData !== 'undefined') {
+        status = 'success';
+        data = replaceData(prevResult == null ? void 0 : prevResult.data, placeholderData, options);
+        isPlaceholderData = true;
+      }
+    }
+
+    if (this.selectError) {
+      error = this.selectError;
+      data = this.selectResult;
+      errorUpdatedAt = Date.now();
+      status = 'error';
+    }
+
+    const isFetching = fetchStatus === 'fetching';
+    const isLoading = status === 'loading';
+    const isError = status === 'error';
+    const result = {
+      status,
+      fetchStatus,
+      isLoading,
+      isSuccess: status === 'success',
+      isError,
+      isInitialLoading: isLoading && isFetching,
+      data,
+      dataUpdatedAt,
+      error,
+      errorUpdatedAt,
+      failureCount: state.fetchFailureCount,
+      failureReason: state.fetchFailureReason,
+      errorUpdateCount: state.errorUpdateCount,
+      isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,
+      isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,
+      isFetching,
+      isRefetching: isFetching && !isLoading,
+      isLoadingError: isError && state.dataUpdatedAt === 0,
+      isPaused: fetchStatus === 'paused',
+      isPlaceholderData,
+      isPreviousData,
+      isRefetchError: isError && state.dataUpdatedAt !== 0,
+      isStale: isStale(query, options),
+      refetch: this.refetch,
+      remove: this.remove
+    };
+    return result;
+  }
+
+  updateResult(notifyOptions) {
+    const prevResult = this.currentResult;
+    const nextResult = this.createResult(this.currentQuery, this.options);
+    this.currentResultState = this.currentQuery.state;
+    this.currentResultOptions = this.options; // Only notify and update result if something has changed
+
+    if (shallowEqualObjects(nextResult, prevResult)) {
+      return;
+    }
+
+    this.currentResult = nextResult; // Determine which callbacks to trigger
+
+    const defaultNotifyOptions = {
+      cache: true
+    };
+
+    const shouldNotifyListeners = () => {
+      if (!prevResult) {
+        return true;
+      }
+
+      const {
+        notifyOnChangeProps
+      } = this.options;
+      const notifyOnChangePropsValue = typeof notifyOnChangeProps === 'function' ? notifyOnChangeProps() : notifyOnChangeProps;
+
+      if (notifyOnChangePropsValue === 'all' || !notifyOnChangePropsValue && !this.trackedProps.size) {
+        return true;
+      }
+
+      const includedProps = new Set(notifyOnChangePropsValue != null ? notifyOnChangePropsValue : this.trackedProps);
+
+      if (this.options.useErrorBoundary) {
+        includedProps.add('error');
+      }
+
+      return Object.keys(this.currentResult).some(key => {
+        const typedKey = key;
+        const changed = this.currentResult[typedKey] !== prevResult[typedKey];
+        return changed && includedProps.has(typedKey);
+      });
+    };
+
+    if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && shouldNotifyListeners()) {
+      defaultNotifyOptions.listeners = true;
+    }
+
+    this.notify({ ...defaultNotifyOptions,
+      ...notifyOptions
+    });
+  }
+
+  updateQuery() {
+    const query = this.client.getQueryCache().build(this.client, this.options);
+
+    if (query === this.currentQuery) {
+      return;
+    }
+
+    const prevQuery = this.currentQuery;
+    this.currentQuery = query;
+    this.currentQueryInitialState = query.state;
+    this.previousQueryResult = this.currentResult;
+
+    if (this.hasListeners()) {
+      prevQuery == null ? void 0 : prevQuery.removeObserver(this);
+      query.addObserver(this);
+    }
+  }
+
+  onQueryUpdate(action) {
+    const notifyOptions = {};
+
+    if (action.type === 'success') {
+      notifyOptions.onSuccess = !action.manual;
+    } else if (action.type === 'error' && !isCancelledError(action.error)) {
+      notifyOptions.onError = true;
+    }
+
+    this.updateResult(notifyOptions);
+
+    if (this.hasListeners()) {
+      this.updateTimers();
+    }
+  }
+
+  notify(notifyOptions) {
+    notifyManager.batch(() => {
+      // First trigger the configuration callbacks
+      if (notifyOptions.onSuccess) {
+        var _this$options$onSucce, _this$options, _this$options$onSettl, _this$options2;
+
+        (_this$options$onSucce = (_this$options = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options, this.currentResult.data);
+        (_this$options$onSettl = (_this$options2 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options2, this.currentResult.data, null);
+      } else if (notifyOptions.onError) {
+        var _this$options$onError, _this$options3, _this$options$onSettl2, _this$options4;
+
+        (_this$options$onError = (_this$options3 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options3, this.currentResult.error);
+        (_this$options$onSettl2 = (_this$options4 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options4, undefined, this.currentResult.error);
+      } // Then trigger the listeners
+
+
+      if (notifyOptions.listeners) {
+        this.listeners.forEach(({
+          listener
+        }) => {
+          listener(this.currentResult);
+        });
+      } // Then the cache listeners
+
+
+      if (notifyOptions.cache) {
+        this.client.getQueryCache().notify({
+          query: this.currentQuery,
+          type: 'observerResultsUpdated'
+        });
+      }
+    });
+  }
+
+}
+
+function shouldLoadOnMount(query, options) {
+  return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === 'error' && options.retryOnMount === false);
+}
+
+function shouldFetchOnMount(query, options) {
+  return shouldLoadOnMount(query, options) || query.state.dataUpdatedAt > 0 && shouldFetchOn(query, options, options.refetchOnMount);
+}
+
+function shouldFetchOn(query, options, field) {
+  if (options.enabled !== false) {
+    const value = typeof field === 'function' ? field(query) : field;
+    return value === 'always' || value !== false && isStale(query, options);
+  }
+
+  return false;
+}
+
+function shouldFetchOptionally(query, prevQuery, options, prevOptions) {
+  return options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== 'error') && isStale(query, options);
+}
+
+function isStale(query, options) {
+  return query.isStaleByTime(options.staleTime);
+} // this function would decide if we will update the observer's 'current'
+// properties after an optimistic reading via getOptimisticResult
+
+
+function shouldAssignObserverCurrentProperties(observer, optimisticResult, options) {
+  // it is important to keep this condition like this for three reasons:
+  // 1. It will get removed in the v5
+  // 2. it reads: don't update the properties if we want to keep the previous
+  // data.
+  // 3. The opposite condition (!options.keepPreviousData) would fallthrough
+  // and will result in a bad decision
+  if (options.keepPreviousData) {
+    return false;
+  } // this means we want to put some placeholder data when pending and queryKey
+  // changed.
+
+
+  if (options.placeholderData !== undefined) {
+    // re-assign properties only if current data is placeholder data
+    // which means that data did not arrive yet, so, if there is some cached data
+    // we need to "prepare" to receive it
+    return optimisticResult.isPlaceholderData;
+  } // if the newly created result isn't what the observer is holding as current,
+  // then we'll need to update the properties as well
+
+
+  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {
+    return true;
+  } // basically, just keep previous properties if nothing changed
+
+
+  return false;
+}
+
+class QueriesObserver extends Subscribable {
+  constructor(client, queries) {
+    super();
+    this.client = client;
+    this.queries = [];
+    this.result = [];
+    this.observers = [];
+    this.observersMap = {};
+
+    if (queries) {
+      this.setQueries(queries);
+    }
+  }
+
+  onSubscribe() {
+    if (this.listeners.size === 1) {
+      this.observers.forEach(observer => {
+        observer.subscribe(result => {
+          this.onUpdate(observer, result);
+        });
+      });
+    }
+  }
+
+  onUnsubscribe() {
+    if (!this.listeners.size) {
+      this.destroy();
+    }
+  }
+
+  destroy() {
+    this.listeners = new Set();
+    this.observers.forEach(observer => {
+      observer.destroy();
+    });
+  }
+
+  setQueries(queries, notifyOptions) {
+    this.queries = queries;
+    notifyManager.batch(() => {
+      const prevObservers = this.observers;
+      const newObserverMatches = this.findMatchingObservers(this.queries); // set options for the new observers to notify of changes
+
+      newObserverMatches.forEach(match => match.observer.setOptions(match.defaultedQueryOptions, notifyOptions));
+      const newObservers = newObserverMatches.map(match => match.observer);
+      const newObserversMap = Object.fromEntries(newObservers.map(observer => [observer.options.queryHash, observer]));
+      const newResult = newObservers.map(observer => observer.getCurrentResult());
+      const hasIndexChange = newObservers.some((observer, index) => observer !== prevObservers[index]);
+
+      if (prevObservers.length === newObservers.length && !hasIndexChange) {
+        return;
+      }
+
+      this.observers = newObservers;
+      this.observersMap = newObserversMap;
+      this.result = newResult;
+
+      if (!this.hasListeners()) {
+        return;
+      }
+
+      difference(prevObservers, newObservers).forEach(observer => {
+        observer.destroy();
+      });
+      difference(newObservers, prevObservers).forEach(observer => {
+        observer.subscribe(result => {
+          this.onUpdate(observer, result);
+        });
+      });
+      this.notify();
+    });
+  }
+
+  getCurrentResult() {
+    return this.result;
+  }
+
+  getQueries() {
+    return this.observers.map(observer => observer.getCurrentQuery());
+  }
+
+  getObservers() {
+    return this.observers;
+  }
+
+  getOptimisticResult(queries) {
+    return this.findMatchingObservers(queries).map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+  }
+
+  findMatchingObservers(queries) {
+    const prevObservers = this.observers;
+    const prevObserversMap = new Map(prevObservers.map(observer => [observer.options.queryHash, observer]));
+    const defaultedQueryOptions = queries.map(options => this.client.defaultQueryOptions(options));
+    const matchingObservers = defaultedQueryOptions.flatMap(defaultedOptions => {
+      const match = prevObserversMap.get(defaultedOptions.queryHash);
+
+      if (match != null) {
+        return [{
+          defaultedQueryOptions: defaultedOptions,
+          observer: match
+        }];
+      }
+
+      return [];
+    });
+    const matchedQueryHashes = new Set(matchingObservers.map(match => match.defaultedQueryOptions.queryHash));
+    const unmatchedQueries = defaultedQueryOptions.filter(defaultedOptions => !matchedQueryHashes.has(defaultedOptions.queryHash));
+    const matchingObserversSet = new Set(matchingObservers.map(match => match.observer));
+    const unmatchedObservers = prevObservers.filter(prevObserver => !matchingObserversSet.has(prevObserver));
+
+    const getObserver = options => {
+      const defaultedOptions = this.client.defaultQueryOptions(options);
+      const currentObserver = this.observersMap[defaultedOptions.queryHash];
+      return currentObserver != null ? currentObserver : new QueryObserver(this.client, defaultedOptions);
+    };
+
+    const newOrReusedObservers = unmatchedQueries.map((options, index) => {
+      if (options.keepPreviousData) {
+        // return previous data from one of the observers that no longer match
+        const previouslyUsedObserver = unmatchedObservers[index];
+
+        if (previouslyUsedObserver !== undefined) {
+          return {
+            defaultedQueryOptions: options,
+            observer: previouslyUsedObserver
+          };
+        }
+      }
+
+      return {
+        defaultedQueryOptions: options,
+        observer: getObserver(options)
+      };
+    });
+
+    const sortMatchesByOrderOfQueries = (a, b) => defaultedQueryOptions.indexOf(a.defaultedQueryOptions) - defaultedQueryOptions.indexOf(b.defaultedQueryOptions);
+
+    return matchingObservers.concat(newOrReusedObservers).sort(sortMatchesByOrderOfQueries);
+  }
+
+  onUpdate(observer, result) {
+    const index = this.observers.indexOf(observer);
+
+    if (index !== -1) {
+      this.result = replaceAt(this.result, index, result);
+      this.notify();
+    }
+  }
+
+  notify() {
+    notifyManager.batch(() => {
+      this.listeners.forEach(({
+        listener
+      }) => {
+        listener(this.result);
+      });
+    });
+  }
+
+}
+
+// CLASS
+class MutationObserver extends Subscribable {
+  constructor(client, options) {
+    super();
+    this.client = client;
+    this.setOptions(options);
+    this.bindMethods();
+    this.updateResult();
+  }
+
+  bindMethods() {
+    this.mutate = this.mutate.bind(this);
+    this.reset = this.reset.bind(this);
+  }
+
+  setOptions(options) {
+    var _this$currentMutation;
+
+    const prevOptions = this.options;
+    this.options = this.client.defaultMutationOptions(options);
+
+    if (!shallowEqualObjects(prevOptions, this.options)) {
+      this.client.getMutationCache().notify({
+        type: 'observerOptionsUpdated',
+        mutation: this.currentMutation,
+        observer: this
+      });
+    }
+
+    (_this$currentMutation = this.currentMutation) == null ? void 0 : _this$currentMutation.setOptions(this.options);
+  }
+
+  onUnsubscribe() {
+    if (!this.hasListeners()) {
+      var _this$currentMutation2;
+
+      (_this$currentMutation2 = this.currentMutation) == null ? void 0 : _this$currentMutation2.removeObserver(this);
+    }
+  }
+
+  onMutationUpdate(action) {
+    this.updateResult(); // Determine which callbacks to trigger
+
+    const notifyOptions = {
+      listeners: true
+    };
+
+    if (action.type === 'success') {
+      notifyOptions.onSuccess = true;
+    } else if (action.type === 'error') {
+      notifyOptions.onError = true;
+    }
+
+    this.notify(notifyOptions);
+  }
+
+  getCurrentResult() {
+    return this.currentResult;
+  }
+
+  reset() {
+    this.currentMutation = undefined;
+    this.updateResult();
+    this.notify({
+      listeners: true
+    });
+  }
+
+  mutate(variables, options) {
+    this.mutateOptions = options;
+
+    if (this.currentMutation) {
+      this.currentMutation.removeObserver(this);
     }
+
+    this.currentMutation = this.client.getMutationCache().build(this.client, { ...this.options,
+      variables: typeof variables !== 'undefined' ? variables : this.options.variables
+    });
+    this.currentMutation.addObserver(this);
+    return this.currentMutation.execute();
+  }
+
+  updateResult() {
+    const state = this.currentMutation ? this.currentMutation.state : getDefaultState();
+    const result = { ...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;
+  }
+
+  notify(options) {
+    notifyManager.batch(() => {
+      // First trigger the mutate callbacks
+      if (this.mutateOptions && this.hasListeners()) {
+        if (options.onSuccess) {
+          var _this$mutateOptions$o, _this$mutateOptions, _this$mutateOptions$o2, _this$mutateOptions2;
+
+          (_this$mutateOptions$o = (_this$mutateOptions = this.mutateOptions).onSuccess) == null ? void 0 : _this$mutateOptions$o.call(_this$mutateOptions, this.currentResult.data, this.currentResult.variables, this.currentResult.context);
+          (_this$mutateOptions$o2 = (_this$mutateOptions2 = this.mutateOptions).onSettled) == null ? void 0 : _this$mutateOptions$o2.call(_this$mutateOptions2, this.currentResult.data, null, this.currentResult.variables, this.currentResult.context);
+        } else if (options.onError) {
+          var _this$mutateOptions$o3, _this$mutateOptions3, _this$mutateOptions$o4, _this$mutateOptions4;
+
+          (_this$mutateOptions$o3 = (_this$mutateOptions3 = this.mutateOptions).onError) == null ? void 0 : _this$mutateOptions$o3.call(_this$mutateOptions3, this.currentResult.error, this.currentResult.variables, this.currentResult.context);
+          (_this$mutateOptions$o4 = (_this$mutateOptions4 = this.mutateOptions).onSettled) == null ? void 0 : _this$mutateOptions$o4.call(_this$mutateOptions4, undefined, this.currentResult.error, this.currentResult.variables, this.currentResult.context);
+        }
+      } // Then trigger the listeners
+
+
+      if (options.listeners) {
+        this.listeners.forEach(({
+          listener
+        }) => {
+          listener(this.currentResult);
+        });
+      }
+    });
+  }
+
 }
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -249,6 +3280,603 @@ function getAugmentedNamespace(n) {
 	return a;
 }
 
+var shim = {exports: {}};
+
+var useSyncExternalStoreShim_production_min = {};
+
+var require$$0$3 = /*@__PURE__*/getAugmentedNamespace(React);
+
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_production_min;
+
+function requireUseSyncExternalStoreShim_production_min () {
+	if (hasRequiredUseSyncExternalStoreShim_production_min) return useSyncExternalStoreShim_production_min;
+	hasRequiredUseSyncExternalStoreShim_production_min = 1;
+var e=require$$0$3;function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k="function"===typeof Object.is?Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;function q(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r(c)&&g({inst:c});},[a,d,b]);m(function(){r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c});})},[a]);p(d);return d}
+	function r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return !k(a,d)}catch(f){return  true}}function t(a,b){return b()}var u="undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement?t:q;useSyncExternalStoreShim_production_min.useSyncExternalStore=void 0!==e.useSyncExternalStore?e.useSyncExternalStore:u;
+	return useSyncExternalStoreShim_production_min;
+}
+
+var useSyncExternalStoreShim_development = {};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredUseSyncExternalStoreShim_development;
+
+function requireUseSyncExternalStoreShim_development () {
+	if (hasRequiredUseSyncExternalStoreShim_development) return useSyncExternalStoreShim_development;
+	hasRequiredUseSyncExternalStoreShim_development = 1;
+
+	if (process.env.NODE_ENV !== "production") {
+	  (function() {
+
+	/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+	if (
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+	    'function'
+	) {
+	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+	}
+	          var React = require$$0$3;
+
+	var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+	function error(format) {
+	  {
+	    {
+	      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+	        args[_key2 - 1] = arguments[_key2];
+	      }
+
+	      printWarning('error', format, args);
+	    }
+	  }
+	}
+
+	function printWarning(level, format, args) {
+	  // When changing this logic, you might want to also
+	  // update consoleWithStackDev.www.js as well.
+	  {
+	    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+	    var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+	    if (stack !== '') {
+	      format += '%s';
+	      args = args.concat([stack]);
+	    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+	    var argsWithFormat = args.map(function (item) {
+	      return String(item);
+	    }); // Careful: RN currently depends on this prefix
+
+	    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+	    // breaks IE9: https://github.com/facebook/react/issues/13610
+	    // eslint-disable-next-line react-internal/no-production-logging
+
+	    Function.prototype.apply.call(console[level], console, argsWithFormat);
+	  }
+	}
+
+	/**
+	 * inlined Object.is polyfill to avoid requiring consumers ship their own
+	 * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+	 */
+	function is(x, y) {
+	  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+	  ;
+	}
+
+	var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+	// dispatch for CommonJS interop named imports.
+
+	var useState = React.useState,
+	    useEffect = React.useEffect,
+	    useLayoutEffect = React.useLayoutEffect,
+	    useDebugValue = React.useDebugValue;
+	var didWarnOld18Alpha = false;
+	var didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
+	// because of a very particular set of implementation details and assumptions
+	// -- change any one of them and it will break. The most important assumption
+	// is that updates are always synchronous, because concurrent rendering is
+	// only available in versions of React that also have a built-in
+	// useSyncExternalStore API. And we only use this shim when the built-in API
+	// does not exist.
+	//
+	// Do not assume that the clever hacks used by this hook also work in general.
+	// The point of this shim is to replace the need for hacks by other libraries.
+
+	function useSyncExternalStore(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+	// React do not expose a way to check if we're hydrating. So users of the shim
+	// will need to track that themselves and return the correct value
+	// from `getSnapshot`.
+	getServerSnapshot) {
+	  {
+	    if (!didWarnOld18Alpha) {
+	      if (React.startTransition !== undefined) {
+	        didWarnOld18Alpha = true;
+
+	        error('You are using an outdated, pre-release alpha of React 18 that ' + 'does not support useSyncExternalStore. The ' + 'use-sync-external-store shim will not work correctly. Upgrade ' + 'to a newer pre-release.');
+	      }
+	    }
+	  } // Read the current snapshot from the store on every render. Again, this
+	  // breaks the rules of React, and only works here because of specific
+	  // implementation details, most importantly that updates are
+	  // always synchronous.
+
+
+	  var value = getSnapshot();
+
+	  {
+	    if (!didWarnUncachedGetSnapshot) {
+	      var cachedValue = getSnapshot();
+
+	      if (!objectIs(value, cachedValue)) {
+	        error('The result of getSnapshot should be cached to avoid an infinite loop');
+
+	        didWarnUncachedGetSnapshot = true;
+	      }
+	    }
+	  } // Because updates are synchronous, we don't queue them. Instead we force a
+	  // re-render whenever the subscribed state changes by updating an some
+	  // arbitrary useState hook. Then, during render, we call getSnapshot to read
+	  // the current value.
+	  //
+	  // Because we don't actually use the state returned by the useState hook, we
+	  // can save a bit of memory by storing other stuff in that slot.
+	  //
+	  // To implement the early bailout, we need to track some things on a mutable
+	  // object. Usually, we would put that in a useRef hook, but we can stash it in
+	  // our useState hook instead.
+	  //
+	  // To force a re-render, we call forceUpdate({inst}). That works because the
+	  // new object always fails an equality check.
+
+
+	  var _useState = useState({
+	    inst: {
+	      value: value,
+	      getSnapshot: getSnapshot
+	    }
+	  }),
+	      inst = _useState[0].inst,
+	      forceUpdate = _useState[1]; // Track the latest getSnapshot function with a ref. This needs to be updated
+	  // in the layout phase so we can access it during the tearing check that
+	  // happens on subscribe.
+
+
+	  useLayoutEffect(function () {
+	    inst.value = value;
+	    inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
+	    // commit phase if there was an interleaved mutation. In concurrent mode
+	    // this can happen all the time, but even in synchronous mode, an earlier
+	    // effect may have mutated the store.
+
+	    if (checkIfSnapshotChanged(inst)) {
+	      // Force a re-render.
+	      forceUpdate({
+	        inst: inst
+	      });
+	    }
+	  }, [subscribe, value, getSnapshot]);
+	  useEffect(function () {
+	    // Check for changes right before subscribing. Subsequent changes will be
+	    // detected in the subscription handler.
+	    if (checkIfSnapshotChanged(inst)) {
+	      // Force a re-render.
+	      forceUpdate({
+	        inst: inst
+	      });
+	    }
+
+	    var handleStoreChange = function () {
+	      // TODO: Because there is no cross-renderer API for batching updates, it's
+	      // up to the consumer of this library to wrap their subscription event
+	      // with unstable_batchedUpdates. Should we try to detect when this isn't
+	      // the case and print a warning in development?
+	      // The store changed. Check if the snapshot changed since the last time we
+	      // read from the store.
+	      if (checkIfSnapshotChanged(inst)) {
+	        // Force a re-render.
+	        forceUpdate({
+	          inst: inst
+	        });
+	      }
+	    }; // Subscribe to the store and return a clean-up function.
+
+
+	    return subscribe(handleStoreChange);
+	  }, [subscribe]);
+	  useDebugValue(value);
+	  return value;
+	}
+
+	function checkIfSnapshotChanged(inst) {
+	  var latestGetSnapshot = inst.getSnapshot;
+	  var prevValue = inst.value;
+
+	  try {
+	    var nextValue = latestGetSnapshot();
+	    return !objectIs(prevValue, nextValue);
+	  } catch (error) {
+	    return true;
+	  }
+	}
+
+	function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+	  // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+	  // React do not expose a way to check if we're hydrating. So users of the shim
+	  // will need to track that themselves and return the correct value
+	  // from `getSnapshot`.
+	  return getSnapshot();
+	}
+
+	var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+	var isServerEnvironment = !canUseDOM;
+
+	var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+	var useSyncExternalStore$2 = React.useSyncExternalStore !== undefined ? React.useSyncExternalStore : shim;
+
+	useSyncExternalStoreShim_development.useSyncExternalStore = useSyncExternalStore$2;
+	          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+	if (
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+	  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+	    'function'
+	) {
+	  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+	}
+	        
+	  })();
+	}
+	return useSyncExternalStoreShim_development;
+}
+
+if (process.env.NODE_ENV === 'production') {
+  shim.exports = requireUseSyncExternalStoreShim_production_min();
+} else {
+  shim.exports = requireUseSyncExternalStoreShim_development();
+}
+
+var shimExports = shim.exports;
+
+const useSyncExternalStore = shimExports.useSyncExternalStore;
+
+const defaultContext = /*#__PURE__*/React.createContext(undefined);
+const QueryClientSharingContext = /*#__PURE__*/React.createContext(false); // If we are given a context, we will use it.
+// Otherwise, if contextSharing is on, we share the first and at least one
+// instance of the context across the window
+// to ensure that if React Query is used across
+// different bundles or microfrontends they will
+// all use the same **instance** of context, regardless
+// of module scoping.
+
+function getQueryClientContext(context, contextSharing) {
+  if (context) {
+    return context;
+  }
+
+  if (contextSharing && typeof window !== 'undefined') {
+    if (!window.ReactQueryClientContext) {
+      window.ReactQueryClientContext = defaultContext;
+    }
+
+    return window.ReactQueryClientContext;
+  }
+
+  return defaultContext;
+}
+
+const useQueryClient = ({
+  context
+} = {}) => {
+  const queryClient = React.useContext(getQueryClientContext(context, React.useContext(QueryClientSharingContext)));
+
+  if (!queryClient) {
+    throw new Error('No QueryClient set, use QueryClientProvider to set one');
+  }
+
+  return queryClient;
+};
+const QueryClientProvider = ({
+  client,
+  children,
+  context,
+  contextSharing = false
+}) => {
+  React.useEffect(() => {
+    client.mount();
+    return () => {
+      client.unmount();
+    };
+  }, [client]);
+
+  if (process.env.NODE_ENV !== 'production' && contextSharing) {
+    client.getLogger().error("The contextSharing option has been deprecated and will be removed in the next major version");
+  }
+
+  const Context = getQueryClientContext(context, contextSharing);
+  return /*#__PURE__*/React.createElement(QueryClientSharingContext.Provider, {
+    value: !context && contextSharing
+  }, /*#__PURE__*/React.createElement(Context.Provider, {
+    value: client
+  }, children));
+};
+
+const IsRestoringContext = /*#__PURE__*/React.createContext(false);
+const useIsRestoring = () => React.useContext(IsRestoringContext);
+IsRestoringContext.Provider;
+
+function createValue() {
+  let isReset = false;
+  return {
+    clearReset: () => {
+      isReset = false;
+    },
+    reset: () => {
+      isReset = true;
+    },
+    isReset: () => {
+      return isReset;
+    }
+  };
+}
+
+const QueryErrorResetBoundaryContext = /*#__PURE__*/React.createContext(createValue()); // HOOK
+
+const useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext); // COMPONENT
+
+function shouldThrowError(_useErrorBoundary, params) {
+  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
+  if (typeof _useErrorBoundary === 'function') {
+    return _useErrorBoundary(...params);
+  }
+
+  return !!_useErrorBoundary;
+}
+
+const ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
+  if (options.suspense || options.useErrorBoundary) {
+    // Prevent retrying failed query if the error boundary has not been reset yet
+    if (!errorResetBoundary.isReset()) {
+      options.retryOnMount = false;
+    }
+  }
+};
+const useClearResetErrorBoundary = errorResetBoundary => {
+  React.useEffect(() => {
+    errorResetBoundary.clearReset();
+  }, [errorResetBoundary]);
+};
+const getHasError = ({
+  result,
+  errorResetBoundary,
+  useErrorBoundary,
+  query
+}) => {
+  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(useErrorBoundary, [result.error, query]);
+};
+
+const ensureStaleTime = defaultedOptions => {
+  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;
+    }
+  }
+};
+const willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;
+const shouldSuspend = (defaultedOptions, result, isRestoring) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && willFetch(result, isRestoring);
+const fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).then(({
+  data
+}) => {
+  defaultedOptions.onSuccess == null ? void 0 : defaultedOptions.onSuccess(data);
+  defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(data, null);
+}).catch(error => {
+  errorResetBoundary.clearReset();
+  defaultedOptions.onError == null ? void 0 : defaultedOptions.onError(error);
+  defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(undefined, error);
+});
+
+function useQueries({
+  queries,
+  context
+}) {
+  const queryClient = useQueryClient({
+    context
+  });
+  const isRestoring = useIsRestoring();
+  const errorResetBoundary = useQueryErrorResetBoundary();
+  const defaultedQueries = React.useMemo(() => queries.map(options => {
+    const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure the results are already in fetching state before subscribing or updating options
+
+    defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic';
+    return defaultedOptions;
+  }), [queries, queryClient, isRestoring]);
+  defaultedQueries.forEach(query => {
+    ensureStaleTime(query);
+    ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
+  });
+  useClearResetErrorBoundary(errorResetBoundary);
+  const [observer] = React.useState(() => new QueriesObserver(queryClient, defaultedQueries));
+  const optimisticResult = observer.getOptimisticResult(defaultedQueries);
+  useSyncExternalStore(React.useCallback(onStoreChange => isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+  React.useEffect(() => {
+    // 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]);
+  const shouldAtLeastOneSuspend = optimisticResult.some((result, index) => shouldSuspend(defaultedQueries[index], result, isRestoring));
+  const suspensePromises = shouldAtLeastOneSuspend ? optimisticResult.flatMap((result, index) => {
+    const options = defaultedQueries[index];
+    const queryObserver = observer.getObservers()[index];
+
+    if (options && queryObserver) {
+      if (shouldSuspend(options, result, isRestoring)) {
+        return fetchOptimistic(options, queryObserver, errorResetBoundary);
+      } else if (willFetch(result, isRestoring)) {
+        void fetchOptimistic(options, queryObserver, errorResetBoundary);
+      }
+    }
+
+    return [];
+  }) : [];
+
+  if (suspensePromises.length > 0) {
+    throw Promise.all(suspensePromises);
+  }
+
+  const observerQueries = observer.getQueries();
+  const firstSingleResultWhichShouldThrow = optimisticResult.find((result, index) => {
+    var _defaultedQueries$ind, _defaultedQueries$ind2;
+
+    return getHasError({
+      result,
+      errorResetBoundary,
+      useErrorBoundary: (_defaultedQueries$ind = (_defaultedQueries$ind2 = defaultedQueries[index]) == null ? void 0 : _defaultedQueries$ind2.useErrorBoundary) != null ? _defaultedQueries$ind : false,
+      query: observerQueries[index]
+    });
+  });
+
+  if (firstSingleResultWhichShouldThrow != null && firstSingleResultWhichShouldThrow.error) {
+    throw firstSingleResultWhichShouldThrow.error;
+  }
+
+  return optimisticResult;
+}
+
+function useBaseQuery(options, Observer) {
+  const queryClient = useQueryClient({
+    context: options.context
+  });
+  const isRestoring = useIsRestoring();
+  const errorResetBoundary = useQueryErrorResetBoundary();
+  const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options
+
+  defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic'; // Include callbacks in batch renders
+
+  if (defaultedOptions.onError) {
+    defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);
+  }
+
+  if (defaultedOptions.onSuccess) {
+    defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);
+  }
+
+  if (defaultedOptions.onSettled) {
+    defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);
+  }
+
+  ensureStaleTime(defaultedOptions);
+  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  useClearResetErrorBoundary(errorResetBoundary);
+  const [observer] = React.useState(() => new Observer(queryClient, defaultedOptions));
+  const result = observer.getOptimisticResult(defaultedOptions);
+  useSyncExternalStore(React.useCallback(onStoreChange => {
+    const unsubscribe = isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)); // Update result to make sure we did not miss any query updates
+    // between creating the observer and subscribing to it.
+
+    observer.updateResult();
+    return unsubscribe;
+  }, [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+  React.useEffect(() => {
+    // Do not notify on updates because of changes in the options because
+    // these changes should already be reflected in the optimistic result.
+    observer.setOptions(defaultedOptions, {
+      listeners: false
+    });
+  }, [defaultedOptions, observer]); // Handle suspense
+
+  if (shouldSuspend(defaultedOptions, result, isRestoring)) {
+    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);
+  } // Handle error boundary
+
+
+  if (getHasError({
+    result,
+    errorResetBoundary,
+    useErrorBoundary: defaultedOptions.useErrorBoundary,
+    query: observer.getCurrentQuery()
+  })) {
+    throw result.error;
+  } // Handle result property usage tracking
+
+
+  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;
+}
+
+function useQuery(arg1, arg2, arg3) {
+  const parsedOptions = parseQueryArgs(arg1, arg2, arg3);
+  return useBaseQuery(parsedOptions, QueryObserver);
+}
+
+function useMutation(arg1, arg2, arg3) {
+  const options = parseMutationArgs(arg1, arg2, arg3);
+  const queryClient = useQueryClient({
+    context: options.context
+  });
+  const [observer] = React.useState(() => new MutationObserver(queryClient, options));
+  React.useEffect(() => {
+    observer.setOptions(options);
+  }, [observer, options]);
+  const result = useSyncExternalStore(React.useCallback(onStoreChange => observer.subscribe(notifyManager.batchCalls(onStoreChange)), [observer]), () => observer.getCurrentResult(), () => observer.getCurrentResult());
+  const mutate = React.useCallback((variables, mutateOptions) => {
+    observer.mutate(variables, mutateOptions).catch(noop);
+  }, [observer]);
+
+  if (result.error && shouldThrowError(observer.options.useErrorBoundary, [result.error])) {
+    throw result.error;
+  }
+
+  return { ...result,
+    mutate,
+    mutateAsync: result.mutate
+  };
+} // eslint-disable-next-line @typescript-eslint/no-empty-function
+
+function noop() {}
+
+var TransactionErrorType;
+(function (TransactionErrorType) {
+    TransactionErrorType[TransactionErrorType["REJECTED_BY_USER"] = 0] = "REJECTED_BY_USER";
+    TransactionErrorType[TransactionErrorType["CALL_EXCEPTION"] = 1] = "CALL_EXCEPTION";
+    TransactionErrorType[TransactionErrorType["UNKNOWN"] = 2] = "UNKNOWN";
+    TransactionErrorType[TransactionErrorType["WARNING"] = 3] = "WARNING";
+})(TransactionErrorType || (TransactionErrorType = {}));
+var SquidStatusErrorType;
+(function (SquidStatusErrorType) {
+    SquidStatusErrorType["NotFoundError"] = "NotFoundError";
+})(SquidStatusErrorType || (SquidStatusErrorType = {}));
+class QrCodeGenerationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "QrCodeGenerationError";
+    }
+}
+
 /**
  * The base implementation of `_.slice` without an iteratee call guard.
  *
@@ -20096,17 +23724,14 @@ function isXrplAddressValid(address) {
     return isValidXAddress(address) || isValidClassicAddress(address);
 }
 function buildXrplTrustSetTx({ amount, sourceAddress, token, }) {
-    const asset = parseXrplTokenAddress(token.address);
-    if (!asset) {
-        throw new Error("Invalid asset");
-    }
+    const [currency, issuer] = token.address.split(".");
     return {
         TransactionType: XrplTransactionType.TRUST_SET,
         Flags: XrplTransactionFlag.tfSetNoRipple,
         Account: sourceAddress,
         LimitAmount: {
-            currency: asset.code,
-            issuer: asset.issuer,
+            currency,
+            issuer,
             value: amount,
         },
     };
@@ -20135,16 +23760,6 @@ function parseXrplPaymentTx(data) {
         throw new Error("Could not parse payment transaction");
     }
 }
-function parseXrplTokenAddress(address) {
-    const [code, issuer] = address.split(".");
-    if (!code || !issuer) {
-        return null;
-    }
-    return {
-        code,
-        issuer,
-    };
-}
 
 const chains = [XrplCAIP2ChainId.MAINNET, XrplCAIP2ChainId.TESTNET];
 class XrplWalletConnect {
@@ -21110,28 +24725,6 @@ const executeSolanaTransfer = async ({ amount, target, signer, connection, sourc
     return signature;
 };
 
-var StellarHorizonAssetType;
-(function (StellarHorizonAssetType) {
-    /**
-     * XLM native token
-     */
-    StellarHorizonAssetType["NATIVE"] = "native";
-    /**
-     * 1-4 char asset code (e.g. USDC)
-     */
-    StellarHorizonAssetType["ALPHANUM4"] = "credit_alphanum4";
-    /**
-     * 5-12 char asset code (e.g. wstETH)
-     */
-    StellarHorizonAssetType["ALPHANUM12"] = "credit_alphanum12";
-})(StellarHorizonAssetType || (StellarHorizonAssetType = {}));
-var StellarTokenType;
-(function (StellarTokenType) {
-    StellarTokenType["NATIVE_TOKEN"] = "nativeToken";
-    StellarTokenType["ISSUER_TOKEN"] = "issuerToken";
-    StellarTokenType["CONTRACT_TOKEN"] = "contractToken";
-})(StellarTokenType || (StellarTokenType = {}));
-
 function isStellarAddressValid(address) {
     return StrKey.isValidEd25519PublicKey(address);
 }
@@ -21153,78 +24746,6 @@ function stellarAddressToScVal(addressString) {
         type: "address",
     });
 }
-function getStellarTrustLineAsset(token) {
-    // The address format for issued assets is `CODE-ISSUER`
-    // Example: USDC-GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN
-    const [code, issuer] = token.address.split("-");
-    if (!code || !issuer) {
-        return null;
-    }
-    return {
-        code,
-        issuer,
-    };
-}
-function isStellarToken(token) {
-    try {
-        const stellarToken = token;
-        return (Object.values(StellarTokenType).includes(stellarToken.chainAssetConfig.stellar.assetType) &&
-            typeof stellarToken.chainAssetConfig.stellar.contractAddress === "string");
-    }
-    catch {
-        return false;
-    }
-}
-function isStellarIssuedToken(token) {
-    try {
-        return (isStellarToken(token) &&
-            token.chainAssetConfig.stellar.assetType === StellarTokenType.ISSUER_TOKEN);
-    }
-    catch {
-        return false;
-    }
-}
-function getStellarHorizonApiUrl(chain) {
-    try {
-        const stellarChain = chain;
-        const [horizonApiUrl] = stellarChain.horizonRpcList;
-        if (typeof horizonApiUrl !== "string") {
-            throw new Error("Invalid Horizon API URL");
-        }
-        return horizonApiUrl;
-    }
-    catch {
-        return null;
-    }
-}
-const VALID_ASSET_TYPES = new Set(Object.values(StellarHorizonAssetType));
-function isValidNativeAsset(asset) {
-    return (typeof asset === "object" &&
-        asset !== null &&
-        "balance" in asset &&
-        typeof asset.balance === "string" &&
-        "asset_type" in asset &&
-        asset.asset_type === StellarHorizonAssetType.NATIVE);
-}
-function isValidIssuedAsset(asset) {
-    return (typeof asset === "object" &&
-        asset !== null &&
-        "balance" in asset &&
-        typeof asset.balance === "string" &&
-        "asset_type" in asset &&
-        typeof asset.asset_type === "string" &&
-        VALID_ASSET_TYPES.has(asset.asset_type) &&
-        asset.asset_type !== StellarHorizonAssetType.NATIVE &&
-        "asset_code" in asset &&
-        typeof asset.asset_code === "string" &&
-        "asset_issuer" in asset &&
-        typeof asset.asset_issuer === "string" &&
-        "limit" in asset &&
-        typeof asset.limit === "string");
-}
-function isValidHorizonAsset(asset) {
-    return isValidNativeAsset(asset) || isValidIssuedAsset(asset);
-}
 
 const SUI_FEATURES = ["sui:signTransaction"];
 function isSuiStandardWallet(wallet) {
@@ -22303,8 +25824,6 @@ var QueryKeys;
     QueryKeys["XrplAccountActivatedInfo"] = "xrplAccountActivatedInfo";
     QueryKeys["FiatToCryptoPaymentMethods"] = "fiatToCryptoPaymentMethods";
     QueryKeys["Stellar"] = "stellar";
-    QueryKeys["StellarTrustLine"] = "stellarTrustLine";
-    QueryKeys["IsStellarTrustLineApproved"] = "isStellarTrustLineApproved";
     QueryKeys["StellarAccountActivatedInfo"] = "stellarAccountActivatedInfo";
     QueryKeys["Hedera"] = "hedera";
     QueryKeys["IsHederaTokenAssociated"] = "isHederaTokenAssociated";
@@ -22412,7 +25931,7 @@ const keys = () => ({
     // ============
     // Approval
     // ============
-    routeApproved: (routeData, allowanceInWei, isAllowanceQueryEnabled, hasAllowance) => [
+    routeApproved: (routeData, allowanceInWei) => [
         ...keys().transactions(),
         QueryKeys.RouteApproved,
         routeData?.params.fromAddress,
@@ -22420,8 +25939,6 @@ const keys = () => ({
         routeData?.params.fromToken,
         routeData?.params.fromAmount,
         allowanceInWei?.toString(),
-        isAllowanceQueryEnabled,
-        hasAllowance,
     ],
     sendTransactionGas: (chainId, tokenAddress, from) => [
         QueryKeys.All,
@@ -22494,23 +26011,6 @@ const keys = () => ({
     // ============
     // Stellar
     // ============
-    stellarTrustLine: (tokenAddress, chainId, address) => [
-        ...keys().stellar(),
-        QueryKeys.StellarTrustLine,
-        tokenAddress,
-        chainId,
-        address,
-    ],
-    isStellarTrustLineApproved: (address, chainId, chainType, tokenAddress, trustLineLimit, amountToApprove) => [
-        ...keys().stellar(),
-        QueryKeys.IsStellarTrustLineApproved,
-        address,
-        chainId,
-        chainType,
-        tokenAddress,
-        trustLineLimit,
-        amountToApprove?.toString(),
-    ],
     stellarAccountActivatedInfo: (address, chainId, chainType) => [
         ...keys().stellar(),
         QueryKeys.StellarAccountActivatedInfo,
@@ -22546,8 +26046,6 @@ const getPrefixKey = (key) => {
             return [...keys().transactions(), key];
         case QueryKeys.XrplTrustLine:
             return [...keys().xrpl(), key];
-        case QueryKeys.StellarTrustLine:
-            return [...keys().stellar(), key];
         case QueryKeys.IsHederaTokenAssociated:
             return [...keys().hedera(), key];
         default:
@@ -23262,7 +26760,7 @@ const filterViewableTokens = (tokens, config, direction) => {
 };
 const getSecretNetworkBalances = async (chainData, cosmosAddress, squidTokens, keplrTypeWallet) => {
     const squidSecretTokens = squidTokens.filter((t) => t.chainId === CHAIN_IDS.SECRET);
-    const { fetchAllSecretBalances } = await import('./secretService-D8hWz2Gz.js');
+    const { fetchAllSecretBalances } = await import('./secretService-BwFxfXV7.js');
     return fetchAllSecretBalances(chainData, cosmosAddress, squidSecretTokens, keplrTypeWallet);
 };
 function getTokenAssetsKey(token) {
@@ -26326,7 +29824,7 @@ function useBitcoin() {
 const BitcoinContext = createContext(undefined);
 const BitcoinProvider = ({ children, }) => {
     const bitcoinContext = useBitcoin();
-    return (React.createElement(BitcoinContext.Provider, { value: bitcoinContext }, children));
+    return (React__default.createElement(BitcoinContext.Provider, { value: bitcoinContext }, children));
 };
 const useBitcoinContext = () => {
     const context = useContext(BitcoinContext);
@@ -26411,7 +29909,7 @@ function useEvm() {
 const EvmContext = createContext(undefined);
 const EvmProvider = ({ children, }) => {
     const evmContext = useEvm();
-    return (React.createElement(EvmContext.Provider, { value: evmContext }, children));
+    return (React__default.createElement(EvmContext.Provider, { value: evmContext }, children));
 };
 const useEvmContext = () => {
     const context = useContext(EvmContext);
@@ -26528,7 +30026,7 @@ const useSolanaConnection = () => {
 const SolanaContext = createContext(undefined);
 const SolanaProvider = ({ children, }) => {
     const solanaHook = useSolana();
-    return (React.createElement(SolanaContext.Provider, { value: solanaHook }, children));
+    return (React__default.createElement(SolanaContext.Provider, { value: solanaHook }, children));
 };
 const useSolanaContext = () => {
     const context = useContext(SolanaContext);
@@ -26547,7 +30045,7 @@ function useStellarWallets() {
             try {
                 const { allowAllModules: initializeAllModules } = await import('@creit.tech/stellar-wallets-kit');
                 const { LedgerModule } = await import('@creit.tech/stellar-wallets-kit/modules/ledger.module');
-                const { formatStellarWallet } = await import('./stellarService.client-Dve9IZZm.js');
+                const { formatStellarWallet } = await import('./stellarService.client-OMPy5fjH.js');
                 const modules = [...initializeAllModules(), new LedgerModule()];
                 const promises = modules.map(async (module) => {
                     const isAvailable = await module.isAvailable();
@@ -26596,7 +30094,7 @@ function useStellar() {
 const StellarContext = createContext(undefined);
 const StellarProvider = ({ children, }) => {
     const stellarContext = useStellar();
-    return (React.createElement(StellarContext.Provider, { value: stellarContext }, children));
+    return (React__default.createElement(StellarContext.Provider, { value: stellarContext }, children));
 };
 const useStellarContext = () => {
     const context = useContext(StellarContext);
@@ -26705,7 +30203,7 @@ function useSui() {
 const SuiContext = createContext(undefined);
 const SuiProvider = ({ children, }) => {
     const suiContext = useSui();
-    return (React.createElement(SuiContext.Provider, { value: suiContext }, children));
+    return (React__default.createElement(SuiContext.Provider, { value: suiContext }, children));
 };
 const useSuiContext = () => {
     const context = useContext(SuiContext);
@@ -27003,7 +30501,7 @@ function useXrpl() {
 const XrplContext = createContext(undefined);
 const XrplProvider = ({ children, }) => {
     const xrplContext = useXrpl();
-    return (React.createElement(XrplContext.Provider, { value: xrplContext }, children));
+    return (React__default.createElement(XrplContext.Provider, { value: xrplContext }, children));
 };
 const useXrplContext = () => {
     const context = useContext(XrplContext);
@@ -27823,15 +31321,15 @@ function useCosmosSigner({ chain }) {
     return { signer, keplrTypeWallet: connector };
 }
 
-const CosmosContext = React.createContext({
+const CosmosContext = React__default.createContext({
     getCosmosAddressForChain: async () => "",
 });
 const CosmosProvider = ({ children }) => {
     const cosmosContext = useCosmos();
-    return (React.createElement(CosmosContext.Provider, { value: cosmosContext }, children));
+    return (React__default.createElement(CosmosContext.Provider, { value: cosmosContext }, children));
 };
 function useCosmosContext() {
-    return React.useContext(CosmosContext);
+    return React__default.useContext(CosmosContext);
 }
 
 /**
@@ -28047,7 +31545,7 @@ function hederaWalletConnect(parameters) {
                 const optionalChains = config.chains.map((x) => x.id);
                 if (!optionalChains.length)
                     return;
-                const { EthereumProvider } = await import('./index.es-CMuCSzqv.js');
+                const { EthereumProvider } = await import('./index.es-C4uVlA0B.js');
                 const rawProvider = await EthereumProvider.init({
                     ...restParameters,
                     disableProviderPing: true,
@@ -29410,15 +32908,12 @@ const getAllXrplTokensBalance = async (userAddress, xrplTokens, xrplChains) => {
 };
 const getStellarTokenBalance = async (userAddress, token, chain) => {
     const stellarClient = await getClient(chain);
-    if (!isStellarToken(token)) {
-        throw new Error("Token must be a Stellar token");
-    }
-    const balance = await stellarClient.getBalance(userAddress, token.chainAssetConfig.stellar.contractAddress, chain.chainId);
+    const balance = await stellarClient.getBalance(userAddress, token.address, chain.chainId);
     return BigInt(balance);
 };
 const getAllStellarTokensBalance = async (userAddress, stellarTokens, stellarChains) => {
     const getBalancesForChain = async (chain) => {
-        const tokensForChain = stellarTokens.filter((t) => t.chainId === chain.chainId && isStellarToken(t));
+        const tokensForChain = stellarTokens.filter((t) => t.chainId === chain.chainId);
         const stellarClient = await getClient(chain);
         const allBalances = await stellarClient.getAllBalances(userAddress, tokensForChain);
         return allBalances.map((token) => {
@@ -29473,7 +32968,7 @@ class StellarRpcClient {
             .build();
         const simulateTxResponse = await this.server.simulateTransaction(tx);
         if ("error" in simulateTxResponse) {
-            const isNoBalanceError = /trying to get non-existing value for contract instance|trustline entry is missing for account/.test(simulateTxResponse.error);
+            const isNoBalanceError = simulateTxResponse.error.includes("trying to get non-existing value for contract instance");
             // If the error message indicates that the user has no balance just return 0
             // We don't want to spam with this error as it's pretty common
             if (isNoBalanceError) {
@@ -29489,7 +32984,7 @@ class StellarRpcClient {
     }
     async getAllBalances(userAddress, tokens) {
         const balancePromises = tokens.map((token) => {
-            return this.getBalance(userAddress, token.chainAssetConfig.stellar.contractAddress, token.chainId);
+            return this.getBalance(userAddress, token.address, token.chainId);
         });
         const results = await Promise.allSettled(balancePromises);
         const balances = results.map((result) => {
@@ -29589,9 +33084,9 @@ class XrplRpcClient {
             },
         ]);
     }
-    async getTrustLine(address, asset) {
-        const response = await this.getTrustLines(address, asset.issuer);
-        const trustLine = response.lines.find((line) => line.currency === asset.code);
+    async getTrustLine(address, issuer, currency) {
+        const response = await this.getTrustLines(address, issuer);
+        const trustLine = response.lines.find((line) => line.currency === currency);
         return trustLine ?? null;
     }
     async accountActivatedInfo(address) {
@@ -29767,26 +33262,9 @@ class StellarApiClient {
         const baseReserveBn = BigInt(latestLedger.base_reserve_in_stroops);
         return baseReserveBn;
     }
-    async getTrustLines(userAddress) {
-        const response = await fetch(`${this.apiUrl}/accounts/${userAddress}`);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch account data: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (!Array.isArray(data?.balances)) {
-            throw new Error("Invalid response from Horizon API");
-        }
-        const assets = data.balances.filter(isValidHorizonAsset);
-        return assets.filter(isValidIssuedAsset);
-    }
-    async getTrustLine(address, asset) {
-        const trustLines = await this.getTrustLines(address);
-        const trustLine = trustLines.find((line) => line.asset_code === asset.code && line.asset_issuer === asset.issuer);
-        return trustLine ?? null;
-    }
 }
 
-const DEFAULT_REFETCH_INTERVAL$2 = 20_000;
+const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
 function useStellarAccountActivation({ address, chain, token, }) {
     /**
      * Checks if the destination account exists on the Stellar network
@@ -29802,8 +33280,9 @@ function useStellarAccountActivation({ address, chain, token, }) {
             if (!address) {
                 throw new Error("Destination address is required");
             }
-            const horizonApiUrl = getStellarHorizonApiUrl(chain);
-            if (!horizonApiUrl) {
+            // TODO: update types
+            const [horizonApiUrl] = chain?.horizonRpcList;
+            if (typeof horizonApiUrl !== "string") {
                 throw new Error("Invalid Horizon API URL");
             }
             const stellarApiClient = new StellarApiClient(horizonApiUrl);
@@ -29819,7 +33298,7 @@ function useStellarAccountActivation({ address, chain, token, }) {
             };
         },
         enabled: !!address && chain?.chainType === ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$2,
+        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
         refetchOnWindowFocus: true,
     });
     return {
@@ -29827,149 +33306,6 @@ function useStellarAccountActivation({ address, chain, token, }) {
     };
 }
 
-/**
- * Maximum asset amount on Stellar
- * @see https://developers.stellar.org/docs/learn/fundamentals/stellar-data-structures/assets#amount-precision
- */
-const MAX_ASSET_AMOUNT = "922337203685.4775807";
-const DEFAULT_REFETCH_INTERVAL$1 = 20_000;
-function useStellarTrustLine({ address, chain, token, amount }) {
-    const { stellarSigner } = useSigner({ chain });
-    const queryClient = useQueryClient();
-    /**
-     * Retrieves the destination account's trust line data for the given token
-     */
-    const trustLineQuery = useQuery({
-        queryKey: keys().stellarTrustLine(token?.address, chain?.chainId, address),
-        queryFn: async () => {
-            if (chain?.chainType !== ChainType.STELLAR ||
-                token?.type !== ChainType.STELLAR) {
-                return null;
-            }
-            if (!address || !isStellarAddressValid(address)) {
-                return null;
-            }
-            // Only issued tokens require trust lines
-            // Other token types like contract tokens don't need trust lines
-            if (!isStellarIssuedToken(token)) {
-                return null;
-            }
-            const asset = getStellarTrustLineAsset(token);
-            if (!asset) {
-                throw new Error("Invalid asset");
-            }
-            const horizonApiUrl = getStellarHorizonApiUrl(chain);
-            if (!horizonApiUrl) {
-                throw new Error("Invalid Horizon API URL");
-            }
-            const stellarApiClient = new StellarApiClient(horizonApiUrl);
-            return stellarApiClient.getTrustLine(address, asset);
-        },
-        enabled: !!address &&
-            chain?.chainType === ChainType.STELLAR &&
-            token?.type === ChainType.STELLAR,
-        refetchInterval: DEFAULT_REFETCH_INTERVAL$1,
-    });
-    /**
-     * Creates a trust line where the destination account authorizes to receive the given token
-     */
-    const createTrustLine = useMutation({
-        mutationFn: async () => {
-            try {
-                if (!stellarSigner) {
-                    throw new Error("Stellar signer not found");
-                }
-                if (!address) {
-                    throw new Error("Destination address is required");
-                }
-                if (chain?.chainType !== ChainType.STELLAR ||
-                    token?.type !== ChainType.STELLAR) {
-                    throw new Error("Chain and token to approve must be a Stellar token");
-                }
-                if (!isStellarIssuedToken(token)) {
-                    throw new Error("Token must be a Stellar issued token");
-                }
-                const assetInfo = getStellarTrustLineAsset(token);
-                if (!assetInfo) {
-                    throw new Error("Invalid asset");
-                }
-                const network = getStellarNetwork(chain.chainId);
-                if (network == null) {
-                    throw new Error(`Stellar network not found for chain ${chain.chainId}`);
-                }
-                const client = await getClient(chain);
-                const account = await client.getAccount(address);
-                const asset = new Asset(assetInfo.code, assetInfo.issuer);
-                const changeTrustOperation = Operation.changeTrust({
-                    asset,
-                    limit: MAX_ASSET_AMOUNT,
-                });
-                const builtTransaction = new TransactionBuilder(account, {
-                    fee: (BigInt(BASE_FEE) * BigInt(2)).toString(),
-                    networkPassphrase: network,
-                })
-                    .addOperation(changeTrustOperation)
-                    .setTimeout(300)
-                    .build();
-                const { signedTxXdr } = await stellarSigner.signTransaction(builtTransaction.toXDR(), {
-                    networkPassphrase: network,
-                });
-                const signedTransaction = new Transaction$1(signedTxXdr, network);
-                const sentTransaction = await client.sendTransaction(signedTransaction);
-                const txStatus = await client.waitForTransaction(sentTransaction.hash, {
-                    interval: 1_000,
-                });
-                if (txStatus !== rpc.Api.GetTransactionStatus.SUCCESS) {
-                    throw new Error(`Transaction failed with status: ${txStatus}`);
-                }
-                return true;
-            }
-            catch (error) {
-                console.error("Error creating trust line:", error);
-                return false;
-            }
-        },
-        async onSuccess() {
-            queryClient.invalidateQueries({
-                queryKey: getPrefixKey(QueryKeys.StellarTrustLine),
-            });
-        },
-    });
-    /**
-     * Checks if the destination account has created a trust line to receive the given token.
-     */
-    const isTrustLineApproved = useQuery({
-        queryKey: keys().isStellarTrustLineApproved(address, token?.chainId, token?.type, token?.address, trustLineQuery.data?.limit, amount),
-        queryFn: async () => {
-            if (token?.type !== ChainType.STELLAR) {
-                return true;
-            }
-            // The native Stellar token doesn't need a trust line
-            if (token.address.toLowerCase() === nativeStellarTokenAddress.toLowerCase()) {
-                return true;
-            }
-            if (!amount) {
-                throw new Error("Amount is required");
-            }
-            const limitBn = BigNumber$1(trustLineQuery.data?.limit || "0");
-            const balanceBn = BigNumber$1(trustLineQuery.data?.balance || "0");
-            const availableAllowanceBn = limitBn.minus(balanceBn);
-            const amountBn = BigNumber$1(formatBNToReadable(amount, token.decimals));
-            return availableAllowanceBn.gte(amountBn);
-        },
-        enabled: !!address &&
-            !!amount &&
-            !trustLineQuery?.isLoading &&
-            trustLineQuery?.isFetched &&
-            token?.type === ChainType.STELLAR,
-    });
-    return {
-        createTrustLine,
-        trustLineQuery,
-        isTrustLineApproved,
-    };
-}
-
 const useAddressBookStore = create(persist((set) => ({
     addressBook: [],
     add: (newAddressData) => {
@@ -31592,18 +34928,15 @@ async function sendTransactionXrpl({ amount, signer, to, token, from, }) {
             txHash: hash,
         };
     }
-    const asset = parseXrplTokenAddress(token.address);
-    if (!asset) {
-        throw new Error("Invalid asset");
-    }
+    const [currency, issuer] = token.address.split(".");
     const amountFormatted = formatBNToReadable(amount, token.decimals);
     const { hash } = await signer.signAndSubmit({
         network: xrplNetwork,
         tx: {
             ...baseTransaction,
             Amount: {
-                currency: asset.code,
-                issuer: asset.issuer,
+                currency,
+                issuer,
                 value: amountFormatted,
             },
         },
@@ -32336,7 +35669,7 @@ const useApproval = ({ squidRoute, }) => {
      * On Error: Showing the error message if any
      * @returns {boolean} approved
      */
-    const routeApproved = useQuery(keys().routeApproved(squidRoute, allowanceInWei, erc20AllowanceQueryEnabled, hasAllowance), async () => {
+    const routeApproved = useQuery(keys().routeApproved(squidRoute, allowanceInWei), async () => {
         if (erc20AllowanceQueryEnabled) {
             return hasAllowance;
         }
@@ -36844,12 +40177,12 @@ function useXrplTrustLine({ address, chain, token, amount }) {
             if (!address || !isXrplAddressValid(address)) {
                 return null;
             }
-            const trustLineAsset = parseXrplTokenAddress(token.address);
-            if (!trustLineAsset) {
+            const [currency, issuer] = token.address.split(".");
+            if (!currency || !issuer) {
                 return null;
             }
             const xrplClient = await getClient(chain);
-            const trustLine = await xrplClient.getTrustLine(address, trustLineAsset);
+            const trustLine = await xrplClient.getTrustLine(address, issuer, currency);
             return trustLine;
         },
         enabled: !!address &&
@@ -37076,16 +40409,16 @@ const SquidProvider = ({ children, config, placeholder, }) => {
     useEffect(() => {
         initializeSdk();
     }, [initializeSdk]);
-    return wagmiConfig ? (React.createElement(WagmiProvider, { reconnectOnMount: false, config: wagmiConfig },
-        React.createElement(QueryClientProvider, { client: queryClient },
-            React.createElement(StellarProvider, null,
-                React.createElement(EvmProvider, null,
-                    React.createElement(XrplProvider, null,
-                        React.createElement(SuiProvider, null,
-                            React.createElement(SolanaProvider, null,
-                                React.createElement(BitcoinProvider, null,
-                                    React.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
-};
-
-export { useAllConnectedWalletBalances as $, AxelarStatusResponseType as A, useSquidQueryClient as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useSquid as E, useStellarAccountActivation as F, useStellarTrustLine as G, HistoryTxType as H, useAddressBookStore as I, useAssetsColorsStore as J, useFavoriteTokensStore as K, useHistoryStore as L, useSendTransactionStore as M, Nr as N, useConfigStore as O, useSquidStore as P, QueryKeys as Q, useSwapRoutePersistStore as R, SquidStatusErrorType as S, TransactionErrorType as T, useTransactionStore as U, ConnectingWalletStatus as V, Wo as W, XamanXrplNetwork as X, useWalletStore as Y, useDepositAddress as Z, useSwap as _, WindowWalletFlag as a, getSupportedChainIdsForDirection as a$, useAllTokensWithBalanceForChainType as a0, useCosmosBalance as a1, useEvmBalance as a2, useMultiChainBalance as a3, useMultipleTokenPrices as a4, useNativeBalance as a5, useNativeTokenForChain as a6, useSingleTokenPrice as a7, useSquidTokens as a8, useHistoricalData as a9, useSigner as aA, useWallet as aB, useWallets as aC, useXrplTrustLine as aD, TX_STATUS_CONSTANTS as aE, FINAL_TRANSACTION_STATUSES as aF, useGetFiatQuote as aG, useGetOnRampConfig as aH, useExecuteFiatQuote as aI, useFiatOnRampTxStatus as aJ, useFiatTransactions as aK, useCurrencyDetails as aL, useCountryDetails as aM, useAvailableQuotes as aN, useRecommendedQuote as aO, useGetOnrampPaymentTypes as aP, useSuggestedFiatAmounts as aQ, SquidProvider as aR, EnsService as aS, getXummClient as aT, isXamanXAppContext as aU, getQueryHeaders as aV, getStatusCode as aW, is404Error as aX, assetsBaseUrl as aY, shareSubgraphId as aZ, sortTokensBySharedSubgraphIds as a_, useTokensData as aa, useEstimateSendTransaction as ab, useSendTransaction as ac, useSendTransactionGas as ad, useAllTransactionsStatus as ae, useApproval as af, useEstimate as ag, useEstimatePriceImpact as ah, useExecuteTransaction as ai, useGetRoute as aj, useGetRouteWrapper as ak, useRouteWarnings as al, useSendTransactionStatus as am, useSwapTransactionStatus as an, useAvatar as ao, useHistory as ap, useUserParams as aq, useDebouncedValue as ar, useAddToken as as, useAutoConnect as at, useEnsDataForAddress as au, useEnsSearch as av, useGnosisContext as aw, useIsSameAddressAndGnosisContext as ax, useIntegratorContext as ay, useMultiChainWallet as az, chainTypeToZeroAddressMap as b, formatTokenAmount as b$, filterChains as b0, filterTokens as b1, getTokenImage as b2, getNewSwapParamsFromInput as b3, sortAllTokens as b4, findToken as b5, findNativeToken as b6, normalizeIbcAddress as b7, groupTokensBySymbol as b8, groupTokensByChainId as b9, suggestChainOrThrow as bA, normalizeError as bB, transactionErrorCode as bC, isUserRejectionError as bD, getTransactionError as bE, handleTransactionErrorEvents as bF, isSwapRouteError as bG, isStatusError as bH, createQuoteRequestParamsHash as bI, WidgetEvents as bJ, EvmNetworkNotSupportedErrorCode as bK, addEthereumChain as bL, parseEvmAddress as bM, formatEvmWallet as bN, filterWagmiConnector as bO, waitForReceiptWithRetry as bP, getUserCountry as bQ, getCountryData as bR, getCurrencyData as bS, adaptiveRound as bT, getSuggestedAmountsForCurrency as bU, HederaExtensionHelper as bV, convertHederaAccountIdToEvmAddress as bW, convertEvmAddressToHederaAccountId as bX, parseToBigInt as bY, roundNumericValue as bZ, formatUnitsRounded as b_, filterViewableTokens as ba, getSecretNetworkBalances as bb, getTokenAssetsKey as bc, fetchAssetsColors as bd, initializeSquidWithAssetsColors as be, isEmptyObject as bf, normalizeTokenSymbol as bg, areTokenSymbolsCompatible as bh, isEvmosChain as bi, getConfigWithDefaults as bj, randomIntFromInterval as bk, getTokensForChain as bl, getFirstAvailableChainId as bm, fetchHighestBalanceToken as bn, getInitialOrDefaultTokenAddressForChain as bo, getInitialTokenAddressForChain as bp, filterTokensForDestination as bq, getInitialChainIdFromConfig as br, getCosmosKey as bs, getKeysSettled as bt, getAllKeysForSupportedCosmosChains as bu, isCosmosAddressValid as bv, getCosmosSigningClient as bw, getCosmosChainInfosObject as bx, connectCosmosWallet as by, isFallbackAddressNeeded as bz, chainTypeToNativeTokenAddressMap as c, walletSupportsChainType as c$, formatUsdAmount as c0, trimExtraDecimals as c1, getNumericValue as c2, cleanAmount as c3, convertTokenAmountToUSD as c4, convertUSDToTokenAmount as c5, calculateTotal24hChange as c6, searchTokens as c7, filterSolanaWallets as c8, isSolanaAddressValid as c9, getStepStatuses as cA, getHalfSuccessState as cB, getStepsInfos as cC, getSwapTxStatusRefetchInterval as cD, getSendTxStatusRefetchInterval as cE, chainflipMultihopBridgeType as cF, getBridgeType as cG, getTransactionStatus as cH, getTransactionEndStatus as cI, isHistoryTransactionPending as cJ, isHistoryTransactionFailed as cK, isHistoryTransactionWarning as cL, isHistoryTransactionEnded as cM, formatHash as cN, isWalletAddressValid as cO, redirectToExtensionsStore as cP, accessProperty as cQ, populateWallets as cR, getDefaultChain as cS, sortWallets as cT, areSameAddress as cU, sortAddressBook as cV, calculateTotalUsdBalanceUSD as cW, addTokenToWallet as cX, isEvmChainNotSupportedError as cY, getWalletSupportedChainTypes as cZ, getConnectorForChainType as c_, executeSolanaSwap as ca, executeSolanaTransfer as cb, isStellarAddressValid as cc, getStellarNetwork as cd, stellarAddressToScVal as ce, getStellarTrustLineAsset as cf, isStellarToken as cg, isStellarIssuedToken as ch, getStellarHorizonApiUrl as ci, isValidIssuedAsset as cj, isValidHorizonAsset as ck, formatTransactionHistoryDate as cl, getAxelarExplorerTxUrl as cm, getSourceExplorerTxUrl as cn, getMainExplorerUrl as co, formatDistance as cp, formatSeconds as cq, formatSwapTxStatusResponseForStorage as cr, simplifyRouteAction as cs, fetchSwapTransactionStatus as ct, compareTransactionIds as cu, isCoralBridgeAction as cv, sleep as cw, isDepositRoute as cx, isChainflipBridgeTransaction as cy, getHistoryTransactionId as cz, definedInWindow as d, connectWallet as d0, cancelConnectWallet as d1, isProblematicConnector as d2, mergeWallets as d3, isXionSmartContractAddress as d4, isXrplAddressValid as d5, buildXrplTrustSetTx as d6, getXrplNetwork as d7, parseXrplPaymentTx as d8, parseXrplTokenAddress as d9, er as e, formatBNToReadable as f, destinationAddressResetValue as g, fallbackAddressResetValue as h, nativeCosmosTokenAddress as i, nativeEvmTokenAddress as j, nativeSolanaTokenAddress as k, nativeStellarTokenAddress as l, nativeSuiTokenAddress as m, nativeBitcoinTokenAddress as n, nativeXrplTokenAddress as o, CosmosProvider as p, SendTransactionStatus as q, TransactionStatus as r, useTrackSearchEmpty as s, useSquidChains as t, useCosmosContext as u, useClient as v, walletIconBaseUrl as w, useCosmosForChain as x, useHederaTokenAssociations as y, useKeyboardNavigation as z };
-//# sourceMappingURL=index-DPakWLan.js.map
+    return wagmiConfig ? (React__default.createElement(WagmiProvider, { reconnectOnMount: false, config: wagmiConfig },
+        React__default.createElement(QueryClientProvider, { client: queryClient },
+            React__default.createElement(StellarProvider, null,
+                React__default.createElement(EvmProvider, null,
+                    React__default.createElement(XrplProvider, null,
+                        React__default.createElement(SuiProvider, null,
+                            React__default.createElement(SolanaProvider, null,
+                                React__default.createElement(BitcoinProvider, null,
+                                    React__default.createElement(CosmosProvider, null, children)))))))))) : (placeholder);
+};
+
+export { useAllTokensWithBalanceForChainType as $, AxelarStatusResponseType as A, useSquidQueryClient as B, CHAIN_IDS as C, DEFAULT_LOCALE as D, useSquid as E, useStellarAccountActivation as F, useAddressBookStore as G, HistoryTxType as H, useAssetsColorsStore as I, useFavoriteTokensStore as J, useHistoryStore as K, useSendTransactionStore as L, useConfigStore as M, Nr as N, useSquidStore as O, useSwapRoutePersistStore as P, QueryKeys as Q, useTransactionStore as R, SquidStatusErrorType as S, TransactionErrorType as T, ConnectingWalletStatus as U, useWalletStore as V, Wo as W, XamanXrplNetwork as X, useDepositAddress as Y, useSwap as Z, useAllConnectedWalletBalances as _, WindowWalletFlag as a, filterChains as a$, useCosmosBalance as a0, useEvmBalance as a1, useMultiChainBalance as a2, useMultipleTokenPrices as a3, useNativeBalance as a4, useNativeTokenForChain as a5, useSingleTokenPrice as a6, useSquidTokens as a7, useHistoricalData as a8, useTokensData as a9, useWallet as aA, useWallets as aB, useXrplTrustLine as aC, TX_STATUS_CONSTANTS as aD, FINAL_TRANSACTION_STATUSES as aE, useGetFiatQuote as aF, useGetOnRampConfig as aG, useExecuteFiatQuote as aH, useFiatOnRampTxStatus as aI, useFiatTransactions as aJ, useCurrencyDetails as aK, useCountryDetails as aL, useAvailableQuotes as aM, useRecommendedQuote as aN, useGetOnrampPaymentTypes as aO, useSuggestedFiatAmounts as aP, SquidProvider as aQ, EnsService as aR, getXummClient as aS, isXamanXAppContext as aT, getQueryHeaders as aU, getStatusCode as aV, is404Error as aW, assetsBaseUrl as aX, shareSubgraphId as aY, sortTokensBySharedSubgraphIds as aZ, getSupportedChainIdsForDirection as a_, useEstimateSendTransaction as aa, useSendTransaction as ab, useSendTransactionGas as ac, useAllTransactionsStatus as ad, useApproval as ae, useEstimate as af, useEstimatePriceImpact as ag, useExecuteTransaction as ah, useGetRoute as ai, useGetRouteWrapper as aj, useRouteWarnings as ak, useSendTransactionStatus as al, useSwapTransactionStatus as am, useAvatar as an, useHistory as ao, useUserParams as ap, useDebouncedValue as aq, useAddToken as ar, useAutoConnect as as, useEnsDataForAddress as at, useEnsSearch as au, useGnosisContext as av, useIsSameAddressAndGnosisContext as aw, useIntegratorContext as ax, useMultiChainWallet as ay, useSigner as az, chainTypeToZeroAddressMap as b, formatUsdAmount as b$, filterTokens as b0, getTokenImage as b1, getNewSwapParamsFromInput as b2, sortAllTokens as b3, findToken as b4, findNativeToken as b5, normalizeIbcAddress as b6, groupTokensBySymbol as b7, groupTokensByChainId as b8, filterViewableTokens as b9, normalizeError as bA, transactionErrorCode as bB, isUserRejectionError as bC, getTransactionError as bD, handleTransactionErrorEvents as bE, isSwapRouteError as bF, isStatusError as bG, createQuoteRequestParamsHash as bH, WidgetEvents as bI, EvmNetworkNotSupportedErrorCode as bJ, addEthereumChain as bK, parseEvmAddress as bL, formatEvmWallet as bM, filterWagmiConnector as bN, waitForReceiptWithRetry as bO, getUserCountry as bP, getCountryData as bQ, getCurrencyData as bR, adaptiveRound as bS, getSuggestedAmountsForCurrency as bT, HederaExtensionHelper as bU, convertHederaAccountIdToEvmAddress as bV, convertEvmAddressToHederaAccountId as bW, parseToBigInt as bX, roundNumericValue as bY, formatUnitsRounded as bZ, formatTokenAmount as b_, getSecretNetworkBalances as ba, getTokenAssetsKey as bb, fetchAssetsColors as bc, initializeSquidWithAssetsColors as bd, isEmptyObject as be, normalizeTokenSymbol as bf, areTokenSymbolsCompatible as bg, isEvmosChain as bh, getConfigWithDefaults as bi, randomIntFromInterval as bj, getTokensForChain as bk, getFirstAvailableChainId as bl, fetchHighestBalanceToken as bm, getInitialOrDefaultTokenAddressForChain as bn, getInitialTokenAddressForChain as bo, filterTokensForDestination as bp, getInitialChainIdFromConfig as bq, getCosmosKey as br, getKeysSettled as bs, getAllKeysForSupportedCosmosChains as bt, isCosmosAddressValid as bu, getCosmosSigningClient as bv, getCosmosChainInfosObject as bw, connectCosmosWallet as bx, isFallbackAddressNeeded as by, suggestChainOrThrow as bz, chainTypeToNativeTokenAddressMap as c, trimExtraDecimals as c0, getNumericValue as c1, cleanAmount as c2, convertTokenAmountToUSD as c3, convertUSDToTokenAmount as c4, calculateTotal24hChange as c5, searchTokens as c6, filterSolanaWallets as c7, isSolanaAddressValid as c8, executeSolanaSwap as c9, isHistoryTransactionFailed as cA, isHistoryTransactionWarning as cB, isHistoryTransactionEnded as cC, formatHash as cD, isWalletAddressValid as cE, redirectToExtensionsStore as cF, accessProperty as cG, populateWallets as cH, getDefaultChain as cI, sortWallets as cJ, areSameAddress as cK, sortAddressBook as cL, calculateTotalUsdBalanceUSD as cM, addTokenToWallet as cN, isEvmChainNotSupportedError as cO, getWalletSupportedChainTypes as cP, getConnectorForChainType as cQ, walletSupportsChainType as cR, connectWallet as cS, cancelConnectWallet as cT, isProblematicConnector as cU, mergeWallets as cV, isXionSmartContractAddress as cW, isXrplAddressValid as cX, buildXrplTrustSetTx as cY, getXrplNetwork as cZ, parseXrplPaymentTx as c_, executeSolanaTransfer as ca, formatTransactionHistoryDate as cb, getAxelarExplorerTxUrl as cc, getSourceExplorerTxUrl as cd, getMainExplorerUrl as ce, formatDistance as cf, formatSeconds as cg, formatSwapTxStatusResponseForStorage as ch, simplifyRouteAction as ci, fetchSwapTransactionStatus as cj, compareTransactionIds as ck, isCoralBridgeAction as cl, sleep as cm, isDepositRoute as cn, isChainflipBridgeTransaction as co, getHistoryTransactionId as cp, getStepStatuses as cq, getHalfSuccessState as cr, getStepsInfos as cs, getSwapTxStatusRefetchInterval as ct, getSendTxStatusRefetchInterval as cu, chainflipMultihopBridgeType as cv, getBridgeType as cw, getTransactionStatus as cx, getTransactionEndStatus as cy, isHistoryTransactionPending as cz, definedInWindow as d, er as e, formatBNToReadable as f, destinationAddressResetValue as g, fallbackAddressResetValue as h, nativeCosmosTokenAddress as i, nativeEvmTokenAddress as j, nativeSolanaTokenAddress as k, nativeStellarTokenAddress as l, nativeSuiTokenAddress as m, nativeBitcoinTokenAddress as n, nativeXrplTokenAddress as o, CosmosProvider as p, SendTransactionStatus as q, TransactionStatus as r, useTrackSearchEmpty as s, useSquidChains as t, useCosmosContext as u, useClient as v, walletIconBaseUrl as w, useCosmosForChain as x, useHederaTokenAssociations as y, useKeyboardNavigation as z };
+//# sourceMappingURL=index-D3LtAuC9.js.map