@gaddario98/react-core 2.0.4 → 2.0.7

package/dist/index.mjs

@@ -1,10 +1,10 @@
-import {atomStateGenerator as atomStateGenerator$1,storage as storage$1}from'@gaddario98/react-state';import {jsx,jsxs,Fragment}from'react/jsx-runtime';import*as React from'react';import React__default,{useReducer,useEffect,useDebugValue,useCallback,useContext,createContext,useRef,useState,memo,useMemo,useLayoutEffect}from'react';import {useApiValues as useApiValues$1,useApiConfigValue as useApiConfigValue$1,useApi as useApi$1,queriesAtom as queriesAtom$1}from'@gaddario98/react-queries';import {c}from'react/compiler-runtime';import equal from'fast-deep-equal';import {useFormValues as useFormValues$1,useFormManager as useFormManager$1}from'@gaddario98/react-form';import {useSyncExternalStoreWithSelector}from'use-sync-external-store/shim/with-selector.js';const {
+import {atomStateGenerator as atomStateGenerator$1,storage as storage$1}from'@gaddario98/react-state';import {jsx,jsxs,Fragment}from'react/jsx-runtime';import*as React from'react';import React__default,{useReducer,useEffect,useDebugValue,useCallback,useContext,createContext,useRef,useState,memo,useMemo,useLayoutEffect}from'react';import {useApiValues as useApiValues$1,useApiConfigValue as useApiConfigValue$1,useApi as useApi$1,queriesAtom as queriesAtom$1,useApiConfigState as useApiConfigState$1}from'@gaddario98/react-queries';import {c}from'react/compiler-runtime';import equal from'fast-deep-equal';import {useFormValues as useFormValues$1,useFormManager as useFormManager$1,useFormConfigState as useFormConfigState$1}from'@gaddario98/react-form';import {useSyncExternalStoreWithSelector}from'use-sync-external-store/shim/with-selector.js';import {useTranslation as useTranslation$1,useLocalizationConfigState as useLocalizationConfigState$1}from'@gaddario98/react-localization';import {usePageConfigState as usePageConfigState$1}from'@gaddario98/react-pages';const {
   atom: authAtom,
   useValue: useAuthValue,
   useState: useAuthState
 } = atomStateGenerator$1({
   defaultValue: null,
-  key: 'reactAuthStore',
+  key: "reactAuthStore",
   persist: true
 });/******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -33,16 +33,16 @@ function __rest(s, e) {
 typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
   var e = new Error(message);
   return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};function hasInitialValue$1(atom) {
+};function hasInitialValue(atom) {
   return "init" in atom;
 }
-function isActuallyWritableAtom$1(atom) {
+function isActuallyWritableAtom(atom) {
   return !!atom.write;
 }
-function isAtomStateInitialized$1(atomState) {
+function isAtomStateInitialized(atomState) {
   return "v" in atomState || "e" in atomState;
 }
-function returnAtomValue$1(atomState) {
+function returnAtomValue(atomState) {
   if ("e" in atomState) {
     throw atomState.e;
   }
@@ -51,23 +51,23 @@ function returnAtomValue$1(atomState) {
   }
   return atomState.v;
 }
-const promiseStateMap$1 = /* @__PURE__ */ new WeakMap();
-function isPendingPromise$1(value) {
+const promiseStateMap = /* @__PURE__ */ new WeakMap();
+function isPendingPromise(value) {
   var _a;
-  return isPromiseLike$4(value) && !!((_a = promiseStateMap$1.get(value)) == null ? void 0 : _a[0]);
+  return isPromiseLike$1(value) && !!((_a = promiseStateMap.get(value)) == null ? void 0 : _a[0]);
 }
-function abortPromise$1(promise) {
-  const promiseState = promiseStateMap$1.get(promise);
+function abortPromise(promise) {
+  const promiseState = promiseStateMap.get(promise);
   if (promiseState == null ? void 0 : promiseState[0]) {
     promiseState[0] = false;
     promiseState[1].forEach((fn) => fn());
   }
 }
-function registerAbortHandler$1(promise, abortHandler) {
-  let promiseState = promiseStateMap$1.get(promise);
+function registerAbortHandler(promise, abortHandler) {
+  let promiseState = promiseStateMap.get(promise);
   if (!promiseState) {
     promiseState = [true, /* @__PURE__ */ new Set()];
-    promiseStateMap$1.set(promise, promiseState);
+    promiseStateMap.set(promise, promiseState);
     const settle = () => {
       promiseState[0] = false;
     };
@@ -75,17 +75,17 @@ function registerAbortHandler$1(promise, abortHandler) {
   }
   promiseState[1].add(abortHandler);
 }
-function isPromiseLike$4(p) {
+function isPromiseLike$1(p) {
   return typeof (p == null ? void 0 : p.then) === "function";
 }
-function addPendingPromiseToDependency$1(atom, promise, dependencyAtomState) {
+function addPendingPromiseToDependency(atom, promise, dependencyAtomState) {
   if (!dependencyAtomState.p.has(atom)) {
     dependencyAtomState.p.add(atom);
     const cleanup = () => dependencyAtomState.p.delete(atom);
     promise.then(cleanup, cleanup);
   }
 }
-function getMountedOrPendingDependents$1(atom, atomState, mountedMap) {
+function getMountedOrPendingDependents(atom, atomState, mountedMap) {
   var _a;
   const dependents = /* @__PURE__ */ new Set();
   for (const a of ((_a = mountedMap.get(atom)) == null ? void 0 : _a.t) || []) {
@@ -96,29 +96,22 @@ function getMountedOrPendingDependents$1(atom, atomState, mountedMap) {
   }
   return dependents;
 }
-const atomRead$1 = (_store, atom, ...params) => atom.read(...params);
-const atomWrite$1 = (_store, atom, ...params) => atom.write(...params);
-const atomOnInit$1 = (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$1 = (_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$1 = (store, atom) => {
+const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
   var _a;
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
+  const buildingBlocks = getInternalBuildingBlocks(store);
   const atomStateMap = buildingBlocks[0];
   const storeHooks = buildingBlocks[6];
-  const atomOnInit2 = buildingBlocks[9];
+  const atomOnInit = buildingBlocks[9];
   if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !atom) {
     throw new Error("Atom is undefined or null");
   }
@@ -127,18 +120,18 @@ const ensureAtomState$1 = (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$1 = (store) => {
-  const buildingBlocks = getInternalBuildingBlocks$1(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 {
@@ -164,28 +157,28 @@ const flushCallbacks$1 = (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$1 = (store) => {
-  const buildingBlocks = getInternalBuildingBlocks$1(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;
@@ -201,7 +194,7 @@ const recomputeInvalidatedAtoms$1 = (store) => {
       continue;
     }
     visiting.add(a);
-    for (const d of getMountedOrPendingDependents$1(a, aState, mountedMap)) {
+    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
       if (!visiting.has(d)) {
         stack.push(d);
       }
@@ -217,35 +210,36 @@ const recomputeInvalidatedAtoms$1 = (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$1 = (store, atom) => {
+const BUILDING_BLOCK_readAtomState = (store, atom) => {
   var _a, _b;
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
+  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);
-  if (isAtomStateInitialized$1(atomState)) {
+  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;
       }
@@ -258,31 +252,31 @@ const readAtomState$1 = (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);
-      if (!isAtomStateInitialized$1(aState2)) {
-        if (hasInitialValue$1(a)) {
-          setAtomStateValueOrPromise$1(store, a, a.init);
+      const aState2 = ensureAtomState(store, a);
+      if (!isAtomStateInitialized(aState2)) {
+        if (hasInitialValue(a)) {
+          setAtomStateValueOrPromise(store, a, a.init);
         } else {
           throw new Error("no atom init");
         }
       }
-      return returnAtomValue$1(aState2);
+      return returnAtomValue(aState2);
     }
-    const aState = readAtomState2(store, a);
+    const aState = readAtomState(store, a);
     try {
-      return returnAtomValue$1(aState);
+      return returnAtomValue(aState);
     } finally {
       atomState.d.set(a, aState.n);
-      if (isPendingPromise$1(atomState.v)) {
-        addPendingPromiseToDependency$1(atom, atomState.v, aState);
+      if (isPendingPromise(atomState.v)) {
+        addPendingPromiseToDependency(atom, atomState.v, aState);
       }
       if (mountedMap.has(atom)) {
         (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom);
@@ -302,20 +296,25 @@ const readAtomState$1 = (store, atom) => {
       return controller.signal;
     },
     get setSelf() {
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom$1(atom)) {
+      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
+        console.warn(
+          "[DEPRECATED] setSelf is deprecated and will be removed in v3."
+        );
+      }
+      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
         console.warn("setSelf function cannot be used with read-only atom");
       }
-      if (!setSelf && isActuallyWritableAtom$1(atom)) {
+      if (!setSelf && isActuallyWritableAtom(atom)) {
         setSelf = (...args) => {
           if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && isSync) {
             console.warn("setSelf function cannot be called in sync");
           }
           if (!isSync) {
             try {
-              return writeAtomState2(store, atom, ...args);
+              return writeAtomState(store, atom, ...args);
             } finally {
-              recomputeInvalidatedAtoms2(store);
-              flushCallbacks2(store);
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
             }
           }
         };
@@ -328,15 +327,15 @@ const readAtomState$1 = (store, atom) => {
     if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
       storeMutationSet.delete(store);
     }
-    const valueOrPromise = atomRead2(store, atom, getter, options);
+    const valueOrPromise = atomRead(store, atom, getter, options);
     if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && storeMutationSet.has(store)) {
       console.warn(
         "Detected store mutation during atom read. This is not supported."
       );
     }
-    setAtomStateValueOrPromise$1(store, atom, valueOrPromise);
-    if (isPromiseLike$4(valueOrPromise)) {
-      registerAbortHandler$1(valueOrPromise, () => controller == null ? void 0 : controller.abort());
+    setAtomStateValueOrPromise(store, atom, valueOrPromise);
+    if (isPromiseLike$1(valueOrPromise)) {
+      registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
       valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
     }
     (_a = storeHooks.r) == null ? void 0 : _a.call(storeHooks, atom);
@@ -355,41 +354,43 @@ const readAtomState$1 = (store, atom) => {
     }
   }
 };
-const invalidateDependents$1 = (store, atom) => {
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
+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);
-    for (const d of getMountedOrPendingDependents$1(a, aState, mountedMap)) {
-      const dState = ensureAtomState2(store, d);
+    const aState = ensureAtomState(store, a);
+    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
+      const dState = ensureAtomState(store, d);
       invalidatedAtoms.set(d, dState.n);
       stack.push(d);
     }
   }
 };
-const writeAtomState$1 = (store, atom, ...args) => {
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
+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$1(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$1(a)) {
+        if (!hasInitialValue(a)) {
           throw new Error("atom not writable");
         }
         if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
@@ -397,52 +398,52 @@ const writeAtomState$1 = (store, atom, ...args) => {
         }
         const prevEpochNumber = aState.n;
         const v = args2[0];
-        setAtomStateValueOrPromise$1(store, a, v);
-        mountDependencies2(store, a);
+        setAtomStateValueOrPromise(store, a, v);
+        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;
       } else {
-        return writeAtomState$1(store, a, ...args2);
+        return writeAtomState(store, a, ...args2);
       }
     } 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$1 = (store, atom) => {
+const BUILDING_BLOCK_mountDependencies = (store, atom) => {
   var _a;
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
+  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$1(atomState.v)) {
+  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);
         }
       }
@@ -450,30 +451,31 @@ const mountDependencies$1 = (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$1 = (store, atom) => {
+const BUILDING_BLOCK_mountAtom = (store, atom) => {
   var _a;
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
+  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$1(store, a);
+      const aMounted = mountAtom(store, a);
       aMounted.t.add(atom);
     }
     mounted = {
@@ -482,21 +484,21 @@ const mountAtom$1 = (store, atom) => {
       t: /* @__PURE__ */ new Set()
     };
     mountedMap.set(atom, mounted);
-    if (isActuallyWritableAtom$1(atom)) {
+    if (isActuallyWritableAtom(atom)) {
       const processOnMount = () => {
         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;
@@ -517,15 +519,15 @@ const mountAtom$1 = (store, atom) => {
   }
   return mounted;
 };
-const unmountAtom$1 = (store, atom) => {
+const BUILDING_BLOCK_unmountAtom = (store, atom) => {
   var _a, _b;
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
+  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;
@@ -544,7 +546,7 @@ const unmountAtom$1 = (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);
@@ -552,17 +554,17 @@ const unmountAtom$1 = (store, atom) => {
   }
   return mounted;
 };
-const setAtomStateValueOrPromise$1 = (store, atom, valueOrPromise) => {
-  const ensureAtomState2 = getInternalBuildingBlocks$1(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$4(valueOrPromise)) {
+  if (isPromiseLike$1(valueOrPromise)) {
     for (const a of atomState.d.keys()) {
-      addPendingPromiseToDependency$1(
+      addPendingPromiseToDependency(
         atom,
         valueOrPromise,
-        ensureAtomState2(store, a)
+        ensureAtomState(store, a)
       );
     }
   }
@@ -570,45 +572,45 @@ const setAtomStateValueOrPromise$1 = (store, atom, valueOrPromise) => {
   delete atomState.e;
   if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
     ++atomState.n;
-    if (isPromiseLike$4(prevValue)) {
-      abortPromise$1(prevValue);
+    if (isPromiseLike$1(prevValue)) {
+      abortPromise(prevValue);
     }
   }
 };
-const storeGet$1 = (store, atom) => {
-  const readAtomState2 = getInternalBuildingBlocks$1(store)[14];
-  return returnAtomValue$1(readAtomState2(store, atom));
+const BUILDING_BLOCK_storeGet = (store, atom) => {
+  const readAtomState = getInternalBuildingBlocks(store)[14];
+  return returnAtomValue(readAtomState(store, atom));
 };
-const storeSet$1 = (store, atom, ...args) => {
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const writeAtomState2 = buildingBlocks[16];
+const BUILDING_BLOCK_storeSet = (store, atom, ...args) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  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$1 = (store, atom, listener) => {
-  const buildingBlocks = getInternalBuildingBlocks$1(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const mountAtom2 = buildingBlocks[18];
-  const unmountAtom2 = buildingBlocks[19];
-  const mounted = mountAtom2(store, atom);
+const BUILDING_BLOCK_storeSub = (store, atom, listener) => {
+  const buildingBlocks = getInternalBuildingBlocks(store);
+  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$1 = /* @__PURE__ */ new WeakMap();
-const getInternalBuildingBlocks$1 = (store) => {
-  const buildingBlocks = buildingBlockMap$1.get(store);
+const buildingBlockMap = /* @__PURE__ */ new WeakMap();
+const getInternalBuildingBlocks = (store) => {
+  const buildingBlocks = buildingBlockMap.get(store);
   if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !buildingBlocks) {
     throw new Error(
       "Store must be created by buildStore to read its building blocks"
@@ -616,19 +618,19 @@ const getInternalBuildingBlocks$1 = (store) => {
   }
   return buildingBlocks;
 };
-function buildStore$1(...buildArgs) {
+function buildStore(...buildArgs) {
   const store = {
     get(atom) {
-      const storeGet2 = getInternalBuildingBlocks$1(store)[21];
-      return storeGet2(store, atom);
+      const storeGet = getInternalBuildingBlocks(store)[21];
+      return storeGet(store, atom);
     },
     set(atom, ...args) {
-      const storeSet2 = getInternalBuildingBlocks$1(store)[22];
-      return storeSet2(store, atom, ...args);
+      const storeSet = getInternalBuildingBlocks(store)[22];
+      return storeSet(store, atom, ...args);
     },
     sub(atom, listener) {
-      const storeSub2 = getInternalBuildingBlocks$1(store)[23];
-      return storeSub2(store, atom, listener);
+      const storeSub = getInternalBuildingBlocks(store)[23];
+      return storeSub(store, atom, listener);
     }
   };
   const buildingBlocks = [
@@ -648,31 +650,31 @@ function buildStore$1(...buildArgs) {
     {},
     // storeHooks
     // atom interceptors
-    atomRead$1,
-    atomWrite$1,
-    atomOnInit$1,
-    atomOnMount$1,
+    BUILDING_BLOCK_atomRead,
+    BUILDING_BLOCK_atomWrite,
+    BUILDING_BLOCK_atomOnInit,
+    BUILDING_BLOCK_atomOnMount,
     // building-block functions
-    ensureAtomState$1,
-    flushCallbacks$1,
-    recomputeInvalidatedAtoms$1,
-    readAtomState$1,
-    invalidateDependents$1,
-    writeAtomState$1,
-    mountDependencies$1,
-    mountAtom$1,
-    unmountAtom$1,
-    setAtomStateValueOrPromise$1,
-    storeGet$1,
-    storeSet$1,
-    storeSub$1,
+    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$1.set(store, Object.freeze(buildingBlocks));
+  buildingBlockMap.set(store, Object.freeze(buildingBlocks));
   return store;
-}let keyCount$1 = 0;
-function atom$1(read, write) {
-  const key = `atom${++keyCount$1}`;
+}let keyCount = 0;
+function atom(read, write) {
+  const key = `atom${++keyCount}`;
   const config = {
     toString() {
       return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
@@ -682,50 +684,50 @@ function atom$1(read, write) {
     config.read = read;
   } else {
     config.init = read;
-    config.read = defaultRead$1;
-    config.write = defaultWrite$1;
+    config.read = defaultRead;
+    config.write = defaultWrite;
   }
   if (write) {
     config.write = write;
   }
   return config;
 }
-function defaultRead$1(get) {
+function defaultRead(get) {
   return get(this);
 }
-function defaultWrite$1(get, set, arg) {
+function defaultWrite(get, set, arg) {
   return set(
     this,
     typeof arg === "function" ? arg(get(this)) : arg
   );
 }
-function createStore$1() {
-  return buildStore$1();
+function createStore() {
+  return buildStore();
 }
-let defaultStore$1;
-function getDefaultStore$1() {
-  if (!defaultStore$1) {
-    defaultStore$1 = createStore$1();
+let defaultStore;
+function getDefaultStore() {
+  if (!defaultStore) {
+    defaultStore = createStore();
     if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-      globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore$1);
-      if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore$1) {
+      globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
+      if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
         console.warn(
           "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
         );
       }
     }
   }
-  return defaultStore$1;
-}const StoreContext$1 = createContext(
+  return defaultStore;
+}const StoreContext = createContext(
   void 0
 );
-function useStore$2(options) {
-  const store = useContext(StoreContext$1);
-  return store || getDefaultStore$1();
+function useStore$1(options) {
+  const store = useContext(StoreContext);
+  return store || getDefaultStore();
 }
 
-const isPromiseLike$2 = (x) => typeof (x == null ? void 0 : x.then) === "function";
-const attachPromiseStatus$1 = (promise) => {
+const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
+const attachPromiseStatus = (promise) => {
   if (!promise.status) {
     promise.status = "pending";
     promise.then(
@@ -740,7 +742,7 @@ const attachPromiseStatus$1 = (promise) => {
     );
   }
 };
-const use$1 = React__default.use || // A shim for older React versions
+const use = React__default.use || // A shim for older React versions
 ((promise) => {
   if (promise.status === "pending") {
     throw promise;
@@ -749,13 +751,13 @@ const use$1 = React__default.use || // A shim for older React versions
   } else if (promise.status === "rejected") {
     throw promise.reason;
   } else {
-    attachPromiseStatus$1(promise);
+    attachPromiseStatus(promise);
     throw promise;
   }
 });
-const continuablePromiseMap$1 = /* @__PURE__ */ new WeakMap();
-const createContinuablePromise$1 = (promise, getValue) => {
-  let continuablePromise = continuablePromiseMap$1.get(promise);
+const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
+const createContinuablePromise = (promise, getValue) => {
+  let continuablePromise = continuablePromiseMap.get(promise);
   if (!continuablePromise) {
     continuablePromise = new Promise((resolve, reject) => {
       let curr = promise;
@@ -772,11 +774,11 @@ const createContinuablePromise$1 = (promise, getValue) => {
       const onAbort = () => {
         try {
           const nextValue = getValue();
-          if (isPromiseLike$2(nextValue)) {
-            continuablePromiseMap$1.set(nextValue, continuablePromise);
+          if (isPromiseLike(nextValue)) {
+            continuablePromiseMap.set(nextValue, continuablePromise);
             curr = nextValue;
             nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
-            registerAbortHandler$1(nextValue, onAbort);
+            registerAbortHandler(nextValue, onAbort);
           } else {
             resolve(nextValue);
           }
@@ -785,15 +787,15 @@ const createContinuablePromise$1 = (promise, getValue) => {
         }
       };
       promise.then(onFulfilled(promise), onRejected(promise));
-      registerAbortHandler$1(promise, onAbort);
+      registerAbortHandler(promise, onAbort);
     });
-    continuablePromiseMap$1.set(promise, continuablePromise);
+    continuablePromiseMap.set(promise, continuablePromise);
   }
   return continuablePromise;
 };
-function useAtomValue$1(atom, options) {
+function useAtomValue(atom, options) {
   const { delay, unstable_promiseStatus: promiseStatus = !React__default.use } = {};
-  const store = useStore$2();
+  const store = useStore$1();
   const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(
     (prev) => {
       const nextValue = store.get(atom);
@@ -815,9 +817,9 @@ function useAtomValue$1(atom, options) {
       if (promiseStatus) {
         try {
           const value2 = store.get(atom);
-          if (isPromiseLike$2(value2)) {
-            attachPromiseStatus$1(
-              createContinuablePromise$1(value2, () => store.get(atom))
+          if (isPromiseLike(value2)) {
+            attachPromiseStatus(
+              createContinuablePromise(value2, () => store.get(atom))
             );
           }
         } catch (e) {
@@ -833,18 +835,18 @@ function useAtomValue$1(atom, options) {
     return unsub;
   }, [store, atom, delay, promiseStatus]);
   useDebugValue(value);
-  if (isPromiseLike$2(value)) {
-    const promise = createContinuablePromise$1(value, () => store.get(atom));
+  if (isPromiseLike(value)) {
+    const promise = createContinuablePromise(value, () => store.get(atom));
     if (promiseStatus) {
-      attachPromiseStatus$1(promise);
+      attachPromiseStatus(promise);
     }
-    return use$1(promise);
+    return use(promise);
   }
   return value;
 }
 
-function useSetAtom$1(atom, options) {
-  const store = useStore$2();
+function useSetAtom(atom, options) {
+  const store = useStore$1();
   const setAtom = useCallback(
     (...args) => {
       if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("write" in atom)) {
@@ -857,11 +859,11 @@ function useSetAtom$1(atom, options) {
   return setAtom;
 }
 
-function useAtom$1(atom, options) {
+function useAtom(atom, options) {
   return [
-    useAtomValue$1(atom),
+    useAtomValue(atom),
     // We do wrong type assertion here, which results in throwing an error.
-    useSetAtom$1(atom)
+    useSetAtom(atom)
   ];
 }/* eslint-disable @typescript-eslint/no-explicit-any */
 /**
@@ -1043,12 +1045,12 @@ function memoize(fn, cacheKeyFn) {
         }
     };
     return createAtom;
-}const pageVariablesAtomFamily = atomFamily(_pageId => atom$1({}));
+}const pageVariablesAtomFamily = atomFamily(_pageId => atom({}));
 /**
  * Global atom storing all page variables.
  * Key format: "scopeId:pageId"
  */
-const pageVariablesAtom = atom$1({});
+const pageVariablesAtom = atom({});
 /**
  * Helper to generate composite keys for page variables.
  */
@@ -1056,7 +1058,7 @@ const getPageVariablesCompositeKey = (scopeId, key) => `${scopeId}:${key}`;
 /**
  * Creates a derived atom for accessing page variables of a specific scope.
  */
-const createScopePageVariablesAtom = scopeId => atom$1(get => {
+const createScopePageVariablesAtom = scopeId => atom(get => {
   const allPageVariables = get(pageVariablesAtom);
   const prefix = `${scopeId}:`;
   const scopePageVariables = {};
@@ -1110,7 +1112,7 @@ const usePageValues = ({
   });
   const subscriptions = useRef(new Map());
   const [trigger, setTrigger] = useState(0);
-  const [pageVariables, setPageVariables] = useAtom$1(pageVariablesAtomFamily(pageId));
+  const [pageVariables, setPageVariables] = useAtom(pageVariablesAtomFamily(pageId));
   const initialized = useRef(false);
   useEffect(() => {
     if (!initialized.current && initialValues) {
@@ -2570,10 +2572,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);
@@ -2595,7 +2598,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++;
   }
@@ -2667,7 +2670,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) {
@@ -2687,6 +2690,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;
@@ -2807,16 +2833,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: {
@@ -2828,7 +2857,7 @@ function dehydrateQuery(query, serializeData, shouldRedactErrors) {
     queryKey: query.queryKey,
     queryHash: query.queryHash,
     ...(query.state.status === "pending" && {
-      promise
+      promise: dehydratePromise()
     }),
     ...(query.meta && {
       meta: query.meta
@@ -3372,7 +3401,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") {
@@ -3564,7 +3593,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 {
@@ -3932,10 +3964,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);
         }
       };
@@ -3951,12 +3985,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;
@@ -4074,19 +4108,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) => {
@@ -4271,7 +4293,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({
@@ -4295,16 +4319,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);
     }
@@ -4588,11 +4625,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 => {
@@ -4619,6 +4672,7 @@ var QueriesObserver = class extends Subscribable {
   #combinedResult;
   #lastCombine;
   #lastResult;
+  #lastQueryHashes;
   #observerMatches = [];
   constructor(client, queries, options) {
     super();
@@ -4661,7 +4715,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());
@@ -4674,6 +4727,7 @@ var QueriesObserver = class extends Subscribable {
       });
       if (!hasStructuralChange && !hasResultChange) return;
       if (hasStructuralChange) {
+        this.#observerMatches = newObserverMatches;
         this.#observers = newObservers;
       }
       this.#result = newResult;
@@ -4703,8 +4757,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);
     }];
@@ -4719,11 +4774,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;
@@ -4731,22 +4791,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;
   }
@@ -5191,8 +5255,9 @@ function createValue() {
 }
 var QueryErrorResetBoundaryContext = React.createContext(createValue());
 var useQueryErrorResetBoundary = () => React.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;
     }
@@ -5248,9 +5313,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.useState(
@@ -5329,6 +5395,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(
@@ -5338,7 +5405,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.useState(
@@ -5371,7 +5438,7 @@ function useBaseQuery(options, Observer, queryClient) {
     result,
     errorResetBoundary,
     throwOnError: defaultedOptions.throwOnError,
-    query: client.getQueryCache().get(defaultedOptions.queryHash),
+    query,
     suspense: defaultedOptions.suspense
   })) {
     throw result.error;
@@ -5386,7 +5453,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();
@@ -5893,7 +5960,7 @@ const MetadataManager = MetadataManagerImpl;const PageGenerator = _a => {
     return (_a_3 = mappedViewSettings.pageContainerProps) !== null && _a_3 !== void 0 ? _a_3 : {};
   }, [mappedViewSettings.pageContainerProps]);
   const layoutBody = useMemo(() => body, [body]);
-  const store = useStore$2();
+  const store = useStore$1();
   const refreshQueries = useCallback(() => {
     const val = store.get(queriesAtom$1);
     Object.values(val).forEach(query => {
@@ -8204,7 +8271,17 @@ class FormApi {
     };
     this.validateField = (field, cause) => {
       const fieldInstance = this.fieldInfo[field]?.instance;
-      if (!fieldInstance) return [];
+      if (!fieldInstance) {
+        const {
+          hasErrored
+        } = this.validateSync(cause);
+        if (hasErrored && !this.options.asyncAlways) {
+          return this.getFieldMeta(field)?.errors ?? [];
+        }
+        return this.validateAsync(cause).then(() => {
+          return this.getFieldMeta(field)?.errors ?? [];
+        });
+      }
       if (!fieldInstance.state.meta.isTouched) {
         fieldInstance.setMeta(prev => ({
           ...prev,
@@ -8891,7 +8968,7 @@ class FormApi {
           if (!prevBaseMeta || currBaseMeta.errorMap !== prevBaseMeta.errorMap) {
             fieldErrors = Object.values(currBaseMeta.errorMap ?? {}).filter(val => val !== void 0);
             const fieldInstance = this.getFieldInfo(fieldName)?.instance;
-            if (fieldInstance && !fieldInstance.options.disableErrorFlat) {
+            if (!fieldInstance || !fieldInstance.options.disableErrorFlat) {
               fieldErrors = fieldErrors.flat(1);
             }
           }
@@ -9629,7 +9706,7 @@ function getErrorMapKey(cause) {
     default:
       return "onChange";
   }
-}function useStore$1(store, selector = (d) => d, options = {}) {
+}function useStore(store, selector = (d) => d, options = {}) {
   const equal = options.equal ?? shallow;
   const slice = useSyncExternalStoreWithSelector(
     store.subscribe,
@@ -9698,31 +9775,31 @@ function getOwnKeys(obj) {
     );
     setPrevOptions({ form: opts.form, name: opts.name });
   }
-  const reactiveStateValue = useStore$1(
+  const reactiveStateValue = useStore(
     fieldApi.store,
     opts.mode === "array" ? (state) => Object.keys(state.value ?? []).length : (state) => state.value
   );
-  const reactiveMetaIsTouched = useStore$1(
+  const reactiveMetaIsTouched = useStore(
     fieldApi.store,
     (state) => state.meta.isTouched
   );
-  const reactiveMetaIsBlurred = useStore$1(
+  const reactiveMetaIsBlurred = useStore(
     fieldApi.store,
     (state) => state.meta.isBlurred
   );
-  const reactiveMetaIsDirty = useStore$1(
+  const reactiveMetaIsDirty = useStore(
     fieldApi.store,
     (state) => state.meta.isDirty
   );
-  const reactiveMetaErrorMap = useStore$1(
+  const reactiveMetaErrorMap = useStore(
     fieldApi.store,
     (state) => state.meta.errorMap
   );
-  const reactiveMetaErrorSourceMap = useStore$1(
+  const reactiveMetaErrorSourceMap = useStore(
     fieldApi.store,
     (state) => state.meta.errorSourceMap
   );
-  const reactiveMetaIsValidating = useStore$1(
+  const reactiveMetaIsValidating = useStore(
     fieldApi.store,
     (state) => state.meta.isValidating
   );
@@ -9785,7 +9862,7 @@ const Field = (({
   selector,
   children
 }) {
-  const data = useStore$1(form.store, selector);
+  const data = useStore(form.store, selector);
   return /* @__PURE__ */ jsx(Fragment, { children: functionalUpdate(children, data) });
 }
 function useForm(opts) {
@@ -9907,7 +9984,7 @@ function useJotaiForm(formOptions) {
   return jsx(FormFieldContainer, {
     children: config.component(baseProps)
   });
-};const RESET$1 = /* @__PURE__ */ Symbol(
+};const RESET = /* @__PURE__ */ Symbol(
   (import.meta.env ? import.meta.env.MODE : void 0) !== "production" ? "RESET" : ""
 );
 
@@ -9929,7 +10006,7 @@ function selectAtom(anAtom, selector, equalityFn = Object.is) {
         const slice = selector(value, prevSlice);
         return equalityFn(prevSlice, slice) ? prevSlice : slice;
       };
-      const derivedAtom = atom$1((get) => {
+      const derivedAtom = atom((get) => {
         const prev = get(derivedAtom);
         const value = get(anAtom);
         return selectValue([value, prev]);
@@ -9943,8 +10020,8 @@ function selectAtom(anAtom, selector, equalityFn = Object.is) {
   );
 }
 
-const isPromiseLike$3$1 = (x) => typeof (x == null ? void 0 : x.then) === "function";
-function createJSONStorage$1(getStringStorage = () => {
+const isPromiseLike$2 = (x) => typeof (x == null ? void 0 : x.then) === "function";
+function createJSONStorage(getStringStorage = () => {
   try {
     return window.localStorage;
   } catch (e) {
@@ -9975,7 +10052,7 @@ function createJSONStorage$1(getStringStorage = () => {
         return lastValue;
       };
       const str = (_b = (_a2 = getStringStorage()) == null ? void 0 : _a2.getItem(key)) != null ? _b : null;
-      if (isPromiseLike$3$1(str)) {
+      if (isPromiseLike$2(str)) {
         return str.then(parse);
       }
       return parse(str);
@@ -10028,10 +10105,10 @@ function createJSONStorage$1(getStringStorage = () => {
   }
   return storage;
 }
-const defaultStorage$1 = createJSONStorage$1();
-function atomWithStorage$1(key, initialValue, storage = defaultStorage$1, options) {
+const defaultStorage = createJSONStorage();
+function atomWithStorage(key, initialValue, storage = defaultStorage, options) {
   const getOnInit = options == null ? void 0 : options.getOnInit;
-  const baseAtom = atom$1(
+  const baseAtom = atom(
     getOnInit ? storage.getItem(key, initialValue) : initialValue
   );
   if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
@@ -10045,15 +10122,15 @@ function atomWithStorage$1(key, initialValue, storage = defaultStorage$1, option
     }
     return unsub;
   };
-  const anAtom = atom$1(
+  const anAtom = atom(
     (get) => get(baseAtom),
     (get, set, update) => {
       const nextValue = typeof update === "function" ? update(get(baseAtom)) : update;
-      if (nextValue === RESET$1) {
+      if (nextValue === RESET) {
         set(baseAtom, initialValue);
         return storage.removeItem(key);
       }
-      if (isPromiseLike$3$1(nextValue)) {
+      if (isPromiseLike$2(nextValue)) {
         return nextValue.then((resolvedValue) => {
           set(baseAtom, resolvedValue);
           return storage.setItem(key, resolvedValue);
@@ -10072,7 +10149,7 @@ function atomWithStorage$1(key, initialValue, storage = defaultStorage$1, option
  * Global atom storing all form state.
  * Key format: "scopeId:formId" or just "formId" for backward compatibility.
  */
-const formAtom = atom$1({});
+const formAtom = atom({});
 /**
  * Helper to generate composite keys for forms.
  */
@@ -10080,7 +10157,7 @@ const getFormCompositeKey = (scopeId, key) => `${scopeId}:${key}`;
 /**
  * Creates a derived atom for accessing forms of a specific scope.
  */
-const createScopeFormsAtom = scopeId => atom$1(get => {
+const createScopeFormsAtom = scopeId => atom(get => {
   const allForms = get(formAtom);
   const prefix = `${scopeId}:`;
   const scopeForms = {};
@@ -10121,13 +10198,13 @@ const useFormValue = formId => {
     t0 = $[1];
   }
   const selectorAtom = t0;
-  return useAtomValue$1(selectorAtom);
+  return useAtomValue(selectorAtom);
 };
 const useFormState = () => {
-  return useAtom$1(formAtom);
+  return useAtom(formAtom);
 };
 const useSetFormState = formId => {
-  const setForms = useSetAtom$1(formAtom);
+  const setForms = useSetAtom(formAtom);
   return useCallback(val => {
     setForms(prev => {
       var _a;
@@ -11010,14 +11087,14 @@ const DEFAULT_MUTATION_ENTRY = Object.freeze({
  * Global atom storing all query results.
  * Key format: "scopeId:queryKey"
  */
-const queriesAtom = atomWithStorage$1('queries-atom', {}, createJSONStorage$1(() => storage$1), {
+const queriesAtom = atomWithStorage('queries-atom', {}, createJSONStorage(() => storage$1), {
   getOnInit: true
 });
 /**
  * Global atom storing all mutation results.
  * Key format: "scopeId:mutationKey"
  */
-const mutationsAtom = atom$1({});
+const mutationsAtom = atom({});
 // ============================================================================
 // Helper to generate composite keys
 // ============================================================================
@@ -11028,7 +11105,7 @@ const getCompositeKey = (scopeId, key) => `${scopeId}:${key}`;
 /**
  * Creates a derived atom for accessing queries of a specific scope.
  */
-const createScopeQueriesAtom = scopeId => atom$1(get => {
+const createScopeQueriesAtom = scopeId => atom(get => {
   const allQueries = get(queriesAtom);
   const prefix = `${scopeId}:`;
   const scopeQueries = {};
@@ -11057,7 +11134,7 @@ const createScopeQueriesAtom = scopeId => atom$1(get => {
 /**
  * Creates a derived atom for accessing mutations of a specific scope.
  */
-const createScopeMutationsAtom = scopeId => atom$1(get => {
+const createScopeMutationsAtom = scopeId => atom(get => {
   const allMutations = get(mutationsAtom);
   const prefix = `${scopeId}:`;
   const scopeMutations = {};
@@ -11356,10 +11433,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, {
@@ -11431,7 +11509,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
  * ```
  *
@@ -11471,7 +11549,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, {
@@ -11479,9 +11558,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
@@ -11514,7 +11603,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
   });
@@ -11841,36 +11935,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;
+};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;
   }
-  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;
-  }
-}
-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,
@@ -11889,46 +11986,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.
  *
@@ -12178,22 +12250,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("#");
@@ -12213,6 +12282,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
    */
@@ -12811,23 +12881,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.
@@ -13062,8 +13131,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);
@@ -13370,7 +13437,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) {
@@ -13835,7 +13902,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) => {
@@ -14228,7 +14295,7 @@ class CancelToken {
  *
  *  ```js
  *  function f(x, y, z) {}
- *  var args = [1, 2, 3];
+ *  const args = [1, 2, 3];
  *  f.apply(null, args);
  *  ```
  *
@@ -14580,7 +14647,7 @@ const {
     (_b = (_a = ref.current).onDataChanged) === null || _b === void 0 ? void 0 : _b.call(_a, result.data);
   }, [result.data]);
   // Sync to Jotai atom for persistence
-  const setQueriesAtom = useSetAtom$1(queriesAtom);
+  const setQueriesAtom = useSetAtom(queriesAtom);
   const queryKeyStr = queryKey.join('-');
   const compositeKey = getCompositeKey(id, queryKeyStr);
   useEffect(() => {
@@ -14719,7 +14786,7 @@ const {
     }
   }));
   // Sync to Jotai atom for persistence
-  const setMutationsAtom = useSetAtom$1(mutationsAtom);
+  const setMutationsAtom = useSetAtom(mutationsAtom);
   const mutationKey = (_b_1 = (_a_2 = restOptions.mutationKey) === null || _a_2 === void 0 ? void 0 : _a_2.join('-')) !== null && _b_1 !== void 0 ? _b_1 : fullEndpoint;
   const compositeKey = getCompositeKey(id, mutationKey);
   useEffect(() => {
@@ -15259,8 +15326,8 @@ const useMultipleMutation = configs => {
     persistToAtoms = true
   } = options;
   // Global atom setters
-  const setQueriesAtom = useSetAtom$1(queriesAtom);
-  const setMutationsAtom = useSetAtom$1(mutationsAtom);
+  const setQueriesAtom = useSetAtom(queriesAtom);
+  const setMutationsAtom = useSetAtom(mutationsAtom);
   // Update a single query in the global atom
   const updateQueryAtom = useCallback((key, state) => {
     const compositeKey = getCompositeKey(scopeId, key);
@@ -15461,7 +15528,7 @@ function useJotaiQueries(options) {
   const {
     scopeId
   } = options;
-  const allQueries = useAtomValue$1(queriesAtom);
+  const allQueries = useAtomValue(queriesAtom);
   const prefix = `${scopeId}:`;
   let scopeQueries;
   if ($[0] !== allQueries || $[1] !== prefix) {
@@ -15487,7 +15554,7 @@ function useJotaiMutations(options) {
   const {
     scopeId
   } = options;
-  const allMutations = useAtomValue$1(mutationsAtom);
+  const allMutations = useAtomValue(mutationsAtom);
   const prefix = `${scopeId}:`;
   let scopeMutations;
   if ($[0] !== allMutations || $[1] !== prefix) {
@@ -16770,931 +16837,7 @@ const baseStorage = {
 let storage = createCompressedStorage(baseStorage);
 const setCustomStorage = newStorage => {
   storage = newStorage;
-};function hasInitialValue(atom) {
-  return "init" in atom;
-}
-function isActuallyWritableAtom(atom) {
-  return !!atom.write;
-}
-function isAtomStateInitialized(atomState) {
-  return "v" in atomState || "e" in atomState;
-}
-function returnAtomValue(atomState) {
-  if ("e" in atomState) {
-    throw atomState.e;
-  }
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("v" in atomState)) {
-    throw new Error("[Bug] atom state is not initialized");
-  }
-  return atomState.v;
-}
-const promiseStateMap = /* @__PURE__ */ new WeakMap();
-function isPendingPromise(value) {
-  var _a;
-  return isPromiseLike$1(value) && !!((_a = promiseStateMap.get(value)) == null ? void 0 : _a[0]);
-}
-function abortPromise(promise) {
-  const promiseState = promiseStateMap.get(promise);
-  if (promiseState == null ? void 0 : promiseState[0]) {
-    promiseState[0] = false;
-    promiseState[1].forEach((fn) => fn());
-  }
-}
-function registerAbortHandler(promise, abortHandler) {
-  let promiseState = promiseStateMap.get(promise);
-  if (!promiseState) {
-    promiseState = [true, /* @__PURE__ */ new Set()];
-    promiseStateMap.set(promise, promiseState);
-    const settle = () => {
-      promiseState[0] = false;
-    };
-    promise.then(settle, settle);
-  }
-  promiseState[1].add(abortHandler);
-}
-function isPromiseLike$1(p) {
-  return typeof (p == null ? void 0 : p.then) === "function";
-}
-function addPendingPromiseToDependency(atom, promise, dependencyAtomState) {
-  if (!dependencyAtomState.p.has(atom)) {
-    dependencyAtomState.p.add(atom);
-    const cleanup = () => dependencyAtomState.p.delete(atom);
-    promise.then(cleanup, cleanup);
-  }
-}
-function getMountedOrPendingDependents(atom, atomState, mountedMap) {
-  var _a;
-  const dependents = /* @__PURE__ */ new Set();
-  for (const a of ((_a = mountedMap.get(atom)) == null ? void 0 : _a.t) || []) {
-    if (mountedMap.has(a)) {
-      dependents.add(a);
-    }
-  }
-  for (const atomWithPendingPromise of atomState.p) {
-    dependents.add(atomWithPendingPromise);
-  }
-  return dependents;
-}
-const atomRead = (_store, atom, ...params) => atom.read(...params);
-const atomWrite = (_store, atom, ...params) => atom.write(...params);
-const atomOnInit = (store, atom) => {
-  var _a;
-  return (_a = atom.unstable_onInit) == null ? void 0 : _a.call(atom, store);
-};
-const atomOnMount = (_store, atom, setAtom) => {
-  var _a;
-  return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
-};
-const ensureAtomState = (store, atom) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const atomStateMap = buildingBlocks[0];
-  const atomOnInit2 = buildingBlocks[9];
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !atom) {
-    throw new Error("Atom is undefined or null");
-  }
-  let atomState = atomStateMap.get(atom);
-  if (!atomState) {
-    atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };
-    atomStateMap.set(atom, atomState);
-    atomOnInit2 == null ? void 0 : atomOnInit2(store, atom);
-  }
-  return atomState;
-};
-const 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 errors = [];
-  const call = (fn) => {
-    try {
-      fn();
-    } catch (e) {
-      errors.push(e);
-    }
-  };
-  do {
-    if (storeHooks.f) {
-      call(storeHooks.f);
-    }
-    const callbacks = /* @__PURE__ */ new Set();
-    const add = callbacks.add.bind(callbacks);
-    changedAtoms.forEach((atom) => {
-      var _a;
-      return (_a = mountedMap.get(atom)) == null ? void 0 : _a.l.forEach(add);
-    });
-    changedAtoms.clear();
-    unmountCallbacks.forEach(add);
-    unmountCallbacks.clear();
-    mountCallbacks.forEach(add);
-    mountCallbacks.clear();
-    callbacks.forEach(call);
-    if (changedAtoms.size) {
-      recomputeInvalidatedAtoms2(store);
-    }
-  } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
-  if (errors.length) {
-    throw new AggregateError(errors);
-  }
-};
-const 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 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);
-    if (visited.has(a)) {
-      stack.pop();
-      continue;
-    }
-    if (visiting.has(a)) {
-      if (invalidatedAtoms.get(a) === aState.n) {
-        topSortedReversed.push([a, aState]);
-      } else if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && invalidatedAtoms.has(a)) {
-        throw new Error("[Bug] invalidated atom exists");
-      }
-      visited.add(a);
-      stack.pop();
-      continue;
-    }
-    visiting.add(a);
-    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      if (!visiting.has(d)) {
-        stack.push(d);
-      }
-    }
-  }
-  for (let i = topSortedReversed.length - 1; i >= 0; --i) {
-    const [a, aState] = topSortedReversed[i];
-    let hasChangedDeps = false;
-    for (const dep of aState.d.keys()) {
-      if (dep !== a && changedAtoms.has(dep)) {
-        hasChangedDeps = true;
-        break;
-      }
-    }
-    if (hasChangedDeps) {
-      readAtomState2(store, a);
-      mountDependencies2(store, a);
-    }
-    invalidatedAtoms.delete(a);
-  }
-};
-const 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);
-  if (isAtomStateInitialized(atomState)) {
-    if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
-      return atomState;
-    }
-    if (Array.from(atomState.d).every(
-      ([a, n]) => (
-        // Recursively, read the atom state of the dependency, and
-        // check if the atom epoch number is unchanged
-        readAtomState2(store, a).n === n
-      )
-    )) {
-      return atomState;
-    }
-  }
-  atomState.d.clear();
-  let isSync = true;
-  function mountDependenciesIfAsync() {
-    if (mountedMap.has(atom)) {
-      mountDependencies2(store, atom);
-      recomputeInvalidatedAtoms2(store);
-      flushCallbacks2(store);
-    }
-  }
-  function getter(a) {
-    var _a2;
-    if (a === atom) {
-      const aState2 = ensureAtomState2(store, a);
-      if (!isAtomStateInitialized(aState2)) {
-        if (hasInitialValue(a)) {
-          setAtomStateValueOrPromise(store, a, a.init);
-        } else {
-          throw new Error("no atom init");
-        }
-      }
-      return returnAtomValue(aState2);
-    }
-    const aState = readAtomState2(store, a);
-    try {
-      return returnAtomValue(aState);
-    } finally {
-      atomState.d.set(a, aState.n);
-      if (isPendingPromise(atomState.v)) {
-        addPendingPromiseToDependency(atom, atomState.v, aState);
-      }
-      (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom);
-      if (!isSync) {
-        mountDependenciesIfAsync();
-      }
-    }
-  }
-  let controller;
-  let setSelf;
-  const options = {
-    get signal() {
-      if (!controller) {
-        controller = new AbortController();
-      }
-      return controller.signal;
-    },
-    get setSelf() {
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
-        console.warn("setSelf function cannot be used with read-only atom");
-      }
-      if (!setSelf && isActuallyWritableAtom(atom)) {
-        setSelf = (...args) => {
-          if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && isSync) {
-            console.warn("setSelf function cannot be called in sync");
-          }
-          if (!isSync) {
-            try {
-              return writeAtomState2(store, atom, ...args);
-            } finally {
-              recomputeInvalidatedAtoms2(store);
-              flushCallbacks2(store);
-            }
-          }
-        };
-      }
-      return setSelf;
-    }
-  };
-  const prevEpochNumber = atomState.n;
-  try {
-    const valueOrPromise = atomRead2(store, atom, getter, options);
-    setAtomStateValueOrPromise(store, atom, valueOrPromise);
-    if (isPromiseLike$1(valueOrPromise)) {
-      registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
-      valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
-    }
-    (_a = storeHooks.r) == null ? void 0 : _a.call(storeHooks, atom);
-    return atomState;
-  } catch (error) {
-    delete atomState.v;
-    atomState.e = error;
-    ++atomState.n;
-    return atomState;
-  } finally {
-    isSync = false;
-    if (prevEpochNumber !== atomState.n && invalidatedAtoms.get(atom) === prevEpochNumber) {
-      invalidatedAtoms.set(atom, atomState.n);
-      changedAtoms.add(atom);
-      (_b = storeHooks.c) == null ? void 0 : _b.call(storeHooks, atom);
-    }
-  }
-};
-const invalidateDependents = (store, atom) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const mountedMap = buildingBlocks[1];
-  const invalidatedAtoms = buildingBlocks[2];
-  const ensureAtomState2 = buildingBlocks[11];
-  const stack = [atom];
-  while (stack.length) {
-    const a = stack.pop();
-    const aState = ensureAtomState2(store, a);
-    for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      const dState = ensureAtomState2(store, d);
-      invalidatedAtoms.set(d, dState.n);
-      stack.push(d);
-    }
-  }
-};
-const 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];
-  let isSync = true;
-  const getter = (a) => returnAtomValue(readAtomState2(store, a));
-  const setter = (a, ...args2) => {
-    var _a;
-    const aState = ensureAtomState2(store, a);
-    try {
-      if (a === atom) {
-        if (!hasInitialValue(a)) {
-          throw new Error("atom not writable");
-        }
-        const prevEpochNumber = aState.n;
-        const v = args2[0];
-        setAtomStateValueOrPromise(store, a, v);
-        mountDependencies2(store, a);
-        if (prevEpochNumber !== aState.n) {
-          changedAtoms.add(a);
-          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
-          invalidateDependents2(store, a);
-        }
-        return void 0;
-      } else {
-        return writeAtomState(store, a, ...args2);
-      }
-    } finally {
-      if (!isSync) {
-        recomputeInvalidatedAtoms2(store);
-        flushCallbacks2(store);
-      }
-    }
-  };
-  try {
-    return atomWrite2(store, atom, getter, setter, ...args);
-  } finally {
-    isSync = false;
-  }
-};
-const 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 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);
-        aMounted.t.add(atom);
-        mounted.d.add(a);
-        if (n !== aState.n) {
-          changedAtoms.add(a);
-          (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
-          invalidateDependents2(store, a);
-        }
-      }
-    }
-    for (const a of mounted.d || []) {
-      if (!atomState.d.has(a)) {
-        mounted.d.delete(a);
-        const aMounted = unmountAtom2(store, a);
-        aMounted == null ? void 0 : aMounted.t.delete(atom);
-      }
-    }
-  }
-};
-const 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);
-  let mounted = mountedMap.get(atom);
-  if (!mounted) {
-    readAtomState2(store, atom);
-    for (const a of atomState.d.keys()) {
-      const aMounted = mountAtom(store, a);
-      aMounted.t.add(atom);
-    }
-    mounted = {
-      l: /* @__PURE__ */ new Set(),
-      d: new Set(atomState.d.keys()),
-      t: /* @__PURE__ */ new Set()
-    };
-    mountedMap.set(atom, mounted);
-    (_a = storeHooks.m) == null ? void 0 : _a.call(storeHooks, atom);
-    if (isActuallyWritableAtom(atom)) {
-      const processOnMount = () => {
-        let isSync = true;
-        const setAtom = (...args) => {
-          try {
-            return writeAtomState2(store, atom, ...args);
-          } finally {
-            if (!isSync) {
-              recomputeInvalidatedAtoms2(store);
-              flushCallbacks2(store);
-            }
-          }
-        };
-        try {
-          const onUnmount = atomOnMount2(store, atom, setAtom);
-          if (onUnmount) {
-            mounted.u = () => {
-              isSync = true;
-              try {
-                onUnmount();
-              } finally {
-                isSync = false;
-              }
-            };
-          }
-        } finally {
-          isSync = false;
-        }
-      };
-      mountCallbacks.add(processOnMount);
-    }
-  }
-  return mounted;
-};
-const unmountAtom = (store, atom) => {
-  var _a;
-  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);
-  let mounted = mountedMap.get(atom);
-  if (mounted && !mounted.l.size && !Array.from(mounted.t).some((a) => {
-    var _a2;
-    return (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.d.has(atom);
-  })) {
-    if (mounted.u) {
-      unmountCallbacks.add(mounted.u);
-    }
-    mounted = void 0;
-    mountedMap.delete(atom);
-    (_a = storeHooks.u) == null ? void 0 : _a.call(storeHooks, atom);
-    for (const a of atomState.d.keys()) {
-      const aMounted = unmountAtom2(store, a);
-      aMounted == null ? void 0 : aMounted.t.delete(atom);
-    }
-    return void 0;
-  }
-  return mounted;
-};
-const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
-  const ensureAtomState2 = getInternalBuildingBlocks(store)[11];
-  const atomState = ensureAtomState2(store, atom);
-  const hasPrevValue = "v" in atomState;
-  const prevValue = atomState.v;
-  if (isPromiseLike$1(valueOrPromise)) {
-    for (const a of atomState.d.keys()) {
-      addPendingPromiseToDependency(
-        atom,
-        valueOrPromise,
-        ensureAtomState2(store, a)
-      );
-    }
-  }
-  atomState.v = valueOrPromise;
-  delete atomState.e;
-  if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
-    ++atomState.n;
-    if (isPromiseLike$1(prevValue)) {
-      abortPromise(prevValue);
-    }
-  }
-};
-const storeGet = (store, atom) => {
-  const readAtomState2 = getInternalBuildingBlocks(store)[14];
-  return returnAtomValue(readAtomState2(store, atom));
-};
-const storeSet = (store, atom, ...args) => {
-  const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const writeAtomState2 = buildingBlocks[16];
-  try {
-    return writeAtomState2(store, atom, ...args);
-  } finally {
-    recomputeInvalidatedAtoms2(store);
-    flushCallbacks2(store);
-  }
-};
-const 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 listeners = mounted.l;
-  listeners.add(listener);
-  flushCallbacks2(store);
-  return () => {
-    listeners.delete(listener);
-    unmountAtom2(store, atom);
-    flushCallbacks2(store);
-  };
-};
-const buildingBlockMap = /* @__PURE__ */ new WeakMap();
-const getInternalBuildingBlocks = (store) => {
-  const buildingBlocks = buildingBlockMap.get(store);
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !buildingBlocks) {
-    throw new Error(
-      "Store must be created by buildStore to read its building blocks"
-    );
-  }
-  return buildingBlocks;
-};
-function buildStore(...buildArgs) {
-  const store = {
-    get(atom) {
-      const storeGet2 = getInternalBuildingBlocks(store)[21];
-      return storeGet2(store, atom);
-    },
-    set(atom, ...args) {
-      const storeSet2 = getInternalBuildingBlocks(store)[22];
-      return storeSet2(store, atom, ...args);
-    },
-    sub(atom, listener) {
-      const storeSub2 = getInternalBuildingBlocks(store)[23];
-      return storeSub2(store, atom, listener);
-    }
-  };
-  const buildingBlocks = [
-    // store state
-    /* @__PURE__ */ new WeakMap(),
-    // atomStateMap
-    /* @__PURE__ */ new WeakMap(),
-    // mountedMap
-    /* @__PURE__ */ new WeakMap(),
-    // invalidatedAtoms
-    /* @__PURE__ */ new Set(),
-    // changedAtoms
-    /* @__PURE__ */ new Set(),
-    // mountCallbacks
-    /* @__PURE__ */ new Set(),
-    // unmountCallbacks
-    {},
-    // storeHooks
-    // atom interceptors
-    atomRead,
-    atomWrite,
-    atomOnInit,
-    atomOnMount,
-    // building-block functions
-    ensureAtomState,
-    flushCallbacks,
-    recomputeInvalidatedAtoms,
-    readAtomState,
-    invalidateDependents,
-    writeAtomState,
-    mountDependencies,
-    mountAtom,
-    unmountAtom,
-    setAtomStateValueOrPromise,
-    storeGet,
-    storeSet,
-    storeSub,
-    void 0
-  ].map((fn, i) => buildArgs[i] || fn);
-  buildingBlockMap.set(store, Object.freeze(buildingBlocks));
-  return store;
-}let keyCount = 0;
-function atom(read, write) {
-  const key = `atom${++keyCount}`;
-  const config = {
-    toString() {
-      return (import.meta.env ? import.meta.env.MODE : void 0) !== "production" && this.debugLabel ? key + ":" + this.debugLabel : key;
-    }
-  };
-  if (typeof read === "function") {
-    config.read = read;
-  } else {
-    config.init = read;
-    config.read = defaultRead;
-    config.write = defaultWrite;
-  }
-  if (write) {
-    config.write = write;
-  }
-  return config;
-}
-function defaultRead(get) {
-  return get(this);
-}
-function defaultWrite(get, set, arg) {
-  return set(
-    this,
-    typeof arg === "function" ? arg(get(this)) : arg
-  );
-}
-function createStore() {
-  return buildStore();
-}
-let defaultStore;
-function getDefaultStore() {
-  if (!defaultStore) {
-    defaultStore = createStore();
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-      globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);
-      if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {
-        console.warn(
-          "Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044"
-        );
-      }
-    }
-  }
-  return defaultStore;
-}const StoreContext = createContext(
-  void 0
-);
-function useStore(options) {
-  const store = useContext(StoreContext);
-  return store || getDefaultStore();
-}
-
-const isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === "function";
-const attachPromiseStatus = (promise) => {
-  if (!promise.status) {
-    promise.status = "pending";
-    promise.then(
-      (v) => {
-        promise.status = "fulfilled";
-        promise.value = v;
-      },
-      (e) => {
-        promise.status = "rejected";
-        promise.reason = e;
-      }
-    );
-  }
-};
-const use = React__default.use || // A shim for older React versions
-((promise) => {
-  if (promise.status === "pending") {
-    throw promise;
-  } else if (promise.status === "fulfilled") {
-    return promise.value;
-  } else if (promise.status === "rejected") {
-    throw promise.reason;
-  } else {
-    attachPromiseStatus(promise);
-    throw promise;
-  }
-});
-const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
-const createContinuablePromise = (promise, getValue) => {
-  let continuablePromise = continuablePromiseMap.get(promise);
-  if (!continuablePromise) {
-    continuablePromise = new Promise((resolve, reject) => {
-      let curr = promise;
-      const onFulfilled = (me) => (v) => {
-        if (curr === me) {
-          resolve(v);
-        }
-      };
-      const onRejected = (me) => (e) => {
-        if (curr === me) {
-          reject(e);
-        }
-      };
-      const onAbort = () => {
-        try {
-          const nextValue = getValue();
-          if (isPromiseLike(nextValue)) {
-            continuablePromiseMap.set(nextValue, continuablePromise);
-            curr = nextValue;
-            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
-            registerAbortHandler(nextValue, onAbort);
-          } else {
-            resolve(nextValue);
-          }
-        } catch (e) {
-          reject(e);
-        }
-      };
-      promise.then(onFulfilled(promise), onRejected(promise));
-      registerAbortHandler(promise, onAbort);
-    });
-    continuablePromiseMap.set(promise, continuablePromise);
-  }
-  return continuablePromise;
-};
-function useAtomValue(atom, options) {
-  const { delay, unstable_promiseStatus: promiseStatus = !React__default.use } = {};
-  const store = useStore();
-  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(
-    (prev) => {
-      const nextValue = store.get(atom);
-      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
-        return prev;
-      }
-      return [nextValue, store, atom];
-    },
-    void 0,
-    () => [store.get(atom), store, atom]
-  );
-  let value = valueFromReducer;
-  if (storeFromReducer !== store || atomFromReducer !== atom) {
-    rerender();
-    value = store.get(atom);
-  }
-  useEffect(() => {
-    const unsub = store.sub(atom, () => {
-      if (promiseStatus) {
-        try {
-          const value2 = store.get(atom);
-          if (isPromiseLike(value2)) {
-            attachPromiseStatus(
-              createContinuablePromise(value2, () => store.get(atom))
-            );
-          }
-        } catch (e) {
-        }
-      }
-      if (typeof delay === "number") {
-        setTimeout(rerender, delay);
-        return;
-      }
-      rerender();
-    });
-    rerender();
-    return unsub;
-  }, [store, atom, delay, promiseStatus]);
-  useDebugValue(value);
-  if (isPromiseLike(value)) {
-    const promise = createContinuablePromise(value, () => store.get(atom));
-    if (promiseStatus) {
-      attachPromiseStatus(promise);
-    }
-    return use(promise);
-  }
-  return value;
-}
-
-function useSetAtom(atom, options) {
-  const store = useStore();
-  const setAtom = useCallback(
-    (...args) => {
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !("write" in atom)) {
-        throw new Error("not writable atom");
-      }
-      return store.set(atom, ...args);
-    },
-    [store, atom]
-  );
-  return setAtom;
-}
-
-function useAtom(atom, options) {
-  return [
-    useAtomValue(atom),
-    // We do wrong type assertion here, which results in throwing an error.
-    useSetAtom(atom)
-  ];
-}const RESET = Symbol(
-  (import.meta.env ? import.meta.env.MODE : void 0) !== "production" ? "RESET" : ""
-);
-
-const isPromiseLike$3 = (x) => typeof (x == null ? void 0 : x.then) === "function";
-function createJSONStorage(getStringStorage = () => {
-  try {
-    return window.localStorage;
-  } catch (e) {
-    if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-      if (typeof window !== "undefined") {
-        console.warn(e);
-      }
-    }
-    return void 0;
-  }
-}, options) {
-  var _a;
-  let lastStr;
-  let lastValue;
-  const storage = {
-    getItem: (key, initialValue) => {
-      var _a2, _b;
-      const parse = (str2) => {
-        str2 = str2 || "";
-        if (lastStr !== str2) {
-          try {
-            lastValue = JSON.parse(str2, void 0 );
-          } catch (e) {
-            return initialValue;
-          }
-          lastStr = str2;
-        }
-        return lastValue;
-      };
-      const str = (_b = (_a2 = getStringStorage()) == null ? void 0 : _a2.getItem(key)) != null ? _b : null;
-      if (isPromiseLike$3(str)) {
-        return str.then(parse);
-      }
-      return parse(str);
-    },
-    setItem: (key, newValue) => {
-      var _a2;
-      return (_a2 = getStringStorage()) == null ? void 0 : _a2.setItem(
-        key,
-        JSON.stringify(newValue, void 0 )
-      );
-    },
-    removeItem: (key) => {
-      var _a2;
-      return (_a2 = getStringStorage()) == null ? void 0 : _a2.removeItem(key);
-    }
-  };
-  const createHandleSubscribe = (subscriber2) => (key, callback, initialValue) => subscriber2(key, (v) => {
-    let newValue;
-    try {
-      newValue = JSON.parse(v || "");
-    } catch (e) {
-      newValue = initialValue;
-    }
-    callback(newValue);
-  });
-  let subscriber;
-  try {
-    subscriber = (_a = getStringStorage()) == null ? void 0 : _a.subscribe;
-  } catch (e) {
-  }
-  if (!subscriber && typeof window !== "undefined" && typeof window.addEventListener === "function" && window.Storage) {
-    subscriber = (key, callback) => {
-      if (!(getStringStorage() instanceof window.Storage)) {
-        return () => {
-        };
-      }
-      const storageEventCallback = (e) => {
-        if (e.storageArea === getStringStorage() && e.key === key) {
-          callback(e.newValue);
-        }
-      };
-      window.addEventListener("storage", storageEventCallback);
-      return () => {
-        window.removeEventListener("storage", storageEventCallback);
-      };
-    };
-  }
-  if (subscriber) {
-    storage.subscribe = createHandleSubscribe(subscriber);
-  }
-  return storage;
-}
-const defaultStorage = createJSONStorage();
-function atomWithStorage(key, initialValue, storage = defaultStorage, options) {
-  const baseAtom = atom(
-    initialValue
-  );
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production") {
-    baseAtom.debugPrivate = true;
-  }
-  baseAtom.onMount = (setAtom) => {
-    setAtom(storage.getItem(key, initialValue));
-    let unsub;
-    if (storage.subscribe) {
-      unsub = storage.subscribe(key, setAtom, initialValue);
-    }
-    return unsub;
-  };
-  const anAtom = atom(
-    (get) => get(baseAtom),
-    (get, set, update) => {
-      const nextValue = typeof update === "function" ? update(get(baseAtom)) : update;
-      if (nextValue === RESET) {
-        set(baseAtom, initialValue);
-        return storage.removeItem(key);
-      }
-      if (isPromiseLike$3(nextValue)) {
-        return nextValue.then((resolvedValue) => {
-          set(baseAtom, resolvedValue);
-          return storage.setItem(key, resolvedValue);
-        });
-      }
-      set(baseAtom, nextValue);
-      return storage.setItem(key, nextValue);
-    }
-  );
-  return anAtom;
-}// Implementazione
+};// Implementazione
 function atomStateGenerator({
   key,
   defaultValue,
@@ -17746,7 +16889,36 @@ function atomStateGenerator({
     useState,
     useReset
   };
-}function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}const CLASS_PART_SEPARATOR = '-';
+}function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}/**
+ * Concatenates two arrays faster than the array spread operator.
+ */
+const concatArrays = (array1, array2) => {
+  // Pre-allocate for better V8 optimization
+  const combinedArray = new Array(array1.length + array2.length);
+  for (let i = 0; i < array1.length; i++) {
+    combinedArray[i] = array1[i];
+  }
+  for (let i = 0; i < array2.length; i++) {
+    combinedArray[array1.length + i] = array2[i];
+  }
+  return combinedArray;
+};
+
+// Factory function ensures consistent object shapes
+const createClassValidatorObject = (classGroupId, validator) => ({
+  classGroupId,
+  validator
+});
+// Factory ensures consistent ClassPartObject shape
+const createClassPartObject = (nextPart = new Map(), validators = null, classGroupId) => ({
+  nextPart,
+  validators,
+  classGroupId
+});
+const CLASS_PART_SEPARATOR = '-';
+const EMPTY_CONFLICTS = [];
+// I use two dots here because one dot is used as prefix for class groups in plugins
+const ARBITRARY_PROPERTY_PREFIX = 'arbitrary..';
 const createClassGroupUtils = config => {
   const classMap = createClassMap(config);
   const {
@@ -17754,54 +16926,73 @@ const createClassGroupUtils = config => {
     conflictingClassGroupModifiers
   } = config;
   const getClassGroupId = className => {
-    const classParts = className.split(CLASS_PART_SEPARATOR);
-    // Classes like `-inset-1` produce an empty string as first classPart. We assume that classes for negative values are used correctly and remove it from classParts.
-    if (classParts[0] === '' && classParts.length !== 1) {
-      classParts.shift();
+    if (className.startsWith('[') && className.endsWith(']')) {
+      return getGroupIdForArbitraryProperty(className);
     }
-    return getGroupRecursive(classParts, classMap) || getGroupIdForArbitraryProperty(className);
+    const classParts = className.split(CLASS_PART_SEPARATOR);
+    // Classes like `-inset-1` produce an empty string as first classPart. We assume that classes for negative values are used correctly and skip it.
+    const startIndex = classParts[0] === '' && classParts.length > 1 ? 1 : 0;
+    return getGroupRecursive(classParts, startIndex, classMap);
   };
   const getConflictingClassGroupIds = (classGroupId, hasPostfixModifier) => {
-    const conflicts = conflictingClassGroups[classGroupId] || [];
-    if (hasPostfixModifier && conflictingClassGroupModifiers[classGroupId]) {
-      return [...conflicts, ...conflictingClassGroupModifiers[classGroupId]];
+    if (hasPostfixModifier) {
+      const modifierConflicts = conflictingClassGroupModifiers[classGroupId];
+      const baseConflicts = conflictingClassGroups[classGroupId];
+      if (modifierConflicts) {
+        if (baseConflicts) {
+          // Merge base conflicts with modifier conflicts
+          return concatArrays(baseConflicts, modifierConflicts);
+        }
+        // Only modifier conflicts
+        return modifierConflicts;
+      }
+      // Fall back to without postfix if no modifier conflicts
+      return baseConflicts || EMPTY_CONFLICTS;
     }
-    return conflicts;
+    return conflictingClassGroups[classGroupId] || EMPTY_CONFLICTS;
   };
   return {
     getClassGroupId,
     getConflictingClassGroupIds
   };
 };
-const getGroupRecursive = (classParts, classPartObject) => {
-  if (classParts.length === 0) {
+const getGroupRecursive = (classParts, startIndex, classPartObject) => {
+  const classPathsLength = classParts.length - startIndex;
+  if (classPathsLength === 0) {
     return classPartObject.classGroupId;
   }
-  const currentClassPart = classParts[0];
+  const currentClassPart = classParts[startIndex];
   const nextClassPartObject = classPartObject.nextPart.get(currentClassPart);
-  const classGroupFromNextClassPart = nextClassPartObject ? getGroupRecursive(classParts.slice(1), nextClassPartObject) : undefined;
-  if (classGroupFromNextClassPart) {
-    return classGroupFromNextClassPart;
+  if (nextClassPartObject) {
+    const result = getGroupRecursive(classParts, startIndex + 1, nextClassPartObject);
+    if (result) return result;
   }
-  if (classPartObject.validators.length === 0) {
+  const validators = classPartObject.validators;
+  if (validators === null) {
     return undefined;
   }
-  const classRest = classParts.join(CLASS_PART_SEPARATOR);
-  return classPartObject.validators.find(({
-    validator
-  }) => validator(classRest))?.classGroupId;
-};
-const arbitraryPropertyRegex = /^\[(.+)\]$/;
-const getGroupIdForArbitraryProperty = className => {
-  if (arbitraryPropertyRegex.test(className)) {
-    const arbitraryPropertyClassName = arbitraryPropertyRegex.exec(className)[1];
-    const property = arbitraryPropertyClassName?.substring(0, arbitraryPropertyClassName.indexOf(':'));
-    if (property) {
-      // I use two dots here because one dot is used as prefix for class groups in plugins
-      return 'arbitrary..' + property;
+  // Build classRest string efficiently by joining from startIndex onwards
+  const classRest = startIndex === 0 ? classParts.join(CLASS_PART_SEPARATOR) : classParts.slice(startIndex).join(CLASS_PART_SEPARATOR);
+  const validatorsLength = validators.length;
+  for (let i = 0; i < validatorsLength; i++) {
+    const validatorObj = validators[i];
+    if (validatorObj.validator(classRest)) {
+      return validatorObj.classGroupId;
     }
   }
+  return undefined;
 };
+/**
+ * Get the class group ID for an arbitrary property.
+ *
+ * @param className - The class name to get the group ID for. Is expected to be string starting with `[` and ending with `]`.
+ */
+const getGroupIdForArbitraryProperty = className => className.slice(1, -1).indexOf(':') === -1 ? undefined : (() => {
+  const content = className.slice(1, -1);
+  const colonIndex = content.indexOf(':');
+  const property = content.slice(0, colonIndex);
+  return property ? ARBITRARY_PROPERTY_PREFIX + property : undefined;
+})();
 /**
  * Exported for testing only
  */
@@ -17810,54 +17001,77 @@ const createClassMap = config => {
     theme,
     classGroups
   } = config;
-  const classMap = {
-    nextPart: new Map(),
-    validators: []
-  };
+  return processClassGroups(classGroups, theme);
+};
+// Split into separate functions to maintain monomorphic call sites
+const processClassGroups = (classGroups, theme) => {
+  const classMap = createClassPartObject();
   for (const classGroupId in classGroups) {
-    processClassesRecursively(classGroups[classGroupId], classMap, classGroupId, theme);
+    const group = classGroups[classGroupId];
+    processClassesRecursively(group, classMap, classGroupId, theme);
   }
   return classMap;
 };
 const processClassesRecursively = (classGroup, classPartObject, classGroupId, theme) => {
-  classGroup.forEach(classDefinition => {
-    if (typeof classDefinition === 'string') {
-      const classPartObjectToEdit = classDefinition === '' ? classPartObject : getPart(classPartObject, classDefinition);
-      classPartObjectToEdit.classGroupId = classGroupId;
-      return;
-    }
-    if (typeof classDefinition === 'function') {
-      if (isThemeGetter(classDefinition)) {
-        processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
-        return;
-      }
-      classPartObject.validators.push({
-        validator: classDefinition,
-        classGroupId
-      });
-      return;
-    }
-    Object.entries(classDefinition).forEach(([key, classGroup]) => {
-      processClassesRecursively(classGroup, getPart(classPartObject, key), classGroupId, theme);
-    });
-  });
+  const len = classGroup.length;
+  for (let i = 0; i < len; i++) {
+    const classDefinition = classGroup[i];
+    processClassDefinition(classDefinition, classPartObject, classGroupId, theme);
+  }
+};
+// Split into separate functions for each type to maintain monomorphic call sites
+const processClassDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
+  if (typeof classDefinition === 'string') {
+    processStringDefinition(classDefinition, classPartObject, classGroupId);
+    return;
+  }
+  if (typeof classDefinition === 'function') {
+    processFunctionDefinition(classDefinition, classPartObject, classGroupId, theme);
+    return;
+  }
+  processObjectDefinition(classDefinition, classPartObject, classGroupId, theme);
+};
+const processStringDefinition = (classDefinition, classPartObject, classGroupId) => {
+  const classPartObjectToEdit = classDefinition === '' ? classPartObject : getPart(classPartObject, classDefinition);
+  classPartObjectToEdit.classGroupId = classGroupId;
+};
+const processFunctionDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
+  if (isThemeGetter(classDefinition)) {
+    processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
+    return;
+  }
+  if (classPartObject.validators === null) {
+    classPartObject.validators = [];
+  }
+  classPartObject.validators.push(createClassValidatorObject(classGroupId, classDefinition));
+};
+const processObjectDefinition = (classDefinition, classPartObject, classGroupId, theme) => {
+  const entries = Object.entries(classDefinition);
+  const len = entries.length;
+  for (let i = 0; i < len; i++) {
+    const [key, value] = entries[i];
+    processClassesRecursively(value, getPart(classPartObject, key), classGroupId, theme);
+  }
 };
 const getPart = (classPartObject, path) => {
-  let currentClassPartObject = classPartObject;
-  path.split(CLASS_PART_SEPARATOR).forEach(pathPart => {
-    if (!currentClassPartObject.nextPart.has(pathPart)) {
-      currentClassPartObject.nextPart.set(pathPart, {
-        nextPart: new Map(),
-        validators: []
-      });
-    }
-    currentClassPartObject = currentClassPartObject.nextPart.get(pathPart);
-  });
-  return currentClassPartObject;
+  let current = classPartObject;
+  const parts = path.split(CLASS_PART_SEPARATOR);
+  const len = parts.length;
+  for (let i = 0; i < len; i++) {
+    const part = parts[i];
+    let next = current.nextPart.get(part);
+    if (!next) {
+      next = createClassPartObject();
+      current.nextPart.set(part, next);
+    }
+    current = next;
+  }
+  return current;
 };
-const isThemeGetter = func => func.isThemeGetter;
+// Type guard maintains monomorphic check
+const isThemeGetter = func => 'isThemeGetter' in func && func.isThemeGetter === true;
 
-// LRU cache inspired from hashlru (https://github.com/dominictarr/hashlru/blob/v1.0.4/index.js) but object replaced with Map to improve performance
+// LRU cache implementation using plain objects for simplicity
 const createLruCache = maxCacheSize => {
   if (maxCacheSize < 1) {
     return {
@@ -17866,31 +17080,31 @@ const createLruCache = maxCacheSize => {
     };
   }
   let cacheSize = 0;
-  let cache = new Map();
-  let previousCache = new Map();
+  let cache = Object.create(null);
+  let previousCache = Object.create(null);
   const update = (key, value) => {
-    cache.set(key, value);
+    cache[key] = value;
     cacheSize++;
     if (cacheSize > maxCacheSize) {
       cacheSize = 0;
       previousCache = cache;
-      cache = new Map();
+      cache = Object.create(null);
     }
   };
   return {
     get(key) {
-      let value = cache.get(key);
+      let value = cache[key];
       if (value !== undefined) {
         return value;
       }
-      if ((value = previousCache.get(key)) !== undefined) {
+      if ((value = previousCache[key]) !== undefined) {
         update(key, value);
         return value;
       }
     },
     set(key, value) {
-      if (cache.has(key)) {
-        cache.set(key, value);
+      if (key in cache) {
+        cache[key] = value;
       } else {
         update(key, value);
       }
@@ -17899,7 +17113,15 @@ const createLruCache = maxCacheSize => {
 };
 const IMPORTANT_MODIFIER = '!';
 const MODIFIER_SEPARATOR = ':';
-const MODIFIER_SEPARATOR_LENGTH = MODIFIER_SEPARATOR.length;
+const EMPTY_MODIFIERS = [];
+// Pre-allocated result object shape for consistency
+const createResultObject = (modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition, isExternal) => ({
+  modifiers,
+  hasImportantModifier,
+  baseClassName,
+  maybePostfixModifierPosition,
+  isExternal
+});
 const createParseClassName = config => {
   const {
     prefix,
@@ -17912,17 +17134,19 @@ const createParseClassName = config => {
    * @see https://github.com/tailwindlabs/tailwindcss/blob/v3.2.2/src/util/splitAtTopLevelOnly.js
    */
   let parseClassName = className => {
+    // Use simple array with push for better performance
     const modifiers = [];
     let bracketDepth = 0;
     let parenDepth = 0;
     let modifierStart = 0;
     let postfixModifierPosition;
-    for (let index = 0; index < className.length; index++) {
-      let currentCharacter = className[index];
+    const len = className.length;
+    for (let index = 0; index < len; index++) {
+      const currentCharacter = className[index];
       if (bracketDepth === 0 && parenDepth === 0) {
         if (currentCharacter === MODIFIER_SEPARATOR) {
           modifiers.push(className.slice(modifierStart, index));
-          modifierStart = index + MODIFIER_SEPARATOR_LENGTH;
+          modifierStart = index + 1;
           continue;
         }
         if (currentCharacter === '/') {
@@ -17930,37 +17154,31 @@ const createParseClassName = config => {
           continue;
         }
       }
-      if (currentCharacter === '[') {
-        bracketDepth++;
-      } else if (currentCharacter === ']') {
-        bracketDepth--;
-      } else if (currentCharacter === '(') {
-        parenDepth++;
-      } else if (currentCharacter === ')') {
-        parenDepth--;
-      }
+      if (currentCharacter === '[') bracketDepth++;else if (currentCharacter === ']') bracketDepth--;else if (currentCharacter === '(') parenDepth++;else if (currentCharacter === ')') parenDepth--;
+    }
+    const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.slice(modifierStart);
+    // Inline important modifier check
+    let baseClassName = baseClassNameWithImportantModifier;
+    let hasImportantModifier = false;
+    if (baseClassNameWithImportantModifier.endsWith(IMPORTANT_MODIFIER)) {
+      baseClassName = baseClassNameWithImportantModifier.slice(0, -1);
+      hasImportantModifier = true;
+    } else if (
+    /**
+     * In Tailwind CSS v3 the important modifier was at the start of the base class name. This is still supported for legacy reasons.
+     * @see https://github.com/dcastil/tailwind-merge/issues/513#issuecomment-2614029864
+     */
+    baseClassNameWithImportantModifier.startsWith(IMPORTANT_MODIFIER)) {
+      baseClassName = baseClassNameWithImportantModifier.slice(1);
+      hasImportantModifier = true;
     }
-    const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.substring(modifierStart);
-    const baseClassName = stripImportantModifier(baseClassNameWithImportantModifier);
-    const hasImportantModifier = baseClassName !== baseClassNameWithImportantModifier;
     const maybePostfixModifierPosition = postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : undefined;
-    return {
-      modifiers,
-      hasImportantModifier,
-      baseClassName,
-      maybePostfixModifierPosition
-    };
+    return createResultObject(modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition);
   };
   if (prefix) {
     const fullPrefix = prefix + MODIFIER_SEPARATOR;
     const parseClassNameOriginal = parseClassName;
-    parseClassName = className => className.startsWith(fullPrefix) ? parseClassNameOriginal(className.substring(fullPrefix.length)) : {
-      isExternal: true,
-      modifiers: [],
-      hasImportantModifier: false,
-      baseClassName: className,
-      maybePostfixModifierPosition: undefined
-    };
+    parseClassName = className => className.startsWith(fullPrefix) ? parseClassNameOriginal(className.slice(fullPrefix.length)) : createResultObject(EMPTY_MODIFIERS, false, className, undefined, true);
   }
   if (experimentalParseClassName) {
     const parseClassNameOriginal = parseClassName;
@@ -17971,19 +17189,6 @@ const createParseClassName = config => {
   }
   return parseClassName;
 };
-const stripImportantModifier = baseClassName => {
-  if (baseClassName.endsWith(IMPORTANT_MODIFIER)) {
-    return baseClassName.substring(0, baseClassName.length - 1);
-  }
-  /**
-   * In Tailwind CSS v3 the important modifier was at the start of the base class name. This is still supported for legacy reasons.
-   * @see https://github.com/dcastil/tailwind-merge/issues/513#issuecomment-2614029864
-   */
-  if (baseClassName.startsWith(IMPORTANT_MODIFIER)) {
-    return baseClassName.substring(1);
-  }
-  return baseClassName;
-};
 
 /**
  * Sorts modifiers according to following schema:
@@ -17991,26 +17196,41 @@ const stripImportantModifier = baseClassName => {
  * - When an arbitrary variant appears, it must be preserved which modifiers are before and after it
  */
 const createSortModifiers = config => {
-  const orderSensitiveModifiers = Object.fromEntries(config.orderSensitiveModifiers.map(modifier => [modifier, true]));
-  const sortModifiers = modifiers => {
-    if (modifiers.length <= 1) {
-      return modifiers;
-    }
-    const sortedModifiers = [];
-    let unsortedModifiers = [];
-    modifiers.forEach(modifier => {
-      const isPositionSensitive = modifier[0] === '[' || orderSensitiveModifiers[modifier];
-      if (isPositionSensitive) {
-        sortedModifiers.push(...unsortedModifiers.sort(), modifier);
-        unsortedModifiers = [];
+  // Pre-compute weights for all known modifiers for O(1) comparison
+  const modifierWeights = new Map();
+  // Assign weights to sensitive modifiers (highest priority, but preserve order)
+  config.orderSensitiveModifiers.forEach((mod, index) => {
+    modifierWeights.set(mod, 1000000 + index); // High weights for sensitive mods
+  });
+  return modifiers => {
+    const result = [];
+    let currentSegment = [];
+    // Process modifiers in one pass
+    for (let i = 0; i < modifiers.length; i++) {
+      const modifier = modifiers[i];
+      // Check if modifier is sensitive (starts with '[' or in orderSensitiveModifiers)
+      const isArbitrary = modifier[0] === '[';
+      const isOrderSensitive = modifierWeights.has(modifier);
+      if (isArbitrary || isOrderSensitive) {
+        // Sort and flush current segment alphabetically
+        if (currentSegment.length > 0) {
+          currentSegment.sort();
+          result.push(...currentSegment);
+          currentSegment = [];
+        }
+        result.push(modifier);
       } else {
-        unsortedModifiers.push(modifier);
+        // Regular modifier - add to current segment for batch sorting
+        currentSegment.push(modifier);
       }
-    });
-    sortedModifiers.push(...unsortedModifiers.sort());
-    return sortedModifiers;
+    }
+    // Sort and add any remaining segment items
+    if (currentSegment.length > 0) {
+      currentSegment.sort();
+      result.push(...currentSegment);
+    }
+    return result;
   };
-  return sortModifiers;
 };
 const createConfigUtils = config => ({
   cache: createLruCache(config.cacheSize),
@@ -18065,10 +17285,11 @@ const mergeClassList = (classList, configUtils) => {
       }
       hasPostfixModifier = false;
     }
-    const variantModifier = sortModifiers(modifiers).join(':');
+    // Fast path: skip sorting for empty or single modifier
+    const variantModifier = modifiers.length === 0 ? '' : modifiers.length === 1 ? modifiers[0] : sortModifiers(modifiers).join(':');
     const modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier;
     const classId = modifierId + classGroupId;
-    if (classGroupsInConflict.includes(classId)) {
+    if (classGroupsInConflict.indexOf(classId) > -1) {
       // Tailwind class omitted due to conflict
       continue;
     }
@@ -18093,13 +17314,13 @@ const mergeClassList = (classList, configUtils) => {
  *
  * Original code has MIT license: Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
  */
-function twJoin() {
+const twJoin = (...classLists) => {
   let index = 0;
   let argument;
   let resolvedValue;
   let string = '';
-  while (index < arguments.length) {
-    if (argument = arguments[index++]) {
+  while (index < classLists.length) {
+    if (argument = classLists[index++]) {
       if (resolvedValue = toValue(argument)) {
         string && (string += ' ');
         string += resolvedValue;
@@ -18107,8 +17328,9 @@ function twJoin() {
     }
   }
   return string;
-}
+};
 const toValue = mix => {
+  // Fast path for strings
   if (typeof mix === 'string') {
     return mix;
   }
@@ -18124,20 +17346,20 @@ const toValue = mix => {
   }
   return string;
 };
-function createTailwindMerge(createConfigFirst, ...createConfigRest) {
+const createTailwindMerge = (createConfigFirst, ...createConfigRest) => {
   let configUtils;
   let cacheGet;
   let cacheSet;
-  let functionToCall = initTailwindMerge;
-  function initTailwindMerge(classList) {
+  let functionToCall;
+  const initTailwindMerge = classList => {
     const config = createConfigRest.reduce((previousConfig, createConfigCurrent) => createConfigCurrent(previousConfig), createConfigFirst());
     configUtils = createConfigUtils(config);
     cacheGet = configUtils.cache.get;
     cacheSet = configUtils.cache.set;
     functionToCall = tailwindMerge;
     return tailwindMerge(classList);
-  }
-  function tailwindMerge(classList) {
+  };
+  const tailwindMerge = classList => {
     const cachedResult = cacheGet(classList);
     if (cachedResult) {
       return cachedResult;
@@ -18145,13 +17367,13 @@ function createTailwindMerge(createConfigFirst, ...createConfigRest) {
     const result = mergeClassList(classList, configUtils);
     cacheSet(classList, result);
     return result;
-  }
-  return function callTailwindMerge() {
-    return functionToCall(twJoin.apply(null, arguments));
   };
-}
+  functionToCall = initTailwindMerge;
+  return (...args) => functionToCall(twJoin(...args));
+};
+const fallbackThemeArr = [];
 const fromTheme = key => {
-  const themeGetter = theme => theme[key] || [];
+  const themeGetter = theme => theme[key] || fallbackThemeArr;
   themeGetter.isThemeGetter = true;
   return themeGetter;
 };
@@ -20718,4 +19940,136 @@ function createExtractor(allData, cache, usedKeys) {
  */
 function withMemo(Component, propsAreEqual) {
   return memo(Component, propsAreEqual);
-}export{AppProviders,DEFAULT_FORM_ENTRY,DEFAULT_MUTATION_ENTRY,DEFAULT_QUERY_ENTRY,DefaultContainer,DefaultFormContainer,FormField,FormManager,MemoizationCache,MetadataStoreProvider,PageGenerator,QueriesProvider,RenderComponents,ab2str,algorithm,apiConfigAtom,apiRequest,applyMetadataToDom,atomStateGenerator,authAtom,buildArticleJsonLd,buildBreadcrumbListJsonLd,buildFAQPageJsonLd,buildOrganizationJsonLd,buildProductJsonLd,buildWebSiteJsonLd,clearMetadataLog,cn,collectMetadataToHtml,createExtractor,createFormSelector,createMetadataStore,createMutationSelector,createQuerySelector,createScopeFormsAtom,createScopeMutationsAtom,createScopePageVariablesAtom,createScopeQueriesAtom,createServerTranslator,decryptData,deepEqual,encryptData,fetchRequest,formAtom,formConfigAtom,generateLlmsFullTxt,generateLlmsTxt,generateRobotsTxt,generateSitemapEntries,generateSitemapXml,getCompositeKey,getFormCompositeKey,getMetadata,getMetadataLog,getPageConfig,getPageVariablesCompositeKey,importKey,isStableValue,localizationConfigAtom,logMetadata,memoPropsComparator,memoize,mutationsAtom,optimizeDeps,pageConfigAtom,pageToMarkdown,pageVariablesAtom,pageVariablesAtomFamily,queriesAtom,resetMetadata,resolveMetadata,resolveTranslation,setCustomStorage,setDefaultFormContainer,setMetadata,setMetadataLogging,shallowEqual,storage,str2ab,toNextHeadTags,toNextMetadata,useApi,useApiConfigReset,useApiConfigState,useApiConfigValue,useApiValues,useApplyMetadata,useAuthState,useAuthValue,useFormConfigReset,useFormConfigState,useFormConfigValue,useFormData,useFormManager,useFormState,useFormValue,useFormValues,useGenerateContent,useGenerateContentRender,useInvalidateQueries,useJotaiForm,useJotaiMutations,useJotaiQueries,useLocalizationActions,useLocalizationConfigReset,useLocalizationConfigState,useLocalizationConfigValue,useMetadata,useMetadataStore,useMultipleMutation,useMultipleQuery,useMultipleWebSocket,useMutateApi,usePageConfig,usePageConfigReset,usePageConfigState,usePageConfigValue,useQueryApi,useSetFormState,useTranslatedText,useTranslation,useViewSettings,useWebSocket,withMemo};//# sourceMappingURL=index.mjs.map
+}const {
+  useState: useNotificationState
+} = atomStateGenerator$1({
+  defaultValue: null,
+  key: 'reactNotificationAtom',
+  persist: false
+});const useNotificationSet = () => {
+  const [, setValue] = useNotificationState();
+  return setValue;
+};
+const useNotification = t0 => {
+  const $ = c(10);
+  const ns = "notifications" ;
+  const setNotification = useNotificationSet();
+  let t1;
+  if ($[0] !== ns || $[1] !== setNotification) {
+    t1 = {
+      setNotification,
+      ns
+    };
+    $[0] = ns;
+    $[1] = setNotification;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const ref = useRef(t1);
+  let t2;
+  let t3;
+  if ($[3] !== ns || $[4] !== setNotification) {
+    t2 = () => {
+      ref.current = {
+        setNotification,
+        ns
+      };
+    };
+    t3 = [setNotification, ns];
+    $[3] = ns;
+    $[4] = setNotification;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t2 = $[5];
+    t3 = $[6];
+  }
+  useEffect(t2, t3);
+  let t4;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = notification => {
+      ref.current.setNotification(Object.assign(Object.assign({
+        ns: ref.current.ns
+      }, notification), {
+        id: Date.now().toString()
+      }));
+    };
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const showNotification = t4;
+  let t5;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = () => {
+      ref.current.setNotification(null);
+    };
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  const clearNotification = t5;
+  let t6;
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = {
+      showNotification,
+      clearNotification
+    };
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  return t6;
+};/**
+ * Hook per accedere a tutte le configurazioni dei plugin di core
+ * Fornisce un'interfaccia centralizzata per le impostazioni dell'applicazione
+ */
+const isLogged = authState => !!(authState === null || authState === void 0 ? void 0 : authState.id) && !!authState.isLogged;
+const useCoreConfig = ({
+  form,
+  localization,
+  pages,
+  apiConfig
+}) => {
+  const auth = useAuthValue();
+  const {
+    t: translateText
+  } = useTranslation$1();
+  const {
+    showNotification
+  } = useNotification();
+  const [currentFormConfig, setFormConfig] = useFormConfigState$1();
+  const [currentLocalizationConfig, setLocalizationConfig] = useLocalizationConfigState$1();
+  const [currentPageConfig, setPageConfig] = usePageConfigState$1();
+  const [currentApiConfig, setApiConfig] = useApiConfigState$1();
+  useEffect(() => {
+    setFormConfig(Object.assign(Object.assign({
+      translateText,
+      showNotification
+    }, currentFormConfig), form));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [translateText, showNotification, form]);
+  useEffect(() => {
+    setLocalizationConfig(Object.assign(Object.assign({}, currentLocalizationConfig), localization));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [JSON.stringify(localization)]);
+  useEffect(() => {
+    setPageConfig(Object.assign(Object.assign(Object.assign({
+      authValues: auth
+    }, currentPageConfig), pages), {
+      isLogged
+    }));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [pages, JSON.stringify(auth)]);
+  useEffect(() => {
+    setApiConfig(Object.assign(Object.assign({
+      defaultHeaders: {
+        Authorization: (auth === null || auth === void 0 ? void 0 : auth.token) ? `Bearer ${auth.token}` : ""
+      },
+      showNotification,
+      validateAuthFn: () => !!(auth === null || auth === void 0 ? void 0 : auth.isLogged)
+    }, currentApiConfig), apiConfig));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [apiConfig, showNotification, JSON.stringify(auth)]);
+};export{AppProviders,DEFAULT_FORM_ENTRY,DEFAULT_MUTATION_ENTRY,DEFAULT_QUERY_ENTRY,DefaultContainer,DefaultFormContainer,FormField,FormManager,MemoizationCache,MetadataStoreProvider,PageGenerator,QueriesProvider,RenderComponents,ab2str,algorithm,apiConfigAtom,apiRequest,applyMetadataToDom,atomStateGenerator,authAtom,buildArticleJsonLd,buildBreadcrumbListJsonLd,buildFAQPageJsonLd,buildOrganizationJsonLd,buildProductJsonLd,buildWebSiteJsonLd,clearMetadataLog,cn,collectMetadataToHtml,createExtractor,createFormSelector,createMetadataStore,createMutationSelector,createQuerySelector,createScopeFormsAtom,createScopeMutationsAtom,createScopePageVariablesAtom,createScopeQueriesAtom,createServerTranslator,decryptData,deepEqual,encryptData,fetchRequest,formAtom,formConfigAtom,generateLlmsFullTxt,generateLlmsTxt,generateRobotsTxt,generateSitemapEntries,generateSitemapXml,getCompositeKey,getFormCompositeKey,getMetadata,getMetadataLog,getPageConfig,getPageVariablesCompositeKey,importKey,isStableValue,localizationConfigAtom,logMetadata,memoPropsComparator,memoize,mutationsAtom,optimizeDeps,pageConfigAtom,pageToMarkdown,pageVariablesAtom,pageVariablesAtomFamily,queriesAtom,resetMetadata,resolveMetadata,resolveTranslation,setCustomStorage,setDefaultFormContainer,setMetadata,setMetadataLogging,shallowEqual,storage,str2ab,toNextHeadTags,toNextMetadata,useApi,useApiConfigReset,useApiConfigState,useApiConfigValue,useApiValues,useApplyMetadata,useAuthState,useAuthValue,useCoreConfig,useFormConfigReset,useFormConfigState,useFormConfigValue,useFormData,useFormManager,useFormState,useFormValue,useFormValues,useGenerateContent,useGenerateContentRender,useInvalidateQueries,useJotaiForm,useJotaiMutations,useJotaiQueries,useLocalizationActions,useLocalizationConfigReset,useLocalizationConfigState,useLocalizationConfigValue,useMetadata,useMetadataStore,useMultipleMutation,useMultipleQuery,useMultipleWebSocket,useMutateApi,usePageConfig,usePageConfigReset,usePageConfigState,usePageConfigValue,useQueryApi,useSetFormState,useTranslatedText,useTranslation,useViewSettings,useWebSocket,withMemo};//# sourceMappingURL=index.mjs.map