{"version":3,"file":"19865208eb0db9f08fd74223.js?3.6.14.7428b935c.1723600572441","mappings":"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","sources":["webpack://mono-repo/./node_modules/jotai/esm/vanilla.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      var _a;\n      if (!pendingMap.has(a)) {\n        const aState = getAtomState(a);\n        (_a = pendingStack[pendingStack.length - 1]) == null ? void 0 : _a.add(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    if (!pendingMap.has(atom)) {\n      (_a = pendingStack[pendingStack.length - 1]) == null ? void 0 : _a.add(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        }\n        abortPromise == null ? void 0 : abortPromise();\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 && 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);\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);\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    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, true);\n        if (!isEqualAtomValue(prevAtomState, nextAtomState)) {\n          changedAtoms.add(a);\n        }\n      }\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"],"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","Set","getAtomState","addPendingDependent","d","forEach","_","_a","has","aState","length","add","setAtomState","freeze","prevAtomState","resolve","reject","updateDependencies","nextAtomState","nextDependencies","keepPreviousDependencies","dependencies","Map","changed","console","warn","size","setAtomValue","orig","setAtomValueOrPromise","valueOrPromise","abortPromise","x","then","continuePromise","updatePromiseDependencies","mountDependencies","settled","catch","finally","registerCancelPromise","readAtomState","force","Array","from","every","s","isSync","getter","aState2","Error","controller","setSelf","options","signal","AbortController","args","writeAtom","abort","error","setAtomError","recomputeDependents","topsortedAtoms","markedAtoms","visit","n","m","_b","dependents","t","dependent","getDependents","push","changedAtoms","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","prevDependencies","depSet","maybeUnmountAtomSet","pendingAtoms","pending","collectPending","pendingAtom","listener","sub","listeners","dev_subscribe_store","dev_get_mounted_atoms","values","dev_get_atom_state","dev_get_mounted","dev_restore_atoms","defaultStore","Symbol","getDefaultStore","globalThis","__JOTAI_DEFAULT_STORE__"],"sourceRoot":""}