{"version":3,"file":"static/chunks/597-6b787fad488f2781.js","mappings":"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CA,qBACA,UACA,WACA,EACA,UACA,EACA,SACA,MACA,IACA,GACA,CAAM,SACN,IACA,IACA,KAEA,CACA,EACA,4BACA,aACA,6BACA,aACA,oBACA,aACA,cACA,MACA,0CACA,CAAK,EACL,YACA,CACA,KACA,OAEA,EACA,uBACA,EAEA,UAEA,gBACA,cACA,MACA,kBACA,SAEA,aADA,KACA,YACA,WAEA,OACA,YACM,IACN,MACA,WAEA,sBACA,MACA,GACA,OAGA,EACA,gBACA,MA4CA,EACA,EA5CA,WACA,UACA,iCAGA,sBACA,SAGA,iBANA,SAYA,YACA,SAqDA,IACA,UArDA,IACA,WACA,WACA,UACA,QACA,mBAEA,4BAGA,WACA,CACA,eACA,IACA,WACA,EAAQ,OACR,KACA,iBACU,CACV,UACA,aACA,SACA,IACA,CACA,CACA,EAGA,CACA,aAIA,OAHA,GACA,wBAEA,SACO,CACP,cAcA,OAbmD,MACnD,oEAEA,UACA,YAIA,GAHuD,GACvD,0DAEA,GACA,gBAEA,GAEA,CACA,CACA,GAIA,GADA,SACA,MACA,6DACA,WACA,QACA,UACA,SACA,IACA,CACA,EACA,WACA,CACA,QACA,CAAM,SAIN,OAHA,WACA,MACA,MACA,CACA,EAAM,OACN,IACA,CACA,EAEA,YACA,QACA,cACA,2CACA,cAEA,iBACA,MACA,EACA,MAMA,OAHA,gCACA,aACA,CAAK,EACL,CACA,EA2BA,YACA,SA3BA,gBACA,SACA,UACA,UACA,UACA,kBACA,uBACA,aACA,QACA,QACA,CACA,aACA,kBACA,SACA,QACA,QACA,CAEA,eADA,SACA,UACA,iBACA,aAGA,CACA,aAIA,EACA,EACA,GAEA,eACA,qBAA4C,KAAQ,KACpD,gBACA,KACA,wBACA,oBACA,KACA,KACA,CAEA,IACA,SACA,SACA,UACA,SACA,WAGA,WACA,CACA,EACA,eACA,SA2BA,IACA,WA3BA,aACA,WACA,WACA,IACA,WAcA,kBAdA,EACA,SACA,iCAEA,UACA,OACA,SACA,SACA,UACA,SACA,UAEA,MACA,CAGA,CAHU,CAGF,OACR,GACA,IAEA,CACA,KAEA,EACA,EAAM,OACN,IACA,CACA,EACA,aACA,UACA,IACA,kBACA,EAAM,OACN,IACA,CACA,EACA,YACA,iBACA,wBACA,eACA,YACA,SACA,cAGA,uBACA,gBACA,gBACA,iBACA,uBACA,CAEA,CACA,EACA,YACA,SAEA,aADA,OACA,YACA,YACA,SAUA,GARA,KACA,UACA,sBACA,SACA,EAEA,SAEA,UAEA,EADA,UAEA,UACA,SACA,WACA,IACA,kBACA,EAAc,OACd,GACA,IAEA,CACA,EACA,IACA,UACA,EAAY,OACZ,IACA,CACA,EACA,SACA,QACA,EACA,0BAEA,GACA,eAEA,CAAS,CACT,CACA,CACA,YAEA,YACA,iDACA,MACA,yCACA,CAAK,GACL,YAQA,aAPA,GACA,cAEA,WAEA,YAEA,aACA,iBACA,uBACA,CACA,MACA,CACA,YAiBA,GACA,IAxNA,kBAyNA,MACA,IAlBA,QACA,UACA,OAEA,EADA,SACA,EAGA,OAFA,SACA,KACA,KACA,YACA,UACA,SACA,IACA,CACA,EAMA,gBALA,mBAMA,EAiCA,OAFA,gBA7BA,CAEA,iCACA,QACA,WACA,WAGA,QACA,CACA,EAAO,CACP,6BACA,uBACA,UACA,iBACA,SACA,WACA,MACA,SACA,SACA,UACA,SACA,SAEA,CAEA,IACA,CACA,GAGA,CACA,EACA,OACA,kBAYA,SAXA,IACA,GAA+C,EAAtC,CACT,KADwB,CACxB,EAD2B,CAAoB,GAC/C,6BAEA,eAKA,OAJA,IACA,GAAoB,yBACpB,YAEA,CACA,EAGA,uBACA,wBACA,WACA,MACA,gDACA,EAEA,EAEA,OACA,IACA,MAEA,2EACA,wCACA,aACA,iJAKA","sources":["webpack://_N_E/../../node_modules/jotai/esm/react.mjs","webpack://_N_E/../../node_modules/jotai/esm/vanilla.mjs"],"sourcesContent":["'use client';\nimport ReactExports, { createContext, useRef, createElement, useContext, useReducer, useEffect, useDebugValue, useCallback } from 'react';\nimport { createStore, getDefaultStore } 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 attachPromiseMeta = (promise) => {\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};\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    attachPromiseMeta(promise);\n    throw promise;\n  }\n});\nconst continuablePromiseMap = /* @__PURE__ */ new WeakMap();\nconst createContinuablePromise = (promise) => {\n  let continuablePromise = continuablePromiseMap.get(promise);\n  if (!continuablePromise) {\n    continuablePromise = new Promise((resolve, reject) => {\n      let curr = promise;\n      const onFulfilled = (me) => (v) => {\n        if (curr === me) {\n          resolve(v);\n        }\n      };\n      const onRejected = (me) => (e) => {\n        if (curr === me) {\n          reject(e);\n        }\n      };\n      const registerCancelHandler = (p) => {\n        if (\"onCancel\" in p && typeof p.onCancel === \"function\") {\n          p.onCancel((nextValue) => {\n            if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" && nextValue === p) {\n              throw new Error(\"[Bug] p is not updated even after cancelation\");\n            }\n            if (isPromiseLike(nextValue)) {\n              continuablePromiseMap.set(nextValue, continuablePromise);\n              curr = nextValue;\n              nextValue.then(onFulfilled(nextValue), onRejected(nextValue));\n              registerCancelHandler(nextValue);\n            } else {\n              resolve(nextValue);\n            }\n          });\n        }\n      };\n      promise.then(onFulfilled(promise), onRejected(promise));\n      registerCancelHandler(promise);\n    });\n    continuablePromiseMap.set(promise, continuablePromise);\n  }\n  return continuablePromise;\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        const value2 = store.get(atom);\n        if (isPromiseLike(value2)) {\n          attachPromiseMeta(createContinuablePromise(value2));\n        }\n        setTimeout(rerender, delay);\n        return;\n      }\n      rerender();\n    });\n    rerender();\n    return unsub;\n  }, [store, atom, delay]);\n  useDebugValue(value);\n  if (isPromiseLike(value)) {\n    const promise = createContinuablePromise(value);\n    return use(promise);\n  }\n  return 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","let keyCount = 0;\nfunction atom(read, write) {\n  const key = `atom${++keyCount}`;\n  const config = {\n    toString() {\n      return (import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" && this.debugLabel ? key + \":\" + this.debugLabel : key;\n    }\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 cancelablePromiseMap = /* @__PURE__ */ new WeakMap();\nconst isPendingPromise = (value) => {\n  var _a;\n  return isPromiseLike(value) && !((_a = cancelablePromiseMap.get(value)) == null ? void 0 : _a[1]);\n};\nconst cancelPromise = (promise, nextValue) => {\n  const promiseState = cancelablePromiseMap.get(promise);\n  if (promiseState) {\n    promiseState[1] = true;\n    promiseState[0].forEach((fn) => fn(nextValue));\n  } else if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    throw new Error(\"[Bug] cancelable promise not found\");\n  }\n};\nconst patchPromiseForCancelability = (promise) => {\n  if (cancelablePromiseMap.has(promise)) {\n    return;\n  }\n  const promiseState = [/* @__PURE__ */ new Set(), false];\n  cancelablePromiseMap.set(promise, promiseState);\n  const settle = () => {\n    promiseState[1] = true;\n  };\n  promise.then(settle, settle);\n  promise.onCancel = (fn) => {\n    promiseState[0].add(fn);\n  };\n};\nconst isPromiseLike = (x) => typeof (x == null ? void 0 : x.then) === \"function\";\nconst isAtomStateInitialized = (atomState) => \"v\" in atomState || \"e\" in atomState;\nconst returnAtomValue = (atomState) => {\n  if (\"e\" in atomState) {\n    throw atomState.e;\n  }\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" && !(\"v\" in atomState)) {\n    throw new Error(\"[Bug] atom state is not initialized\");\n  }\n  return atomState.v;\n};\nconst addPendingPromiseToDependency = (atom, promise, dependencyAtomState) => {\n  if (!dependencyAtomState.p.has(atom)) {\n    dependencyAtomState.p.add(atom);\n    promise.then(\n      () => {\n        dependencyAtomState.p.delete(atom);\n      },\n      () => {\n        dependencyAtomState.p.delete(atom);\n      }\n    );\n  }\n};\nconst addDependency = (pending, atom, atomState, a, aState) => {\n  var _a;\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" && a === atom) {\n    throw new Error(\"[Bug] atom cannot depend on itself\");\n  }\n  atomState.d.set(a, aState.n);\n  if (isPendingPromise(atomState.v)) {\n    addPendingPromiseToDependency(atom, atomState.v, aState);\n  }\n  (_a = aState.m) == null ? void 0 : _a.t.add(atom);\n  if (pending) {\n    addPendingDependent(pending, a, atom);\n  }\n};\nconst createPending = () => [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set()];\nconst addPendingAtom = (pending, atom, atomState) => {\n  if (!pending[0].has(atom)) {\n    pending[0].set(atom, /* @__PURE__ */ new Set());\n  }\n  pending[1].set(atom, atomState);\n};\nconst addPendingDependent = (pending, atom, dependent) => {\n  const dependents = pending[0].get(atom);\n  if (dependents) {\n    dependents.add(dependent);\n  }\n};\nconst getPendingDependents = (pending, atom) => pending[0].get(atom);\nconst addPendingFunction = (pending, fn) => {\n  pending[2].add(fn);\n};\nconst flushPending = (pending) => {\n  let error;\n  let hasError = false;\n  const call = (fn) => {\n    try {\n      fn();\n    } catch (e) {\n      if (!hasError) {\n        error = e;\n        hasError = true;\n      }\n    }\n  };\n  while (pending[1].size || pending[2].size) {\n    pending[0].clear();\n    const atomStates = new Set(pending[1].values());\n    pending[1].clear();\n    const functions = new Set(pending[2]);\n    pending[2].clear();\n    atomStates.forEach((atomState) => {\n      var _a;\n      return (_a = atomState.m) == null ? void 0 : _a.l.forEach(call);\n    });\n    functions.forEach(call);\n  }\n  if (hasError) {\n    throw error;\n  }\n};\nconst buildStore = (...[getAtomState, atomRead, atomWrite, atomOnMount]) => {\n  let debugMountedAtoms;\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    debugMountedAtoms = /* @__PURE__ */ new Set();\n  }\n  const setAtomStateValueOrPromise = (atom, atomState, valueOrPromise) => {\n    const hasPrevValue = \"v\" in atomState;\n    const prevValue = atomState.v;\n    const pendingPromise = isPendingPromise(atomState.v) ? atomState.v : null;\n    if (isPromiseLike(valueOrPromise)) {\n      patchPromiseForCancelability(valueOrPromise);\n      for (const a of atomState.d.keys()) {\n        addPendingPromiseToDependency(atom, valueOrPromise, getAtomState(a));\n      }\n      atomState.v = valueOrPromise;\n      delete atomState.e;\n    } else {\n      atomState.v = valueOrPromise;\n      delete atomState.e;\n    }\n    if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {\n      ++atomState.n;\n      if (pendingPromise) {\n        cancelPromise(pendingPromise, valueOrPromise);\n      }\n    }\n  };\n  const readAtomState = (pending, atom, dirtyAtoms) => {\n    var _a;\n    const atomState = getAtomState(atom);\n    if (isAtomStateInitialized(atomState)) {\n      if (atomState.m && !(dirtyAtoms == null ? void 0 : dirtyAtoms.has(atom))) {\n        return atomState;\n      }\n      if (Array.from(atomState.d).every(\n        ([a, n]) => (\n          // Recursively, read the atom state of the dependency, and\n          // check if the atom epoch number is unchanged\n          readAtomState(pending, a, dirtyAtoms).n === n\n        )\n      )) {\n        return atomState;\n      }\n    }\n    atomState.d.clear();\n    let isSync = true;\n    const getter = (a) => {\n      if (isSelfAtom(atom, a)) {\n        const aState2 = getAtomState(a);\n        if (!isAtomStateInitialized(aState2)) {\n          if (hasInitialValue(a)) {\n            setAtomStateValueOrPromise(a, aState2, a.init);\n          } else {\n            throw new Error(\"no atom init\");\n          }\n        }\n        return returnAtomValue(aState2);\n      }\n      const aState = readAtomState(pending, a, dirtyAtoms);\n      try {\n        return returnAtomValue(aState);\n      } finally {\n        if (isSync) {\n          addDependency(pending, atom, atomState, a, aState);\n        } else {\n          const pending2 = createPending();\n          addDependency(pending2, atom, atomState, a, aState);\n          mountDependencies(pending2, atom, atomState);\n          flushPending(pending2);\n        }\n      }\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 = atomRead(atom, getter, options);\n      setAtomStateValueOrPromise(atom, atomState, valueOrPromise);\n      if (isPromiseLike(valueOrPromise)) {\n        (_a = valueOrPromise.onCancel) == null ? void 0 : _a.call(valueOrPromise, () => controller == null ? void 0 : controller.abort());\n        const complete = () => {\n          if (atomState.m) {\n            const pending2 = createPending();\n            mountDependencies(pending2, atom, atomState);\n            flushPending(pending2);\n          }\n        };\n        valueOrPromise.then(complete, complete);\n      }\n      return atomState;\n    } catch (error) {\n      delete atomState.v;\n      atomState.e = error;\n      ++atomState.n;\n      return atomState;\n    } finally {\n      isSync = false;\n    }\n  };\n  const readAtom = (atom) => returnAtomValue(readAtomState(void 0, atom));\n  const getDependents = (pending, atom, atomState) => {\n    var _a, _b;\n    const dependents = /* @__PURE__ */ new Map();\n    for (const a of ((_a = atomState.m) == null ? void 0 : _a.t) || []) {\n      dependents.set(a, getAtomState(a));\n    }\n    for (const atomWithPendingPromise of atomState.p) {\n      dependents.set(\n        atomWithPendingPromise,\n        getAtomState(atomWithPendingPromise)\n      );\n    }\n    (_b = getPendingDependents(pending, atom)) == null ? void 0 : _b.forEach((dependent) => {\n      dependents.set(dependent, getAtomState(dependent));\n    });\n    return dependents;\n  };\n  function getSortedDependents(pending, rootAtom, rootAtomState) {\n    const sorted = [];\n    const visiting = /* @__PURE__ */ new Set();\n    const visited = /* @__PURE__ */ new Set();\n    const stack = [[rootAtom, rootAtomState]];\n    while (stack.length > 0) {\n      const [a, aState] = stack[stack.length - 1];\n      if (visited.has(a)) {\n        stack.pop();\n        continue;\n      }\n      if (visiting.has(a)) {\n        sorted.push([a, aState, aState.n]);\n        visited.add(a);\n        stack.pop();\n        continue;\n      }\n      visiting.add(a);\n      for (const [d, s] of getDependents(pending, a, aState)) {\n        if (a !== d && !visiting.has(d)) {\n          stack.push([d, s]);\n        }\n      }\n    }\n    return [sorted, visited];\n  }\n  const recomputeDependents = (pending, atom, atomState) => {\n    const [topsortedAtoms, markedAtoms] = getSortedDependents(\n      pending,\n      atom,\n      atomState\n    );\n    const changedAtoms = /* @__PURE__ */ new Set([atom]);\n    for (let i = topsortedAtoms.length - 1; i >= 0; --i) {\n      const [a, aState, prevEpochNumber] = topsortedAtoms[i];\n      let hasChangedDeps = false;\n      for (const dep of aState.d.keys()) {\n        if (dep !== a && changedAtoms.has(dep)) {\n          hasChangedDeps = true;\n          break;\n        }\n      }\n      if (hasChangedDeps) {\n        readAtomState(pending, a, markedAtoms);\n        mountDependencies(pending, a, aState);\n        if (prevEpochNumber !== aState.n) {\n          addPendingAtom(pending, a, aState);\n          changedAtoms.add(a);\n        }\n      }\n      markedAtoms.delete(a);\n    }\n  };\n  const writeAtomState = (pending, atom, ...args) => {\n    let isSync = true;\n    const getter = (a) => returnAtomValue(readAtomState(pending, a));\n    const setter = (a, ...args2) => {\n      const aState = getAtomState(a);\n      try {\n        if (isSelfAtom(atom, a)) {\n          if (!hasInitialValue(a)) {\n            throw new Error(\"atom not writable\");\n          }\n          const prevEpochNumber = aState.n;\n          const v = args2[0];\n          setAtomStateValueOrPromise(a, aState, v);\n          mountDependencies(pending, a, aState);\n          if (prevEpochNumber !== aState.n) {\n            addPendingAtom(pending, a, aState);\n            recomputeDependents(pending, a, aState);\n          }\n          return void 0;\n        } else {\n          return writeAtomState(pending, a, ...args2);\n        }\n      } finally {\n        if (!isSync) {\n          flushPending(pending);\n        }\n      }\n    };\n    try {\n      return atomWrite(atom, getter, setter, ...args);\n    } finally {\n      isSync = false;\n    }\n  };\n  const writeAtom = (atom, ...args) => {\n    const pending = createPending();\n    try {\n      return writeAtomState(pending, atom, ...args);\n    } finally {\n      flushPending(pending);\n    }\n  };\n  const mountDependencies = (pending, atom, atomState) => {\n    if (atomState.m && !isPendingPromise(atomState.v)) {\n      for (const a of atomState.d.keys()) {\n        if (!atomState.m.d.has(a)) {\n          const aMounted = mountAtom(pending, a, getAtomState(a));\n          aMounted.t.add(atom);\n          atomState.m.d.add(a);\n        }\n      }\n      for (const a of atomState.m.d || []) {\n        if (!atomState.d.has(a)) {\n          atomState.m.d.delete(a);\n          const aMounted = unmountAtom(pending, a, getAtomState(a));\n          aMounted == null ? void 0 : aMounted.t.delete(atom);\n        }\n      }\n    }\n  };\n  const mountAtom = (pending, atom, atomState) => {\n    if (!atomState.m) {\n      readAtomState(pending, atom);\n      for (const a of atomState.d.keys()) {\n        const aMounted = mountAtom(pending, a, getAtomState(a));\n        aMounted.t.add(atom);\n      }\n      atomState.m = {\n        l: /* @__PURE__ */ new Set(),\n        d: new Set(atomState.d.keys()),\n        t: /* @__PURE__ */ new Set()\n      };\n      if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n        debugMountedAtoms.add(atom);\n      }\n      if (isActuallyWritableAtom(atom)) {\n        const mounted = atomState.m;\n        let setAtom;\n        const createInvocationContext = (pending2, fn) => {\n          let isSync = true;\n          setAtom = (...args) => {\n            try {\n              return writeAtomState(pending2, atom, ...args);\n            } finally {\n              if (!isSync) {\n                flushPending(pending2);\n              }\n            }\n          };\n          try {\n            return fn();\n          } finally {\n            isSync = false;\n          }\n        };\n        addPendingFunction(pending, () => {\n          const onUnmount = createInvocationContext(\n            pending,\n            () => atomOnMount(atom, (...args) => setAtom(...args))\n          );\n          if (onUnmount) {\n            mounted.u = (pending2) => createInvocationContext(pending2, onUnmount);\n          }\n        });\n      }\n    }\n    return atomState.m;\n  };\n  const unmountAtom = (pending, atom, atomState) => {\n    if (atomState.m && !atomState.m.l.size && !Array.from(atomState.m.t).some((a) => {\n      var _a;\n      return (_a = getAtomState(a).m) == null ? void 0 : _a.d.has(atom);\n    })) {\n      const onUnmount = atomState.m.u;\n      if (onUnmount) {\n        addPendingFunction(pending, () => onUnmount(pending));\n      }\n      delete atomState.m;\n      if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n        debugMountedAtoms.delete(atom);\n      }\n      for (const a of atomState.d.keys()) {\n        const aMounted = unmountAtom(pending, a, getAtomState(a));\n        aMounted == null ? void 0 : aMounted.t.delete(atom);\n      }\n      return void 0;\n    }\n    return atomState.m;\n  };\n  const subscribeAtom = (atom, listener) => {\n    const pending = createPending();\n    const atomState = getAtomState(atom);\n    const mounted = mountAtom(pending, atom, atomState);\n    const listeners = mounted.l;\n    listeners.add(listener);\n    flushPending(pending);\n    return () => {\n      listeners.delete(listener);\n      const pending2 = createPending();\n      unmountAtom(pending2, atom, atomState);\n      flushPending(pending2);\n    };\n  };\n  const unstable_derive = (fn) => buildStore(...fn(getAtomState, atomRead, atomWrite, atomOnMount));\n  const store = {\n    get: readAtom,\n    set: writeAtom,\n    sub: subscribeAtom,\n    unstable_derive\n  };\n  if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\") {\n    const devStore = {\n      // store dev methods (these are tentative and subject to change without notice)\n      dev4_get_internal_weak_map: () => ({\n        get: (atom) => {\n          const atomState = getAtomState(atom);\n          if (atomState.n === 0) {\n            return void 0;\n          }\n          return atomState;\n        }\n      }),\n      dev4_get_mounted_atoms: () => debugMountedAtoms,\n      dev4_restore_atoms: (values) => {\n        const pending = createPending();\n        for (const [atom, value] of values) {\n          if (hasInitialValue(atom)) {\n            const atomState = getAtomState(atom);\n            const prevEpochNumber = atomState.n;\n            setAtomStateValueOrPromise(atom, atomState, value);\n            mountDependencies(pending, atom, atomState);\n            if (prevEpochNumber !== atomState.n) {\n              addPendingAtom(pending, atom, atomState);\n              recomputeDependents(pending, atom, atomState);\n            }\n          }\n        }\n        flushPending(pending);\n      }\n    };\n    Object.assign(store, devStore);\n  }\n  return store;\n};\nconst createStore = () => {\n  const atomStateMap = /* @__PURE__ */ new WeakMap();\n  const getAtomState = (atom) => {\n    if ((import.meta.env ? import.meta.env.MODE : void 0) !== \"production\" && !atom) {\n      throw new Error(\"Atom is undefined or null\");\n    }\n    let atomState = atomStateMap.get(atom);\n    if (!atomState) {\n      atomState = { d: /* @__PURE__ */ new Map(), p: /* @__PURE__ */ new Set(), n: 0 };\n      atomStateMap.set(atom, atomState);\n    }\n    return atomState;\n  };\n  return buildStore(\n    getAtomState,\n    (atom, ...params) => atom.read(...params),\n    (atom, ...params) => atom.write(...params),\n    (atom, ...params) => {\n      var _a;\n      return (_a = atom.onMount) == null ? void 0 : _a.call(atom, ...params);\n    }\n  );\n};\nlet defaultStore;\nconst getDefaultStore = () => {\n  if (!defaultStore) {\n    defaultStore = createStore();\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\nexport { atom, createStore, getDefaultStore };\n"],"names":["StoreContext","createContext","useStore","store","useContext","options","getDefaultStore","Provider","children","storeRef","useRef","current","createStore","createElement","value","isPromiseLike","x","then","attachPromiseMeta","promise","status","v","reason","e","use","ReactExports","continuablePromiseMap","WeakMap","createContinuablePromise","continuablePromise","get","Promise","resolve","reject","curr","onFulfilled","me","onRejected","registerCancelHandler","p","onCancel","nextValue","set","useAtom","atom","useAtomValue","valueFromReducer","storeFromReducer","atomFromReducer","rerender","useReducer","is","prev","delay","useEffect","unsub","sub","value2","setTimeout","useDebugValue","useSetAtom","useCallback","setAtom","args"],"sourceRoot":"","ignoreList":[0,1]}