{"version":3,"file":"static/chunks/3347-ad89732731afedef.js","mappings":"mIAOA,IAAAA,EAAA,IAAAC,QACAC,EAAA,IAAAD,QACAE,EAAA,GACAC,EAAA,EACAC,EAAA,SAAAC,CAAA,EACA,OAAAA,GAAAA,CAAAA,EAAAC,IAAA,EAAAF,EAAAC,EAAAE,UAAA,EACA,EAwBAC,EAAA,SAAAC,CAAA,CAAAF,CAAA,CAAAG,CAAA,CAAAC,CAAA,EACA,IAAAC,EAvBAA,CAuBAC,MAAAC,OAAA,CAAAL,GAAAA,EAAA,CAAAA,EAAA,EAtBAM,GAAA,UAAAC,CAAA,EACA,GAAAC,EAAAC,QAAA,CAAAF,GACA,OAAAA,EAEA,IAAAG,EAAAf,EAAAY,UACA,GAAAC,EAAAC,QAAA,CAAAC,GACAA,GAEAC,QAAAC,KAAA,eAAAL,EAAA,0BAcAT,EAdA,mBACA,KACA,GACAe,MAAA,UAAAC,CAAA,EAA+B,MAAAC,CAAAA,CAAAD,CAAA,EAY/BrB,CAAAA,CAAA,CAAAQ,EAAA,EACAR,CAAAA,CAAA,CAAAQ,EAAA,KAAAV,OAAA,EAEA,IAAAyB,EAAAvB,CAAA,CAAAQ,EAAA,CACAgB,EAAA,GACAC,EAAA,IAAAC,IACAC,EAAA,IAAAD,IAAAhB,GACAkB,EAAA,SAAAC,CAAA,EACA,CAAAA,GAAAJ,EAAAK,GAAA,CAAAD,KAGAJ,EAAAM,GAAA,CAAAF,GACAD,EAAAC,EAAAxB,UAAA,EACA,EACAK,EAAAsB,OAAA,CAAAJ,GACA,IAAAK,EAAA,SAAAlB,CAAA,EACA,CAAAA,GAAAY,EAAAG,GAAA,CAAAf,IAGAJ,MAAAuB,SAAA,CAAAF,OAAA,CAAAG,IAAA,CAAApB,EAAAqB,QAAA,UAAAjC,CAAA,EACA,GAAAsB,EAAAK,GAAA,CAAA3B,GACA8B,EAAA9B,QAGA,IACA,IAAAkC,EAAAlC,EAAAmC,YAAA,CAAA7B,GACA8B,EAAAF,OAAAA,GAAAA,UAAAA,EACAG,EAAA,CAAA3C,EAAA4C,GAAA,CAAAtC,IAAA,KACAuC,EAAA,CAAAnB,EAAAkB,GAAA,CAAAtC,IAAA,KACAN,EAAA8C,GAAA,CAAAxC,EAAAqC,GACAjB,EAAAoB,GAAA,CAAAxC,EAAAuC,GACAlB,EAAAoB,IAAA,CAAAzC,GACA,IAAAqC,GAAAD,GACAxC,EAAA4C,GAAA,CAAAxC,EAAA,IAEA,IAAAuC,GACAvC,EAAA0C,YAAA,CAAArC,EAAA,QAEA+B,GACApC,EAAA0C,YAAA,CAAApC,EAAA,OAEA,CACA,MAAAqC,EAAA,CACA5B,QAAAC,KAAA,mCAAAhB,EAAA2C,EACA,CAEA,EACA,EAIA,OAHAb,EAAA5B,GACAoB,EAAAsB,KAAA,GACA9C,IACA,WACAuB,EAAAQ,OAAA,UAAA7B,CAAA,EACA,IAAAqC,EAAA3C,EAAA4C,GAAA,CAAAtC,GAAA,EACAuC,EAAAnB,EAAAkB,GAAA,CAAAtC,GAAA,EACAN,EAAA8C,GAAA,CAAAxC,EAAAqC,GACAjB,EAAAoB,GAAA,CAAAxC,EAAAuC,GACAF,IACAzC,EAAA+B,GAAA,CAAA3B,IACAA,EAAA6C,eAAA,CAAAvC,GAEAV,EAAAkD,MAAA,CAAA9C,IAEAuC,GACAvC,EAAA6C,eAAA,CAAAxC,EAEA,KAEAP,IAEAJ,EAAA,IAAAC,QACAD,EAAA,IAAAC,QACAC,EAAA,IAAAD,QACAE,EAAA,GAEA,CACA,EAQOkD,EAAA,SAAA3C,CAAA,CAAAF,CAAA,CAAAG,CAAA,EACP,SAAAA,GAAiCA,CAAAA,EAAA,oBACjC,IAAAE,EAAAC,MAAAwC,IAAA,CAAAxC,MAAAC,OAAA,CAAAL,GAAAA,EAAA,CAAAA,EAAA,EACA6C,EAAA/C,GA7HA,qBAAAgD,SACA,KAGAC,CADA3C,MAAAC,OAAA,CA0HAL,GA1HAA,CAAA,IA0HAA,CA1HA,EACAgD,aAAA,CAAAC,IAAA,SA0HA,GAIA9C,EAAAkC,IAAA,CAAAa,KAAA,CAAA/C,EAAAC,MAAAwC,IAAA,CAAAC,EAAAM,gBAAA,kBACApD,EAAAI,EAAA0C,EAAA5C,EAAA,gBAJA,WAA6B,YAK7B,6DK7DOmD,EApEPC,EAEAC,EACAC,EAmEAC,EG5DOC,ECdPC,sBRAOC,EAAA,4BACAC,EAAA,0BCYA,SAAAC,EAAAC,CAAA,CAAAC,CAAA,EAOP,MANA,mBAAAD,EACAA,EAAAC,GAEAD,GACAA,CAAAA,EAAAE,OAAA,CAAAD,CAAA,EAEAD,CACA,CElBA,IAAAG,EAAA,oBAAAC,OAAgEC,EAAAC,eAAqB,CAAGD,EAAAE,SAAe,CACvGC,EAAA,IAAA/E,QEHOgF,GDwEP,SAAAnB,GAA8BA,CAAAA,EAAA,IAE9BI,CAtEA,SAAAH,GAAiCA,CAAAA,EAJjC,SAAAmB,CAAA,EACA,OAAAA,CACA,CAEiC,EACjClB,EAAA,GACAC,EAAA,GAmEAC,EAlEA,CACAiB,KAAA,WACA,GAAAlB,EACA,uHAEA,EAAAmB,MAAA,CACApB,CAAA,CAAAA,EAAAoB,MAAA,IA4DA,IAzDA,EACAC,UAAA,SAAAC,CAAA,EACA,IAAAC,EAAAxB,EAAAuB,EAAArB,GAEA,OADAD,EAAAjB,IAAA,CAAAwC,GACA,WACAvB,EAAAA,EAAAzC,MAAA,UAAAC,CAAA,EAAsD,OAAAA,IAAA+D,CAAA,EACtD,CACA,EACAC,iBAAA,SAAAC,CAAA,EAEA,IADAxB,EAAA,GACAD,EAAAoB,MAAA,GACA,IAAAM,EAAA1B,EACAA,EAAA,GACA0B,EAAAvD,OAAA,CAAAsD,EACA,CACAzB,EAAA,CACAjB,KAAA,SAAAvB,CAAA,EAAqC,OAAAiE,EAAAjE,EAAA,EACrCD,OAAA,WAAsC,OAAAyC,CAAA,CACtC,CACA,EACA2B,aAAA,SAAAF,CAAA,EACAxB,EAAA,GACA,IAAA2B,EAAA,GACA,GAAA5B,EAAAoB,MAAA,EACA,IAAAM,EAAA1B,EACAA,EAAA,GACA0B,EAAAvD,OAAA,CAAAsD,GACAG,EAAA5B,CACA,CACA,IAAA6B,EAAA,WACA,IAAAH,EAAAE,EACAA,EAAA,GACAF,EAAAvD,OAAA,CAAAsD,EACA,EACAK,EAAA,WAAsC,OAAAC,QAAAC,OAAA,GAAAC,IAAA,CAAAJ,EAAA,EACtCC,IACA9B,EAAA,CACAjB,KAAA,SAAAvB,CAAA,EACAoE,EAAA7C,IAAA,CAAAvB,GACAsE,GACA,EACAvE,OAAA,SAAAA,CAAA,EAEA,OADAqE,EAAAA,EAAArE,MAAA,CAAAA,GACAyC,CACA,CACA,CACA,CACA,GAWAF,OAAA,CAAqB,GAAAoC,EAAAC,EAAA,EAAQ,CAAGC,MAAA,GAAAC,IAAA,IAAyBvC,GACzDI,GEvEAoC,EAAA,WAEA,EAIAC,EAAmB1B,EAAA2B,UAAgB,UAAAC,CAAA,CAAAC,CAAA,EACnC,IHOOC,EDJAC,EACPpC,ECIAqC,EGRArC,EAAcK,EAAAiC,MAAY,OAC1BC,EAAalC,EAAAmC,QAAc,EAC3BC,gBAAAX,EACAY,eAAAZ,EACAa,mBAAAb,CACA,GAAKc,EAAAL,CAAA,IAAAM,EAAAN,CAAA,IACLO,EAAAb,EAAAa,YAAA,CAAA/E,EAAAkE,EAAAlE,QAAA,CAAAgF,EAAAd,EAAAc,SAAA,CAAAC,EAAAf,EAAAe,eAAA,CAAAC,EAAAhB,EAAAgB,OAAA,CAAAC,EAAAjB,EAAAiB,MAAA,CAAAC,EAAAlB,EAAAkB,OAAA,CAAAC,EAAAnB,EAAAmB,WAAA,CAAAC,EAAApB,EAAAoB,KAAA,CAAAC,EAAArB,EAAAqB,cAAA,CAAAC,EAAAtB,EAAAuB,EAAA,CAAAC,EAAAxB,EAAAwB,OAAA,CAAAC,EAAyY,GAAAhC,EAAAiC,EAAA,EAAM1B,EAAA,8IAE/Y2B,GHDOzB,EGC4B,CAAAnC,EAAAkC,EAAA,CJL5BE,ECK6B,SAAAyB,CAAA,EACpC,OAAA1B,EAAAxE,OAAA,UAAAqC,CAAA,EAA6C,OAAOD,EAASC,EAAA6D,EAAA,EAC7D,EDcA7D,CApBAA,EAAc,GAAAK,EAAAmC,QAAA,EAAQ,WAAe,OAErCvC,MCEoC,KDApCmC,SAAAA,EAEA0B,OAAA,CACA,IAAA5D,SAAA,CACA,OAAAF,EAAAC,KAAA,EAEA,IAAAC,QAAAD,MAAA,CACA,IAAA8D,EAAA/D,EAAAC,KAAA,CACA8D,IAAA9D,QACAD,EAAAC,KAAA,CAAAA,MACAD,EAAAoC,QAAA,CAAAnC,MAAA8D,GAEA,CACA,CACA,CAAK,EAAI,KAET3B,QAAA,CAAAA,EChBAC,EDiBArC,EAAA8D,MAAA,CCbA3D,EAAA,WACA,IAAA6D,EAAAxD,EAAApC,GAAA,CAAAiE,GACA,GAAA2B,EAAA,CACA,IAAAC,EAAA,IAAA5G,IAAA2G,GACAE,EAAA,IAAA7G,IAAA8E,GACAgC,EAAA9B,EAAAnC,OAAA,CACA+D,EAAAtG,OAAA,UAAAqC,CAAA,EACAkE,EAAAzG,GAAA,CAAAuC,IACoBD,EAASC,EAAA,KAE7B,GACAkE,EAAAvG,OAAA,UAAAqC,CAAA,EACAiE,EAAAxG,GAAA,CAAAuC,IACoBD,EAASC,EAAAmE,EAE7B,EACA,CACA3D,EAAAlC,GAAA,CAAA+D,EAAAF,EACA,EAAK,CAAAA,EAAA,EACLE,GGtBA+B,EAAyB,GAAA1C,EAAAC,EAAA,EAAS,GAAAD,EAAAC,EAAA,EAAQ,GAAG+B,GAAAd,GAC7C,OAAYvC,EAAAgE,aAAmB,CAAChE,EAAAiE,QAAc,MAC9CrB,GAAoB5C,EAAAgE,aAAmB,CAJvClB,EAIuC,CAAYA,QAAS1C,EAASuC,gBAAAA,EAAAE,OAAAA,EAAAE,YAAAA,EAAAC,MAAAA,EAAAR,aAAAA,EAAAS,eAAA,EAAAA,EAAAiB,QAAAvE,EAAAyD,QAAAA,CAAA,GACrEX,EAAwBzC,EAAAmE,YAAkB,CAACnE,EAAAoE,QAAc,CAAAC,IAAA,CAAA3G,GAAiB,GAAA2D,EAAAC,EAAA,EAAS,GAAAD,EAAAC,EAAA,EAAQ,GAAGyC,GAAA,CAAqBpE,IAAA4D,CAAA,IAA0BvD,EAAAgE,aAAmB,CANhKd,KAAA,IAAAA,EAAA,MAAAA,EAM4K,GAAA7B,EAAAC,EAAA,EAAQ,GAAGyC,EAAA,CAAoBrB,UAAAA,EAAA/C,IAAA4D,CAAA,GAAyC7F,GACpP,EACAgE,CAAAA,EAAA4C,YAAA,EACA1B,QAAA,GACAD,gBAAA,GACAK,MAAA,EACA,EACAtB,EAAA6C,UAAA,EACAC,UAAe/E,EACfgF,UAAejF,CACf,EChCA,IAAAkF,EAAA,SAAAxC,CAAA,EACA,IAAAY,EAAAZ,EAAAY,OAAA,CAAAO,EAAqC,GAAAhC,EAAAiC,EAAA,EAAMpB,EAAA,aAC3C,IAAAY,EACA,kFAEA,IAAA6B,EAAA7B,EAAAxC,IAAA,GACA,IAAAqE,EACA,wCAEA,OAAW3E,EAAAgE,aAAmB,CAAAW,EAAS,GAAAtD,EAAAC,EAAA,EAAQ,GAAG+B,GAClD,CACAqB,CAAAA,EAAAE,eAAA,IEaO,IAAAC,EAAA,WACP,IAAAC,EAAA,EACAC,EAAA,KACA,OACA1H,IAAA,SAAA2H,CAAA,EACA,GAAAF,GAAAA,GACAC,CAAAA,EAAAE,WA9BA,IAAAtG,SACA,YACA,IAAAuG,EAAAvG,SAAAqF,aAAA,SACAkB,CAAAA,EAAAC,IAAA,YACA,IAAAC,EDDA,GAIeC,EAAAC,EAAiB,CCChC,OAHAF,GACAF,EAAA/G,YAAA,SAAAiH,GAEAF,CACA,GAqBA,OApBAA,EAUAA,CARAA,EAFAA,EAqBAH,GAnBAQ,UAAA,CAEAL,EAAAK,UAAA,CAAAC,OAAA,CAiBAR,EAdAE,EAAAO,WAAA,CAAA9G,SAAA+G,cAAA,CAcAV,IAXAE,EAYAH,EAVAY,CADAhH,SAAAgH,IAAA,EAAAhH,SAAAiH,oBAAA,aACAH,WAAA,CAAAP,EAWA,CAEAJ,GACA,EACAe,OAAA,aAEAf,IAAAC,IACAA,EAAApJ,UAAA,EAAAoJ,EAAApJ,UAAA,CAAAmK,WAAA,CAAAf,GACAA,EAAA,KAEA,CACA,CACA,ECpCOgB,EAAA,WACP,IAAAC,EAAgBnB,IAChB,gBAAAoB,CAAA,CAAAC,CAAA,EACQlG,EAAAE,SAAe,YAEvB,OADA8F,EAAA3I,GAAA,CAAA4I,GACA,WACAD,EAAAH,MAAA,EACA,CACA,EAAS,CAAAI,GAAAC,EAAA,CACT,CACA,ECdOC,EAAA,WACP,IAAAC,EAAmBL,IAMnB,OALA,SAAA7D,CAAA,EAGA,OADAkE,EADAlE,EAAA+D,MAAA,CAAA/D,EAAAmE,OAAA,EAEA,IACA,CAEA,EEfOC,EAAA,CACPC,KAAA,EACAC,IAAA,EACAC,MAAA,EACAC,IAAA,CACA,EACAC,EAAA,SAAAhK,CAAA,EAA2B,OAAAiK,SAAAjK,GAAA,WAC3BkK,EAAA,SAAAzD,CAAA,EACA,IAAA0D,EAAA/G,OAAAgH,gBAAA,CAAApI,SAAAG,IAAA,EACAyH,EAAAO,CAAA,CAAA1D,YAAAA,EAAA,4BACAoD,EAAAM,CAAA,CAAA1D,YAAAA,EAAA,0BACAqD,EAAAK,CAAA,CAAA1D,YAAAA,EAAA,8BACA,OAAAuD,EAAAJ,GAAAI,EAAAH,GAAAG,EAAAF,GAAA,EAEOO,EAAA,SAAA5D,CAAA,EAEP,GADA,SAAAA,GAA8BA,CAAAA,EAAA,UAC9B,oBAAArD,OACA,OAAAuG,EAEA,IAAAW,EAAAJ,EAAAzD,GACA8D,EAAAvI,SAAAwI,eAAA,CAAAC,WAAA,CACAC,EAAAtH,OAAAuH,UAAA,CACA,OACAf,KAAAU,CAAA,IACAT,IAAAS,CAAA,IACAR,MAAAQ,CAAA,IACAP,IAAAa,KAAAC,GAAA,GAAAH,EAAAH,EAAAD,CAAA,IAAAA,CAAA,IACA,CACA,ECxBAQ,EAAYtB,IACLuB,EAAA,qBAIPC,EAAA,SAAAzF,CAAA,CAAA0F,CAAA,CAAAxE,CAAA,CAAAyE,CAAA,EACA,IAAAtB,EAAArE,EAAAqE,IAAA,CAAAC,EAAAtE,EAAAsE,GAAA,CAAAC,EAAAvE,EAAAuE,KAAA,CAAAC,EAAAxE,EAAAwE,GAAA,CAEA,OADA,SAAAtD,GAA8BA,CAAAA,EAAA,UAC9B,QAAA0E,MAAA,CdVO,0BcUwC,4BAAKA,MAAA,CAAAD,EAAA,yBAA6CC,MAAA,CAAApB,EAAA,OAAAoB,MAAA,CAAAD,EAAA,mBAAmEC,MAAA,CAAAJ,EAAA,8BAAsCI,MAAA,CAAAD,EAAA,8CAAiFC,MAAA,EAC3RF,GAAA,sBAAAE,MAAA,CAAAD,EAAA,KACAzE,WAAAA,GACA,uBAAA0E,MAAA,CAAAvB,EAAA,0BAAoDuB,MAAA,CAAAtB,EAAA,4BAAsCsB,MAAA,CAAArB,EAAA,kEAAiFqB,MAAA,CAAApB,EAAA,OAAAoB,MAAA,CAAAD,EAAA,WAC3KzE,YAAAA,GAAA,kBAAA0E,MAAA,CAAApB,EAAA,OAAAoB,MAAA,CAAAD,EAAA,KACA,CACAnL,MAAA,CAAAE,SACAmL,IAAA,uBAAyBD,MAAA,CAAmBtI,EAAkB,mBAAKsI,MAAA,CAAApB,EAAA,OAAAoB,MAAA,CAAAD,EAAA,mBAA4DC,MAAA,CAAmBrI,EAAkB,0BAAKqI,MAAA,CAAApB,EAAA,OAAAoB,MAAA,CAAAD,EAAA,mBAAmEC,MAAA,CAAmBtI,EAAkB,MAAAsI,MAAA,CAAetI,EAAkB,qBAAKsI,MAAA,CAAAD,EAAA,mBAA2CC,MAAA,CAAmBrI,EAAkB,MAAAqI,MAAA,CAAerI,EAAkB,4BAAKqI,MAAA,CAAAD,EAAA,uBAAkDC,MAAA,CAAAJ,EAAA,aAA0CI,MAAA,CdZlgB,iCcYwiB,MAAAA,MAAA,CAAApB,EAAA,aAC/iB,EACAsB,EAAA,WACA,IAAAlD,EAAA8B,SAAAjI,SAAAG,IAAA,CAAAlB,YAAA,CAAA8J,IAAA,QACA,OAAAO,SAAAnD,GAAAA,EAAA,CACA,EACOoD,EAAA,WACHlI,EAAAE,SAAe,YAEnB,OADAvB,SAAAG,IAAA,CAAAX,YAAA,CAAAuJ,EAAA,CAAAM,IAAA,GAAAG,QAAA,IACA,WACA,IAAAC,EAAAJ,IAAA,CACAI,CAAAA,GAAA,EACAzJ,SAAAG,IAAA,CAAAR,eAAA,CAAAoJ,GAGA/I,SAAAG,IAAA,CAAAX,YAAA,CAAAuJ,EAAAU,EAAAD,QAAA,GAEA,CACA,EAAK,GACL,EAIOE,EAAA,SAAAnG,CAAA,EACP,IAAAoG,EAAApG,EAAAoG,UAAA,CAAAC,EAAArG,EAAAqG,WAAA,CAAArF,EAAAhB,EAAAkB,OAAA,CAAAA,EAAAF,KAAA,IAAAA,EAAA,SAAAA,EACAgF,IAMA,IAAAxB,EAAc1G,EAAAwI,OAAa,YAAe,OAAOxB,EAAW5D,EAAA,EAAY,CAAAA,EAAA,EACxE,OAAWpD,EAAAgE,aAAmB,CAAAyD,EAAA,CAAUxB,OAAA0B,EAAAjB,EAAA,CAAA4B,EAAAlF,EAAA,oBACxC,EEpDAqF,EAAA,GACA,uBAAA1I,OACA,IACA,IAAAd,EAAAyJ,OAAAC,cAAA,IAA8C,WAC9C5K,IAAA,WAEA,OADA0K,EAAA,GACA,EACA,CACA,GAEA1I,OAAA6I,gBAAA,QAAA3J,EAAAA,GAEAc,OAAA8I,mBAAA,QAAA5J,EAAAA,EACA,CACA,MAAA6J,EAAA,CACAL,EAAA,EACA,CAEO,IAAAM,EAAAN,EAAAA,GAAA,CAAsCO,QAAA,ICd7CC,EAAA,SAAAxN,CAAA,CAAAyN,CAAA,EACA,IAAAzN,CAAAA,aAAA0N,OAAA,EACA,SAEA,IAAAlD,EAAAlG,OAAAgH,gBAAA,CAAAtL,GACA,MAEAwK,WAAAA,CAAA,CAAAiD,EAAA,EAEA,CAAAjD,CAAAA,EAAAmD,SAAA,GAAAnD,EAAAoD,SAAA,eAXA5N,EAAA6N,OAAA,EAWArD,YAAAA,CAAA,CAAAiD,EAAA,CACA,EAGOK,EAAA,SAAAC,CAAA,CAAA/N,CAAA,EACP,IAAAoD,EAAApD,EAAAoD,aAAA,CACAgB,EAAApE,EACA,GAMA,GAJA,oBAAAgO,YAAA5J,aAAA4J,YACA5J,CAAAA,EAAAA,EAAAnE,IAAA,EAEAgO,EAAAF,EAAA3J,GACA,CACA,IAAAqC,EAAAyH,EAAAH,EAAA3J,GACA,GAAA+J,CADA,IAAA1H,CAAA,IAEA,QAEA,CACArC,EAAAA,EAAAlE,UAAA,OACMkE,GAAAA,IAAAhB,EAAAC,IAAA,EACN,QACA,EAiBA4K,EAAA,SAAAF,CAAA,CAAA/N,CAAA,EACA,MAAA+N,MAAAA,EAtCgDP,EAsChDxN,EAtCgD,aACAwN,EAqChDxN,EArCgD,YAsChD,EACAkO,EAAA,SAAAH,CAAA,CAAA/N,CAAA,EACA,MAAA+N,MAAAA,EAlBA,CADAtH,EAAA2H,SAAA,CAAA3H,EAAA0H,YAAA,CAAA1H,EAAA4H,YAAA,CAKA,CAIA,CADA5H,EAAA6H,UAAA,CAAA7H,EAAA8H,WAAA,CAAA9H,EAAAkF,WAAA,CAKA,EAgBO6C,EAAA,SAAAT,CAAA,CAAAU,CAAA,CAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EACP,IATAC,EASAC,GATAD,EASAvK,OAAAgH,gBAAA,CAAAmD,GAAAI,SAAA,CAHAd,MAGAA,GAHAc,QAAAA,EAAA,MAIAE,EAAAD,EAAAH,EAEAhO,EAAA+N,EAAA/N,MAAA,CACAqO,EAAAP,EAAA5N,QAAA,CAAAF,GACAsO,EAAA,GACAC,EAAAH,EAAA,EACAI,EAAA,EACAC,EAAA,EACA,GACA,IAAA3I,EAAAyH,EAAAH,EAAApN,GAAA0O,EAAA5I,CAAA,IACA6I,EAAAC,CADA,IAAA9I,CAAA,IACAqI,EAAAO,EACAA,CAAAA,GAAAC,CAAA,GACArB,EAAAF,EAAApN,KACAwO,GAAAG,EACAF,GAAAC,GAGA1O,aAAAqN,WACArN,EAAAA,EAAAV,IAAA,CAGAU,EAAAA,EAAAT,UAAA,OAIA,CAAA8O,GAAArO,IAAAuC,SAAAG,IAAA,EAEA2L,GAAAP,CAAAA,EAAA5N,QAAA,CAAAF,IAAA8N,IAAA9N,CAAA,GAUA,OARAuO,GACA,IAAApD,EAAAA,KAAA0D,GAAA,CAAAL,IAAA,CAAAP,GAAAG,EAAAI,CAAA,EACAF,EAAA,GAEA,CAAAC,GACA,IAAApD,EAAAA,KAAA0D,GAAA,CAAAJ,IAAA,CAAAR,GAAA,CAAAG,EAAAK,CAAA,GACAH,CAAAA,EAAA,IAEAA,CACA,ECpGOQ,EAAA,SAAAf,CAAA,EACP,yBAAAA,EAAA,CAAAA,EAAAgB,cAAA,IAAAC,OAAA,CAAAjB,EAAAgB,cAAA,IAAAE,OAAA,SAEOC,EAAA,SAAAnB,CAAA,EAAoC,OAAAA,EAAAoB,MAAA,CAAApB,EAAAqB,MAAA,GAC3CC,EAAA,SAAA9L,CAAA,EACA,OAAAA,GAAA,YAAAA,EAAAA,EAAAE,OAAA,CAAAF,CACA,EAGA+L,EAAA,EACAC,EAAA,GCbAC,GZWOtM,EWGA,SAAAsC,CAAA,EACP,IAAAiK,EAA6B7L,EAAAiC,MAAY,KACzC6J,EAAwB9L,EAAAiC,MAAY,QACpC8J,EAAqB/L,EAAAiC,MAAY,GACjC+J,EAAahM,EAAAmC,QAAc,CAAAuJ,IAAA,IAC3BjE,EAAgBzH,EAAAmC,QAAc,CAACgE,EAAc,IAC7C8F,EAAoBjM,EAAAiC,MAAY,CAAAL,GAC5B5B,EAAAE,SAAe,YACnB+L,EAAApM,OAAA,CAAA+B,CACA,EAAK,CAAAA,EAAA,EACD5B,EAAAE,SAAe,YACnB,GAAA0B,EAAAoB,KAAA,EACArE,SAAAG,IAAA,CAAAoN,SAAA,CAAA7O,GAAA,wBAAAyK,MAAA,CAAAkE,IACA,IAAAG,EAA0B,GAAA9K,EAAA+K,EAAA,EAAa,CAAAxK,EAAAsC,OAAA,CAAArE,OAAA,GAAA+B,EAAAiB,MAAA,MAAA1G,GAAA,CAAAsP,GAAA,IAAA/O,MAAA,CAAAE,SAEvC,OADAuP,EAAA7O,OAAA,UAAAH,CAAA,EAA4C,OAAAA,EAAA+O,SAAA,CAAA7O,GAAA,wBAAAyK,MAAA,CAAAkE,GAAA,GAC5C,WACArN,SAAAG,IAAA,CAAAoN,SAAA,CAAArG,MAAA,wBAAAiC,MAAA,CAAAkE,IACAG,EAAA7O,OAAA,UAAAH,CAAA,EAAgD,OAAAA,EAAA+O,SAAA,CAAArG,MAAA,wBAAAiC,MAAA,CAAAkE,GAAA,EAChD,CACA,CAEA,EAAK,CAAApK,EAAAoB,KAAA,CAAApB,EAAAsC,OAAA,CAAArE,OAAA,CAAA+B,EAAAiB,MAAA,GACL,IAAAwJ,EAA4BrM,EAAAsM,WAAiB,UAAAnC,CAAA,CAAA9N,CAAA,EAC7C,eAAA8N,GAAAA,IAAAA,EAAAoC,OAAA,CAAAhM,MAAA,EAAA4J,UAAAA,EAAAhF,IAAA,EAAAgF,EAAAqC,OAAA,CACA,OAAAP,EAAApM,OAAA,CAAAoD,cAAA,CAEA,IAIAwJ,EAJAC,EAAAxB,EAAAf,GACAwC,EAAAb,EAAAjM,OAAA,CACA0L,EAAA,WAAApB,EAAAA,EAAAoB,MAAA,CAAAoB,CAAA,IAAAD,CAAA,IACAlB,EAAA,WAAArB,EAAAA,EAAAqB,MAAA,CAAAmB,CAAA,IAAAD,CAAA,IAEAtQ,EAAA+N,EAAA/N,MAAA,CACAwQ,EAAArF,KAAA0D,GAAA,CAAAM,GAAAhE,KAAA0D,GAAA,CAAAO,GAAA,QAEA,eAAArB,GAAAyC,MAAAA,GAAAxQ,UAAAA,EAAA+I,IAAA,CACA,SAEA,IAAA0H,EAA2CtD,EAAuBqD,EAAAxQ,GAClE,IAAAyQ,EACA,SAUA,GARAA,EACAJ,EAAAG,GAGAH,EAAAG,MAAAA,EAAA,QACAC,EAA2CtD,EAAuBqD,EAAAxQ,IAGlE,CAAAyQ,EACA,SAKA,GAHA,CAAAd,EAAAlM,OAAA,qBAAAsK,GAAAoB,CAAAA,GAAAC,CAAA,GACAO,CAAAA,EAAAlM,OAAA,CAAA4M,CAAA,EAEA,CAAAA,EACA,SAEA,IAAAK,EAAAf,EAAAlM,OAAA,EAAA4M,EACA,OAAexC,EAAY6C,EAAAzQ,EAAA8N,EAAA2C,MAAAA,EAAAvB,EAAAC,EAAA,GAC3B,EAAK,IACLuB,EAAwB/M,EAAAsM,WAAiB,UAAAU,CAAA,EAEzC,KAAAzM,MAAA,EAAAoL,CAAA,CAAAA,EAAApL,MAAA,MAAAkH,GAIA,IAAA+C,EAAA,WALAwC,EAKA1B,EALA0B,GAKA9B,EALA8B,GAMAC,EAAApB,EAAAhM,OAAA,CAAAnD,MAAA,UAAA0B,CAAA,MAxEAzB,EAwE2E,OAAAyB,EAAA8O,IAAA,GAAA/C,EAAAhF,IAAA,EAAA/G,CAAAA,EAAAhC,MAAA,GAAA+N,EAAA/N,MAAA,EAAA+N,EAAA/N,MAAA,GAAAgC,EAAA+O,YAAA,GAxEtCxQ,CAArCA,EAwE2EyB,EAAAoM,KAAA,CAxEtC,MAAA4C,CAAA,KAAAzQ,CAAA,MAAAyQ,CAAA,KAwEuK,IAE5M,GAAAH,GAAAA,EAAAI,MAAA,EACAlD,EAAAmD,UAAA,EACAnD,EAAAoD,cAAA,GAEA,MACA,CAEA,IAAAN,EAAA,CACA,IAAAO,EAAA,CAAAvB,EAAApM,OAAA,CAAAgD,MAAA,MACA1G,GAAA,CAAAsP,GACA/O,MAAA,CAAAE,SACAF,MAAA,UAAAjB,CAAA,EAA0C,OAAAA,EAAAa,QAAA,CAAA6N,EAAA/N,MAAA,IAC1CoR,CAAAA,EAAAjN,MAAA,GAAA8L,EApBAW,EAoBAQ,CAAA,MAAAvB,EAAApM,OAAA,CAAAkD,WAAA,GAEAoH,EAAAmD,UAAA,EACAnD,EAAAoD,cAAA,EAGA,EACA,EAAK,IACLE,EAAuBzN,EAAAsM,WAAiB,UAAAY,CAAA,CAAA1C,CAAA,CAAApO,CAAA,CAAAiR,CAAA,EACxC,IAAAlD,EAAA,CAAsB+C,KAAAA,EAAA1C,MAAAA,EAAApO,OAAAA,EAAAiR,OAAAA,EAAAF,aAAAO,SAsCtBjS,CAAA,EAEA,IADA,IAAA0R,EAAA,KACA1R,OAAAA,GACAA,aAAAgO,aACA0D,EAAA1R,EAAAC,IAAA,CACAD,EAAAA,EAAAC,IAAA,EAEAD,EAAAA,EAAAE,UAAA,CAEA,OAAAwR,CACA,EAhDsB/Q,EAAA,EACtByP,EAAAhM,OAAA,CAAA3B,IAAA,CAAAiM,GACAwD,WAAA,WACA9B,EAAAhM,OAAA,CAAAgM,EAAAhM,OAAA,CAAAnD,MAAA,UAAA0B,CAAA,EAA0F,OAAAA,IAAA+L,CAAA,EAC1F,EAAS,EACT,EAAK,IACLyD,EAA2B5N,EAAAsM,WAAiB,UAAAnC,CAAA,EAC5C2B,EAAAjM,OAAA,CAAAqL,EAAAf,GACA4B,EAAAlM,OAAA,CAAAgO,KAAAA,CACA,EAAK,IACLC,EAAsB9N,EAAAsM,WAAiB,UAAAnC,CAAA,EACvCsD,EAAAtD,EAAAhF,IAAA,CAAAmG,EAAAnB,GAAAA,EAAA/N,MAAA,CAAAiQ,EAAAlC,EAAAvI,EAAAsC,OAAA,CAAArE,OAAA,EACA,EAAK,IACLkO,EAA0B/N,EAAAsM,WAAiB,UAAAnC,CAAA,EAC3CsD,EAAAtD,EAAAhF,IAAA,CAAA+F,EAAAf,GAAAA,EAAA/N,MAAA,CAAAiQ,EAAAlC,EAAAvI,EAAAsC,OAAA,CAAArE,OAAA,EACA,EAAK,IACDG,EAAAE,SAAe,YAUnB,OATAyL,EAAAzN,IAAA,CAAAuJ,GACA7F,EAAAY,YAAA,EACAJ,gBAAA0L,EACAzL,eAAAyL,EACAxL,mBAAAyL,CACA,GACApP,SAAAiK,gBAAA,SAAAmE,EAA0DhE,GAC1DpK,SAAAiK,gBAAA,aAAAmE,EAA8DhE,GAC9DpK,SAAAiK,gBAAA,cAAAgF,EAAkE7E,GAClE,WACA4C,EAAAA,EAAAjP,MAAA,UAAAsR,CAAA,EAA2D,OAAAA,IAAAvG,CAAA,GAC3D9I,SAAAkK,mBAAA,SAAAkE,EAAiEhE,GACjEpK,SAAAkK,mBAAA,aAAAkE,EAAqEhE,GACrEpK,SAAAkK,mBAAA,cAAA+E,EAAyE7E,EACzE,CACA,EAAK,IACL,IAAApG,EAAAf,EAAAe,eAAA,CAAAK,EAAApB,EAAAoB,KAAA,CACA,OAAYhD,EAAAgE,aAAmB,CAAChE,EAAAiE,QAAc,MAC9CjB,EAAgBhD,EAAAgE,aAAmB,CAAAyD,EAAA,CAAUxB,OAjIT,4BAAA6B,MAAA,CAiISkE,EAjIT,qDAAuElE,MAAA,CAiI9DkE,EAjI8D,4BAiI9D,GAA2B,KACxErJ,EAA0B3C,EAAAgE,aAAmB,CAACqE,EAAe,CAAIjF,QAAAxB,EAAAwB,OAAA,GAAwB,KACzF,EXlIA/D,EAAAmB,SAAA,CAAAlB,GACAoF,GaZAuJ,EAAwBjO,EAAA2B,UAAgB,UAAAC,CAAA,CAAAjC,CAAA,EAAyB,OAAQK,EAAAgE,aAAmB,CAACtC,EAAc,GAAAL,EAAAC,EAAA,EAAQ,GAAGM,EAAA,CAAWjC,IAAAA,EAAAmD,QAAmB8I,CAAO,GAAE,EAC7JqC,CAAAA,EAAA1J,UAAA,CAA+B7C,EAAY6C,UAAA,CAC3C,IAAA2J,EAAeD,8DEUXE,kEAJEC,EAAiB,0BAMjBC,EAAgCC,EAAAA,aAAA,CAAc,CAClDC,OAAQ,IAAIvR,IACZwR,uCAAwC,IAAIxR,IAC5CyR,SAAU,IAAIzR,GAChB,GAsCM0R,EAAyBJ,EAAAA,UAAA,CAC7B,CAAC1M,EAAO+M,SAYuCC,EAAvBnT,EAXtB,GAAM,CACJoT,4BAAAA,EAA8B,GAC9BC,gBAAAA,CAAA,CACAC,qBAAAA,CAAA,CACAC,eAAAA,CAAA,CACAC,kBAAAA,CAAA,CACAC,UAAAA,CAAA,CACA,GAAGC,EACL,CAAIvN,EACEwN,EAAgBd,EAAAA,UAAA,CAAWD,GAC3B,CAAC5S,EAAM4T,EAAO,CAAUf,EAAAA,QAAA,CAAyC,MACjEzP,EAAgBpD,OAAAA,CAAAA,EAAAA,MAAAA,EAAAA,KAAAA,EAAAA,EAAMoD,aAAA,GAANpD,KAAAA,IAAAA,EAAAA,EAAAA,OAAuBmT,CAAAA,EAAAA,UAAAA,GAAAA,KAAAA,IAAAA,EAAAA,KAAAA,EAAAA,EAAYjQ,QAAA,CACnD,EAAG2Q,EAAK,CAAUhB,EAAAA,QAAA,CAAS,CAAC,GAC5BiB,EAAeC,CAAAA,EAAAA,EAAAA,CAAAA,EAAgBb,EAAc,GAAUU,EAAQ5T,IAC/D8S,EAAStS,MAAMwC,IAAA,CAAK2Q,EAAQb,MAAM,EAClC,CAACkB,EAA4C,CAAI,IAAIL,EAAQZ,sCAAsC,EAAEkB,KAAA,CAAM,IAC3GC,EAAoDpB,EAAOqB,OAAA,CAAQH,GACnEI,EAAQpU,EAAO8S,EAAOqB,OAAA,CAAQnU,GAAQ,GACtCqU,EAA8BV,EAAQZ,sCAAA,CAAuCuB,IAAA,CAAO,EACpFC,EAAyBH,GAASF,EAElCM,EAAqBC,SA0I7BnB,CAAA,MAC0BH,MAA1B/P,EAAAA,UAAAA,MAAAA,CAAAA,GAAAA,KAAAA,IAAAA,SAAAA,CAAAA,EAAAA,CAAAA,SAAAA,CAAAA,EAAAA,CAA0B+P,OAAAA,CAAAA,EAAAA,UAAAA,GAAAA,KAAAA,IAAAA,EAAAA,KAAAA,EAAAA,EAAYjQ,QAAA,CAEhCwR,EAA2BC,CAAAA,EAAAA,EAAAA,CAAAA,EAAerB,GAC1CsB,EAAoC/B,EAAAA,MAAA,CAAO,IAC3CgC,EAAuBhC,EAAAA,MAAA,CAAO,KAAO,GAiE3C,OA/DMA,EAAAA,SAAA,CAAU,KACd,IAAMiC,EAAoB,IACxB,GAAIpG,EAAM/N,MAAA,EAAU,CAACiU,EAA4BxQ,OAAA,CAAS,CAGxD,IAAS2Q,EAAT,WACEC,EA7NmB,sCA+NjBN,EACAO,EACA,CAAEC,SAAU,EAAK,EAErB,EATMD,EAAc,CAAEE,cAAezG,CAAM,CAuBvCA,CAAsB,UAAtBA,EAAM0G,WAAA,EACRhS,EAAcgK,mBAAA,CAAoB,QAASyH,EAAezQ,OAAO,EACjEyQ,EAAezQ,OAAA,CAAU2Q,EACzB3R,EAAc+J,gBAAA,CAAiB,QAAS0H,EAAezQ,OAAA,CAAS,CAAEiR,KAAM,EAAK,IAE7EN,GAEJ,MAGE3R,EAAcgK,mBAAA,CAAoB,QAASyH,EAAezQ,OAAO,CAEnEwQ,CAAAA,EAA4BxQ,OAAA,CAAU,EACxC,EAcMkR,EAAUhR,OAAO4N,UAAA,CAAW,KAChC9O,EAAc+J,gBAAA,CAAiB,cAAe2H,EAChD,EAAG,GACH,MAAO,KACLxQ,OAAOiR,YAAA,CAAaD,GACpBlS,EAAcgK,mBAAA,CAAoB,cAAe0H,GACjD1R,EAAcgK,mBAAA,CAAoB,QAASyH,EAAezQ,OAAO,CACnE,CACF,EAAG,CAAChB,EAAesR,EAAyB,EAErC,CAELc,qBAAsB,IAAOZ,EAA4BxQ,OAAA,CAAU,EACrE,CACF,EApNqD,IAC/C,IAAMzD,EAAS+N,EAAM/N,MAAA,CACf8U,EAAwB,IAAI9B,EAAQX,QAAQ,EAAE0C,IAAA,CAAK,GAAYC,EAAO9U,QAAA,CAASF,KAChF4T,GAA0BkB,IAC/BnC,MAAAA,GAAAA,EAAuB5E,GACvB8E,MAAAA,GAAAA,EAAoB9E,GACfA,EAAMkH,gBAAA,EAAkBnC,MAAAA,GAAAA,IAC/B,EAAGrQ,GAEGyS,EAAeC,SAkNvBvC,CAAA,MAC0BJ,MAA1B/P,EAAAA,UAAAA,MAAAA,CAAAA,GAAAA,KAAAA,IAAAA,SAAAA,CAAAA,EAAAA,CAAAA,SAAAA,CAAAA,EAAAA,CAA0B+P,OAAAA,CAAAA,EAAAA,UAAAA,GAAAA,KAAAA,IAAAA,EAAAA,KAAAA,EAAAA,EAAYjQ,QAAA,CAEhC6S,EAAqBpB,CAAAA,EAAAA,EAAAA,CAAAA,EAAepB,GACpCyC,EAAkCnD,EAAAA,MAAA,CAAO,IAe/C,OAbMA,EAAAA,SAAA,CAAU,KACd,IAAMoD,EAAc,IACdvH,EAAM/N,MAAA,EAAU,CAACqV,EAA0B5R,OAAA,EAE7C4Q,EA1Sc,gCA0S8Be,EADxB,CAAEZ,cAAezG,CAAM,EACkC,CAC3EwG,SAAU,EACZ,EAEJ,EAEA,OADA9R,EAAc+J,gBAAA,CAAiB,UAAW8I,GACnC,IAAM7S,EAAcgK,mBAAA,CAAoB,UAAW6I,EAC5D,EAAG,CAAC7S,EAAe2S,EAAmB,EAE/B,CACLG,eAAgB,IAAOF,EAA0B5R,OAAA,CAAU,GAC3D+R,cAAe,IAAOH,EAA0B5R,OAAA,CAAU,EAC5D,CACF,EAzOyC,IACnC,IAAMzD,EAAS+N,EAAM/N,MAAA,CACG,IAAIgT,EAAQX,QAAQ,EAAE0C,IAAA,CAAK,GAAYC,EAAO9U,QAAA,CAASF,MAE/E4S,MAAAA,GAAAA,EAAiB7E,GACjB8E,MAAAA,GAAAA,EAAoB9E,GACfA,EAAMkH,gBAAA,EAAkBnC,MAAAA,GAAAA,IAC/B,EAAGrQ,GAsDH,OApDAgT,SDlGJC,CAAA,CAAAjT,EAAA+P,YAAAjQ,QAAA,EACA,IAAAmQ,EAA0B,GAAAiD,EAAAC,CAAA,EAAcF,GACtC9R,EAAAE,SAAe,MACjB,IAAA+R,EAAA,IACA,WAAA9H,EAAA+H,GAAA,EACApD,EAAA3E,EAEA,EAEA,OADAtL,EAAA+J,gBAAA,WAAAqJ,EAAA,CAA+DE,QAAA,KAC/D,IAAAtT,EAAAgK,mBAAA,WAAAoJ,EAAA,CAA+EE,QAAA,IAC/E,EAAG,CAAArD,EAAAjQ,EAAA,CACH,ECuFqB,IACQgR,IAAUT,EAAQb,MAAA,CAAOwB,IAAA,CAAO,IAEvDjB,MAAAA,GAAAA,EAAkB3E,GACd,CAACA,EAAMkH,gBAAA,EAAoBnC,IAC7B/E,EAAMoD,cAAA,GACN2B,KAEJ,EAAGrQ,GAEGyP,EAAAA,SAAA,CAAU,KACd,GAAK7S,EAUL,OATIoT,IAC0D,IAAxDO,EAAQZ,sCAAA,CAAuCuB,IAAA,GACjD5B,EAA4BtP,EAAcC,IAAA,CAAKkG,KAAA,CAAMoN,aAAA,CACrDvT,EAAcC,IAAA,CAAKkG,KAAA,CAAMoN,aAAA,CAAgB,QAE3ChD,EAAQZ,sCAAA,CAAuCnR,GAAA,CAAI5B,IAErD2T,EAAQb,MAAA,CAAOlR,GAAA,CAAI5B,GACnB4W,IACO,KAEHxD,GACAO,IAAAA,EAAQZ,sCAAA,CAAuCuB,IAAA,EAE/ClR,CAAAA,EAAcC,IAAA,CAAKkG,KAAA,CAAMoN,aAAA,CAAgBjE,CAAAA,CAE7C,CACF,EAAG,CAAC1S,EAAMoD,EAAegQ,EAA6BO,EAAQ,EAQxDd,EAAAA,SAAA,CAAU,IACP,KACA7S,IACL2T,EAAQb,MAAA,CAAOhQ,MAAA,CAAO9C,GACtB2T,EAAQZ,sCAAA,CAAuCjQ,MAAA,CAAO9C,GACtD4W,IACF,EACC,CAAC5W,EAAM2T,EAAQ,EAEZd,EAAAA,SAAA,CAAU,KACd,IAAMgE,EAAe,IAAMhD,EAAM,CAAC,GAElC,OADA3Q,SAASiK,gBAAA,CAAiBwF,EAAgBkE,GACnC,IAAM3T,SAASkK,mBAAA,CAAoBuF,EAAgBkE,EAC5D,EAAG,EAAE,EAGHC,CAAAA,EAAAA,EAAAA,GAAAA,EAACC,EAAAA,EAASA,CAACC,GAAA,CAAV,CACE,GAAGtD,CAAA,CACJxP,IAAK4P,EACLvK,MAAO,CACLoN,cAAetC,EACXE,EACE,OACA,OACF,OACJ,GAAGpO,EAAMoD,KAAA,EAEX2M,eAAgBe,CAAAA,EAAAA,EAAAA,CAAAA,EAAqB9Q,EAAM+P,cAAA,CAAgBL,EAAaK,cAAc,EACtFC,cAAec,CAAAA,EAAAA,EAAAA,CAAAA,EAAqB9Q,EAAMgQ,aAAA,CAAeN,EAAaM,aAAa,EACnFX,qBAAsByB,CAAAA,EAAAA,EAAAA,CAAAA,EACpB9Q,EAAMqP,oBAAA,CACNhB,EAAmBgB,oBAAA,CACrB,EAGN,GA0JF,SAASoB,IACP,IAAMlI,EAAQ,IAAIwI,YAAYvE,GAC9BzP,SAASiU,aAAA,CAAczI,EACzB,CAEA,SAASsG,EACPvD,CAAA,CACA2F,CAAA,CACAC,CAAA,CACAC,CAAW,KAAX,CAAEpC,SAAAA,CAAA,CAAS,CAAXoC,EAEM3W,EAAS0W,EAAOlC,aAAA,CAAcxU,MAAA,CAC9B+N,EAAQ,IAAIwI,YAAYzF,EAAM,CAAE8F,QAAS,GAAO1F,WAAY,GAAMwF,OAAAA,CAAO,GAC3ED,GAASzW,EAAOwM,gBAAA,CAAiBsE,EAAM2F,EAA0B,CAAE/B,KAAM,EAAK,GAE9EH,EACFsC,CAAAA,EAAAA,EAAAA,EAAAA,EAA4B7W,EAAQ+N,GAEpC/N,EAAOwW,aAAA,CAAczI,EAEzB,CA3KAuE,EAAiBwE,WAAA,CArKc,mBAqM/BC,EArBqC7E,UAAA,CAGnC,CAAC1M,EAAO+M,KACR,IAAMS,EAAgBd,EAAAA,UAAA,CAAWD,GAC3B1O,EAAY2O,EAAAA,MAAA,CAAsC,MAClDiB,EAAeC,CAAAA,EAAAA,EAAAA,CAAAA,EAAgBb,EAAchP,GAYnD,OAVM2O,EAAAA,SAAA,CAAU,KACd,IAAM7S,EAAOkE,EAAIE,OAAA,CACjB,GAAIpE,EAEF,OADA2T,EAAQX,QAAA,CAASpR,GAAA,CAAI5B,GACd,KACL2T,EAAQX,QAAA,CAASlQ,MAAA,CAAO9C,EAC1B,CAEJ,EAAG,CAAC2T,EAAQX,QAAQ,CAAC,EAEd8D,CAAAA,EAAAA,EAAAA,GAAAA,EAACC,EAAAA,EAASA,CAACC,GAAA,CAAV,CAAe,GAAG7Q,CAAA,CAAOjC,IAAK4P,CAAA,EACxC,GAEuB2D,WAAA,CA1BH,+FCnLhBE,EAAQ,EAWZ,SAASC,IACD/E,EAAAA,SAAA,CAAU,SAEoCgF,EACDA,EAFjD,IAAMA,EAAa3U,SAASK,gBAAA,CAAiB,4BAK7C,OAJAL,SAASG,IAAA,CAAKyU,qBAAA,CAAsB,aAAcD,OAAAA,CAAAA,EAAAA,CAAA,CAAW,EAAC,GAAZA,KAAAA,IAAAA,EAAAA,EAAiBE,KACnE7U,SAASG,IAAA,CAAKyU,qBAAA,CAAsB,YAAaD,OAAAA,CAAAA,EAAAA,CAAA,CAAW,EAAC,GAAZA,KAAAA,IAAAA,EAAAA,EAAiBE,KAClEJ,IAEO,KACS,IAAVA,GACFzU,SAASK,gBAAA,CAAiB,4BAA4B1B,OAAA,CAAQ,GAAU7B,EAAKoK,MAAA,IAE/EuN,GACF,CACF,EAAG,EAAE,CACP,CAEA,SAASI,IACP,IAAMC,EAAU9U,SAASqF,aAAA,CAAc,QAOvC,OANAyP,EAAQtV,YAAA,CAAa,yBAA0B,IAC/CsV,EAAQC,QAAA,CAAW,EACnBD,EAAQzO,KAAA,CAAM2O,OAAA,CAAU,OACxBF,EAAQzO,KAAA,CAAM4O,OAAA,CAAU,IACxBH,EAAQzO,KAAA,CAAM8F,QAAA,CAAW,QACzB2I,EAAQzO,KAAA,CAAMoN,aAAA,CAAgB,OACvBqB,CACT,6BC+QMI,4FAjTAC,EAAqB,8BACrBC,EAAuB,gCACvBC,EAAgB,CAAEhB,QAAS,GAAO1F,WAAY,EAAK,EAwCnD2G,EAAmB3F,EAAAA,UAAA,CAA+C,CAAC1M,EAAO+M,KAC9E,GAAM,CACJuF,KAAAA,EAAO,GACPC,QAAAA,EAAU,GACVC,iBAAkBC,CAAA,CAClBC,mBAAoBC,CAAA,CACpB,GAAGC,EACL,CAAI5S,EACE,CAAC6S,EAAWC,EAAY,CAAUpG,EAAAA,QAAA,CAA6B,MAC/D8F,EAAmBhE,CAAAA,EAAAA,EAAAA,CAAAA,EAAeiE,GAClCC,EAAqBlE,CAAAA,EAAAA,EAAAA,CAAAA,EAAemE,GACpCI,EAA8BrG,EAAAA,MAAA,CAA2B,MACzDiB,EAAeC,CAAAA,EAAAA,EAAAA,CAAAA,EAAgBb,EAAc,GAAU+F,EAAajZ,IAEpEmZ,EAAmBtG,EAAAA,MAAA,CAAO,CAC9BuG,OAAQ,GACRC,QACE,KAAKD,MAAA,CAAS,EAChB,EACAE,SACE,KAAKF,MAAA,CAAS,EAChB,CACF,GAAGhV,OAAA,CAGGyO,EAAAA,SAAA,CAAU,KACd,GAAI6F,EAAS,CACX,IAASa,EAAT,SAAuB7K,CAAA,EACrB,GAAIyK,EAAWC,MAAA,EAAU,CAACJ,EAAW,OACrC,IAAMrY,EAAS+N,EAAM/N,MAAA,CACjBqY,EAAUnY,QAAA,CAASF,GACrBuY,EAAsB9U,OAAA,CAAUzD,EAEhC6Y,EAAMN,EAAsB9U,OAAA,CAAS,CAAEqV,OAAQ,EAAK,EAExD,EAESC,EAAT,SAAwBhL,CAAA,EACtB,GAAIyK,EAAWC,MAAA,EAAU,CAACJ,EAAW,OACrC,IAAMW,EAAgBjL,EAAMiL,aAAA,QAYxBA,GAICX,EAAUnY,QAAA,CAAS8Y,IACtBH,EAAMN,EAAsB9U,OAAA,CAAS,CAAEqV,OAAQ,EAAK,EAExD,EAaAvW,SAASiK,gBAAA,CAAiB,UAAWoM,GACrCrW,SAASiK,gBAAA,CAAiB,WAAYuM,GACtC,IAAME,EAAmB,IAAIC,iBAV7B,SAAyBC,CAAA,EAEvB,GAAIC,SAD4BC,aAAA,GACT9W,SAASG,IAAA,CAChC,QAAW4W,KAAYH,EACjBG,EAASC,YAAA,CAAapV,MAAA,CAAS,GAAG0U,EAAMR,EAEhD,GAOA,OAFIA,GAAWY,EAAiBO,OAAA,CAAQnB,EAAW,CAAEoB,UAAW,GAAMC,QAAS,EAAK,GAE7E,KACLnX,SAASkK,mBAAA,CAAoB,UAAWmM,GACxCrW,SAASkK,mBAAA,CAAoB,WAAYsM,GACzCE,EAAiBU,UAAA,EACnB,CACF,CACF,EAAG,CAAC5B,EAASM,EAAWG,EAAWC,MAAM,CAAC,EAEpCvG,EAAAA,SAAA,CAAU,KACd,GAAImG,EAAW,CACbuB,EAAiB3Y,GAAA,CAAIuX,GACrB,IAAMqB,EAA2BtX,SAAS8W,aAAA,CAG1C,GAAI,CAFwBhB,EAAUnY,QAAA,CAAS2Z,GAErB,CACxB,IAAMC,EAAa,IAAIvD,YAAYmB,EAAoBE,GACvDS,EAAU7L,gBAAA,CAAiBkL,EAAoBM,GAC/CK,EAAU7B,aAAA,CAAcsD,GACnBA,EAAW7E,gBAAA,GACd8E,SA2EUC,CAAA,KAA2B,CAAElB,OAAAA,EAAS,GAAM,CAAjBmB,UAAA9V,MAAA,IAAA8V,KAAA,IAAAA,SAAA,IAAAA,SAAA,IAAqB,CAAC,EAC7DJ,EAA2BtX,SAAS8W,aAAA,CAC1C,QAAWa,KAAaF,EAEtB,GADAnB,EAAMqB,EAAW,CAAEpB,OAAAA,CAAO,GACtBvW,SAAS8W,aAAA,GAAkBQ,EAA0B,MAE7D,EAsHSM,EAvM8C9B,GAuMxC/X,MAAA,CAAO,GAAUgE,MAAAA,EAAK4I,OAAA,EAvM+B,CAAE4L,OAAQ,EAAK,GACrEvW,SAAS8W,aAAA,GAAkBQ,GAC7BhB,EAAMR,GAGZ,CAEA,MAAO,KACLA,EAAU5L,mBAAA,CAAoBiL,EAAoBM,GAKlDzG,WAAW,KACT,IAAM6I,EAAe,IAAI7D,YAAYoB,EAAsBC,GAC3DS,EAAU7L,gBAAA,CAAiBmL,EAAsBO,GACjDG,EAAU7B,aAAA,CAAc4D,GACnBA,EAAanF,gBAAA,EAChB4D,EAAMgB,MAAAA,EAAAA,EAA4BtX,SAASG,IAAA,CAAM,CAAEoW,OAAQ,EAAK,GAGlET,EAAU5L,mBAAA,CAAoBkL,EAAsBO,GAEpD0B,EAAiBnQ,MAAA,CAAO+O,EAC1B,EAAG,EACL,CACF,CACF,EAAG,CAACH,EAAWL,EAAkBE,EAAoBM,EAAW,EAGhE,IAAM3C,EAAsB3D,EAAAA,WAAA,CAC1B,IACE,GAAI,CAAC4F,GAAQ,CAACC,GACVS,EAAWC,MAAA,CADQ,OAGvB,IAAM4B,EAAWtM,QAAAA,EAAM+H,GAAA,EAAiB,CAAC/H,EAAMuM,MAAA,EAAU,CAACvM,EAAMqC,OAAA,EAAW,CAACrC,EAAMwM,OAAA,CAC5EnB,EAAiB7W,SAAS8W,aAAA,CAEhC,GAAIgB,GAAYjB,EAAgB,CAC9B,IAAMf,EAAYtK,EAAMyM,aAAA,CAClB,CAACC,EAAOnT,EAAI,CAAIoT,SA8CJrC,CAAA,EACxB,IAAM2B,EAAaW,EAAsBtC,GAGzC,MAAO,CAFOuC,EAAYZ,EAAY3B,GACzBuC,EAAYZ,EAAWa,OAAA,GAAWxC,GAC5B,EAlD0BA,EACLoC,CAAAA,GAASnT,EAMrC,EAAOwT,QAAA,EAAY1B,IAAmB9R,EAG/ByG,EAAM+M,QAAA,EAAY1B,IAAmBqB,IAC9C1M,EAAMoD,cAAA,GACF2G,GAAMe,EAAMvR,EAAM,CAAEwR,OAAQ,EAAK,KAJrC/K,EAAMoD,cAAA,GACF2G,GAAMe,EAAM4B,EAAO,CAAE3B,OAAQ,EAAK,IAJpCM,IAAmBf,GAAWtK,EAAMoD,cAAA,EAU5C,CACF,EACA,CAAC2G,EAAMC,EAASS,EAAWC,MAAM,GAGnC,MACEtC,CAAAA,EAAAA,EAAAA,GAAAA,EAACC,EAAAA,EAASA,CAACC,GAAA,CAAV,CAAciB,SAAU,GAAK,GAAGc,CAAA,CAAY7U,IAAK4P,EAAc4H,UAAWlF,CAAA,EAE/E,GAwCA,SAAS8E,EAAsBtC,CAAA,EAC7B,IAAM2C,EAAuB,EAAC,CACxBC,EAAS1Y,SAAS2Y,gBAAA,CAAiB7C,EAAW8C,WAAWC,YAAA,CAAc,CAC3EC,WAAY,IACV,IAAMC,EAAgBjc,UAAAA,EAAK6N,OAAA,EAAuB7N,WAAAA,EAAK0J,IAAA,QACvD,EAASwS,QAAA,EAAYlc,EAAKmc,MAAA,EAAUF,EAAsBH,WAAWM,WAAA,CAI9Dpc,EAAKiY,QAAA,EAAY,EAAI6D,WAAWO,aAAA,CAAgBP,WAAWM,WAAA,CAEtE,GACA,KAAOR,EAAOU,QAAA,IAAYX,EAAMlZ,IAAA,CAAKmZ,EAAOW,WAA0B,EAGtE,OAAOZ,CACT,CAMA,SAASJ,EAAYiB,CAAA,CAAyBxD,CAAA,EAC5C,QAAWhB,KAAWwE,EAEpB,GAAI,CAACC,SAISzc,CAAA,CAAmBsX,CAAO,KAAP,CAAEoF,KAAAA,CAAA,CAAK,CAAPpF,EACnC,GAAIhM,WAAAA,iBAAiBtL,GAAM2c,UAAA,CAAyB,MAAO,GAC3D,KAEE,GAAID,CAAAA,KAAS,IAATA,GAAsB1c,IAAS0c,CAAAA,GAFxB,CAGX,GAAIpR,SAAAA,iBAAiBtL,GAAM4c,OAAA,CAAoB,MAAO,GACtD5c,EAAOA,EAAK6c,aAAA,CAEd,MAAO,EACT,EAbkB7E,EAAS,CAAE0E,KAAM1D,CAAU,GAAI,OAAOhB,CAExD,CAiBA,SAASwB,EAAMxB,CAAA,KAAkC,CAAEyB,OAAAA,EAAS,GAAM,CAAjBmB,UAAA9V,MAAA,IAAA8V,KAAA,IAAAA,SAAA,IAAAA,SAAA,IAAqB,CAAC,EAErE,GAAI5C,GAAWA,EAAQwB,KAAA,CAAO,KANLxB,EAOvB,IAAMwC,EAA2BtX,SAAS8W,aAAA,CAE1ChC,EAAQwB,KAAA,CAAM,CAAEsD,cAAe,EAAK,GAEhC9E,IAAYwC,GAVXxC,CADkBA,EAWuCA,aAVtC+E,kBAAoB,WAAY/E,GAUkByB,GACxEzB,EAAQyB,MAAA,EACZ,CACF,CA5FAjB,EAAWf,WAAA,CAhMc,aAmSzB,IAAM8C,GAIAnC,EAAyB,EAAC,CAEvB,CACLxW,IAAIuX,CAAA,EAEF,IAAM6D,EAAmB5E,CAAA,CAAM,EAAC,CAC5Be,IAAe6D,GACjBA,CAAAA,MAAAA,GAAAA,EAAkB3D,KAAA,IAIpBjB,CADAA,EAAQ6E,EAAY7E,EAAOe,EAAAA,EACrB+D,OAAA,CAAQ/D,EAChB,EAEA/O,OAAO+O,CAAA,MAELf,CAAO,QAAPA,CAAAA,EAAAA,CADAA,EAAQ6E,EAAY7E,EAAOe,EAAAA,CAC3B,CAAM,EAAC,GAAPf,KAAAA,IAAAA,GAAAA,EAAUkB,MAAA,EACZ,CACF,GAGF,SAAS2D,EAAeE,CAAA,CAAYlY,CAAA,EAClC,IAAMmY,EAAe,IAAID,EAAK,CACxB/I,EAAQgJ,EAAajJ,OAAA,CAAQlP,GAInC,OAHc,KAAVmP,GACFgJ,EAAaC,MAAA,CAAOjJ,EAAO,GAEtBgJ,CACT,mHC9TME,EAAezK,EAAAA,UAAA,CAAuC,CAAC1M,EAAO+M,SAInBC,EAAAA,EAH/C,GAAM,CAAE6F,UAAWuE,CAAA,CAAe,GAAGC,EAAY,CAAIrX,EAC/C,CAACsX,EAASC,EAAU,CAAU7K,EAAAA,QAAA,CAAS,IAC7CrO,CAAAA,EAAAA,EAAAA,CAAAA,EAAgB,IAAMkZ,EAAW,IAAO,EAAE,EAC1C,IAAM1E,EAAYuE,GAAkBE,GAAAA,CAAAA,OAAWtK,CAAAA,EAAAA,UAAAA,GAAAA,KAAAA,IAAAA,EAAAA,KAAAA,EAAAA,OAAAA,CAAAA,EAAAA,EAAYjQ,QAAA,GAAZiQ,KAAAA,IAAAA,EAAAA,KAAAA,EAAAA,EAAsB9P,IAAA,EACrE,OAAO2V,EACH2E,EAAAA,YAAS,CAAa7G,CAAAA,EAAAA,EAAAA,GAAAA,EAACC,EAAAA,EAASA,CAACC,GAAA,CAAV,CAAe,GAAGwG,CAAA,CAAatZ,IAAKgP,CAAA,GAAkB8F,GAC7E,IACN,EAEAsE,CAAAA,EAAO7F,WAAA,CArBa","sources":["webpack://_N_E/./node_modules/aria-hidden/dist/es2015/index.js","webpack://_N_E/./node_modules/react-remove-scroll-bar/dist/es2015/constants.js","webpack://_N_E/./node_modules/use-callback-ref/dist/es2015/assignRef.js","webpack://_N_E/./node_modules/use-callback-ref/dist/es2015/useRef.js","webpack://_N_E/./node_modules/use-callback-ref/dist/es2015/useMergeRef.js","webpack://_N_E/./node_modules/use-sidecar/dist/es2015/medium.js","webpack://_N_E/./node_modules/react-remove-scroll/dist/es2015/medium.js","webpack://_N_E/./node_modules/react-remove-scroll/dist/es2015/UI.js","webpack://_N_E/./node_modules/use-sidecar/dist/es2015/exports.js","webpack://_N_E/./node_modules/get-nonce/dist/es2015/index.js","webpack://_N_E/./node_modules/react-style-singleton/dist/es2015/singleton.js","webpack://_N_E/./node_modules/react-style-singleton/dist/es2015/hook.js","webpack://_N_E/./node_modules/react-style-singleton/dist/es2015/component.js","webpack://_N_E/./node_modules/react-style-singleton/dist/es2015/index.js","webpack://_N_E/./node_modules/react-remove-scroll-bar/dist/es2015/utils.js","webpack://_N_E/./node_modules/react-remove-scroll-bar/dist/es2015/component.js","webpack://_N_E/./node_modules/react-remove-scroll-bar/dist/es2015/index.js","webpack://_N_E/./node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js","webpack://_N_E/./node_modules/react-remove-scroll/dist/es2015/handleScroll.js","webpack://_N_E/./node_modules/react-remove-scroll/dist/es2015/SideEffect.js","webpack://_N_E/./node_modules/react-remove-scroll/dist/es2015/sidecar.js","webpack://_N_E/./node_modules/react-remove-scroll/dist/es2015/Combination.js","webpack://_N_E/./node_modules/@radix-ui/react-use-escape-keydown/dist/index.mjs","webpack://_N_E/../src/dismissable-layer.tsx","webpack://_N_E/../src/FocusGuards.tsx","webpack://_N_E/../src/focus-scope.tsx","webpack://_N_E/../src/portal.tsx"],"sourcesContent":["var getDefaultParent = function (originalTarget) {\n    if (typeof document === 'undefined') {\n        return null;\n    }\n    var sampleTarget = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;\n    return sampleTarget.ownerDocument.body;\n};\nvar counterMap = new WeakMap();\nvar uncontrolledNodes = new WeakMap();\nvar markerMap = {};\nvar lockCount = 0;\nvar unwrapHost = function (node) {\n    return node && (node.host || unwrapHost(node.parentNode));\n};\nvar correctTargets = function (parent, targets) {\n    return targets\n        .map(function (target) {\n        if (parent.contains(target)) {\n            return target;\n        }\n        var correctedTarget = unwrapHost(target);\n        if (correctedTarget && parent.contains(correctedTarget)) {\n            return correctedTarget;\n        }\n        console.error('aria-hidden', target, 'in not contained inside', parent, '. Doing nothing');\n        return null;\n    })\n        .filter(function (x) { return Boolean(x); });\n};\n/**\n * Marks everything except given node(or nodes) as aria-hidden\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @param {String} [controlAttribute] - html Attribute to control\n * @return {Undo} undo command\n */\nvar applyAttributeToOthers = function (originalTarget, parentNode, markerName, controlAttribute) {\n    var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);\n    if (!markerMap[markerName]) {\n        markerMap[markerName] = new WeakMap();\n    }\n    var markerCounter = markerMap[markerName];\n    var hiddenNodes = [];\n    var elementsToKeep = new Set();\n    var elementsToStop = new Set(targets);\n    var keep = function (el) {\n        if (!el || elementsToKeep.has(el)) {\n            return;\n        }\n        elementsToKeep.add(el);\n        keep(el.parentNode);\n    };\n    targets.forEach(keep);\n    var deep = function (parent) {\n        if (!parent || elementsToStop.has(parent)) {\n            return;\n        }\n        Array.prototype.forEach.call(parent.children, function (node) {\n            if (elementsToKeep.has(node)) {\n                deep(node);\n            }\n            else {\n                try {\n                    var attr = node.getAttribute(controlAttribute);\n                    var alreadyHidden = attr !== null && attr !== 'false';\n                    var counterValue = (counterMap.get(node) || 0) + 1;\n                    var markerValue = (markerCounter.get(node) || 0) + 1;\n                    counterMap.set(node, counterValue);\n                    markerCounter.set(node, markerValue);\n                    hiddenNodes.push(node);\n                    if (counterValue === 1 && alreadyHidden) {\n                        uncontrolledNodes.set(node, true);\n                    }\n                    if (markerValue === 1) {\n                        node.setAttribute(markerName, 'true');\n                    }\n                    if (!alreadyHidden) {\n                        node.setAttribute(controlAttribute, 'true');\n                    }\n                }\n                catch (e) {\n                    console.error('aria-hidden: cannot operate on ', node, e);\n                }\n            }\n        });\n    };\n    deep(parentNode);\n    elementsToKeep.clear();\n    lockCount++;\n    return function () {\n        hiddenNodes.forEach(function (node) {\n            var counterValue = counterMap.get(node) - 1;\n            var markerValue = markerCounter.get(node) - 1;\n            counterMap.set(node, counterValue);\n            markerCounter.set(node, markerValue);\n            if (!counterValue) {\n                if (!uncontrolledNodes.has(node)) {\n                    node.removeAttribute(controlAttribute);\n                }\n                uncontrolledNodes.delete(node);\n            }\n            if (!markerValue) {\n                node.removeAttribute(markerName);\n            }\n        });\n        lockCount--;\n        if (!lockCount) {\n            // clear\n            counterMap = new WeakMap();\n            counterMap = new WeakMap();\n            uncontrolledNodes = new WeakMap();\n            markerMap = {};\n        }\n    };\n};\n/**\n * Marks everything except given node(or nodes) as aria-hidden\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var hideOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-aria-hidden'; }\n    var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);\n    var activeParentNode = parentNode || getDefaultParent(originalTarget);\n    if (!activeParentNode) {\n        return function () { return null; };\n    }\n    // we should not hide ariaLive elements - https://github.com/theKashey/aria-hidden/issues/10\n    targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll('[aria-live]')));\n    return applyAttributeToOthers(targets, activeParentNode, markerName, 'aria-hidden');\n};\n/**\n * Marks everything except given node(or nodes) as inert\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var inertOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-inert-ed'; }\n    var activeParentNode = parentNode || getDefaultParent(originalTarget);\n    if (!activeParentNode) {\n        return function () { return null; };\n    }\n    return applyAttributeToOthers(originalTarget, activeParentNode, markerName, 'inert');\n};\n/**\n * @returns if current browser supports inert\n */\nexport var supportsInert = function () {\n    return typeof HTMLElement !== 'undefined' && HTMLElement.prototype.hasOwnProperty('inert');\n};\n/**\n * Automatic function to \"suppress\" DOM elements - _hide_ or _inert_ in the best possible way\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var suppressOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-suppressed'; }\n    return (supportsInert() ? inertOthers : hideOthers)(originalTarget, parentNode, markerName);\n};\n","export var zeroRightClassName = 'right-scroll-bar-position';\nexport var fullWidthClassName = 'width-before-scroll-bar';\nexport var noScrollbarsClassName = 'with-scroll-bars-hidden';\n/**\n * Name of a CSS variable containing the amount of \"hidden\" scrollbar\n * ! might be undefined ! use will fallback!\n */\nexport var removedBarSizeVariable = '--removed-body-scroll-bar-size';\n","/**\n * Assigns a value for a given ref, no matter of the ref format\n * @param {RefObject} ref - a callback function or ref object\n * @param value - a new value\n *\n * @see https://github.com/theKashey/use-callback-ref#assignref\n * @example\n * const refObject = useRef();\n * const refFn = (ref) => {....}\n *\n * assignRef(refObject, \"refValue\");\n * assignRef(refFn, \"refValue\");\n */\nexport function assignRef(ref, value) {\n    if (typeof ref === 'function') {\n        ref(value);\n    }\n    else if (ref) {\n        ref.current = value;\n    }\n    return ref;\n}\n","import { useState } from 'react';\n/**\n * creates a MutableRef with ref change callback\n * @param initialValue - initial ref value\n * @param {Function} callback - a callback to run when value changes\n *\n * @example\n * const ref = useCallbackRef(0, (newValue, oldValue) => console.log(oldValue, '->', newValue);\n * ref.current = 1;\n * // prints 0 -> 1\n *\n * @see https://reactjs.org/docs/hooks-reference.html#useref\n * @see https://github.com/theKashey/use-callback-ref#usecallbackref---to-replace-reactuseref\n * @returns {MutableRefObject}\n */\nexport function useCallbackRef(initialValue, callback) {\n    var ref = useState(function () { return ({\n        // value\n        value: initialValue,\n        // last callback\n        callback: callback,\n        // \"memoized\" public interface\n        facade: {\n            get current() {\n                return ref.value;\n            },\n            set current(value) {\n                var last = ref.value;\n                if (last !== value) {\n                    ref.value = value;\n                    ref.callback(value, last);\n                }\n            },\n        },\n    }); })[0];\n    // update callback\n    ref.callback = callback;\n    return ref.facade;\n}\n","import * as React from 'react';\nimport { assignRef } from './assignRef';\nimport { useCallbackRef } from './useRef';\nvar useIsomorphicLayoutEffect = typeof window !== 'undefined' ? React.useLayoutEffect : React.useEffect;\nvar currentValues = new WeakMap();\n/**\n * Merges two or more refs together providing a single interface to set their value\n * @param {RefObject|Ref} refs\n * @returns {MutableRefObject} - a new ref, which translates all changes to {refs}\n *\n * @see {@link mergeRefs} a version without buit-in memoization\n * @see https://github.com/theKashey/use-callback-ref#usemergerefs\n * @example\n * const Component = React.forwardRef((props, ref) => {\n *   const ownRef = useRef();\n *   const domRef = useMergeRefs([ref, ownRef]); // 👈 merge together\n *   return <div ref={domRef}>...</div>\n * }\n */\nexport function useMergeRefs(refs, defaultValue) {\n    var callbackRef = useCallbackRef(defaultValue || null, function (newValue) {\n        return refs.forEach(function (ref) { return assignRef(ref, newValue); });\n    });\n    // handle refs changes - added or removed\n    useIsomorphicLayoutEffect(function () {\n        var oldValue = currentValues.get(callbackRef);\n        if (oldValue) {\n            var prevRefs_1 = new Set(oldValue);\n            var nextRefs_1 = new Set(refs);\n            var current_1 = callbackRef.current;\n            prevRefs_1.forEach(function (ref) {\n                if (!nextRefs_1.has(ref)) {\n                    assignRef(ref, null);\n                }\n            });\n            nextRefs_1.forEach(function (ref) {\n                if (!prevRefs_1.has(ref)) {\n                    assignRef(ref, current_1);\n                }\n            });\n        }\n        currentValues.set(callbackRef, refs);\n    }, [refs]);\n    return callbackRef;\n}\n","import { __assign } from \"tslib\";\nfunction ItoI(a) {\n    return a;\n}\nfunction innerCreateMedium(defaults, middleware) {\n    if (middleware === void 0) { middleware = ItoI; }\n    var buffer = [];\n    var assigned = false;\n    var medium = {\n        read: function () {\n            if (assigned) {\n                throw new Error('Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`.');\n            }\n            if (buffer.length) {\n                return buffer[buffer.length - 1];\n            }\n            return defaults;\n        },\n        useMedium: function (data) {\n            var item = middleware(data, assigned);\n            buffer.push(item);\n            return function () {\n                buffer = buffer.filter(function (x) { return x !== item; });\n            };\n        },\n        assignSyncMedium: function (cb) {\n            assigned = true;\n            while (buffer.length) {\n                var cbs = buffer;\n                buffer = [];\n                cbs.forEach(cb);\n            }\n            buffer = {\n                push: function (x) { return cb(x); },\n                filter: function () { return buffer; },\n            };\n        },\n        assignMedium: function (cb) {\n            assigned = true;\n            var pendingQueue = [];\n            if (buffer.length) {\n                var cbs = buffer;\n                buffer = [];\n                cbs.forEach(cb);\n                pendingQueue = buffer;\n            }\n            var executeQueue = function () {\n                var cbs = pendingQueue;\n                pendingQueue = [];\n                cbs.forEach(cb);\n            };\n            var cycle = function () { return Promise.resolve().then(executeQueue); };\n            cycle();\n            buffer = {\n                push: function (x) {\n                    pendingQueue.push(x);\n                    cycle();\n                },\n                filter: function (filter) {\n                    pendingQueue = pendingQueue.filter(filter);\n                    return buffer;\n                },\n            };\n        },\n    };\n    return medium;\n}\nexport function createMedium(defaults, middleware) {\n    if (middleware === void 0) { middleware = ItoI; }\n    return innerCreateMedium(defaults, middleware);\n}\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function createSidecarMedium(options) {\n    if (options === void 0) { options = {}; }\n    var medium = innerCreateMedium(null);\n    medium.options = __assign({ async: true, ssr: false }, options);\n    return medium;\n}\n","import { createSidecarMedium } from 'use-sidecar';\nexport var effectCar = createSidecarMedium();\n","import { __assign, __rest } from \"tslib\";\nimport * as React from 'react';\nimport { fullWidthClassName, zeroRightClassName } from 'react-remove-scroll-bar/constants';\nimport { useMergeRefs } from 'use-callback-ref';\nimport { effectCar } from './medium';\nvar nothing = function () {\n    return;\n};\n/**\n * Removes scrollbar from the page and contain the scroll within the Lock\n */\nvar RemoveScroll = React.forwardRef(function (props, parentRef) {\n    var ref = React.useRef(null);\n    var _a = React.useState({\n        onScrollCapture: nothing,\n        onWheelCapture: nothing,\n        onTouchMoveCapture: nothing,\n    }), callbacks = _a[0], setCallbacks = _a[1];\n    var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? 'div' : _b, gapMode = props.gapMode, rest = __rest(props, [\"forwardProps\", \"children\", \"className\", \"removeScrollBar\", \"enabled\", \"shards\", \"sideCar\", \"noIsolation\", \"inert\", \"allowPinchZoom\", \"as\", \"gapMode\"]);\n    var SideCar = sideCar;\n    var containerRef = useMergeRefs([ref, parentRef]);\n    var containerProps = __assign(__assign({}, rest), callbacks);\n    return (React.createElement(React.Fragment, null,\n        enabled && (React.createElement(SideCar, { sideCar: effectCar, removeScrollBar: removeScrollBar, shards: shards, noIsolation: noIsolation, inert: inert, setCallbacks: setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref, gapMode: gapMode })),\n        forwardProps ? (React.cloneElement(React.Children.only(children), __assign(__assign({}, containerProps), { ref: containerRef }))) : (React.createElement(Container, __assign({}, containerProps, { className: className, ref: containerRef }), children))));\n});\nRemoveScroll.defaultProps = {\n    enabled: true,\n    removeScrollBar: true,\n    inert: false,\n};\nRemoveScroll.classNames = {\n    fullWidth: fullWidthClassName,\n    zeroRight: zeroRightClassName,\n};\nexport { RemoveScroll };\n","import { __assign, __rest } from \"tslib\";\nimport * as React from 'react';\nvar SideCar = function (_a) {\n    var sideCar = _a.sideCar, rest = __rest(_a, [\"sideCar\"]);\n    if (!sideCar) {\n        throw new Error('Sidecar: please provide `sideCar` property to import the right car');\n    }\n    var Target = sideCar.read();\n    if (!Target) {\n        throw new Error('Sidecar medium not found');\n    }\n    return React.createElement(Target, __assign({}, rest));\n};\nSideCar.isSideCarExport = true;\nexport function exportSidecar(medium, exported) {\n    medium.useMedium(exported);\n    return SideCar;\n}\n","var currentNonce;\nexport var setNonce = function (nonce) {\n    currentNonce = nonce;\n};\nexport var getNonce = function () {\n    if (currentNonce) {\n        return currentNonce;\n    }\n    if (typeof __webpack_nonce__ !== 'undefined') {\n        return __webpack_nonce__;\n    }\n    return undefined;\n};\n","import { getNonce } from 'get-nonce';\nfunction makeStyleTag() {\n    if (!document)\n        return null;\n    var tag = document.createElement('style');\n    tag.type = 'text/css';\n    var nonce = getNonce();\n    if (nonce) {\n        tag.setAttribute('nonce', nonce);\n    }\n    return tag;\n}\nfunction injectStyles(tag, css) {\n    // @ts-ignore\n    if (tag.styleSheet) {\n        // @ts-ignore\n        tag.styleSheet.cssText = css;\n    }\n    else {\n        tag.appendChild(document.createTextNode(css));\n    }\n}\nfunction insertStyleTag(tag) {\n    var head = document.head || document.getElementsByTagName('head')[0];\n    head.appendChild(tag);\n}\nexport var stylesheetSingleton = function () {\n    var counter = 0;\n    var stylesheet = null;\n    return {\n        add: function (style) {\n            if (counter == 0) {\n                if ((stylesheet = makeStyleTag())) {\n                    injectStyles(stylesheet, style);\n                    insertStyleTag(stylesheet);\n                }\n            }\n            counter++;\n        },\n        remove: function () {\n            counter--;\n            if (!counter && stylesheet) {\n                stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet);\n                stylesheet = null;\n            }\n        },\n    };\n};\n","import * as React from 'react';\nimport { stylesheetSingleton } from './singleton';\n/**\n * creates a hook to control style singleton\n * @see {@link styleSingleton} for a safer component version\n * @example\n * ```tsx\n * const useStyle = styleHookSingleton();\n * ///\n * useStyle('body { overflow: hidden}');\n */\nexport var styleHookSingleton = function () {\n    var sheet = stylesheetSingleton();\n    return function (styles, isDynamic) {\n        React.useEffect(function () {\n            sheet.add(styles);\n            return function () {\n                sheet.remove();\n            };\n        }, [styles && isDynamic]);\n    };\n};\n","import { styleHookSingleton } from './hook';\n/**\n * create a Component to add styles on demand\n * - styles are added when first instance is mounted\n * - styles are removed when the last instance is unmounted\n * - changing styles in runtime does nothing unless dynamic is set. But with multiple components that can lead to the undefined behavior\n */\nexport var styleSingleton = function () {\n    var useStyle = styleHookSingleton();\n    var Sheet = function (_a) {\n        var styles = _a.styles, dynamic = _a.dynamic;\n        useStyle(styles, dynamic);\n        return null;\n    };\n    return Sheet;\n};\n","export { styleSingleton } from './component';\nexport { stylesheetSingleton } from './singleton';\nexport { styleHookSingleton } from './hook';\n","export var zeroGap = {\n    left: 0,\n    top: 0,\n    right: 0,\n    gap: 0,\n};\nvar parse = function (x) { return parseInt(x || '', 10) || 0; };\nvar getOffset = function (gapMode) {\n    var cs = window.getComputedStyle(document.body);\n    var left = cs[gapMode === 'padding' ? 'paddingLeft' : 'marginLeft'];\n    var top = cs[gapMode === 'padding' ? 'paddingTop' : 'marginTop'];\n    var right = cs[gapMode === 'padding' ? 'paddingRight' : 'marginRight'];\n    return [parse(left), parse(top), parse(right)];\n};\nexport var getGapWidth = function (gapMode) {\n    if (gapMode === void 0) { gapMode = 'margin'; }\n    if (typeof window === 'undefined') {\n        return zeroGap;\n    }\n    var offsets = getOffset(gapMode);\n    var documentWidth = document.documentElement.clientWidth;\n    var windowWidth = window.innerWidth;\n    return {\n        left: offsets[0],\n        top: offsets[1],\n        right: offsets[2],\n        gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0]),\n    };\n};\n","import * as React from 'react';\nimport { styleSingleton } from 'react-style-singleton';\nimport { fullWidthClassName, zeroRightClassName, noScrollbarsClassName, removedBarSizeVariable } from './constants';\nimport { getGapWidth } from './utils';\nvar Style = styleSingleton();\nexport var lockAttribute = 'data-scroll-locked';\n// important tip - once we measure scrollBar width and remove them\n// we could not repeat this operation\n// thus we are using style-singleton - only the first \"yet correct\" style will be applied.\nvar getStyles = function (_a, allowRelative, gapMode, important) {\n    var left = _a.left, top = _a.top, right = _a.right, gap = _a.gap;\n    if (gapMode === void 0) { gapMode = 'margin'; }\n    return \"\\n  .\".concat(noScrollbarsClassName, \" {\\n   overflow: hidden \").concat(important, \";\\n   padding-right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  body[\").concat(lockAttribute, \"] {\\n    overflow: hidden \").concat(important, \";\\n    overscroll-behavior: contain;\\n    \").concat([\n        allowRelative && \"position: relative \".concat(important, \";\"),\n        gapMode === 'margin' &&\n            \"\\n    padding-left: \".concat(left, \"px;\\n    padding-top: \").concat(top, \"px;\\n    padding-right: \").concat(right, \"px;\\n    margin-left:0;\\n    margin-top:0;\\n    margin-right: \").concat(gap, \"px \").concat(important, \";\\n    \"),\n        gapMode === 'padding' && \"padding-right: \".concat(gap, \"px \").concat(important, \";\"),\n    ]\n        .filter(Boolean)\n        .join(''), \"\\n  }\\n  \\n  .\").concat(zeroRightClassName, \" {\\n    right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  \\n  .\").concat(fullWidthClassName, \" {\\n    margin-right: \").concat(gap, \"px \").concat(important, \";\\n  }\\n  \\n  .\").concat(zeroRightClassName, \" .\").concat(zeroRightClassName, \" {\\n    right: 0 \").concat(important, \";\\n  }\\n  \\n  .\").concat(fullWidthClassName, \" .\").concat(fullWidthClassName, \" {\\n    margin-right: 0 \").concat(important, \";\\n  }\\n  \\n  body[\").concat(lockAttribute, \"] {\\n    \").concat(removedBarSizeVariable, \": \").concat(gap, \"px;\\n  }\\n\");\n};\nvar getCurrentUseCounter = function () {\n    var counter = parseInt(document.body.getAttribute(lockAttribute) || '0', 10);\n    return isFinite(counter) ? counter : 0;\n};\nexport var useLockAttribute = function () {\n    React.useEffect(function () {\n        document.body.setAttribute(lockAttribute, (getCurrentUseCounter() + 1).toString());\n        return function () {\n            var newCounter = getCurrentUseCounter() - 1;\n            if (newCounter <= 0) {\n                document.body.removeAttribute(lockAttribute);\n            }\n            else {\n                document.body.setAttribute(lockAttribute, newCounter.toString());\n            }\n        };\n    }, []);\n};\n/**\n * Removes page scrollbar and blocks page scroll when mounted\n */\nexport var RemoveScrollBar = function (_a) {\n    var noRelative = _a.noRelative, noImportant = _a.noImportant, _b = _a.gapMode, gapMode = _b === void 0 ? 'margin' : _b;\n    useLockAttribute();\n    /*\n     gap will be measured on every component mount\n     however it will be used only by the \"first\" invocation\n     due to singleton nature of <Style\n     */\n    var gap = React.useMemo(function () { return getGapWidth(gapMode); }, [gapMode]);\n    return React.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? '!important' : '') });\n};\n","import { RemoveScrollBar } from './component';\nimport { zeroRightClassName, fullWidthClassName, noScrollbarsClassName, removedBarSizeVariable } from './constants';\nimport { getGapWidth } from './utils';\nexport { RemoveScrollBar, zeroRightClassName, fullWidthClassName, noScrollbarsClassName, removedBarSizeVariable, getGapWidth, };\n","var passiveSupported = false;\nif (typeof window !== 'undefined') {\n    try {\n        var options = Object.defineProperty({}, 'passive', {\n            get: function () {\n                passiveSupported = true;\n                return true;\n            },\n        });\n        // @ts-ignore\n        window.addEventListener('test', options, options);\n        // @ts-ignore\n        window.removeEventListener('test', options, options);\n    }\n    catch (err) {\n        passiveSupported = false;\n    }\n}\nexport var nonPassive = passiveSupported ? { passive: false } : false;\n","var alwaysContainsScroll = function (node) {\n    // textarea will always _contain_ scroll inside self. It only can be hidden\n    return node.tagName === 'TEXTAREA';\n};\nvar elementCanBeScrolled = function (node, overflow) {\n    if (!(node instanceof Element)) {\n        return false;\n    }\n    var styles = window.getComputedStyle(node);\n    return (\n    // not-not-scrollable\n    styles[overflow] !== 'hidden' &&\n        // contains scroll inside self\n        !(styles.overflowY === styles.overflowX && !alwaysContainsScroll(node) && styles[overflow] === 'visible'));\n};\nvar elementCouldBeVScrolled = function (node) { return elementCanBeScrolled(node, 'overflowY'); };\nvar elementCouldBeHScrolled = function (node) { return elementCanBeScrolled(node, 'overflowX'); };\nexport var locationCouldBeScrolled = function (axis, node) {\n    var ownerDocument = node.ownerDocument;\n    var current = node;\n    do {\n        // Skip over shadow root\n        if (typeof ShadowRoot !== 'undefined' && current instanceof ShadowRoot) {\n            current = current.host;\n        }\n        var isScrollable = elementCouldBeScrolled(axis, current);\n        if (isScrollable) {\n            var _a = getScrollVariables(axis, current), scrollHeight = _a[1], clientHeight = _a[2];\n            if (scrollHeight > clientHeight) {\n                return true;\n            }\n        }\n        current = current.parentNode;\n    } while (current && current !== ownerDocument.body);\n    return false;\n};\nvar getVScrollVariables = function (_a) {\n    var scrollTop = _a.scrollTop, scrollHeight = _a.scrollHeight, clientHeight = _a.clientHeight;\n    return [\n        scrollTop,\n        scrollHeight,\n        clientHeight,\n    ];\n};\nvar getHScrollVariables = function (_a) {\n    var scrollLeft = _a.scrollLeft, scrollWidth = _a.scrollWidth, clientWidth = _a.clientWidth;\n    return [\n        scrollLeft,\n        scrollWidth,\n        clientWidth,\n    ];\n};\nvar elementCouldBeScrolled = function (axis, node) {\n    return axis === 'v' ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node);\n};\nvar getScrollVariables = function (axis, node) {\n    return axis === 'v' ? getVScrollVariables(node) : getHScrollVariables(node);\n};\nvar getDirectionFactor = function (axis, direction) {\n    /**\n     * If the element's direction is rtl (right-to-left), then scrollLeft is 0 when the scrollbar is at its rightmost position,\n     * and then increasingly negative as you scroll towards the end of the content.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollLeft\n     */\n    return axis === 'h' && direction === 'rtl' ? -1 : 1;\n};\nexport var handleScroll = function (axis, endTarget, event, sourceDelta, noOverscroll) {\n    var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction);\n    var delta = directionFactor * sourceDelta;\n    // find scrollable target\n    var target = event.target;\n    var targetInLock = endTarget.contains(target);\n    var shouldCancelScroll = false;\n    var isDeltaPositive = delta > 0;\n    var availableScroll = 0;\n    var availableScrollTop = 0;\n    do {\n        var _a = getScrollVariables(axis, target), position = _a[0], scroll_1 = _a[1], capacity = _a[2];\n        var elementScroll = scroll_1 - capacity - directionFactor * position;\n        if (position || elementScroll) {\n            if (elementCouldBeScrolled(axis, target)) {\n                availableScroll += elementScroll;\n                availableScrollTop += position;\n            }\n        }\n        if (target instanceof ShadowRoot) {\n            target = target.host;\n        }\n        else {\n            target = target.parentNode;\n        }\n    } while (\n    // portaled content\n    (!targetInLock && target !== document.body) ||\n        // self content\n        (targetInLock && (endTarget.contains(target) || endTarget === target)));\n    // handle epsilon around 0 (non standard zoom levels)\n    if (isDeltaPositive &&\n        ((noOverscroll && Math.abs(availableScroll) < 1) || (!noOverscroll && delta > availableScroll))) {\n        shouldCancelScroll = true;\n    }\n    else if (!isDeltaPositive &&\n        ((noOverscroll && Math.abs(availableScrollTop) < 1) || (!noOverscroll && -delta > availableScrollTop))) {\n        shouldCancelScroll = true;\n    }\n    return shouldCancelScroll;\n};\n","import { __spreadArray } from \"tslib\";\nimport * as React from 'react';\nimport { RemoveScrollBar } from 'react-remove-scroll-bar';\nimport { styleSingleton } from 'react-style-singleton';\nimport { nonPassive } from './aggresiveCapture';\nimport { handleScroll, locationCouldBeScrolled } from './handleScroll';\nexport var getTouchXY = function (event) {\n    return 'changedTouches' in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0];\n};\nexport var getDeltaXY = function (event) { return [event.deltaX, event.deltaY]; };\nvar extractRef = function (ref) {\n    return ref && 'current' in ref ? ref.current : ref;\n};\nvar deltaCompare = function (x, y) { return x[0] === y[0] && x[1] === y[1]; };\nvar generateStyle = function (id) { return \"\\n  .block-interactivity-\".concat(id, \" {pointer-events: none;}\\n  .allow-interactivity-\").concat(id, \" {pointer-events: all;}\\n\"); };\nvar idCounter = 0;\nvar lockStack = [];\nexport function RemoveScrollSideCar(props) {\n    var shouldPreventQueue = React.useRef([]);\n    var touchStartRef = React.useRef([0, 0]);\n    var activeAxis = React.useRef();\n    var id = React.useState(idCounter++)[0];\n    var Style = React.useState(styleSingleton)[0];\n    var lastProps = React.useRef(props);\n    React.useEffect(function () {\n        lastProps.current = props;\n    }, [props]);\n    React.useEffect(function () {\n        if (props.inert) {\n            document.body.classList.add(\"block-interactivity-\".concat(id));\n            var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean);\n            allow_1.forEach(function (el) { return el.classList.add(\"allow-interactivity-\".concat(id)); });\n            return function () {\n                document.body.classList.remove(\"block-interactivity-\".concat(id));\n                allow_1.forEach(function (el) { return el.classList.remove(\"allow-interactivity-\".concat(id)); });\n            };\n        }\n        return;\n    }, [props.inert, props.lockRef.current, props.shards]);\n    var shouldCancelEvent = React.useCallback(function (event, parent) {\n        if (('touches' in event && event.touches.length === 2) || (event.type === 'wheel' && event.ctrlKey)) {\n            return !lastProps.current.allowPinchZoom;\n        }\n        var touch = getTouchXY(event);\n        var touchStart = touchStartRef.current;\n        var deltaX = 'deltaX' in event ? event.deltaX : touchStart[0] - touch[0];\n        var deltaY = 'deltaY' in event ? event.deltaY : touchStart[1] - touch[1];\n        var currentAxis;\n        var target = event.target;\n        var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? 'h' : 'v';\n        // allow horizontal touch move on Range inputs. They will not cause any scroll\n        if ('touches' in event && moveDirection === 'h' && target.type === 'range') {\n            return false;\n        }\n        var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n        if (!canBeScrolledInMainDirection) {\n            return true;\n        }\n        if (canBeScrolledInMainDirection) {\n            currentAxis = moveDirection;\n        }\n        else {\n            currentAxis = moveDirection === 'v' ? 'h' : 'v';\n            canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target);\n            // other axis might be not scrollable\n        }\n        if (!canBeScrolledInMainDirection) {\n            return false;\n        }\n        if (!activeAxis.current && 'changedTouches' in event && (deltaX || deltaY)) {\n            activeAxis.current = currentAxis;\n        }\n        if (!currentAxis) {\n            return true;\n        }\n        var cancelingAxis = activeAxis.current || currentAxis;\n        return handleScroll(cancelingAxis, parent, event, cancelingAxis === 'h' ? deltaX : deltaY, true);\n    }, []);\n    var shouldPrevent = React.useCallback(function (_event) {\n        var event = _event;\n        if (!lockStack.length || lockStack[lockStack.length - 1] !== Style) {\n            // not the last active\n            return;\n        }\n        var delta = 'deltaY' in event ? getDeltaXY(event) : getTouchXY(event);\n        var sourceEvent = shouldPreventQueue.current.filter(function (e) { return e.name === event.type && (e.target === event.target || event.target === e.shadowParent) && deltaCompare(e.delta, delta); })[0];\n        // self event, and should be canceled\n        if (sourceEvent && sourceEvent.should) {\n            if (event.cancelable) {\n                event.preventDefault();\n            }\n            return;\n        }\n        // outside or shard event\n        if (!sourceEvent) {\n            var shardNodes = (lastProps.current.shards || [])\n                .map(extractRef)\n                .filter(Boolean)\n                .filter(function (node) { return node.contains(event.target); });\n            var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation;\n            if (shouldStop) {\n                if (event.cancelable) {\n                    event.preventDefault();\n                }\n            }\n        }\n    }, []);\n    var shouldCancel = React.useCallback(function (name, delta, target, should) {\n        var event = { name: name, delta: delta, target: target, should: should, shadowParent: getOutermostShadowParent(target) };\n        shouldPreventQueue.current.push(event);\n        setTimeout(function () {\n            shouldPreventQueue.current = shouldPreventQueue.current.filter(function (e) { return e !== event; });\n        }, 1);\n    }, []);\n    var scrollTouchStart = React.useCallback(function (event) {\n        touchStartRef.current = getTouchXY(event);\n        activeAxis.current = undefined;\n    }, []);\n    var scrollWheel = React.useCallback(function (event) {\n        shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n    }, []);\n    var scrollTouchMove = React.useCallback(function (event) {\n        shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current));\n    }, []);\n    React.useEffect(function () {\n        lockStack.push(Style);\n        props.setCallbacks({\n            onScrollCapture: scrollWheel,\n            onWheelCapture: scrollWheel,\n            onTouchMoveCapture: scrollTouchMove,\n        });\n        document.addEventListener('wheel', shouldPrevent, nonPassive);\n        document.addEventListener('touchmove', shouldPrevent, nonPassive);\n        document.addEventListener('touchstart', scrollTouchStart, nonPassive);\n        return function () {\n            lockStack = lockStack.filter(function (inst) { return inst !== Style; });\n            document.removeEventListener('wheel', shouldPrevent, nonPassive);\n            document.removeEventListener('touchmove', shouldPrevent, nonPassive);\n            document.removeEventListener('touchstart', scrollTouchStart, nonPassive);\n        };\n    }, []);\n    var removeScrollBar = props.removeScrollBar, inert = props.inert;\n    return (React.createElement(React.Fragment, null,\n        inert ? React.createElement(Style, { styles: generateStyle(id) }) : null,\n        removeScrollBar ? React.createElement(RemoveScrollBar, { gapMode: props.gapMode }) : null));\n}\nfunction getOutermostShadowParent(node) {\n    var shadowParent = null;\n    while (node !== null) {\n        if (node instanceof ShadowRoot) {\n            shadowParent = node.host;\n            node = node.host;\n        }\n        node = node.parentNode;\n    }\n    return shadowParent;\n}\n","import { exportSidecar } from 'use-sidecar';\nimport { RemoveScrollSideCar } from './SideEffect';\nimport { effectCar } from './medium';\nexport default exportSidecar(effectCar, RemoveScrollSideCar);\n","import { __assign } from \"tslib\";\nimport * as React from 'react';\nimport { RemoveScroll } from './UI';\nimport SideCar from './sidecar';\nvar ReactRemoveScroll = React.forwardRef(function (props, ref) { return (React.createElement(RemoveScroll, __assign({}, props, { ref: ref, sideCar: SideCar }))); });\nReactRemoveScroll.classNames = RemoveScroll.classNames;\nexport default ReactRemoveScroll;\n","// packages/react/use-escape-keydown/src/useEscapeKeydown.tsx\nimport * as React from \"react\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nfunction useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {\n  const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);\n  React.useEffect(() => {\n    const handleKeyDown = (event) => {\n      if (event.key === \"Escape\") {\n        onEscapeKeyDown(event);\n      }\n    };\n    ownerDocument.addEventListener(\"keydown\", handleKeyDown, { capture: true });\n    return () => ownerDocument.removeEventListener(\"keydown\", handleKeyDown, { capture: true });\n  }, [onEscapeKeyDown, ownerDocument]);\n}\nexport {\n  useEscapeKeydown\n};\n//# sourceMappingURL=index.mjs.map\n","import * as React from 'react';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { Primitive, dispatchDiscreteCustomEvent } from '@radix-ui/react-primitive';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { useCallbackRef } from '@radix-ui/react-use-callback-ref';\nimport { useEscapeKeydown } from '@radix-ui/react-use-escape-keydown';\n\n/* -------------------------------------------------------------------------------------------------\n * DismissableLayer\n * -----------------------------------------------------------------------------------------------*/\n\nconst DISMISSABLE_LAYER_NAME = 'DismissableLayer';\nconst CONTEXT_UPDATE = 'dismissableLayer.update';\nconst POINTER_DOWN_OUTSIDE = 'dismissableLayer.pointerDownOutside';\nconst FOCUS_OUTSIDE = 'dismissableLayer.focusOutside';\n\nlet originalBodyPointerEvents: string;\n\nconst DismissableLayerContext = React.createContext({\n  layers: new Set<DismissableLayerElement>(),\n  layersWithOutsidePointerEventsDisabled: new Set<DismissableLayerElement>(),\n  branches: new Set<DismissableLayerBranchElement>(),\n});\n\ntype DismissableLayerElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface DismissableLayerProps extends PrimitiveDivProps {\n  /**\n   * When `true`, hover/focus/click interactions will be disabled on elements outside\n   * the `DismissableLayer`. Users will need to click twice on outside elements to\n   * interact with them: once to close the `DismissableLayer`, and again to trigger the element.\n   */\n  disableOutsidePointerEvents?: boolean;\n  /**\n   * Event handler called when the escape key is down.\n   * Can be prevented.\n   */\n  onEscapeKeyDown?: (event: KeyboardEvent) => void;\n  /**\n   * Event handler called when the a `pointerdown` event happens outside of the `DismissableLayer`.\n   * Can be prevented.\n   */\n  onPointerDownOutside?: (event: PointerDownOutsideEvent) => void;\n  /**\n   * Event handler called when the focus moves outside of the `DismissableLayer`.\n   * Can be prevented.\n   */\n  onFocusOutside?: (event: FocusOutsideEvent) => void;\n  /**\n   * Event handler called when an interaction happens outside the `DismissableLayer`.\n   * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.\n   * Can be prevented.\n   */\n  onInteractOutside?: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;\n  /**\n   * Handler called when the `DismissableLayer` should be dismissed\n   */\n  onDismiss?: () => void;\n}\n\nconst DismissableLayer = React.forwardRef<DismissableLayerElement, DismissableLayerProps>(\n  (props, forwardedRef) => {\n    const {\n      disableOutsidePointerEvents = false,\n      onEscapeKeyDown,\n      onPointerDownOutside,\n      onFocusOutside,\n      onInteractOutside,\n      onDismiss,\n      ...layerProps\n    } = props;\n    const context = React.useContext(DismissableLayerContext);\n    const [node, setNode] = React.useState<DismissableLayerElement | null>(null);\n    const ownerDocument = node?.ownerDocument ?? globalThis?.document;\n    const [, force] = React.useState({});\n    const composedRefs = useComposedRefs(forwardedRef, (node) => setNode(node));\n    const layers = Array.from(context.layers);\n    const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1); // prettier-ignore\n    const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled); // prettier-ignore\n    const index = node ? layers.indexOf(node) : -1;\n    const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;\n    const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;\n\n    const pointerDownOutside = usePointerDownOutside((event) => {\n      const target = event.target as HTMLElement;\n      const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (!isPointerEventsEnabled || isPointerDownOnBranch) return;\n      onPointerDownOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n\n    const focusOutside = useFocusOutside((event) => {\n      const target = event.target as HTMLElement;\n      const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (isFocusInBranch) return;\n      onFocusOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n\n    useEscapeKeydown((event) => {\n      const isHighestLayer = index === context.layers.size - 1;\n      if (!isHighestLayer) return;\n      onEscapeKeyDown?.(event);\n      if (!event.defaultPrevented && onDismiss) {\n        event.preventDefault();\n        onDismiss();\n      }\n    }, ownerDocument);\n\n    React.useEffect(() => {\n      if (!node) return;\n      if (disableOutsidePointerEvents) {\n        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {\n          originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;\n          ownerDocument.body.style.pointerEvents = 'none';\n        }\n        context.layersWithOutsidePointerEventsDisabled.add(node);\n      }\n      context.layers.add(node);\n      dispatchUpdate();\n      return () => {\n        if (\n          disableOutsidePointerEvents &&\n          context.layersWithOutsidePointerEventsDisabled.size === 1\n        ) {\n          ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;\n        }\n      };\n    }, [node, ownerDocument, disableOutsidePointerEvents, context]);\n\n    /**\n     * We purposefully prevent combining this effect with the `disableOutsidePointerEvents` effect\n     * because a change to `disableOutsidePointerEvents` would remove this layer from the stack\n     * and add it to the end again so the layering order wouldn't be _creation order_.\n     * We only want them to be removed from context stacks when unmounted.\n     */\n    React.useEffect(() => {\n      return () => {\n        if (!node) return;\n        context.layers.delete(node);\n        context.layersWithOutsidePointerEventsDisabled.delete(node);\n        dispatchUpdate();\n      };\n    }, [node, context]);\n\n    React.useEffect(() => {\n      const handleUpdate = () => force({});\n      document.addEventListener(CONTEXT_UPDATE, handleUpdate);\n      return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);\n    }, []);\n\n    return (\n      <Primitive.div\n        {...layerProps}\n        ref={composedRefs}\n        style={{\n          pointerEvents: isBodyPointerEventsDisabled\n            ? isPointerEventsEnabled\n              ? 'auto'\n              : 'none'\n            : undefined,\n          ...props.style,\n        }}\n        onFocusCapture={composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture)}\n        onBlurCapture={composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture)}\n        onPointerDownCapture={composeEventHandlers(\n          props.onPointerDownCapture,\n          pointerDownOutside.onPointerDownCapture\n        )}\n      />\n    );\n  }\n);\n\nDismissableLayer.displayName = DISMISSABLE_LAYER_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * DismissableLayerBranch\n * -----------------------------------------------------------------------------------------------*/\n\nconst BRANCH_NAME = 'DismissableLayerBranch';\n\ntype DismissableLayerBranchElement = React.ElementRef<typeof Primitive.div>;\ninterface DismissableLayerBranchProps extends PrimitiveDivProps {}\n\nconst DismissableLayerBranch = React.forwardRef<\n  DismissableLayerBranchElement,\n  DismissableLayerBranchProps\n>((props, forwardedRef) => {\n  const context = React.useContext(DismissableLayerContext);\n  const ref = React.useRef<DismissableLayerBranchElement>(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n\n  React.useEffect(() => {\n    const node = ref.current;\n    if (node) {\n      context.branches.add(node);\n      return () => {\n        context.branches.delete(node);\n      };\n    }\n  }, [context.branches]);\n\n  return <Primitive.div {...props} ref={composedRefs} />;\n});\n\nDismissableLayerBranch.displayName = BRANCH_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype PointerDownOutsideEvent = CustomEvent<{ originalEvent: PointerEvent }>;\ntype FocusOutsideEvent = CustomEvent<{ originalEvent: FocusEvent }>;\n\n/**\n * Listens for `pointerdown` outside a react subtree. We use `pointerdown` rather than `pointerup`\n * to mimic layer dismissing behaviour present in OS.\n * Returns props to pass to the node we want to check for outside events.\n */\nfunction usePointerDownOutside(\n  onPointerDownOutside?: (event: PointerDownOutsideEvent) => void,\n  ownerDocument: Document = globalThis?.document\n) {\n  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside) as EventListener;\n  const isPointerInsideReactTreeRef = React.useRef(false);\n  const handleClickRef = React.useRef(() => {});\n\n  React.useEffect(() => {\n    const handlePointerDown = (event: PointerEvent) => {\n      if (event.target && !isPointerInsideReactTreeRef.current) {\n        const eventDetail = { originalEvent: event };\n\n        function handleAndDispatchPointerDownOutsideEvent() {\n          handleAndDispatchCustomEvent(\n            POINTER_DOWN_OUTSIDE,\n            handlePointerDownOutside,\n            eventDetail,\n            { discrete: true }\n          );\n        }\n\n        /**\n         * On touch devices, we need to wait for a click event because browsers implement\n         * a ~350ms delay between the time the user stops touching the display and when the\n         * browser executres events. We need to ensure we don't reactivate pointer-events within\n         * this timeframe otherwise the browser may execute events that should have been prevented.\n         *\n         * Additionally, this also lets us deal automatically with cancellations when a click event\n         * isn't raised because the page was considered scrolled/drag-scrolled, long-pressed, etc.\n         *\n         * This is why we also continuously remove the previous listener, because we cannot be\n         * certain that it was raised, and therefore cleaned-up.\n         */\n        if (event.pointerType === 'touch') {\n          ownerDocument.removeEventListener('click', handleClickRef.current);\n          handleClickRef.current = handleAndDispatchPointerDownOutsideEvent;\n          ownerDocument.addEventListener('click', handleClickRef.current, { once: true });\n        } else {\n          handleAndDispatchPointerDownOutsideEvent();\n        }\n      } else {\n        // We need to remove the event listener in case the outside click has been canceled.\n        // See: https://github.com/radix-ui/primitives/issues/2171\n        ownerDocument.removeEventListener('click', handleClickRef.current);\n      }\n      isPointerInsideReactTreeRef.current = false;\n    };\n    /**\n     * if this hook executes in a component that mounts via a `pointerdown` event, the event\n     * would bubble up to the document and trigger a `pointerDownOutside` event. We avoid\n     * this by delaying the event listener registration on the document.\n     * This is not React specific, but rather how the DOM works, ie:\n     * ```\n     * button.addEventListener('pointerdown', () => {\n     *   console.log('I will log');\n     *   document.addEventListener('pointerdown', () => {\n     *     console.log('I will also log');\n     *   })\n     * });\n     */\n    const timerId = window.setTimeout(() => {\n      ownerDocument.addEventListener('pointerdown', handlePointerDown);\n    }, 0);\n    return () => {\n      window.clearTimeout(timerId);\n      ownerDocument.removeEventListener('pointerdown', handlePointerDown);\n      ownerDocument.removeEventListener('click', handleClickRef.current);\n    };\n  }, [ownerDocument, handlePointerDownOutside]);\n\n  return {\n    // ensures we check React component tree (not just DOM tree)\n    onPointerDownCapture: () => (isPointerInsideReactTreeRef.current = true),\n  };\n}\n\n/**\n * Listens for when focus happens outside a react subtree.\n * Returns props to pass to the root (node) of the subtree we want to check.\n */\nfunction useFocusOutside(\n  onFocusOutside?: (event: FocusOutsideEvent) => void,\n  ownerDocument: Document = globalThis?.document\n) {\n  const handleFocusOutside = useCallbackRef(onFocusOutside) as EventListener;\n  const isFocusInsideReactTreeRef = React.useRef(false);\n\n  React.useEffect(() => {\n    const handleFocus = (event: FocusEvent) => {\n      if (event.target && !isFocusInsideReactTreeRef.current) {\n        const eventDetail = { originalEvent: event };\n        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {\n          discrete: false,\n        });\n      }\n    };\n    ownerDocument.addEventListener('focusin', handleFocus);\n    return () => ownerDocument.removeEventListener('focusin', handleFocus);\n  }, [ownerDocument, handleFocusOutside]);\n\n  return {\n    onFocusCapture: () => (isFocusInsideReactTreeRef.current = true),\n    onBlurCapture: () => (isFocusInsideReactTreeRef.current = false),\n  };\n}\n\nfunction dispatchUpdate() {\n  const event = new CustomEvent(CONTEXT_UPDATE);\n  document.dispatchEvent(event);\n}\n\nfunction handleAndDispatchCustomEvent<E extends CustomEvent, OriginalEvent extends Event>(\n  name: string,\n  handler: ((event: E) => void) | undefined,\n  detail: { originalEvent: OriginalEvent } & (E extends CustomEvent<infer D> ? D : never),\n  { discrete }: { discrete: boolean }\n) {\n  const target = detail.originalEvent.target;\n  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });\n  if (handler) target.addEventListener(name, handler as EventListener, { once: true });\n\n  if (discrete) {\n    dispatchDiscreteCustomEvent(target, event);\n  } else {\n    target.dispatchEvent(event);\n  }\n}\n\nconst Root = DismissableLayer;\nconst Branch = DismissableLayerBranch;\n\nexport {\n  DismissableLayer,\n  DismissableLayerBranch,\n  //\n  Root,\n  Branch,\n};\nexport type { DismissableLayerProps };\n","import * as React from 'react';\n\n/** Number of components which have requested interest to have focus guards */\nlet count = 0;\n\nfunction FocusGuards(props: any) {\n  useFocusGuards();\n  return props.children;\n}\n\n/**\n * Injects a pair of focus guards at the edges of the whole DOM tree\n * to ensure `focusin` & `focusout` events can be caught consistently.\n */\nfunction useFocusGuards() {\n  React.useEffect(() => {\n    const edgeGuards = document.querySelectorAll('[data-radix-focus-guard]');\n    document.body.insertAdjacentElement('afterbegin', edgeGuards[0] ?? createFocusGuard());\n    document.body.insertAdjacentElement('beforeend', edgeGuards[1] ?? createFocusGuard());\n    count++;\n\n    return () => {\n      if (count === 1) {\n        document.querySelectorAll('[data-radix-focus-guard]').forEach((node) => node.remove());\n      }\n      count--;\n    };\n  }, []);\n}\n\nfunction createFocusGuard() {\n  const element = document.createElement('span');\n  element.setAttribute('data-radix-focus-guard', '');\n  element.tabIndex = 0;\n  element.style.outline = 'none';\n  element.style.opacity = '0';\n  element.style.position = 'fixed';\n  element.style.pointerEvents = 'none';\n  return element;\n}\n\nconst Root = FocusGuards;\n\nexport {\n  FocusGuards,\n  //\n  Root,\n  //\n  useFocusGuards,\n};\n","import * as React from 'react';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport { useCallbackRef } from '@radix-ui/react-use-callback-ref';\n\nconst AUTOFOCUS_ON_MOUNT = 'focusScope.autoFocusOnMount';\nconst AUTOFOCUS_ON_UNMOUNT = 'focusScope.autoFocusOnUnmount';\nconst EVENT_OPTIONS = { bubbles: false, cancelable: true };\n\ntype FocusableTarget = HTMLElement | { focus(): void };\n\n/* -------------------------------------------------------------------------------------------------\n * FocusScope\n * -----------------------------------------------------------------------------------------------*/\n\nconst FOCUS_SCOPE_NAME = 'FocusScope';\n\ntype FocusScopeElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface FocusScopeProps extends PrimitiveDivProps {\n  /**\n   * When `true`, tabbing from last item will focus first tabbable\n   * and shift+tab from first item will focus last tababble.\n   * @defaultValue false\n   */\n  loop?: boolean;\n\n  /**\n   * When `true`, focus cannot escape the focus scope via keyboard,\n   * pointer, or a programmatic focus.\n   * @defaultValue false\n   */\n  trapped?: boolean;\n\n  /**\n   * Event handler called when auto-focusing on mount.\n   * Can be prevented.\n   */\n  onMountAutoFocus?: (event: Event) => void;\n\n  /**\n   * Event handler called when auto-focusing on unmount.\n   * Can be prevented.\n   */\n  onUnmountAutoFocus?: (event: Event) => void;\n}\n\nconst FocusScope = React.forwardRef<FocusScopeElement, FocusScopeProps>((props, forwardedRef) => {\n  const {\n    loop = false,\n    trapped = false,\n    onMountAutoFocus: onMountAutoFocusProp,\n    onUnmountAutoFocus: onUnmountAutoFocusProp,\n    ...scopeProps\n  } = props;\n  const [container, setContainer] = React.useState<HTMLElement | null>(null);\n  const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp);\n  const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp);\n  const lastFocusedElementRef = React.useRef<HTMLElement | null>(null);\n  const composedRefs = useComposedRefs(forwardedRef, (node) => setContainer(node));\n\n  const focusScope = React.useRef({\n    paused: false,\n    pause() {\n      this.paused = true;\n    },\n    resume() {\n      this.paused = false;\n    },\n  }).current;\n\n  // Takes care of trapping focus if focus is moved outside programmatically for example\n  React.useEffect(() => {\n    if (trapped) {\n      function handleFocusIn(event: FocusEvent) {\n        if (focusScope.paused || !container) return;\n        const target = event.target as HTMLElement | null;\n        if (container.contains(target)) {\n          lastFocusedElementRef.current = target;\n        } else {\n          focus(lastFocusedElementRef.current, { select: true });\n        }\n      }\n\n      function handleFocusOut(event: FocusEvent) {\n        if (focusScope.paused || !container) return;\n        const relatedTarget = event.relatedTarget as HTMLElement | null;\n\n        // A `focusout` event with a `null` `relatedTarget` will happen in at least two cases:\n        //\n        // 1. When the user switches app/tabs/windows/the browser itself loses focus.\n        // 2. In Google Chrome, when the focused element is removed from the DOM.\n        //\n        // We let the browser do its thing here because:\n        //\n        // 1. The browser already keeps a memory of what's focused for when the page gets refocused.\n        // 2. In Google Chrome, if we try to focus the deleted focused element (as per below), it\n        //    throws the CPU to 100%, so we avoid doing anything for this reason here too.\n        if (relatedTarget === null) return;\n\n        // If the focus has moved to an actual legitimate element (`relatedTarget !== null`)\n        // that is outside the container, we move focus to the last valid focused element inside.\n        if (!container.contains(relatedTarget)) {\n          focus(lastFocusedElementRef.current, { select: true });\n        }\n      }\n\n      // When the focused element gets removed from the DOM, browsers move focus\n      // back to the document.body. In this case, we move focus to the container\n      // to keep focus trapped correctly.\n      function handleMutations(mutations: MutationRecord[]) {\n        const focusedElement = document.activeElement as HTMLElement | null;\n        if (focusedElement !== document.body) return;\n        for (const mutation of mutations) {\n          if (mutation.removedNodes.length > 0) focus(container);\n        }\n      }\n\n      document.addEventListener('focusin', handleFocusIn);\n      document.addEventListener('focusout', handleFocusOut);\n      const mutationObserver = new MutationObserver(handleMutations);\n      if (container) mutationObserver.observe(container, { childList: true, subtree: true });\n\n      return () => {\n        document.removeEventListener('focusin', handleFocusIn);\n        document.removeEventListener('focusout', handleFocusOut);\n        mutationObserver.disconnect();\n      };\n    }\n  }, [trapped, container, focusScope.paused]);\n\n  React.useEffect(() => {\n    if (container) {\n      focusScopesStack.add(focusScope);\n      const previouslyFocusedElement = document.activeElement as HTMLElement | null;\n      const hasFocusedCandidate = container.contains(previouslyFocusedElement);\n\n      if (!hasFocusedCandidate) {\n        const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS);\n        container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);\n        container.dispatchEvent(mountEvent);\n        if (!mountEvent.defaultPrevented) {\n          focusFirst(removeLinks(getTabbableCandidates(container)), { select: true });\n          if (document.activeElement === previouslyFocusedElement) {\n            focus(container);\n          }\n        }\n      }\n\n      return () => {\n        container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus);\n\n        // We hit a react bug (fixed in v17) with focusing in unmount.\n        // We need to delay the focus a little to get around it for now.\n        // See: https://github.com/facebook/react/issues/17894\n        setTimeout(() => {\n          const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS);\n          container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);\n          container.dispatchEvent(unmountEvent);\n          if (!unmountEvent.defaultPrevented) {\n            focus(previouslyFocusedElement ?? document.body, { select: true });\n          }\n          // we need to remove the listener after we `dispatchEvent`\n          container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus);\n\n          focusScopesStack.remove(focusScope);\n        }, 0);\n      };\n    }\n  }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]);\n\n  // Takes care of looping focus (when tabbing whilst at the edges)\n  const handleKeyDown = React.useCallback(\n    (event: React.KeyboardEvent) => {\n      if (!loop && !trapped) return;\n      if (focusScope.paused) return;\n\n      const isTabKey = event.key === 'Tab' && !event.altKey && !event.ctrlKey && !event.metaKey;\n      const focusedElement = document.activeElement as HTMLElement | null;\n\n      if (isTabKey && focusedElement) {\n        const container = event.currentTarget as HTMLElement;\n        const [first, last] = getTabbableEdges(container);\n        const hasTabbableElementsInside = first && last;\n\n        // we can only wrap focus if we have tabbable edges\n        if (!hasTabbableElementsInside) {\n          if (focusedElement === container) event.preventDefault();\n        } else {\n          if (!event.shiftKey && focusedElement === last) {\n            event.preventDefault();\n            if (loop) focus(first, { select: true });\n          } else if (event.shiftKey && focusedElement === first) {\n            event.preventDefault();\n            if (loop) focus(last, { select: true });\n          }\n        }\n      }\n    },\n    [loop, trapped, focusScope.paused]\n  );\n\n  return (\n    <Primitive.div tabIndex={-1} {...scopeProps} ref={composedRefs} onKeyDown={handleKeyDown} />\n  );\n});\n\nFocusScope.displayName = FOCUS_SCOPE_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * Utils\n * -----------------------------------------------------------------------------------------------*/\n\n/**\n * Attempts focusing the first element in a list of candidates.\n * Stops when focus has actually moved.\n */\nfunction focusFirst(candidates: HTMLElement[], { select = false } = {}) {\n  const previouslyFocusedElement = document.activeElement;\n  for (const candidate of candidates) {\n    focus(candidate, { select });\n    if (document.activeElement !== previouslyFocusedElement) return;\n  }\n}\n\n/**\n * Returns the first and last tabbable elements inside a container.\n */\nfunction getTabbableEdges(container: HTMLElement) {\n  const candidates = getTabbableCandidates(container);\n  const first = findVisible(candidates, container);\n  const last = findVisible(candidates.reverse(), container);\n  return [first, last] as const;\n}\n\n/**\n * Returns a list of potential tabbable candidates.\n *\n * NOTE: This is only a close approximation. For example it doesn't take into account cases like when\n * elements are not visible. This cannot be worked out easily by just reading a property, but rather\n * necessitate runtime knowledge (computed styles, etc). We deal with these cases separately.\n *\n * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker\n * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1\n */\nfunction getTabbableCandidates(container: HTMLElement) {\n  const nodes: HTMLElement[] = [];\n  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {\n    acceptNode: (node: any) => {\n      const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';\n      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;\n      // `.tabIndex` is not the same as the `tabindex` attribute. It works on the\n      // runtime's understanding of tabbability, so this automatically accounts\n      // for any kind of element that could be tabbed to.\n      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n    },\n  });\n  while (walker.nextNode()) nodes.push(walker.currentNode as HTMLElement);\n  // we do not take into account the order of nodes with positive `tabIndex` as it\n  // hinders accessibility to have tab order different from visual order.\n  return nodes;\n}\n\n/**\n * Returns the first visible element in a list.\n * NOTE: Only checks visibility up to the `container`.\n */\nfunction findVisible(elements: HTMLElement[], container: HTMLElement) {\n  for (const element of elements) {\n    // we stop checking if it's hidden at the `container` level (excluding)\n    if (!isHidden(element, { upTo: container })) return element;\n  }\n}\n\nfunction isHidden(node: HTMLElement, { upTo }: { upTo?: HTMLElement }) {\n  if (getComputedStyle(node).visibility === 'hidden') return true;\n  while (node) {\n    // we stop at `upTo` (excluding it)\n    if (upTo !== undefined && node === upTo) return false;\n    if (getComputedStyle(node).display === 'none') return true;\n    node = node.parentElement as HTMLElement;\n  }\n  return false;\n}\n\nfunction isSelectableInput(element: any): element is FocusableTarget & { select: () => void } {\n  return element instanceof HTMLInputElement && 'select' in element;\n}\n\nfunction focus(element?: FocusableTarget | null, { select = false } = {}) {\n  // only focus if that element is focusable\n  if (element && element.focus) {\n    const previouslyFocusedElement = document.activeElement;\n    // NOTE: we prevent scrolling on focus, to minimize jarring transitions for users\n    element.focus({ preventScroll: true });\n    // only select if its not the same element, it supports selection and we need to select\n    if (element !== previouslyFocusedElement && isSelectableInput(element) && select)\n      element.select();\n  }\n}\n\n/* -------------------------------------------------------------------------------------------------\n * FocusScope stack\n * -----------------------------------------------------------------------------------------------*/\n\ntype FocusScopeAPI = { paused: boolean; pause(): void; resume(): void };\nconst focusScopesStack = createFocusScopesStack();\n\nfunction createFocusScopesStack() {\n  /** A stack of focus scopes, with the active one at the top */\n  let stack: FocusScopeAPI[] = [];\n\n  return {\n    add(focusScope: FocusScopeAPI) {\n      // pause the currently active focus scope (at the top of the stack)\n      const activeFocusScope = stack[0];\n      if (focusScope !== activeFocusScope) {\n        activeFocusScope?.pause();\n      }\n      // remove in case it already exists (because we'll re-add it at the top of the stack)\n      stack = arrayRemove(stack, focusScope);\n      stack.unshift(focusScope);\n    },\n\n    remove(focusScope: FocusScopeAPI) {\n      stack = arrayRemove(stack, focusScope);\n      stack[0]?.resume();\n    },\n  };\n}\n\nfunction arrayRemove<T>(array: T[], item: T) {\n  const updatedArray = [...array];\n  const index = updatedArray.indexOf(item);\n  if (index !== -1) {\n    updatedArray.splice(index, 1);\n  }\n  return updatedArray;\n}\n\nfunction removeLinks(items: HTMLElement[]) {\n  return items.filter((item) => item.tagName !== 'A');\n}\n\nconst Root = FocusScope;\n\nexport {\n  FocusScope,\n  //\n  Root,\n};\nexport type { FocusScopeProps };\n","import * as React from 'react';\nimport ReactDOM from 'react-dom';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport { useLayoutEffect } from '@radix-ui/react-use-layout-effect';\n\n/* -------------------------------------------------------------------------------------------------\n * Portal\n * -----------------------------------------------------------------------------------------------*/\n\nconst PORTAL_NAME = 'Portal';\n\ntype PortalElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface PortalProps extends PrimitiveDivProps {\n  /**\n   * An optional container where the portaled content should be appended.\n   */\n  container?: Element | DocumentFragment | null;\n}\n\nconst Portal = React.forwardRef<PortalElement, PortalProps>((props, forwardedRef) => {\n  const { container: containerProp, ...portalProps } = props;\n  const [mounted, setMounted] = React.useState(false);\n  useLayoutEffect(() => setMounted(true), []);\n  const container = containerProp || (mounted && globalThis?.document?.body);\n  return container\n    ? ReactDOM.createPortal(<Primitive.div {...portalProps} ref={forwardedRef} />, container)\n    : null;\n});\n\nPortal.displayName = PORTAL_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\nconst Root = Portal;\n\nexport {\n  Portal,\n  //\n  Root,\n};\nexport type { PortalProps };\n"],"names":["counterMap","WeakMap","uncontrolledNodes","markerMap","lockCount","unwrapHost","node","host","parentNode","applyAttributeToOthers","originalTarget","markerName","controlAttribute","targets","Array","isArray","map","target","parent","contains","correctedTarget","console","error","filter","x","Boolean","markerCounter","hiddenNodes","elementsToKeep","Set","elementsToStop","keep","el","has","add","forEach","deep","prototype","call","children","attr","getAttribute","alreadyHidden","counterValue","get","markerValue","set","push","setAttribute","e","clear","removeAttribute","delete","hideOthers","from","activeParentNode","document","sampleTarget","ownerDocument","body","apply","querySelectorAll","options","middleware","buffer","assigned","medium","exported","currentNonce","zeroRightClassName","fullWidthClassName","assignRef","ref","value","current","useIsomorphicLayoutEffect","window","react","useLayoutEffect","useEffect","currentValues","effectCar","a","read","length","useMedium","data","item","assignSyncMedium","cb","cbs","assignMedium","pendingQueue","executeQueue","cycle","Promise","resolve","then","tslib_es6","pi","async","ssr","nothing","RemoveScroll","forwardRef","props","parentRef","refs","callback","callbackRef","useRef","_a","useState","onScrollCapture","onWheelCapture","onTouchMoveCapture","callbacks","setCallbacks","forwardProps","className","removeScrollBar","enabled","shards","sideCar","noIsolation","inert","allowPinchZoom","_b","as","gapMode","rest","_T","containerRef","newValue","facade","last","oldValue","prevRefs_1","nextRefs_1","current_1","containerProps","createElement","Fragment","lockRef","cloneElement","Children","only","defaultProps","classNames","fullWidth","zeroRight","SideCar","Target","isSideCarExport","stylesheetSingleton","counter","stylesheet","style","makeStyleTag","tag","type","nonce","__webpack_require__","nc","styleSheet","cssText","appendChild","createTextNode","head","getElementsByTagName","remove","removeChild","styleHookSingleton","sheet","styles","isDynamic","styleSingleton","useStyle","dynamic","zeroGap","left","top","right","gap","parse","parseInt","getOffset","cs","getComputedStyle","getGapWidth","offsets","documentWidth","documentElement","clientWidth","windowWidth","innerWidth","Math","max","Style","lockAttribute","getStyles","allowRelative","important","concat","join","getCurrentUseCounter","isFinite","useLockAttribute","toString","newCounter","RemoveScrollBar","noRelative","noImportant","useMemo","passiveSupported","Object","defineProperty","addEventListener","removeEventListener","err","nonPassive","passive","elementCanBeScrolled","overflow","Element","overflowY","overflowX","tagName","locationCouldBeScrolled","axis","ShadowRoot","elementCouldBeScrolled","getScrollVariables","scrollHeight","scrollTop","clientHeight","scrollLeft","scrollWidth","handleScroll","endTarget","event","sourceDelta","noOverscroll","direction","directionFactor","delta","targetInLock","shouldCancelScroll","isDeltaPositive","availableScroll","availableScrollTop","position","elementScroll","scroll_1","abs","getTouchXY","changedTouches","clientX","clientY","getDeltaXY","deltaX","deltaY","extractRef","idCounter","lockStack","sidecar","shouldPreventQueue","touchStartRef","activeAxis","id","lastProps","classList","allow_1","ev","shouldCancelEvent","useCallback","touches","ctrlKey","currentAxis","touch","touchStart","moveDirection","canBeScrolledInMainDirection","cancelingAxis","shouldPrevent","_event","sourceEvent","name","shadowParent","y","should","cancelable","preventDefault","shardNodes","shouldCancel","getOutermostShadowParent","setTimeout","scrollTouchStart","undefined","scrollWheel","scrollTouchMove","inst","ReactRemoveScroll","Combination","originalBodyPointerEvents","CONTEXT_UPDATE","DismissableLayerContext","React","layers","layersWithOutsidePointerEventsDisabled","branches","DismissableLayer","forwardedRef","globalThis","disableOutsidePointerEvents","onEscapeKeyDown","onPointerDownOutside","onFocusOutside","onInteractOutside","onDismiss","layerProps","context","setNode","force","composedRefs","useComposedRefs","highestLayerWithOutsidePointerEventsDisabled","slice","highestLayerWithOutsidePointerEventsDisabledIndex","indexOf","index","isBodyPointerEventsDisabled","size","isPointerEventsEnabled","pointerDownOutside","usePointerDownOutside","handlePointerDownOutside","useCallbackRef","isPointerInsideReactTreeRef","handleClickRef","handlePointerDown","handleAndDispatchPointerDownOutsideEvent","handleAndDispatchCustomEvent","eventDetail","discrete","originalEvent","pointerType","once","timerId","clearTimeout","onPointerDownCapture","isPointerDownOnBranch","some","branch","defaultPrevented","focusOutside","useFocusOutside","handleFocusOutside","isFocusInsideReactTreeRef","handleFocus","onFocusCapture","onBlurCapture","useEscapeKeydown","onEscapeKeyDownProp","react_use_callback_ref_dist","W","handleKeyDown","key","capture","pointerEvents","dispatchUpdate","handleUpdate","jsx","Primitive","div","composeEventHandlers","CustomEvent","dispatchEvent","handler","detail","param","bubbles","dispatchDiscreteCustomEvent","displayName","DismissableLayerBranch","count","useFocusGuards","edgeGuards","insertAdjacentElement","createFocusGuard","element","tabIndex","outline","opacity","stack","AUTOFOCUS_ON_MOUNT","AUTOFOCUS_ON_UNMOUNT","EVENT_OPTIONS","FocusScope","loop","trapped","onMountAutoFocus","onMountAutoFocusProp","onUnmountAutoFocus","onUnmountAutoFocusProp","scopeProps","container","setContainer","lastFocusedElementRef","focusScope","paused","pause","resume","handleFocusIn","focus","select","handleFocusOut","relatedTarget","mutationObserver","MutationObserver","mutations","focusedElement","activeElement","mutation","removedNodes","observe","childList","subtree","disconnect","focusScopesStack","previouslyFocusedElement","mountEvent","focusFirst","candidates","arguments","candidate","items","unmountEvent","isTabKey","altKey","metaKey","currentTarget","first","getTabbableEdges","getTabbableCandidates","findVisible","reverse","shiftKey","onKeyDown","nodes","walker","createTreeWalker","NodeFilter","SHOW_ELEMENT","acceptNode","isHiddenInput","disabled","hidden","FILTER_SKIP","FILTER_ACCEPT","nextNode","currentNode","elements","isHidden","upTo","visibility","display","parentElement","preventScroll","HTMLInputElement","activeFocusScope","arrayRemove","unshift","array","updatedArray","splice","Portal","containerProp","portalProps","mounted","setMounted","ReactDOM"],"sourceRoot":""}