{"version":3,"file":"jotai-BU2rLceN.js","sources":["../../node_modules/jotai/esm/vanilla.mjs","../../node_modules/jotai/esm/react.mjs","../../node_modules/jotai/esm/vanilla/utils.mjs","../../node_modules/jotai/esm/react/utils.mjs"],"sourcesContent":["let keyCount = 0;\nfunction atom(read, write) {\n  const key = `atom${++keyCount}`;\n  const config = {\n    toString: () => key\n  };\n  if (typeof read === \"function\") {\n    config.read = read;\n  } else {\n    config.init = read;\n    config.read = defaultRead;\n    config.write = defaultWrite;\n  }\n  if (write) {\n    config.write = write;\n  }\n  return config;\n}\nfunction defaultRead(get) {\n  return get(this);\n}\nfunction defaultWrite(get, set, arg) {\n  return set(\n    this,\n    typeof arg === \"function\" ? arg(get(this)) : arg\n  );\n}\n\nconst isSelfAtom = (atom, a) => atom.unstable_is ? atom.unstable_is(a) : a === atom;\nconst hasInitialValue = (atom) => \"init\" in atom;\nconst isActuallyWritableAtom = (atom) => !!atom.write;\nconst cancelPromiseMap = /* @__PURE__ */ new WeakMap();\nconst registerCancelPromise = (promise, cancel) => {\n  cancelPromiseMap.set(promise, cancel);\n  promise.catch(() => {\n  }).finally(() => cancelPromiseMap.delete(promise));\n};\nconst cancelPromise = (promise, next) => {\n  const cancel = cancelPromiseMap.get(promise);\n  if (cancel) {\n    cancelPromiseMap.delete(promise);\n    cancel(next);\n  }\n};\nconst resolvePromise = (promise, value) => {\n  promise.status = \"fulfilled\";\n  promise.value = value;\n};\nconst rejectPromise = (promise, e) => {\n  promise.status = \"rejected\";\n  promise.reason = e;\n};\nconst isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === \"function\";\nconst isEqualAtomValue = (a, b) => !!a && \"v\" in a && \"v\" in b && Object.is(a.v, b.v);\nconst isEqualAtomError = (a, b) => !!a && \"e\" in a && \"e\" in b && Object.is(a.e, b.e);\nconst hasPromiseAtomValue = (a) => !!a && \"v\" in a && a.v instanceof Promise;\nconst isEqualPromiseAtomValue = (a, b) => \"v\" in a && \"v\" in b && a.v.orig && a.v.orig === b.v.orig;\nconst returnAtomValue = (atomState) => {\n  if (\"e\" in atomState) {\n    throw atomState.e;\n  }\n  return atomState.v;\n};\nconst createStore$1 = () => {\n  const atomStateMap = /* @__PURE__ */ new WeakMap();\n  const mountedMap = /* @__PURE__ */ new WeakMap();\n  const pendingStack = [];\n  const pendingMap = /* @__PURE__ */ new WeakMap();\n  let devListenersRev2;\n  let mountedAtoms;\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    devListenersRev2 = /* @__PURE__ */ new Set();\n    mountedAtoms = /* @__PURE__ */ new Set();\n  }\n  const getAtomState = (atom) => atomStateMap.get(atom);\n  const addPendingDependent = (atom, atomState) => {\n    atomState.d.forEach((_, a) => {\n      if (!pendingMap.has(a)) {\n        const aState = getAtomState(a);\n        pendingMap.set(a, [aState, /* @__PURE__ */ new Set()]);\n        if (aState) {\n          addPendingDependent(a, aState);\n        }\n      }\n      pendingMap.get(a)[1].add(atom);\n    });\n  };\n  const setAtomState = (atom, atomState) => {\n    var _a;\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      Object.freeze(atomState);\n    }\n    const prevAtomState = getAtomState(atom);\n    atomStateMap.set(atom, atomState);\n    (_a = pendingStack[pendingStack.length - 1]) == null ? void 0 : _a.add(atom);\n    if (!pendingMap.has(atom)) {\n      pendingMap.set(atom, [prevAtomState, /* @__PURE__ */ new Set()]);\n      addPendingDependent(atom, atomState);\n    }\n    if (hasPromiseAtomValue(prevAtomState)) {\n      const next = \"v\" in atomState ? atomState.v instanceof Promise ? atomState.v : Promise.resolve(atomState.v) : Promise.reject(atomState.e);\n      if (prevAtomState.v !== next) {\n        cancelPromise(prevAtomState.v, next);\n      }\n    }\n  };\n  const updateDependencies = (atom, nextAtomState, nextDependencies, keepPreviousDependencies) => {\n    const dependencies = new Map(\n      keepPreviousDependencies ? nextAtomState.d : null\n    );\n    let changed = false;\n    nextDependencies.forEach((aState, a) => {\n      if (!aState && isSelfAtom(atom, a)) {\n        aState = nextAtomState;\n      }\n      if (aState) {\n        dependencies.set(a, aState);\n        if (nextAtomState.d.get(a) !== aState) {\n          changed = true;\n        }\n      } else if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n        console.warn(\"[Bug] atom state not found\");\n      }\n    });\n    if (changed || nextAtomState.d.size !== dependencies.size) {\n      nextAtomState.d = dependencies;\n    }\n  };\n  const setAtomValue = (atom, value, nextDependencies, keepPreviousDependencies) => {\n    const prevAtomState = getAtomState(atom);\n    const nextAtomState = {\n      d: (prevAtomState == null ? void 0 : prevAtomState.d) || /* @__PURE__ */ new Map(),\n      v: value\n    };\n    if (nextDependencies) {\n      updateDependencies(\n        atom,\n        nextAtomState,\n        nextDependencies,\n        keepPreviousDependencies\n      );\n    }\n    if (isEqualAtomValue(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {\n      return prevAtomState;\n    }\n    if (hasPromiseAtomValue(prevAtomState) && hasPromiseAtomValue(nextAtomState) && isEqualPromiseAtomValue(prevAtomState, nextAtomState)) {\n      if (prevAtomState.d === nextAtomState.d) {\n        return prevAtomState;\n      } else {\n        nextAtomState.v = prevAtomState.v;\n      }\n    }\n    setAtomState(atom, nextAtomState);\n    return nextAtomState;\n  };\n  const setAtomValueOrPromise = (atom, valueOrPromise, nextDependencies, abortPromise) => {\n    if (isPromiseLike(valueOrPromise)) {\n      let continuePromise;\n      const updatePromiseDependencies = () => {\n        const prevAtomState = getAtomState(atom);\n        if (!hasPromiseAtomValue(prevAtomState) || prevAtomState.v !== promise) {\n          return;\n        }\n        const nextAtomState = setAtomValue(\n          atom,\n          promise,\n          nextDependencies\n        );\n        if (mountedMap.has(atom) && prevAtomState.d !== nextAtomState.d) {\n          mountDependencies(atom, nextAtomState, prevAtomState.d);\n        }\n      };\n      const promise = new Promise((resolve, reject) => {\n        let settled = false;\n        valueOrPromise.then(\n          (v) => {\n            if (!settled) {\n              settled = true;\n              resolvePromise(promise, v);\n              resolve(v);\n              updatePromiseDependencies();\n            }\n          },\n          (e) => {\n            if (!settled) {\n              settled = true;\n              rejectPromise(promise, e);\n              reject(e);\n              updatePromiseDependencies();\n            }\n          }\n        );\n        continuePromise = (next) => {\n          if (!settled) {\n            settled = true;\n            next.then(\n              (v) => resolvePromise(promise, v),\n              (e) => rejectPromise(promise, e)\n            );\n            resolve(next);\n          }\n        };\n      });\n      promise.orig = valueOrPromise;\n      promise.status = \"pending\";\n      registerCancelPromise(promise, (next) => {\n        if (next) {\n          continuePromise(next);\n          abortPromise == null ? void 0 : abortPromise();\n        }\n      });\n      return setAtomValue(atom, promise, nextDependencies, true);\n    }\n    return setAtomValue(atom, valueOrPromise, nextDependencies);\n  };\n  const setAtomError = (atom, error, nextDependencies) => {\n    const prevAtomState = getAtomState(atom);\n    const nextAtomState = {\n      d: (prevAtomState == null ? void 0 : prevAtomState.d) || /* @__PURE__ */ new Map(),\n      e: error\n    };\n    if (nextDependencies) {\n      updateDependencies(atom, nextAtomState, nextDependencies);\n    }\n    if (isEqualAtomError(prevAtomState, nextAtomState) && prevAtomState.d === nextAtomState.d) {\n      return prevAtomState;\n    }\n    setAtomState(atom, nextAtomState);\n    return nextAtomState;\n  };\n  const readAtomState = (atom, force) => {\n    const atomState = getAtomState(atom);\n    if (!(force == null ? void 0 : force(atom)) && atomState) {\n      if (mountedMap.has(atom)) {\n        return atomState;\n      }\n      if (Array.from(atomState.d).every(([a, s]) => {\n        if (a === atom) {\n          return true;\n        }\n        const aState = readAtomState(a, force);\n        return aState === s || isEqualAtomValue(aState, s);\n      })) {\n        return atomState;\n      }\n    }\n    const nextDependencies = /* @__PURE__ */ new Map();\n    let isSync = true;\n    const getter = (a) => {\n      if (isSelfAtom(atom, a)) {\n        const aState2 = getAtomState(a);\n        if (aState2) {\n          nextDependencies.set(a, aState2);\n          return returnAtomValue(aState2);\n        }\n        if (hasInitialValue(a)) {\n          nextDependencies.set(a, void 0);\n          return a.init;\n        }\n        throw new Error(\"no atom init\");\n      }\n      const aState = readAtomState(a, force);\n      nextDependencies.set(a, aState);\n      return returnAtomValue(aState);\n    };\n    let controller;\n    let setSelf;\n    const options = {\n      get signal() {\n        if (!controller) {\n          controller = new AbortController();\n        }\n        return controller.signal;\n      },\n      get setSelf() {\n        if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" && !isActuallyWritableAtom(atom)) {\n          console.warn(\"setSelf function cannot be used with read-only atom\");\n        }\n        if (!setSelf && isActuallyWritableAtom(atom)) {\n          setSelf = (...args) => {\n            if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" && isSync) {\n              console.warn(\"setSelf function cannot be called in sync\");\n            }\n            if (!isSync) {\n              return writeAtom(atom, ...args);\n            }\n          };\n        }\n        return setSelf;\n      }\n    };\n    try {\n      const valueOrPromise = atom.read(getter, options);\n      return setAtomValueOrPromise(\n        atom,\n        valueOrPromise,\n        nextDependencies,\n        () => controller == null ? void 0 : controller.abort()\n      );\n    } catch (error) {\n      return setAtomError(atom, error, nextDependencies);\n    } finally {\n      isSync = false;\n    }\n  };\n  const readAtom = (atom) => returnAtomValue(readAtomState(atom));\n  const recomputeDependents = (atom) => {\n    const getDependents = (a) => {\n      var _a, _b;\n      const dependents = new Set((_a = mountedMap.get(a)) == null ? void 0 : _a.t);\n      (_b = pendingMap.get(a)) == null ? void 0 : _b[1].forEach((dependent) => {\n        dependents.add(dependent);\n      });\n      return dependents;\n    };\n    const topsortedAtoms = new Array();\n    const markedAtoms = /* @__PURE__ */ new Set();\n    const visit = (n) => {\n      if (markedAtoms.has(n)) {\n        return;\n      }\n      markedAtoms.add(n);\n      for (const m of getDependents(n)) {\n        if (n !== m) {\n          visit(m);\n        }\n      }\n      topsortedAtoms.push(n);\n    };\n    visit(atom);\n    const changedAtoms = /* @__PURE__ */ new Set([atom]);\n    const isMarked = (a) => markedAtoms.has(a);\n    for (let i = topsortedAtoms.length - 1; i >= 0; --i) {\n      const a = topsortedAtoms[i];\n      const prevAtomState = getAtomState(a);\n      if (!prevAtomState) {\n        continue;\n      }\n      let hasChangedDeps = false;\n      for (const dep of prevAtomState.d.keys()) {\n        if (dep !== a && changedAtoms.has(dep)) {\n          hasChangedDeps = true;\n          break;\n        }\n      }\n      if (hasChangedDeps) {\n        const nextAtomState = readAtomState(a, isMarked);\n        addPendingDependent(a, nextAtomState);\n        if (!isEqualAtomValue(prevAtomState, nextAtomState)) {\n          changedAtoms.add(a);\n        }\n      }\n      markedAtoms.delete(a);\n    }\n  };\n  const writeAtomState = (atom, ...args) => {\n    const getter = (a) => returnAtomValue(readAtomState(a));\n    const setter = (a, ...args2) => {\n      const isSync = pendingStack.length > 0;\n      if (!isSync) {\n        pendingStack.push(/* @__PURE__ */ new Set([a]));\n      }\n      let r;\n      if (isSelfAtom(atom, a)) {\n        if (!hasInitialValue(a)) {\n          throw new Error(\"atom not writable\");\n        }\n        const prevAtomState = getAtomState(a);\n        const nextAtomState = setAtomValueOrPromise(a, args2[0]);\n        if (!isEqualAtomValue(prevAtomState, nextAtomState)) {\n          recomputeDependents(a);\n        }\n      } else {\n        r = writeAtomState(a, ...args2);\n      }\n      if (!isSync) {\n        const flushed = flushPending(pendingStack.pop());\n        if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n          devListenersRev2.forEach(\n            (l) => l({ type: \"async-write\", flushed })\n          );\n        }\n      }\n      return r;\n    };\n    const result = atom.write(getter, setter, ...args);\n    return result;\n  };\n  const writeAtom = (atom, ...args) => {\n    pendingStack.push(/* @__PURE__ */ new Set([atom]));\n    const result = writeAtomState(atom, ...args);\n    const flushed = flushPending(pendingStack.pop());\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      devListenersRev2.forEach((l) => l({ type: \"write\", flushed }));\n    }\n    return result;\n  };\n  const mountAtom = (atom, initialDependent, onMountQueue) => {\n    var _a;\n    const existingMount = mountedMap.get(atom);\n    if (existingMount) {\n      if (initialDependent) {\n        existingMount.t.add(initialDependent);\n      }\n      return existingMount;\n    }\n    const queue = onMountQueue || [];\n    (_a = getAtomState(atom)) == null ? void 0 : _a.d.forEach((_, a) => {\n      if (a !== atom) {\n        mountAtom(a, atom, queue);\n      }\n    });\n    readAtomState(atom);\n    const mounted = {\n      t: new Set(initialDependent && [initialDependent]),\n      l: /* @__PURE__ */ new Set()\n    };\n    mountedMap.set(atom, mounted);\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      mountedAtoms.add(atom);\n    }\n    if (isActuallyWritableAtom(atom) && atom.onMount) {\n      const { onMount } = atom;\n      queue.push(() => {\n        const onUnmount = onMount((...args) => writeAtom(atom, ...args));\n        if (onUnmount) {\n          mounted.u = onUnmount;\n        }\n      });\n    }\n    if (!onMountQueue) {\n      queue.forEach((f) => f());\n    }\n    return mounted;\n  };\n  const canUnmountAtom = (atom, mounted) => !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom));\n  const tryUnmountAtom = (atom, mounted) => {\n    if (!canUnmountAtom(atom, mounted)) {\n      return;\n    }\n    const onUnmount = mounted.u;\n    if (onUnmount) {\n      onUnmount();\n    }\n    mountedMap.delete(atom);\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      mountedAtoms.delete(atom);\n    }\n    const atomState = getAtomState(atom);\n    if (atomState) {\n      if (hasPromiseAtomValue(atomState)) {\n        cancelPromise(atomState.v);\n      }\n      atomState.d.forEach((_, a) => {\n        if (a !== atom) {\n          const mountedDep = mountedMap.get(a);\n          if (mountedDep) {\n            mountedDep.t.delete(atom);\n            tryUnmountAtom(a, mountedDep);\n          }\n        }\n      });\n    } else if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      console.warn(\"[Bug] could not find atom state to unmount\", atom);\n    }\n  };\n  const mountDependencies = (atom, atomState, prevDependencies) => {\n    const depSet = new Set(atomState.d.keys());\n    const maybeUnmountAtomSet = /* @__PURE__ */ new Set();\n    prevDependencies == null ? void 0 : prevDependencies.forEach((_, a) => {\n      if (depSet.has(a)) {\n        depSet.delete(a);\n        return;\n      }\n      maybeUnmountAtomSet.add(a);\n      const mounted = mountedMap.get(a);\n      if (mounted) {\n        mounted.t.delete(atom);\n      }\n    });\n    depSet.forEach((a) => {\n      mountAtom(a, atom);\n    });\n    maybeUnmountAtomSet.forEach((a) => {\n      const mounted = mountedMap.get(a);\n      if (mounted) {\n        tryUnmountAtom(a, mounted);\n      }\n    });\n  };\n  const flushPending = (pendingAtoms) => {\n    let flushed;\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      flushed = /* @__PURE__ */ new Set();\n    }\n    const pending = [];\n    const collectPending = (pendingAtom) => {\n      var _a;\n      if (!pendingMap.has(pendingAtom)) {\n        return;\n      }\n      const [prevAtomState, dependents] = pendingMap.get(pendingAtom);\n      pendingMap.delete(pendingAtom);\n      pending.push([pendingAtom, prevAtomState]);\n      dependents.forEach(collectPending);\n      (_a = getAtomState(pendingAtom)) == null ? void 0 : _a.d.forEach((_, a) => collectPending(a));\n    };\n    pendingAtoms.forEach(collectPending);\n    pending.forEach(([atom, prevAtomState]) => {\n      const atomState = getAtomState(atom);\n      if (!atomState) {\n        if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n          console.warn(\"[Bug] no atom state to flush\");\n        }\n        return;\n      }\n      if (atomState !== prevAtomState) {\n        const mounted = mountedMap.get(atom);\n        if (mounted && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {\n          mountDependencies(atom, atomState, prevAtomState == null ? void 0 : prevAtomState.d);\n        }\n        if (mounted && !// TODO This seems pretty hacky. Hope to fix it.\n        // Maybe we could `mountDependencies` in `setAtomState`?\n        (!hasPromiseAtomValue(prevAtomState) && (isEqualAtomValue(prevAtomState, atomState) || isEqualAtomError(prevAtomState, atomState)))) {\n          mounted.l.forEach((listener) => listener());\n          if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n            flushed.add(atom);\n          }\n        }\n      }\n    });\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      return flushed;\n    }\n  };\n  const subscribeAtom = (atom, listener) => {\n    const mounted = mountAtom(atom);\n    const flushed = flushPending([atom]);\n    const listeners = mounted.l;\n    listeners.add(listener);\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      devListenersRev2.forEach(\n        (l) => l({ type: \"sub\", flushed })\n      );\n    }\n    return () => {\n      listeners.delete(listener);\n      tryUnmountAtom(atom, mounted);\n      if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n        devListenersRev2.forEach((l) => l({ type: \"unsub\" }));\n      }\n    };\n  };\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    return {\n      get: readAtom,\n      set: writeAtom,\n      sub: subscribeAtom,\n      // store dev methods (these are tentative and subject to change without notice)\n      dev_subscribe_store: (l) => {\n        devListenersRev2.add(l);\n        return () => {\n          devListenersRev2.delete(l);\n        };\n      },\n      dev_get_mounted_atoms: () => mountedAtoms.values(),\n      dev_get_atom_state: (a) => atomStateMap.get(a),\n      dev_get_mounted: (a) => mountedMap.get(a),\n      dev_restore_atoms: (values) => {\n        pendingStack.push(/* @__PURE__ */ new Set());\n        for (const [atom, valueOrPromise] of values) {\n          if (hasInitialValue(atom)) {\n            setAtomValueOrPromise(atom, valueOrPromise);\n            recomputeDependents(atom);\n          }\n        }\n        const flushed = flushPending(pendingStack.pop());\n        devListenersRev2.forEach(\n          (l) => l({ type: \"restore\", flushed })\n        );\n      }\n    };\n  }\n  return {\n    get: readAtom,\n    set: writeAtom,\n    sub: subscribeAtom\n  };\n};\nlet defaultStore;\nconst getDefaultStore$1 = () => {\n  if (!defaultStore) {\n    defaultStore = createStore$1();\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      globalThis.__JOTAI_DEFAULT_STORE__ || (globalThis.__JOTAI_DEFAULT_STORE__ = defaultStore);\n      if (globalThis.__JOTAI_DEFAULT_STORE__ !== defaultStore) {\n        console.warn(\n          \"Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044\"\n        );\n      }\n    }\n  }\n  return defaultStore;\n};\n\nSymbol(\n  (import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" ? \"CONTINUE_PROMISE\" : \"\"\n);\n\nconst createStore = createStore$1;\nconst getDefaultStore = getDefaultStore$1;\n\nexport { atom, createStore, getDefaultStore };\n","'use client';\nimport ReactExports, { createContext, useContext, useRef, createElement, useReducer, useEffect, useDebugValue, useCallback } from 'react';\nimport { getDefaultStore, createStore } from 'jotai/vanilla';\n\nconst StoreContext = createContext(\n  void 0\n);\nconst useStore = (options) => {\n  const store = useContext(StoreContext);\n  return (options == null ? void 0 : options.store) || store || getDefaultStore();\n};\nconst Provider = ({\n  children,\n  store\n}) => {\n  const storeRef = useRef();\n  if (!store && !storeRef.current) {\n    storeRef.current = createStore();\n  }\n  return createElement(\n    StoreContext.Provider,\n    {\n      value: store || storeRef.current\n    },\n    children\n  );\n};\n\nconst isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === \"function\";\nconst use = ReactExports.use || ((promise) => {\n  if (promise.status === \"pending\") {\n    throw promise;\n  } else if (promise.status === \"fulfilled\") {\n    return promise.value;\n  } else if (promise.status === \"rejected\") {\n    throw promise.reason;\n  } else {\n    promise.status = \"pending\";\n    promise.then(\n      (v) => {\n        promise.status = \"fulfilled\";\n        promise.value = v;\n      },\n      (e) => {\n        promise.status = \"rejected\";\n        promise.reason = e;\n      }\n    );\n    throw promise;\n  }\n});\nfunction useAtomValue(atom, options) {\n  const store = useStore(options);\n  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer(\n    (prev) => {\n      const nextValue = store.get(atom);\n      if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {\n        return prev;\n      }\n      return [nextValue, store, atom];\n    },\n    void 0,\n    () => [store.get(atom), store, atom]\n  );\n  let value = valueFromReducer;\n  if (storeFromReducer !== store || atomFromReducer !== atom) {\n    rerender();\n    value = store.get(atom);\n  }\n  const delay = options == null ? void 0 : options.delay;\n  useEffect(() => {\n    const unsub = store.sub(atom, () => {\n      if (typeof delay === \"number\") {\n        setTimeout(rerender, delay);\n        return;\n      }\n      rerender();\n    });\n    rerender();\n    return unsub;\n  }, [store, atom, delay]);\n  useDebugValue(value);\n  return isPromiseLike(value) ? use(value) : value;\n}\n\nfunction useSetAtom(atom, options) {\n  const store = useStore(options);\n  const setAtom = useCallback(\n    (...args) => {\n      if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" && !(\"write\" in atom)) {\n        throw new Error(\"not writable atom\");\n      }\n      return store.set(atom, ...args);\n    },\n    [store, atom]\n  );\n  return setAtom;\n}\n\nfunction useAtom(atom, options) {\n  return [\n    useAtomValue(atom, options),\n    // We do wrong type assertion here, which results in throwing an error.\n    useSetAtom(atom, options)\n  ];\n}\n\nexport { Provider, useAtom, useAtomValue, useSetAtom, useStore };\n","import { atom } from 'jotai/vanilla';\n\nconst RESET = Symbol(\n  (import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" ? \"RESET\" : \"\"\n);\n\nfunction atomWithReset(initialValue) {\n  const anAtom = atom(\n    initialValue,\n    (get, set, update) => {\n      const nextValue = typeof update === \"function\" ? update(get(anAtom)) : update;\n      set(anAtom, nextValue === RESET ? initialValue : nextValue);\n    }\n  );\n  return anAtom;\n}\n\nfunction atomWithReducer(initialValue, reducer) {\n  return atom(initialValue, function(get, set, action) {\n    set(this, reducer(get(this), action));\n  });\n}\n\nfunction atomFamily(initializeAtom, areEqual) {\n  let shouldRemove = null;\n  const atoms = /* @__PURE__ */ new Map();\n  const createAtom = (param) => {\n    let item;\n    if (areEqual === void 0) {\n      item = atoms.get(param);\n    } else {\n      for (const [key, value] of atoms) {\n        if (areEqual(key, param)) {\n          item = value;\n          break;\n        }\n      }\n    }\n    if (item !== void 0) {\n      if (shouldRemove == null ? void 0 : shouldRemove(item[1], param)) {\n        createAtom.remove(param);\n      } else {\n        return item[0];\n      }\n    }\n    const newAtom = initializeAtom(param);\n    atoms.set(param, [newAtom, Date.now()]);\n    return newAtom;\n  };\n  createAtom.remove = (param) => {\n    if (areEqual === void 0) {\n      atoms.delete(param);\n    } else {\n      for (const [key] of atoms) {\n        if (areEqual(key, param)) {\n          atoms.delete(key);\n          break;\n        }\n      }\n    }\n  };\n  createAtom.setShouldRemove = (fn) => {\n    shouldRemove = fn;\n    if (!shouldRemove) return;\n    for (const [key, value] of atoms) {\n      if (shouldRemove(value[1], key)) {\n        atoms.delete(key);\n      }\n    }\n  };\n  return createAtom;\n}\n\nconst getCached$2 = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);\nconst cache1$3 = /* @__PURE__ */ new WeakMap();\nconst memo3 = (create, dep1, dep2, dep3) => {\n  const cache2 = getCached$2(() => /* @__PURE__ */ new WeakMap(), cache1$3, dep1);\n  const cache3 = getCached$2(() => /* @__PURE__ */ new WeakMap(), cache2, dep2);\n  return getCached$2(create, cache3, dep3);\n};\nfunction selectAtom(anAtom, selector, equalityFn = Object.is) {\n  return memo3(\n    () => {\n      const EMPTY = Symbol();\n      const selectValue = ([value, prevSlice]) => {\n        if (prevSlice === EMPTY) {\n          return selector(value);\n        }\n        const slice = selector(value, prevSlice);\n        return equalityFn(prevSlice, slice) ? prevSlice : slice;\n      };\n      const derivedAtom = atom((get) => {\n        const prev = get(derivedAtom);\n        const value = get(anAtom);\n        return selectValue([value, prev]);\n      });\n      derivedAtom.init = EMPTY;\n      return derivedAtom;\n    },\n    anAtom,\n    selector,\n    equalityFn\n  );\n}\n\nconst frozenAtoms = /* @__PURE__ */ new WeakSet();\nconst deepFreeze = (obj) => {\n  if (typeof obj !== \"object\" || obj === null) return;\n  Object.freeze(obj);\n  const propNames = Object.getOwnPropertyNames(obj);\n  for (const name of propNames) {\n    const value = obj[name];\n    deepFreeze(value);\n  }\n  return obj;\n};\nfunction freezeAtom(anAtom) {\n  if (frozenAtoms.has(anAtom)) {\n    return anAtom;\n  }\n  frozenAtoms.add(anAtom);\n  const origRead = anAtom.read;\n  anAtom.read = function(get, options) {\n    return deepFreeze(origRead.call(this, get, options));\n  };\n  if (\"write\" in anAtom) {\n    const origWrite = anAtom.write;\n    anAtom.write = function(get, set, ...args) {\n      return origWrite.call(\n        this,\n        get,\n        (...setArgs) => {\n          if (setArgs[0] === anAtom) {\n            setArgs[1] = deepFreeze(setArgs[1]);\n          }\n          return set(...setArgs);\n        },\n        ...args\n      );\n    };\n  }\n  return anAtom;\n}\nfunction freezeAtomCreator(createAtom) {\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    console.warn(\n      \"[DEPRECATED] freezeAtomCreator is deprecated, define it on users end\"\n    );\n  }\n  return (...args) => freezeAtom(createAtom(...args));\n}\n\nconst getCached$1 = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);\nconst cache1$2 = /* @__PURE__ */ new WeakMap();\nconst memo2$1 = (create, dep1, dep2) => {\n  const cache2 = getCached$1(() => /* @__PURE__ */ new WeakMap(), cache1$2, dep1);\n  return getCached$1(create, cache2, dep2);\n};\nconst cacheKeyForEmptyKeyExtractor = {};\nconst isWritable = (atom2) => !!atom2.write;\nconst isFunction = (x) => typeof x === \"function\";\nfunction splitAtom(arrAtom, keyExtractor) {\n  return memo2$1(\n    () => {\n      const mappingCache = /* @__PURE__ */ new WeakMap();\n      const getMapping = (arr, prev) => {\n        let mapping = mappingCache.get(arr);\n        if (mapping) {\n          return mapping;\n        }\n        const prevMapping = prev && mappingCache.get(prev);\n        const atomList = [];\n        const keyList = [];\n        arr.forEach((item, index) => {\n          const key = keyExtractor ? keyExtractor(item) : index;\n          keyList[index] = key;\n          const cachedAtom = prevMapping && prevMapping.atomList[prevMapping.keyList.indexOf(key)];\n          if (cachedAtom) {\n            atomList[index] = cachedAtom;\n            return;\n          }\n          const read = (get) => {\n            const prev2 = get(mappingAtom);\n            const currArr = get(arrAtom);\n            const mapping2 = getMapping(currArr, prev2 == null ? void 0 : prev2.arr);\n            const index2 = mapping2.keyList.indexOf(key);\n            if (index2 < 0 || index2 >= currArr.length) {\n              const prevItem = arr[getMapping(arr).keyList.indexOf(key)];\n              if (prevItem) {\n                return prevItem;\n              }\n              throw new Error(\"splitAtom: index out of bounds for read\");\n            }\n            return currArr[index2];\n          };\n          const write = (get, set, update) => {\n            const prev2 = get(mappingAtom);\n            const arr2 = get(arrAtom);\n            const mapping2 = getMapping(arr2, prev2 == null ? void 0 : prev2.arr);\n            const index2 = mapping2.keyList.indexOf(key);\n            if (index2 < 0 || index2 >= arr2.length) {\n              throw new Error(\"splitAtom: index out of bounds for write\");\n            }\n            const nextItem = isFunction(update) ? update(arr2[index2]) : update;\n            if (!Object.is(arr2[index2], nextItem)) {\n              set(arrAtom, [\n                ...arr2.slice(0, index2),\n                nextItem,\n                ...arr2.slice(index2 + 1)\n              ]);\n            }\n          };\n          atomList[index] = isWritable(arrAtom) ? atom(read, write) : atom(read);\n        });\n        if (prevMapping && prevMapping.keyList.length === keyList.length && prevMapping.keyList.every((x, i) => x === keyList[i])) {\n          mapping = prevMapping;\n        } else {\n          mapping = { arr, atomList, keyList };\n        }\n        mappingCache.set(arr, mapping);\n        return mapping;\n      };\n      const mappingAtom = atom((get) => {\n        const prev = get(mappingAtom);\n        const arr = get(arrAtom);\n        const mapping = getMapping(arr, prev == null ? void 0 : prev.arr);\n        return mapping;\n      });\n      if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n        mappingAtom.debugPrivate = true;\n      }\n      mappingAtom.init = void 0;\n      const splittedAtom = isWritable(arrAtom) ? atom(\n        (get) => get(mappingAtom).atomList,\n        (get, set, action) => {\n          switch (action.type) {\n            case \"remove\": {\n              const index = get(splittedAtom).indexOf(action.atom);\n              if (index >= 0) {\n                const arr = get(arrAtom);\n                set(arrAtom, [\n                  ...arr.slice(0, index),\n                  ...arr.slice(index + 1)\n                ]);\n              }\n              break;\n            }\n            case \"insert\": {\n              const index = action.before ? get(splittedAtom).indexOf(action.before) : get(splittedAtom).length;\n              if (index >= 0) {\n                const arr = get(arrAtom);\n                set(arrAtom, [\n                  ...arr.slice(0, index),\n                  action.value,\n                  ...arr.slice(index)\n                ]);\n              }\n              break;\n            }\n            case \"move\": {\n              const index1 = get(splittedAtom).indexOf(action.atom);\n              const index2 = action.before ? get(splittedAtom).indexOf(action.before) : get(splittedAtom).length;\n              if (index1 >= 0 && index2 >= 0) {\n                const arr = get(arrAtom);\n                if (index1 < index2) {\n                  set(arrAtom, [\n                    ...arr.slice(0, index1),\n                    ...arr.slice(index1 + 1, index2),\n                    arr[index1],\n                    ...arr.slice(index2)\n                  ]);\n                } else {\n                  set(arrAtom, [\n                    ...arr.slice(0, index2),\n                    arr[index1],\n                    ...arr.slice(index2, index1),\n                    ...arr.slice(index1 + 1)\n                  ]);\n                }\n              }\n              break;\n            }\n          }\n        }\n      ) : atom((get) => get(mappingAtom).atomList);\n      return splittedAtom;\n    },\n    arrAtom,\n    keyExtractor || cacheKeyForEmptyKeyExtractor\n  );\n}\n\nfunction atomWithDefault(getDefault) {\n  const EMPTY = Symbol();\n  const overwrittenAtom = atom(EMPTY);\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    overwrittenAtom.debugPrivate = true;\n  }\n  const anAtom = atom(\n    (get, options) => {\n      const overwritten = get(overwrittenAtom);\n      if (overwritten !== EMPTY) {\n        return overwritten;\n      }\n      return getDefault(get, options);\n    },\n    (get, set, update) => {\n      if (update === RESET) {\n        set(overwrittenAtom, EMPTY);\n      } else if (typeof update === \"function\") {\n        const prevValue = get(anAtom);\n        set(overwrittenAtom, update(prevValue));\n      } else {\n        set(overwrittenAtom, update);\n      }\n    }\n  );\n  return anAtom;\n}\n\nconst isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === \"function\";\nfunction withStorageValidator(validator) {\n  return (unknownStorage) => {\n    const storage = {\n      ...unknownStorage,\n      getItem: (key, initialValue) => {\n        const validate = (value2) => {\n          if (!validator(value2)) {\n            return initialValue;\n          }\n          return value2;\n        };\n        const value = unknownStorage.getItem(key, initialValue);\n        if (isPromiseLike(value)) {\n          return value.then(validate);\n        }\n        return validate(value);\n      }\n    };\n    return storage;\n  };\n}\nfunction createJSONStorage(getStringStorage = () => {\n  try {\n    return window.localStorage;\n  } catch (e) {\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      if (typeof window !== \"undefined\") {\n        console.warn(e);\n      }\n    }\n    return void 0;\n  }\n}, options) {\n  var _a;\n  let lastStr;\n  let lastValue;\n  const storage = {\n    getItem: (key, initialValue) => {\n      var _a2, _b;\n      const parse = (str2) => {\n        str2 = str2 || \"\";\n        if (lastStr !== str2) {\n          try {\n            lastValue = JSON.parse(str2, options == null ? void 0 : options.reviver);\n          } catch (e) {\n            return initialValue;\n          }\n          lastStr = str2;\n        }\n        return lastValue;\n      };\n      const str = (_b = (_a2 = getStringStorage()) == null ? void 0 : _a2.getItem(key)) != null ? _b : null;\n      if (isPromiseLike(str)) {\n        return str.then(parse);\n      }\n      return parse(str);\n    },\n    setItem: (key, newValue) => {\n      var _a2;\n      return (_a2 = getStringStorage()) == null ? void 0 : _a2.setItem(\n        key,\n        JSON.stringify(newValue, options == null ? void 0 : options.replacer)\n      );\n    },\n    removeItem: (key) => {\n      var _a2;\n      return (_a2 = getStringStorage()) == null ? void 0 : _a2.removeItem(key);\n    }\n  };\n  const createHandleSubscribe = (subscriber2) => (key, callback, initialValue) => subscriber2(key, (v) => {\n    let newValue;\n    try {\n      newValue = JSON.parse(v || \"\");\n    } catch (e) {\n      newValue = initialValue;\n    }\n    callback(newValue);\n  });\n  let subscriber;\n  try {\n    subscriber = (_a = getStringStorage()) == null ? void 0 : _a.subscribe;\n  } catch (e) {\n  }\n  if (!subscriber && typeof window !== \"undefined\" && typeof window.addEventListener === \"function\" && window.Storage) {\n    subscriber = (key, callback) => {\n      if (!(getStringStorage() instanceof window.Storage)) {\n        return () => {\n        };\n      }\n      const storageEventCallback = (e) => {\n        if (e.storageArea === getStringStorage() && e.key === key) {\n          callback(e.newValue);\n        }\n      };\n      window.addEventListener(\"storage\", storageEventCallback);\n      return () => {\n        window.removeEventListener(\"storage\", storageEventCallback);\n      };\n    };\n  }\n  if (subscriber) {\n    storage.subscribe = createHandleSubscribe(subscriber);\n  }\n  return storage;\n}\nconst defaultStorage = createJSONStorage();\nfunction atomWithStorage(key, initialValue, storage = defaultStorage, options) {\n  const getOnInit = options == null ? void 0 : options.getOnInit;\n  const baseAtom = atom(\n    getOnInit ? storage.getItem(key, initialValue) : initialValue\n  );\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    baseAtom.debugPrivate = true;\n  }\n  baseAtom.onMount = (setAtom) => {\n    setAtom(storage.getItem(key, initialValue));\n    let unsub;\n    if (storage.subscribe) {\n      unsub = storage.subscribe(key, setAtom, initialValue);\n    }\n    return unsub;\n  };\n  const anAtom = atom(\n    (get) => get(baseAtom),\n    (get, set, update) => {\n      const nextValue = typeof update === \"function\" ? update(get(baseAtom)) : update;\n      if (nextValue === RESET) {\n        set(baseAtom, initialValue);\n        return storage.removeItem(key);\n      }\n      if (nextValue instanceof Promise) {\n        return nextValue.then((resolvedValue) => {\n          set(baseAtom, resolvedValue);\n          return storage.setItem(key, resolvedValue);\n        });\n      }\n      set(baseAtom, nextValue);\n      return storage.setItem(key, nextValue);\n    }\n  );\n  return anAtom;\n}\n\nfunction atomWithObservable(getObservable, options) {\n  const returnResultData = (result) => {\n    if (\"e\" in result) {\n      throw result.e;\n    }\n    return result.d;\n  };\n  const observableResultAtom = atom((get) => {\n    var _a;\n    let observable = getObservable(get);\n    const itself = (_a = observable[Symbol.observable]) == null ? void 0 : _a.call(observable);\n    if (itself) {\n      observable = itself;\n    }\n    let resolve;\n    const makePending = () => new Promise((r) => {\n      resolve = r;\n    });\n    const initialResult = options && \"initialValue\" in options ? {\n      d: typeof options.initialValue === \"function\" ? options.initialValue() : options.initialValue\n    } : makePending();\n    let setResult;\n    let lastResult;\n    const listener = (result) => {\n      lastResult = result;\n      resolve == null ? void 0 : resolve(result);\n      setResult == null ? void 0 : setResult(result);\n    };\n    let subscription;\n    let timer;\n    const isNotMounted = () => !setResult;\n    const start = () => {\n      if (subscription) {\n        clearTimeout(timer);\n        subscription.unsubscribe();\n      }\n      subscription = observable.subscribe({\n        next: (d) => listener({ d }),\n        error: (e) => listener({ e }),\n        complete: () => {\n        }\n      });\n      if (isNotMounted() && (options == null ? void 0 : options.unstable_timeout)) {\n        timer = setTimeout(() => {\n          if (subscription) {\n            subscription.unsubscribe();\n            subscription = void 0;\n          }\n        }, options.unstable_timeout);\n      }\n    };\n    start();\n    const resultAtom = atom(lastResult || initialResult);\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      resultAtom.debugPrivate = true;\n    }\n    resultAtom.onMount = (update) => {\n      setResult = update;\n      if (lastResult) {\n        update(lastResult);\n      }\n      if (subscription) {\n        clearTimeout(timer);\n      } else {\n        start();\n      }\n      return () => {\n        setResult = void 0;\n        if (subscription) {\n          subscription.unsubscribe();\n          subscription = void 0;\n        }\n      };\n    };\n    return [resultAtom, observable, makePending, start, isNotMounted];\n  });\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    observableResultAtom.debugPrivate = true;\n  }\n  const observableAtom = atom(\n    (get) => {\n      const [resultAtom] = get(observableResultAtom);\n      const result = get(resultAtom);\n      if (result instanceof Promise) {\n        return result.then(returnResultData);\n      }\n      return returnResultData(result);\n    },\n    (get, set, data) => {\n      const [resultAtom, observable, makePending, start, isNotMounted] = get(observableResultAtom);\n      if (\"next\" in observable) {\n        if (isNotMounted()) {\n          set(resultAtom, makePending());\n          start();\n        }\n        observable.next(data);\n      } else {\n        throw new Error(\"observable is not subject\");\n      }\n    }\n  );\n  return observableAtom;\n}\n\nconst cache1$1 = /* @__PURE__ */ new WeakMap();\nconst memo1 = (create, dep1) => (cache1$1.has(dep1) ? cache1$1 : cache1$1.set(dep1, create())).get(dep1);\nconst isPromise$1 = (x) => x instanceof Promise;\nconst LOADING = { state: \"loading\" };\nfunction loadable(anAtom) {\n  return memo1(() => {\n    const loadableCache = /* @__PURE__ */ new WeakMap();\n    const refreshAtom = atom(0);\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      refreshAtom.debugPrivate = true;\n    }\n    const derivedAtom = atom(\n      (get, { setSelf }) => {\n        get(refreshAtom);\n        let value;\n        try {\n          value = get(anAtom);\n        } catch (error) {\n          return { state: \"hasError\", error };\n        }\n        if (!isPromise$1(value)) {\n          return { state: \"hasData\", data: value };\n        }\n        const promise = value;\n        const cached1 = loadableCache.get(promise);\n        if (cached1) {\n          return cached1;\n        }\n        if (promise.status === \"fulfilled\") {\n          loadableCache.set(promise, { state: \"hasData\", data: promise.value });\n        } else if (promise.status === \"rejected\") {\n          loadableCache.set(promise, {\n            state: \"hasError\",\n            error: promise.reason\n          });\n        } else {\n          promise.then(\n            (data) => {\n              loadableCache.set(promise, { state: \"hasData\", data });\n            },\n            (error) => {\n              loadableCache.set(promise, { state: \"hasError\", error });\n            }\n          ).finally(setSelf);\n        }\n        const cached2 = loadableCache.get(promise);\n        if (cached2) {\n          return cached2;\n        }\n        loadableCache.set(promise, LOADING);\n        return LOADING;\n      },\n      (_get, set) => {\n        set(refreshAtom, (c) => c + 1);\n      }\n    );\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n      derivedAtom.debugPrivate = true;\n    }\n    return atom((get) => get(derivedAtom));\n  }, anAtom);\n}\n\nconst getCached = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);\nconst cache1 = /* @__PURE__ */ new WeakMap();\nconst memo2 = (create, dep1, dep2) => {\n  const cache2 = getCached(() => /* @__PURE__ */ new WeakMap(), cache1, dep1);\n  return getCached(create, cache2, dep2);\n};\nconst isPromise = (x) => x instanceof Promise;\nconst defaultFallback = () => void 0;\nfunction unwrap(anAtom, fallback = defaultFallback) {\n  return memo2(\n    () => {\n      const promiseErrorCache = /* @__PURE__ */ new WeakMap();\n      const promiseResultCache = /* @__PURE__ */ new WeakMap();\n      const refreshAtom = atom(0);\n      if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n        refreshAtom.debugPrivate = true;\n      }\n      const promiseAndValueAtom = atom(\n        (get, { setSelf }) => {\n          get(refreshAtom);\n          const prev = get(promiseAndValueAtom);\n          const promise = get(anAtom);\n          if (!isPromise(promise)) {\n            return { v: promise };\n          }\n          if (promise !== (prev == null ? void 0 : prev.p)) {\n            if (promise.status === \"fulfilled\") {\n              promiseResultCache.set(promise, promise.value);\n            } else if (promise.status === \"rejected\") {\n              promiseErrorCache.set(promise, promise.reason);\n            } else {\n              promise.then(\n                (v) => promiseResultCache.set(promise, v),\n                (e) => promiseErrorCache.set(promise, e)\n              ).finally(setSelf);\n            }\n          }\n          if (promiseErrorCache.has(promise)) {\n            throw promiseErrorCache.get(promise);\n          }\n          if (promiseResultCache.has(promise)) {\n            return {\n              p: promise,\n              v: promiseResultCache.get(promise)\n            };\n          }\n          if (prev && \"v\" in prev) {\n            return { p: promise, f: fallback(prev.v), v: prev.v };\n          }\n          return { p: promise, f: fallback() };\n        },\n        (_get, set) => {\n          set(refreshAtom, (c) => c + 1);\n        }\n      );\n      promiseAndValueAtom.init = void 0;\n      if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n        promiseAndValueAtom.debugPrivate = true;\n      }\n      return atom(\n        (get) => {\n          const state = get(promiseAndValueAtom);\n          if (\"f\" in state) {\n            return state.f;\n          }\n          return state.v;\n        },\n        (_get, set, ...args) => set(anAtom, ...args)\n      );\n    },\n    anAtom,\n    fallback\n  );\n}\n\nfunction atomWithRefresh(read, write) {\n  const refreshAtom = atom(0);\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    refreshAtom.debugPrivate = true;\n  }\n  return atom(\n    (get, options) => {\n      get(refreshAtom);\n      return read(get, options);\n    },\n    (get, set, ...args) => {\n      if (args.length === 0) {\n        set(refreshAtom, (c) => c + 1);\n      } else if (write) {\n        return write(get, set, ...args);\n      }\n    }\n  );\n}\n\nfunction atomWithLazy(makeInitial) {\n  const a = atom(void 0);\n  delete a.init;\n  Object.defineProperty(a, \"init\", {\n    get() {\n      return makeInitial();\n    }\n  });\n  return a;\n}\n\nexport { RESET, atomFamily, atomWithDefault, atomWithLazy, atomWithObservable, atomWithReducer, atomWithRefresh, atomWithReset, atomWithStorage, createJSONStorage, freezeAtom, freezeAtomCreator, loadable, selectAtom, splitAtom, withStorageValidator as unstable_withStorageValidator, unwrap };\n","'use client';\nimport { useCallback, useMemo } from 'react';\nimport { useSetAtom, useAtom, useStore } from 'jotai/react';\nimport { RESET } from 'jotai/vanilla/utils';\nimport { atom } from 'jotai/vanilla';\n\nfunction useResetAtom(anAtom, options) {\n  const setAtom = useSetAtom(anAtom, options);\n  const resetAtom = useCallback(() => setAtom(RESET), [setAtom]);\n  return resetAtom;\n}\n\nfunction useReducerAtom(anAtom, reducer, options) {\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    console.warn(\n      \"[DEPRECATED] useReducerAtom is deprecated and will be removed in the future. Please create your own version using the recipe. https://github.com/pmndrs/jotai/pull/2467\"\n    );\n  }\n  const [state, setState] = useAtom(anAtom, options);\n  const dispatch = useCallback(\n    (action) => {\n      setState((prev) => reducer(prev, action));\n    },\n    [setState, reducer]\n  );\n  return [state, dispatch];\n}\n\nfunction useAtomCallback(callback, options) {\n  const anAtom = useMemo(\n    () => atom(null, (get, set, ...args) => callback(get, set, ...args)),\n    [callback]\n  );\n  return useSetAtom(anAtom, options);\n}\n\nconst hydratedMap = /* @__PURE__ */ new WeakMap();\nfunction useHydrateAtoms(values, options) {\n  const store = useStore(options);\n  const hydratedSet = getHydratedSet(store);\n  for (const [atom, value] of values) {\n    if (!hydratedSet.has(atom) || (options == null ? void 0 : options.dangerouslyForceHydrate)) {\n      hydratedSet.add(atom);\n      store.set(atom, value);\n    }\n  }\n}\nconst getHydratedSet = (store) => {\n  let hydratedSet = hydratedMap.get(store);\n  if (!hydratedSet) {\n    hydratedSet = /* @__PURE__ */ new WeakSet();\n    hydratedMap.set(store, hydratedSet);\n  }\n  return hydratedSet;\n};\n\nexport { useAtomCallback, useHydrateAtoms, useReducerAtom, useResetAtom };\n"],"names":["keyCount","atom","read","write","key","config","toString","init","defaultRead","defaultWrite","get","this","set","arg","isSelfAtom","a","unstable_is","hasInitialValue","isActuallyWritableAtom","cancelPromiseMap","WeakMap","cancelPromise","promise","next","cancel","delete","resolvePromise","value","status","rejectPromise","e","reason","isEqualAtomValue","b","Object","is","v","isEqualAtomError","hasPromiseAtomValue","Promise","returnAtomValue","atomState","createStore$1","atomStateMap","mountedMap","pendingStack","pendingMap","devListenersRev2","mountedAtoms","define_import_meta_env_default","Set","getAtomState","addPendingDependent","d","forEach","_","has","aState","add","setAtomState","_a","freeze","prevAtomState","length","resolve","reject","updateDependencies","nextAtomState","nextDependencies","keepPreviousDependencies","dependencies","Map","changed","console","warn","size","setAtomValue","orig","setAtomValueOrPromise","valueOrPromise","abortPromise","isPromiseLike","x","then","continuePromise","updatePromiseDependencies","settled","catch","finally","registerCancelPromise","readAtomState","force","Array","from","every","s","isSync","getter","aState2","Error","controller","setSelf","options","signal","AbortController","args","writeAtom","abort","error","setAtomError","readAtom","recomputeDependents","topsortedAtoms","markedAtoms","visit","n","m","_b","dependents","t","dependent","getDependents","push","changedAtoms","isMarked","i","hasChangedDeps","dep","keys","writeAtomState","args2","r","flushed","flushPending","pop","l","type","result","mountAtom","initialDependent","onMountQueue","existingMount","queue","mounted","onMount","onUnmount","u","f","tryUnmountAtom","canUnmountAtom","mountedDep","mountDependencies","prevDependencies","depSet","maybeUnmountAtomSet","pendingAtoms","pending","collectPending","pendingAtom","listener","subscribeAtom","listeners","sub","dev_subscribe_store","dev_get_mounted_atoms","values","dev_get_atom_state","dev_get_mounted","dev_restore_atoms","defaultStore","createStore","getDefaultStore","globalThis","__JOTAI_DEFAULT_STORE__","StoreContext","createContext","useStore","store","useContext","use","ReactExports","useAtomValue","valueFromReducer","storeFromReducer","atomFromReducer","rerender","useReducer","prev","nextValue","delay","useEffect","unsub","setTimeout","useDebugValue","useSetAtom","useCallback","useAtom","getCached$2","c","k","cache1$3","selectAtom","anAtom","selector","equalityFn","create","dep1","dep2","dep3","cache2","cache3","memo3","EMPTY","Symbol","derivedAtom","prevSlice","slice","selectValue","getStringStorage","window","localStorage","lastStr","lastValue","storage","getItem","initialValue","_a2","parse","str2","JSON","reviver","str","setItem","newValue","stringify","removeItem","subscriber","subscribe","subscriber2","addEventListener","Storage","callback","storageEventCallback","storageArea","removeEventListener","createJSONStorage","hydratedMap","useHydrateAtoms","hydratedSet","getHydratedSet","dangerouslyForceHydrate","WeakSet"],"mappings":"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","x_google_ignoreList":[0,1,2,3]}