@gaddario98/react-core 2.0.5 → 2.0.7

package/dist/queries/index.js

@@ -61,29 +61,22 @@ function getMountedOrPendingDependents(atom, atomState, mountedMap) {
   }
   return dependents;
 }
-const atomRead = (_store, atom, ...params) => atom.read(...params);
-const atomWrite = (_store, atom, ...params) => atom.write(...params);
-const atomOnInit = (store, atom) => {
-  if (atom.INTERNAL_onInit) {
-    return atom.INTERNAL_onInit(store);
-  }
-  if (atom.unstable_onInit) {
-    console.warn(
-      "[DEPRECATED] atom.unstable_onInit is renamed to atom.INTERNAL_onInit."
-    );
-    return atom.unstable_onInit(store);
-  }
+const BUILDING_BLOCK_atomRead = (_store, atom, ...params) => atom.read(...params);
+const BUILDING_BLOCK_atomWrite = (_store, atom, ...params) => atom.write(...params);
+const BUILDING_BLOCK_atomOnInit = (store, atom) => {
+  var _a;
+  return (_a = atom.INTERNAL_onInit) == null ? void 0 : _a.call(atom, store);
 };
-const atomOnMount = (_store, atom, setAtom) => {
+const BUILDING_BLOCK_atomOnMount = (_store, atom, setAtom) => {
   var _a;
   return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
 };
-const ensureAtomState = (store, atom) => {
+const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
   var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const atomStateMap = buildingBlocks[0];
   const storeHooks = buildingBlocks[6];
-  const atomOnInit2 = buildingBlocks[9];
+  const atomOnInit = buildingBlocks[9];
   if ((undefined ? undefined.MODE : void 0) !== "production" && !atom) {
     throw new Error("Atom is undefined or null");
   }
@@ -92,18 +85,18 @@ const ensureAtomState = (store, atom) => {
     atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
     atomStateMap.set(atom, atomState);
     (_a = storeHooks.i) == null ? void 0 : _a.call(storeHooks, atom);
-    atomOnInit2 == null ? void 0 : atomOnInit2(store, atom);
+    atomOnInit == null ? void 0 : atomOnInit(store, atom);
   }
   return atomState;
 };
-const flushCallbacks = (store) => {
+const BUILDING_BLOCK_flushCallbacks = (store) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const changedAtoms = buildingBlocks[3];
   const mountCallbacks = buildingBlocks[4];
   const unmountCallbacks = buildingBlocks[5];
   const storeHooks = buildingBlocks[6];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
   const errors = [];
   const call = (fn) => {
     try {
@@ -129,28 +122,28 @@ const flushCallbacks = (store) => {
     mountCallbacks.clear();
     callbacks.forEach(call);
     if (changedAtoms.size) {
-      recomputeInvalidatedAtoms2(store);
+      recomputeInvalidatedAtoms(store);
     }
   } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
   if (errors.length) {
     throw new AggregateError(errors);
   }
 };
-const recomputeInvalidatedAtoms = (store) => {
+const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
   const changedAtoms = buildingBlocks[3];
-  const ensureAtomState2 = buildingBlocks[11];
-  const readAtomState2 = buildingBlocks[14];
-  const mountDependencies2 = buildingBlocks[17];
+  const ensureAtomState = buildingBlocks[11];
+  const readAtomState = buildingBlocks[14];
+  const mountDependencies = buildingBlocks[17];
   const topSortedReversed = [];
   const visiting = /* @__PURE__ */ new WeakSet();
   const visited = /* @__PURE__ */ new WeakSet();
   const stack = Array.from(changedAtoms);
   while (stack.length) {
     const a = stack[stack.length - 1];
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     if (visited.has(a)) {
       stack.pop();
       continue;
@@ -182,35 +175,36 @@ const recomputeInvalidatedAtoms = (store) => {
       }
     }
     if (hasChangedDeps) {
-      readAtomState2(store, a);
-      mountDependencies2(store, a);
+      readAtomState(store, a);
+      mountDependencies(store, a);
     }
     invalidatedAtoms.delete(a);
   }
 };
 const storeMutationSet = /* @__PURE__ */ new WeakSet();
-const readAtomState = (store, atom) => {
+const BUILDING_BLOCK_readAtomState = (store, atom) => {
   var _a, _b;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const atomRead2 = buildingBlocks[7];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const writeAtomState2 = buildingBlocks[16];
-  const mountDependencies2 = buildingBlocks[17];
-  const atomState = ensureAtomState2(store, atom);
+  const atomRead = buildingBlocks[7];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const writeAtomState = buildingBlocks[16];
+  const mountDependencies = buildingBlocks[17];
+  const setAtomStateValueOrPromise = buildingBlocks[20];
+  const atomState = ensureAtomState(store, atom);
   if (isAtomStateInitialized(atomState)) {
     if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
       return atomState;
     }
     let hasChangedDeps = false;
     for (const [a, n] of atomState.d) {
-      if (readAtomState2(store, a).n !== n) {
+      if (readAtomState(store, a).n !== n) {
         hasChangedDeps = true;
         break;
       }
@@ -223,15 +217,15 @@ const readAtomState = (store, atom) => {
   let isSync = true;
   function mountDependenciesIfAsync() {
     if (mountedMap.has(atom)) {
-      mountDependencies2(store, atom);
-      recomputeInvalidatedAtoms2(store);
-      flushCallbacks2(store);
+      mountDependencies(store, atom);
+      recomputeInvalidatedAtoms(store);
+      flushCallbacks(store);
     }
   }
   function getter(a) {
     var _a2;
     if (a === atom) {
-      const aState2 = ensureAtomState2(store, a);
+      const aState2 = ensureAtomState(store, a);
       if (!isAtomStateInitialized(aState2)) {
         if (hasInitialValue(a)) {
           setAtomStateValueOrPromise(store, a, a.init);
@@ -241,7 +235,7 @@ const readAtomState = (store, atom) => {
       }
       return returnAtomValue(aState2);
     }
-    const aState = readAtomState2(store, a);
+    const aState = readAtomState(store, a);
     try {
       return returnAtomValue(aState);
     } finally {
@@ -267,6 +261,11 @@ const readAtomState = (store, atom) => {
       return controller.signal;
     },
     get setSelf() {
+      if ((undefined ? undefined.MODE : void 0) !== "production") {
+        console.warn(
+          "[DEPRECATED] setSelf is deprecated and will be removed in v3."
+        );
+      }
       if ((undefined ? undefined.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
         console.warn("setSelf function cannot be used with read-only atom");
       }
@@ -277,10 +276,10 @@ const readAtomState = (store, atom) => {
           }
           if (!isSync) {
             try {
-              return writeAtomState2(store, atom, ...args);
+              return writeAtomState(store, atom, ...args);
             } finally {
-              recomputeInvalidatedAtoms2(store);
-              flushCallbacks2(store);
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
             }
           }
         };
@@ -293,7 +292,7 @@ const readAtomState = (store, atom) => {
     if ((undefined ? undefined.MODE : void 0) !== "production") {
       storeMutationSet.delete(store);
     }
-    const valueOrPromise = atomRead2(store, atom, getter, options);
+    const valueOrPromise = atomRead(store, atom, getter, options);
     if ((undefined ? undefined.MODE : void 0) !== "production" && storeMutationSet.has(store)) {
       console.warn(
         "Detected store mutation during atom read. This is not supported."
@@ -320,38 +319,40 @@ const readAtomState = (store, atom) => {
     }
   }
 };
-const invalidateDependents = (store, atom) => {
+const BUILDING_BLOCK_invalidateDependents = (store, atom) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
-  const ensureAtomState2 = buildingBlocks[11];
+  const ensureAtomState = buildingBlocks[11];
   const stack = [atom];
   while (stack.length) {
     const a = stack.pop();
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      const dState = ensureAtomState2(store, d);
+      const dState = ensureAtomState(store, d);
       invalidatedAtoms.set(d, dState.n);
       stack.push(d);
     }
   }
 };
-const writeAtomState = (store, atom, ...args) => {
+const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const atomWrite2 = buildingBlocks[8];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const invalidateDependents2 = buildingBlocks[15];
-  const mountDependencies2 = buildingBlocks[17];
+  const atomWrite = buildingBlocks[8];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const invalidateDependents = buildingBlocks[15];
+  const writeAtomState = buildingBlocks[16];
+  const mountDependencies = buildingBlocks[17];
+  const setAtomStateValueOrPromise = buildingBlocks[20];
   let isSync = true;
-  const getter = (a) => returnAtomValue(readAtomState2(store, a));
+  const getter = (a) => returnAtomValue(readAtomState(store, a));
   const setter = (a, ...args2) => {
     var _a;
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     try {
       if (a === atom) {
         if (!hasInitialValue(a)) {
@@ -363,10 +364,10 @@ const writeAtomState = (store, atom, ...args) => {
         const prevEpochNumber = aState.n;
         const v = args2[0];
         setAtomStateValueOrPromise(store, a, v);
-        mountDependencies2(store, a);
+        mountDependencies(store, a);
         if (prevEpochNumber !== aState.n) {
           changedAtoms.add(a);
-          invalidateDependents2(store, a);
+          invalidateDependents(store, a);
           (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
         }
         return void 0;
@@ -375,39 +376,39 @@ const writeAtomState = (store, atom, ...args) => {
       }
     } finally {
       if (!isSync) {
-        recomputeInvalidatedAtoms2(store);
-        flushCallbacks2(store);
+        recomputeInvalidatedAtoms(store);
+        flushCallbacks(store);
       }
     }
   };
   try {
-    return atomWrite2(store, atom, getter, setter, ...args);
+    return atomWrite(store, atom, getter, setter, ...args);
   } finally {
     isSync = false;
   }
 };
-const mountDependencies = (store, atom) => {
+const BUILDING_BLOCK_mountDependencies = (store, atom) => {
   var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const ensureAtomState2 = buildingBlocks[11];
-  const invalidateDependents2 = buildingBlocks[15];
-  const mountAtom2 = buildingBlocks[18];
-  const unmountAtom2 = buildingBlocks[19];
-  const atomState = ensureAtomState2(store, atom);
+  const ensureAtomState = buildingBlocks[11];
+  const invalidateDependents = buildingBlocks[15];
+  const mountAtom = buildingBlocks[18];
+  const unmountAtom = buildingBlocks[19];
+  const atomState = ensureAtomState(store, atom);
   const mounted = mountedMap.get(atom);
   if (mounted && !isPendingPromise(atomState.v)) {
     for (const [a, n] of atomState.d) {
       if (!mounted.d.has(a)) {
-        const aState = ensureAtomState2(store, a);
-        const aMounted = mountAtom2(store, a);
+        const aState = ensureAtomState(store, a);
+        const aMounted = mountAtom(store, a);
         aMounted.t.add(atom);
         mounted.d.add(a);
         if (n !== aState.n) {
           changedAtoms.add(a);
-          invalidateDependents2(store, a);
+          invalidateDependents(store, a);
           (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
         }
       }
@@ -415,28 +416,29 @@ const mountDependencies = (store, atom) => {
     for (const a of mounted.d) {
       if (!atomState.d.has(a)) {
         mounted.d.delete(a);
-        const aMounted = unmountAtom2(store, a);
+        const aMounted = unmountAtom(store, a);
         aMounted == null ? void 0 : aMounted.t.delete(atom);
       }
     }
   }
 };
-const mountAtom = (store, atom) => {
+const BUILDING_BLOCK_mountAtom = (store, atom) => {
   var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const mountCallbacks = buildingBlocks[4];
   const storeHooks = buildingBlocks[6];
-  const atomOnMount2 = buildingBlocks[10];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const writeAtomState2 = buildingBlocks[16];
-  const atomState = ensureAtomState2(store, atom);
+  const atomOnMount = buildingBlocks[10];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const writeAtomState = buildingBlocks[16];
+  const mountAtom = buildingBlocks[18];
+  const atomState = ensureAtomState(store, atom);
   let mounted = mountedMap.get(atom);
   if (!mounted) {
-    readAtomState2(store, atom);
+    readAtomState(store, atom);
     for (const a of atomState.d.keys()) {
       const aMounted = mountAtom(store, a);
       aMounted.t.add(atom);
@@ -452,16 +454,16 @@ const mountAtom = (store, atom) => {
         let isSync = true;
         const setAtom = (...args) => {
           try {
-            return writeAtomState2(store, atom, ...args);
+            return writeAtomState(store, atom, ...args);
           } finally {
             if (!isSync) {
-              recomputeInvalidatedAtoms2(store);
-              flushCallbacks2(store);
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
             }
           }
         };
         try {
-          const onUnmount = atomOnMount2(store, atom, setAtom);
+          const onUnmount = atomOnMount(store, atom, setAtom);
           if (onUnmount) {
             mounted.u = () => {
               isSync = true;
@@ -482,15 +484,15 @@ const mountAtom = (store, atom) => {
   }
   return mounted;
 };
-const unmountAtom = (store, atom) => {
+const BUILDING_BLOCK_unmountAtom = (store, atom) => {
   var _a, _b;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const unmountCallbacks = buildingBlocks[5];
   const storeHooks = buildingBlocks[6];
-  const ensureAtomState2 = buildingBlocks[11];
-  const unmountAtom2 = buildingBlocks[19];
-  const atomState = ensureAtomState2(store, atom);
+  const ensureAtomState = buildingBlocks[11];
+  const unmountAtom = buildingBlocks[19];
+  const atomState = ensureAtomState(store, atom);
   let mounted = mountedMap.get(atom);
   if (!mounted || mounted.l.size) {
     return mounted;
@@ -509,7 +511,7 @@ const unmountAtom = (store, atom) => {
     mounted = void 0;
     mountedMap.delete(atom);
     for (const a of atomState.d.keys()) {
-      const aMounted = unmountAtom2(store, a);
+      const aMounted = unmountAtom(store, a);
       aMounted == null ? void 0 : aMounted.t.delete(atom);
     }
     (_b = storeHooks.u) == null ? void 0 : _b.call(storeHooks, atom);
@@ -517,9 +519,9 @@ const unmountAtom = (store, atom) => {
   }
   return mounted;
 };
-const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
-  const ensureAtomState2 = getInternalBuildingBlocks(store)[11];
-  const atomState = ensureAtomState2(store, atom);
+const BUILDING_BLOCK_setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
+  const ensureAtomState = getInternalBuildingBlocks(store)[11];
+  const atomState = ensureAtomState(store, atom);
   const hasPrevValue = "v" in atomState;
   const prevValue = atomState.v;
   if (isPromiseLike$1(valueOrPromise)) {
@@ -527,7 +529,7 @@ const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
       addPendingPromiseToDependency(
         atom,
         valueOrPromise,
-        ensureAtomState2(store, a)
+        ensureAtomState(store, a)
       );
     }
   }
@@ -540,35 +542,35 @@ const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
     }
   }
 };
-const storeGet = (store, atom) => {
-  const readAtomState2 = getInternalBuildingBlocks(store)[14];
-  return returnAtomValue(readAtomState2(store, atom));
+const BUILDING_BLOCK_storeGet = (store, atom) => {
+  const readAtomState = getInternalBuildingBlocks(store)[14];
+  return returnAtomValue(readAtomState(store, atom));
 };
-const storeSet = (store, atom, ...args) => {
+const BUILDING_BLOCK_storeSet = (store, atom, ...args) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const writeAtomState2 = buildingBlocks[16];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const writeAtomState = buildingBlocks[16];
   try {
-    return writeAtomState2(store, atom, ...args);
+    return writeAtomState(store, atom, ...args);
   } finally {
-    recomputeInvalidatedAtoms2(store);
-    flushCallbacks2(store);
+    recomputeInvalidatedAtoms(store);
+    flushCallbacks(store);
   }
 };
-const storeSub = (store, atom, listener) => {
+const BUILDING_BLOCK_storeSub = (store, atom, listener) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const mountAtom2 = buildingBlocks[18];
-  const unmountAtom2 = buildingBlocks[19];
-  const mounted = mountAtom2(store, atom);
+  const flushCallbacks = buildingBlocks[12];
+  const mountAtom = buildingBlocks[18];
+  const unmountAtom = buildingBlocks[19];
+  const mounted = mountAtom(store, atom);
   const listeners = mounted.l;
   listeners.add(listener);
-  flushCallbacks2(store);
+  flushCallbacks(store);
   return () => {
     listeners.delete(listener);
-    unmountAtom2(store, atom);
-    flushCallbacks2(store);
+    unmountAtom(store, atom);
+    flushCallbacks(store);
   };
 };
 const buildingBlockMap = /* @__PURE__ */ new WeakMap();
@@ -584,16 +586,16 @@ const getInternalBuildingBlocks = (store) => {
 function buildStore(...buildArgs) {
   const store = {
     get(atom) {
-      const storeGet2 = getInternalBuildingBlocks(store)[21];
-      return storeGet2(store, atom);
+      const storeGet = getInternalBuildingBlocks(store)[21];
+      return storeGet(store, atom);
     },
     set(atom, ...args) {
-      const storeSet2 = getInternalBuildingBlocks(store)[22];
-      return storeSet2(store, atom, ...args);
+      const storeSet = getInternalBuildingBlocks(store)[22];
+      return storeSet(store, atom, ...args);
     },
     sub(atom, listener) {
-      const storeSub2 = getInternalBuildingBlocks(store)[23];
-      return storeSub2(store, atom, listener);
+      const storeSub = getInternalBuildingBlocks(store)[23];
+      return storeSub(store, atom, listener);
     }
   };
   const buildingBlocks = [
@@ -613,24 +615,24 @@ function buildStore(...buildArgs) {
     {},
     // storeHooks
     // atom interceptors
-    atomRead,
-    atomWrite,
-    atomOnInit,
-    atomOnMount,
+    BUILDING_BLOCK_atomRead,
+    BUILDING_BLOCK_atomWrite,
+    BUILDING_BLOCK_atomOnInit,
+    BUILDING_BLOCK_atomOnMount,
     // building-block functions
-    ensureAtomState,
-    flushCallbacks,
-    recomputeInvalidatedAtoms,
-    readAtomState,
-    invalidateDependents,
-    writeAtomState,
-    mountDependencies,
-    mountAtom,
-    unmountAtom,
-    setAtomStateValueOrPromise,
-    storeGet,
-    storeSet,
-    storeSub,
+    BUILDING_BLOCK_ensureAtomState,
+    BUILDING_BLOCK_flushCallbacks,
+    BUILDING_BLOCK_recomputeInvalidatedAtoms,
+    BUILDING_BLOCK_readAtomState,
+    BUILDING_BLOCK_invalidateDependents,
+    BUILDING_BLOCK_writeAtomState,
+    BUILDING_BLOCK_mountDependencies,
+    BUILDING_BLOCK_mountAtom,
+    BUILDING_BLOCK_unmountAtom,
+    BUILDING_BLOCK_setAtomStateValueOrPromise,
+    BUILDING_BLOCK_storeGet,
+    BUILDING_BLOCK_storeSet,
+    BUILDING_BLOCK_storeSub,
     void 0
   ].map((fn, i) => buildArgs[i] || fn);
   buildingBlockMap.set(store, Object.freeze(buildingBlocks));
@@ -856,7 +858,7 @@ function selectAtom(anAtom, selector, equalityFn = Object.is) {
   );
 }
 
-const isPromiseLike$3 = (x) => typeof (x == null ? void 0 : x.then) === "function";
+const isPromiseLike$2 = (x) => typeof (x == null ? void 0 : x.then) === "function";
 function createJSONStorage(getStringStorage = () => {
   try {
     return window.localStorage;
@@ -888,7 +890,7 @@ function createJSONStorage(getStringStorage = () => {
         return lastValue;
       };
       const str = (_b = (_a2 = getStringStorage()) == null ? void 0 : _a2.getItem(key)) != null ? _b : null;
-      if (isPromiseLike$3(str)) {
+      if (isPromiseLike$2(str)) {
         return str.then(parse);
       }
       return parse(str);
@@ -966,7 +968,7 @@ function atomWithStorage(key, initialValue, storage = defaultStorage, options) {
         set(baseAtom, initialValue);
         return storage.removeItem(key);
       }
-      if (isPromiseLike$3(nextValue)) {
+      if (isPromiseLike$2(nextValue)) {
         return nextValue.then((resolvedValue) => {
           set(baseAtom, resolvedValue);
           return storage.setItem(key, resolvedValue);
@@ -1298,10 +1300,11 @@ function partialMatchKey(a, b) {
   return false;
 }
 var hasOwn = Object.prototype.hasOwnProperty;
-function replaceEqualDeep(a, b) {
+function replaceEqualDeep(a, b, depth = 0) {
   if (a === b) {
     return a;
   }
+  if (depth > 500) return b;
   const array = isPlainArray(a) && isPlainArray(b);
   if (!array && !(isPlainObject$1(a) && isPlainObject$1(b))) return b;
   const aItems = array ? a : Object.keys(a);
@@ -1323,7 +1326,7 @@ function replaceEqualDeep(a, b) {
       copy[key] = bItem;
       continue;
     }
-    const v = replaceEqualDeep(aItem, bItem);
+    const v = replaceEqualDeep(aItem, bItem, depth + 1);
     copy[key] = v;
     if (v === aItem) equalItems++;
   }
@@ -1395,7 +1398,7 @@ function addToStart(items, item, max = 0) {
   const newItems = [item, ...items];
   return max && newItems.length > max ? newItems.slice(0, -1) : newItems;
 }
-var skipToken = Symbol();
+var skipToken = /* @__PURE__ */Symbol();
 function ensureQueryFn(options, fetchOptions) {
   if (process.env.NODE_ENV !== "production") {
     if (options.queryFn === skipToken) {
@@ -1415,6 +1418,29 @@ function shouldThrowError(throwOnError, params) {
     return throwOnError(...params);
   }
   return !!throwOnError;
+}
+function addConsumeAwareSignal(object, getSignal, onCancelled) {
+  let consumed = false;
+  let signal;
+  Object.defineProperty(object, "signal", {
+    enumerable: true,
+    get: () => {
+      signal ??= getSignal();
+      if (consumed) {
+        return signal;
+      }
+      consumed = true;
+      if (signal.aborted) {
+        onCancelled();
+      } else {
+        signal.addEventListener("abort", onCancelled, {
+          once: true
+        });
+      }
+      return signal;
+    }
+  });
+  return object;
 }// src/focusManager.ts
 var FocusManager = class extends Subscribable {
   #focused;
@@ -1535,16 +1561,19 @@ function dehydrateMutation(mutation) {
   };
 }
 function dehydrateQuery(query, serializeData, shouldRedactErrors) {
-  const promise = query.promise?.then(serializeData).catch(error => {
-    if (!shouldRedactErrors(error)) {
-      return Promise.reject(error);
-    }
-    if (process.env.NODE_ENV !== "production") {
-      console.error(`A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`);
-    }
-    return Promise.reject(new Error("redacted"));
-  });
-  promise?.catch(noop$1);
+  const dehydratePromise = () => {
+    const promise = query.promise?.then(serializeData).catch(error => {
+      if (!shouldRedactErrors(error)) {
+        return Promise.reject(error);
+      }
+      if (process.env.NODE_ENV !== "production") {
+        console.error(`A query that was dehydrated as pending ended up rejecting. [${query.queryHash}]: ${error}; The error will be redacted in production builds`);
+      }
+      return Promise.reject(new Error("redacted"));
+    });
+    promise?.catch(noop$1);
+    return promise;
+  };
   return {
     dehydratedAt: Date.now(),
     state: {
@@ -1556,7 +1585,7 @@ function dehydrateQuery(query, serializeData, shouldRedactErrors) {
     queryKey: query.queryKey,
     queryHash: query.queryHash,
     ...(query.state.status === "pending" && {
-      promise
+      promise: dehydratePromise()
     }),
     ...(query.meta && {
       meta: query.meta
@@ -2100,7 +2129,7 @@ var Query = class extends Removable {
   }
   async fetch(options, fetchOptions) {
     if (this.state.fetchStatus !== "idle" &&
-    // If the promise in the retyer is already rejected, we have to definitely
+    // If the promise in the retryer is already rejected, we have to definitely
     // re-start the fetch; there is a chance that the query is still in a
     // pending state when that happens
     this.#retryer?.status() !== "rejected") {
@@ -2292,7 +2321,10 @@ var Query = class extends Removable {
             fetchFailureCount: state.fetchFailureCount + 1,
             fetchFailureReason: error,
             fetchStatus: "idle",
-            status: "error"
+            status: "error",
+            // flag existing data as invalidated if we get a background error
+            // note that "no data" always means stale so we can set unconditionally here
+            isInvalidated: true
           };
         case "invalidate":
           return {
@@ -2660,10 +2692,12 @@ var QueryObserver = class extends Subscribable {
     };
     const nextResult = result;
     if (this.options.experimental_prefetchInRender) {
+      const hasResultData = nextResult.data !== void 0;
+      const isErrorWithoutData = nextResult.status === "error" && !hasResultData;
       const finalizeThenableIfPossible = thenable => {
-        if (nextResult.status === "error") {
+        if (isErrorWithoutData) {
           thenable.reject(nextResult.error);
-        } else if (nextResult.data !== void 0) {
+        } else if (hasResultData) {
           thenable.resolve(nextResult.data);
         }
       };
@@ -2679,12 +2713,12 @@ var QueryObserver = class extends Subscribable {
           }
           break;
         case "fulfilled":
-          if (nextResult.status === "error" || nextResult.data !== prevThenable.value) {
+          if (isErrorWithoutData || nextResult.data !== prevThenable.value) {
             recreateThenable();
           }
           break;
         case "rejected":
-          if (nextResult.status !== "error" || nextResult.error !== prevThenable.reason) {
+          if (!isErrorWithoutData || nextResult.error !== prevThenable.reason) {
             recreateThenable();
           }
           break;
@@ -2802,19 +2836,7 @@ function infiniteQueryBehavior(pages) {
       const fetchFn = async () => {
         let cancelled = false;
         const addSignalProperty = object => {
-          Object.defineProperty(object, "signal", {
-            enumerable: true,
-            get: () => {
-              if (context.signal.aborted) {
-                cancelled = true;
-              } else {
-                context.signal.addEventListener("abort", () => {
-                  cancelled = true;
-                });
-              }
-              return context.signal;
-            }
-          });
+          addConsumeAwareSignal(object, () => context.signal, () => cancelled = true);
         };
         const queryFn = ensureQueryFn(context.options, context.fetchOptions);
         const fetchPage = async (data, param, previous) => {
@@ -2999,7 +3021,9 @@ var Mutation = class extends Removable {
           variables,
           isPaused
         });
-        await this.#mutationCache.config.onMutate?.(variables, this, mutationFnContext);
+        if (this.#mutationCache.config.onMutate) {
+          await this.#mutationCache.config.onMutate(variables, this, mutationFnContext);
+        }
         const context = await this.options.onMutate?.(variables, mutationFnContext);
         if (context !== this.state.context) {
           this.#dispatch({
@@ -3023,16 +3047,29 @@ var Mutation = class extends Removable {
     } catch (error) {
       try {
         await this.#mutationCache.config.onError?.(error, variables, this.state.context, this, mutationFnContext);
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
         await this.options.onError?.(error, variables, this.state.context, mutationFnContext);
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
         await this.#mutationCache.config.onSettled?.(void 0, error, this.state.variables, this.state.context, this, mutationFnContext);
+      } catch (e) {
+        void Promise.reject(e);
+      }
+      try {
         await this.options.onSettled?.(void 0, error, variables, this.state.context, mutationFnContext);
-        throw error;
-      } finally {
-        this.#dispatch({
-          type: "error",
-          error
-        });
+      } catch (e) {
+        void Promise.reject(e);
       }
+      this.#dispatch({
+        type: "error",
+        error
+      });
+      throw error;
     } finally {
       this.#mutationCache.runNext(this);
     }
@@ -3316,11 +3353,27 @@ var MutationObserver = class extends Subscribable {
           mutationKey: this.options.mutationKey
         };
         if (action?.type === "success") {
-          this.#mutateOptions.onSuccess?.(action.data, variables, onMutateResult, context);
-          this.#mutateOptions.onSettled?.(action.data, null, variables, onMutateResult, context);
+          try {
+            this.#mutateOptions.onSuccess?.(action.data, variables, onMutateResult, context);
+          } catch (e) {
+            void Promise.reject(e);
+          }
+          try {
+            this.#mutateOptions.onSettled?.(action.data, null, variables, onMutateResult, context);
+          } catch (e) {
+            void Promise.reject(e);
+          }
         } else if (action?.type === "error") {
-          this.#mutateOptions.onError?.(action.error, variables, onMutateResult, context);
-          this.#mutateOptions.onSettled?.(void 0, action.error, variables, onMutateResult, context);
+          try {
+            this.#mutateOptions.onError?.(action.error, variables, onMutateResult, context);
+          } catch (e) {
+            void Promise.reject(e);
+          }
+          try {
+            this.#mutateOptions.onSettled?.(void 0, action.error, variables, onMutateResult, context);
+          } catch (e) {
+            void Promise.reject(e);
+          }
         }
       }
       this.listeners.forEach(listener => {
@@ -3347,6 +3400,7 @@ var QueriesObserver = class extends Subscribable {
   #combinedResult;
   #lastCombine;
   #lastResult;
+  #lastQueryHashes;
   #observerMatches = [];
   constructor(client, queries, options) {
     super();
@@ -3389,7 +3443,6 @@ var QueriesObserver = class extends Subscribable {
     notifyManager.batch(() => {
       const prevObservers = this.#observers;
       const newObserverMatches = this.#findMatchingObservers(this.#queries);
-      this.#observerMatches = newObserverMatches;
       newObserverMatches.forEach(match => match.observer.setOptions(match.defaultedQueryOptions));
       const newObservers = newObserverMatches.map(match => match.observer);
       const newResult = newObservers.map(observer => observer.getCurrentResult());
@@ -3402,6 +3455,7 @@ var QueriesObserver = class extends Subscribable {
       });
       if (!hasStructuralChange && !hasResultChange) return;
       if (hasStructuralChange) {
+        this.#observerMatches = newObserverMatches;
         this.#observers = newObservers;
       }
       this.#result = newResult;
@@ -3431,8 +3485,9 @@ var QueriesObserver = class extends Subscribable {
   getOptimisticResult(queries, combine) {
     const matches = this.#findMatchingObservers(queries);
     const result = matches.map(match => match.observer.getOptimisticResult(match.defaultedQueryOptions));
+    const queryHashes = matches.map(match => match.defaultedQueryOptions.queryHash);
     return [result, r => {
-      return this.#combineResult(r ?? result, combine);
+      return this.#combineResult(r ?? result, combine, queryHashes);
     }, () => {
       return this.#trackResult(result, matches);
     }];
@@ -3447,11 +3502,16 @@ var QueriesObserver = class extends Subscribable {
       }) : observerResult;
     });
   }
-  #combineResult(input, combine) {
+  #combineResult(input, combine, queryHashes) {
     if (combine) {
-      if (!this.#combinedResult || this.#result !== this.#lastResult || combine !== this.#lastCombine) {
+      const lastHashes = this.#lastQueryHashes;
+      const queryHashesChanged = queryHashes !== void 0 && lastHashes !== void 0 && (lastHashes.length !== queryHashes.length || queryHashes.some((hash, i) => hash !== lastHashes[i]));
+      if (!this.#combinedResult || this.#result !== this.#lastResult || queryHashesChanged || combine !== this.#lastCombine) {
         this.#lastCombine = combine;
         this.#lastResult = this.#result;
+        if (queryHashes !== void 0) {
+          this.#lastQueryHashes = queryHashes;
+        }
         this.#combinedResult = replaceEqualDeep(this.#combinedResult, combine(input));
       }
       return this.#combinedResult;
@@ -3459,22 +3519,26 @@ var QueriesObserver = class extends Subscribable {
     return input;
   }
   #findMatchingObservers(queries) {
-    const prevObserversMap = new Map(this.#observers.map(observer => [observer.options.queryHash, observer]));
+    const prevObserversMap = /* @__PURE__ */new Map();
+    this.#observers.forEach(observer => {
+      const key = observer.options.queryHash;
+      if (!key) return;
+      const previousObservers = prevObserversMap.get(key);
+      if (previousObservers) {
+        previousObservers.push(observer);
+      } else {
+        prevObserversMap.set(key, [observer]);
+      }
+    });
     const observers = [];
     queries.forEach(options => {
       const defaultedOptions = this.#client.defaultQueryOptions(options);
-      const match = prevObserversMap.get(defaultedOptions.queryHash);
-      if (match) {
-        observers.push({
-          defaultedQueryOptions: defaultedOptions,
-          observer: match
-        });
-      } else {
-        observers.push({
-          defaultedQueryOptions: defaultedOptions,
-          observer: new QueryObserver(this.#client, defaultedOptions)
-        });
-      }
+      const match = prevObserversMap.get(defaultedOptions.queryHash)?.shift();
+      const observer = match ?? new QueryObserver(this.#client, defaultedOptions);
+      observers.push({
+        defaultedQueryOptions: defaultedOptions,
+        observer
+      });
     });
     return observers;
   }
@@ -3919,8 +3983,9 @@ function createValue() {
 }
 var QueryErrorResetBoundaryContext = React__namespace.createContext(createValue());
 var useQueryErrorResetBoundary = () => React__namespace.useContext(QueryErrorResetBoundaryContext);// src/errorBoundaryUtils.ts
-var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {
-  if (options.suspense || options.throwOnError || options.experimental_prefetchInRender) {
+var ensurePreventErrorBoundaryRetry = (options, errorResetBoundary, query) => {
+  const throwOnError = query?.state.error && typeof options.throwOnError === "function" ? shouldThrowError(options.throwOnError, [query.state.error, query]) : options.throwOnError;
+  if (options.suspense || options.experimental_prefetchInRender || throwOnError) {
     if (!errorResetBoundary.isReset()) {
       options.retryOnMount = false;
     }
@@ -3976,9 +4041,10 @@ function useQueries({
     }),
     [queries, client, isRestoring]
   );
-  defaultedQueries.forEach((query) => {
-    ensureSuspenseTimers(query);
-    ensurePreventErrorBoundaryRetry(query, errorResetBoundary);
+  defaultedQueries.forEach((queryOptions) => {
+    ensureSuspenseTimers(queryOptions);
+    const query = client.getQueryCache().get(queryOptions.queryHash);
+    ensurePreventErrorBoundaryRetry(queryOptions, errorResetBoundary, query);
   });
   useClearResetErrorBoundary(errorResetBoundary);
   const [observer] = React__namespace.useState(
@@ -4057,6 +4123,7 @@ function useBaseQuery(options, Observer, queryClient) {
   client.getDefaultOptions().queries?._experimental_beforeQuery?.(
     defaultedOptions
   );
+  const query = client.getQueryCache().get(defaultedOptions.queryHash);
   if (process.env.NODE_ENV !== "production") {
     if (!defaultedOptions.queryFn) {
       console.error(
@@ -4066,7 +4133,7 @@ function useBaseQuery(options, Observer, queryClient) {
   }
   defaultedOptions._optimisticResults = isRestoring ? "isRestoring" : "optimistic";
   ensureSuspenseTimers(defaultedOptions);
-  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);
+  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary, query);
   useClearResetErrorBoundary(errorResetBoundary);
   const isNewCacheEntry = !client.getQueryCache().get(defaultedOptions.queryHash);
   const [observer] = React__namespace.useState(
@@ -4099,7 +4166,7 @@ function useBaseQuery(options, Observer, queryClient) {
     result,
     errorResetBoundary,
     throwOnError: defaultedOptions.throwOnError,
-    query: client.getQueryCache().get(defaultedOptions.queryHash),
+    query,
     suspense: defaultedOptions.suspense
   })) {
     throw result.error;
@@ -4114,7 +4181,7 @@ function useBaseQuery(options, Observer, queryClient) {
       fetchOptimistic(defaultedOptions, observer, errorResetBoundary)
     ) : (
       // subscribe to the "cache promise" so that we can finalize the currentThenable once data comes in
-      client.getQueryCache().get(defaultedOptions.queryHash)?.promise
+      query?.promise
     );
     promise?.catch(noop$1).finally(() => {
       observer.updateResult();
@@ -4409,10 +4476,11 @@ const trim = str => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uF
  * If 'obj' is an Object callback will be called passing
  * the value, key, and complete object for each property.
  *
- * @param {Object|Array} obj The object to iterate
+ * @param {Object|Array<unknown>} obj The object to iterate
  * @param {Function} fn The callback to invoke for each item
  *
- * @param {Boolean} [allOwnKeys = false]
+ * @param {Object} [options]
+ * @param {Boolean} [options.allOwnKeys = false]
  * @returns {any}
  */
 function forEach(obj, fn, {
@@ -4484,7 +4552,7 @@ const isContextDefined = context => !isUndefined(context) && context !== _global
  * Example:
  *
  * ```js
- * var result = merge({foo: 123}, {foo: 456});
+ * const result = merge({foo: 123}, {foo: 456});
  * console.log(result.foo); // outputs 456
  * ```
  *
@@ -4524,7 +4592,8 @@ function merge(/* obj1, obj2, obj3, ... */
  * @param {Object} b The object to copy properties from
  * @param {Object} thisArg The object to bind function to
  *
- * @param {Boolean} [allOwnKeys]
+ * @param {Object} [options]
+ * @param {Boolean} [options.allOwnKeys]
  * @returns {Object} The resulting value of object a
  */
 const extend = (a, b, thisArg, {
@@ -4532,9 +4601,19 @@ const extend = (a, b, thisArg, {
 } = {}) => {
   forEach(b, (val, key) => {
     if (thisArg && isFunction$1(val)) {
-      a[key] = bind(val, thisArg);
+      Object.defineProperty(a, key, {
+        value: bind(val, thisArg),
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
     } else {
-      a[key] = val;
+      Object.defineProperty(a, key, {
+        value: val,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
     }
   }, {
     allOwnKeys
@@ -4567,7 +4646,12 @@ const stripBOM = content => {
  */
 const inherits = (constructor, superConstructor, props, descriptors) => {
   constructor.prototype = Object.create(superConstructor.prototype, descriptors);
-  constructor.prototype.constructor = constructor;
+  Object.defineProperty(constructor.prototype, 'constructor', {
+    value: constructor,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  });
   Object.defineProperty(constructor, 'super', {
     value: superConstructor.prototype
   });
@@ -4894,36 +4978,39 @@ var utils$1 = {
   setImmediate: _setImmediate,
   asap,
   isIterable
-};/**
- * Create an Error with the specified message, config, error code, request and response.
- *
- * @param {string} message The error message.
- * @param {string} [code] The error code (for example, 'ECONNABORTED').
- * @param {Object} [config] The config.
- * @param {Object} [request] The request.
- * @param {Object} [response] The response.
- *
- * @returns {Error} The created error.
- */
-function AxiosError(message, code, config, request, response) {
-  Error.call(this);
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, this.constructor);
-  } else {
-    this.stack = new Error().stack;
-  }
-  this.message = message;
-  this.name = 'AxiosError';
-  code && (this.code = code);
-  config && (this.config = config);
-  request && (this.request = request);
-  if (response) {
-    this.response = response;
-    this.status = response.status ? response.status : null;
+};class AxiosError extends Error {
+  static from(error, code, config, request, response, customProps) {
+    const axiosError = new AxiosError(error.message, code || error.code, config, request, response);
+    axiosError.cause = error;
+    axiosError.name = error.name;
+    customProps && Object.assign(axiosError, customProps);
+    return axiosError;
   }
-}
-utils$1.inherits(AxiosError, Error, {
-  toJSON: function toJSON() {
+
+  /**
+   * Create an Error with the specified message, config, error code, request and response.
+   *
+   * @param {string} message The error message.
+   * @param {string} [code] The error code (for example, 'ECONNABORTED').
+   * @param {Object} [config] The config.
+   * @param {Object} [request] The request.
+   * @param {Object} [response] The response.
+   *
+   * @returns {Error} The created error.
+   */
+  constructor(message, code, config, request, response) {
+    super(message);
+    this.name = 'AxiosError';
+    this.isAxiosError = true;
+    code && (this.code = code);
+    config && (this.config = config);
+    request && (this.request = request);
+    if (response) {
+      this.response = response;
+      this.status = response.status;
+    }
+  }
+  toJSON() {
     return {
       // Standard
       message: this.message,
@@ -4942,46 +5029,21 @@ utils$1.inherits(AxiosError, Error, {
       status: this.status
     };
   }
-});
-const prototype$1 = AxiosError.prototype;
-const descriptors = {};
-['ERR_BAD_OPTION_VALUE', 'ERR_BAD_OPTION', 'ECONNABORTED', 'ETIMEDOUT', 'ERR_NETWORK', 'ERR_FR_TOO_MANY_REDIRECTS', 'ERR_DEPRECATED', 'ERR_BAD_RESPONSE', 'ERR_BAD_REQUEST', 'ERR_CANCELED', 'ERR_NOT_SUPPORT', 'ERR_INVALID_URL'
-// eslint-disable-next-line func-names
-].forEach(code => {
-  descriptors[code] = {
-    value: code
-  };
-});
-Object.defineProperties(AxiosError, descriptors);
-Object.defineProperty(prototype$1, 'isAxiosError', {
-  value: true
-});
-
-// eslint-disable-next-line func-names
-AxiosError.from = (error, code, config, request, response, customProps) => {
-  const axiosError = Object.create(prototype$1);
-  utils$1.toFlatObject(error, axiosError, function filter(obj) {
-    return obj !== Error.prototype;
-  }, prop => {
-    return prop !== 'isAxiosError';
-  });
-  const msg = error && error.message ? error.message : 'Error';
-
-  // Prefer explicit code; otherwise copy the low-level error's code (e.g. ECONNREFUSED)
-  const errCode = code == null && error ? error.code : code;
-  AxiosError.call(axiosError, msg, errCode, config, request, response);
+}
 
-  // Chain the original error on the standard field; non-enumerable to avoid JSON noise
-  if (error && axiosError.cause == null) {
-    Object.defineProperty(axiosError, 'cause', {
-      value: error,
-      configurable: true
-    });
-  }
-  axiosError.name = error && error.name || 'Error';
-  customProps && Object.assign(axiosError, customProps);
-  return axiosError;
-};// eslint-disable-next-line strict
+// This can be changed to static properties as soon as the parser options in .eslint.cjs are updated.
+AxiosError.ERR_BAD_OPTION_VALUE = 'ERR_BAD_OPTION_VALUE';
+AxiosError.ERR_BAD_OPTION = 'ERR_BAD_OPTION';
+AxiosError.ECONNABORTED = 'ECONNABORTED';
+AxiosError.ETIMEDOUT = 'ETIMEDOUT';
+AxiosError.ERR_NETWORK = 'ERR_NETWORK';
+AxiosError.ERR_FR_TOO_MANY_REDIRECTS = 'ERR_FR_TOO_MANY_REDIRECTS';
+AxiosError.ERR_DEPRECATED = 'ERR_DEPRECATED';
+AxiosError.ERR_BAD_RESPONSE = 'ERR_BAD_RESPONSE';
+AxiosError.ERR_BAD_REQUEST = 'ERR_BAD_REQUEST';
+AxiosError.ERR_CANCELED = 'ERR_CANCELED';
+AxiosError.ERR_NOT_SUPPORT = 'ERR_NOT_SUPPORT';
+AxiosError.ERR_INVALID_URL = 'ERR_INVALID_URL';// eslint-disable-next-line strict
 var httpAdapter = null;/**
  * Determines if the given thing is a array or js object.
  *
@@ -5231,22 +5293,19 @@ function encode(val) {
  * @returns {string} The formatted url
  */
 function buildURL(url, params, options) {
-  /*eslint no-param-reassign:0*/
   if (!params) {
     return url;
   }
   const _encode = options && options.encode || encode;
-  if (utils$1.isFunction(options)) {
-    options = {
-      serialize: options
-    };
-  }
-  const serializeFn = options && options.serialize;
+  const _options = utils$1.isFunction(options) ? {
+    serialize: options
+  } : options;
+  const serializeFn = _options && _options.serialize;
   let serializedParams;
   if (serializeFn) {
-    serializedParams = serializeFn(params, options);
+    serializedParams = serializeFn(params, _options);
   } else {
-    serializedParams = utils$1.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, options).toString(_encode);
+    serializedParams = utils$1.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, _options).toString(_encode);
   }
   if (serializedParams) {
     const hashmarkIndex = url.indexOf("#");
@@ -5266,6 +5325,7 @@ function buildURL(url, params, options) {
    *
    * @param {Function} fulfilled The function to handle `then` for a `Promise`
    * @param {Function} rejected The function to handle `reject` for a `Promise`
+   * @param {Object} options The options for the interceptor, synchronous and runWhen
    *
    * @return {Number} An ID used to remove interceptor later
    */
@@ -5864,23 +5924,22 @@ function transformData(fns, response) {
   return data;
 }function isCancel(value) {
   return !!(value && value.__CANCEL__);
+}class CanceledError extends AxiosError {
+  /**
+   * A `CanceledError` is an object that is thrown when an operation is canceled.
+   *
+   * @param {string=} message The message.
+   * @param {Object=} config The config.
+   * @param {Object=} request The request.
+   *
+   * @returns {CanceledError} The created error.
+   */
+  constructor(message, config, request) {
+    super(message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
+    this.name = 'CanceledError';
+    this.__CANCEL__ = true;
+  }
 }/**
- * A `CanceledError` is an object that is thrown when an operation is canceled.
- *
- * @param {string=} message The message.
- * @param {Object=} config The config.
- * @param {Object=} request The request.
- *
- * @returns {CanceledError} The created error.
- */
-function CanceledError(message, config, request) {
-  // eslint-disable-next-line no-eq-null,eqeqeq
-  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED, config, request);
-  this.name = 'CanceledError';
-}
-utils$1.inherits(CanceledError, AxiosError, {
-  __CANCEL__: true
-});/**
  * Resolve or reject a Promise based on response status.
  *
  * @param {Function} resolve A function that resolves the promise.
@@ -6115,8 +6174,6 @@ function mergeConfig(config1, config2) {
     }
     return source;
   }
-
-  // eslint-disable-next-line consistent-return
   function mergeDeepProperties(a, b, prop, caseless) {
     if (!utils$1.isUndefined(b)) {
       return getMergedValue(a, b, prop, caseless);
@@ -6423,7 +6480,7 @@ var xhrAdapter = isXHRAdapterSupported && function (config) {
     };
     let timer = timeout && setTimeout(() => {
       timer = null;
-      onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT));
+      onabort(new AxiosError(`timeout of ${timeout}ms exceeded`, AxiosError.ETIMEDOUT));
     }, timeout);
     const unsubscribe = () => {
       if (signals) {
@@ -6888,7 +6945,7 @@ function dispatchRequest(config) {
     }
     return Promise.reject(reason);
   });
-}const VERSION = "1.13.1";const validators$1 = {};
+}const VERSION = "1.13.4";const validators$1 = {};
 
 // eslint-disable-next-line func-names
 ['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {
@@ -7281,7 +7338,7 @@ class CancelToken {
  *
  *  ```js
  *  function f(x, y, z) {}
- *  var args = [1, 2, 3];
+ *  const args = [1, 2, 3];
  *  f.apply(null, args);
  *  ```
  *