@gaddario98/react-core 2.0.4 → 2.0.7

package/dist/state/index.js

@@ -1004,29 +1004,29 @@ 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);
-    }
+    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) => {
+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.unstable_onInit) == null ? void 0 : _a.call(atom, store);
+  return (_a = atom.INTERNAL_onInit) == null ? void 0 : _a.call(atom, store);
 };
-const atomOnMount = (_store, atom, setAtom) => {
+const BUILDING_BLOCK_atomOnMount = (_store, atom, setAtom) => {
   var _a;
   return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
 };
-const ensureAtomState = (store, atom) => {
+const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
+  var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const atomStateMap = buildingBlocks[0];
-  const atomOnInit2 = buildingBlocks[9];
+  const storeHooks = buildingBlocks[6];
+  const atomOnInit = buildingBlocks[9];
   if ((undefined ? undefined.MODE : void 0) !== "production" && !atom) {
     throw new Error("Atom is undefined or null");
   }
@@ -1034,18 +1034,19 @@ const ensureAtomState = (store, 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);
+    (_a = storeHooks.i) == null ? void 0 : _a.call(storeHooks, atom);
+    atomOnInit == null ? void 0 : atomOnInit(store, atom);
   }
   return atomState;
 };
-const flushCallbacks = (store) => {
+const BUILDING_BLOCK_flushCallbacks = (store) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const changedAtoms = buildingBlocks[3];
   const mountCallbacks = buildingBlocks[4];
   const unmountCallbacks = buildingBlocks[5];
   const storeHooks = buildingBlocks[6];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
   const errors = [];
   const call = (fn) => {
     try {
@@ -1071,28 +1072,28 @@ const flushCallbacks = (store) => {
     mountCallbacks.clear();
     callbacks.forEach(call);
     if (changedAtoms.size) {
-      recomputeInvalidatedAtoms2(store);
+      recomputeInvalidatedAtoms(store);
     }
   } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
   if (errors.length) {
     throw new AggregateError(errors);
   }
 };
-const recomputeInvalidatedAtoms = (store) => {
+const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
   const changedAtoms = buildingBlocks[3];
-  const ensureAtomState2 = buildingBlocks[11];
-  const readAtomState2 = buildingBlocks[14];
-  const mountDependencies2 = buildingBlocks[17];
+  const ensureAtomState = buildingBlocks[11];
+  const readAtomState = buildingBlocks[14];
+  const mountDependencies = buildingBlocks[17];
   const topSortedReversed = [];
   const visiting = /* @__PURE__ */ new WeakSet();
   const visited = /* @__PURE__ */ new WeakSet();
   const stack = Array.from(changedAtoms);
   while (stack.length) {
     const a = stack[stack.length - 1];
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     if (visited.has(a)) {
       stack.pop();
       continue;
@@ -1124,38 +1125,41 @@ const recomputeInvalidatedAtoms = (store) => {
       }
     }
     if (hasChangedDeps) {
-      readAtomState2(store, a);
-      mountDependencies2(store, a);
+      readAtomState(store, a);
+      mountDependencies(store, a);
     }
     invalidatedAtoms.delete(a);
   }
 };
-const readAtomState = (store, atom) => {
+const storeMutationSet = /* @__PURE__ */ new WeakSet();
+const BUILDING_BLOCK_readAtomState = (store, atom) => {
   var _a, _b;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const atomRead2 = buildingBlocks[7];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const writeAtomState2 = buildingBlocks[16];
-  const mountDependencies2 = buildingBlocks[17];
-  const atomState = ensureAtomState2(store, atom);
+  const atomRead = buildingBlocks[7];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const writeAtomState = buildingBlocks[16];
+  const mountDependencies = buildingBlocks[17];
+  const setAtomStateValueOrPromise = buildingBlocks[20];
+  const atomState = ensureAtomState(store, atom);
   if (isAtomStateInitialized(atomState)) {
     if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
       return atomState;
     }
-    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
-      )
-    )) {
+    let hasChangedDeps = false;
+    for (const [a, n] of atomState.d) {
+      if (readAtomState(store, a).n !== n) {
+        hasChangedDeps = true;
+        break;
+      }
+    }
+    if (!hasChangedDeps) {
       return atomState;
     }
   }
@@ -1163,15 +1167,15 @@ const readAtomState = (store, atom) => {
   let isSync = true;
   function mountDependenciesIfAsync() {
     if (mountedMap.has(atom)) {
-      mountDependencies2(store, atom);
-      recomputeInvalidatedAtoms2(store);
-      flushCallbacks2(store);
+      mountDependencies(store, atom);
+      recomputeInvalidatedAtoms(store);
+      flushCallbacks(store);
     }
   }
   function getter(a) {
     var _a2;
     if (a === atom) {
-      const aState2 = ensureAtomState2(store, a);
+      const aState2 = ensureAtomState(store, a);
       if (!isAtomStateInitialized(aState2)) {
         if (hasInitialValue(a)) {
           setAtomStateValueOrPromise(store, a, a.init);
@@ -1181,7 +1185,7 @@ const readAtomState = (store, atom) => {
       }
       return returnAtomValue(aState2);
     }
-    const aState = readAtomState2(store, a);
+    const aState = readAtomState(store, a);
     try {
       return returnAtomValue(aState);
     } finally {
@@ -1189,7 +1193,9 @@ const readAtomState = (store, atom) => {
       if (isPendingPromise(atomState.v)) {
         addPendingPromiseToDependency(atom, atomState.v, aState);
       }
-      (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom);
+      if (mountedMap.has(atom)) {
+        (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.t.add(atom);
+      }
       if (!isSync) {
         mountDependenciesIfAsync();
       }
@@ -1205,6 +1211,11 @@ const readAtomState = (store, atom) => {
       return controller.signal;
     },
     get setSelf() {
+      if ((undefined ? undefined.MODE : void 0) !== "production") {
+        console.warn(
+          "[DEPRECATED] setSelf is deprecated and will be removed in v3."
+        );
+      }
       if ((undefined ? undefined.MODE : void 0) !== "production" && !isActuallyWritableAtom(atom)) {
         console.warn("setSelf function cannot be used with read-only atom");
       }
@@ -1215,10 +1226,10 @@ const readAtomState = (store, atom) => {
           }
           if (!isSync) {
             try {
-              return writeAtomState2(store, atom, ...args);
+              return writeAtomState(store, atom, ...args);
             } finally {
-              recomputeInvalidatedAtoms2(store);
-              flushCallbacks2(store);
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
             }
           }
         };
@@ -1228,7 +1239,15 @@ const readAtomState = (store, atom) => {
   };
   const prevEpochNumber = atomState.n;
   try {
-    const valueOrPromise = atomRead2(store, atom, getter, options);
+    if ((undefined ? undefined.MODE : void 0) !== "production") {
+      storeMutationSet.delete(store);
+    }
+    const valueOrPromise = atomRead(store, atom, getter, options);
+    if ((undefined ? undefined.MODE : void 0) !== "production" && storeMutationSet.has(store)) {
+      console.warn(
+        "Detected store mutation during atom read. This is not supported."
+      );
+    }
     setAtomStateValueOrPromise(store, atom, valueOrPromise);
     if (isPromiseLike$1(valueOrPromise)) {
       registerAbortHandler(valueOrPromise, () => controller == null ? void 0 : controller.abort());
@@ -1250,51 +1269,56 @@ const readAtomState = (store, atom) => {
     }
   }
 };
-const invalidateDependents = (store, atom) => {
+const BUILDING_BLOCK_invalidateDependents = (store, atom) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const invalidatedAtoms = buildingBlocks[2];
-  const ensureAtomState2 = buildingBlocks[11];
+  const ensureAtomState = buildingBlocks[11];
   const stack = [atom];
   while (stack.length) {
     const a = stack.pop();
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-      const dState = ensureAtomState2(store, d);
+      const dState = ensureAtomState(store, d);
       invalidatedAtoms.set(d, dState.n);
       stack.push(d);
     }
   }
 };
-const writeAtomState = (store, atom, ...args) => {
+const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const atomWrite2 = buildingBlocks[8];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const invalidateDependents2 = buildingBlocks[15];
-  const mountDependencies2 = buildingBlocks[17];
+  const atomWrite = buildingBlocks[8];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const invalidateDependents = buildingBlocks[15];
+  const writeAtomState = buildingBlocks[16];
+  const mountDependencies = buildingBlocks[17];
+  const setAtomStateValueOrPromise = buildingBlocks[20];
   let isSync = true;
-  const getter = (a) => returnAtomValue(readAtomState2(store, a));
+  const getter = (a) => returnAtomValue(readAtomState(store, a));
   const setter = (a, ...args2) => {
     var _a;
-    const aState = ensureAtomState2(store, a);
+    const aState = ensureAtomState(store, a);
     try {
       if (a === atom) {
         if (!hasInitialValue(a)) {
           throw new Error("atom not writable");
         }
+        if ((undefined ? undefined.MODE : void 0) !== "production") {
+          storeMutationSet.add(store);
+        }
         const prevEpochNumber = aState.n;
         const v = args2[0];
         setAtomStateValueOrPromise(store, a, v);
-        mountDependencies2(store, a);
+        mountDependencies(store, a);
         if (prevEpochNumber !== aState.n) {
           changedAtoms.add(a);
+          invalidateDependents(store, a);
           (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
-          invalidateDependents2(store, a);
         }
         return void 0;
       } else {
@@ -1302,68 +1326,69 @@ const writeAtomState = (store, atom, ...args) => {
       }
     } finally {
       if (!isSync) {
-        recomputeInvalidatedAtoms2(store);
-        flushCallbacks2(store);
+        recomputeInvalidatedAtoms(store);
+        flushCallbacks(store);
       }
     }
   };
   try {
-    return atomWrite2(store, atom, getter, setter, ...args);
+    return atomWrite(store, atom, getter, setter, ...args);
   } finally {
     isSync = false;
   }
 };
-const mountDependencies = (store, atom) => {
+const BUILDING_BLOCK_mountDependencies = (store, atom) => {
   var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const changedAtoms = buildingBlocks[3];
   const storeHooks = buildingBlocks[6];
-  const ensureAtomState2 = buildingBlocks[11];
-  const invalidateDependents2 = buildingBlocks[15];
-  const mountAtom2 = buildingBlocks[18];
-  const unmountAtom2 = buildingBlocks[19];
-  const atomState = ensureAtomState2(store, atom);
+  const ensureAtomState = buildingBlocks[11];
+  const invalidateDependents = buildingBlocks[15];
+  const mountAtom = buildingBlocks[18];
+  const unmountAtom = buildingBlocks[19];
+  const atomState = ensureAtomState(store, atom);
   const mounted = mountedMap.get(atom);
   if (mounted && !isPendingPromise(atomState.v)) {
     for (const [a, n] of atomState.d) {
       if (!mounted.d.has(a)) {
-        const aState = ensureAtomState2(store, a);
-        const aMounted = mountAtom2(store, a);
+        const aState = ensureAtomState(store, a);
+        const aMounted = mountAtom(store, a);
         aMounted.t.add(atom);
         mounted.d.add(a);
         if (n !== aState.n) {
           changedAtoms.add(a);
+          invalidateDependents(store, a);
           (_a = storeHooks.c) == null ? void 0 : _a.call(storeHooks, a);
-          invalidateDependents2(store, a);
         }
       }
     }
-    for (const a of mounted.d || []) {
+    for (const a of mounted.d) {
       if (!atomState.d.has(a)) {
         mounted.d.delete(a);
-        const aMounted = unmountAtom2(store, a);
+        const aMounted = unmountAtom(store, a);
         aMounted == null ? void 0 : aMounted.t.delete(atom);
       }
     }
   }
 };
-const mountAtom = (store, atom) => {
+const BUILDING_BLOCK_mountAtom = (store, atom) => {
   var _a;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const mountCallbacks = buildingBlocks[4];
   const storeHooks = buildingBlocks[6];
-  const atomOnMount2 = buildingBlocks[10];
-  const ensureAtomState2 = buildingBlocks[11];
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const readAtomState2 = buildingBlocks[14];
-  const writeAtomState2 = buildingBlocks[16];
-  const atomState = ensureAtomState2(store, atom);
+  const atomOnMount = buildingBlocks[10];
+  const ensureAtomState = buildingBlocks[11];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const readAtomState = buildingBlocks[14];
+  const writeAtomState = buildingBlocks[16];
+  const mountAtom = buildingBlocks[18];
+  const atomState = ensureAtomState(store, atom);
   let mounted = mountedMap.get(atom);
   if (!mounted) {
-    readAtomState2(store, atom);
+    readAtomState(store, atom);
     for (const a of atomState.d.keys()) {
       const aMounted = mountAtom(store, a);
       aMounted.t.add(atom);
@@ -1374,22 +1399,21 @@ const mountAtom = (store, atom) => {
       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);
+            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;
@@ -1406,40 +1430,48 @@ const mountAtom = (store, atom) => {
       };
       mountCallbacks.add(processOnMount);
     }
+    (_a = storeHooks.m) == null ? void 0 : _a.call(storeHooks, atom);
   }
   return mounted;
 };
-const unmountAtom = (store, atom) => {
-  var _a;
+const BUILDING_BLOCK_unmountAtom = (store, atom) => {
+  var _a, _b;
   const buildingBlocks = getInternalBuildingBlocks(store);
   const mountedMap = buildingBlocks[1];
   const unmountCallbacks = buildingBlocks[5];
   const storeHooks = buildingBlocks[6];
-  const ensureAtomState2 = buildingBlocks[11];
-  const unmountAtom2 = buildingBlocks[19];
-  const atomState = ensureAtomState2(store, atom);
+  const ensureAtomState = buildingBlocks[11];
+  const unmountAtom = buildingBlocks[19];
+  const atomState = ensureAtomState(store, atom);
   let mounted = mountedMap.get(atom);
-  if (mounted && !mounted.l.size && !Array.from(mounted.t).some((a) => {
-    var _a2;
-    return (_a2 = mountedMap.get(a)) == null ? void 0 : _a2.d.has(atom);
-  })) {
+  if (!mounted || mounted.l.size) {
+    return mounted;
+  }
+  let isDependent = false;
+  for (const a of mounted.t) {
+    if ((_a = mountedMap.get(a)) == null ? void 0 : _a.d.has(atom)) {
+      isDependent = true;
+      break;
+    }
+  }
+  if (!isDependent) {
     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);
+      const aMounted = unmountAtom(store, a);
       aMounted == null ? void 0 : aMounted.t.delete(atom);
     }
+    (_b = storeHooks.u) == null ? void 0 : _b.call(storeHooks, atom);
     return void 0;
   }
   return mounted;
 };
-const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
-  const ensureAtomState2 = getInternalBuildingBlocks(store)[11];
-  const atomState = ensureAtomState2(store, atom);
+const BUILDING_BLOCK_setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
+  const ensureAtomState = getInternalBuildingBlocks(store)[11];
+  const atomState = ensureAtomState(store, atom);
   const hasPrevValue = "v" in atomState;
   const prevValue = atomState.v;
   if (isPromiseLike$1(valueOrPromise)) {
@@ -1447,7 +1479,7 @@ const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
       addPendingPromiseToDependency(
         atom,
         valueOrPromise,
-        ensureAtomState2(store, a)
+        ensureAtomState(store, a)
       );
     }
   }
@@ -1460,35 +1492,35 @@ const setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
     }
   }
 };
-const storeGet = (store, atom) => {
-  const readAtomState2 = getInternalBuildingBlocks(store)[14];
-  return returnAtomValue(readAtomState2(store, atom));
+const BUILDING_BLOCK_storeGet = (store, atom) => {
+  const readAtomState = getInternalBuildingBlocks(store)[14];
+  return returnAtomValue(readAtomState(store, atom));
 };
-const storeSet = (store, atom, ...args) => {
+const BUILDING_BLOCK_storeSet = (store, atom, ...args) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const recomputeInvalidatedAtoms2 = buildingBlocks[13];
-  const writeAtomState2 = buildingBlocks[16];
+  const flushCallbacks = buildingBlocks[12];
+  const recomputeInvalidatedAtoms = buildingBlocks[13];
+  const writeAtomState = buildingBlocks[16];
   try {
-    return writeAtomState2(store, atom, ...args);
+    return writeAtomState(store, atom, ...args);
   } finally {
-    recomputeInvalidatedAtoms2(store);
-    flushCallbacks2(store);
+    recomputeInvalidatedAtoms(store);
+    flushCallbacks(store);
   }
 };
-const storeSub = (store, atom, listener) => {
+const BUILDING_BLOCK_storeSub = (store, atom, listener) => {
   const buildingBlocks = getInternalBuildingBlocks(store);
-  const flushCallbacks2 = buildingBlocks[12];
-  const mountAtom2 = buildingBlocks[18];
-  const unmountAtom2 = buildingBlocks[19];
-  const mounted = mountAtom2(store, atom);
+  const flushCallbacks = buildingBlocks[12];
+  const mountAtom = buildingBlocks[18];
+  const unmountAtom = buildingBlocks[19];
+  const mounted = mountAtom(store, atom);
   const listeners = mounted.l;
   listeners.add(listener);
-  flushCallbacks2(store);
+  flushCallbacks(store);
   return () => {
     listeners.delete(listener);
-    unmountAtom2(store, atom);
-    flushCallbacks2(store);
+    unmountAtom(store, atom);
+    flushCallbacks(store);
   };
 };
 const buildingBlockMap = /* @__PURE__ */ new WeakMap();
@@ -1504,16 +1536,16 @@ const getInternalBuildingBlocks = (store) => {
 function buildStore(...buildArgs) {
   const store = {
     get(atom) {
-      const storeGet2 = getInternalBuildingBlocks(store)[21];
-      return storeGet2(store, atom);
+      const storeGet = getInternalBuildingBlocks(store)[21];
+      return storeGet(store, atom);
     },
     set(atom, ...args) {
-      const storeSet2 = getInternalBuildingBlocks(store)[22];
-      return storeSet2(store, atom, ...args);
+      const storeSet = getInternalBuildingBlocks(store)[22];
+      return storeSet(store, atom, ...args);
     },
     sub(atom, listener) {
-      const storeSub2 = getInternalBuildingBlocks(store)[23];
-      return storeSub2(store, atom, listener);
+      const storeSub = getInternalBuildingBlocks(store)[23];
+      return storeSub(store, atom, listener);
     }
   };
   const buildingBlocks = [
@@ -1533,24 +1565,24 @@ function buildStore(...buildArgs) {
     {},
     // storeHooks
     // atom interceptors
-    atomRead,
-    atomWrite,
-    atomOnInit,
-    atomOnMount,
+    BUILDING_BLOCK_atomRead,
+    BUILDING_BLOCK_atomWrite,
+    BUILDING_BLOCK_atomOnInit,
+    BUILDING_BLOCK_atomOnMount,
     // building-block functions
-    ensureAtomState,
-    flushCallbacks,
-    recomputeInvalidatedAtoms,
-    readAtomState,
-    invalidateDependents,
-    writeAtomState,
-    mountDependencies,
-    mountAtom,
-    unmountAtom,
-    setAtomStateValueOrPromise,
-    storeGet,
-    storeSet,
-    storeSub,
+    BUILDING_BLOCK_ensureAtomState,
+    BUILDING_BLOCK_flushCallbacks,
+    BUILDING_BLOCK_recomputeInvalidatedAtoms,
+    BUILDING_BLOCK_readAtomState,
+    BUILDING_BLOCK_invalidateDependents,
+    BUILDING_BLOCK_writeAtomState,
+    BUILDING_BLOCK_mountDependencies,
+    BUILDING_BLOCK_mountAtom,
+    BUILDING_BLOCK_unmountAtom,
+    BUILDING_BLOCK_setAtomStateValueOrPromise,
+    BUILDING_BLOCK_storeGet,
+    BUILDING_BLOCK_storeSet,
+    BUILDING_BLOCK_storeSub,
     void 0
   ].map((fn, i) => buildArgs[i] || fn);
   buildingBlockMap.set(store, Object.freeze(buildingBlocks));
@@ -1748,11 +1780,11 @@ function useAtom(atom, options) {
     // We do wrong type assertion here, which results in throwing an error.
     useSetAtom(atom)
   ];
-}const RESET = Symbol(
+}const RESET = /* @__PURE__ */ Symbol(
   (undefined ? undefined.MODE : void 0) !== "production" ? "RESET" : ""
 );
 
-const isPromiseLike$3 = (x) => typeof (x == null ? void 0 : x.then) === "function";
+const isPromiseLike$2 = (x) => typeof (x == null ? void 0 : x.then) === "function";
 function createJSONStorage(getStringStorage = () => {
   try {
     return window.localStorage;
@@ -1784,7 +1816,7 @@ function createJSONStorage(getStringStorage = () => {
         return lastValue;
       };
       const str = (_b = (_a2 = getStringStorage()) == null ? void 0 : _a2.getItem(key)) != null ? _b : null;
-      if (isPromiseLike$3(str)) {
+      if (isPromiseLike$2(str)) {
         return str.then(parse);
       }
       return parse(str);
@@ -1861,7 +1893,7 @@ function atomWithStorage(key, initialValue, storage = defaultStorage, options) {
         set(baseAtom, initialValue);
         return storage.removeItem(key);
       }
-      if (isPromiseLike$3(nextValue)) {
+      if (isPromiseLike$2(nextValue)) {
         return nextValue.then((resolvedValue) => {
           set(baseAtom, resolvedValue);
           return storage.setItem(key, resolvedValue);