add hw2

node_modules/jotai/vanilla/atom.d.ts

@@ -0,0 +1,47 @@
+import type { Store } from './store';
+type Getter = <Value>(atom: Atom<Value>) => Value;
+type Setter = <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type SetAtom<Args extends unknown[], Result> = <A extends Args>(...args: A) => Result;
+/**
+ * setSelf is for internal use only and subject to change without notice.
+ */
+type Read<Value, SetSelf = never> = (get: Getter, options: {
+    readonly signal: AbortSignal;
+    readonly setSelf: SetSelf;
+}) => Value;
+type Write<Args extends unknown[], Result> = (get: Getter, set: Setter, ...args: Args) => Result;
+type WithInitialValue<Value> = {
+    init: Value;
+};
+type OnUnmount = () => void;
+type OnMount<Args extends unknown[], Result> = <S extends SetAtom<Args, Result>>(setAtom: S) => OnUnmount | void;
+export interface Atom<Value> {
+    toString: () => string;
+    read: Read<Value>;
+    debugLabel?: string;
+    /**
+     * To ONLY be used by Jotai libraries to mark atoms as private. Subject to change.
+     * @private
+     */
+    debugPrivate?: boolean;
+    /**
+     * Fires after atom is referenced by the store for the first time
+     * This is still an experimental API and subject to change without notice.
+     */
+    unstable_onInit?: (store: Store) => void;
+}
+export interface WritableAtom<Value, Args extends unknown[], Result> extends Atom<Value> {
+    read: Read<Value, SetAtom<Args, Result>>;
+    write: Write<Args, Result>;
+    onMount?: OnMount<Args, Result>;
+}
+type SetStateAction<Value> = Value | ((prev: Value) => Value);
+export type PrimitiveAtom<Value> = WritableAtom<Value, [
+    SetStateAction<Value>
+], void>;
+export declare function atom<Value, Args extends unknown[], Result>(read: Read<Value, SetAtom<Args, Result>>, write: Write<Args, Result>): WritableAtom<Value, Args, Result>;
+export declare function atom<Value>(read: Read<Value>): Atom<Value>;
+export declare function atom<Value, Args extends unknown[], Result>(initialValue: Value, write: Write<Args, Result>): WritableAtom<Value, Args, Result> & WithInitialValue<Value>;
+export declare function atom<Value>(): PrimitiveAtom<Value | undefined> & WithInitialValue<Value | undefined>;
+export declare function atom<Value>(initialValue: Value): PrimitiveAtom<Value> & WithInitialValue<Value>;
+export {};

node_modules/jotai/vanilla/internals.d.ts

@@ -0,0 +1,173 @@
+import type { Atom, WritableAtom } from './atom';
+type AnyValue = unknown;
+type AnyError = unknown;
+type AnyAtom = Atom<AnyValue>;
+type AnyWritableAtom = WritableAtom<AnyValue, unknown[], unknown>;
+type OnUnmount = () => void;
+type EpochNumber = number;
+/**
+ * Mutable atom state,
+ * tracked for both mounted and unmounted atoms in a store.
+ *
+ * This should be garbage collectable.
+ * We can mutate it during atom read. (except for fields with TODO)
+ */
+type AtomState<Value = AnyValue> = {
+    /**
+     * Map of atoms that the atom depends on.
+     * The map value is the epoch number of the dependency.
+     */
+    readonly d: Map<AnyAtom, EpochNumber>;
+    /**
+     * Set of atoms with pending promise that depend on the atom.
+     *
+     * This may cause memory leaks, but it's for the capability to continue promises
+     * TODO(daishi): revisit how to handle this
+     */
+    readonly p: Set<AnyAtom>;
+    /** The epoch number of the atom. */
+    n: EpochNumber;
+    /** Atom value */
+    v?: Value;
+    /** Atom error */
+    e?: AnyError;
+};
+/**
+ * State tracked for mounted atoms. An atom is considered "mounted" if it has a
+ * subscriber, or is a transitive dependency of another atom that has a
+ * subscriber.
+ * The mounted state of an atom is freed once it is no longer mounted.
+ */
+type Mounted = {
+    /** Set of listeners to notify when the atom value changes. */
+    readonly l: Set<() => void>;
+    /** Set of mounted atoms that the atom depends on. */
+    readonly d: Set<AnyAtom>;
+    /** Set of mounted atoms that depends on the atom. */
+    readonly t: Set<AnyAtom>;
+    /** Function to run when the atom is unmounted. */
+    u?: () => void;
+};
+type AtomStateMap = {
+    get(atom: AnyAtom): AtomState | undefined;
+    set(atom: AnyAtom, atomState: AtomState): void;
+};
+type MountedMap = {
+    get(atom: AnyAtom): Mounted | undefined;
+    has(atom: AnyAtom): boolean;
+    set(atom: AnyAtom, mounted: Mounted): void;
+    delete(atom: AnyAtom): void;
+};
+type InvalidatedAtoms = {
+    get(atom: AnyAtom): EpochNumber | undefined;
+    has(atom: AnyAtom): boolean;
+    set(atom: AnyAtom, n: EpochNumber): void;
+    delete(atom: AnyAtom): void;
+};
+type ChangedAtoms = {
+    readonly size: number;
+    add(atom: AnyAtom): void;
+    has(atom: AnyAtom): boolean;
+    clear(): void;
+    forEach(callback: (atom: AnyAtom) => void): void;
+    [Symbol.iterator](): IterableIterator<AnyAtom>;
+};
+type Callbacks = {
+    readonly size: number;
+    add(fn: () => void): void;
+    clear(): void;
+    forEach(callback: (fn: () => void) => void): void;
+};
+type AtomRead = <Value>(store: Store, atom: Atom<Value>, ...params: Parameters<Atom<Value>['read']>) => Value;
+type AtomWrite = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, ...params: Parameters<WritableAtom<Value, Args, Result>['write']>) => Result;
+type AtomOnInit = <Value>(store: Store, atom: Atom<Value>) => void;
+type AtomOnMount = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, setAtom: (...args: Args) => Result) => OnUnmount | void;
+type EnsureAtomState = <Value>(store: Store, atom: Atom<Value>) => AtomState<Value>;
+type FlushCallbacks = (store: Store) => void;
+type RecomputeInvalidatedAtoms = (store: Store) => void;
+type ReadAtomState = <Value>(store: Store, atom: Atom<Value>) => AtomState<Value>;
+type InvalidateDependents = (store: Store, atom: AnyAtom) => void;
+type WriteAtomState = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type MountDependencies = (store: Store, atom: AnyAtom) => void;
+type MountAtom = <Value>(store: Store, atom: Atom<Value>) => Mounted;
+type UnmountAtom = <Value>(store: Store, atom: Atom<Value>) => Mounted | undefined;
+type SetAtomStateValueOrPromise = <Value>(store: Store, atom: Atom<Value>, valueOrPromise: Value) => void;
+type StoreGet = <Value>(store: Store, atom: Atom<Value>) => Value;
+type StoreSet = <Value, Args extends unknown[], Result>(store: Store, atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+type StoreSub = (store: Store, atom: AnyAtom, listener: () => void) => () => void;
+type EnhanceBuildingBlocks = (buildingBlocks: Readonly<BuildingBlocks>) => Readonly<BuildingBlocks>;
+type Store = {
+    get: <Value>(atom: Atom<Value>) => Value;
+    set: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
+    sub: (atom: AnyAtom, listener: () => void) => () => void;
+};
+type BuildingBlocks = [
+    atomStateMap: AtomStateMap,
+    mountedMap: MountedMap,
+    invalidatedAtoms: InvalidatedAtoms,
+    changedAtoms: ChangedAtoms,
+    mountCallbacks: Callbacks,
+    unmountCallbacks: Callbacks,
+    storeHooks: StoreHooks,
+    atomRead: AtomRead,
+    atomWrite: AtomWrite,
+    atomOnInit: AtomOnInit,
+    atomOnMount: AtomOnMount,
+    ensureAtomState: EnsureAtomState,
+    flushCallbacks: FlushCallbacks,
+    recomputeInvalidatedAtoms: RecomputeInvalidatedAtoms,
+    readAtomState: ReadAtomState,
+    invalidateDependents: InvalidateDependents,
+    writeAtomState: WriteAtomState,
+    mountDependencies: MountDependencies,
+    mountAtom: MountAtom,
+    unmountAtom: UnmountAtom,
+    setAtomStateValueOrPromise: SetAtomStateValueOrPromise,
+    storeGet: StoreGet,
+    storeSet: StoreSet,
+    storeSub: StoreSub,
+    enhanceBuildingBlocks: EnhanceBuildingBlocks | undefined
+];
+export type { AtomState as INTERNAL_AtomState, Mounted as INTERNAL_Mounted, AtomStateMap as INTERNAL_AtomStateMap, MountedMap as INTERNAL_MountedMap, InvalidatedAtoms as INTERNAL_InvalidatedAtoms, ChangedAtoms as INTERNAL_ChangedAtoms, Callbacks as INTERNAL_Callbacks, AtomRead as INTERNAL_AtomRead, AtomWrite as INTERNAL_AtomWrite, AtomOnInit as INTERNAL_AtomOnInit, AtomOnMount as INTERNAL_AtomOnMount, EnsureAtomState as INTERNAL_EnsureAtomState, FlushCallbacks as INTERNAL_FlushCallbacks, RecomputeInvalidatedAtoms as INTERNAL_RecomputeInvalidatedAtoms, ReadAtomState as INTERNAL_ReadAtomState, InvalidateDependents as INTERNAL_InvalidateDependents, WriteAtomState as INTERNAL_WriteAtomState, MountDependencies as INTERNAL_MountDependencies, MountAtom as INTERNAL_MountAtom, UnmountAtom as INTERNAL_UnmountAtom, Store as INTERNAL_Store, BuildingBlocks as INTERNAL_BuildingBlocks, StoreHooks as INTERNAL_StoreHooks, };
+declare function hasInitialValue<T extends Atom<AnyValue>>(atom: T): atom is T & (T extends Atom<infer Value> ? {
+    init: Value;
+} : never);
+declare function isActuallyWritableAtom(atom: AnyAtom): atom is AnyWritableAtom;
+declare function isAtomStateInitialized<Value>(atomState: AtomState<Value>): boolean;
+declare function returnAtomValue<Value>(atomState: AtomState<Value>): Value;
+declare const promiseStateMap: WeakMap<PromiseLike<unknown>, [
+    pending: boolean,
+    abortHandlers: Set<() => void>
+]>;
+declare function isPendingPromise(value: unknown): value is PromiseLike<unknown>;
+declare function abortPromise<T>(promise: PromiseLike<T>): void;
+declare function registerAbortHandler<T>(promise: PromiseLike<T>, abortHandler: () => void): void;
+declare function isPromiseLike(p: unknown): p is PromiseLike<unknown>;
+declare function addPendingPromiseToDependency(atom: AnyAtom, promise: PromiseLike<AnyValue>, dependencyAtomState: AtomState): void;
+declare function getMountedOrPendingDependents(atom: AnyAtom, atomState: AtomState, mountedMap: MountedMap): Set<AnyAtom>;
+type StoreHook = {
+    (): void;
+    add(callback: () => void): () => void;
+};
+type StoreHookForAtoms = {
+    (atom: AnyAtom): void;
+    add(atom: AnyAtom, callback: () => void): () => void;
+    add(atom: undefined, callback: (atom: AnyAtom) => void): () => void;
+};
+/** StoreHooks are an experimental API. */
+type StoreHooks = {
+    /** Listener to notify when the atom is read. */
+    readonly r?: StoreHookForAtoms;
+    /** Listener to notify when the atom value is changed. */
+    readonly c?: StoreHookForAtoms;
+    /** Listener to notify when the atom is mounted. */
+    readonly m?: StoreHookForAtoms;
+    /** Listener to notify when the atom is unmounted. */
+    readonly u?: StoreHookForAtoms;
+    /** Listener to notify when callbacks are being flushed. */
+    readonly f?: StoreHook;
+};
+declare function initializeStoreHooks(storeHooks: StoreHooks): Required<StoreHooks>;
+declare function getBuildingBlocks(store: Store): Readonly<BuildingBlocks>;
+declare function buildStore(...buildArgs: Partial<BuildingBlocks>): Store;
+export { buildStore as INTERNAL_buildStoreRev2, getBuildingBlocks as INTERNAL_getBuildingBlocksRev2, initializeStoreHooks as INTERNAL_initializeStoreHooksRev2, hasInitialValue as INTERNAL_hasInitialValue, isActuallyWritableAtom as INTERNAL_isActuallyWritableAtom, isAtomStateInitialized as INTERNAL_isAtomStateInitialized, returnAtomValue as INTERNAL_returnAtomValue, promiseStateMap as INTERNAL_promiseStateMap, isPendingPromise as INTERNAL_isPendingPromise, abortPromise as INTERNAL_abortPromise, registerAbortHandler as INTERNAL_registerAbortHandler, isPromiseLike as INTERNAL_isPromiseLike, addPendingPromiseToDependency as INTERNAL_addPendingPromiseToDependency, getMountedOrPendingDependents as INTERNAL_getMountedOrPendingDependents, };

node_modules/jotai/vanilla/internals.js

@@ -0,0 +1,725 @@
+'use strict';
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+    t && (r = t);
+    var o = 0;
+    return function () {
+      return o >= r.length ? {
+        done: true
+      } : {
+        done: false,
+        value: r[o++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+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 (process.env.NODE_ENV !== 'production' && !('v' in atomState)) {
+    throw new Error('[Bug] atom state is not initialized');
+  }
+  return atomState.v;
+}
+var promiseStateMap = new WeakMap();
+function isPendingPromise(value) {
+  var _promiseStateMap$get;
+  return isPromiseLike(value) && !!((_promiseStateMap$get = promiseStateMap.get(value)) != null && _promiseStateMap$get[0]);
+}
+function abortPromise(promise) {
+  var promiseState = promiseStateMap.get(promise);
+  if (promiseState != null && promiseState[0]) {
+    promiseState[0] = false;
+    promiseState[1].forEach(function (fn) {
+      return fn();
+    });
+  }
+}
+function registerAbortHandler(promise, abortHandler) {
+  var promiseState = promiseStateMap.get(promise);
+  if (!promiseState) {
+    promiseState = [true, new Set()];
+    promiseStateMap.set(promise, promiseState);
+    var settle = function 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);
+    var cleanup = function cleanup() {
+      return dependencyAtomState.p.delete(atom);
+    };
+    promise.then(cleanup, cleanup);
+  }
+}
+function getMountedOrPendingDependents(atom, atomState, mountedMap) {
+  var dependents = new Set();
+  for (var _iterator = _createForOfIteratorHelperLoose(((_mountedMap$get = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get.t) || []), _step; !(_step = _iterator()).done;) {
+    var _mountedMap$get;
+    var a = _step.value;
+    if (mountedMap.has(a)) {
+      dependents.add(a);
+    }
+  }
+  for (var _iterator2 = _createForOfIteratorHelperLoose(atomState.p), _step2; !(_step2 = _iterator2()).done;) {
+    var atomWithPendingPromise = _step2.value;
+    dependents.add(atomWithPendingPromise);
+  }
+  return dependents;
+}
+var createStoreHook = function createStoreHook() {
+  var callbacks = new Set();
+  var notify = function notify() {
+    return callbacks.forEach(function (fn) {
+      return fn();
+    });
+  };
+  notify.add = function (fn) {
+    callbacks.add(fn);
+    return function () {
+      return callbacks.delete(fn);
+    };
+  };
+  return notify;
+};
+var createStoreHookForAtoms = function createStoreHookForAtoms() {
+  var all = {};
+  var callbacks = new WeakMap();
+  var notify = function notify(atom) {
+    var _callbacks$get, _callbacks$get2;
+    (_callbacks$get = callbacks.get(all)) == null || _callbacks$get.forEach(function (fn) {
+      return fn(atom);
+    });
+    (_callbacks$get2 = callbacks.get(atom)) == null || _callbacks$get2.forEach(function (fn) {
+      return fn();
+    });
+  };
+  notify.add = function (atom, fn) {
+    var key = atom || all;
+    var fns = (callbacks.has(key) ? callbacks : callbacks.set(key, new Set())).get(key);
+    fns.add(fn);
+    return function () {
+      fns == null || fns.delete(fn);
+      if (!fns.size) {
+        callbacks.delete(key);
+      }
+    };
+  };
+  return notify;
+};
+function initializeStoreHooks(storeHooks) {
+  var _ref, _ref2, _ref3, _ref4, _ref5;
+  (_ref = storeHooks).r || (_ref.r = createStoreHookForAtoms());
+  (_ref2 = storeHooks).c || (_ref2.c = createStoreHookForAtoms());
+  (_ref3 = storeHooks).m || (_ref3.m = createStoreHookForAtoms());
+  (_ref4 = storeHooks).u || (_ref4.u = createStoreHookForAtoms());
+  (_ref5 = storeHooks).f || (_ref5.f = createStoreHook());
+  return storeHooks;
+}
+var atomRead = function atomRead(_store, atom) {
+  for (var _len = arguments.length, params = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    params[_key - 2] = arguments[_key];
+  }
+  return atom.read.apply(atom, params);
+};
+var atomWrite = function atomWrite(_store, atom) {
+  for (var _len2 = arguments.length, params = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+    params[_key2 - 2] = arguments[_key2];
+  }
+  return atom.write.apply(atom, params);
+};
+var atomOnInit = function atomOnInit(store, atom) {
+  return atom.unstable_onInit == null ? void 0 : atom.unstable_onInit(store);
+};
+var atomOnMount = function atomOnMount(_store, atom, setAtom) {
+  return atom.onMount == null ? void 0 : atom.onMount(setAtom);
+};
+var ensureAtomState = function ensureAtomState(store, atom) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var atomStateMap = buildingBlocks[0];
+  var atomOnInit = buildingBlocks[9];
+  if (process.env.NODE_ENV !== 'production' && !atom) {
+    throw new Error('Atom is undefined or null');
+  }
+  var atomState = atomStateMap.get(atom);
+  if (!atomState) {
+    atomState = {
+      d: new Map(),
+      p: new Set(),
+      n: 0
+    };
+    atomStateMap.set(atom, atomState);
+    atomOnInit == null || atomOnInit(store, atom);
+  }
+  return atomState;
+};
+var flushCallbacks = function flushCallbacks(store) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var mountedMap = buildingBlocks[1];
+  var changedAtoms = buildingBlocks[3];
+  var mountCallbacks = buildingBlocks[4];
+  var unmountCallbacks = buildingBlocks[5];
+  var storeHooks = buildingBlocks[6];
+  var recomputeInvalidatedAtoms = buildingBlocks[13];
+  var errors = [];
+  var call = function call(fn) {
+    try {
+      fn();
+    } catch (e) {
+      errors.push(e);
+    }
+  };
+  var _loop = function _loop() {
+    if (storeHooks.f) {
+      call(storeHooks.f);
+    }
+    var callbacks = new Set();
+    var add = callbacks.add.bind(callbacks);
+    changedAtoms.forEach(function (atom) {
+      var _mountedMap$get2;
+      return (_mountedMap$get2 = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get2.l.forEach(add);
+    });
+    changedAtoms.clear();
+    unmountCallbacks.forEach(add);
+    unmountCallbacks.clear();
+    mountCallbacks.forEach(add);
+    mountCallbacks.clear();
+    callbacks.forEach(call);
+    if (changedAtoms.size) {
+      recomputeInvalidatedAtoms(store);
+    }
+  };
+  do {
+    _loop();
+  } while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
+  if (errors.length) {
+    throw new AggregateError(errors);
+  }
+};
+var recomputeInvalidatedAtoms = function recomputeInvalidatedAtoms(store) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var mountedMap = buildingBlocks[1];
+  var invalidatedAtoms = buildingBlocks[2];
+  var changedAtoms = buildingBlocks[3];
+  var ensureAtomState = buildingBlocks[11];
+  var readAtomState = buildingBlocks[14];
+  var mountDependencies = buildingBlocks[17];
+  var topSortedReversed = [];
+  var visiting = new WeakSet();
+  var visited = new WeakSet();
+  var stack = Array.from(changedAtoms);
+  while (stack.length) {
+    var a = stack[stack.length - 1];
+    var aState = ensureAtomState(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 (process.env.NODE_ENV !== 'production' && invalidatedAtoms.has(a)) {
+        throw new Error('[Bug] invalidated atom exists');
+      }
+      visited.add(a);
+      stack.pop();
+      continue;
+    }
+    visiting.add(a);
+    for (var _iterator3 = _createForOfIteratorHelperLoose(getMountedOrPendingDependents(a, aState, mountedMap)), _step3; !(_step3 = _iterator3()).done;) {
+      var d = _step3.value;
+      if (!visiting.has(d)) {
+        stack.push(d);
+      }
+    }
+  }
+  for (var i = topSortedReversed.length - 1; i >= 0; --i) {
+    var _ref6 = topSortedReversed[i],
+      _a = _ref6[0],
+      _aState = _ref6[1];
+    var hasChangedDeps = false;
+    for (var _iterator4 = _createForOfIteratorHelperLoose(_aState.d.keys()), _step4; !(_step4 = _iterator4()).done;) {
+      var dep = _step4.value;
+      if (dep !== _a && changedAtoms.has(dep)) {
+        hasChangedDeps = true;
+        break;
+      }
+    }
+    if (hasChangedDeps) {
+      readAtomState(store, _a);
+      mountDependencies(store, _a);
+    }
+    invalidatedAtoms.delete(_a);
+  }
+};
+var readAtomState = function readAtomState(store, atom) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var mountedMap = buildingBlocks[1];
+  var invalidatedAtoms = buildingBlocks[2];
+  var changedAtoms = buildingBlocks[3];
+  var storeHooks = buildingBlocks[6];
+  var atomRead = buildingBlocks[7];
+  var ensureAtomState = buildingBlocks[11];
+  var flushCallbacks = buildingBlocks[12];
+  var recomputeInvalidatedAtoms = buildingBlocks[13];
+  var readAtomState = buildingBlocks[14];
+  var writeAtomState = buildingBlocks[16];
+  var mountDependencies = buildingBlocks[17];
+  var atomState = ensureAtomState(store, atom);
+  if (isAtomStateInitialized(atomState)) {
+    if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n) {
+      return atomState;
+    }
+    if (Array.from(atomState.d).every(function (_ref7) {
+      var a = _ref7[0],
+        n = _ref7[1];
+      return (readAtomState(store, a).n === n
+      );
+    })) {
+      return atomState;
+    }
+  }
+  atomState.d.clear();
+  var isSync = true;
+  function mountDependenciesIfAsync() {
+    if (mountedMap.has(atom)) {
+      mountDependencies(store, atom);
+      recomputeInvalidatedAtoms(store);
+      flushCallbacks(store);
+    }
+  }
+  function getter(a) {
+    if (a === atom) {
+      var _aState2 = ensureAtomState(store, a);
+      if (!isAtomStateInitialized(_aState2)) {
+        if (hasInitialValue(a)) {
+          setAtomStateValueOrPromise(store, a, a.init);
+        } else {
+          throw new Error('no atom init');
+        }
+      }
+      return returnAtomValue(_aState2);
+    }
+    var aState = readAtomState(store, a);
+    try {
+      return returnAtomValue(aState);
+    } finally {
+      var _mountedMap$get3;
+      atomState.d.set(a, aState.n);
+      if (isPendingPromise(atomState.v)) {
+        addPendingPromiseToDependency(atom, atomState.v, aState);
+      }
+      (_mountedMap$get3 = mountedMap.get(a)) == null || _mountedMap$get3.t.add(atom);
+      if (!isSync) {
+        mountDependenciesIfAsync();
+      }
+    }
+  }
+  var controller;
+  var setSelf;
+  var options = {
+    get signal() {
+      if (!controller) {
+        controller = new AbortController();
+      }
+      return controller.signal;
+    },
+    get setSelf() {
+      if (process.env.NODE_ENV !== 'production' && !isActuallyWritableAtom(atom)) {
+        console.warn('setSelf function cannot be used with read-only atom');
+      }
+      if (!setSelf && isActuallyWritableAtom(atom)) {
+        setSelf = function setSelf() {
+          if (process.env.NODE_ENV !== 'production' && isSync) {
+            console.warn('setSelf function cannot be called in sync');
+          }
+          if (!isSync) {
+            try {
+              for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+                args[_key3] = arguments[_key3];
+              }
+              return writeAtomState.apply(void 0, [store, atom].concat(args));
+            } finally {
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
+            }
+          }
+        };
+      }
+      return setSelf;
+    }
+  };
+  var prevEpochNumber = atomState.n;
+  try {
+    var _valueOrPromise = atomRead(store, atom, getter, options);
+    setAtomStateValueOrPromise(store, atom, _valueOrPromise);
+    if (isPromiseLike(_valueOrPromise)) {
+      registerAbortHandler(_valueOrPromise, function () {
+        var _controller;
+        return (_controller = controller) == null ? void 0 : _controller.abort();
+      });
+      _valueOrPromise.then(mountDependenciesIfAsync, mountDependenciesIfAsync);
+    }
+    storeHooks.r == null || storeHooks.r(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);
+      storeHooks.c == null || storeHooks.c(atom);
+    }
+  }
+};
+var invalidateDependents = function invalidateDependents(store, atom) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var mountedMap = buildingBlocks[1];
+  var invalidatedAtoms = buildingBlocks[2];
+  var ensureAtomState = buildingBlocks[11];
+  var stack = [atom];
+  while (stack.length) {
+    var a = stack.pop();
+    var aState = ensureAtomState(store, a);
+    for (var _iterator5 = _createForOfIteratorHelperLoose(getMountedOrPendingDependents(a, aState, mountedMap)), _step5; !(_step5 = _iterator5()).done;) {
+      var d = _step5.value;
+      var dState = ensureAtomState(store, d);
+      invalidatedAtoms.set(d, dState.n);
+      stack.push(d);
+    }
+  }
+};
+var _writeAtomState = function writeAtomState(store, atom) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var changedAtoms = buildingBlocks[3];
+  var storeHooks = buildingBlocks[6];
+  var atomWrite = buildingBlocks[8];
+  var ensureAtomState = buildingBlocks[11];
+  var flushCallbacks = buildingBlocks[12];
+  var recomputeInvalidatedAtoms = buildingBlocks[13];
+  var readAtomState = buildingBlocks[14];
+  var invalidateDependents = buildingBlocks[15];
+  var mountDependencies = buildingBlocks[17];
+  var isSync = true;
+  var getter = function getter(a) {
+    return returnAtomValue(readAtomState(store, a));
+  };
+  var setter = function setter(a) {
+    var aState = ensureAtomState(store, a);
+    try {
+      for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+        args[_key5 - 1] = arguments[_key5];
+      }
+      if (a === atom) {
+        if (!hasInitialValue(a)) {
+          throw new Error('atom not writable');
+        }
+        var prevEpochNumber = aState.n;
+        var v = args[0];
+        setAtomStateValueOrPromise(store, a, v);
+        mountDependencies(store, a);
+        if (prevEpochNumber !== aState.n) {
+          changedAtoms.add(a);
+          storeHooks.c == null || storeHooks.c(a);
+          invalidateDependents(store, a);
+        }
+        return undefined;
+      } else {
+        return _writeAtomState.apply(void 0, [store, a].concat(args));
+      }
+    } finally {
+      if (!isSync) {
+        recomputeInvalidatedAtoms(store);
+        flushCallbacks(store);
+      }
+    }
+  };
+  try {
+    for (var _len4 = arguments.length, args = new Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
+      args[_key4 - 2] = arguments[_key4];
+    }
+    return atomWrite.apply(void 0, [store, atom, getter, setter].concat(args));
+  } finally {
+    isSync = false;
+  }
+};
+var mountDependencies = function mountDependencies(store, atom) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var mountedMap = buildingBlocks[1];
+  var changedAtoms = buildingBlocks[3];
+  var storeHooks = buildingBlocks[6];
+  var ensureAtomState = buildingBlocks[11];
+  var invalidateDependents = buildingBlocks[15];
+  var mountAtom = buildingBlocks[18];
+  var unmountAtom = buildingBlocks[19];
+  var atomState = ensureAtomState(store, atom);
+  var mounted = mountedMap.get(atom);
+  if (mounted && !isPendingPromise(atomState.v)) {
+    for (var _iterator6 = _createForOfIteratorHelperLoose(atomState.d), _step6; !(_step6 = _iterator6()).done;) {
+      var _step6$value = _step6.value,
+        a = _step6$value[0],
+        _n = _step6$value[1];
+      if (!mounted.d.has(a)) {
+        var aState = ensureAtomState(store, a);
+        var aMounted = mountAtom(store, a);
+        aMounted.t.add(atom);
+        mounted.d.add(a);
+        if (_n !== aState.n) {
+          changedAtoms.add(a);
+          storeHooks.c == null || storeHooks.c(a);
+          invalidateDependents(store, a);
+        }
+      }
+    }
+    for (var _iterator7 = _createForOfIteratorHelperLoose(mounted.d || []), _step7; !(_step7 = _iterator7()).done;) {
+      var _a2 = _step7.value;
+      if (!atomState.d.has(_a2)) {
+        mounted.d.delete(_a2);
+        var _aMounted = unmountAtom(store, _a2);
+        _aMounted == null || _aMounted.t.delete(atom);
+      }
+    }
+  }
+};
+var _mountAtom = function mountAtom(store, atom) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var mountedMap = buildingBlocks[1];
+  var mountCallbacks = buildingBlocks[4];
+  var storeHooks = buildingBlocks[6];
+  var atomOnMount = buildingBlocks[10];
+  var ensureAtomState = buildingBlocks[11];
+  var flushCallbacks = buildingBlocks[12];
+  var recomputeInvalidatedAtoms = buildingBlocks[13];
+  var readAtomState = buildingBlocks[14];
+  var writeAtomState = buildingBlocks[16];
+  var atomState = ensureAtomState(store, atom);
+  var mounted = mountedMap.get(atom);
+  if (!mounted) {
+    readAtomState(store, atom);
+    for (var _iterator8 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step8; !(_step8 = _iterator8()).done;) {
+      var a = _step8.value;
+      var aMounted = _mountAtom(store, a);
+      aMounted.t.add(atom);
+    }
+    mounted = {
+      l: new Set(),
+      d: new Set(atomState.d.keys()),
+      t: new Set()
+    };
+    mountedMap.set(atom, mounted);
+    storeHooks.m == null || storeHooks.m(atom);
+    if (isActuallyWritableAtom(atom)) {
+      var processOnMount = function processOnMount() {
+        var isSync = true;
+        var setAtom = function setAtom() {
+          try {
+            for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+              args[_key6] = arguments[_key6];
+            }
+            return writeAtomState.apply(void 0, [store, atom].concat(args));
+          } finally {
+            if (!isSync) {
+              recomputeInvalidatedAtoms(store);
+              flushCallbacks(store);
+            }
+          }
+        };
+        try {
+          var onUnmount = atomOnMount(store, atom, setAtom);
+          if (onUnmount) {
+            mounted.u = function () {
+              isSync = true;
+              try {
+                onUnmount();
+              } finally {
+                isSync = false;
+              }
+            };
+          }
+        } finally {
+          isSync = false;
+        }
+      };
+      mountCallbacks.add(processOnMount);
+    }
+  }
+  return mounted;
+};
+var unmountAtom = function unmountAtom(store, atom) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var mountedMap = buildingBlocks[1];
+  var unmountCallbacks = buildingBlocks[5];
+  var storeHooks = buildingBlocks[6];
+  var ensureAtomState = buildingBlocks[11];
+  var unmountAtom = buildingBlocks[19];
+  var atomState = ensureAtomState(store, atom);
+  var mounted = mountedMap.get(atom);
+  if (mounted && !mounted.l.size && !Array.from(mounted.t).some(function (a) {
+    var _mountedMap$get4;
+    return (_mountedMap$get4 = mountedMap.get(a)) == null ? void 0 : _mountedMap$get4.d.has(atom);
+  })) {
+    if (mounted.u) {
+      unmountCallbacks.add(mounted.u);
+    }
+    mounted = undefined;
+    mountedMap.delete(atom);
+    storeHooks.u == null || storeHooks.u(atom);
+    for (var _iterator9 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step9; !(_step9 = _iterator9()).done;) {
+      var a = _step9.value;
+      var aMounted = unmountAtom(store, a);
+      aMounted == null || aMounted.t.delete(atom);
+    }
+    return undefined;
+  }
+  return mounted;
+};
+var setAtomStateValueOrPromise = function setAtomStateValueOrPromise(store, atom, valueOrPromise) {
+  var ensureAtomState = getInternalBuildingBlocks(store)[11];
+  var atomState = ensureAtomState(store, atom);
+  var hasPrevValue = 'v' in atomState;
+  var prevValue = atomState.v;
+  if (isPromiseLike(valueOrPromise)) {
+    for (var _iterator0 = _createForOfIteratorHelperLoose(atomState.d.keys()), _step0; !(_step0 = _iterator0()).done;) {
+      var a = _step0.value;
+      addPendingPromiseToDependency(atom, valueOrPromise, ensureAtomState(store, a));
+    }
+  }
+  atomState.v = valueOrPromise;
+  delete atomState.e;
+  if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
+    ++atomState.n;
+    if (isPromiseLike(prevValue)) {
+      abortPromise(prevValue);
+    }
+  }
+};
+var storeGet = function storeGet(store, atom) {
+  var readAtomState = getInternalBuildingBlocks(store)[14];
+  return returnAtomValue(readAtomState(store, atom));
+};
+var storeSet = function storeSet(store, atom) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var flushCallbacks = buildingBlocks[12];
+  var recomputeInvalidatedAtoms = buildingBlocks[13];
+  var writeAtomState = buildingBlocks[16];
+  try {
+    for (var _len7 = arguments.length, args = new Array(_len7 > 2 ? _len7 - 2 : 0), _key7 = 2; _key7 < _len7; _key7++) {
+      args[_key7 - 2] = arguments[_key7];
+    }
+    return writeAtomState.apply(void 0, [store, atom].concat(args));
+  } finally {
+    recomputeInvalidatedAtoms(store);
+    flushCallbacks(store);
+  }
+};
+var storeSub = function storeSub(store, atom, listener) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var flushCallbacks = buildingBlocks[12];
+  var mountAtom = buildingBlocks[18];
+  var unmountAtom = buildingBlocks[19];
+  var mounted = mountAtom(store, atom);
+  var listeners = mounted.l;
+  listeners.add(listener);
+  flushCallbacks(store);
+  return function () {
+    listeners.delete(listener);
+    unmountAtom(store, atom);
+    flushCallbacks(store);
+  };
+};
+var buildingBlockMap = new WeakMap();
+var getInternalBuildingBlocks = function getInternalBuildingBlocks(store) {
+  var buildingBlocks = buildingBlockMap.get(store);
+  if (process.env.NODE_ENV !== 'production' && !buildingBlocks) {
+    throw new Error('Store must be created by buildStore to read its building blocks');
+  }
+  return buildingBlocks;
+};
+function getBuildingBlocks(store) {
+  var buildingBlocks = getInternalBuildingBlocks(store);
+  var enhanceBuildingBlocks = buildingBlocks[24];
+  if (enhanceBuildingBlocks) {
+    return enhanceBuildingBlocks(buildingBlocks);
+  }
+  return buildingBlocks;
+}
+function buildStore() {
+  for (var _len8 = arguments.length, buildArgs = new Array(_len8), _key8 = 0; _key8 < _len8; _key8++) {
+    buildArgs[_key8] = arguments[_key8];
+  }
+  var store = {
+    get: function get(atom) {
+      var storeGet = getInternalBuildingBlocks(store)[21];
+      return storeGet(store, atom);
+    },
+    set: function set(atom) {
+      var storeSet = getInternalBuildingBlocks(store)[22];
+      for (var _len9 = arguments.length, args = new Array(_len9 > 1 ? _len9 - 1 : 0), _key9 = 1; _key9 < _len9; _key9++) {
+        args[_key9 - 1] = arguments[_key9];
+      }
+      return storeSet.apply(void 0, [store, atom].concat(args));
+    },
+    sub: function sub(atom, listener) {
+      var storeSub = getInternalBuildingBlocks(store)[23];
+      return storeSub(store, atom, listener);
+    }
+  };
+  var buildingBlocks = [new WeakMap(), new WeakMap(), new WeakMap(), new Set(), new Set(), new Set(), {}, atomRead, atomWrite, atomOnInit, atomOnMount, ensureAtomState, flushCallbacks, recomputeInvalidatedAtoms, readAtomState, invalidateDependents, _writeAtomState, mountDependencies, _mountAtom, unmountAtom, setAtomStateValueOrPromise, storeGet, storeSet, storeSub, undefined].map(function (fn, i) {
+    return buildArgs[i] || fn;
+  });
+  buildingBlockMap.set(store, Object.freeze(buildingBlocks));
+  return store;
+}
+
+exports.INTERNAL_abortPromise = abortPromise;
+exports.INTERNAL_addPendingPromiseToDependency = addPendingPromiseToDependency;
+exports.INTERNAL_buildStoreRev2 = buildStore;
+exports.INTERNAL_getBuildingBlocksRev2 = getBuildingBlocks;
+exports.INTERNAL_getMountedOrPendingDependents = getMountedOrPendingDependents;
+exports.INTERNAL_hasInitialValue = hasInitialValue;
+exports.INTERNAL_initializeStoreHooksRev2 = initializeStoreHooks;
+exports.INTERNAL_isActuallyWritableAtom = isActuallyWritableAtom;
+exports.INTERNAL_isAtomStateInitialized = isAtomStateInitialized;
+exports.INTERNAL_isPendingPromise = isPendingPromise;
+exports.INTERNAL_isPromiseLike = isPromiseLike;
+exports.INTERNAL_promiseStateMap = promiseStateMap;
+exports.INTERNAL_registerAbortHandler = registerAbortHandler;
+exports.INTERNAL_returnAtomValue = returnAtomValue;

node_modules/jotai/vanilla/store.d.ts

@@ -0,0 +1,5 @@
+import type { INTERNAL_Store } from 'jotai/vanilla/internals';
+export type Store = INTERNAL_Store;
+export declare function INTERNAL_overrideCreateStore(fn: (prev: typeof createStore | undefined) => typeof createStore): void;
+export declare function createStore(): Store;
+export declare function getDefaultStore(): Store;

node_modules/jotai/vanilla/typeUtils.d.ts

@@ -0,0 +1,7 @@
+import type { Atom, PrimitiveAtom, WritableAtom } from './atom';
+export type Getter = Parameters<Atom<unknown>['read']>[0];
+export type Setter = Parameters<WritableAtom<unknown, unknown[], unknown>['write']>[1];
+export type ExtractAtomValue<AtomType> = AtomType extends Atom<infer Value> ? Value : never;
+export type ExtractAtomArgs<AtomType> = AtomType extends WritableAtom<unknown, infer Args, infer _Result> ? Args : never;
+export type ExtractAtomResult<AtomType> = AtomType extends WritableAtom<unknown, infer _Args, infer Result> ? Result : never;
+export type SetStateAction<Value> = ExtractAtomArgs<PrimitiveAtom<Value>>[0];

node_modules/jotai/vanilla/utils.d.ts

@@ -0,0 +1,14 @@
+export { RESET } from './utils/constants';
+export { atomWithReset } from './utils/atomWithReset';
+export { atomWithReducer } from './utils/atomWithReducer';
+export { atomFamily } from './utils/atomFamily';
+export { selectAtom } from './utils/selectAtom';
+export { freezeAtom, freezeAtomCreator } from './utils/freezeAtom';
+export { splitAtom } from './utils/splitAtom';
+export { atomWithDefault } from './utils/atomWithDefault';
+export { atomWithStorage, createJSONStorage, withStorageValidator as unstable_withStorageValidator, } from './utils/atomWithStorage';
+export { atomWithObservable } from './utils/atomWithObservable';
+export { loadable } from './utils/loadable';
+export { unwrap } from './utils/unwrap';
+export { atomWithRefresh } from './utils/atomWithRefresh';
+export { atomWithLazy } from './utils/atomWithLazy';

node_modules/jotai/vanilla/utils.js

@@ -0,0 +1,873 @@
+'use strict';
+
+var vanilla = require('jotai/vanilla');
+
+var RESET = Symbol(process.env.NODE_ENV !== 'production' ? 'RESET' : '');
+
+function atomWithReset(initialValue) {
+  var anAtom = vanilla.atom(initialValue, function (get, set, update) {
+    var nextValue = typeof update === 'function' ? update(get(anAtom)) : update;
+    set(anAtom, nextValue === RESET ? initialValue : nextValue);
+  });
+  return anAtom;
+}
+
+function atomWithReducer(initialValue, reducer) {
+  return vanilla.atom(initialValue, function (get, set, action) {
+    set(this, reducer(get(this), action));
+  });
+}
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+    t && (r = t);
+    var o = 0;
+    return function () {
+      return o >= r.length ? {
+        done: true
+      } : {
+        done: false,
+        value: r[o++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function atomFamily(initializeAtom, areEqual) {
+  var shouldRemove = null;
+  var atoms = new Map();
+  var listeners = new Set();
+  var _createAtom = function createAtom(param) {
+    var item;
+    if (areEqual === undefined) {
+      item = atoms.get(param);
+    } else {
+      for (var _iterator = _createForOfIteratorHelperLoose(atoms), _step; !(_step = _iterator()).done;) {
+        var _step$value = _step.value,
+          key = _step$value[0],
+          value = _step$value[1];
+        if (areEqual(key, param)) {
+          item = value;
+          break;
+        }
+      }
+    }
+    if (item !== undefined) {
+      if (shouldRemove != null && shouldRemove(item[1], param)) {
+        _createAtom.remove(param);
+      } else {
+        return item[0];
+      }
+    }
+    var newAtom = initializeAtom(param);
+    atoms.set(param, [newAtom, Date.now()]);
+    notifyListeners('CREATE', param, newAtom);
+    return newAtom;
+  };
+  var notifyListeners = function notifyListeners(type, param, atom) {
+    for (var _iterator2 = _createForOfIteratorHelperLoose(listeners), _step2; !(_step2 = _iterator2()).done;) {
+      var listener = _step2.value;
+      listener({
+        type: type,
+        param: param,
+        atom: atom
+      });
+    }
+  };
+  _createAtom.unstable_listen = function (callback) {
+    listeners.add(callback);
+    return function () {
+      listeners.delete(callback);
+    };
+  };
+  _createAtom.getParams = function () {
+    return atoms.keys();
+  };
+  _createAtom.remove = function (param) {
+    if (areEqual === undefined) {
+      if (!atoms.has(param)) return;
+      var _ref = atoms.get(param),
+        atom = _ref[0];
+      atoms.delete(param);
+      notifyListeners('REMOVE', param, atom);
+    } else {
+      for (var _iterator3 = _createForOfIteratorHelperLoose(atoms), _step3; !(_step3 = _iterator3()).done;) {
+        var _step3$value = _step3.value,
+          key = _step3$value[0],
+          _step3$value$ = _step3$value[1],
+          _atom = _step3$value$[0];
+        if (areEqual(key, param)) {
+          atoms.delete(key);
+          notifyListeners('REMOVE', key, _atom);
+          break;
+        }
+      }
+    }
+  };
+  _createAtom.setShouldRemove = function (fn) {
+    shouldRemove = fn;
+    if (!shouldRemove) return;
+    for (var _iterator4 = _createForOfIteratorHelperLoose(atoms), _step4; !(_step4 = _iterator4()).done;) {
+      var _step4$value = _step4.value,
+        key = _step4$value[0],
+        _step4$value$ = _step4$value[1],
+        atom = _step4$value$[0],
+        _createdAt = _step4$value$[1];
+      if (shouldRemove(_createdAt, key)) {
+        atoms.delete(key);
+        notifyListeners('REMOVE', key, atom);
+      }
+    }
+  };
+  return _createAtom;
+}
+
+var getCached$2 = function getCached(c, m, k) {
+  return (m.has(k) ? m : m.set(k, c())).get(k);
+};
+var cache1$3 = new WeakMap();
+var memo3 = function memo3(create, dep1, dep2, dep3) {
+  var cache2 = getCached$2(function () {
+    return new WeakMap();
+  }, cache1$3, dep1);
+  var cache3 = getCached$2(function () {
+    return new WeakMap();
+  }, cache2, dep2);
+  return getCached$2(create, cache3, dep3);
+};
+function selectAtom(anAtom, selector, equalityFn) {
+  if (equalityFn === void 0) {
+    equalityFn = Object.is;
+  }
+  return memo3(function () {
+    var EMPTY = Symbol();
+    var selectValue = function selectValue(_ref) {
+      var value = _ref[0],
+        prevSlice = _ref[1];
+      if (prevSlice === EMPTY) {
+        return selector(value);
+      }
+      var slice = selector(value, prevSlice);
+      return equalityFn(prevSlice, slice) ? prevSlice : slice;
+    };
+    var derivedAtom = vanilla.atom(function (get) {
+      var prev = get(derivedAtom);
+      var value = get(anAtom);
+      return selectValue([value, prev]);
+    });
+    derivedAtom.init = EMPTY;
+    return derivedAtom;
+  }, anAtom, selector, equalityFn);
+}
+
+var frozenAtoms = new WeakSet();
+var _deepFreeze = function deepFreeze(value) {
+  if (typeof value !== 'object' || value === null) {
+    return value;
+  }
+  Object.freeze(value);
+  var propNames = Object.getOwnPropertyNames(value);
+  for (var _iterator = _createForOfIteratorHelperLoose(propNames), _step; !(_step = _iterator()).done;) {
+    var name = _step.value;
+    _deepFreeze(value[name]);
+  }
+  return value;
+};
+function freezeAtom(anAtom) {
+  if (frozenAtoms.has(anAtom)) {
+    return anAtom;
+  }
+  frozenAtoms.add(anAtom);
+  var origRead = anAtom.read;
+  anAtom.read = function (get, options) {
+    return _deepFreeze(origRead.call(this, get, options));
+  };
+  if ('write' in anAtom) {
+    var origWrite = anAtom.write;
+    anAtom.write = function (get, set) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      return origWrite.call.apply(origWrite, [this, get, function () {
+        for (var _len2 = arguments.length, setArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          setArgs[_key2] = arguments[_key2];
+        }
+        if (setArgs[0] === anAtom) {
+          setArgs[1] = _deepFreeze(setArgs[1]);
+        }
+        return set.apply(void 0, setArgs);
+      }].concat(args));
+    };
+  }
+  return anAtom;
+}
+function freezeAtomCreator(createAtom) {
+  if (process.env.NODE_ENV !== 'production') {
+    console.warn('[DEPRECATED] freezeAtomCreator is deprecated, define it on users end');
+  }
+  return function () {
+    return freezeAtom(createAtom.apply(void 0, arguments));
+  };
+}
+
+var getCached$1 = function getCached(c, m, k) {
+  return (m.has(k) ? m : m.set(k, c())).get(k);
+};
+var cache1$2 = new WeakMap();
+var memo2$1 = function memo2(create, dep1, dep2) {
+  var cache2 = getCached$1(function () {
+    return new WeakMap();
+  }, cache1$2, dep1);
+  return getCached$1(create, cache2, dep2);
+};
+var cacheKeyForEmptyKeyExtractor = {};
+var isWritable = function isWritable(atom) {
+  return !!atom.write;
+};
+var isFunction = function isFunction(x) {
+  return typeof x === 'function';
+};
+function splitAtom(arrAtom, keyExtractor) {
+  return memo2$1(function () {
+    var mappingCache = new WeakMap();
+    var _getMapping = function getMapping(arr, prev) {
+      var mapping = mappingCache.get(arr);
+      if (mapping) {
+        return mapping;
+      }
+      var prevMapping = prev && mappingCache.get(prev);
+      var atomList = [];
+      var keyList = [];
+      arr.forEach(function (item, index) {
+        var key = keyExtractor ? keyExtractor(item) : index;
+        keyList[index] = key;
+        var cachedAtom = prevMapping && prevMapping.atomList[prevMapping.keyList.indexOf(key)];
+        if (cachedAtom) {
+          atomList[index] = cachedAtom;
+          return;
+        }
+        var read = function read(get) {
+          var prev = get(mappingAtom);
+          var currArr = get(arrAtom);
+          var mapping = _getMapping(currArr, prev == null ? void 0 : prev.arr);
+          var index = mapping.keyList.indexOf(key);
+          if (index < 0 || index >= currArr.length) {
+            var prevItem = arr[_getMapping(arr).keyList.indexOf(key)];
+            if (prevItem) {
+              return prevItem;
+            }
+            throw new Error('splitAtom: index out of bounds for read');
+          }
+          return currArr[index];
+        };
+        var write = function write(get, set, update) {
+          var prev = get(mappingAtom);
+          var arr = get(arrAtom);
+          var mapping = _getMapping(arr, prev == null ? void 0 : prev.arr);
+          var index = mapping.keyList.indexOf(key);
+          if (index < 0 || index >= arr.length) {
+            throw new Error('splitAtom: index out of bounds for write');
+          }
+          var nextItem = isFunction(update) ? update(arr[index]) : update;
+          if (!Object.is(arr[index], nextItem)) {
+            set(arrAtom, [].concat(arr.slice(0, index), [nextItem], arr.slice(index + 1)));
+          }
+        };
+        atomList[index] = isWritable(arrAtom) ? vanilla.atom(read, write) : vanilla.atom(read);
+      });
+      if (prevMapping && prevMapping.keyList.length === keyList.length && prevMapping.keyList.every(function (x, i) {
+        return x === keyList[i];
+      })) {
+        mapping = prevMapping;
+      } else {
+        mapping = {
+          arr: arr,
+          atomList: atomList,
+          keyList: keyList
+        };
+      }
+      mappingCache.set(arr, mapping);
+      return mapping;
+    };
+    var mappingAtom = vanilla.atom(function (get) {
+      var prev = get(mappingAtom);
+      var arr = get(arrAtom);
+      var mapping = _getMapping(arr, prev == null ? void 0 : prev.arr);
+      return mapping;
+    });
+    if (process.env.NODE_ENV !== 'production') {
+      mappingAtom.debugPrivate = true;
+    }
+    mappingAtom.init = undefined;
+    var splittedAtom = isWritable(arrAtom) ? vanilla.atom(function (get) {
+      return get(mappingAtom).atomList;
+    }, function (get, set, action) {
+      switch (action.type) {
+        case 'remove':
+          {
+            var index = get(splittedAtom).indexOf(action.atom);
+            if (index >= 0) {
+              var arr = get(arrAtom);
+              set(arrAtom, [].concat(arr.slice(0, index), arr.slice(index + 1)));
+            }
+            break;
+          }
+        case 'insert':
+          {
+            var _index = action.before ? get(splittedAtom).indexOf(action.before) : get(splittedAtom).length;
+            if (_index >= 0) {
+              var _arr = get(arrAtom);
+              set(arrAtom, [].concat(_arr.slice(0, _index), [action.value], _arr.slice(_index)));
+            }
+            break;
+          }
+        case 'move':
+          {
+            var index1 = get(splittedAtom).indexOf(action.atom);
+            var index2 = action.before ? get(splittedAtom).indexOf(action.before) : get(splittedAtom).length;
+            if (index1 >= 0 && index2 >= 0) {
+              var _arr2 = get(arrAtom);
+              if (index1 < index2) {
+                set(arrAtom, [].concat(_arr2.slice(0, index1), _arr2.slice(index1 + 1, index2), [_arr2[index1]], _arr2.slice(index2)));
+              } else {
+                set(arrAtom, [].concat(_arr2.slice(0, index2), [_arr2[index1]], _arr2.slice(index2, index1), _arr2.slice(index1 + 1)));
+              }
+            }
+            break;
+          }
+      }
+    }) : vanilla.atom(function (get) {
+      return get(mappingAtom).atomList;
+    });
+    return splittedAtom;
+  }, arrAtom, keyExtractor || cacheKeyForEmptyKeyExtractor);
+}
+
+function atomWithDefault(getDefault) {
+  var EMPTY = Symbol();
+  var overwrittenAtom = vanilla.atom(EMPTY);
+  if (process.env.NODE_ENV !== 'production') {
+    overwrittenAtom.debugPrivate = true;
+  }
+  var anAtom = vanilla.atom(function (get, options) {
+    var overwritten = get(overwrittenAtom);
+    if (overwritten !== EMPTY) {
+      return overwritten;
+    }
+    return getDefault(get, options);
+  }, function (get, set, update) {
+    var newValue = typeof update === 'function' ? update(get(anAtom)) : update;
+    set(overwrittenAtom, newValue === RESET ? EMPTY : newValue);
+  });
+  return anAtom;
+}
+
+var isPromiseLike$3 = function isPromiseLike(x) {
+  return typeof (x == null ? void 0 : x.then) === 'function';
+};
+function withStorageValidator(validator) {
+  return function (unknownStorage) {
+    var storage = _extends({}, unknownStorage, {
+      getItem: function getItem(key, initialValue) {
+        var validate = function validate(value) {
+          if (!validator(value)) {
+            return initialValue;
+          }
+          return value;
+        };
+        var value = unknownStorage.getItem(key, initialValue);
+        if (isPromiseLike$3(value)) {
+          return value.then(validate);
+        }
+        return validate(value);
+      }
+    });
+    return storage;
+  };
+}
+function createJSONStorage(getStringStorage, options) {
+  if (getStringStorage === void 0) {
+    getStringStorage = function getStringStorage() {
+      try {
+        return window.localStorage;
+      } catch (e) {
+        if (process.env.NODE_ENV !== 'production') {
+          if (typeof window !== 'undefined') {
+            console.warn(e);
+          }
+        }
+        return undefined;
+      }
+    };
+  }
+  var lastStr;
+  var lastValue;
+  var storage = {
+    getItem: function getItem(key, initialValue) {
+      var _getStringStorage$get, _getStringStorage;
+      var parse = function parse(str) {
+        str = str || '';
+        if (lastStr !== str) {
+          try {
+            lastValue = JSON.parse(str, options == null ? void 0 : options.reviver);
+          } catch (_unused) {
+            return initialValue;
+          }
+          lastStr = str;
+        }
+        return lastValue;
+      };
+      var str = (_getStringStorage$get = (_getStringStorage = getStringStorage()) == null ? void 0 : _getStringStorage.getItem(key)) != null ? _getStringStorage$get : null;
+      if (isPromiseLike$3(str)) {
+        return str.then(parse);
+      }
+      return parse(str);
+    },
+    setItem: function setItem(key, newValue) {
+      var _getStringStorage2;
+      return (_getStringStorage2 = getStringStorage()) == null ? void 0 : _getStringStorage2.setItem(key, JSON.stringify(newValue, options == null ? void 0 : options.replacer));
+    },
+    removeItem: function removeItem(key) {
+      var _getStringStorage3;
+      return (_getStringStorage3 = getStringStorage()) == null ? void 0 : _getStringStorage3.removeItem(key);
+    }
+  };
+  var createHandleSubscribe = function createHandleSubscribe(subscriber) {
+    return function (key, callback, initialValue) {
+      return subscriber(key, function (v) {
+        var newValue;
+        try {
+          newValue = JSON.parse(v || '');
+        } catch (_unused2) {
+          newValue = initialValue;
+        }
+        callback(newValue);
+      });
+    };
+  };
+  var subscriber;
+  try {
+    var _getStringStorage4;
+    subscriber = (_getStringStorage4 = getStringStorage()) == null ? void 0 : _getStringStorage4.subscribe;
+  } catch (_unused3) {}
+  if (!subscriber && typeof window !== 'undefined' && typeof window.addEventListener === 'function' && window.Storage) {
+    subscriber = function subscriber(key, callback) {
+      if (!(getStringStorage() instanceof window.Storage)) {
+        return function () {};
+      }
+      var storageEventCallback = function storageEventCallback(e) {
+        if (e.storageArea === getStringStorage() && e.key === key) {
+          callback(e.newValue);
+        }
+      };
+      window.addEventListener('storage', storageEventCallback);
+      return function () {
+        window.removeEventListener('storage', storageEventCallback);
+      };
+    };
+  }
+  if (subscriber) {
+    storage.subscribe = createHandleSubscribe(subscriber);
+  }
+  return storage;
+}
+var defaultStorage = createJSONStorage();
+function atomWithStorage(key, initialValue, storage, options) {
+  if (storage === void 0) {
+    storage = defaultStorage;
+  }
+  var getOnInit = options == null ? void 0 : options.getOnInit;
+  var baseAtom = vanilla.atom(getOnInit ? storage.getItem(key, initialValue) : initialValue);
+  if (process.env.NODE_ENV !== 'production') {
+    baseAtom.debugPrivate = true;
+  }
+  baseAtom.onMount = function (setAtom) {
+    setAtom(storage.getItem(key, initialValue));
+    var unsub;
+    if (storage.subscribe) {
+      unsub = storage.subscribe(key, setAtom, initialValue);
+    }
+    return unsub;
+  };
+  var anAtom = vanilla.atom(function (get) {
+    return get(baseAtom);
+  }, function (get, set, update) {
+    var 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(function (resolvedValue) {
+        set(baseAtom, resolvedValue);
+        return storage.setItem(key, resolvedValue);
+      });
+    }
+    set(baseAtom, nextValue);
+    return storage.setItem(key, nextValue);
+  });
+  return anAtom;
+}
+
+var isPromiseLike$2 = function isPromiseLike(x) {
+  return typeof (x == null ? void 0 : x.then) === 'function';
+};
+function atomWithObservable(getObservable, options) {
+  var returnResultData = function returnResultData(result) {
+    if ('e' in result) {
+      throw result.e;
+    }
+    return result.d;
+  };
+  var observableResultAtom = vanilla.atom(function (get) {
+    var _Symbol$observable, _ref;
+    var observable = getObservable(get);
+    var itself = (_Symbol$observable = (_ref = observable)[Symbol.observable]) == null ? void 0 : _Symbol$observable.call(_ref);
+    if (itself) {
+      observable = itself;
+    }
+    var resolve;
+    var makePending = function makePending() {
+      return new Promise(function (r) {
+        resolve = r;
+      });
+    };
+    var initialResult = options && 'initialValue' in options ? {
+      d: typeof options.initialValue === 'function' ? options.initialValue() : options.initialValue
+    } : makePending();
+    var setResult;
+    var lastResult;
+    var listener = function listener(result) {
+      lastResult = result;
+      resolve == null || resolve(result);
+      setResult == null || setResult(result);
+    };
+    var subscription;
+    var timer;
+    var isNotMounted = function isNotMounted() {
+      return !setResult;
+    };
+    var unsubscribe = function unsubscribe() {
+      if (subscription) {
+        subscription.unsubscribe();
+        subscription = undefined;
+      }
+    };
+    var start = function start() {
+      if (subscription) {
+        clearTimeout(timer);
+        subscription.unsubscribe();
+      }
+      subscription = observable.subscribe({
+        next: function next(d) {
+          return listener({
+            d: d
+          });
+        },
+        error: function error(e) {
+          return listener({
+            e: e
+          });
+        },
+        complete: function complete() {}
+      });
+      if (isNotMounted() && options != null && options.unstable_timeout) {
+        timer = setTimeout(unsubscribe, options.unstable_timeout);
+      }
+    };
+    start();
+    var resultAtom = vanilla.atom(lastResult || initialResult);
+    if (process.env.NODE_ENV !== 'production') {
+      resultAtom.debugPrivate = true;
+    }
+    resultAtom.onMount = function (update) {
+      setResult = update;
+      if (lastResult) {
+        update(lastResult);
+      }
+      if (subscription) {
+        clearTimeout(timer);
+      } else {
+        start();
+      }
+      return function () {
+        setResult = undefined;
+        if (options != null && options.unstable_timeout) {
+          timer = setTimeout(unsubscribe, options.unstable_timeout);
+        } else {
+          unsubscribe();
+        }
+      };
+    };
+    return [resultAtom, observable, makePending, start, isNotMounted];
+  });
+  if (process.env.NODE_ENV !== 'production') {
+    observableResultAtom.debugPrivate = true;
+  }
+  var observableAtom = vanilla.atom(function (get) {
+    var _get = get(observableResultAtom),
+      resultAtom = _get[0];
+    var result = get(resultAtom);
+    if (isPromiseLike$2(result)) {
+      return result.then(returnResultData);
+    }
+    return returnResultData(result);
+  }, function (get, set, data) {
+    var _get2 = get(observableResultAtom),
+      resultAtom = _get2[0],
+      observable = _get2[1],
+      makePending = _get2[2],
+      start = _get2[3],
+      isNotMounted = _get2[4];
+    if ('next' in observable) {
+      if (isNotMounted()) {
+        set(resultAtom, makePending());
+        start();
+      }
+      observable.next(data);
+    } else {
+      throw new Error('observable is not subject');
+    }
+  });
+  return observableAtom;
+}
+
+var cache1$1 = new WeakMap();
+var memo1 = function memo1(create, dep1) {
+  return (cache1$1.has(dep1) ? cache1$1 : cache1$1.set(dep1, create())).get(dep1);
+};
+var isPromiseLike$1 = function isPromiseLike(p) {
+  return typeof (p == null ? void 0 : p.then) === 'function';
+};
+var LOADING = {
+  state: 'loading'
+};
+function loadable(anAtom) {
+  return memo1(function () {
+    var loadableCache = new WeakMap();
+    var refreshAtom = vanilla.atom(0);
+    if (process.env.NODE_ENV !== 'production') {
+      refreshAtom.debugPrivate = true;
+    }
+    var derivedAtom = vanilla.atom(function (get, _ref) {
+      var setSelf = _ref.setSelf;
+      get(refreshAtom);
+      var value;
+      try {
+        value = get(anAtom);
+      } catch (error) {
+        return {
+          state: 'hasError',
+          error: error
+        };
+      }
+      if (!isPromiseLike$1(value)) {
+        return {
+          state: 'hasData',
+          data: value
+        };
+      }
+      var promise = value;
+      var cached1 = loadableCache.get(promise);
+      if (cached1) {
+        return cached1;
+      }
+      promise.then(function (data) {
+        loadableCache.set(promise, {
+          state: 'hasData',
+          data: data
+        });
+        setSelf();
+      }, function (error) {
+        loadableCache.set(promise, {
+          state: 'hasError',
+          error: error
+        });
+        setSelf();
+      });
+      var cached2 = loadableCache.get(promise);
+      if (cached2) {
+        return cached2;
+      }
+      loadableCache.set(promise, LOADING);
+      return LOADING;
+    }, function (_get, set) {
+      set(refreshAtom, function (c) {
+        return c + 1;
+      });
+    });
+    if (process.env.NODE_ENV !== 'production') {
+      derivedAtom.debugPrivate = true;
+    }
+    return vanilla.atom(function (get) {
+      return get(derivedAtom);
+    });
+  }, anAtom);
+}
+
+var getCached = function getCached(c, m, k) {
+  return (m.has(k) ? m : m.set(k, c())).get(k);
+};
+var cache1 = new WeakMap();
+var memo2 = function memo2(create, dep1, dep2) {
+  var cache2 = getCached(function () {
+    return new WeakMap();
+  }, cache1, dep1);
+  return getCached(create, cache2, dep2);
+};
+var isPromiseLike = function isPromiseLike(p) {
+  return typeof (p == null ? void 0 : p.then) === 'function';
+};
+var defaultFallback = function defaultFallback() {
+  return undefined;
+};
+function unwrap(anAtom, fallback) {
+  if (fallback === void 0) {
+    fallback = defaultFallback;
+  }
+  return memo2(function () {
+    var promiseErrorCache = new WeakMap();
+    var promiseResultCache = new WeakMap();
+    var refreshAtom = vanilla.atom(0);
+    if (process.env.NODE_ENV !== 'production') {
+      refreshAtom.debugPrivate = true;
+    }
+    var promiseAndValueAtom = vanilla.atom(function (get, _ref) {
+      var setSelf = _ref.setSelf;
+      get(refreshAtom);
+      var prev = get(promiseAndValueAtom);
+      var promise = get(anAtom);
+      if (!isPromiseLike(promise)) {
+        return {
+          v: promise
+        };
+      }
+      if (promise !== (prev == null ? void 0 : prev.p)) {
+        promise.then(function (v) {
+          promiseResultCache.set(promise, v);
+          setSelf();
+        }, function (e) {
+          promiseErrorCache.set(promise, e);
+          setSelf();
+        });
+      }
+      if (promiseErrorCache.has(promise)) {
+        throw promiseErrorCache.get(promise);
+      }
+      if (promiseResultCache.has(promise)) {
+        return {
+          p: promise,
+          v: promiseResultCache.get(promise)
+        };
+      }
+      if (prev && 'v' in prev) {
+        return {
+          p: promise,
+          f: fallback(prev.v),
+          v: prev.v
+        };
+      }
+      return {
+        p: promise,
+        f: fallback()
+      };
+    }, function (_get, set) {
+      set(refreshAtom, function (c) {
+        return c + 1;
+      });
+    });
+    promiseAndValueAtom.init = undefined;
+    if (process.env.NODE_ENV !== 'production') {
+      promiseAndValueAtom.debugPrivate = true;
+    }
+    return vanilla.atom(function (get) {
+      var state = get(promiseAndValueAtom);
+      if ('f' in state) {
+        return state.f;
+      }
+      return state.v;
+    }, function (_get, set) {
+      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        args[_key - 2] = arguments[_key];
+      }
+      return set.apply(void 0, [anAtom].concat(args));
+    });
+  }, anAtom, fallback);
+}
+
+function atomWithRefresh(read, write) {
+  var refreshAtom = vanilla.atom(0);
+  if (process.env.NODE_ENV !== 'production') {
+    refreshAtom.debugPrivate = true;
+  }
+  return vanilla.atom(function (get, options) {
+    get(refreshAtom);
+    return read(get, options);
+  }, function (get, set) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    if (args.length === 0) {
+      set(refreshAtom, function (c) {
+        return c + 1;
+      });
+    } else if (write) {
+      return write.apply(void 0, [get, set].concat(args));
+    } else if (process.env.NODE_ENV !== 'production') {
+      throw new Error('refresh must be called without arguments');
+    }
+  });
+}
+
+function atomWithLazy(makeInitial) {
+  var a = vanilla.atom(undefined);
+  delete a.init;
+  Object.defineProperty(a, 'init', {
+    get: function get() {
+      return makeInitial();
+    }
+  });
+  return a;
+}
+
+exports.RESET = RESET;
+exports.atomFamily = atomFamily;
+exports.atomWithDefault = atomWithDefault;
+exports.atomWithLazy = atomWithLazy;
+exports.atomWithObservable = atomWithObservable;
+exports.atomWithReducer = atomWithReducer;
+exports.atomWithRefresh = atomWithRefresh;
+exports.atomWithReset = atomWithReset;
+exports.atomWithStorage = atomWithStorage;
+exports.createJSONStorage = createJSONStorage;
+exports.freezeAtom = freezeAtom;
+exports.freezeAtomCreator = freezeAtomCreator;
+exports.loadable = loadable;
+exports.selectAtom = selectAtom;
+exports.splitAtom = splitAtom;
+exports.unstable_withStorageValidator = withStorageValidator;
+exports.unwrap = unwrap;

node_modules/jotai/vanilla/utils/atomFamily.d.ts

@@ -0,0 +1,25 @@
+import { type Atom } from 'jotai/vanilla';
+/**
+ * in milliseconds
+ */
+type CreatedAt = number;
+type ShouldRemove<Param> = (createdAt: CreatedAt, param: Param) => boolean;
+type Cleanup = () => void;
+type Callback<Param, AtomType> = (event: {
+    type: 'CREATE' | 'REMOVE';
+    param: Param;
+    atom: AtomType;
+}) => void;
+export interface AtomFamily<Param, AtomType> {
+    (param: Param): AtomType;
+    getParams(): Iterable<Param>;
+    remove(param: Param): void;
+    setShouldRemove(shouldRemove: ShouldRemove<Param> | null): void;
+    /**
+     * fires when a atom is created or removed
+     * This API is for advanced use cases, and can change without notice.
+     */
+    unstable_listen(callback: Callback<Param, AtomType>): Cleanup;
+}
+export declare function atomFamily<Param, AtomType extends Atom<unknown>>(initializeAtom: (param: Param) => AtomType, areEqual?: (a: Param, b: Param) => boolean): AtomFamily<Param, AtomType>;
+export {};

node_modules/jotai/vanilla/utils/atomWithDefault.d.ts

@@ -0,0 +1,6 @@
+import type { WritableAtom } from 'jotai/vanilla';
+import { RESET } from './constants';
+type Read<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['read'];
+type DefaultSetStateAction<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+export declare function atomWithDefault<Value>(getDefault: Read<Value, [DefaultSetStateAction<Value>], void>): WritableAtom<Value, [DefaultSetStateAction<Value>], void>;
+export {};

node_modules/jotai/vanilla/utils/atomWithLazy.d.ts

@@ -0,0 +1,2 @@
+import type { PrimitiveAtom } from 'jotai/vanilla';
+export declare function atomWithLazy<Value>(makeInitial: () => Value): PrimitiveAtom<Value>;

node_modules/jotai/vanilla/utils/atomWithObservable.d.ts

@@ -0,0 +1,32 @@
+import type { Atom, Getter, WritableAtom } from 'jotai/vanilla';
+type AnyError = unknown;
+type Subscription = {
+    unsubscribe: () => void;
+};
+type Observer<T> = {
+    next: (value: T) => void;
+    error: (error: AnyError) => void;
+    complete: () => void;
+};
+type ObservableLike<T> = {
+    subscribe(observer: Observer<T>): Subscription;
+} | {
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+} | {
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+    subscribe(next: (value: T) => void): Subscription;
+};
+type SubjectLike<T> = ObservableLike<T> & Observer<T>;
+type Options<Data> = {
+    initialValue?: Data | (() => Data);
+    unstable_timeout?: number;
+};
+type OptionsWithInitialValue<Data> = {
+    initialValue: Data | (() => Data);
+    unstable_timeout?: number;
+};
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => SubjectLike<Data>, options: OptionsWithInitialValue<Data>): WritableAtom<Data, [Data], void>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => SubjectLike<Data>, options?: Options<Data>): WritableAtom<Data | Promise<Data>, [Data], void>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => ObservableLike<Data>, options: OptionsWithInitialValue<Data>): Atom<Data>;
+export declare function atomWithObservable<Data>(getObservable: (get: Getter) => ObservableLike<Data>, options?: Options<Data>): Atom<Data | Promise<Data>>;
+export {};

node_modules/jotai/vanilla/utils/atomWithReducer.d.ts

@@ -0,0 +1,3 @@
+import type { WritableAtom } from 'jotai/vanilla';
+export declare function atomWithReducer<Value, Action>(initialValue: Value, reducer: (value: Value, action?: Action) => Value): WritableAtom<Value, [Action?], void>;
+export declare function atomWithReducer<Value, Action>(initialValue: Value, reducer: (value: Value, action: Action) => Value): WritableAtom<Value, [Action], void>;

node_modules/jotai/vanilla/utils/atomWithRefresh.d.ts

@@ -0,0 +1,6 @@
+import type { WritableAtom } from 'jotai/vanilla';
+type Read<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['read'];
+type Write<Value, Args extends unknown[], Result> = WritableAtom<Value, Args, Result>['write'];
+export declare function atomWithRefresh<Value, Args extends unknown[], Result>(read: Read<Value, Args, Result>, write: Write<Value, Args, Result>): WritableAtom<Value, Args | [], Result | void>;
+export declare function atomWithRefresh<Value>(read: Read<Value, [], void>): WritableAtom<Value, [], void>;
+export {};

node_modules/jotai/vanilla/utils/atomWithReset.d.ts

@@ -0,0 +1,8 @@
+import type { WritableAtom } from 'jotai/vanilla';
+import { RESET } from './constants';
+type SetStateActionWithReset<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+type WithInitialValue<Value> = {
+    init: Value;
+};
+export declare function atomWithReset<Value>(initialValue: Value): WritableAtom<Value, [SetStateActionWithReset<Value>], void> & WithInitialValue<Value>;
+export {};

node_modules/jotai/vanilla/utils/atomWithStorage.d.ts

@@ -0,0 +1,50 @@
+import type { WritableAtom } from 'jotai/vanilla';
+import { RESET } from './constants';
+type Unsubscribe = () => void;
+type Subscribe<Value> = (key: string, callback: (value: Value) => void, initialValue: Value) => Unsubscribe | undefined;
+type StringSubscribe = (key: string, callback: (value: string | null) => void) => Unsubscribe | undefined;
+type SetStateActionWithReset<Value> = Value | typeof RESET | ((prev: Value) => Value | typeof RESET);
+export interface AsyncStorage<Value> {
+    getItem: (key: string, initialValue: Value) => PromiseLike<Value>;
+    setItem: (key: string, newValue: Value) => PromiseLike<void>;
+    removeItem: (key: string) => PromiseLike<void>;
+    subscribe?: Subscribe<Value>;
+}
+export interface SyncStorage<Value> {
+    getItem: (key: string, initialValue: Value) => Value;
+    setItem: (key: string, newValue: Value) => void;
+    removeItem: (key: string) => void;
+    subscribe?: Subscribe<Value>;
+}
+export interface AsyncStringStorage {
+    getItem: (key: string) => PromiseLike<string | null>;
+    setItem: (key: string, newValue: string) => PromiseLike<void>;
+    removeItem: (key: string) => PromiseLike<void>;
+    subscribe?: StringSubscribe;
+}
+export interface SyncStringStorage {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, newValue: string) => void;
+    removeItem: (key: string) => void;
+    subscribe?: StringSubscribe;
+}
+export declare function withStorageValidator<Value>(validator: (value: unknown) => value is Value): {
+    (storage: AsyncStorage<unknown>): AsyncStorage<Value>;
+    (storage: SyncStorage<unknown>): SyncStorage<Value>;
+};
+type JsonStorageOptions = {
+    reviver?: (key: string, value: unknown) => unknown;
+    replacer?: (key: string, value: unknown) => unknown;
+};
+export declare function createJSONStorage<Value>(): SyncStorage<Value>;
+export declare function createJSONStorage<Value>(getStringStorage: () => AsyncStringStorage, options?: JsonStorageOptions): AsyncStorage<Value>;
+export declare function createJSONStorage<Value>(getStringStorage: () => SyncStringStorage, options?: JsonStorageOptions): SyncStorage<Value>;
+export declare function atomWithStorage<Value>(key: string, initialValue: Value, storage: AsyncStorage<Value>, options?: {
+    getOnInit?: boolean;
+}): WritableAtom<Value | Promise<Value>, [
+    SetStateActionWithReset<Value | Promise<Value>>
+], Promise<void>>;
+export declare function atomWithStorage<Value>(key: string, initialValue: Value, storage?: SyncStorage<Value>, options?: {
+    getOnInit?: boolean;
+}): WritableAtom<Value, [SetStateActionWithReset<Value>], void>;
+export {};

node_modules/jotai/vanilla/utils/constants.d.ts

@@ -0,0 +1 @@
+export declare const RESET: unique symbol;

node_modules/jotai/vanilla/utils/freezeAtom.d.ts

@@ -0,0 +1,6 @@
+import type { Atom } from 'jotai/vanilla';
+export declare function freezeAtom<AtomType extends Atom<unknown>>(anAtom: AtomType): AtomType;
+/**
+ * @deprecated Define it on users end
+ */
+export declare function freezeAtomCreator<CreateAtom extends (...args: unknown[]) => Atom<unknown>>(createAtom: CreateAtom): CreateAtom;

node_modules/jotai/vanilla/utils/loadable.d.ts

@@ -0,0 +1,11 @@
+import type { Atom } from 'jotai/vanilla';
+export type Loadable<Value> = {
+    state: 'loading';
+} | {
+    state: 'hasError';
+    error: unknown;
+} | {
+    state: 'hasData';
+    data: Awaited<Value>;
+};
+export declare function loadable<Value>(anAtom: Atom<Value>): Atom<Loadable<Value>>;

node_modules/jotai/vanilla/utils/selectAtom.d.ts

@@ -0,0 +1,2 @@
+import type { Atom } from 'jotai/vanilla';
+export declare function selectAtom<Value, Slice>(anAtom: Atom<Value>, selector: (v: Value, prevSlice?: Slice) => Slice, equalityFn?: (a: Slice, b: Slice) => boolean): Atom<Slice>;

node_modules/jotai/vanilla/utils/splitAtom.d.ts

@@ -0,0 +1,16 @@
+import type { Atom, PrimitiveAtom, WritableAtom } from 'jotai/vanilla';
+type SplitAtomAction<Item> = {
+    type: 'remove';
+    atom: PrimitiveAtom<Item>;
+} | {
+    type: 'insert';
+    value: Item;
+    before?: PrimitiveAtom<Item>;
+} | {
+    type: 'move';
+    atom: PrimitiveAtom<Item>;
+    before?: PrimitiveAtom<Item>;
+};
+export declare function splitAtom<Item, Key>(arrAtom: WritableAtom<Item[], [Item[]], void>, keyExtractor?: (item: Item) => Key): WritableAtom<PrimitiveAtom<Item>[], [SplitAtomAction<Item>], void>;
+export declare function splitAtom<Item, Key>(arrAtom: Atom<Item[]>, keyExtractor?: (item: Item) => Key): Atom<Atom<Item>[]>;
+export {};

node_modules/jotai/vanilla/utils/unwrap.d.ts

@@ -0,0 +1,5 @@
+import type { Atom, WritableAtom } from 'jotai/vanilla';
+export declare function unwrap<Value, Args extends unknown[], Result>(anAtom: WritableAtom<Value, Args, Result>): WritableAtom<Awaited<Value> | undefined, Args, Result>;
+export declare function unwrap<Value, Args extends unknown[], Result, PendingValue>(anAtom: WritableAtom<Value, Args, Result>, fallback: (prev?: Awaited<Value>) => PendingValue): WritableAtom<Awaited<Value> | PendingValue, Args, Result>;
+export declare function unwrap<Value>(anAtom: Atom<Value>): Atom<Awaited<Value> | undefined>;
+export declare function unwrap<Value, PendingValue>(anAtom: Atom<Value>, fallback: (prev?: Awaited<Value>) => PendingValue): Atom<Awaited<Value> | PendingValue>;