add hw2

node_modules/jotai/system/vanilla/internals.development.js

@@ -0,0 +1,679 @@
+System.register([], (function (exports) {
+  'use strict';
+  return {
+    execute: (function () {
+
+      exports({
+        INTERNAL_abortPromise: abortPromise,
+        INTERNAL_addPendingPromiseToDependency: addPendingPromiseToDependency,
+        INTERNAL_buildStoreRev2: buildStore,
+        INTERNAL_getBuildingBlocksRev2: getBuildingBlocks,
+        INTERNAL_getMountedOrPendingDependents: getMountedOrPendingDependents,
+        INTERNAL_hasInitialValue: hasInitialValue,
+        INTERNAL_initializeStoreHooksRev2: initializeStoreHooks,
+        INTERNAL_isActuallyWritableAtom: isActuallyWritableAtom,
+        INTERNAL_isAtomStateInitialized: isAtomStateInitialized,
+        INTERNAL_isPendingPromise: isPendingPromise,
+        INTERNAL_isPromiseLike: isPromiseLike,
+        INTERNAL_registerAbortHandler: registerAbortHandler,
+        INTERNAL_returnAtomValue: returnAtomValue
+      });
+
+      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 (!("v" in atomState)) {
+          throw new Error("[Bug] atom state is not initialized");
+        }
+        return atomState.v;
+      }
+      const promiseStateMap = exports("INTERNAL_promiseStateMap", /* @__PURE__ */ new WeakMap());
+      function isPendingPromise(value) {
+        var _a;
+        return isPromiseLike(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(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 createStoreHook = () => {
+        const callbacks = /* @__PURE__ */ new Set();
+        const notify = () => callbacks.forEach((fn) => fn());
+        notify.add = (fn) => {
+          callbacks.add(fn);
+          return () => callbacks.delete(fn);
+        };
+        return notify;
+      };
+      const createStoreHookForAtoms = () => {
+        const all = {};
+        const callbacks = /* @__PURE__ */ new WeakMap();
+        const notify = (atom) => {
+          var _a, _b;
+          (_a = callbacks.get(all)) == null ? void 0 : _a.forEach((fn) => fn(atom));
+          (_b = callbacks.get(atom)) == null ? void 0 : _b.forEach((fn) => fn());
+        };
+        notify.add = (atom, fn) => {
+          const key = atom || all;
+          const fns = (callbacks.has(key) ? callbacks : callbacks.set(key, /* @__PURE__ */ new Set())).get(key);
+          fns.add(fn);
+          return () => {
+            fns == null ? void 0 : fns.delete(fn);
+            if (!fns.size) {
+              callbacks.delete(key);
+            }
+          };
+        };
+        return notify;
+      };
+      function initializeStoreHooks(storeHooks) {
+        storeHooks.r || (storeHooks.r = createStoreHookForAtoms());
+        storeHooks.c || (storeHooks.c = createStoreHookForAtoms());
+        storeHooks.m || (storeHooks.m = createStoreHookForAtoms());
+        storeHooks.u || (storeHooks.u = createStoreHookForAtoms());
+        storeHooks.f || (storeHooks.f = createStoreHook());
+        return storeHooks;
+      }
+      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 (!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 (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 (!isActuallyWritableAtom(atom)) {
+              console.warn("setSelf function cannot be used with read-only atom");
+            }
+            if (!setSelf && isActuallyWritableAtom(atom)) {
+              setSelf = (...args) => {
+                if (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(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(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(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 (!buildingBlocks) {
+          throw new Error(
+            "Store must be created by buildStore to read its building blocks"
+          );
+        }
+        return buildingBlocks;
+      };
+      function getBuildingBlocks(store) {
+        const buildingBlocks = getInternalBuildingBlocks(store);
+        const enhanceBuildingBlocks = buildingBlocks[24];
+        if (enhanceBuildingBlocks) {
+          return enhanceBuildingBlocks(buildingBlocks);
+        }
+        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;
+      }
+
+    })
+  };
+}));