{"version":3,"sources":["webpack://@lemon8/web-homepage/./node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/index.js","webpack://@lemon8/web-homepage/./node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/react.js","webpack://@lemon8/web-homepage/./node_modules/.pnpm/jotai@2.6.1_@types+react@18.2.60_react@18.2.0/node_modules/jotai/vanilla.js"],"names":["vanilla","react","k","exports","ReactExports","StoreContext","useStore","options","store","Provider","_ref","children","storeRef","isPromiseLike","x","use","promise","v","e","useAtomValue","atom","_useReducer","prev","nextValue","_useReducer$","valueFromReducer","storeFromReducer","atomFromReducer","rerender","value","delay","unsub","useSetAtom","setAtom","_len","args","_key","useAtom","keyCount","read","write","key","config","get","set","arg","_unsupportedIterableToArray","o","minLen","_arrayLikeToArray","n","arr","len","i","arr2","_createForOfIteratorHelperLoose","allowArrayLike","it","hasInitialValue","isActuallyWritableAtom","cancelPromiseMap","registerCancelPromise","cancel","cancelPromise","next","resolvePromise","rejectPromise","isEqualAtomValue","a","b","isEqualAtomError","hasPromiseAtomValue","isEqualPromiseAtomValue","returnAtomValue","atomState","createStore","atomStateMap","mountedMap","pendingMap","storeListenersRev2","mountedAtoms","getAtomState","setAtomState","prevAtomState","_next","updateDependencies","nextAtomState","nextDependencies","dependencies","changed","aState","setAtomValue","setAtomValueOrPromise","valueOrPromise","abortPromise","continuePromise","updatePromiseDependencies","mountDependencies","resolve","reject","settled","setAtomError","error","readAtomState","force","s","isSync","getter","_aState","controller","setSelf","writeAtom","_controller","readAtom","addAtom","mounted","mountAtom","canUnmountAtom","delAtom","unmountAtom","recomputeDependents","dependencyMap","dirtyMap","getDependents","_mountedMap$get","dependents","_","pendingAtom","_getAtomState","loop1","dependent","loop2","dirtyCount","_dependencyMap$get","isChanged","writeAtomState","setter","r","_len3","_key3","flushed","flushPending","_len2","_key2","result","_len4","_key4","initialDependent","onMountQueue","_getAtomState2","queue","aMounted","onMount","onUnmount","_len5","_key5","f","_mountedMap$get2","prevDependencies","depSet","pending","_ref2","listener","subscribeAtom","listeners","defaultStore","getDefaultStore"],"mappings":"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","file":"958-60d6063959e9a61eb64f.js","sourcesContent":["'use strict';\n\nvar vanilla = require('jotai/vanilla');\nvar react = require('jotai/react');\n\n\n\nObject.keys(vanilla).forEach(function (k) {\n\tif (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {\n\t\tenumerable: true,\n\t\tget: function () { return vanilla[k]; }\n\t});\n});\nObject.keys(react).forEach(function (k) {\n\tif (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {\n\t\tenumerable: true,\n\t\tget: function () { return react[k]; }\n\t});\n});\n","'use client';\n'use strict';\n\nvar ReactExports = require('react');\nvar vanilla = require('jotai/vanilla');\n\nvar StoreContext = ReactExports.createContext(undefined);\nvar useStore = function useStore(options) {\n  var store = ReactExports.useContext(StoreContext);\n  return (options == null ? void 0 : options.store) || store || vanilla.getDefaultStore();\n};\nvar Provider = function Provider(_ref) {\n  var children = _ref.children,\n    store = _ref.store;\n  var storeRef = ReactExports.useRef();\n  if (!store && !storeRef.current) {\n    storeRef.current = vanilla.createStore();\n  }\n  return ReactExports.createElement(StoreContext.Provider, {\n    value: store || storeRef.current\n  }, children);\n};\n\nvar isPromiseLike = function isPromiseLike(x) {\n  return typeof (x == null ? void 0 : x.then) === 'function';\n};\nvar use = ReactExports.use || function (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(function (v) {\n      promise.status = 'fulfilled';\n      promise.value = v;\n    }, function (e) {\n      promise.status = 'rejected';\n      promise.reason = e;\n    });\n    throw promise;\n  }\n};\nfunction useAtomValue(atom, options) {\n  var store = useStore(options);\n  var _useReducer = ReactExports.useReducer(function (prev) {\n      var 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    }, undefined, function () {\n      return [store.get(atom), store, atom];\n    }),\n    _useReducer$ = _useReducer[0],\n    valueFromReducer = _useReducer$[0],\n    storeFromReducer = _useReducer$[1],\n    atomFromReducer = _useReducer$[2],\n    rerender = _useReducer[1];\n  var value = valueFromReducer;\n  if (storeFromReducer !== store || atomFromReducer !== atom) {\n    rerender();\n    value = store.get(atom);\n  }\n  var delay = options == null ? void 0 : options.delay;\n  ReactExports.useEffect(function () {\n    var unsub = store.sub(atom, function () {\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  ReactExports.useDebugValue(value);\n  return isPromiseLike(value) ? use(value) : value;\n}\n\nfunction useSetAtom(atom, options) {\n  var store = useStore(options);\n  var setAtom = ReactExports.useCallback(function () {\n    if (process.env.NODE_ENV !== 'production' && !('write' in atom)) {\n      throw new Error('not writable atom');\n    }\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n    return store.set.apply(store, [atom].concat(args));\n  }, [store, atom]);\n  return setAtom;\n}\n\nfunction useAtom(atom, options) {\n  return [useAtomValue(atom, options), useSetAtom(atom, options)];\n}\n\nexports.Provider = Provider;\nexports.useAtom = useAtom;\nexports.useAtomValue = useAtomValue;\nexports.useSetAtom = useSetAtom;\nexports.useStore = useStore;\n","'use strict';\n\nvar keyCount = 0;\nfunction atom(read, write) {\n  var key = \"atom\" + ++keyCount;\n  var config = {\n    toString: function toString() {\n      return key;\n    }\n  };\n  if (typeof read === 'function') {\n    config.read = read;\n  } else {\n    config.init = read;\n    config.read = function (get) {\n      return get(this);\n    };\n    config.write = function (get, set, arg) {\n      return set(this, typeof arg === 'function' ? arg(get(this)) : arg);\n    };\n  }\n  if (write) {\n    config.write = write;\n  }\n  return config;\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n  return arr2;\n}\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n  if (it) return (it = it.call(o)).next.bind(it);\n  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n    if (it) o = it;\n    var i = 0;\n    return function () {\n      if (i >= o.length) return {\n        done: true\n      };\n      return {\n        done: false,\n        value: o[i++]\n      };\n    };\n  }\n  throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nvar hasInitialValue = function hasInitialValue(atom) {\n  return 'init' in atom;\n};\nvar isActuallyWritableAtom = function isActuallyWritableAtom(atom) {\n  return !!atom.write;\n};\nvar cancelPromiseMap = new WeakMap();\nvar registerCancelPromise = function registerCancelPromise(promise, cancel) {\n  cancelPromiseMap.set(promise, cancel);\n  promise.catch(function () {}).finally(function () {\n    return cancelPromiseMap.delete(promise);\n  });\n};\nvar cancelPromise = function cancelPromise(promise, next) {\n  var cancel = cancelPromiseMap.get(promise);\n  if (cancel) {\n    cancelPromiseMap.delete(promise);\n    cancel(next);\n  }\n};\nvar resolvePromise = function resolvePromise(promise, value) {\n  promise.status = 'fulfilled';\n  promise.value = value;\n};\nvar rejectPromise = function rejectPromise(promise, e) {\n  promise.status = 'rejected';\n  promise.reason = e;\n};\nvar isPromiseLike = function isPromiseLike(x) {\n  return typeof (x == null ? void 0 : x.then) === 'function';\n};\nvar isEqualAtomValue = function isEqualAtomValue(a, b) {\n  return !!a && 'v' in a && 'v' in b && Object.is(a.v, b.v);\n};\nvar isEqualAtomError = function isEqualAtomError(a, b) {\n  return !!a && 'e' in a && 'e' in b && Object.is(a.e, b.e);\n};\nvar hasPromiseAtomValue = function hasPromiseAtomValue(a) {\n  return !!a && 'v' in a && a.v instanceof Promise;\n};\nvar isEqualPromiseAtomValue = function isEqualPromiseAtomValue(a, b) {\n  return 'v' in a && 'v' in b && a.v.orig && a.v.orig === b.v.orig;\n};\nvar returnAtomValue = function returnAtomValue(atomState) {\n  if ('e' in atomState) {\n    throw atomState.e;\n  }\n  return atomState.v;\n};\nvar createStore = function createStore() {\n  var atomStateMap = new WeakMap();\n  var mountedMap = new WeakMap();\n  var pendingMap = new Map();\n  var storeListenersRev2;\n  var mountedAtoms;\n  if (process.env.NODE_ENV !== 'production') {\n    storeListenersRev2 = new Set();\n    mountedAtoms = new Set();\n  }\n  var getAtomState = function getAtomState(atom) {\n    return atomStateMap.get(atom);\n  };\n  var setAtomState = function setAtomState(atom, atomState) {\n    if (process.env.NODE_ENV !== 'production') {\n      Object.freeze(atomState);\n    }\n    var prevAtomState = atomStateMap.get(atom);\n    atomStateMap.set(atom, atomState);\n    if (!pendingMap.has(atom)) {\n      pendingMap.set(atom, prevAtomState);\n    }\n    if (hasPromiseAtomValue(prevAtomState)) {\n      var _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  var updateDependencies = function updateDependencies(atom, nextAtomState, nextDependencies) {\n    var dependencies = new Map();\n    var changed = false;\n    nextDependencies.forEach(function (aState, a) {\n      if (!aState && a === atom) {\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 (process.env.NODE_ENV !== '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  var setAtomValue = function setAtomValue(atom, value, nextDependencies) {\n    var prevAtomState = getAtomState(atom);\n    var nextAtomState = {\n      d: (prevAtomState == null ? void 0 : prevAtomState.d) || new Map(),\n      v: value\n    };\n    if (nextDependencies) {\n      updateDependencies(atom, nextAtomState, nextDependencies);\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  var setAtomValueOrPromise = function setAtomValueOrPromise(atom, valueOrPromise, nextDependencies, abortPromise) {\n    if (isPromiseLike(valueOrPromise)) {\n      var continuePromise;\n      var updatePromiseDependencies = function updatePromiseDependencies() {\n        var prevAtomState = getAtomState(atom);\n        if (!hasPromiseAtomValue(prevAtomState) || prevAtomState.v !== promise) {\n          return;\n        }\n        var nextAtomState = setAtomValue(atom, promise, nextDependencies);\n        if (mountedMap.has(atom) && prevAtomState.d !== nextAtomState.d) {\n          mountDependencies(atom, nextAtomState, prevAtomState.d);\n        }\n      };\n      var promise = new Promise(function (resolve, reject) {\n        var settled = false;\n        valueOrPromise.then(function (v) {\n          if (!settled) {\n            settled = true;\n            resolvePromise(promise, v);\n            resolve(v);\n            updatePromiseDependencies();\n          }\n        }, function (e) {\n          if (!settled) {\n            settled = true;\n            rejectPromise(promise, e);\n            reject(e);\n            updatePromiseDependencies();\n          }\n        });\n        continuePromise = function continuePromise(next) {\n          if (!settled) {\n            settled = true;\n            next.then(function (v) {\n              return resolvePromise(promise, v);\n            }, function (e) {\n              return rejectPromise(promise, e);\n            });\n            resolve(next);\n          }\n        };\n      });\n      promise.orig = valueOrPromise;\n      promise.status = 'pending';\n      registerCancelPromise(promise, function (next) {\n        if (next) {\n          continuePromise(next);\n        }\n        abortPromise == null || abortPromise();\n      });\n      return setAtomValue(atom, promise, nextDependencies);\n    }\n    return setAtomValue(atom, valueOrPromise, nextDependencies);\n  };\n  var setAtomError = function setAtomError(atom, error, nextDependencies) {\n    var prevAtomState = getAtomState(atom);\n    var nextAtomState = {\n      d: (prevAtomState == null ? void 0 : prevAtomState.d) || 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  var readAtomState = function readAtomState(atom, force) {\n    var atomState = getAtomState(atom);\n    if (!force && atomState) {\n      if (mountedMap.has(atom)) {\n        return atomState;\n      }\n      if (Array.from(atomState.d).every(function (_ref) {\n        var a = _ref[0],\n          s = _ref[1];\n        if (a === atom) {\n          return true;\n        }\n        var aState = readAtomState(a);\n        return aState === s || isEqualAtomValue(aState, s);\n      })) {\n        return atomState;\n      }\n    }\n    var nextDependencies = new Map();\n    var isSync = true;\n    var getter = function getter(a) {\n      if (a === atom) {\n        var _aState = getAtomState(a);\n        if (_aState) {\n          nextDependencies.set(a, _aState);\n          return returnAtomValue(_aState);\n        }\n        if (hasInitialValue(a)) {\n          nextDependencies.set(a, undefined);\n          return a.init;\n        }\n        throw new Error('no atom init');\n      }\n      var aState = readAtomState(a);\n      nextDependencies.set(a, aState);\n      return returnAtomValue(aState);\n    };\n    var controller;\n    var setSelf;\n    var options = {\n      get signal() {\n        if (!controller) {\n          controller = new AbortController();\n        }\n        return controller.signal;\n      },\n      get setSelf() {\n        if (process.env.NODE_ENV !== 'production' && !isActuallyWritableAtom(atom)) {\n          console.warn('setSelf function cannot be used with read-only atom');\n        }\n        if (!setSelf && isActuallyWritableAtom(atom)) {\n          setSelf = function setSelf() {\n            if (process.env.NODE_ENV !== 'production' && isSync) {\n              console.warn('setSelf function cannot be called in sync');\n            }\n            if (!isSync) {\n              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n                args[_key] = arguments[_key];\n              }\n              return writeAtom.apply(void 0, [atom].concat(args));\n            }\n          };\n        }\n        return setSelf;\n      }\n    };\n    try {\n      var valueOrPromise = atom.read(getter, options);\n      return setAtomValueOrPromise(atom, valueOrPromise, nextDependencies, function () {\n        var _controller;\n        return (_controller = controller) == null ? void 0 : _controller.abort();\n      });\n    } catch (error) {\n      return setAtomError(atom, error, nextDependencies);\n    } finally {\n      isSync = false;\n    }\n  };\n  var readAtom = function readAtom(atom) {\n    return returnAtomValue(readAtomState(atom));\n  };\n  var addAtom = function addAtom(atom) {\n    var mounted = mountedMap.get(atom);\n    if (!mounted) {\n      mounted = mountAtom(atom);\n    }\n    return mounted;\n  };\n  var canUnmountAtom = function canUnmountAtom(atom, mounted) {\n    return !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom));\n  };\n  var delAtom = function delAtom(atom) {\n    var mounted = mountedMap.get(atom);\n    if (mounted && canUnmountAtom(atom, mounted)) {\n      unmountAtom(atom);\n    }\n  };\n  var recomputeDependents = function recomputeDependents(atom) {\n    var dependencyMap = new Map();\n    var dirtyMap = new WeakMap();\n    var getDependents = function getDependents(a) {\n      var _mountedMap$get;\n      var dependents = new Set((_mountedMap$get = mountedMap.get(a)) == null ? void 0 : _mountedMap$get.t);\n      pendingMap.forEach(function (_, pendingAtom) {\n        var _getAtomState;\n        if ((_getAtomState = getAtomState(pendingAtom)) != null && _getAtomState.d.has(a)) {\n          dependents.add(pendingAtom);\n        }\n      });\n      return dependents;\n    };\n    var loop1 = function loop1(a) {\n      getDependents(a).forEach(function (dependent) {\n        if (dependent !== a) {\n          dependencyMap.set(dependent, (dependencyMap.get(dependent) || new Set()).add(a));\n          dirtyMap.set(dependent, (dirtyMap.get(dependent) || 0) + 1);\n          loop1(dependent);\n        }\n      });\n    };\n    loop1(atom);\n    var loop2 = function loop2(a) {\n      getDependents(a).forEach(function (dependent) {\n        if (dependent !== a) {\n          var dirtyCount = dirtyMap.get(dependent);\n          if (dirtyCount) {\n            dirtyMap.set(dependent, --dirtyCount);\n          }\n          if (!dirtyCount) {\n            var _dependencyMap$get;\n            var isChanged = !!((_dependencyMap$get = dependencyMap.get(dependent)) != null && _dependencyMap$get.size);\n            if (isChanged) {\n              var prevAtomState = getAtomState(dependent);\n              var nextAtomState = readAtomState(dependent, true);\n              isChanged = !isEqualAtomValue(prevAtomState, nextAtomState);\n            }\n            if (!isChanged) {\n              dependencyMap.forEach(function (s) {\n                return s.delete(dependent);\n              });\n            }\n          }\n          loop2(dependent);\n        }\n      });\n    };\n    loop2(atom);\n  };\n  var writeAtomState = function writeAtomState(atom) {\n    var isSync = true;\n    var getter = function getter(a) {\n      return returnAtomValue(readAtomState(a));\n    };\n    var setter = function setter(a) {\n      var r;\n      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n        args[_key3 - 1] = arguments[_key3];\n      }\n      if (a === atom) {\n        if (!hasInitialValue(a)) {\n          throw new Error('atom not writable');\n        }\n        var prevAtomState = getAtomState(a);\n        var nextAtomState = setAtomValueOrPromise(a, args[0]);\n        if (!isEqualAtomValue(prevAtomState, nextAtomState)) {\n          recomputeDependents(a);\n        }\n      } else {\n        r = writeAtomState.apply(void 0, [a].concat(args));\n      }\n      if (!isSync) {\n        var flushed = flushPending();\n        if (process.env.NODE_ENV !== 'production') {\n          storeListenersRev2.forEach(function (l) {\n            return l({\n              type: 'async-write',\n              flushed: flushed\n            });\n          });\n        }\n      }\n      return r;\n    };\n    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n      args[_key2 - 1] = arguments[_key2];\n    }\n    var result = atom.write.apply(atom, [getter, setter].concat(args));\n    isSync = false;\n    return result;\n  };\n  var writeAtom = function writeAtom(atom) {\n    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n      args[_key4 - 1] = arguments[_key4];\n    }\n    var result = writeAtomState.apply(void 0, [atom].concat(args));\n    var flushed = flushPending();\n    if (process.env.NODE_ENV !== 'production') {\n      storeListenersRev2.forEach(function (l) {\n        return l({\n          type: 'write',\n          flushed: flushed\n        });\n      });\n    }\n    return result;\n  };\n  var mountAtom = function mountAtom(atom, initialDependent, onMountQueue) {\n    var _getAtomState2;\n    var queue = onMountQueue || [];\n    (_getAtomState2 = getAtomState(atom)) == null || _getAtomState2.d.forEach(function (_, a) {\n      var aMounted = mountedMap.get(a);\n      if (aMounted) {\n        aMounted.t.add(atom);\n      } else {\n        if (a !== atom) {\n          mountAtom(a, atom, queue);\n        }\n      }\n    });\n    readAtomState(atom);\n    var mounted = {\n      t: new Set(initialDependent && [initialDependent]),\n      l: new Set()\n    };\n    mountedMap.set(atom, mounted);\n    if (process.env.NODE_ENV !== 'production') {\n      mountedAtoms.add(atom);\n    }\n    if (isActuallyWritableAtom(atom) && atom.onMount) {\n      var onMount = atom.onMount;\n      queue.push(function () {\n        var onUnmount = onMount(function () {\n          for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {\n            args[_key5] = arguments[_key5];\n          }\n          return writeAtom.apply(void 0, [atom].concat(args));\n        });\n        if (onUnmount) {\n          mounted.u = onUnmount;\n        }\n      });\n    }\n    if (!onMountQueue) {\n      queue.forEach(function (f) {\n        return f();\n      });\n    }\n    return mounted;\n  };\n  var unmountAtom = function unmountAtom(atom) {\n    var _mountedMap$get2;\n    var onUnmount = (_mountedMap$get2 = mountedMap.get(atom)) == null ? void 0 : _mountedMap$get2.u;\n    if (onUnmount) {\n      onUnmount();\n    }\n    mountedMap.delete(atom);\n    if (process.env.NODE_ENV !== 'production') {\n      mountedAtoms.delete(atom);\n    }\n    var atomState = getAtomState(atom);\n    if (atomState) {\n      if (hasPromiseAtomValue(atomState)) {\n        cancelPromise(atomState.v);\n      }\n      atomState.d.forEach(function (_, a) {\n        if (a !== atom) {\n          var mounted = mountedMap.get(a);\n          if (mounted) {\n            mounted.t.delete(atom);\n            if (canUnmountAtom(a, mounted)) {\n              unmountAtom(a);\n            }\n          }\n        }\n      });\n    } else if (process.env.NODE_ENV !== 'production') {\n      console.warn('[Bug] could not find atom state to unmount', atom);\n    }\n  };\n  var mountDependencies = function mountDependencies(atom, atomState, prevDependencies) {\n    var depSet = new Set(atomState.d.keys());\n    prevDependencies == null || prevDependencies.forEach(function (_, a) {\n      if (depSet.has(a)) {\n        depSet.delete(a);\n        return;\n      }\n      var mounted = mountedMap.get(a);\n      if (mounted) {\n        mounted.t.delete(atom);\n        if (canUnmountAtom(a, mounted)) {\n          unmountAtom(a);\n        }\n      }\n    });\n    depSet.forEach(function (a) {\n      var mounted = mountedMap.get(a);\n      if (mounted) {\n        mounted.t.add(atom);\n      } else if (mountedMap.has(atom)) {\n        mountAtom(a, atom);\n      }\n    });\n  };\n  var flushPending = function flushPending() {\n    var flushed;\n    if (process.env.NODE_ENV !== 'production') {\n      flushed = new Set();\n    }\n    while (pendingMap.size) {\n      var pending = Array.from(pendingMap);\n      pendingMap.clear();\n      pending.forEach(function (_ref2) {\n        var atom = _ref2[0],\n          prevAtomState = _ref2[1];\n        var atomState = getAtomState(atom);\n        if (atomState) {\n          var 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 && !(!hasPromiseAtomValue(prevAtomState) && (isEqualAtomValue(prevAtomState, atomState) || isEqualAtomError(prevAtomState, atomState)))) {\n            mounted.l.forEach(function (listener) {\n              return listener();\n            });\n            if (process.env.NODE_ENV !== 'production') {\n              flushed.add(atom);\n            }\n          }\n        } else if (process.env.NODE_ENV !== 'production') {\n          console.warn('[Bug] no atom state to flush');\n        }\n      });\n    }\n    if (process.env.NODE_ENV !== 'production') {\n      return flushed;\n    }\n  };\n  var subscribeAtom = function subscribeAtom(atom, listener) {\n    var mounted = addAtom(atom);\n    var flushed = flushPending();\n    var listeners = mounted.l;\n    listeners.add(listener);\n    if (process.env.NODE_ENV !== 'production') {\n      storeListenersRev2.forEach(function (l) {\n        return l({\n          type: 'sub',\n          flushed: flushed\n        });\n      });\n    }\n    return function () {\n      listeners.delete(listener);\n      delAtom(atom);\n      if (process.env.NODE_ENV !== 'production') {\n        storeListenersRev2.forEach(function (l) {\n          return l({\n            type: 'unsub'\n          });\n        });\n      }\n    };\n  };\n  if (process.env.NODE_ENV !== 'production') {\n    return {\n      get: readAtom,\n      set: writeAtom,\n      sub: subscribeAtom,\n      dev_subscribe_store: function dev_subscribe_store(l, rev) {\n        if (rev !== 2) {\n          throw new Error('The current StoreListener revision is 2.');\n        }\n        storeListenersRev2.add(l);\n        return function () {\n          storeListenersRev2.delete(l);\n        };\n      },\n      dev_get_mounted_atoms: function dev_get_mounted_atoms() {\n        return mountedAtoms.values();\n      },\n      dev_get_atom_state: function dev_get_atom_state(a) {\n        return atomStateMap.get(a);\n      },\n      dev_get_mounted: function dev_get_mounted(a) {\n        return mountedMap.get(a);\n      },\n      dev_restore_atoms: function dev_restore_atoms(values) {\n        for (var _iterator = _createForOfIteratorHelperLoose(values), _step; !(_step = _iterator()).done;) {\n          var _step$value = _step.value,\n            atom = _step$value[0],\n            valueOrPromise = _step$value[1];\n          if (hasInitialValue(atom)) {\n            setAtomValueOrPromise(atom, valueOrPromise);\n            recomputeDependents(atom);\n          }\n        }\n        var flushed = flushPending();\n        storeListenersRev2.forEach(function (l) {\n          return l({\n            type: 'restore',\n            flushed: flushed\n          });\n        });\n      }\n    };\n  }\n  return {\n    get: readAtom,\n    set: writeAtom,\n    sub: subscribeAtom\n  };\n};\nvar defaultStore;\nif (process.env.NODE_ENV !== 'production') {\n  if (typeof globalThis.__NUMBER_OF_JOTAI_INSTANCES__ === 'number') {\n    ++globalThis.__NUMBER_OF_JOTAI_INSTANCES__;\n  } else {\n    globalThis.__NUMBER_OF_JOTAI_INSTANCES__ = 1;\n  }\n}\nvar getDefaultStore = function getDefaultStore() {\n  if (!defaultStore) {\n    if (process.env.NODE_ENV !== 'production' && globalThis.__NUMBER_OF_JOTAI_INSTANCES__ !== 1) {\n      console.warn('Detected multiple Jotai instances. It may cause unexpected behavior with the default store. https://github.com/pmndrs/jotai/discussions/2044');\n    }\n    defaultStore = createStore();\n  }\n  return defaultStore;\n};\n\nexports.atom = atom;\nexports.createStore = createStore;\nexports.getDefaultStore = getDefaultStore;\n"],"sourceRoot":""}