{"version":3,"sources":["webpack:///./node_modules/@charlietango/use-focus-trap/lib/useFocusTrap.esm.js","webpack:///./node_modules/jotai/index.js","webpack:///./node_modules/jotai/vanilla.js","webpack:///./node_modules/@charlietango/use-client-hydrated/lib/useClientHydrated.esm.js","webpack:///./node_modules/window-or-global/lib/index.js","webpack:///./node_modules/jotai/react.js","webpack:///./node_modules/@charlietango/use-id/lib/useId.esm.js","webpack:///./node_modules/deepmerge/dist/umd.js"],"names":["tabbableNode","focusSelector","getElementTabIndex","element","tabIndex","getAttribute","undefined","parseInt","focusable","nodeName","toLowerCase","isTabIndexNotNaN","isNaN","test","disabled","HTMLAnchorElement","href","el","parentElement","document","body","offsetWidth","offsetHeight","style","display","parentNode","visible","tabbable","findTabbableDescendants","Array","from","querySelectorAll","filter","focusLaterElements","focusElement","needToFocus","handleBlur","handleFocus","contains","activeElement","focus","active","options","ref","restoreAria","setRef","node","current","toFocus","pop","e","console","warn","join","returnFocus","removeEventListener","addEventListener","push","processNode","disableAriaHider","containerNode","selector","rootNodes","map","ariaHidden","setAttribute","forEach","item","removeAttribute","createAriaHider","querySelector","children","find","setTimeout","ownerDocument","handleKeyDown","event","key","length","shiftKey","preventDefault","target","scopeTab","vanilla","require","react","Object","keys","k","prototype","hasOwnProperty","call","exports","defineProperty","enumerable","get","keyCount","defaultStore","hasInitialValue","atom","isActuallyWritableAtom","write","cancelPromiseMap","WeakMap","cancelPromise","promise","next","cancel","delete","resolvePromise","value","status","rejectPromise","reason","isEqualAtomValue","a","b","is","v","isEqualAtomError","hasPromiseAtomValue","Promise","returnAtomValue","atomState","createStore","atomStateMap","mountedMap","pendingMap","Map","getAtomState","setAtomState","prevAtomState","set","has","_next","resolve","reject","updateDependencies","nextAtomState","nextDependencies","dependencies","changed","aState","d","size","setAtomValue","orig","setAtomValueOrPromise","valueOrPromise","abortPromise","x","then","continuePromise","updatePromiseDependencies","mountDependencies","settled","catch","finally","registerCancelPromise","readAtomState","force","every","_ref","s","controller","setSelf","isSync","AbortController","signal","_len","arguments","args","_key","writeAtom","apply","concat","read","_aState","init","Error","_controller","abort","error","setAtomError","canUnmountAtom","mounted","l","t","recomputeDependents","dependencyMap","dirtyMap","getDependents","_mountedMap$get","dependents","Set","_","pendingAtom","_getAtomState","add","loop1","dependent","loop2","dirtyCount","_dependencyMap$get","isChanged","writeAtomState","getter","setter","r","_len3","_key3","flushPending","process","_len2","_key2","result","_len4","_key4","mountAtom","initialDependent","onMountQueue","_getAtomState2","queue","aMounted","onMount","onUnmount","_len5","_key5","u","f","unmountAtom","_mountedMap$get2","prevDependencies","depSet","pending","clear","_ref2","listener","sub","addAtom","listeners","delAtom","config","toString","this","arg","getDefaultStore","clientHydrated","module","self","global","ReactExports","StoreContext","createContext","useStore","store","useContext","use","useAtomValue","_useReducer","useReducer","prev","nextValue","_useReducer$","valueFromReducer","storeFromReducer","atomFromReducer","rerender","delay","useEffect","unsub","useDebugValue","useSetAtom","useCallback","Provider","storeRef","useRef","createElement","useAtom","Context","fallbackId","localGenerateId","IdProvider","props","generateId","prefix","_useState","id","setId","isMergeableObject","isNonNullObject","stringValue","$$typeof","REACT_ELEMENT_TYPE","isReactElement","isSpecial","Symbol","for","cloneUnlessOtherwiseSpecified","clone","deepmerge","val","isArray","defaultArrayMerge","source","getKeys","getOwnPropertySymbols","symbol","propertyIsEnumerable","getEnumerableOwnPropertySymbols","mergeObject","destination","customMerge","getMergeFunction","arrayMerge","sourceIsArray","all","array","reduce","factory"],"mappings":"4FAAA,WAaIA,EAAe,sCACfC,EAAgB,yDAmBpB,SAASC,EAAmBC,GAC1B,IAAIC,EAAWD,EAAQE,aAAa,YAEpC,OADiB,OAAbD,IAAmBA,OAAWE,GAC3BC,SAASH,EAAU,IAG5B,SAASI,EAAUL,GACjB,IAAIM,EAAWN,EAAQM,SAASC,cAC5BC,GAAoBC,MAAMV,EAAmBC,IAGjD,OADAH,EAAaa,KAAKJ,KAAcN,EAAQW,UAAaX,aAAmBY,mBAAoBZ,EAAQa,MAA2BL,IAtBjI,SAAiBR,GAGf,IAFA,IANcc,EAMVC,EAAgBf,EAEbe,GACDA,IAAkBC,SAASC,MADX,CAEpB,IAVYH,EAUDC,GARHG,aAAe,GAAKJ,EAAGK,cAAgB,GAA0B,SAArBL,EAAGM,MAAMC,QAQlC,OAAO,EAClCN,EAAgBA,EAAcO,WAGhC,OAAO,EAcOC,CAAQvB,GAExB,SAASwB,EAASxB,GAChB,IAAIC,EAAWF,EAAmBC,GAElC,OADoBS,MAAMR,IACDA,GAAY,IAAMI,EAAUL,GAMvD,SAASyB,EAAwBzB,GAC/B,OAAO0B,MAAMC,KAAK3B,EAAQ4B,iBAAiB9B,IAAgB+B,OAAOL,GAGpE,IAAIM,EAAqB,GACrBC,EAAe,KACfC,GAAc,EAElB,SAASC,IACPD,GAAc,EAGhB,SAASE,IACP,GAAIF,EAAa,CAGf,GAFAA,GAAc,GAETD,EACH,OAGF,IAAKA,EAAc,OAEnB,GAAIA,EAAaI,SAASnB,SAASoB,eACjC,QAGOX,EAAwBM,GAAc,IAAMA,GAClDM,SAmLQ,IAvFf,SAAsBC,EAAQC,QACb,IAAXD,IACFA,GAAS,QAGK,IAAZC,IACFA,EAAU,IAGZ,IAAIC,EAAM,mBACNC,EAAc,iBAAO,MACrBC,EAAS,uBAAY,SAAUC,GAUjC,GATIF,EAAYG,SACdH,EAAYG,UAGVJ,EAAII,WArGZ,WACE,IAAIC,EAAU,KAEd,KACEA,EAAUf,EAAmBgB,QAChBD,EAAQR,QACrB,MAAOU,GAEPC,QAAQC,KAAK,CAAC,+BAAgCJ,EAAS,oCAAoCK,KAAK,OA8F9FC,GArFJpB,EAAe,KACff,SAASoC,oBAAoB,WAAYnB,GACzCjB,SAASoC,oBAAoB,UAAWlB,IAuFlCI,GAAUK,EAAM,CA9FtBZ,EA+FqBY,EA9FrB3B,SAASqC,iBAAiB,WAAYpB,GAAY,GAClDjB,SAASqC,iBAAiB,UAAWnB,GAAa,GAhBlDJ,EAAmBwB,KAAKtC,SAASoB,eAgH7B,IAAImB,EAAc,SAAqBZ,GAErCF,EAAYG,QAAWL,EAAQiB,iBAA2C,KAhElF,SAAyBC,EAAeC,QACrB,IAAbA,IACFA,EAAW,uBAGb,IAAIC,EAAYjC,MAAMC,KAAKX,SAASY,iBAAiB8B,IAAWE,KAAI,SAAUjB,GAC5E,IAAIA,EAAKR,SAASsB,GAAlB,CAIA,IAAII,EAAalB,EAAKzC,aAAa,eAMnC,OAJmB,OAAf2D,GAAsC,UAAfA,GACzBlB,EAAKmB,aAAa,cAAe,QAG5B,CACLnB,KAAMA,EACNkB,WAAYA,OAGhB,OAAO,WACLF,EAAUI,SAAQ,SAAUC,GACrBA,IAEmB,OAApBA,EAAKH,WACPG,EAAKrB,KAAKsB,gBAAgB,eAE1BD,EAAKrB,KAAKmB,aAAa,cAAeE,EAAKH,iBAoCOK,CAAgBvB,GAElE,IAAIZ,EAAe,KAMnB,GAJIQ,EAAQzC,gBACViC,EAAgD,iBAA1BQ,EAAQzC,cAA6B6C,EAAKwB,cAAc5B,EAAQzC,eAAiByC,EAAQzC,gBAG5GiC,EAAc,CACjB,IAAIqC,EAAW1C,MAAMC,KAAKgB,EAAKf,iBAAiB9B,MAChDiC,EACAqC,EAASC,KAAK7C,IACd4C,EAASC,KAAKhE,IACd,OAEqBA,EAAUsC,KAAOZ,EAAeY,GAGnDZ,GAEFA,EAAaM,SAUjBiC,YAAW,WACL3B,EAAK4B,eACPhB,EAAYZ,MAMhBH,EAAII,QAAUD,OAEdH,EAAII,QAAU,OAEf,CAACN,EAAQC,EAAQzC,cAAeyC,EAAQiB,mBAe3C,OAdA,qBAAU,WACR,GAAKlB,EAAL,CAEA,IAAIkC,EAAgB,SAAuBC,GACvB,QAAdA,EAAMC,KAAiBlC,EAAII,SAnIrC,SAAkBD,EAAM8B,GACtB,IAAIjD,EAAWC,EAAwBkB,GAEvC,GAAKnB,EAASmD,QAQd,GAHoBnD,EAASiD,EAAMG,SAAW,EAAIpD,EAASmD,OAAS,KACvB3D,SAASoB,eACtDO,IAAS3B,SAASoB,cAClB,CACAqC,EAAMI,iBACN,IAAIC,EAAStD,EAASiD,EAAMG,SAAWpD,EAASmD,OAAS,EAAI,GACzDG,GAAQA,EAAOzC,cAVjBoC,EAAMI,iBAgIFE,CAASvC,EAAII,QAAS6B,IAK1B,OADAzD,SAASqC,iBAAiB,UAAWmB,GAC9B,WACLxD,SAASoC,oBAAoB,UAAWoB,OAEzC,CAAClC,IACGI,I,iCChQT,IAAIsC,EAAUC,EAAQ,KAClBC,EAAQD,EAAQ,KAIpBE,OAAOC,KAAKJ,GAASjB,SAAQ,SAAUsB,GAC5B,YAANA,GAAoBF,OAAOG,UAAUC,eAAeC,KAAKC,EAASJ,IAAIF,OAAOO,eAAeD,EAASJ,EAAG,CAC3GM,YAAY,EACZC,IAAK,WAAc,OAAOZ,EAAQK,SAGpCF,OAAOC,KAAKF,GAAOnB,SAAQ,SAAUsB,GAC1B,YAANA,GAAoBF,OAAOG,UAAUC,eAAeC,KAAKC,EAASJ,IAAIF,OAAOO,eAAeD,EAASJ,EAAG,CAC3GM,YAAY,EACZC,IAAK,WAAc,OAAOV,EAAMG,U,iCCdlC,IAAIQ,EAAW,EAyDf,IAwlBIC,EAxlBAC,EAAkB,SAAyBC,GAC7C,MAAO,SAAUA,GAEfC,EAAyB,SAAgCD,GAC3D,QAASA,EAAKE,OAEZC,EAAmB,IAAIC,QAOvBC,EAAgB,SAAuBC,EAASC,GAClD,IAAIC,EAASL,EAAiBP,IAAIU,GAC9BE,IACFL,EAAiBM,OAAOH,GACxBE,EAAOD,KAGPG,EAAiB,SAAwBJ,EAASK,GACpDL,EAAQM,OAAS,YACjBN,EAAQK,MAAQA,GAEdE,EAAgB,SAAuBP,EAASvD,GAClDuD,EAAQM,OAAS,WACjBN,EAAQQ,OAAS/D,GAKfgE,EAAmB,SAA0BC,EAAGC,GAClD,QAASD,GAAK,MAAOA,GAAK,MAAOC,GAAK9B,OAAO+B,GAAGF,EAAEG,EAAGF,EAAEE,IAErDC,EAAmB,SAA0BJ,EAAGC,GAClD,QAASD,GAAK,MAAOA,GAAK,MAAOC,GAAK9B,OAAO+B,GAAGF,EAAEjE,EAAGkE,EAAElE,IAErDsE,EAAsB,SAA6BL,GACrD,QAASA,GAAK,MAAOA,GAAKA,EAAEG,aAAaG,SAKvCC,EAAkB,SAAyBC,GAC7C,GAAI,MAAOA,EACT,MAAMA,EAAUzE,EAElB,OAAOyE,EAAUL,GAEfM,EAAc,WAChB,IAAIC,EAAe,IAAItB,QACnBuB,EAAa,IAAIvB,QACjBwB,EAAa,IAAIC,IAOrB,IAAIC,EAAe,SAAsB9B,GACvC,OAAO0B,EAAa9B,IAAII,IAEtB+B,EAAe,SAAsB/B,EAAMwB,GAI7C,IAAIQ,EAAgBN,EAAa9B,IAAII,GAKrC,GAJA0B,EAAaO,IAAIjC,EAAMwB,GAClBI,EAAWM,IAAIlC,IAClB4B,EAAWK,IAAIjC,EAAMgC,GAEnBX,EAAoBW,GAAgB,CACtC,IAAIG,EAAQ,MAAOX,EAAYA,EAAUL,aAAaG,QAAUE,EAAUL,EAAIG,QAAQc,QAAQZ,EAAUL,GAAKG,QAAQe,OAAOb,EAAUzE,GAClIiF,EAAcb,IAAMgB,GACtB9B,EAAc2B,EAAcb,EAAGgB,KAIjCG,EAAqB,SAA4BtC,EAAMuC,EAAeC,GACxE,IAAIC,EAAe,IAAIZ,IACnBa,GAAU,EACdF,EAAiBzE,SAAQ,SAAU4E,EAAQ3B,GACpC2B,GAAU3B,IAAMhB,IACnB2C,EAASJ,GAEPI,IACFF,EAAaR,IAAIjB,EAAG2B,GAChBJ,EAAcK,EAAEhD,IAAIoB,KAAO2B,IAC7BD,GAAU,QAMZA,GAAWH,EAAcK,EAAEC,OAASJ,EAAaI,QACnDN,EAAcK,EAAIH,IAGlBK,EAAe,SAAsB9C,EAAMW,EAAO6B,GACpD,IA3D2DxB,EAAGC,EA2D1De,EAAgBF,EAAa9B,GAC7BuC,EAAgB,CAClBK,GAAqB,MAAjBZ,OAAwB,EAASA,EAAcY,IAAM,IAAIf,IAC7DV,EAAGR,GAKL,GAHI6B,GACFF,EAAmBtC,EAAMuC,EAAeC,GAEtCzB,EAAiBiB,EAAeO,IAAkBP,EAAcY,IAAML,EAAcK,EACtF,OAAOZ,EAET,GAAIX,EAAoBW,IAAkBX,EAAoBkB,KAtEAtB,EAsEyDsB,EArElH,MADsDvB,EAsE6CgB,IArEvF,MAAOf,GAAKD,EAAEG,EAAE4B,MAAQ/B,EAAEG,EAAE4B,OAAS9B,EAAEE,EAAE4B,MAqE6E,CACrI,GAAIf,EAAcY,IAAML,EAAcK,EACpC,OAAOZ,EAEPO,EAAcpB,EAAIa,EAAcb,EAIpC,OADAY,EAAa/B,EAAMuC,GACZA,GAELS,EAAwB,SAA+BhD,EAAMiD,EAAgBT,EAAkBU,GACjG,GA5F8C,mBAA5B,OADqBC,EA6FrBF,QA5FO,EAASE,EAAEC,MA4FD,CACjC,IAAIC,EACAC,EAA4B,WAC9B,IAAItB,EAAgBF,EAAa9B,GACjC,GAAKqB,EAAoBW,IAAkBA,EAAcb,IAAMb,EAA/D,CAGA,IAAIiC,EAAgBO,EAAa9C,EAAMM,EAASkC,GAC5Cb,EAAWO,IAAIlC,IAASgC,EAAcY,IAAML,EAAcK,GAC5DW,EAAkBvD,EAAMuC,EAAeP,EAAcY,KAGrDtC,EAAU,IAAIgB,SAAQ,SAAUc,EAASC,GAC3C,IAAImB,GAAU,EACdP,EAAeG,MAAK,SAAUjC,GACvBqC,IACHA,GAAU,EACV9C,EAAeJ,EAASa,GACxBiB,EAAQjB,GACRmC,QAED,SAAUvG,GACNyG,IACHA,GAAU,EACV3C,EAAcP,EAASvD,GACvBsF,EAAOtF,GACPuG,QAGJD,EAAkB,SAAyB9C,GACpCiD,IACHA,GAAU,EACVjD,EAAK6C,MAAK,SAAUjC,GAClB,OAAOT,EAAeJ,EAASa,MAC9B,SAAUpE,GACX,OAAO8D,EAAcP,EAASvD,MAEhCqF,EAAQ7B,QAYd,OARAD,EAAQyC,KAAOE,EACf3C,EAAQM,OAAS,UA5JK,SAA+BN,EAASE,GAClEL,EAAiB8B,IAAI3B,EAASE,GAC9BF,EAAQmD,OAAM,eAAgBC,SAAQ,WACpC,OAAOvD,EAAiBM,OAAOH,MA0J7BqD,CAAsBrD,GAAS,SAAUC,GACnCA,GACF8C,EAAgB9C,GAEF,MAAhB2C,GAAwBA,OAEnBJ,EAAa9C,EAAMM,EAASkC,GA9IrB,IAAuBW,EAgJvC,OAAOL,EAAa9C,EAAMiD,EAAgBT,IAiBxCoB,EAAgB,SAASA,EAAc5D,EAAM6D,GAC/C,IAAIrC,EAAYM,EAAa9B,GAC7B,IAAK6D,GAASrC,EAAW,CACvB,GAAIG,EAAWO,IAAIlC,GACjB,OAAOwB,EAET,GAAI9F,MAAMC,KAAK6F,EAAUoB,GAAGkB,OAAM,SAAUC,GAC1C,IAAI/C,EAAI+C,EAAK,GACXC,EAAID,EAAK,GACX,GAAI/C,IAAMhB,EACR,OAAO,EAET,IAAI2C,EAASiB,EAAc5C,GAC3B,OAAO2B,IAAWqB,GAAKjD,EAAiB4B,EAAQqB,MAEhD,OAAOxC,EAGX,IAmBIyC,EACAC,EApBA1B,EAAmB,IAAIX,IACvBsC,GAAS,EAoBT5H,EAAU,CACZ,aAIE,OAHK0H,IACHA,EAAa,IAAIG,iBAEZH,EAAWI,QAEpB,cAiBE,OAbKH,GAAWjE,EAAuBD,KACrCkE,EAAU,WAIR,IAAKC,EAAQ,CACX,IAAK,IAAIG,EAAOC,UAAU5F,OAAQ6F,EAAO,IAAI9I,MAAM4I,GAAOG,EAAO,EAAGA,EAAOH,EAAMG,IAC/ED,EAAKC,GAAQF,UAAUE,GAEzB,OAAOC,EAAUC,WAAM,EAAQ,CAAC3E,GAAM4E,OAAOJ,OAI5CN,IAGX,IACE,IAAIjB,EAAiBjD,EAAK6E,MA/Cf,SAAgB7D,GAC3B,GAAIA,IAAMhB,EAAM,CACd,IAAI8E,EAAUhD,EAAad,GAC3B,GAAI8D,EAEF,OADAtC,EAAiBP,IAAIjB,EAAG8D,GACjBvD,EAAgBuD,GAEzB,GAAI/E,EAAgBiB,GAElB,OADAwB,EAAiBP,IAAIjB,OAAG7G,GACjB6G,EAAE+D,KAEX,MAAM,IAAIC,MAAM,gBAElB,IAAIrC,EAASiB,EAAc5C,GAE3B,OADAwB,EAAiBP,IAAIjB,EAAG2B,GACjBpB,EAAgBoB,KAgCgBpG,GACvC,OAAOyG,EAAsBhD,EAAMiD,EAAgBT,GAAkB,WACnE,IAAIyC,EACJ,OAAqC,OAA7BA,EAAchB,QAAsB,EAASgB,EAAYC,WAEnE,MAAOC,GACP,OAxFe,SAAsBnF,EAAMmF,EAAO3C,GACpD,IAAIR,EAAgBF,EAAa9B,GAC7BuC,EAAgB,CAClBK,GAAqB,MAAjBZ,OAAwB,EAASA,EAAcY,IAAM,IAAIf,IAC7D9E,EAAGoI,GAKL,OAHI3C,GACFF,EAAmBtC,EAAMuC,EAAeC,GAEtCpB,EAAiBY,EAAeO,IAAkBP,EAAcY,IAAML,EAAcK,EAC/EZ,GAETD,EAAa/B,EAAMuC,GACZA,GA2EE6C,CAAapF,EAAMmF,EAAO3C,GACjC,QACA2B,GAAS,IAaTkB,EAAiB,SAAwBrF,EAAMsF,GACjD,OAAQA,EAAQC,EAAE1C,QAAUyC,EAAQE,EAAE3C,MAA2B,IAAnByC,EAAQE,EAAE3C,MAAcyC,EAAQE,EAAEtD,IAAIlC,KAQlFyF,EAAsB,SAA6BzF,GACrD,IAAI0F,EAAgB,IAAI7D,IACpB8D,EAAW,IAAIvF,QACfwF,EAAgB,SAAuB5E,GACzC,IAAI6E,EACAC,EAAa,IAAIC,IAA6C,OAAxCF,EAAkBlE,EAAW/B,IAAIoB,SAAc,EAAS6E,EAAgBL,GAOlG,OANA5D,EAAW7D,SAAQ,SAAUiI,EAAGC,GAC9B,IAAIC,EAC+C,OAA9CA,EAAgBpE,EAAamE,KAAyBC,EAActD,EAAEV,IAAIlB,IAC7E8E,EAAWK,IAAIF,MAGZH,IAEG,SAASM,EAAMpF,GACzB4E,EAAc5E,GAAGjD,SAAQ,SAAUsI,GAC7BA,IAAcrF,IAChB0E,EAAczD,IAAIoE,GAAYX,EAAc9F,IAAIyG,IAAc,IAAIN,KAAOI,IAAInF,IAC7E2E,EAAS1D,IAAIoE,GAAYV,EAAS/F,IAAIyG,IAAc,GAAK,GACzDD,EAAMC,OAIZD,CAAMpG,IACM,SAASsG,EAAMtF,GACzB4E,EAAc5E,GAAGjD,SAAQ,SAAUsI,GACjC,GAAIA,IAAcrF,EAAG,CACnB,IAAIuF,EAAaZ,EAAS/F,IAAIyG,GAI9B,GAHIE,GACFZ,EAAS1D,IAAIoE,IAAaE,IAEvBA,EAAY,CACf,IAAIC,EACAC,IAAsE,OAAtDD,EAAqBd,EAAc9F,IAAIyG,MAAuBG,EAAmB3D,MACrG,GAAI4D,EAAW,CACb,IAAIzE,EAAgBF,EAAauE,GAC7B9D,EAAgBqB,EAAcyC,GAAW,GAC7CI,GAAa1F,EAAiBiB,EAAeO,GAE1CkE,GACHf,EAAc3H,SAAQ,SAAUiG,GAC9B,OAAOA,EAAEvD,OAAO4F,MAItBC,EAAMD,OAIZC,CAAMtG,IAEJ0G,EAAiB,SAASA,EAAe1G,GAmC3C,IAlCA,IAAImE,GAAS,EACTwC,EAAS,SAAgB3F,GAC3B,OAAOO,EAAgBqC,EAAc5C,KAEnC4F,EAAS,SAAgB5F,GAE3B,IADA,IAAI6F,EACKC,EAAQvC,UAAU5F,OAAQ6F,EAAO,IAAI9I,MAAMoL,EAAQ,EAAIA,EAAQ,EAAI,GAAIC,EAAQ,EAAGA,EAAQD,EAAOC,IACxGvC,EAAKuC,EAAQ,GAAKxC,UAAUwC,GAE9B,GAAI/F,IAAMhB,EAAM,CACd,IAAKD,EAAgBiB,GACnB,MAAM,IAAIgE,MAAM,qBAElB,IAAIhD,EAAgBF,EAAad,GAC7BuB,EAAgBS,EAAsBhC,EAAGwD,EAAK,IAC7CzD,EAAiBiB,EAAeO,IACnCkD,EAAoBzE,QAGtB6F,EAAIH,EAAe/B,WAAM,EAAQ,CAAC3D,GAAG4D,OAAOJ,IAE9C,IAAKL,EAAQ,CACG6C,IACVC,EASN,OAAOJ,GAEAK,EAAQ3C,UAAU5F,OAAQ6F,EAAO,IAAI9I,MAAMwL,EAAQ,EAAIA,EAAQ,EAAI,GAAIC,EAAQ,EAAGA,EAAQD,EAAOC,IACxG3C,EAAK2C,EAAQ,GAAK5C,UAAU4C,GAE9B,IAAIC,EAASpH,EAAKE,MAAMyE,MAAM3E,EAAM,CAAC2G,EAAQC,GAAQhC,OAAOJ,IAE5D,OADAL,GAAS,EACFiD,GAEL1C,EAAY,SAAmB1E,GACjC,IAAK,IAAIqH,EAAQ9C,UAAU5F,OAAQ6F,EAAO,IAAI9I,MAAM2L,EAAQ,EAAIA,EAAQ,EAAI,GAAIC,EAAQ,EAAGA,EAAQD,EAAOC,IACxG9C,EAAK8C,EAAQ,GAAK/C,UAAU+C,GAE9B,IAAIF,EAASV,EAAe/B,WAAM,EAAQ,CAAC3E,GAAM4E,OAAOJ,IAC1CwC,IASd,OAAOI,GAELG,EAAY,SAASA,EAAUvH,EAAMwH,EAAkBC,GACzD,IAAIC,EACAC,EAAQF,GAAgB,GACa,OAAxCC,EAAiB5F,EAAa9B,KAAkB0H,EAAe9E,EAAE7E,SAAQ,SAAUiI,EAAGhF,GACrF,IAAI4G,EAAWjG,EAAW/B,IAAIoB,GAC1B4G,EACFA,EAASpC,EAAEW,IAAInG,GAEXgB,IAAMhB,GACRuH,EAAUvG,EAAGhB,EAAM2H,MAIzB/D,EAAc5D,GACd,IAAIsF,EAAU,CACZE,EAAG,IAAIO,IAAIyB,GAAoB,CAACA,IAChCjC,EAAG,IAAIQ,KAMT,GAJApE,EAAWM,IAAIjC,EAAMsF,GAIjBrF,EAAuBD,IAASA,EAAK6H,QAAS,CAChD,IAAIA,EAAU7H,EAAK6H,QACnBF,EAAMrK,MAAK,WACT,IAAIwK,EAAYD,GAAQ,WACtB,IAAK,IAAIE,EAAQxD,UAAU5F,OAAQ6F,EAAO,IAAI9I,MAAMqM,GAAQC,EAAQ,EAAGA,EAAQD,EAAOC,IACpFxD,EAAKwD,GAASzD,UAAUyD,GAE1B,OAAOtD,EAAUC,WAAM,EAAQ,CAAC3E,GAAM4E,OAAOJ,OAE3CsD,IACFxC,EAAQ2C,EAAIH,MASlB,OALKL,GACHE,EAAM5J,SAAQ,SAAUmK,GACtB,OAAOA,OAGJ5C,GAEL6C,EAAc,SAASA,EAAYnI,GACrC,IAAIoI,EACAN,EAAyD,OAA5CM,EAAmBzG,EAAW/B,IAAII,SAAiB,EAASoI,EAAiBH,EAC1FH,GACFA,IAEFnG,EAAWlB,OAAOT,GAIlB,IAAIwB,EAAYM,EAAa9B,GACzBwB,IACEH,EAAoBG,IACtBnB,EAAcmB,EAAUL,GAE1BK,EAAUoB,EAAE7E,SAAQ,SAAUiI,EAAGhF,GAC/B,GAAIA,IAAMhB,EAAM,CACd,IAAIsF,EAAU3D,EAAW/B,IAAIoB,GACzBsE,IACFA,EAAQE,EAAE/E,OAAOT,GACbqF,EAAerE,EAAGsE,IACpB6C,EAAYnH,UASpBuC,EAAoB,SAA2BvD,EAAMwB,EAAW6G,GAClE,IAAIC,EAAS,IAAIvC,IAAIvE,EAAUoB,EAAExD,QACb,MAApBiJ,GAA4BA,EAAiBtK,SAAQ,SAAUiI,EAAGhF,GAChE,GAAIsH,EAAOpG,IAAIlB,GACbsH,EAAO7H,OAAOO,OADhB,CAIA,IAAIsE,EAAU3D,EAAW/B,IAAIoB,GACzBsE,IACFA,EAAQE,EAAE/E,OAAOT,GACbqF,EAAerE,EAAGsE,IACpB6C,EAAYnH,QAIlBsH,EAAOvK,SAAQ,SAAUiD,GACvB,IAAIsE,EAAU3D,EAAW/B,IAAIoB,GACzBsE,EACFA,EAAQE,EAAEW,IAAInG,GACL2B,EAAWO,IAAIlC,IACxBuH,EAAUvG,EAAGhB,OAIfgH,EAAe,WAKjB,IAHIC,EAGGrF,EAAWiB,MAAM,CACtB,IAAI0F,EAAU7M,MAAMC,KAAKiG,GACzBA,EAAW4G,QACXD,EAAQxK,SAAQ,SAAU0K,GACxB,IAAIzI,EAAOyI,EAAM,GACfzG,EAAgByG,EAAM,GACpBjH,EAAYM,EAAa9B,GAC7B,GAAIwB,EAAW,CACb,IAAI8D,EAAU3D,EAAW/B,IAAII,GACzBsF,GAAW9D,EAAUoB,KAAwB,MAAjBZ,OAAwB,EAASA,EAAcY,IAC7EW,EAAkBvD,EAAMwB,EAA4B,MAAjBQ,OAAwB,EAASA,EAAcY,GAEhF0C,IAAcjE,EAAoBW,KAAmBjB,EAAiBiB,EAAeR,KAAcJ,EAAiBY,EAAeR,KACrI8D,EAAQC,EAAExH,SAAQ,SAAU2K,GAC1B,OAAOA,YAMFzB,OA6EjB,MAAO,CACLrH,IAxUa,SAAkBI,GAC/B,OAAOuB,EAAgBqC,EAAc5D,KAwUrCiC,IAAKyC,EACLiE,IAvEkB,SAAuB3I,EAAM0I,GAC/C,IAAIpD,EAjQQ,SAAiBtF,GAC7B,IAAIsF,EAAU3D,EAAW/B,IAAII,GAI7B,OAHKsF,IACHA,EAAUiC,EAAUvH,IAEfsF,EA4POsD,CAAQ5I,GAElB6I,GADU7B,IACE1B,EAAQC,GAUxB,OATAsD,EAAU1C,IAAIuC,GASP,WACLG,EAAUpI,OAAOiI,GApQP,SAAiB1I,GAC7B,IAAIsF,EAAU3D,EAAW/B,IAAII,GACzBsF,GAAWD,EAAerF,EAAMsF,IAClC6C,EAAYnI,GAkQZ8I,CAAQ9I,OA6EdP,EAAQO,KAlqBR,SAAc6E,EAAM3E,GAClB,IAAIxB,EAAM,UAAWmB,EACjBkJ,EAAS,CACXC,SAAU,WACR,OAAOtK,IAiBX,MAdoB,mBAATmG,EACTkE,EAAOlE,KAAOA,GAEdkE,EAAOhE,KAAOF,EACdkE,EAAOlE,KAAO,SAAUjF,GACtB,OAAOA,EAAIqJ,OAEbF,EAAO7I,MAAQ,SAAUN,EAAKqC,EAAKiH,GACjC,OAAOjH,EAAIgH,KAAqB,mBAARC,EAAqBA,EAAItJ,EAAIqJ,OAASC,KAG9DhJ,IACF6I,EAAO7I,MAAQA,GAEV6I,GA8oBTtJ,EAAQgC,YAAcA,EACtBhC,EAAQ0J,gBAZc,WAOpB,OANKrJ,IAIHA,EAAe2B,KAEV3B,I,iCClqBT,WAEIsJ,GAAiB,EAcN,IAPf,WAIE,OAHA,qBAAU,WACHA,IAAgBA,GAAiB,KACrC,IACIA,I,kCCbT,YACAC,EAAO5J,QAA2B,iBAAT6J,MAAqBA,KAAKA,OAASA,MAAQA,MAC/C,iBAAXC,GAAuBA,EAAOA,SAAWA,GAAUA,GAC3DN,O,sCCFF,aAEA,IAAIO,EAAevK,EAAQ,GACvBD,EAAUC,EAAQ,KAElBwK,EAAeD,EAAaE,mBAAcvP,GAC1CwP,EAAW,SAAkBpN,GAC/B,IAAIqN,EAAQJ,EAAaK,WAAWJ,GACpC,OAAmB,MAAXlN,OAAkB,EAASA,EAAQqN,QAAUA,GAAS5K,EAAQmK,mBAiBpEW,EAAMN,EAAaM,KAAO,SAAUxJ,GACtC,GAAuB,YAAnBA,EAAQM,OACV,MAAMN,EACD,GAAuB,cAAnBA,EAAQM,OACjB,OAAON,EAAQK,MACV,KAAuB,aAAnBL,EAAQM,OACXN,EAAQQ,QAEdR,EAAQM,OAAS,UACjBN,EAAQ8C,MAAK,SAAUjC,GACrBb,EAAQM,OAAS,YACjBN,EAAQK,MAAQQ,KACf,SAAUpE,GACXuD,EAAQM,OAAS,WACjBN,EAAQQ,OAAS/D,KAEbuD,IAGV,SAASyJ,EAAa/J,EAAMzD,GAC1B,IAAIqN,EAAQD,EAASpN,GACjByN,EAAcR,EAAaS,YAAW,SAAUC,GAChD,IAAIC,EAAYP,EAAMhK,IAAII,GAC1B,OAAIb,OAAO+B,GAAGgJ,EAAK,GAAIC,IAAcD,EAAK,KAAON,GAASM,EAAK,KAAOlK,EAC7DkK,EAEF,CAACC,EAAWP,EAAO5J,UACzB7F,GAAW,WACZ,MAAO,CAACyP,EAAMhK,IAAII,GAAO4J,EAAO5J,MAElCoK,EAAeJ,EAAY,GAC3BK,EAAmBD,EAAa,GAChCE,EAAmBF,EAAa,GAChCG,EAAkBH,EAAa,GAC/BI,EAAWR,EAAY,GACrBrJ,EAAQ0J,EACRC,IAAqBV,GAASW,IAAoBvK,IACpDwK,IACA7J,EAAQiJ,EAAMhK,IAAII,IAEpB,IA3CyCmD,EA2CrCsH,EAAmB,MAAXlO,OAAkB,EAASA,EAAQkO,MAa/C,OAZAjB,EAAakB,WAAU,WACrB,IAAIC,EAAQf,EAAMjB,IAAI3I,GAAM,WACL,iBAAVyK,EAIXD,IAHElM,WAAWkM,EAAUC,MAMzB,OADAD,IACOG,IACN,CAACf,EAAO5J,EAAMyK,IACjBjB,EAAaoB,cAAcjK,GAtDqB,mBAA5B,OADqBwC,EAwDpBxC,QAvDM,EAASwC,EAAEC,MAuDR0G,EAAInJ,GAASA,EAG7C,SAASkK,EAAW7K,EAAMzD,GACxB,IAAIqN,EAAQD,EAASpN,GAUrB,OATciN,EAAasB,aAAY,WAIrC,IAAK,IAAIxG,EAAOC,UAAU5F,OAAQ6F,EAAO,IAAI9I,MAAM4I,GAAOG,EAAO,EAAGA,EAAOH,EAAMG,IAC/ED,EAAKC,GAAQF,UAAUE,GAEzB,OAAOmF,EAAM3H,IAAI0C,MAAMiF,EAAO,CAAC5J,GAAM4E,OAAOJ,MAC3C,CAACoF,EAAO5J,IAQbP,EAAQsL,SAzFO,SAAkBhH,GAC/B,IAAI3F,EAAW2F,EAAK3F,SAClBwL,EAAQ7F,EAAK6F,MACXoB,EAAWxB,EAAayB,SAI5B,OAHKrB,GAAUoB,EAASpO,UACtBoO,EAASpO,QAAUoC,EAAQyC,eAEtB+H,EAAa0B,cAAczB,EAAasB,SAAU,CACvDpK,MAAOiJ,GAASoB,EAASpO,SACxBwB,IAiFLqB,EAAQ0L,QALR,SAAiBnL,EAAMzD,GACrB,MAAO,CAACwN,EAAa/J,EAAMzD,GAAUsO,EAAW7K,EAAMzD,KAKxDkD,EAAQsK,aAAeA,EACvBtK,EAAQoL,WAAaA,EACrBpL,EAAQkK,SAAWA,G,iCCxGnB,sDAGIyB,EAAuB,6BAAcjR,GAErCkR,EAAa,EAEbC,EAAkB,WACpB,SAAUD,GAAYrC,YAMpBuC,EAAa,SAAoBC,GACnC,IAAIhP,EAAM,iBAAO,GACbiP,EAAa,uBAAY,WAC3B,SAAUjP,EAAII,SAASoM,aACtB,IACH,OAAoB,wBAAcoC,EAAQL,SAAU,CAClDpK,MAAO8K,GACND,EAAMpN,WA2BI,IApBH,SAAesN,GACzB,IAAItC,EAAiB,cACjBqC,EAAa,qBAAWL,GAExBO,EAAY,mBAASF,EAAaA,IAAerC,EAAiBkC,SAAoBnR,GACtFyR,EAAKD,EAAU,GACfE,EAAQF,EAAU,GAUtB,GARA,qBAAU,WAEHC,GACHC,EAAMP,OAGP,IAEEM,EACL,OAAOF,EAASA,EAAS,IAAME,EAAKA,I,oBC5C0BvC,EAAO5J,QAG/D,WAAc,aAErB,IAAIqM,EAAoB,SAA2BnL,GAClD,OAID,SAAyBA,GACxB,QAASA,GAA0B,iBAAVA,EALlBoL,CAAgBpL,KAQxB,SAAmBA,GAClB,IAAIqL,EAAc7M,OAAOG,UAAU0J,SAASxJ,KAAKmB,GAEjD,MAAuB,oBAAhBqL,GACa,kBAAhBA,GAQL,SAAwBrL,GACvB,OAAOA,EAAMsL,WAAaC,EARtBC,CAAexL,GAZdyL,CAAUzL,IAiBZuL,EADiC,mBAAXG,QAAyBA,OAAOC,IAClBD,OAAOC,IAAI,iBAAmB,MAUtE,SAASC,EAA8B5L,EAAOpE,GAC7C,OAA0B,IAAlBA,EAAQiQ,OAAmBjQ,EAAQuP,kBAAkBnL,GAC1D8L,GANiBC,EAMK/L,EALlBjF,MAAMiR,QAAQD,GAAO,GAAK,IAKA/L,EAAOpE,GACrCoE,EAPJ,IAAqB+L,EAUrB,SAASE,EAAkB9N,EAAQ+N,EAAQtQ,GAC1C,OAAOuC,EAAO8F,OAAOiI,GAAQjP,KAAI,SAAS5D,GACzC,OAAOuS,EAA8BvS,EAASuC,MAoBhD,SAASuQ,EAAQhO,GAChB,OAAOK,OAAOC,KAAKN,GAAQ8F,OAT5B,SAAyC9F,GACxC,OAAOK,OAAO4N,sBACX5N,OAAO4N,sBAAsBjO,GAAQjD,QAAO,SAASmR,GACtD,OAAOlO,EAAOmO,qBAAqBD,MAElC,GAI+BE,CAAgCpO,IAGnE,SAASqO,EAAYrO,EAAQ+N,EAAQtQ,GACpC,IAAI6Q,EAAc,GAalB,OAZI7Q,EAAQuP,kBAAkBhN,IAC7BgO,EAAQhO,GAAQf,SAAQ,SAASW,GAChC0O,EAAY1O,GAAO6N,EAA8BzN,EAAOJ,GAAMnC,MAGhEuQ,EAAQD,GAAQ9O,SAAQ,SAASW,GAC3BnC,EAAQuP,kBAAkBe,EAAOnO,KAAUI,EAAOJ,GAGtD0O,EAAY1O,GA/Bf,SAA0BA,EAAKnC,GAC9B,IAAKA,EAAQ8Q,YACZ,OAAOZ,EAER,IAAIY,EAAc9Q,EAAQ8Q,YAAY3O,GACtC,MAA8B,mBAAhB2O,EAA6BA,EAAcZ,EA0BpCa,CAAiB5O,EAAKnC,EAAtB+Q,CAA+BxO,EAAOJ,GAAMmO,EAAOnO,GAAMnC,GAF5E6Q,EAAY1O,GAAO6N,EAA8BM,EAAOnO,GAAMnC,MAKzD6Q,EAGR,SAASX,EAAU3N,EAAQ+N,EAAQtQ,IAClCA,EAAUA,GAAW,IACbgR,WAAahR,EAAQgR,YAAcX,EAC3CrQ,EAAQuP,kBAAoBvP,EAAQuP,mBAAqBA,EAEzD,IAAI0B,EAAgB9R,MAAMiR,QAAQE,GAIlC,OAFgCW,IADZ9R,MAAMiR,QAAQ7N,GAKvB0O,EACHjR,EAAQgR,WAAWzO,EAAQ+N,EAAQtQ,GAEnC4Q,EAAYrO,EAAQ+N,EAAQtQ,GAJ5BgQ,EAA8BM,EAAQtQ,GAoB/C,OAZAkQ,EAAUgB,IAAM,SAAsBC,EAAOnR,GAC5C,IAAKb,MAAMiR,QAAQe,GAClB,MAAM,IAAI1I,MAAM,qCAGjB,OAAO0I,EAAMC,QAAO,SAASzD,EAAM3J,GAClC,OAAOkM,EAAUvC,EAAM3J,EAAMhE,KAC3B,KAGckQ,EA/G8DmB","file":"static/scripts/66-4f98f97feffd645b7a0f.js","sourcesContent":["import { useRef, useCallback, useEffect } from 'react';\n\n/*!\n * Adapted from jQuery UI core\n *\n * http://jqueryui.com\n *\n * Copyright 2014 jQuery Foundation and other contributors\n * Released under the MIT license.\n * http://jquery.org/license\n *\n * http://api.jqueryui.com/category/ui-core/\n */\nvar tabbableNode = /input|select|textarea|button|object/;\nvar focusSelector = 'a, input, select, textarea, button, object, [tabindex]';\n\nfunction hidden(el) {\n  if (process.env.NODE_ENV === 'test') return false;\n  return el.offsetWidth <= 0 && el.offsetHeight <= 0 || el.style.display === 'none';\n}\n\nfunction visible(element) {\n  var parentElement = element;\n\n  while (parentElement) {\n    if (parentElement === document.body) break;\n    if (hidden(parentElement)) return false;\n    parentElement = parentElement.parentNode;\n  }\n\n  return true;\n}\n\nfunction getElementTabIndex(element) {\n  var tabIndex = element.getAttribute('tabindex');\n  if (tabIndex === null) tabIndex = undefined;\n  return parseInt(tabIndex, 10);\n}\n\nfunction focusable(element) {\n  var nodeName = element.nodeName.toLowerCase();\n  var isTabIndexNotNaN = !isNaN(getElementTabIndex(element));\n  var res = // @ts-ignore\n  tabbableNode.test(nodeName) && !element.disabled || (element instanceof HTMLAnchorElement ? element.href || isTabIndexNotNaN : isTabIndexNotNaN);\n  return res && visible(element);\n}\nfunction tabbable(element) {\n  var tabIndex = getElementTabIndex(element);\n  var isTabIndexNaN = isNaN(tabIndex);\n  return (isTabIndexNaN || tabIndex >= 0) && focusable(element);\n}\n/**\n * Tabbable elements are elements the user can tab between. This excludes elements with tabIndex=-1\n * */\n\nfunction findTabbableDescendants(element) {\n  return Array.from(element.querySelectorAll(focusSelector)).filter(tabbable);\n}\n\nvar focusLaterElements = [];\nvar focusElement = null;\nvar needToFocus = false;\n\nfunction handleBlur() {\n  needToFocus = true;\n}\n\nfunction handleFocus() {\n  if (needToFocus) {\n    needToFocus = false;\n\n    if (!focusElement) {\n      return;\n    }\n\n    if (!focusElement) return;\n\n    if (focusElement.contains(document.activeElement)) {\n      return;\n    }\n\n    var el = findTabbableDescendants(focusElement)[0] || focusElement;\n    el.focus();\n  }\n}\n\nfunction markForFocusLater() {\n  focusLaterElements.push(document.activeElement);\n}\nfunction returnFocus() {\n  var toFocus = null;\n\n  try {\n    toFocus = focusLaterElements.pop();\n    if (toFocus) toFocus.focus();\n  } catch (e) {\n    // eslint-disable-next-line no-console\n    console.warn(['You tried to return focus to', toFocus, 'but it is not in the DOM anymore'].join(' '));\n  }\n}\nfunction setupScopedFocus(element) {\n  focusElement = element;\n  document.addEventListener('focusout', handleBlur, false);\n  document.addEventListener('focusin', handleFocus, true);\n}\nfunction teardownScopedFocus() {\n  focusElement = null;\n  document.removeEventListener('focusout', handleBlur);\n  document.removeEventListener('focusin', handleFocus);\n}\n\n/**\n * Controls tabbing, so it stays inside the node element\n * @param node\n * @param event\n */\n\nfunction scopeTab(node, event) {\n  var tabbable = findTabbableDescendants(node);\n\n  if (!tabbable.length) {\n    event.preventDefault();\n    return;\n  }\n\n  var finalTabbable = tabbable[event.shiftKey ? 0 : tabbable.length - 1];\n  var leavingFinalTabbable = finalTabbable === document.activeElement || // handle immediate shift+tab after opening with mouse\n  node === document.activeElement;\n  if (!leavingFinalTabbable) return;\n  event.preventDefault();\n  var target = tabbable[event.shiftKey ? tabbable.length - 1 : 0];\n  if (target) target.focus();\n}\n\n/**\n * Sets `aria-hidden` on all elements on the body, except for the active node.\n **/\nfunction createAriaHider(containerNode, selector) {\n  if (selector === void 0) {\n    selector = 'body > :not(script)';\n  }\n\n  var rootNodes = Array.from(document.querySelectorAll(selector)).map(function (node) {\n    if (node.contains(containerNode)) {\n      return undefined;\n    }\n\n    var ariaHidden = node.getAttribute('aria-hidden');\n\n    if (ariaHidden === null || ariaHidden === 'false') {\n      node.setAttribute('aria-hidden', 'true');\n    }\n\n    return {\n      node: node,\n      ariaHidden: ariaHidden\n    };\n  });\n  return function () {\n    rootNodes.forEach(function (item) {\n      if (!item) return;\n\n      if (item.ariaHidden === null) {\n        item.node.removeAttribute('aria-hidden');\n      } else {\n        item.node.setAttribute('aria-hidden', item.ariaHidden);\n      }\n    });\n  };\n}\n\n/**\n *  Traps focus to DOM node. Use this with a modal to ensure the user focus doesn't leave.\n * */\nfunction useFocusTrap(active, options) {\n  if (active === void 0) {\n    active = true;\n  }\n\n  if (options === void 0) {\n    options = {};\n  }\n\n  var ref = useRef();\n  var restoreAria = useRef(null);\n  var setRef = useCallback(function (node) {\n    if (restoreAria.current) {\n      restoreAria.current();\n    }\n\n    if (ref.current) {\n      returnFocus();\n      teardownScopedFocus();\n    }\n\n    if (active && node) {\n      setupScopedFocus(node);\n      markForFocusLater();\n\n      var processNode = function processNode(node) {\n        // See if we should disable aria\n        restoreAria.current = !options.disableAriaHider ? createAriaHider(node) : null; // Find the initial focus element\n\n        var focusElement = null;\n\n        if (options.focusSelector) {\n          focusElement = typeof options.focusSelector === 'string' ? node.querySelector(options.focusSelector) : options.focusSelector;\n        }\n\n        if (!focusElement) {\n          var children = Array.from(node.querySelectorAll(focusSelector));\n          focusElement = // Prefer tabbable elements, But fallback to any focusable element\n          children.find(tabbable) || // But fallback to any focusable element\n          children.find(focusable) || // Nothing found\n          null; // If everything else fails, see if the node itself can handle focus\n\n          if (!focusElement && focusable(node)) focusElement = node;\n        }\n\n        if (focusElement) {\n          // Set the initial focus inside the traps\n          focusElement.focus();\n        } else {\n          if (process.env.NODE_ENV === 'development') {\n            // eslint-disable-next-line no-console\n            console.warn('[useFocusTrap]: Failed to find a focusable element after activating the focus trap. Make sure to include at an element that can recieve focus. As a fallback, you can also set \"tabIndex={-1}\" on the focus trap node.', node);\n          }\n        }\n      }; // Delay processing the HTML node by a frame. This ensures focus is assigned correctly.\n\n\n      setTimeout(function () {\n        if (node.ownerDocument) {\n          processNode(node);\n        } else if (process.env.NODE_ENV === 'development') {\n          // eslint-disable-next-line no-console\n          console.warn('[useFocusTrap]: The focus trap is not part of the DOM yet, so it is unable to correctly set focus. Make sure to render the ref node.', node);\n        }\n      });\n      ref.current = node;\n    } else {\n      ref.current = null;\n    }\n  }, [active, options.focusSelector, options.disableAriaHider]);\n  useEffect(function () {\n    if (!active) return undefined;\n\n    var handleKeyDown = function handleKeyDown(event) {\n      if (event.key === 'Tab' && ref.current) {\n        scopeTab(ref.current, event);\n      }\n    };\n\n    document.addEventListener('keydown', handleKeyDown);\n    return function () {\n      document.removeEventListener('keydown', handleKeyDown);\n    };\n  }, [active]);\n  return setRef;\n}\n\nexport default useFocusTrap;\n","'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 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","import { useEffect } from 'react';\n\nvar clientHydrated = false;\n/**\n * Returns false when serverside rendering and during the first render pass (hydration) in the client.\n * Use this to modify behavior of components when they can be certain they are running client side.\n * Like check a media query during the initial render.\n * */\n\nfunction useClientHydrated() {\n  useEffect(function () {\n    if (!clientHydrated) clientHydrated = true;\n  }, []);\n  return clientHydrated;\n}\n\nexport default useClientHydrated;\n","'use strict'\nmodule.exports = (typeof self === 'object' && self.self === self && self) ||\n  (typeof global === 'object' && global.global === global && global) ||\n  this\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","import { useRef, useCallback, createElement, useContext, useState, useEffect, createContext } from 'react';\nimport useClientHydrated from '@charlietango/use-client-hydrated';\n\nvar Context = /*#__PURE__*/createContext(undefined);\n// Client side fallback \"id\" for cases where the application is not surrounded with an <IdProvider />\nvar fallbackId = 0;\n\nvar localGenerateId = function localGenerateId() {\n  return (++fallbackId).toString();\n};\n\nvar resetLocalId = function resetLocalId() {\n  return fallbackId = 0;\n};\nvar IdProvider = function IdProvider(props) {\n  var ref = useRef(0);\n  var generateId = useCallback(function () {\n    return (++ref.current).toString();\n  }, []);\n  return /*#__PURE__*/createElement(Context.Provider, {\n    value: generateId\n  }, props.children);\n};\n/**\n * Return a deterministic Id for this Hook. Optionally add prefix to the id\n * @param prefix\n */\n\nvar useId = function useId(prefix) {\n  var clientHydrated = useClientHydrated();\n  var generateId = useContext(Context); // Prefer generating the id from the IdProvider context, but fallback to the localGenerateId method\n\n  var _useState = useState(generateId ? generateId() : clientHydrated ? localGenerateId() : undefined),\n      id = _useState[0],\n      setId = _useState[1];\n\n  useEffect(function () {\n    // If the Provider is not included, we fallback to generating an id as a client effect.\n    if (!id) {\n      setId(localGenerateId());\n    } // eslint-disable-next-line react-hooks/exhaustive-deps\n\n  }, []); // If the id isn't set yet, return undefined.\n\n  if (!id) return undefined;\n  return prefix ? prefix + \"_\" + id : id;\n};\n\nexport default useId;\nexport { IdProvider, resetLocalId };\n","(function (global, factory) {\n\ttypeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n\ttypeof define === 'function' && define.amd ? define(factory) :\n\t(global = global || self, global.deepmerge = factory());\n}(this, function () { 'use strict';\n\n\tvar isMergeableObject = function isMergeableObject(value) {\n\t\treturn isNonNullObject(value)\n\t\t\t&& !isSpecial(value)\n\t};\n\n\tfunction isNonNullObject(value) {\n\t\treturn !!value && typeof value === 'object'\n\t}\n\n\tfunction isSpecial(value) {\n\t\tvar stringValue = Object.prototype.toString.call(value);\n\n\t\treturn stringValue === '[object RegExp]'\n\t\t\t|| stringValue === '[object Date]'\n\t\t\t|| isReactElement(value)\n\t}\n\n\t// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25\n\tvar canUseSymbol = typeof Symbol === 'function' && Symbol.for;\n\tvar REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;\n\n\tfunction isReactElement(value) {\n\t\treturn value.$$typeof === REACT_ELEMENT_TYPE\n\t}\n\n\tfunction emptyTarget(val) {\n\t\treturn Array.isArray(val) ? [] : {}\n\t}\n\n\tfunction cloneUnlessOtherwiseSpecified(value, options) {\n\t\treturn (options.clone !== false && options.isMergeableObject(value))\n\t\t\t? deepmerge(emptyTarget(value), value, options)\n\t\t\t: value\n\t}\n\n\tfunction defaultArrayMerge(target, source, options) {\n\t\treturn target.concat(source).map(function(element) {\n\t\t\treturn cloneUnlessOtherwiseSpecified(element, options)\n\t\t})\n\t}\n\n\tfunction getMergeFunction(key, options) {\n\t\tif (!options.customMerge) {\n\t\t\treturn deepmerge\n\t\t}\n\t\tvar customMerge = options.customMerge(key);\n\t\treturn typeof customMerge === 'function' ? customMerge : deepmerge\n\t}\n\n\tfunction getEnumerableOwnPropertySymbols(target) {\n\t\treturn Object.getOwnPropertySymbols\n\t\t\t? Object.getOwnPropertySymbols(target).filter(function(symbol) {\n\t\t\t\treturn target.propertyIsEnumerable(symbol)\n\t\t\t})\n\t\t\t: []\n\t}\n\n\tfunction getKeys(target) {\n\t\treturn Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))\n\t}\n\n\tfunction mergeObject(target, source, options) {\n\t\tvar destination = {};\n\t\tif (options.isMergeableObject(target)) {\n\t\t\tgetKeys(target).forEach(function(key) {\n\t\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(target[key], options);\n\t\t\t});\n\t\t}\n\t\tgetKeys(source).forEach(function(key) {\n\t\t\tif (!options.isMergeableObject(source[key]) || !target[key]) {\n\t\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(source[key], options);\n\t\t\t} else {\n\t\t\t\tdestination[key] = getMergeFunction(key, options)(target[key], source[key], options);\n\t\t\t}\n\t\t});\n\t\treturn destination\n\t}\n\n\tfunction deepmerge(target, source, options) {\n\t\toptions = options || {};\n\t\toptions.arrayMerge = options.arrayMerge || defaultArrayMerge;\n\t\toptions.isMergeableObject = options.isMergeableObject || isMergeableObject;\n\n\t\tvar sourceIsArray = Array.isArray(source);\n\t\tvar targetIsArray = Array.isArray(target);\n\t\tvar sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;\n\n\t\tif (!sourceAndTargetTypesMatch) {\n\t\t\treturn cloneUnlessOtherwiseSpecified(source, options)\n\t\t} else if (sourceIsArray) {\n\t\t\treturn options.arrayMerge(target, source, options)\n\t\t} else {\n\t\t\treturn mergeObject(target, source, options)\n\t\t}\n\t}\n\n\tdeepmerge.all = function deepmergeAll(array, options) {\n\t\tif (!Array.isArray(array)) {\n\t\t\tthrow new Error('first argument should be an array')\n\t\t}\n\n\t\treturn array.reduce(function(prev, next) {\n\t\t\treturn deepmerge(prev, next, options)\n\t\t}, {})\n\t};\n\n\tvar deepmerge_1 = deepmerge;\n\n\treturn deepmerge_1;\n\n}));\n"],"sourceRoot":""}