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;
      }

    })
  };
}));