{"version":3,"file":"js/23146-f9fe762116c85e83bfa8.js","mappings":"8KAGA,SAASA,IAeP,OAdAA,EAAWC,OAAOC,QAAU,SAAUC,GACpC,IAAK,IAAIC,EAAI,EAAGA,EAAIC,UAAUC,OAAQF,IAAK,CACzC,IAAIG,EAASF,UAAUD,GAEvB,IAAK,IAAII,KAAOD,EACVN,OAAOQ,UAAUC,eAAeC,KAAKJ,EAAQC,KAC/CL,EAAOK,GAAOD,EAAOC,IAK3B,OAAOL,GAGFH,EAASY,MAAMC,KAAMR,WAkB9B,IAAIS,EAAY,CAAC,KAAM,SAQnBC,GAA8B,IAAAC,aAAW,SAAwBC,EAAMC,GACzE,IAAIC,EAAUF,EAAKG,GACfC,OAAmB,IAAZF,EAAqB,OAASA,EACrCG,EAAaL,EAAKM,MAClBA,OAAuB,IAAfD,EAAwB,GAAKA,EACrCE,EA5BN,SAAuCjB,EAAQkB,GAC7C,GAAc,MAAVlB,EAAgB,MAAO,GAC3B,IAEIC,EAAKJ,EAFLD,EAAS,GACTuB,EAAazB,OAAO0B,KAAKpB,GAG7B,IAAKH,EAAI,EAAGA,EAAIsB,EAAWpB,OAAQF,IACjCI,EAAMkB,EAAWtB,GACbqB,EAASG,QAAQpB,IAAQ,IAC7BL,EAAOK,GAAOD,EAAOC,IAGvB,OAAOL,EAgBK0B,CAA8BZ,EAAMH,GAEhD,OAAoB,IAAAgB,eAAcT,EAAMrB,EAAS,CAC/CkB,IAAKA,EACLK,MAAOvB,EAAS,CACd+B,OAAQ,EACRC,KAAM,gBACNC,OAAQ,MACRC,OAAQ,OACRC,SAAU,SACVC,QAAS,EACTC,SAAU,WACVC,MAAO,MAEPC,WAAY,SACZC,SAAU,UACTjB,IACFC,OCzDL,SAASiB,EAAiBC,GACxB,MCT4B,qBAAXC,QAA0BA,OAAOC,UAAYD,OAAOC,SAASd,cDSzDY,EAAUA,EAAQG,cAAgBD,SAAW,KEPpE,SAASE,EAAkBC,EAAKC,IACnB,MAAPA,GAAeA,EAAMD,EAAIzC,UAAQ0C,EAAMD,EAAIzC,QAE/C,IAAK,IAAIF,EAAI,EAAG6C,EAAO,IAAIC,MAAMF,GAAM5C,EAAI4C,EAAK5C,IAAK6C,EAAK7C,GAAK2C,EAAI3C,GAEnE,OAAO6C,EAYT,SAASE,EAAgCC,EAAGC,GAC1C,IAAIC,EAEJ,GAAsB,qBAAXC,QAAgD,MAAtBH,EAAEG,OAAOC,UAAmB,CAC/D,GAAIN,MAAMO,QAAQL,KAAOE,EAb7B,SAAqCF,EAAGM,GACtC,GAAKN,EAAL,CACA,GAAiB,kBAANA,EAAgB,OAAON,EAAkBM,EAAGM,GACvD,IAAIC,EAAI1D,OAAOQ,UAAUmD,SAASjD,KAAKyC,GAAGS,MAAM,GAAI,GAEpD,MADU,WAANF,GAAkBP,EAAEU,cAAaH,EAAIP,EAAEU,YAAYC,MAC7C,QAANJ,GAAqB,QAANA,EAAoBT,MAAMc,KAAKZ,GACxC,cAANO,GAAqB,2CAA2CM,KAAKN,GAAWb,EAAkBM,EAAGM,QAAzG,GAOgCQ,CAA4Bd,KAAOC,GAAkBD,GAAyB,kBAAbA,EAAE9C,OAAqB,CAChHgD,IAAIF,EAAIE,GACZ,IAAIlD,EAAI,EACR,OAAO,WACL,OAAIA,GAAKgD,EAAE9C,OAAe,CACxB6D,MAAM,GAED,CACLA,MAAM,EACNC,MAAOhB,EAAEhD,OAKf,MAAM,IAAIiE,UAAU,yIAItB,OADAf,EAAKF,EAAEG,OAAOC,aACJc,KAAKC,KAAKjB,GAStB,SAASkB,EAAUtD,EAAKkD,GACtB,GAAW,MAAPlD,EAEJ,GCxCF,SAAoBkD,GAElB,SAAUA,GAAoC,qBAA3B,GAAGR,SAASjD,KAAKyD,IDsChCK,CAAWvD,GACbA,EAAIkD,QAEJ,IACElD,EAAIwD,QAAUN,EACd,MAAOO,GACP,MAAM,IAAIC,MAAM,wBAA2BR,EAAQ,aAAiBlD,EAAM,MEpDhF,SAAS,IAeP,OAdA,EAAWjB,OAAOC,QAAU,SAAUC,GACpC,IAAK,IAAIC,EAAI,EAAGA,EAAIC,UAAUC,OAAQF,IAAK,CACzC,IAAIG,EAASF,UAAUD,GAEvB,IAAK,IAAII,KAAOD,EACVN,OAAOQ,UAAUC,eAAeC,KAAKJ,EAAQC,KAC/CL,EAAOK,GAAOD,EAAOC,IAK3B,OAAOL,GAGF,EAASS,MAAMC,KAAMR,WAkB9B,IAkBIwE,EAlBA,EAAY,CAAC,KAAM,WAAY,QAM/BlD,EAAO,CACTmD,QAAS,EACTC,WAAY,GAEV,EAAW,CACbD,OAAQ,GACRC,UAAW,IAETC,EAAc,CAChBF,OAAQ,KACRC,UAAW,MAcTE,GAAqB,IAAAjE,aAAW,SAAeC,EAAMiE,GACvD,IAAI/D,EAAUF,EAAKG,GACfC,OAAmB,IAAZF,EAAqB,MAAQA,EACpCgE,EAAWlE,EAAKkE,SAChBC,EAAYnE,EAAKoE,KACjBC,OAA2B,IAAdF,EAAuB,SAAWA,EAC/C5D,EAnDN,SAAuCjB,EAAQkB,GAC7C,GAAc,MAAVlB,EAAgB,MAAO,GAC3B,IAEIC,EAAKJ,EAFLD,EAAS,GACTuB,EAAazB,OAAO0B,KAAKpB,GAG7B,IAAKH,EAAI,EAAGA,EAAIsB,EAAWpB,OAAQF,IACjCI,EAAMkB,EAAWtB,GACbqB,EAASG,QAAQpB,IAAQ,IAC7BL,EAAOK,GAAOD,EAAOC,IAGvB,OAAOL,EAuCK,CAA8Bc,EAAM,GAE5CsE,GAAS,IAAAC,QAAO,MAChBtE,EFRN,WACE,IAAK,IAAIuE,EAAOpF,UAAUC,OAAQoF,EAAO,IAAIxC,MAAMuC,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IAC/ED,EAAKC,GAAQtF,UAAUsF,GAGzB,OAAO,IAAAC,cAAY,SAAUC,GAC3B,IAAK,IAAuDC,EAAnDC,EAAY5C,EAAgCuC,KAAgBI,EAAQC,KAAa5B,MAExFK,EADUsB,EAAM1B,MACDyB,KAGhBH,GEHOM,CAAgBd,EAAcK,GACpCU,GAAQ,IAAAC,UAAQ,WAClB,OAAoB,IAAApE,eAAcT,EAAM,EAAS,GAAIG,EAAO,CAC1DN,IAAKA,EACL,oBAAoB,IAClBiE,KAEN,CAACA,EAAU3D,IAEX,OAkFF,SAA0B8D,EAAY5C,EAASxB,GAC7C,IAAIiF,ECpKN,SAAqB/B,GACnB,IAAIlD,GAAM,IAAAsE,QAAO,MAIjB,OAHA,IAAAY,YAAU,WACRlF,EAAIwD,QAAUN,IACb,CAACA,IACGlD,EAAIwD,QD+JI2B,CAAYf,GACvBgB,GAAS,IAAAd,QAAO,MAChBe,GAAU,IAAAf,SAAO,IACrB,IAAAY,YAAU,WACR,IAAIvD,EAAgBJ,EAAiBvB,EAAIwD,SAEpC6B,EAAQ7B,QAIFyB,IAAab,GACtBgB,EAAO5B,SAAW4B,EAAO5B,QAAQ8B,UACjCF,EAAO5B,QAAU+B,EAAanB,EAAYzC,GAC1CyD,EAAO5B,QAAQgC,MAAMhE,IAErB4D,EAAO5B,SAAW4B,EAAO5B,QAAQiC,OAAOjE,IARxC6D,EAAQ7B,SAAU,EAClB4B,EAAO5B,QAAU+B,EAAanB,EAAYzC,GAC1CyD,EAAO5B,QAAQgC,MAAMhE,MAQtB,CAACA,EAAS4C,EAAYa,EAAUjF,KACnC,IAAAkF,YAAU,WACR,OAAO,WACLE,EAAO5B,SAAW4B,EAAO5B,QAAQ8B,aAElC,IA1GHI,CAAiBtB,EAAYW,EAAOV,GAC7BU,KAeT,SAASQ,EAAapB,EAAMwB,GAC1B,IAAIrG,IAAQmB,EAAK0D,GAyBjB,MAAO,CACLqB,MAxBU,SAASA,EAAMhE,GACzB,GAAIsC,EAAYK,GACd,EAASA,GAAM7E,GAAOkC,EACtBoE,QACK,CACL,IAAIjB,EAAOgB,EAAI/E,cAAc,OAC7B+D,EAAKkB,aAAa,mBAAqB1B,EAAM,QAC7CL,EAAYK,GAAQQ,EACpBgB,EAAIG,KAAKC,YAAYjC,EAAYK,IACjCqB,EAAMhE,KAgBRiE,OAZW,SAAgBjE,GAC3B,EAAS2C,GAAM7E,GAAOkC,EACtBoE,KAWAN,QARY,kBACL,EAASnB,GAAM7E,GACtBsG,MAUJ,SAASA,IACY,MAAfjC,GACFlC,OAAOuE,aAAarC,GAGtBA,EAAclC,OAAOwE,YAAW,WAC9BlH,OAAO0B,KAAK,GAAUyF,SAAQ,SAAUC,GACtC,IAAI/B,EAAa+B,EACDrC,EAAYM,KAG1B,IAAAgC,SAAqB,IAAAxF,eAAcf,EAAgB,CACjDK,GAAI,QACU,IAAAU,eAAc,MAAO,CAQnCyF,KAAqB,cAAfjC,EAA6B,QAAU,SAC7C,YAAaA,GACZrF,OAAO0B,KAAK,EAAS2D,IAAakC,KAAI,SAAUhH,GACjD,OAAoB,IAAAiH,cAAa,EAASnC,GAAY9E,GAAM,CAC1DA,IAAKA,EACLU,IAAK,YAEH8D,EAAYM,SAGrB,KA6BL,S,mCE5LA,IAAIoC,EAAuB,EAAQ,OAEnC,SAASC,KACT,SAASC,KACTA,EAAuBC,kBAAoBF,EAE3CG,EAAOC,QAAU,WACf,SAASC,EAAKxG,EAAOyG,EAAUC,EAAeC,EAAUC,EAAcC,GACpE,GAAIA,IAAWX,EAAf,CAIA,IAAIY,EAAM,IAAI1D,MACZ,mLAKF,MADA0D,EAAIvE,KAAO,sBACLuE,GAGR,SAASC,IACP,OAAOP,EAFTA,EAAKQ,WAAaR,EAMlB,IAAIS,EAAiB,CACnBC,MAAOV,EACPW,OAAQX,EACRY,KAAMZ,EACNa,KAAMb,EACNc,OAAQd,EACRe,OAAQf,EACRgB,OAAQhB,EACRiB,OAAQjB,EAERkB,IAAKlB,EACLmB,QAASZ,EACT7F,QAASsF,EACTX,YAAaW,EACboB,WAAYb,EACZ1C,KAAMmC,EACNqB,SAAUd,EACVe,MAAOf,EACPgB,UAAWhB,EACXiB,MAAOjB,EACPkB,MAAOlB,EAEPmB,eAAgB9B,EAChBC,kBAAmBF,GAKrB,OAFAc,EAAekB,UAAYlB,EAEpBA,I,sBC9CPX,EAAOC,QAAU,EAAQ,MAAR,I,+BCNnBD,EAAOC,QAFoB,gD,kUCNhB6B,EAAc,kBAIdC,EAAiB,2BCSrB,SAASC,EAAapE,EAAMqE,GAC/B,OCF2BC,EDELD,GAAgB,KCFGE,EDEG,SAAUC,GAAY,OAAOxE,EAAK0B,SAAQ,SAAUlG,GAAO,OEJpG,SAAmBA,EAAKkD,GAO3B,MANmB,oBAARlD,EACPA,EAAIkD,GAEClD,IACLA,EAAIwD,QAAUN,GAEXlD,EFHuGsD,CAAUtD,EAAKgJ,QCDzHhJ,GAAM,IAAAiJ,WAAS,WAAc,MAAO,CAEpC/F,MAAO4F,EAEPC,SAAUA,EAEVG,OAAQ,CACA1F,cACA,OAAOxD,EAAIkD,OAEXM,YAAQN,GACR,IAAIiG,EAAOnJ,EAAIkD,MACXiG,IAASjG,IACTlD,EAAIkD,MAAQA,EACZlD,EAAI+I,SAAS7F,EAAOiG,UAI7B,IAEHJ,SAAWA,EACR/I,EAAIkJ,OAtBR,IAAwBJ,EAAcC,EACrC/I,EEdD,IAAIoJ,EAAc,CACvBhI,MAAO,MACPL,OAAQ,MACRG,QAAS,EACTD,SAAU,SACVE,SAAU,QACVkI,IAAK,MACLC,KAAM,OAGJC,EAAe,SAAsBxJ,GACvC,IAAIkE,EAAWlE,EAAKkE,SACpB,OAAoB,gBAAoB,WAAgB,KAAmB,gBAAoB,MAAO,CACpG3E,IAAK,cACL,oBAAoB,EACpB,yBAAyB,EACzBe,MAAO+I,IACLnF,EAAUA,GAAyB,gBAAoB,MAAO,CAChE3E,IAAK,aACL,oBAAoB,EACpB,yBAAyB,EACzBe,MAAO+I,MAIXG,EAAaC,UAET,GACJD,EAAaE,aAAe,CAC1BxF,SAAU,MAEZ,I,WChCA,SAASyF,EAAKC,GACV,OAAOA,EAEX,SAASC,EAAkBC,EAAUC,QACd,IAAfA,IAAyBA,EAAaJ,GAC1C,IAAIK,EAAS,GACTC,GAAW,EA0Df,MAzDa,CACTC,KAAM,WACF,GAAID,EACA,MAAM,IAAItG,MAAM,oGAEpB,OAAIqG,EAAO3K,OACA2K,EAAOA,EAAO3K,OAAS,GAE3ByK,GAEXK,UAAW,SAAUC,GACjB,IAAIC,EAAON,EAAWK,EAAMH,GAE5B,OADAD,EAAOM,KAAKD,GACL,WACHL,EAASA,EAAOO,QAAO,SAAUC,GAAK,OAAOA,IAAMH,OAG3DI,iBAAkB,SAAUC,GAExB,IADAT,GAAW,EACJD,EAAO3K,QAAQ,CAClB,IAAIsL,EAAMX,EACVA,EAAS,GACTW,EAAIxE,QAAQuE,GAEhBV,EAAS,CACLM,KAAM,SAAUE,GAAK,OAAOE,EAAGF,IAC/BD,OAAQ,WAAc,OAAOP,KAGrCY,aAAc,SAAUF,GACpBT,GAAW,EACX,IAAIY,EAAe,GACnB,GAAIb,EAAO3K,OAAQ,CACf,IAAIsL,EAAMX,EACVA,EAAS,GACTW,EAAIxE,QAAQuE,GACZG,EAAeb,EAEnB,IAAIc,EAAe,WACf,IAAIH,EAAME,EACVA,EAAe,GACfF,EAAIxE,QAAQuE,IAEZK,EAAQ,WAAc,OAAOC,QAAQC,UAAUC,KAAKJ,IACxDC,IACAf,EAAS,CACLM,KAAM,SAAUE,GACZK,EAAaP,KAAKE,GAClBO,KAEJR,OAAQ,SAAUA,GAEd,OADAM,EAAeA,EAAaN,OAAOA,GAC5BP,MAOpB,SAASmB,EAAarB,EAAUC,GAEnC,YADmB,IAAfA,IAAyBA,EAAaJ,GACnCE,EAAkBC,EAAUC,GAGhC,SAASqB,EAAoBC,QAChB,IAAZA,IAAsBA,EAAU,IACpC,IAAIC,EAASzB,EAAkB,MAE/B,OADAyB,EAAOD,SAAU,QAAS,CAAEE,OAAO,EAAMC,KAAK,GAASH,GAChDC,EC3EJ,IAAIG,EAAcN,EAAa,IAAI,SAAUnL,GAGlD,MAAO,CACLd,OAHWc,EAAKd,OAIhBwM,cAHkB1L,EAAK0L,kBAMhBC,EAAaR,IACbS,EAAeT,IACfU,EAAgBT,EAAoB,CAC7CG,OAAO,ICJLO,EAAa,GACbC,EAAyB,cAAiB,SAAqBxL,EAAOyL,GACxE,IAAIC,EAEAC,EAAkB,aAClBC,EAAeD,EAAgB,GAC/BE,EAAcF,EAAgB,GAE9BG,EAAW,WACXC,EAAW,UAAa,GACxBC,EAAyB,SAAa,MACtCrI,EAAW3D,EAAM2D,SACjBsI,EAAWjM,EAAMiM,SACjBC,EAAgBlM,EAAMkM,cACtBC,EAAkBnM,EAAMmM,gBACxBC,EAAapM,EAAMoM,WACnBC,EAAYrM,EAAMqM,UAElBC,GADqBtM,EAAMuM,mBACnBvM,EAAMsM,OACdE,EAAYxM,EAAMwM,UAClBC,EAAYzM,EAAMyM,UAClBC,EAAqB1M,EAAM0M,mBAC3BC,EAAgB3M,EAAM4M,OACtBA,OAA2B,IAAlBD,EAA2BpB,EAAaoB,EACjDE,EAAY7M,EAAMJ,GAClBkN,OAA0B,IAAdD,EAAuB,MAAQA,EAC3CE,EAAmB/M,EAAMgN,UACzBC,OAAsC,IAArBF,EAA8B,GAAKA,EACpDG,EAAUlN,EAAMmN,QAChBC,EAAoBpN,EAAMqN,YAC1BC,EAAetN,EAAMsN,aACrBC,EAAuBvN,EAAMwN,aAC7BC,EAAyBzN,EAAM0N,eAG/BC,EADmB,WAAe,IACZ,GAGtBH,EAAe,eAAkB,WACnCxB,EAAuB9I,QAAU8I,EAAuB9I,SAAW9B,UAAYA,SAASwM,cAEpF9B,EAAS5I,SAAWqK,GACtBA,EAAqBzB,EAAS5I,SAGhC6I,EAAS7I,SAAU,IAClB,CAACqK,IACAG,EAAiB,eAAkB,WACrC3B,EAAS7I,SAAU,EAEfuK,GACFA,EAAuB3B,EAAS5I,WAEjC,CAACuK,KACJ,IAAA7I,YAAU,WACHqH,IAGHD,EAAuB9I,QAAU,QAElC,IACH,IAAImK,EAAc,eAAkB,SAAUQ,GAC5C,IAAIC,EAAgB9B,EAAuB9I,QAE3C,GAAI4K,GAAiBA,EAAcC,MAAO,CACxC,IAAIC,EAAgD,oBAAtBZ,EAAmCA,EAAkBU,GAAiBV,EAEpG,GAAIY,EAAkB,CACpB,IAAIC,EAAiD,kBAArBD,EAAgCA,OAAmBE,EACnFlC,EAAuB9I,QAAU,KAE7B2K,EAGFpD,QAAQC,UAAUC,MAAK,WACrB,OAAOmD,EAAcC,MAAME,MAG7BH,EAAcC,MAAME,OAIzB,CAACb,IAEAe,EAAU,eAAkB,SAAUC,GACpCrC,EAAS7I,SACXgI,EAAYtB,UAAUwE,KAEvB,IACCC,EAASjD,EAAWxB,UAGpB0E,EAAiB,eAAkB,SAAUC,GAC3CzC,EAAS5I,UAAYqL,IACvBzC,EAAS5I,QAAUqL,EACnB1C,EAAY0C,MAEb,IAgBH,IAAIvB,GAAY,SAAUtB,EAAY,IAAc,GAA4BO,GAAY,WAAYP,EAAU,GAAyBY,EAAOZ,GAAYuB,GAE1JuB,GAAqC,IAAlBtC,EACnBuC,EAAmBD,GAAsC,SAAlBtC,EACvCwC,EAAYpG,EAAa,CAACmD,EAAW6C,IACzC,OAAoB,gBAAoB,WAAgB,KAAME,GAAoB,CAGlF,gBAAoB,MAAO,CACzBxP,IAAK,cACL,oBAAoB,EACpB2P,SAAU1C,GAAY,EAAI,EAC1BlM,MAAO+I,IAET4D,EAAkC,gBAAoB,MAAO,CAC3D1N,IAAK,gBACL,oBAAoB,EACpB2P,SAAU1C,GAAY,EAAI,EAC1BlM,MAAO+I,IACJ,OAAQmD,GAAyB,gBAAoBiB,EAAS,CACjES,GAAIA,EACJR,QAAS7B,EACTQ,SAAUF,EACVK,SAAUA,EACVE,gBAAiBA,EACjBC,WAAYA,EACZC,UAAWA,EACXI,UAAWA,EACXG,OAAQA,EACRY,aAAcA,EACdE,eAAgBA,EAChBL,YAAaA,EACbC,aAAcA,IACC,gBAAoBR,GAAW,OAAS,CACvDpN,IAAKgP,GACJ1B,EAAW,CACZR,UAAWA,EACX6B,OAAQA,EACRF,QAASA,IACPxK,GAAW8K,GAAiC,gBAAoB,MAAO,CACzE,oBAAoB,EACpBE,SAAU1C,GAAY,EAAI,EAC1BlM,MAAO+I,QAGX0C,EAAUtC,UAoBN,GACJsC,EAAUrC,aAAe,CACvBxF,cAAUuK,EACVjC,UAAU,EACVoB,aAAa,EACbC,kBAAcY,EACdhC,eAAe,EACfG,WAAW,EACXF,iBAAiB,EACjBC,YAAY,EACZM,wBAAoBwB,EACpB3B,wBAAoB2B,EACpB5B,WAAO4B,EACP1B,eAAW0B,EACXzB,eAAWyB,EACXtB,YAAQsB,EACRtO,GAAI,MACJoN,UAAW,GACXQ,kBAAcU,EACdR,oBAAgBQ,GAElB,Q,qBCjIA,MA1EA,SAAwBU,EAAoBC,GAe1C,OAAO,SAAcC,GAOnB,IACIC,EADAC,EAAmB,GAGvB,SAASC,IACPF,EAAQH,EAAmBI,EAAiBhJ,KAAI,SAAUkJ,GACxD,OAAOA,EAASlP,UAElB6O,EAA0BE,GAG5B,IAAII,EAA0B,SAAUC,GAGtC,SAASD,IACP,OAAOC,EAAehQ,MAAMC,KAAMR,YAAcQ,MAHlD,OAAe8P,EAAYC,GAO3BD,EAAWE,KAAO,WAChB,OAAON,GAGT,IAAIO,EAASH,EAAWlQ,UAqBxB,OAnBAqQ,EAAOC,kBAAoB,WACzBP,EAAiBjF,KAAK1K,MACtB4P,KAGFK,EAAOE,mBAAqB,WAC1BP,KAGFK,EAAOG,qBAAuB,WAC5B,IAAIC,EAAQV,EAAiB5O,QAAQf,MACrC2P,EAAiBW,OAAOD,EAAO,GAC/BT,KAGFK,EAAOxJ,OAAS,WACd,OAAoB,gBAAoBgJ,EAAkBzP,KAAKW,QAG1DmP,EAjCqB,CAkC5B,EAAAS,eAIF,OAFA,OAAgBT,EAAY,cAAe,cAzD7C,SAAwBL,GACtB,OAAOA,EAAiBe,aAAef,EAAiBvM,MAAQ,YAwDLuN,CAAehB,GAAoB,KAEvFK,IC7DPY,EAAgB,SAAU1L,GAE1B,OAAOA,EAAK2L,YAAc3L,EAAK2L,WAAWC,WAAaC,KAAKC,uBAEpD9L,EAAK2L,WAAWI,KAClB/L,EAAK2L,YAEXK,EAAY,SAAUhM,GAEtB,OAAOA,IAASjD,UAAaiD,GAAQA,EAAK4L,WAAaC,KAAKI,eAE5DC,EAAoB,SAAUlM,EAAMmM,GACpC,OAAQnM,GAAQgM,EAAUhM,KAxBR,SAAUA,GAG5B,GAAIA,EAAK4L,WAAaC,KAAKO,aACvB,OAAO,EAEX,IAAIC,EAAgBvP,OAAOwP,iBAAiBtM,EAAM,MAClD,SAAKqM,IAAkBA,EAAcE,oBAGiB,SAA9CF,EAAcE,iBAAiB,YAA0E,WAAjDF,EAAcE,iBAAiB,eAc1DC,CAAgBxM,IAASmM,EAAYT,EAAc1L,KAEjFyM,EAAkB,SAAUC,EAAiB1M,GACpD,IAAI2M,EAASD,EAAgBE,IAAI5M,GACjC,QAAe6J,IAAX8C,EACA,OAAOA,EAEX,IAAIE,EAASX,EAAkBlM,EAAMyM,EAAgB/N,UAAKmL,EAAW6C,IAErE,OADAA,EAAgBI,IAAI9M,EAAM6M,GACnBA,GAKAE,EAA2B,SAAUC,EAAOhN,GACnD,IAAI2M,EAASK,EAAMJ,IAAI5M,GACvB,QAAe6J,IAAX8C,EACA,OAAOA,EAEX,IAAIE,EARyB,SAAU7M,EAAMmM,GAC7C,QAAOnM,IAASgM,EAAUhM,OAASiN,EAAmBjN,IAAQmM,EAAYT,EAAc1L,IAO3EkN,CAA2BlN,EAAM+M,EAAyBrO,UAAKmL,EAAWmD,IAEvF,OADAA,EAAMF,IAAI9M,EAAM6M,GACTA,GAEAM,EAAa,SAAUnN,GAE9B,OAAOA,EAAKoN,SAGLC,EAAqB,SAAUrN,GAAQ,MAAwB,UAAjBA,EAAKsN,SACnDC,EAAiB,SAAUvN,GAClC,OAAOqN,EAAmBrN,IAAuB,UAAdA,EAAKR,MAKjCyN,EAAqB,SAAUjN,GACtC,IAAIwN,EAAYxN,EAAKyN,aTxCO,qBSyC5B,OAAQ,EAAC,EAAM,OAAQ,IAAIC,SAASF,IAE7BG,EAAU,SAAU3N,GAAQ,IAAI4N,EAAI,OAAOC,QAAQ7N,IAAqC,QAA3B4N,EAAKT,EAAWnN,UAA0B,IAAP4N,OAAgB,EAASA,EAAGE,cAC5HC,EAAc,SAAU/N,GAAQ,OAAQ2N,EAAQ3N,IAChDgO,EAAY,SAAUpI,GAAK,OAAOiI,QAAQjI,IC3D1CqI,EAAc,SAAUjO,EAAMkO,GACrC,OAAIX,EAAevN,IAASA,EAAK9B,KAPb,SAAU8B,EAAMkO,GACpC,OAAOA,EACFvI,OAAO4H,GACP5H,QAAO,SAAUwI,GAAM,OAAOA,EAAGjQ,OAAS8B,EAAK9B,QAC/CyH,QAAO,SAAUwI,GAAM,OAAOA,EAAGC,WAAY,IAAMpO,EAI7CqO,CAAkBrO,EAAMkO,GAE5BlO,GCVAsO,EAAiB,SAAUJ,GAClC,OAAIA,EAAM,IAAMA,EAAMzT,OAAS,EACpBwT,EAAYC,EAAM,GAAIA,GAE1BA,EAAM,IAENK,EAAgB,SAAUL,EAAO7C,GACxC,OAAI6C,EAAMzT,OAAS,EACRyT,EAAMnS,QAAQkS,EAAYC,EAAM7C,GAAQ6C,IAE5C7C,GCRAmD,EAAY,YASZC,EAAW,SAAUC,EAAYC,EAAYpF,EAAeqF,GACnE,IAAIC,EAAMH,EAAWjU,OACjBqU,EAAaJ,EAAW,GACxBK,EAAYL,EAAWG,EAAM,GAC7BG,EAAYrB,EAAQpE,GAExB,KAAIA,GAAiBmF,EAAW3S,QAAQwN,IAAkB,GAA1D,CAGA,IFJgC2E,EAE5Be,EEEAC,OAAgCrF,IAAlBN,EAA8BoF,EAAW5S,QAAQwN,IAAkB,EACjF4F,EAAYP,EAAWD,EAAW5S,QAAQ6S,GAAYM,EACtDE,EAAiBR,EAAWF,EAAW3S,QAAQ6S,IAAa,EAC5DS,EAAYH,EAAcC,EAC1BG,EAAiBX,EAAW5S,QAAQ+S,GACpCS,EAAgBZ,EAAW5S,QAAQgT,GACnCS,GFV4BtB,EEUES,EFR9BM,EAAY,IAAIQ,IACpBvB,EAAM3M,SAAQ,SAAUvB,GAAQ,OAAOiP,EAAUS,IAAIzB,EAAYjO,EAAMkO,OAEhEA,EAAMvI,QAAO,SAAU3F,GAAQ,OAAOiP,EAAUU,IAAI3P,OEOvD4P,QADmC/F,IAAlBN,EAA8BiG,EAAezT,QAAQwN,IAAkB,IACjDqF,EAAWY,EAAezT,QAAQ6S,GAAYM,GACrFW,EAAkBtB,EAAcG,EAAY,GAC5CoB,EAAiBvB,EAAcG,EAAYG,EAAM,GAErD,OAAqB,IAAjBK,IAA0C,IAApBE,EACfZ,GAGNa,GAAaD,GAAkB,EACzBA,EAGPF,GAAeI,GAAkBN,GAAae,KAAKC,IAAIX,GAAa,EAC7DS,EAGPZ,GAAeK,GAAiBP,GAAae,KAAKC,IAAIX,GAAa,EAC5DQ,EAGPR,GAAaU,KAAKC,IAAIJ,GAAsB,EACrCR,EAGPF,GAAeI,EACRQ,EAGPZ,EAAcK,EACPM,EAGPR,EACIU,KAAKC,IAAIX,GAAa,EACfD,GAEHP,EAAMO,EAAiBC,GAAaR,OAJhD,IC1DOoB,EAAU,SAAUjL,GAE3B,IADA,IAAIkL,EAAM7S,MAAM2H,EAAEvK,QACTF,EAAI,EAAGA,EAAIyK,EAAEvK,SAAUF,EAC5B2V,EAAI3V,GAAKyK,EAAEzK,GAEf,OAAO2V,GAEAC,EAAU,SAAUnL,GAAK,OAAQ3H,MAAMO,QAAQoH,GAAKA,EAAI,CAACA,ICTzDoL,EAAU,SAAUpL,EAAGqL,GAC9B,IAAIC,EAAUtL,EAAEsF,SAAW+F,EAAE/F,SACzB+E,EAAYrK,EAAEqG,MAAQgF,EAAEhF,MAC5B,GAAIiF,EAAS,CACT,IAAKtL,EAAEsF,SACH,OAAO,EAEX,IAAK+F,EAAE/F,SACH,OAAQ,EAGhB,OAAOgG,GAAWjB,GAEXkB,EAAkB,SAAUrC,EAAOsC,EAAgBC,GAC1D,OAAOR,EAAQ/B,GACVvM,KAAI,SAAU3B,EAAMqL,GAAS,MAAO,CACrCrL,KAAMA,EACNqL,MAAOA,EACPf,SAAUmG,IAAiC,IAAnBzQ,EAAKsK,UAAoBtK,EAAKoN,SAAW,IAAIU,WAAa,GAAK,EAAK9N,EAAKsK,aAEhG3E,QAAO,SAAUH,GAAQ,OAAQgL,GAAkBhL,EAAK8E,UAAY,KACpEoG,KAAKN,ICnBVO,ECAmB,CACnB,iBACA,iBACA,mBACA,gBAGA,UACA,aACA,UACA,SACA,SACA,QACA,kBACA,kBACA,aACA,oBACA,eDjB2BC,KAAK,KAChCC,EAAsB,GAAGC,OAAOH,EAAgB,wBAChDI,EAA6B,SAAUC,EAAQC,GAC/C,IAAIrD,EACJ,OAAOqC,GAAsC,QAA5BrC,EAAKoD,EAAOE,kBAA+B,IAAPtD,OAAgB,EAASA,EAAGtO,WAAa0R,EAAO1R,UAAU6R,QAAO,SAAUC,EAAKhR,GACjI,OAAOgR,EAAIN,OAAO1Q,EAAMiR,QAAQJ,EAAaJ,EAAsBF,GAAkB,CAACvQ,GAAS,GAAI2Q,EAA2B3Q,MAC/H,KAEIkR,GAAgB,SAAUC,EAASN,GAC1C,OAAOM,EAAQJ,QAAO,SAAUC,EAAKJ,GACjC,OAAOI,EAAIN,OAEXC,EAA2BC,EAAQC,GAEnCD,EAAOrF,WACDsE,EAAQe,EAAOrF,WAAW6F,iBAAiBb,IAAiBhL,QAAO,SAAU3F,GAAQ,OAAOA,IAASgR,KACrG,MACP,KEXIS,GAAkB,SAAUvD,EAAOxB,GAC1C,OAAOuD,EAAQ/B,GACVvI,QAAO,SAAU3F,GAAQ,OAAOyM,EAAgBC,EAAiB1M,MACjE2F,QAAO,SAAU3F,GAAQ,OR6CN,SAAUA,GAClC,SAAUqN,EAAmBrN,IANA,SAAUA,GAAQ,MAAwB,WAAjBA,EAAKsN,QAMrBoE,CAAoB1R,MAAyB,WAAdA,EAAKR,MAAqBQ,EAAK4H,WQ9C/D+J,CAAe3R,OAE7C4R,GAAsB,SAAU1D,EAAOlB,GAE9C,YADc,IAAVA,IAAoBA,EAAQ,IAAI6E,KAC7B5B,EAAQ/B,GAAOvI,QAAO,SAAU3F,GAAQ,OAAO+M,EAAyBC,EAAOhN,OAM/E8R,GAAmB,SAAUC,EAAUrF,EAAiBuE,GAC/D,OAAOV,EAAgBkB,GAAgBH,GAAcS,EAAUd,GAAavE,IAAkB,EAAMuE,IAM7Fe,GAAsB,SAAUD,EAAUrF,GACjD,OAAO6D,EAAgBkB,GAAgBH,GAAcS,GAAWrF,IAAkB,IAO3EuF,GAAuB,SAAUC,EAASxF,GACjD,OAAO+E,IFXHU,EEW2CD,EFXtBV,iBAAiB,IAAIV,OfX1B,wBeW6C,MAC1Db,EAAQkC,GACVxQ,KAAI,SAAU3B,GAAQ,OAAOsR,GAAc,CAACtR,OAC5CmR,QAAO,SAAUC,EAAKlD,GAAS,OAAOkD,EAAIN,OAAO5C,KAAW,KEQRxB,GFZxB,IAC7ByF,GEgBGC,GAAW,SAAUC,EAAOxV,GACnC,OAASwV,EAAMnB,WACTkB,GAASC,EAAMnB,WAAYrU,GAC3BzC,OAAOkY,eAAeD,GAAOD,SAAStX,KAAKuX,EAAOxV,KACpDoT,EAAQoC,EAAM/S,UAAUiT,MAAK,SAAUnS,GAAS,OAAOgS,GAAShS,EAAOvD,OCf3E2V,GAAe,SAAUxS,GACzB,OAAOA,EAAK2L,WAAa6G,GAAaxS,EAAK2L,YAAc3L,GAOlDyS,GAAsB,SAAUzS,GAEvC,OADYmQ,EAAQnQ,GACP2F,OAAOkI,SAASsD,QAAO,SAAUC,EAAKsB,GAC/C,IAAIzK,EAAQyK,EAAYjF,aAAa1J,GAIrC,OAHAqN,EAAI1L,KAAK3K,MAAMqW,EAAMnJ,EAnCV,SAAUiG,GAGzB,IAFA,IAAIyE,EAAY,IAAIlD,IAChBmD,EAAI1E,EAAMzT,OACLF,EAAI,EAAGA,EAAIqY,EAAGrY,GAAK,EACxB,IAAK,IAAIsY,EAAItY,EAAI,EAAGsY,EAAID,EAAGC,GAAK,EAAG,CAC/B,IAAIrW,EAAW0R,EAAM3T,GAAGuY,wBAAwB5E,EAAM2E,KAEjDrW,EAAWqP,KAAKkH,gCAAkC,GACnDJ,EAAUjD,IAAImD,IAEbrW,EAAWqP,KAAKmH,4BAA8B,GAC/CL,EAAUjD,IAAInV,GAK1B,OAAO2T,EAAMvI,QAAO,SAAUsN,EAAG5H,GAAS,OAAQsH,EAAUhD,IAAItE,MAoBtD6H,CAAajD,EAAQuC,GAAaE,GAAalB,iBAAiB,IAAIV,OAAO/M,EAAa,MAAO+M,OAAO7I,EAAO,YAAa6I,OAAO9M,EAAgB,oBACjJ,CAAC0O,IACAtB,IACR,KChDH+B,GAA+B,SAAUjC,GACzC,OAAOA,EAAW3H,cACZ2H,EAAW3H,cAAc2H,WACrBiC,GAA6BjC,EAAW3H,cAAc2H,YACtDA,EAAW3H,mBACfM,GAKCuJ,GAAmB,WAC1B,OAAQrW,SAASwM,cACXxM,SAASwM,cAAc2H,WACnBiC,GAA6BpW,SAASwM,cAAc2H,YACpDnU,SAASwM,mBACbM,GCZNwJ,GAAa,SAAUrT,EAAMuR,GAM7B,YALgB,IAAZA,IAAsBA,EAAU,IACpCA,EAAQ7L,KAAK1F,GACTA,EAAK2L,YACL0H,GAAWrT,EAAK2L,WAAWI,MAAQ/L,EAAK2L,WAAY4F,GAEjDA,GAQA+B,GAAkB,SAAUC,EAAOC,GAI1C,IAHA,IAAIC,EAAWJ,GAAWE,GACtBG,EAAWL,GAAWG,GAEjBjZ,EAAI,EAAGA,EAAIkZ,EAAShZ,OAAQF,GAAK,EAAG,CACzC,IAAIoZ,EAAgBF,EAASlZ,GAC7B,GAAImZ,EAAS3X,QAAQ4X,IAAkB,EACnC,OAAOA,EAGf,OAAO,GAEAC,GAAqB,SAAUC,EAAmBC,EAAWC,GACpE,IAAIC,EAAiB7D,EAAQ0D,GACzBI,EAAc9D,EAAQ2D,GACtBvK,EAAgByK,EAAe,GAC/BE,GAAY,EAgBhB,OAfAD,EAAYtO,OAAOkI,SAAStM,SAAQ,SAAU4S,GAC1CD,EAAYZ,GAAgBY,GAAaC,EAAOA,IAAUD,EAC1DH,EAAapO,OAAOkI,SAAStM,SAAQ,SAAU6S,GAC3C,IAAIC,EAASf,GAAgB/J,EAAe6K,GACxCC,IAEIH,GADCA,GAAa9B,GAASiC,EAAQH,GACnBG,EAGAf,GAAgBe,EAAQH,UAM7CA,GCzBAI,GAAgB,SAAUpC,EAAStD,GAC1C,IAAIrF,EAAgBxM,UAAYqW,KAC5BmB,EAAU9B,GAAoBP,GAASvM,OAAOoI,GAC9CyG,EAAeZ,GAAmBrK,GAAiB2I,EAASA,EAASqC,GACrE7H,EAAkB,IAAImF,IACtB4C,EAAezC,GAAoBuC,EAAS7H,GAC5CgI,EAAgB5C,GAAiByC,EAAS7H,GAAiB/G,QAAO,SAAUiI,GAC5E,IAAI5N,EAAO4N,EAAG5N,KACd,OAAO+N,EAAY/N,MAEvB,GAAK0U,EAAc,KACfA,EAAgBD,GACG,GAFvB,CAMA,IA5ByBE,EAAUC,EAC/BC,EANwBC,EAiCxBnG,EAAaqD,GAAoB,CAACwC,GAAe9H,GAAiB/K,KAAI,SAAUiM,GAEhF,OADWA,EAAG5N,QAGd+U,GAhCqBJ,EAgCehG,EAhCLiG,EAgCiBF,EA/BhDG,EAAQ,IAAIhD,IAEhB+C,EAASrT,SAAQ,SAAUyT,GAAU,OAAOH,EAAM/H,IAAIkI,EAAOhV,KAAMgV,MAE5DL,EAAShT,KAAI,SAAU3B,GAAQ,OAAO6U,EAAMjI,IAAI5M,MAAU2F,OAAOqI,IA4BpEU,EAAaqG,EAAqBpT,KAAI,SAAUiM,GAEhD,OADWA,EAAG5N,QAGdiV,EAAQxG,EAASC,EAAYC,EAAYpF,EAAeqF,GAC5D,GAAIqG,IAAUzG,EAAW,CACrB,IAAI0G,EAAgBtD,GAAoB6C,EAAa9S,KAAI,SAAUiM,GAE/D,OADWA,EAAG5N,SAEd2F,QA/CoBmP,EDiDK,SAAUP,EAAS7H,GACpD,OAAO6H,EAAQpD,QAAO,SAAUC,EAAKpR,GAAQ,OAAOoR,EAAIN,OAAOmB,GAAqBjS,EAAM0M,MAAsB,ICHjFyI,CAAwBZ,EAAS7H,GA9CzD,SAAU1M,GAAQ,IAAI4N,EAE7B,OAAO5N,EAAKoV,cAA4C,QAA3BxH,EAAKT,EAAWnN,UAA0B,IAAP4N,OAAgB,EAASA,EAAGwH,YAAcN,EAAe/Y,QAAQiE,IAAS,KA6CtI,MAAO,CACHA,KAAMkV,GAAiBA,EAAcza,OAC/B6T,EAAe4G,GACf5G,EAAesD,GAAoBlD,KAGjD,YAAc7E,IAAVoL,EACOA,EAEJF,EAAqBE,KCvD5BI,GAAa,EACbC,IAAe,ECCnB,GDOsB,SAAUpD,EAAStD,EAAUnI,QAC/B,IAAZA,IAAsBA,EAAU,IACpC,IAnB2BnM,EAAQ2O,EAmB/BsM,EAAYjB,GAAcpC,EAAStD,GACvC,IAAI0G,IAGAC,EAAW,CACX,GAAIF,GAAa,EAQb,OANAG,QAAQ1W,MAAM,qJAEdwW,IAAe,OACfhU,YAAW,WACPgU,IAAe,IAChB,GAGPD,KAlCuB/a,EAmCfib,EAAUvV,KAnCaiJ,EAmCPxC,EAAQwC,aAlChC,UAAW3O,GACXA,EAAOoP,MAAMT,GAEb,kBAAmB3O,GAAUA,EAAOmb,eACpCnb,EAAOmb,cAAc/L,QA+BrB2L,OEhCJK,GAAoB,SAAUxD,GAC9B,OAAOrE,QAAQoC,EAAQiC,EAAQV,iBAAiB,WAAWe,MAAK,SAAUvS,GAAQ,OAAoBA,IAFnDjD,SAASwM,mBAOrDoM,GAAc,SAAUzD,GAC/B,IAAI3I,EAAgBxM,UAAYqW,KAChC,SAAK7J,GAAkBA,EAAc6D,SAAW7D,EAAc6D,QAAQU,aAG/D2E,GAAoBP,GAASK,MAAK,SAAUvS,GAAQ,OAAOoS,GAASpS,EAAMuJ,IAAkBmM,GAAkB1V,OCR9G4V,GAAkB,SAAU1D,GACnC,IAAIqC,EAAU9B,GAAoBP,GAASvM,OAAOoI,GAC9CyG,EAAeZ,GAAmB1B,EAASA,EAASqC,GACpD7H,EAAkB,IAAImF,IACtBlD,EAAamD,GAAiB,CAAC0C,GAAe9H,GAAiB,GAC/DgI,EAAgB5C,GAAiByC,EAAS7H,GACzC/G,QAAO,SAAUiI,GAClB,IAAI5N,EAAO4N,EAAG5N,KACd,OAAO+N,EAAY/N,MAElB2B,KAAI,SAAUiM,GAEf,OADWA,EAAG5N,QAGlB,OAAO2O,EAAWhN,KAAI,SAAUiM,GAC5B,IAAI5N,EAAO4N,EAAG5N,KACd,MAAO,CACHA,KAAMA,EACNqL,MAHwBuC,EAAGvC,MAI3BwK,SAAUnB,EAAc3Y,QAAQiE,IAAS,EACzC8V,MAAOnI,EAAQ3N,QC5BpB,SAAS+V,GAAYC,GAE1B,IACIC,EADUnZ,OACamZ,aAEC,qBAAjBA,EACTA,EAAaD,GAEb1U,WAAW0U,EAAQ,GAGhB,ICCHE,GAAc,WAChB,OAJOnZ,UAAYA,SAASwM,gBAAkBxM,SAASoE,SCCjDoI,EAAgBxM,UAAYqW,OAKzBnD,EAAQlT,SAASyU,iBAAiB,IAAIV,O5BJxB,qB4BI4C,OAAOyB,MAAK,SAAUvS,GAAQ,OAAOoS,GAASpS,EAAMuJ,MAN9F,IACnBA,GDMJ4M,GAAiB,KACjBC,GAAkB,KAClBC,GAAsB,KACtBC,IAAwB,EAExBC,GAAmB,WACrB,OAAO,GAkBT,SAASC,GAAUC,EAAYC,EAAKC,EAAMC,GACxC,IAAIC,EAAY,KACZtc,EAAIkc,EAER,EAAG,CACD,IAAIhR,EAAOmR,EAASrc,GAEpB,GAAIkL,EAAKqQ,MACHrQ,EAAKzF,KAAKoN,QAAQ0J,iBACpBD,EAAYpR,OAET,KAAIA,EAAKoQ,SAQd,MAPA,GAAItb,IAAMkc,EAER,OAGFI,EAAY,aAINtc,GAAKoc,KAAUD,GAErBG,IACFA,EAAU7W,KAAKsK,SAAW,GAI9B,IAAIyM,GAAa,SAAoB1b,GACnC,OAAOA,GAAO,YAAaA,EAAMA,EAAIwD,QAAUxD,GAa7C2b,GAAc,SAASA,EAAYC,EAAO9I,EAAI+I,GAChD,OAAO/I,IACPA,EAAGpC,OAASkL,KAAW9I,EAAG5E,eAAiB2N,EAAS9E,SAASjE,EAAG5E,iBAC7D4E,EAAGxC,YAAcqL,EAAYC,EAAO9I,EAAGxC,WAAYuL,KASpDC,GAAe,WACjB,IA3DqDta,EA2DjDgQ,GAAS,EAEb,GAAIsJ,GAAgB,CAClB,IAAIiB,EAAkBjB,GAClB1O,EAAW2P,EAAgB3P,SAC3BK,EAAkBsP,EAAgBtP,gBAClCE,EAAYoP,EAAgBpP,UAC5BO,EAAS6O,EAAgB7O,OACzBR,EAAaqP,EAAgBrP,WAC7BkB,EAAemO,EAAgBnO,aAC/BoO,EAAc5P,GAAY4O,IAAuBA,GAAoBiB,gBACrE/N,EAAgBxM,UAAYA,SAASwM,cAEzC,GAAI8N,EAAa,CACf,IAAIE,EAAc,CAACF,GAAavG,OAAOvI,EAAO5G,IAAIoV,IAAYpR,OAAOkI,UA2BrE,GAzBKtE,IAtFY,SAA0BA,GAC/C,OAAQ4M,GAAe/N,WAAamO,IAAkBhN,GAqF5BiO,CAAiBjO,KACjCzB,IAAmCC,EArCpC8F,QAAQyI,IAIgB,cAA1BA,MAiCsDJ,OAAkBE,IAAmBpO,KACtFqP,KACJ1B,GAAY4B,IACZhO,GA3BO,SAAoBA,EAAegO,GAClD,OAAOA,EAAYhF,MAAK,SAAUkF,GAChC,OAAOT,GAAYzN,EAAekO,EAAMA,MAyBjBC,CAAWnO,EAAegO,KA/EE1a,EA+EkC0M,EA9EhF8M,IAAuBA,GAAoBiB,kBAAoBza,MA+ExDE,WAAaqZ,IAAmB7M,IAAkBvB,GAEhDuB,EAAcoO,MAChBpO,EAAcoO,OAGhB5a,SAASoE,KAAKuI,UAEdmD,EAAS,GAAgB0K,EAAanB,GAAiB,CACrDnN,aAAcA,IAEhBoN,GAAsB,KAI1BC,IAAwB,EACxBF,GAAkBrZ,UAAYA,SAASwM,eAIvCxM,SAAU,CACZ,IAAI6a,EAAmB7a,UAAYA,SAASwM,cACxCqN,EAAWhB,GAAgB2B,GAC3BM,EAAejB,EAASjV,KAAI,SAAUvG,GAExC,OADWA,EAAK4E,QAEfjE,QAAQ6b,GAEPC,GAAgB,IAElBjB,EAASjR,QAAO,SAAUmS,GACxB,IAAIhC,EAAQgC,EAAMhC,MACd9V,EAAO8X,EAAM9X,KACjB,OAAO8V,GAAS9V,EAAKoN,QAAQ0J,kBAC5BvV,SAAQ,SAAUwW,GAEnB,OADWA,EAAM/X,KACLgY,gBAAgB,eAE9BxB,GAAUqB,EAAcjB,EAASnc,OAAQ,EAAImc,GAC7CJ,GAAUqB,GAAe,GAAI,EAAGjB,MAMxC,OAAO/J,GAGLoL,GAAS,SAAgBlO,GACvBoN,MAAkBpN,IAEpBA,EAAMmO,kBACNnO,EAAMoO,mBAINnO,GAAS,WACX,OAAO+L,GAAYoB,KAGjBrN,GAAU,SAAiBC,GAE7B,IAAIrP,EAASqP,EAAMzP,OACfoY,EAAc3I,EAAMjD,cAEnB4L,EAAYN,SAAS1X,KAvJ1B2b,GAAsB,CACpB+B,aAuJa1F,EAtJb4E,gBAsJ0B5c,KAoB1B2d,GAAe,WACjB/B,GAAwB,OAExBhV,YAAW,WACTgV,GAAwB,cACvB,IA6DLzP,EAAYhB,iBAAiBiE,IAC7B/C,EAAWf,aAAagE,IACxBhD,EAAahB,cAAa,SAAUF,GAClC,OAAOA,EAAG,CACRwS,gBAAiB,GACjB3C,YAAaA,QAGjB,OAAe,GAtDf,SAA4B4C,GAC1B,OAAOA,EAAU5S,QAAO,SAAU6S,GAEhC,OADeA,EAAM5Q,eAKzB,SAAmC6Q,GACjC,IAAIC,EAAOD,EAAMza,OAAO,GAAG,GAEvB0a,IAASvC,KArBbpZ,SAAS4b,iBAAiB,UAAWV,IACrClb,SAAS4b,iBAAiB,WAAY3O,IACtClN,OAAO6b,iBAAiB,OAAQN,KAuBhC,IAAIO,EAAWzC,GACX0C,EAAWD,GAAYF,GAAQA,EAAKpP,KAAOsP,EAAStP,GACxD6M,GAAiBuC,EAEbE,IAAaC,IACfD,EAASvP,iBAEJoP,EAAM9S,QAAO,SAAUmT,GAE1B,OADSA,EAAMxP,KACDsP,EAAStP,MACtB7O,QAEDme,EAAS5P,aAAa0P,IAItBA,GACFtC,GAAkB,KAEbyC,GAAYD,EAASnR,WAAaiR,EAAKjR,UAC1CiR,EAAKvP,eAGPgO,KACApB,GAAYoB,MA3Cdpa,SAASgc,oBAAoB,UAAWd,IACxClb,SAASgc,oBAAoB,WAAY/O,IACzClN,OAAOic,oBAAoB,OAAQV,IA4CjCjC,GAAkB,QAatB,EA1FmB,WACjB,OAAO,QE7KL4C,GAAoC,cAAiB,SAAgCrd,EAAON,GAC9F,OAAoB,gBAAoB,GAAa,OAAS,CAC5DyN,QAAS,GACTzN,IAAKA,GACJM,OAGDP,GAAO,aAAyB,GACtBA,GAAK0N,SACH,OAA8B1N,GAAM,CAAC,YAErD4d,GAAqBnU,UAAgE,GACrF,ICxBA,GDwBA,GE1BWoU,GAAqB,4BACrBC,GAAqB,0BCArBC,GAAY3S,ICInB4S,GAAU,aAMVC,GAAe,cAAiB,SAAU1d,EAAOyL,GACjD,IAAI/L,EAAM,SAAa,MACnBuS,EAAK,WAAe,CACpB0L,gBAAiBF,GACjBG,eAAgBH,GAChBI,mBAAoBJ,KACpBK,EAAY7L,EAAG,GAAI8L,EAAe9L,EAAG,GACrC+L,EAAehe,EAAMge,aAAcra,EAAW3D,EAAM2D,SAAU6I,EAAYxM,EAAMwM,UAAWyR,EAAkBje,EAAMie,gBAAiBC,EAAUle,EAAMke,QAAStR,EAAS5M,EAAM4M,OAAQO,EAAUnN,EAAMmN,QAASgR,EAAcne,EAAMme,YAAaC,EAAQpe,EAAMoe,MAAOC,EAAiBre,EAAMqe,eAAgBC,EAAKte,EAAMJ,GAAIkN,OAAmB,IAAPwR,EAAgB,MAAQA,EAAIC,GAAO,QAAOve,EAAO,CAAC,eAAgB,WAAY,YAAa,kBAAmB,UAAW,SAAU,UAAW,cAAe,QAAS,iBAAkB,OAC7fkN,EAAUC,EACVqR,EAAelW,EAAa,CAAC5I,EAAK+L,IAClCwB,GAAiB,SAAS,QAAS,GAAIsR,GAAOT,GAClD,OAAQ,gBAAoB,WAAgB,KACxCI,GAAY,gBAAoBhR,EAAS,CAAEC,QAASqQ,GAAWS,gBAAiBA,EAAiBrR,OAAQA,EAAQuR,YAAaA,EAAaC,MAAOA,EAAOL,aAAcA,EAAcM,iBAAkBA,EAAgBI,QAAS/e,IAChOse,EAAgB,eAAmB,gBAAoBra,IAAW,SAAS,QAAS,GAAIsJ,GAAiB,CAAEvN,IAAK8e,KAAqB,gBAAoB1R,GAAW,QAAS,GAAIG,EAAgB,CAAET,UAAWA,EAAW9M,IAAK8e,IAAiB7a,OAEvP+Z,GAAavU,aAAe,CACxB+U,SAAS,EACTD,iBAAiB,EACjBG,OAAO,GAEXV,GAAagB,WAAa,CACtBC,UAAWpB,GACXqB,UAAWtB,IC/Bf,ICFIuB,GDEA3R,GAAU,SAAU+E,GACpB,IAAI9E,EAAU8E,EAAG9E,QAASoR,GAAO,QAAOtM,EAAI,CAAC,YAC7C,IAAK9E,EACD,MAAM,IAAI/J,MAAM,sEAEpB,IAAI0b,EAAS3R,EAAQxD,OACrB,IAAKmV,EACD,MAAM,IAAI1b,MAAM,4BAEpB,OAAO,gBAAoB0b,GAAQ,QAAS,GAAIP,KAEpDrR,GAAQ6R,iBAAkB,EEZ1B,SAASC,KACL,IAAK5d,SACD,OAAO,KACX,IAAI6d,EAAM7d,SAASd,cAAc,SACjC2e,EAAIpb,KAAO,WACX,IAAIqb,EDDAL,IAIO,KCCX,OAHIK,GACAD,EAAI1Z,aAAa,QAAS2Z,GAEvBD,EAgBJ,IAAIE,GAAsB,WAC7B,IAAIC,EAAU,EACVC,EAAa,KACjB,MAAO,CACHtL,IAAK,SAAUhU,GAlBvB,IAAsBkf,EAAKK,EAmBA,GAAXF,IACKC,EAAaL,QApBPM,EAqBkBvf,GArBvBkf,EAqBWI,GAnBrBE,WAEJN,EAAIM,WAAWC,QAAUF,EAGzBL,EAAIxZ,YAAYrE,SAASqe,eAAeH,IAGhD,SAAwBL,IACT7d,SAASse,MAAQte,SAASue,qBAAqB,QAAQ,IAC7Dla,YAAYwZ,GAUDW,CAAeP,IAGvBD,KAEJS,OAAQ,cACJT,GACgBC,IACZA,EAAWrP,YAAcqP,EAAWrP,WAAW8P,YAAYT,GAC3DA,EAAa,SCpClBU,GAAiB,WACxB,ICIIC,EDJAC,GCIAD,EAAQb,KACL,SAAUe,EAAQC,GACrB,aAAgB,WAEZ,OADAH,EAAMjM,IAAImM,GACH,WACHF,EAAMH,YAEX,CAACK,GAAUC,MDLlB,OALY,SAAUlO,GAClB,IAAIiO,EAASjO,EAAGiO,OAAQE,EAAUnO,EAAGmO,QAErC,OADAH,EAASC,EAAQE,GACV,OEZJC,GAAU,CACjBrX,KAAM,EACND,IAAK,EACLuX,MAAO,EACPC,IAAK,GAELC,GAAQ,SAAUvW,GAAK,OAAOwW,SAASxW,GAAK,GAAI,KAAO,GAahDyW,GAAc,SAAUC,GAE/B,QADgB,IAAZA,IAAsBA,EAAU,UACd,qBAAXxf,OACP,OAAOkf,GAEX,IAAIO,EAjBQ,SAAUD,GACtB,IAAIE,EAAK1f,OAAOwP,iBAAiBvP,SAASoE,MAMtCwD,EAAO6X,EAAe,YAAZF,EAAwB,cAAgB,cAClD5X,EAAM8X,EAAe,YAAZF,EAAwB,aAAe,aAChDL,EAAQO,EAAe,YAAZF,EAAwB,eAAiB,eACxD,MAAO,CAACH,GAAMxX,GAAOwX,GAAMzX,GAAMyX,GAAMF,IAOzBQ,CAAUH,GACpBI,EAAgB3f,SAAS4f,gBAAgBC,YACzCC,EAAc/f,OAAOggB,WACzB,MAAO,CACHnY,KAAM4X,EAAQ,GACd7X,IAAK6X,EAAQ,GACbN,MAAOM,EAAQ,GACfL,IAAKnM,KAAKgN,IAAI,EAAGF,EAAcH,EAAgBH,EAAQ,GAAKA,EAAQ,MC3BxES,GAAQtB,KAIRuB,GAAY,SAAUrP,EAAIsP,EAAeZ,EAASa,GAClD,IAAIxY,EAAOiJ,EAAGjJ,KAAMD,EAAMkJ,EAAGlJ,IAAKuX,EAAQrO,EAAGqO,MAAOC,EAAMtO,EAAGsO,IAE7D,YADgB,IAAZI,IAAsBA,EAAU,UAC7B,QAAQxL,OTTgB,0BSSc,4BAA4BA,OAAOqM,EAAW,yBAAyBrM,OAAOoL,EAAK,OAAOpL,OAAOqM,EAAW,2CAA2CrM,OAAOqM,EAAW,8CAA8CrM,OAAO,CACvQoM,GAAiB,sBAAsBpM,OAAOqM,EAAW,KAC7C,WAAZb,GACI,uBAAuBxL,OAAOnM,EAAM,0BAA0BmM,OAAOpM,EAAK,4BAA4BoM,OAAOmL,EAAO,kEAAkEnL,OAAOoL,EAAK,OAAOpL,OAAOqM,EAAW,WACnN,YAAZb,GAAyB,kBAAkBxL,OAAOoL,EAAK,OAAOpL,OAAOqM,EAAW,MAE/ExX,OAAOkI,SACP+C,KAAK,IAAK,kBAAkBE,OAAOmI,GAAoB,mBAAmBnI,OAAOoL,EAAK,OAAOpL,OAAOqM,EAAW,mBAAmBrM,OAAOoI,GAAoB,0BAA0BpI,OAAOoL,EAAK,OAAOpL,OAAOqM,EAAW,mBAAmBrM,OAAOmI,GAAoB,MAAMnI,OAAOmI,GAAoB,qBAAqBnI,OAAOqM,EAAW,mBAAmBrM,OAAOoI,GAAoB,MAAMpI,OAAOoI,GAAoB,4BAA4BpI,OAAOqM,EAAW,8BAA8BrM,OTXld,iCSWif,MAAMA,OAAOoL,EAAK,eAK5hBkB,GAAkB,SAAUzhB,GACnC,IAAI0hB,EAAa1hB,EAAM0hB,WAAYC,EAAc3hB,EAAM2hB,YAAa1P,EAAKjS,EAAM2gB,QAASA,OAAiB,IAAP1O,EAAgB,SAAWA,EACzHsO,EAAM,WAAc,WAAc,OAAOG,GAAYC,KAAa,CAACA,IACvE,OAAO,gBAAoBU,GAAO,CAAEnB,OAAQoB,GAAUf,GAAMmB,EAAYf,EAAUgB,EAA6B,GAAf,iBC1BhGC,IAAmB,EACvB,GAAsB,qBAAXzgB,OACP,IACI,IAAI2J,GAAUrM,OAAOojB,eAAe,GAAI,UAAW,CAC/C5Q,IAAK,WAED,OADA2Q,IAAmB,GACZ,KAIfzgB,OAAO6b,iBAAiB,OAAQlS,GAASA,IAEzC3J,OAAOic,oBAAoB,OAAQtS,GAASA,IAEhD,MAAOhE,IACH8a,IAAmB,EAGpB,IAAIE,KAAaF,IAAmB,CAAEG,SAAS,GCdlDC,GAAuB,SAAU3d,EAAM1D,GACvC,IAAIuf,EAAS/e,OAAOwP,iBAAiBtM,GACrC,MAEqB,WAArB6b,EAAOvf,MAEDuf,EAAO+B,YAAc/B,EAAOgC,YAVX,SAAU7d,GAEjC,MAAwB,aAAjBA,EAAKsN,QAQoCwQ,CAAqB9d,IAA8B,YAArB6b,EAAOvf,KAI9EyhB,GAA0B,SAAUC,EAAMhe,GACjD,IAAInB,EAAUmB,EACd,EAAG,CAMC,GAJ0B,qBAAfie,YAA8Bpf,aAAmBof,aACxDpf,EAAUA,EAAQkN,MAEHmS,GAAuBF,EAAMnf,GAC9B,CACd,IAAI+O,EAAKuQ,GAAmBH,EAAMnf,GAClC,GADgD+O,EAAG,GAAQA,EAAG,GAE1D,OAAO,EAGf/O,EAAUA,EAAQ8M,iBACb9M,GAAWA,IAAY9B,SAASoE,MACzC,OAAO,GAkBP+c,GAAyB,SAAUF,EAAMhe,GACzC,MAAgB,MAATge,EArCmB,SAAUhe,GAAQ,OAAO2d,GAAqB3d,EAAM,aAqCxDoe,CAAwBpe,GApCpB,SAAUA,GAAQ,OAAO2d,GAAqB3d,EAAM,aAoCxBqe,CAAwBre,IAE9Eme,GAAqB,SAAUH,EAAMhe,GACrC,MAAgB,MAATge,EAlBA,EAFyBpQ,EAoBU5N,GAnBvBse,UAA0B1Q,EAAG2Q,aAA6B3Q,EAAG4Q,cAO1D,SAAU5Q,GAEhC,MAAO,CADUA,EAAG6Q,WAA0B7Q,EAAG8Q,YAA2B9Q,EAAGgP,aAW7B+B,CAAoB3e,GApBhD,IAAU4N,GC1BzBgR,GAAa,SAAU7U,GAC9B,MAAO,mBAAoBA,EAAQ,CAACA,EAAM8U,eAAe,GAAGC,QAAS/U,EAAM8U,eAAe,GAAGE,SAAW,CAAC,EAAG,IAErGC,GAAa,SAAUjV,GAAS,MAAO,CAACA,EAAMkV,OAAQlV,EAAMmV,SACnE,GAAa,SAAU7jB,GACvB,OAAOA,GAAO,YAAaA,EAAMA,EAAIwD,QAAUxD,GAG/C8jB,GAAgB,SAAU7V,GAAM,MAAO,4BAA4BwH,OAAOxH,EAAI,qDAAqDwH,OAAOxH,EAAI,8BAC9I8V,GAAY,EACZC,GAAY,GCbhB,IVWsCC,GUXtC,IVWsCA,GSG/B,SAA6B3jB,GAChC,IAAI4jB,EAAqB,SAAa,IAClCC,EAAgB,SAAa,CAAC,EAAG,IACjCC,EAAa,WACbnW,EAAK,WAAe8V,MAAa,GACjCpC,EAAQ,YAAe,WAAc,OAAOtB,QAAqB,GACjEgE,EAAY,SAAa/jB,GAC7B,aAAgB,WACZ+jB,EAAU7gB,QAAUlD,IACrB,CAACA,IACJ,aAAgB,WACZ,GAAIA,EAAMoe,MAAO,CACbhd,SAASoE,KAAKwe,UAAUjQ,IAAI,uBAAuBoB,OAAOxH,IAC1D,IAAIsW,GAAU,QAAc,CAACjkB,EAAMye,QAAQvb,UAAWlD,EAAM4M,QAAU,IAAI5G,IAAI,KAAa,GAAMgE,OAAOkI,SAExG,OADA+R,EAAQre,SAAQ,SAAU4M,GAAM,OAAOA,EAAGwR,UAAUjQ,IAAI,uBAAuBoB,OAAOxH,OAC/E,WACHvM,SAASoE,KAAKwe,UAAUnE,OAAO,uBAAuB1K,OAAOxH,IAC7DsW,EAAQre,SAAQ,SAAU4M,GAAM,OAAOA,EAAGwR,UAAUnE,OAAO,uBAAuB1K,OAAOxH,WAIlG,CAAC3N,EAAMoe,MAAOpe,EAAMye,QAAQvb,QAASlD,EAAM4M,SAC9C,IAAIsX,EAAoB,eAAkB,SAAU9V,EAAOiH,GACvD,GAAI,YAAajH,GAAkC,IAAzBA,EAAM+V,QAAQrlB,OACpC,OAAQilB,EAAU7gB,QAAQmb,eAE9B,IAII+F,EAJAC,EAAQpB,GAAW7U,GACnBkW,EAAaT,EAAc3gB,QAC3BogB,EAAS,WAAYlV,EAAQA,EAAMkV,OAASgB,EAAW,GAAKD,EAAM,GAClEd,EAAS,WAAYnV,EAAQA,EAAMmV,OAASe,EAAW,GAAKD,EAAM,GAElE1lB,EAASyP,EAAMzP,OACf4lB,EAAgBnQ,KAAKC,IAAIiP,GAAUlP,KAAKC,IAAIkP,GAAU,IAAM,IAEhE,GAAI,YAAanV,GAA2B,MAAlBmW,GAAyC,UAAhB5lB,EAAOkF,KACtD,OAAO,EAEX,IAAI2gB,EAA+BpC,GAAwBmC,EAAe5lB,GAC1E,IAAK6lB,EACD,OAAO,EAUX,GARIA,EACAJ,EAAcG,GAGdH,EAAgC,MAAlBG,EAAwB,IAAM,IAC5CC,EAA+BpC,GAAwBmC,EAAe5lB,KAGrE6lB,EACD,OAAO,EAKX,IAHKV,EAAW5gB,SAAW,mBAAoBkL,IAAUkV,GAAUC,KAC/DO,EAAW5gB,QAAUkhB,IAEpBA,EACD,OAAO,EAEX,IAAIK,EAAgBX,EAAW5gB,SAAWkhB,EAC1C,ODdkB,SAAU/B,EAAMqC,EAAWtW,EAAOuW,EAAaC,GACrE,IAAIC,EATiB,SAAUxC,EAAMyC,GAMrC,MAAgB,MAATzC,GAA8B,QAAdyC,GAAuB,EAAI,EAG5BC,CAAmB1C,EAAMlhB,OAAOwP,iBAAiB+T,GAAWI,WAC9EE,EAAQH,EAAkBF,EAE1BhmB,EAASyP,EAAMzP,OACfsmB,EAAeP,EAAUjO,SAAS9X,GAClCumB,GAAqB,EACrBC,EAAkBH,EAAQ,EAC1BI,EAAkB,EAClBC,EAAqB,EACzB,EAAG,CACC,IAAIpT,EAAKuQ,GAAmBH,EAAM1jB,GAASkC,EAAWoR,EAAG,GACrDqT,EADoErT,EAAG,GAAeA,EAAG,GACnD4S,EAAkBhkB,GACxDA,GAAYykB,IACR/C,GAAuBF,EAAM1jB,KAC7BymB,GAAmBE,EACnBD,GAAsBxkB,GAG9BlC,EAASA,EAAOqR,kBAGlBiV,GAAgBtmB,IAAWyC,SAASoE,MAEjCyf,IAAiBP,EAAUjO,SAAS9X,IAAW+lB,IAAc/lB,IAQlE,OAPIwmB,IAAqBP,GAAoC,IAApBQ,IAA4BR,GAAgBI,EAAQI,KAGnFD,IACJP,GAAuC,IAAvBS,IAA+BT,IAAiBI,EAAQK,MAH1EH,GAAqB,GAMlBA,EClBIK,CAAad,EAAepP,EAAQjH,EAAyB,MAAlBqW,EAAwBnB,EAASC,GAAQ,KAC5F,IACCiC,EAAgB,eAAkB,SAAUC,GAC5C,IAAIrX,EAAQqX,EACZ,GAAK/B,GAAU5kB,QAAU4kB,GAAUA,GAAU5kB,OAAS,KAAOuiB,EAA7D,CAIA,IAAI2D,EAAQ,WAAY5W,EAAQiV,GAAWjV,GAAS6U,GAAW7U,GAC3DsX,EAAc9B,EAAmB1gB,QAAQ8G,QAAO,SAAU2b,GAAK,OAAOA,EAAEpjB,OAAS6L,EAAMvK,MAAQ8hB,EAAEhnB,SAAWyP,EAAMzP,SAxEjGsL,EAwEwH0b,EAAEX,MAxEvHY,EAwE8HZ,EAxElH/a,EAAE,KAAO2b,EAAE,IAAM3b,EAAE,KAAO2b,EAAE,IAArD,IAAU3b,EAAG2b,KAwEyI,GAEjK,GAAIF,GAAeA,EAAYG,OACvBzX,EAAM0X,YACN1X,EAAMoO,sBAKd,IAAKkJ,EAAa,CACd,IAAIK,GAAchC,EAAU7gB,QAAQ0J,QAAU,IACzC5G,IAAI,IACJgE,OAAOkI,SACPlI,QAAO,SAAU3F,GAAQ,OAAOA,EAAKoS,SAASrI,EAAMzP,YACxConB,EAAWjnB,OAAS,EAAIolB,EAAkB9V,EAAO2X,EAAW,KAAOhC,EAAU7gB,QAAQib,cAE9F/P,EAAM0X,YACN1X,EAAMoO,qBAInB,IACCwJ,EAAe,eAAkB,SAAUzjB,EAAMyiB,EAAOrmB,EAAQknB,GAChE,IAAIzX,EAAQ,CAAE7L,KAAMA,EAAMyiB,MAAOA,EAAOrmB,OAAQA,EAAQknB,OAAQA,GAChEjC,EAAmB1gB,QAAQ6G,KAAKqE,GAChCzI,YAAW,WACPie,EAAmB1gB,QAAU0gB,EAAmB1gB,QAAQ8G,QAAO,SAAU2b,GAAK,OAAOA,IAAMvX,OAC5F,KACJ,IACC6X,EAAmB,eAAkB,SAAU7X,GAC/CyV,EAAc3gB,QAAU+f,GAAW7U,GACnC0V,EAAW5gB,aAAUgL,IACtB,IACCgY,EAAc,eAAkB,SAAU9X,GAC1C4X,EAAa5X,EAAMvK,KAAMwf,GAAWjV,GAAQA,EAAMzP,OAAQulB,EAAkB9V,EAAOpO,EAAMye,QAAQvb,YAClG,IACCijB,EAAkB,eAAkB,SAAU/X,GAC9C4X,EAAa5X,EAAMvK,KAAMof,GAAW7U,GAAQA,EAAMzP,OAAQulB,EAAkB9V,EAAOpO,EAAMye,QAAQvb,YAClG,IACH,aAAgB,WAUZ,OATAwgB,GAAU3Z,KAAKsX,GACfrhB,EAAM+d,aAAa,CACfJ,gBAAiBuI,EACjBtI,eAAgBsI,EAChBrI,mBAAoBsI,IAExB/kB,SAAS4b,iBAAiB,QAASwI,EAAe1D,IAClD1gB,SAAS4b,iBAAiB,YAAawI,EAAe1D,IACtD1gB,SAAS4b,iBAAiB,aAAciJ,EAAkBnE,IACnD,WACH4B,GAAYA,GAAU1Z,QAAO,SAAUoc,GAAQ,OAAOA,IAAS/E,KAC/DjgB,SAASgc,oBAAoB,QAASoI,EAAe1D,IACrD1gB,SAASgc,oBAAoB,YAAaoI,EAAe1D,IACzD1gB,SAASgc,oBAAoB,aAAc6I,EAAkBnE,OAElE,IACH,IAAI7D,EAAkBje,EAAMie,gBAAiBG,EAAQpe,EAAMoe,MAC3D,OAAQ,gBAAoB,WAAgB,KACxCA,EAAQ,gBAAoBiD,EAAO,CAAEnB,OAAQsD,GAAc7V,KAAS,KACpEsQ,EAAkB,gBAAoBwD,GAAiB,CAAEd,QAAS,WAAc,OC7I3DnD,GVYlB5T,UAAU+Z,IACVzW,IWZPmZ,GAAoB,cAAiB,SAAUrmB,EAAON,GAAO,OAAQ,gBAAoBge,IAAc,QAAS,GAAI1d,EAAO,CAAEN,IAAKA,EAAKyN,QAAS,SACpJkZ,GAAkB3H,WAAahB,GAAagB,WAC5C,U,uBCmBA,SAASre,GAA8BtB,EAAQkB,GAC7C,GAAc,MAAVlB,EAAgB,MAAO,GAC3B,IAEIC,EAAKJ,EAFLD,EAAS,GACTuB,EAAazB,OAAO0B,KAAKpB,GAG7B,IAAKH,EAAI,EAAGA,EAAIsB,EAAWpB,OAAQF,IACjCI,EAAMkB,EAAWtB,GACbqB,EAASG,QAAQpB,IAAQ,IAC7BL,EAAOK,GAAOD,EAAOC,IAGvB,OAAOL,EAIS,UACY,UACC,UAKlB,UARb,IAsBI2nB,IAA6B,IAAA9mB,aAAW,SAAuBC,EAAMiE,GACvE,IAAI6iB,EAAc9mB,EAAK+mB,OACnBA,OAAyB,IAAhBD,GAAgCA,EACzCvmB,EAAQK,GAA8BZ,EAAM,CAAC,WAoBjD,OAlBA,IAAAmF,YAAU,WACR,OAAO,QAAY,YAClB,KAIH,IAAAA,YAAU,WACJ4hB,EAEFrlB,OAAOslB,0BAA2B,EAElCtlB,OAAOulB,uBAAsB,WAG3BvlB,OAAOslB,0BAA2B,OAGrC,CAACD,IACGA,EAAS,gBAAoB,IAAQ,CAC1C,4BAA6B,IAC5B,gBAAoBG,GAAaloB,OAAOC,OAAO,CAChDgB,IAAKgE,GACJ1D,KAAW,QAehB,IAAI2mB,IAA2B,IAAAnnB,aAAW,SAAqB2c,EAAOzY,GACpE,IAAI2a,EAAiBlC,EAAMkC,eACvBuI,EAAwBzK,EAAM0K,2BAC9BA,OAAuD,IAA1BD,GAA2CA,EACxEE,EAAyB3K,EAAM4K,4BAC/BA,OAAyD,IAA3BD,GAA4CA,EAC1EE,EAAkB7K,EAAM6K,gBACxBC,EAAU9K,EAAM8K,QAChBC,EAAkB/K,EAAMgL,UACxBA,OAAgC,IAApBD,EAA6B,KAAOA,EAChDE,EAAYjL,EAAMiL,UAClBC,EAAclL,EAAMkL,YACpBC,EAAwBnL,EAAMoL,+BAC9BA,OAA2D,IAA1BD,GAA0CA,EAC3EtnB,EAAQK,GAA8B8b,EAAO,CAAC,iBAAkB,6BAA8B,8BAA+B,kBAAmB,UAAW,YAAa,YAAa,cAAe,mCAEpMqL,GAAkB,IAAAxjB,QAAO,MACzByjB,GAAc,IAAAzjB,QAAO,MACrBtE,GAAM,QAAa+nB,EAAa/jB,GAChCgkB,GAAoB,IAAAtjB,cAAY,WAC9B4iB,GAAmBA,EAAgB9jB,SACrC8jB,EAAgB9jB,QAAQ6K,UAEzB,CAACiZ,IAuBJ,OAHA,IAAApiB,YAAU,WACR,OAAO6iB,EAAYvkB,QAiHvB,SAAyBykB,GACvB,IAAIC,EAAiB,GACjBC,EAAY,GACZxmB,GAAgB,QAAiBsmB,IAAevmB,SAEpD,IAAKumB,EAKH,OAAO,KAuBT,OApBAjmB,MAAMzC,UAAU2G,QAAQzG,KAAKkC,EAAcwU,iBAAiB,aAAa,SAAUxR,GACjF,IAAIyjB,EAAuBC,EAI3B,GAAI1jB,KAFiE,QAAnDyjB,EAAwBH,EAAW3X,kBAAkD,IAA1B8X,GAA4G,QAA/DC,EAAyBD,EAAsB9X,kBAAmD,IAA3B+X,OAAjF,EAA8HA,EAAuB/X,YAErQ,CAIA,IAAIgY,EAAO3jB,EAAKyN,aAAa,eACA,OAATkW,GAA0B,UAATA,IAMrCJ,EAAe7d,KAAKie,GACpBH,EAAU9d,KAAK1F,GACfA,EAAKkB,aAAa,cAAe,aAE5B,WACLsiB,EAAUjiB,SAAQ,SAAUvB,EAAMqL,GAChC,IAAIuY,EAAgBL,EAAelY,GAEb,OAAlBuY,EACF5jB,EAAKgY,gBAAgB,eAErBhY,EAAKkB,aAAa,cAAe0iB,OAzJRC,CAAgBT,EAAYvkB,cAAW,IACnE,IACI,gBAAoB,GAAW,CACpCmJ,WAAW,EACXgB,aAAa,EACbG,aAAcka,EACdzb,SAAU4a,EACVza,WAAYmb,GACX,gBAAoB,GAAc,CACnClJ,eAAgBA,EAChBH,SAAU6I,GACT,gBAAoB,MAAOtoB,OAAOC,OAAO,GAAIsB,EAAO,CACrDN,IAAKA,EACL,4BAA6B,GAO7BunB,SAAS,QAAUA,GAvCrB,SAAqB7Y,GACfoZ,EAAgBtkB,UAAYkL,EAAMzP,SACpCyP,EAAMmO,kBACN4K,EAAU/Y,OAqCZgZ,WAAW,QAAUA,GAjCvB,SAAuBhZ,GACH,WAAdA,EAAMpP,MACRoP,EAAMmO,kBACN4K,EAAU/Y,OA+BZiZ,aAAa,QAAUA,GA3BzB,SAAyBjZ,GACvBoZ,EAAgBtkB,QAAUkL,EAAMzP,kBAoDpC,IAAIwpB,IAA6B,IAAA3oB,aAAW,SAAuB4c,EAAO1Y,GACxE,IAAIujB,EAAU7K,EAAM6K,QAEhBjnB,GADYoc,EAAMgL,UACV/mB,GAA8B+b,EAAO,CAAC,UAAW,eAE7D,OAAO,gBAAoB,MAAO3d,OAAOC,OAAO,CAC9C,aAAc,OACdqH,KAAM,SACN4I,UAAW,GACV3O,EAAO,CACRN,IAAKgE,EACL,4BAA6B,GAC7BujB,SAAS,QAAUA,GAAS,SAAU7Y,GACpCA,EAAMmO,2BAkHZ,I,oCClUA,GAA0B,wBAA1B,GAA2D,uBAA3D,GAA4I,6BAA5I,GAAiL,sBAAjL,GAA2P,2BAA3P,GAA6R,qBAA7R,GAA4T,wB,qQCerT,SAAS6L,GAAT,GAA+D,IAAvC5b,EAAsC,EAAtCA,UAAW7I,EAA2B,EAA3BA,SAAa0kB,GAAc,aAC7D3J,EAAa,CAACwB,IAIpB,OAHI1T,GACFkS,EAAW3U,KAAKyC,GAGhB,gBAAC8Z,IAAD,QAAe9Z,UAAWkS,EAAWzJ,KAAK,MAAUoT,GACjD1kB,GAoCA,SAAS2kB,GAAT,GAA+D,IAAvC9b,EAAsC,EAAtCA,UAAW7I,EAA2B,EAA3BA,SAAa0kB,GAAc,aAC7D3J,EAAa,CAACwB,IAIpB,OAHI1T,GACFkS,EAAW3U,KAAKyC,GAGhB,gBAAC2b,IAAD,QAAe3b,UAAWkS,EAAWzJ,KAAK,MAAUoT,GACjD1kB,GA8BA,SAAS4kB,GAAT,GAA6D,IAAvC/b,EAAsC,EAAtCA,UAAW7I,EAA2B,EAA3BA,SAAa0kB,GAAc,aAC3D3J,EAAa,CAACwB,IAIpB,OAHI1T,GACFkS,EAAW3U,KAAKyC,GAGhB,8BAAIA,UAAWkS,EAAWzJ,KAAK,MAAUoT,GACtC1kB,GAkBA,SAAS6kB,GAAT,GAA+D,IAAvChc,EAAsC,EAAtCA,UAAW7I,EAA2B,EAA3BA,SAAa0kB,GAAc,aAC7D3J,EAAa,CAACwB,IAIpB,OAHI1T,GACFkS,EAAW3U,KAAKyC,GAGhB,+BAAKA,UAAWkS,EAAWzJ,KAAK,MAAUoT,GACvC1kB,GAkBA,SAAS8kB,GAAT,GAAiE,IAAvCjc,EAAsC,EAAtCA,UAAWkc,EAA2B,EAA3BA,IAAKC,EAAsB,EAAtBA,IAAQN,GAAc,aAC/D3J,EAAa,CAACwB,IAIpB,OAHI1T,GACFkS,EAAW3U,KAAKyC,GAGhB,+BAAKkc,IAAKA,EAAKC,IAAKA,EAAKnc,UAAWkS,EAAWzJ,KAAK,MAAUoT,IAkB3D,SAASO,GAAT,GAAkD,IAA7Bpc,EAA4B,EAA5BA,UAAc6b,GAAc,aAChD3J,EAAa,CAACwB,IAIpB,OAHI1T,GACFkS,EAAW3U,KAAKyC,GAEX,+BAAKA,UAAWkS,EAAWzJ,KAAK,MAAUoT,IAgB5C,SAASQ,GAAT,GAAgE,IAApCrc,EAAmC,EAAnCA,UAAWsc,EAAwB,EAAxBA,MAAUT,GAAc,aACpE,OACE,gBAACU,GAAA,GAAD,QAAQllB,KAAK,SAASmlB,QAAQ,OAAOxc,UAAWA,GAAe6b,GAC7D,gBAACY,GAAA,QAAD,CAA2BC,KAAMJ,GAASK,GAAAA,EAAAA,SAmBhD,SAASC,GAAT,GAQI,IAPF5c,EAOC,EAPDA,UACAga,EAMC,EANDA,OACAW,EAKC,EALDA,UACAkC,EAIC,EAJDA,SACA1lB,EAGC,EAHDA,SACAqjB,EAEC,EAFDA,gBACGqB,GACF,aACD,OACE,gBAACD,GAAD,CACE5B,OAAQA,EACRW,UAAWA,EACXH,gBAAiBA,GAEjB,gBAACsB,IAAD,QAAc9b,UAAWA,GAAe6b,GACrCgB,GACC,gBAACR,GAAD,CACErc,UAAW0T,GACX+G,QAASE,IAGZxjB,IA9MT2iB,GAAczW,YAAc,eAE5BuY,GAAajf,aAAe,CAC1BqD,UAAW,KACXga,QAAQ,EACRW,UAAW,aACXH,gBAAiB,aAEjB3I,gBAAgB,EAChBwI,4BAA4B,EAC5BE,6BAA6B,GAG/BqB,GAAalf,UAAY,CACvBvF,SAAUwE,IAAAA,KAAAA,WACVqE,UAAWrE,IAAAA,OACXqe,OAAQre,IAAAA,KACRgf,UAAWhf,IAAAA,KACX6e,gBAAiB7e,IAAAA,KACjBkW,eAAgBlW,IAAAA,KAChB0e,2BAA4B1e,IAAAA,KAC5B4e,4BAA6B5e,IAAAA,MAsB/BggB,GAActY,YAAc,eAE5ByY,GAAanf,aAAe,CAC1BqD,UAAW,MAGb8b,GAAapf,UAAY,CACvBvF,SAAUwE,IAAAA,KAAAA,WACVqE,UAAWrE,IAAAA,OAOX,aAAcA,IAAAA,OACd,kBAAmBA,IAAAA,QAoBrBogB,GAAWpf,aAAe,CACxBqD,UAAW,MAGb+b,GAAWrf,UAAY,CACrBvF,SAAUwE,IAAAA,KAAAA,WACVqE,UAAWrE,IAAAA,QAmBbqgB,GAAarf,aAAe,CAC1BqD,UAAW,MAGbgc,GAAatf,UAAY,CACvBvF,SAAUwE,IAAAA,KAAAA,WACVqE,UAAWrE,IAAAA,QAiBbsgB,GAAetf,aAAe,CAC5BqD,UAAW,MAGbic,GAAevf,UAAY,CACzBsD,UAAWrE,IAAAA,OACXugB,IAAKvgB,IAAAA,OAAAA,WACLwgB,IAAKxgB,IAAAA,OAAAA,YAePygB,GAAUzf,aAAe,CACvBqD,UAAW,MAGboc,GAAU1f,UAAY,CACpBsD,UAAWrE,IAAAA,OACXxE,SAAUwE,IAAAA,KAAAA,YAeZ0gB,GAAiB1f,aAAe,CAC9BqD,UAAW,KACXsc,MAAO,MAGTD,GAAiB3f,UAAY,CAC3BsD,UAAWrE,IAAAA,OACX2gB,MAAO3gB,IAAAA,QAmCTihB,GAAMjgB,aAAe,CACnBqD,UAAW,KACXga,QAAQ,EACR6C,UAAU,EACVlC,UAAW,aACXH,gBAAiB,cAGnBoC,GAAMlgB,UAAY,CAIhBsD,UAAWrE,IAAAA,OAKXqe,OAAQre,IAAAA,KAKRgf,UAAWhf,IAAAA,KAKX6e,gBAAiB7e,IAAAA,KAKjBkhB,SAAUlhB,IAAAA,KAEVxE,SAAUwE,IAAAA,UAAoB,CAC5BA,IAAAA,QAAkBA,IAAAA,MAClBA,IAAAA,OACCnB,WAOH,aAAcmB,IAAAA,OACd,kBAAmBA,IAAAA,QAIrB,W,iCC1QA,IAJA,SAAevF,GACb,OAAgB,MAATA,I,kCCrBM,SAAS0mB,EAAgBC,EAAKvqB,EAAK4D,GAYhD,OAXI5D,KAAOuqB,EACT9qB,OAAOojB,eAAe0H,EAAKvqB,EAAK,CAC9B4D,MAAOA,EACP4mB,YAAY,EACZC,cAAc,EACdC,UAAU,IAGZH,EAAIvqB,GAAO4D,EAGN2mB,E","sources":["webpack://StravaModern/./node_modules/@reach/visually-hidden/dist/reach-visually-hidden.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/owner-document/dist/reach-utils-owner-document.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/can-use-dom/dist/reach-utils-can-use-dom.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/compose-refs/dist/reach-utils-compose-refs.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/type-check/dist/reach-utils-type-check.esm.js","webpack://StravaModern/./node_modules/@reach/alert/dist/reach-alert.esm.js","webpack://StravaModern/./node_modules/@reach/alert/node_modules/@reach/utils/use-previous/dist/reach-utils-use-previous.esm.js","webpack://StravaModern/./node_modules/@reach/dialog/node_modules/prop-types/factoryWithThrowingShims.js","webpack://StravaModern/./node_modules/@reach/dialog/node_modules/prop-types/index.js","webpack://StravaModern/./node_modules/@reach/dialog/node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/constants.js","webpack://StravaModern/./node_modules/use-callback-ref/dist/es2015/useMergeRef.js","webpack://StravaModern/./node_modules/use-callback-ref/dist/es2015/useRef.js","webpack://StravaModern/./node_modules/use-callback-ref/dist/es2015/assignRef.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/FocusGuard.js","webpack://StravaModern/./node_modules/use-sidecar/dist/es2015/medium.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/medium.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/Lock.js","webpack://StravaModern/./node_modules/react-clientside-effect/lib/index.es.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/is.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/correctFocus.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/firstFocus.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/solver.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/array.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/tabOrder.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/tabUtils.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/tabbables.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/DOMutils.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/all-affected.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/getActiveElement.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/utils/parenting.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/focusMerge.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/setFocus.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/index.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/focusInside.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/focusables.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/util.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/Trap.js","webpack://StravaModern/./node_modules/focus-lock/dist/es2015/focusIsHidden.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/Combination.js","webpack://StravaModern/./node_modules/react-focus-lock/dist/es2015/index.js","webpack://StravaModern/./node_modules/react-remove-scroll-bar/dist/es2015/constants.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/medium.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/UI.js","webpack://StravaModern/./node_modules/use-sidecar/dist/es2015/exports.js","webpack://StravaModern/./node_modules/get-nonce/dist/es2015/index.js","webpack://StravaModern/./node_modules/react-style-singleton/dist/es2015/singleton.js","webpack://StravaModern/./node_modules/react-style-singleton/dist/es2015/component.js","webpack://StravaModern/./node_modules/react-style-singleton/dist/es2015/hook.js","webpack://StravaModern/./node_modules/react-remove-scroll-bar/dist/es2015/utils.js","webpack://StravaModern/./node_modules/react-remove-scroll-bar/dist/es2015/component.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/handleScroll.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/SideEffect.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/sidecar.js","webpack://StravaModern/./node_modules/react-remove-scroll/dist/es2015/Combination.js","webpack://StravaModern/./node_modules/@reach/dialog/dist/dialog.esm.js","webpack://StravaModern/./node_modules/@strava/ui/Modal/styles.scss?b48f","webpack://StravaModern/./node_modules/@strava/ui/Modal/index.js","webpack://StravaModern/./node_modules/lodash-es/isNil.js","webpack://StravaModern/./node_modules/@babel/runtime/helpers/esm/defineProperty.js"],"sourcesContent":["import { forwardRef, createElement } from 'react';\nimport PropTypes from 'prop-types';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar _excluded = [\"as\", \"style\"];\n\n/**\n * VisuallyHidden\n *\n * Provides text for screen readers that is visually hidden.\n * It is the logical opposite of the `aria-hidden` attribute.\n */\nvar VisuallyHidden = /*#__PURE__*/forwardRef(function VisuallyHidden(_ref, ref) {\n  var _ref$as = _ref.as,\n      Comp = _ref$as === void 0 ? \"span\" : _ref$as,\n      _ref$style = _ref.style,\n      style = _ref$style === void 0 ? {} : _ref$style,\n      props = _objectWithoutPropertiesLoose(_ref, _excluded);\n\n  return /*#__PURE__*/createElement(Comp, _extends({\n    ref: ref,\n    style: _extends({\n      border: 0,\n      clip: \"rect(0 0 0 0)\",\n      height: \"1px\",\n      margin: \"-1px\",\n      overflow: \"hidden\",\n      padding: 0,\n      position: \"absolute\",\n      width: \"1px\",\n      // https://medium.com/@jessebeach/beware-smushed-off-screen-accessible-text-5952a4c2cbfe\n      whiteSpace: \"nowrap\",\n      wordWrap: \"normal\"\n    }, style)\n  }, props));\n});\n/**\n * @see Docs https://reach.tech/visually-hidden#visuallyhidden-props\n */\n\nif (process.env.NODE_ENV !== \"production\") {\n  VisuallyHidden.displayName = \"VisuallyHidden\";\n  VisuallyHidden.propTypes = {\n    as: PropTypes.any,\n    children: PropTypes.node\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\nexport default VisuallyHidden;\nexport { VisuallyHidden };\n","import { canUseDOM } from '../../can-use-dom/dist/reach-utils-can-use-dom.esm.js';\n\n/**\n * Get an element's owner document. Useful when components are used in iframes\n * or other environments like dev tools.\n *\n * @param element\n */\n\nfunction getOwnerDocument(element) {\n  return canUseDOM() ? element ? element.ownerDocument : document : null;\n}\n/**\n * TODO: Remove in 1.0\n */\n\nfunction getOwnerWindow(element) {\n  var ownerDocument = getOwnerDocument(element);\n  return ownerDocument ? ownerDocument.defaultView || window : null;\n}\n\nexport { getOwnerDocument, getOwnerWindow };\n","function canUseDOM() {\n  return !!(typeof window !== \"undefined\" && window.document && window.document.createElement);\n}\n\nexport { canUseDOM };\n","import { useCallback } from 'react';\nimport { isFunction } from '../../type-check/dist/reach-utils-type-check.esm.js';\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _createForOfIteratorHelperLoose(o, allowArrayLike) {\n  var it;\n\n  if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n      return function () {\n        if (i >= o.length) return {\n          done: true\n        };\n        return {\n          done: false,\n          value: o[i++]\n        };\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  it = o[Symbol.iterator]();\n  return it.next.bind(it);\n}\n\n/**\n * Passes or assigns an arbitrary value to a ref function or object.\n *\n * @param ref\n * @param value\n */\nfunction assignRef(ref, value) {\n  if (ref == null) return;\n\n  if (isFunction(ref)) {\n    ref(value);\n  } else {\n    try {\n      ref.current = value;\n    } catch (error) {\n      throw new Error(\"Cannot assign value \\\"\" + value + \"\\\" to ref \\\"\" + ref + \"\\\"\");\n    }\n  }\n}\n/**\n * Passes or assigns a value to multiple refs (typically a DOM node). Useful for\n * dealing with components that need an explicit ref for DOM calculations but\n * also forwards refs assigned by an app.\n *\n * @param refs Refs to fork\n */\n\nfunction useComposedRefs() {\n  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {\n    refs[_key] = arguments[_key];\n  }\n\n  return useCallback(function (node) {\n    for (var _iterator = _createForOfIteratorHelperLoose(refs), _step; !(_step = _iterator()).done;) {\n      var ref = _step.value;\n      assignRef(ref, node);\n    } // eslint-disable-next-line react-hooks/exhaustive-deps\n\n  }, refs);\n}\n\nexport { assignRef, useComposedRefs };\n","/**\n * Checks whether or not a value is a boolean.\n *\n * @param value\n */\nfunction isBoolean(value) {\n  return typeof value === \"boolean\";\n}\n/**\n * Checks whether or not a value is a function.\n *\n * @param value\n */\n\nfunction isFunction(value) {\n  // eslint-disable-next-line eqeqeq\n  return !!(value && {}.toString.call(value) == \"[object Function]\");\n}\n/**\n * Checks whether or not a value is a number.\n *\n * @param value\n */\n\nfunction isNumber(value) {\n  return typeof value === \"number\" && !isNaN(value);\n}\n/**\n * Checks whether or not a value is a string.\n *\n * @param value\n */\n\nfunction isString(value) {\n  return typeof value === \"string\";\n}\n\nexport { isBoolean, isFunction, isNumber, isString };\n","import { forwardRef, useRef, useMemo, createElement, useEffect, cloneElement } from 'react';\nimport { render } from 'react-dom';\nimport { VisuallyHidden } from '@reach/visually-hidden';\nimport { usePrevious } from '@reach/utils/use-previous';\nimport { getOwnerDocument } from '@reach/utils/owner-document';\nimport { useComposedRefs } from '@reach/utils/compose-refs';\nimport PropTypes from 'prop-types';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar _excluded = [\"as\", \"children\", \"type\"];\n\n/*\n * Singleton state is fine because you don't server render\n * an alert (SRs don't read them on first load anyway)\n */\nvar keys = {\n  polite: -1,\n  assertive: -1\n};\nvar elements = {\n  polite: {},\n  assertive: {}\n};\nvar liveRegions = {\n  polite: null,\n  assertive: null\n};\nvar renderTimer; ////////////////////////////////////////////////////////////////////////////////\n\n/**\n * Alert\n *\n * Screen-reader-friendly alert messages. In many apps developers add \"alert\"\n * messages when network events or other things happen. Users with assistive\n * technologies may not know about the message unless you develop for it.\n *\n * @see Docs https://reach.tech/alert\n */\n\nvar Alert = /*#__PURE__*/forwardRef(function Alert(_ref, forwardedRef) {\n  var _ref$as = _ref.as,\n      Comp = _ref$as === void 0 ? \"div\" : _ref$as,\n      children = _ref.children,\n      _ref$type = _ref.type,\n      regionType = _ref$type === void 0 ? \"polite\" : _ref$type,\n      props = _objectWithoutPropertiesLoose(_ref, _excluded);\n\n  var ownRef = useRef(null);\n  var ref = useComposedRefs(forwardedRef, ownRef);\n  var child = useMemo(function () {\n    return /*#__PURE__*/createElement(Comp, _extends({}, props, {\n      ref: ref,\n      \"data-reach-alert\": true\n    }), children);\n  }, // eslint-disable-next-line react-hooks/exhaustive-deps\n  [children, props]);\n  useMirrorEffects(regionType, child, ownRef);\n  return child;\n});\n/**\n * @see Docs https://reach.tech/alert#alert-props\n */\n\nif (process.env.NODE_ENV !== \"production\") {\n  Alert.displayName = \"Alert\";\n  Alert.propTypes = {\n    children: PropTypes.node,\n    type: /*#__PURE__*/PropTypes.oneOf([\"assertive\", \"polite\"])\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\n\nfunction createMirror(type, doc) {\n  var key = ++keys[type];\n\n  var mount = function mount(element) {\n    if (liveRegions[type]) {\n      elements[type][key] = element;\n      renderAlerts();\n    } else {\n      var node = doc.createElement(\"div\");\n      node.setAttribute(\"data-reach-live-\" + type, \"true\");\n      liveRegions[type] = node;\n      doc.body.appendChild(liveRegions[type]);\n      mount(element);\n    }\n  };\n\n  var update = function update(element) {\n    elements[type][key] = element;\n    renderAlerts();\n  };\n\n  var unmount = function unmount() {\n    delete elements[type][key];\n    renderAlerts();\n  };\n\n  return {\n    mount: mount,\n    update: update,\n    unmount: unmount\n  };\n}\n\nfunction renderAlerts() {\n  if (renderTimer != null) {\n    window.clearTimeout(renderTimer);\n  }\n\n  renderTimer = window.setTimeout(function () {\n    Object.keys(elements).forEach(function (elementType) {\n      var regionType = elementType;\n      var container = liveRegions[regionType];\n\n      if (container) {\n        render( /*#__PURE__*/createElement(VisuallyHidden, {\n          as: \"div\"\n        }, /*#__PURE__*/createElement(\"div\", {\n          // The status role is a type of live region and a container whose\n          // content is advisory information for the user that is not\n          // important enough to justify an alert, and is often presented as\n          // a status bar. When the role is added to an element, the browser\n          // will send out an accessible status event to assistive\n          // technology products which can then notify the user about it.\n          // https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/ARIA_Techniques/Using_the_status_role\n          role: regionType === \"assertive\" ? \"alert\" : \"status\",\n          \"aria-live\": regionType\n        }, Object.keys(elements[regionType]).map(function (key) {\n          return /*#__PURE__*/cloneElement(elements[regionType][key], {\n            key: key,\n            ref: null\n          });\n        }))), liveRegions[regionType]);\n      }\n    });\n  }, 500);\n}\n\nfunction useMirrorEffects(regionType, element, ref) {\n  var prevType = usePrevious(regionType);\n  var mirror = useRef(null);\n  var mounted = useRef(false);\n  useEffect(function () {\n    var ownerDocument = getOwnerDocument(ref.current);\n\n    if (!mounted.current) {\n      mounted.current = true;\n      mirror.current = createMirror(regionType, ownerDocument);\n      mirror.current.mount(element);\n    } else if (prevType !== regionType) {\n      mirror.current && mirror.current.unmount();\n      mirror.current = createMirror(regionType, ownerDocument);\n      mirror.current.mount(element);\n    } else {\n      mirror.current && mirror.current.update(element);\n    }\n  }, [element, regionType, prevType, ref]);\n  useEffect(function () {\n    return function () {\n      mirror.current && mirror.current.unmount();\n    };\n  }, []);\n} ////////////////////////////////////////////////////////////////////////////////\n\nexport default Alert;\nexport { Alert };\n","import { useRef, useEffect } from 'react';\n\n/**\n * Returns the previous value of a reference after a component update.\n *\n * @param value\n */\n\nfunction usePrevious(value) {\n  var ref = useRef(null);\n  useEffect(function () {\n    ref.current = value;\n  }, [value]);\n  return ref.current;\n}\n\nexport { usePrevious };\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","/**\n * defines a focus group\n */\nexport var FOCUS_GROUP = 'data-focus-lock';\n/**\n * disables element discovery inside a group marked by key\n */\nexport var FOCUS_DISABLED = 'data-focus-lock-disabled';\n/**\n * allows uncontrolled focus within the marked area, effectively disabling focus lock for it's content\n */\nexport var FOCUS_ALLOW = 'data-no-focus-lock';\n/**\n * instructs autofocus engine to pick default autofocus inside a given node\n * can be set on the element or container\n */\nexport var FOCUS_AUTO = 'data-autofocus-inside';\n/**\n * instructs autofocus to ignore elements within a given node\n * can be set on the element or container\n */\nexport var FOCUS_NO_AUTOFOCUS = 'data-no-autofocus';\n","import { assignRef } from './assignRef';\nimport { useCallbackRef } from './useRef';\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    return useCallbackRef(defaultValue || null, function (newValue) { return refs.forEach(function (ref) { return assignRef(ref, newValue); }); });\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","/**\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 * as React from 'react';\nimport PropTypes from 'prop-types';\nexport var hiddenGuard = {\n  width: '1px',\n  height: '0px',\n  padding: 0,\n  overflow: 'hidden',\n  position: 'fixed',\n  top: '1px',\n  left: '1px'\n};\n\nvar InFocusGuard = function InFocusGuard(_ref) {\n  var children = _ref.children;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    \"data-focus-auto-guard\": true,\n    style: hiddenGuard\n  }), children, children && /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-last\",\n    \"data-focus-guard\": true,\n    \"data-focus-auto-guard\": true,\n    style: hiddenGuard\n  }));\n};\n\nInFocusGuard.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node\n} : {};\nInFocusGuard.defaultProps = {\n  children: null\n};\nexport default InFocusGuard;","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 { createMedium, createSidecarMedium } from 'use-sidecar';\nexport var mediumFocus = createMedium({}, function (_ref) {\n  var target = _ref.target,\n      currentTarget = _ref.currentTarget;\n  return {\n    target: target,\n    currentTarget: currentTarget\n  };\n});\nexport var mediumBlur = createMedium();\nexport var mediumEffect = createMedium();\nexport var mediumSidecar = createSidecarMedium({\n  async: true\n});","import _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport { node, bool, string, any, arrayOf, oneOfType, object, func } from 'prop-types';\nimport * as constants from 'focus-lock/constants';\nimport { useMergeRefs } from 'use-callback-ref';\nimport { useEffect } from 'react';\nimport { hiddenGuard } from './FocusGuard';\nimport { mediumFocus, mediumBlur, mediumSidecar } from './medium';\nvar emptyArray = [];\nvar FocusLock = /*#__PURE__*/React.forwardRef(function FocusLockUI(props, parentRef) {\n  var _extends2;\n\n  var _React$useState = React.useState(),\n      realObserved = _React$useState[0],\n      setObserved = _React$useState[1];\n\n  var observed = React.useRef();\n  var isActive = React.useRef(false);\n  var originalFocusedElement = React.useRef(null);\n  var children = props.children,\n      disabled = props.disabled,\n      noFocusGuards = props.noFocusGuards,\n      persistentFocus = props.persistentFocus,\n      crossFrame = props.crossFrame,\n      autoFocus = props.autoFocus,\n      allowTextSelection = props.allowTextSelection,\n      group = props.group,\n      className = props.className,\n      whiteList = props.whiteList,\n      hasPositiveIndices = props.hasPositiveIndices,\n      _props$shards = props.shards,\n      shards = _props$shards === void 0 ? emptyArray : _props$shards,\n      _props$as = props.as,\n      Container = _props$as === void 0 ? 'div' : _props$as,\n      _props$lockProps = props.lockProps,\n      containerProps = _props$lockProps === void 0 ? {} : _props$lockProps,\n      SideCar = props.sideCar,\n      shouldReturnFocus = props.returnFocus,\n      focusOptions = props.focusOptions,\n      onActivationCallback = props.onActivation,\n      onDeactivationCallback = props.onDeactivation;\n\n  var _React$useState2 = React.useState({}),\n      id = _React$useState2[0]; // SIDE EFFECT CALLBACKS\n\n\n  var onActivation = React.useCallback(function () {\n    originalFocusedElement.current = originalFocusedElement.current || document && document.activeElement;\n\n    if (observed.current && onActivationCallback) {\n      onActivationCallback(observed.current);\n    }\n\n    isActive.current = true;\n  }, [onActivationCallback]);\n  var onDeactivation = React.useCallback(function () {\n    isActive.current = false;\n\n    if (onDeactivationCallback) {\n      onDeactivationCallback(observed.current);\n    }\n  }, [onDeactivationCallback]);\n  useEffect(function () {\n    if (!disabled) {\n      // cleanup return focus on trap deactivation\n      // sideEffect/returnFocus should happen by this time\n      originalFocusedElement.current = null;\n    }\n  }, []);\n  var returnFocus = React.useCallback(function (allowDefer) {\n    var returnFocusTo = originalFocusedElement.current;\n\n    if (returnFocusTo && returnFocusTo.focus) {\n      var howToReturnFocus = typeof shouldReturnFocus === 'function' ? shouldReturnFocus(returnFocusTo) : shouldReturnFocus;\n\n      if (howToReturnFocus) {\n        var returnFocusOptions = typeof howToReturnFocus === 'object' ? howToReturnFocus : undefined;\n        originalFocusedElement.current = null;\n\n        if (allowDefer) {\n          // React might return focus after update\n          // it's safer to defer the action\n          Promise.resolve().then(function () {\n            return returnFocusTo.focus(returnFocusOptions);\n          });\n        } else {\n          returnFocusTo.focus(returnFocusOptions);\n        }\n      }\n    }\n  }, [shouldReturnFocus]); // MEDIUM CALLBACKS\n\n  var onFocus = React.useCallback(function (event) {\n    if (isActive.current) {\n      mediumFocus.useMedium(event);\n    }\n  }, []);\n  var onBlur = mediumBlur.useMedium; // REF PROPAGATION\n  // not using real refs due to race conditions\n\n  var setObserveNode = React.useCallback(function (newObserved) {\n    if (observed.current !== newObserved) {\n      observed.current = newObserved;\n      setObserved(newObserved);\n    }\n  }, []);\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof allowTextSelection !== 'undefined') {\n      // eslint-disable-next-line no-console\n      console.warn('React-Focus-Lock: allowTextSelection is deprecated and enabled by default');\n    }\n\n    React.useEffect(function () {\n      if (!observed.current) {\n        // eslint-disable-next-line no-console\n        console.error('FocusLock: could not obtain ref to internal node');\n      }\n    }, []);\n  }\n\n  var lockProps = _extends((_extends2 = {}, _extends2[constants.FOCUS_DISABLED] = disabled && 'disabled', _extends2[constants.FOCUS_GROUP] = group, _extends2), containerProps);\n\n  var hasLeadingGuards = noFocusGuards !== true;\n  var hasTailingGuards = hasLeadingGuards && noFocusGuards !== 'tail';\n  var mergedRef = useMergeRefs([parentRef, setObserveNode]);\n  return /*#__PURE__*/React.createElement(React.Fragment, null, hasLeadingGuards && [\n  /*#__PURE__*/\n  // nearest focus guard\n  React.createElement(\"div\", {\n    key: \"guard-first\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }), // first tabbed element guard\n  hasPositiveIndices ? /*#__PURE__*/React.createElement(\"div\", {\n    key: \"guard-nearest\",\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 1,\n    style: hiddenGuard\n  }) : null], !disabled && /*#__PURE__*/React.createElement(SideCar, {\n    id: id,\n    sideCar: mediumSidecar,\n    observed: realObserved,\n    disabled: disabled,\n    persistentFocus: persistentFocus,\n    crossFrame: crossFrame,\n    autoFocus: autoFocus,\n    whiteList: whiteList,\n    shards: shards,\n    onActivation: onActivation,\n    onDeactivation: onDeactivation,\n    returnFocus: returnFocus,\n    focusOptions: focusOptions\n  }), /*#__PURE__*/React.createElement(Container, _extends({\n    ref: mergedRef\n  }, lockProps, {\n    className: className,\n    onBlur: onBlur,\n    onFocus: onFocus\n  }), children), hasTailingGuards && /*#__PURE__*/React.createElement(\"div\", {\n    \"data-focus-guard\": true,\n    tabIndex: disabled ? -1 : 0,\n    style: hiddenGuard\n  }));\n});\nFocusLock.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: node,\n  disabled: bool,\n  returnFocus: oneOfType([bool, object, func]),\n  focusOptions: object,\n  noFocusGuards: bool,\n  hasPositiveIndices: bool,\n  allowTextSelection: bool,\n  autoFocus: bool,\n  persistentFocus: bool,\n  crossFrame: bool,\n  group: string,\n  className: string,\n  whiteList: func,\n  shards: arrayOf(any),\n  as: oneOfType([string, func, object]),\n  lockProps: object,\n  onActivation: func,\n  onDeactivation: func,\n  sideCar: any.isRequired\n} : {};\nFocusLock.defaultProps = {\n  children: undefined,\n  disabled: false,\n  returnFocus: false,\n  focusOptions: undefined,\n  noFocusGuards: false,\n  autoFocus: true,\n  persistentFocus: false,\n  crossFrame: true,\n  hasPositiveIndices: undefined,\n  allowTextSelection: undefined,\n  group: undefined,\n  className: undefined,\n  whiteList: undefined,\n  shards: undefined,\n  as: 'div',\n  lockProps: {},\n  onActivation: undefined,\n  onDeactivation: undefined\n};\nexport default FocusLock;","import _inheritsLoose from '@babel/runtime/helpers/esm/inheritsLoose';\nimport _defineProperty from '@babel/runtime/helpers/esm/defineProperty';\nimport React, { PureComponent } from 'react';\n\nfunction withSideEffect(reducePropsToState, handleStateChangeOnClient) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof reducePropsToState !== 'function') {\n      throw new Error('Expected reducePropsToState to be a function.');\n    }\n\n    if (typeof handleStateChangeOnClient !== 'function') {\n      throw new Error('Expected handleStateChangeOnClient to be a function.');\n    }\n  }\n\n  function getDisplayName(WrappedComponent) {\n    return WrappedComponent.displayName || WrappedComponent.name || 'Component';\n  }\n\n  return function wrap(WrappedComponent) {\n    if (process.env.NODE_ENV !== \"production\") {\n      if (typeof WrappedComponent !== 'function') {\n        throw new Error('Expected WrappedComponent to be a React component.');\n      }\n    }\n\n    var mountedInstances = [];\n    var state;\n\n    function emitChange() {\n      state = reducePropsToState(mountedInstances.map(function (instance) {\n        return instance.props;\n      }));\n      handleStateChangeOnClient(state);\n    }\n\n    var SideEffect = /*#__PURE__*/function (_PureComponent) {\n      _inheritsLoose(SideEffect, _PureComponent);\n\n      function SideEffect() {\n        return _PureComponent.apply(this, arguments) || this;\n      }\n\n      // Try to use displayName of wrapped component\n      SideEffect.peek = function peek() {\n        return state;\n      };\n\n      var _proto = SideEffect.prototype;\n\n      _proto.componentDidMount = function componentDidMount() {\n        mountedInstances.push(this);\n        emitChange();\n      };\n\n      _proto.componentDidUpdate = function componentDidUpdate() {\n        emitChange();\n      };\n\n      _proto.componentWillUnmount = function componentWillUnmount() {\n        var index = mountedInstances.indexOf(this);\n        mountedInstances.splice(index, 1);\n        emitChange();\n      };\n\n      _proto.render = function render() {\n        return /*#__PURE__*/React.createElement(WrappedComponent, this.props);\n      };\n\n      return SideEffect;\n    }(PureComponent);\n\n    _defineProperty(SideEffect, \"displayName\", \"SideEffect(\" + getDisplayName(WrappedComponent) + \")\");\n\n    return SideEffect;\n  };\n}\n\nexport default withSideEffect;\n","import { FOCUS_NO_AUTOFOCUS } from '../constants';\nvar isElementHidden = function (node) {\n    // we can measure only \"elements\"\n    // consider others as \"visible\"\n    if (node.nodeType !== Node.ELEMENT_NODE) {\n        return false;\n    }\n    var computedStyle = window.getComputedStyle(node, null);\n    if (!computedStyle || !computedStyle.getPropertyValue) {\n        return false;\n    }\n    return (computedStyle.getPropertyValue('display') === 'none' || computedStyle.getPropertyValue('visibility') === 'hidden');\n};\nvar getParentNode = function (node) {\n    // DOCUMENT_FRAGMENT_NODE can also point on ShadowRoot. In this case .host will point on the next node\n    return node.parentNode && node.parentNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE\n        ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            node.parentNode.host\n        : node.parentNode;\n};\nvar isTopNode = function (node) {\n    // @ts-ignore\n    return node === document || (node && node.nodeType === Node.DOCUMENT_NODE);\n};\nvar isVisibleUncached = function (node, checkParent) {\n    return !node || isTopNode(node) || (!isElementHidden(node) && checkParent(getParentNode(node)));\n};\nexport var isVisibleCached = function (visibilityCache, node) {\n    var cached = visibilityCache.get(node);\n    if (cached !== undefined) {\n        return cached;\n    }\n    var result = isVisibleUncached(node, isVisibleCached.bind(undefined, visibilityCache));\n    visibilityCache.set(node, result);\n    return result;\n};\nvar isAutoFocusAllowedUncached = function (node, checkParent) {\n    return node && !isTopNode(node) ? (isAutoFocusAllowed(node) ? checkParent(getParentNode(node)) : false) : true;\n};\nexport var isAutoFocusAllowedCached = function (cache, node) {\n    var cached = cache.get(node);\n    if (cached !== undefined) {\n        return cached;\n    }\n    var result = isAutoFocusAllowedUncached(node, isAutoFocusAllowedCached.bind(undefined, cache));\n    cache.set(node, result);\n    return result;\n};\nexport var getDataset = function (node) {\n    // @ts-ignore\n    return node.dataset;\n};\nexport var isHTMLButtonElement = function (node) { return node.tagName === 'BUTTON'; };\nexport var isHTMLInputElement = function (node) { return node.tagName === 'INPUT'; };\nexport var isRadioElement = function (node) {\n    return isHTMLInputElement(node) && node.type === 'radio';\n};\nexport var notHiddenInput = function (node) {\n    return !((isHTMLInputElement(node) || isHTMLButtonElement(node)) && (node.type === 'hidden' || node.disabled));\n};\nexport var isAutoFocusAllowed = function (node) {\n    var attribute = node.getAttribute(FOCUS_NO_AUTOFOCUS);\n    return ![true, 'true', ''].includes(attribute);\n};\nexport var isGuard = function (node) { var _a; return Boolean(node && ((_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.focusGuard)); };\nexport var isNotAGuard = function (node) { return !isGuard(node); };\nexport var isDefined = function (x) { return Boolean(x); };\n","import { isRadioElement } from './is';\nvar findSelectedRadio = function (node, nodes) {\n    return nodes\n        .filter(isRadioElement)\n        .filter(function (el) { return el.name === node.name; })\n        .filter(function (el) { return el.checked; })[0] || node;\n};\nexport var correctNode = function (node, nodes) {\n    if (isRadioElement(node) && node.name) {\n        return findSelectedRadio(node, nodes);\n    }\n    return node;\n};\n/**\n * giving a set of radio inputs keeps only selected (tabbable) ones\n * @param nodes\n */\nexport var correctNodes = function (nodes) {\n    // IE11 has no Set(array) constructor\n    var resultSet = new Set();\n    nodes.forEach(function (node) { return resultSet.add(correctNode(node, nodes)); });\n    // using filter to support IE11\n    return nodes.filter(function (node) { return resultSet.has(node); });\n};\n","import { correctNode } from './correctFocus';\nexport var pickFirstFocus = function (nodes) {\n    if (nodes[0] && nodes.length > 1) {\n        return correctNode(nodes[0], nodes);\n    }\n    return nodes[0];\n};\nexport var pickFocusable = function (nodes, index) {\n    if (nodes.length > 1) {\n        return nodes.indexOf(correctNode(nodes[index], nodes));\n    }\n    return index;\n};\n","import { correctNodes } from './utils/correctFocus';\nimport { pickFocusable } from './utils/firstFocus';\nimport { isGuard } from './utils/is';\nexport var NEW_FOCUS = 'NEW_FOCUS';\n/**\n * Main solver for the \"find next focus\" question\n * @param innerNodes\n * @param outerNodes\n * @param activeElement\n * @param lastNode\n * @returns {number|string|undefined|*}\n */\nexport var newFocus = function (innerNodes, outerNodes, activeElement, lastNode) {\n    var cnt = innerNodes.length;\n    var firstFocus = innerNodes[0];\n    var lastFocus = innerNodes[cnt - 1];\n    var isOnGuard = isGuard(activeElement);\n    // focus is inside\n    if (activeElement && innerNodes.indexOf(activeElement) >= 0) {\n        return undefined;\n    }\n    var activeIndex = activeElement !== undefined ? outerNodes.indexOf(activeElement) : -1;\n    var lastIndex = lastNode ? outerNodes.indexOf(lastNode) : activeIndex;\n    var lastNodeInside = lastNode ? innerNodes.indexOf(lastNode) : -1;\n    var indexDiff = activeIndex - lastIndex;\n    var firstNodeIndex = outerNodes.indexOf(firstFocus);\n    var lastNodeIndex = outerNodes.indexOf(lastFocus);\n    var correctedNodes = correctNodes(outerNodes);\n    var correctedIndex = activeElement !== undefined ? correctedNodes.indexOf(activeElement) : -1;\n    var correctedIndexDiff = correctedIndex - (lastNode ? correctedNodes.indexOf(lastNode) : activeIndex);\n    var returnFirstNode = pickFocusable(innerNodes, 0);\n    var returnLastNode = pickFocusable(innerNodes, cnt - 1);\n    // new focus\n    if (activeIndex === -1 || lastNodeInside === -1) {\n        return NEW_FOCUS;\n    }\n    // old focus\n    if (!indexDiff && lastNodeInside >= 0) {\n        return lastNodeInside;\n    }\n    // first element\n    if (activeIndex <= firstNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n        return returnLastNode;\n    }\n    // last element\n    if (activeIndex >= lastNodeIndex && isOnGuard && Math.abs(indexDiff) > 1) {\n        return returnFirstNode;\n    }\n    // jump out, but not on the guard\n    if (indexDiff && Math.abs(correctedIndexDiff) > 1) {\n        return lastNodeInside;\n    }\n    // focus above lock\n    if (activeIndex <= firstNodeIndex) {\n        return returnLastNode;\n    }\n    // focus below lock\n    if (activeIndex > lastNodeIndex) {\n        return returnFirstNode;\n    }\n    // index is inside tab order, but outside Lock\n    if (indexDiff) {\n        if (Math.abs(indexDiff) > 1) {\n            return lastNodeInside;\n        }\n        return (cnt + lastNodeInside + indexDiff) % cnt;\n    }\n    // do nothing\n    return undefined;\n};\n","/*\nIE11 support\n */\nexport var toArray = function (a) {\n    var ret = Array(a.length);\n    for (var i = 0; i < a.length; ++i) {\n        ret[i] = a[i];\n    }\n    return ret;\n};\nexport var asArray = function (a) { return (Array.isArray(a) ? a : [a]); };\n","import { toArray } from './array';\nexport var tabSort = function (a, b) {\n    var tabDiff = a.tabIndex - b.tabIndex;\n    var indexDiff = a.index - b.index;\n    if (tabDiff) {\n        if (!a.tabIndex) {\n            return 1;\n        }\n        if (!b.tabIndex) {\n            return -1;\n        }\n    }\n    return tabDiff || indexDiff;\n};\nexport var orderByTabIndex = function (nodes, filterNegative, keepGuards) {\n    return toArray(nodes)\n        .map(function (node, index) { return ({\n        node: node,\n        index: index,\n        tabIndex: keepGuards && node.tabIndex === -1 ? ((node.dataset || {}).focusGuard ? 0 : -1) : node.tabIndex,\n    }); })\n        .filter(function (data) { return !filterNegative || data.tabIndex >= 0; })\n        .sort(tabSort);\n};\n","import { FOCUS_AUTO } from '../constants';\nimport { toArray } from './array';\nimport { tabbables } from './tabbables';\nvar queryTabbables = tabbables.join(',');\nvar queryGuardTabbables = \"\".concat(queryTabbables, \", [data-focus-guard]\");\nvar getFocusablesWithShadowDom = function (parent, withGuards) {\n    var _a;\n    return toArray(((_a = parent.shadowRoot) === null || _a === void 0 ? void 0 : _a.children) || parent.children).reduce(function (acc, child) {\n        return acc.concat(child.matches(withGuards ? queryGuardTabbables : queryTabbables) ? [child] : [], getFocusablesWithShadowDom(child));\n    }, []);\n};\nexport var getFocusables = function (parents, withGuards) {\n    return parents.reduce(function (acc, parent) {\n        return acc.concat(\n        // add all tabbables inside and within shadow DOMs in DOM order\n        getFocusablesWithShadowDom(parent, withGuards), \n        // add if node is tabbable itself\n        parent.parentNode\n            ? toArray(parent.parentNode.querySelectorAll(queryTabbables)).filter(function (node) { return node === parent; })\n            : []);\n    }, []);\n};\n/**\n * return a list of focusable nodes within an area marked as \"auto-focusable\"\n * @param parent\n */\nexport var getParentAutofocusables = function (parent) {\n    var parentFocus = parent.querySelectorAll(\"[\".concat(FOCUS_AUTO, \"]\"));\n    return toArray(parentFocus)\n        .map(function (node) { return getFocusables([node]); })\n        .reduce(function (acc, nodes) { return acc.concat(nodes); }, []);\n};\n","/**\n * list of the object to be considered as focusable\n */\nexport var tabbables = [\n    'button:enabled',\n    'select:enabled',\n    'textarea:enabled',\n    'input:enabled',\n    // elements with explicit roles will also use explicit tabindex\n    // '[role=\"button\"]',\n    'a[href]',\n    'area[href]',\n    'summary',\n    'iframe',\n    'object',\n    'embed',\n    'audio[controls]',\n    'video[controls]',\n    '[tabindex]',\n    '[contenteditable]',\n    '[autofocus]',\n];\n","import { toArray } from './array';\nimport { isAutoFocusAllowedCached, isVisibleCached, notHiddenInput } from './is';\nimport { orderByTabIndex } from './tabOrder';\nimport { getFocusables, getParentAutofocusables } from './tabUtils';\n/**\n * given list of focusable elements keeps the ones user can interact with\n * @param nodes\n * @param visibilityCache\n */\nexport var filterFocusable = function (nodes, visibilityCache) {\n    return toArray(nodes)\n        .filter(function (node) { return isVisibleCached(visibilityCache, node); })\n        .filter(function (node) { return notHiddenInput(node); });\n};\nexport var filterAutoFocusable = function (nodes, cache) {\n    if (cache === void 0) { cache = new Map(); }\n    return toArray(nodes).filter(function (node) { return isAutoFocusAllowedCached(cache, node); });\n};\n/**\n * only tabbable ones\n * (but with guards which would be ignored)\n */\nexport var getTabbableNodes = function (topNodes, visibilityCache, withGuards) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes, withGuards), visibilityCache), true, withGuards);\n};\n/**\n * actually anything \"focusable\", not only tabbable\n * (without guards, as long as they are not expected to be focused)\n */\nexport var getAllTabbableNodes = function (topNodes, visibilityCache) {\n    return orderByTabIndex(filterFocusable(getFocusables(topNodes), visibilityCache), false);\n};\n/**\n * return list of nodes which are expected to be auto-focused\n * @param topNode\n * @param visibilityCache\n */\nexport var parentAutofocusables = function (topNode, visibilityCache) {\n    return filterFocusable(getParentAutofocusables(topNode), visibilityCache);\n};\n/*\n * Determines if element is contained in scope, including nested shadow DOMs\n */\nexport var contains = function (scope, element) {\n    return ((scope.shadowRoot\n        ? contains(scope.shadowRoot, element)\n        : Object.getPrototypeOf(scope).contains.call(scope, element)) ||\n        toArray(scope.children).some(function (child) { return contains(child, element); }));\n};\n","import { FOCUS_DISABLED, FOCUS_GROUP } from '../constants';\nimport { asArray, toArray } from './array';\n/**\n * in case of multiple nodes nested inside each other\n * keeps only top ones\n * this is O(nlogn)\n * @param nodes\n * @returns {*}\n */\nvar filterNested = function (nodes) {\n    var contained = new Set();\n    var l = nodes.length;\n    for (var i = 0; i < l; i += 1) {\n        for (var j = i + 1; j < l; j += 1) {\n            var position = nodes[i].compareDocumentPosition(nodes[j]);\n            /* eslint-disable no-bitwise */\n            if ((position & Node.DOCUMENT_POSITION_CONTAINED_BY) > 0) {\n                contained.add(j);\n            }\n            if ((position & Node.DOCUMENT_POSITION_CONTAINS) > 0) {\n                contained.add(i);\n            }\n            /* eslint-enable */\n        }\n    }\n    return nodes.filter(function (_, index) { return !contained.has(index); });\n};\n/**\n * finds top most parent for a node\n * @param node\n * @returns {*}\n */\nvar getTopParent = function (node) {\n    return node.parentNode ? getTopParent(node.parentNode) : node;\n};\n/**\n * returns all \"focus containers\" inside a given node\n * @param node\n * @returns {T}\n */\nexport var getAllAffectedNodes = function (node) {\n    var nodes = asArray(node);\n    return nodes.filter(Boolean).reduce(function (acc, currentNode) {\n        var group = currentNode.getAttribute(FOCUS_GROUP);\n        acc.push.apply(acc, (group\n            ? filterNested(toArray(getTopParent(currentNode).querySelectorAll(\"[\".concat(FOCUS_GROUP, \"=\\\"\").concat(group, \"\\\"]:not([\").concat(FOCUS_DISABLED, \"=\\\"disabled\\\"])\"))))\n            : [currentNode]));\n        return acc;\n    }, []);\n};\n","var getNestedShadowActiveElement = function (shadowRoot) {\n    return shadowRoot.activeElement\n        ? shadowRoot.activeElement.shadowRoot\n            ? getNestedShadowActiveElement(shadowRoot.activeElement.shadowRoot)\n            : shadowRoot.activeElement\n        : undefined;\n};\n/**\n * returns active element from document or from nested shadowdoms\n */\nexport var getActiveElement = function () {\n    return (document.activeElement\n        ? document.activeElement.shadowRoot\n            ? getNestedShadowActiveElement(document.activeElement.shadowRoot)\n            : document.activeElement\n        : undefined); // eslint-disable-next-line @typescript-eslint/no-explicit-any\n};\n","import { parentAutofocusables } from './DOMutils';\nimport { contains } from './DOMutils';\nimport { asArray } from './array';\nvar getParents = function (node, parents) {\n    if (parents === void 0) { parents = []; }\n    parents.push(node);\n    if (node.parentNode) {\n        getParents(node.parentNode.host || node.parentNode, parents);\n    }\n    return parents;\n};\n/**\n * finds a parent for both nodeA and nodeB\n * @param nodeA\n * @param nodeB\n * @returns {boolean|*}\n */\nexport var getCommonParent = function (nodeA, nodeB) {\n    var parentsA = getParents(nodeA);\n    var parentsB = getParents(nodeB);\n    // tslint:disable-next-line:prefer-for-of\n    for (var i = 0; i < parentsA.length; i += 1) {\n        var currentParent = parentsA[i];\n        if (parentsB.indexOf(currentParent) >= 0) {\n            return currentParent;\n        }\n    }\n    return false;\n};\nexport var getTopCommonParent = function (baseActiveElement, leftEntry, rightEntries) {\n    var activeElements = asArray(baseActiveElement);\n    var leftEntries = asArray(leftEntry);\n    var activeElement = activeElements[0];\n    var topCommon = false;\n    leftEntries.filter(Boolean).forEach(function (entry) {\n        topCommon = getCommonParent(topCommon || entry, entry) || topCommon;\n        rightEntries.filter(Boolean).forEach(function (subEntry) {\n            var common = getCommonParent(activeElement, subEntry);\n            if (common) {\n                if (!topCommon || contains(common, topCommon)) {\n                    topCommon = common;\n                }\n                else {\n                    topCommon = getCommonParent(common, topCommon);\n                }\n            }\n        });\n    });\n    // TODO: add assert here?\n    return topCommon;\n};\n/**\n * return list of nodes which are expected to be autofocused inside a given top nodes\n * @param entries\n * @param visibilityCache\n */\nexport var allParentAutofocusables = function (entries, visibilityCache) {\n    return entries.reduce(function (acc, node) { return acc.concat(parentAutofocusables(node, visibilityCache)); }, []);\n};\n","import { NEW_FOCUS, newFocus } from './solver';\nimport { filterAutoFocusable, getAllTabbableNodes, getTabbableNodes } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { pickFirstFocus } from './utils/firstFocus';\nimport { getActiveElement } from './utils/getActiveElement';\nimport { getDataset, isDefined, isNotAGuard } from './utils/is';\nimport { allParentAutofocusables, getTopCommonParent } from './utils/parenting';\nvar findAutoFocused = function (autoFocusables) {\n    return function (node) { var _a; \n    // @ts-expect-error\n    return node.autofocus || !!((_a = getDataset(node)) === null || _a === void 0 ? void 0 : _a.autofocus) || autoFocusables.indexOf(node) >= 0; };\n};\nvar reorderNodes = function (srcNodes, dstNodes) {\n    var remap = new Map();\n    // no Set(dstNodes) for IE11 :(\n    dstNodes.forEach(function (entity) { return remap.set(entity.node, entity); });\n    // remap to dstNodes\n    return srcNodes.map(function (node) { return remap.get(node); }).filter(isDefined);\n};\n/**\n * given top node(s) and the last active element return the element to be focused next\n * @param topNode\n * @param lastNode\n */\nexport var getFocusMerge = function (topNode, lastNode) {\n    var activeElement = document && getActiveElement();\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(activeElement || topNode, topNode, entries);\n    var visibilityCache = new Map();\n    var anyFocusable = getAllTabbableNodes(entries, visibilityCache);\n    var innerElements = getTabbableNodes(entries, visibilityCache).filter(function (_a) {\n        var node = _a.node;\n        return isNotAGuard(node);\n    });\n    if (!innerElements[0]) {\n        innerElements = anyFocusable;\n        if (!innerElements[0]) {\n            return undefined;\n        }\n    }\n    var outerNodes = getAllTabbableNodes([commonParent], visibilityCache).map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var orderedInnerElements = reorderNodes(outerNodes, innerElements);\n    var innerNodes = orderedInnerElements.map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    var newId = newFocus(innerNodes, outerNodes, activeElement, lastNode);\n    if (newId === NEW_FOCUS) {\n        var autoFocusable = filterAutoFocusable(anyFocusable.map(function (_a) {\n            var node = _a.node;\n            return node;\n        })).filter(findAutoFocused(allParentAutofocusables(entries, visibilityCache)));\n        return {\n            node: autoFocusable && autoFocusable.length\n                ? pickFirstFocus(autoFocusable)\n                : pickFirstFocus(filterAutoFocusable(innerNodes)),\n        };\n    }\n    if (newId === undefined) {\n        return newId;\n    }\n    return orderedInnerElements[newId];\n};\n","import { getFocusMerge } from './focusMerge';\nexport var focusOn = function (target, focusOptions) {\n    if ('focus' in target) {\n        target.focus(focusOptions);\n    }\n    if ('contentWindow' in target && target.contentWindow) {\n        target.contentWindow.focus();\n    }\n};\nvar guardCount = 0;\nvar lockDisabled = false;\n/**\n * Sets focus at a given node. The last focused element will help to determine which element(first or last) should be focused.\n * HTML markers (see {@link import('./constants').FOCUS_AUTO} constants) can control autofocus\n * @param topNode\n * @param lastNode\n * @param options\n */\nexport var setFocus = function (topNode, lastNode, options) {\n    if (options === void 0) { options = {}; }\n    var focusable = getFocusMerge(topNode, lastNode);\n    if (lockDisabled) {\n        return;\n    }\n    if (focusable) {\n        if (guardCount > 2) {\n            // tslint:disable-next-line:no-console\n            console.error('FocusLock: focus-fighting detected. Only one focus management system could be active. ' +\n                'See https://github.com/theKashey/focus-lock/#focus-fighting');\n            lockDisabled = true;\n            setTimeout(function () {\n                lockDisabled = false;\n            }, 1);\n            return;\n        }\n        guardCount++;\n        focusOn(focusable.node, options.focusOptions);\n        guardCount--;\n    }\n};\n","import * as constants from './constants';\nimport { focusInside } from './focusInside';\nimport { focusIsHidden } from './focusIsHidden';\nimport { getFocusMerge as focusMerge } from './focusMerge';\nimport { getFocusabledIn, getFocusableIn } from './focusables';\nimport { setFocus } from './setFocus';\nimport { focusNextElement, focusPrevElement } from './sibling';\nimport tabHook from './tabHook';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { getActiveElement } from './utils/getActiveElement';\nexport { tabHook, focusInside, focusIsHidden, focusMerge, getFocusableIn, getFocusabledIn, constants, getAllAffectedNodes, focusNextElement, focusPrevElement, getActiveElement, };\nexport default setFocus;\n//\n","import { contains } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { toArray } from './utils/array';\nimport { getActiveElement } from './utils/getActiveElement';\nvar focusInFrame = function (frame) { return frame === document.activeElement; };\nvar focusInsideIframe = function (topNode) {\n    return Boolean(toArray(topNode.querySelectorAll('iframe')).some(function (node) { return focusInFrame(node); }));\n};\n/**\n * @returns {Boolean} true, if the current focus is inside given node or nodes\n */\nexport var focusInside = function (topNode) {\n    var activeElement = document && getActiveElement();\n    if (!activeElement || (activeElement.dataset && activeElement.dataset.focusGuard)) {\n        return false;\n    }\n    return getAllAffectedNodes(topNode).some(function (node) { return contains(node, activeElement) || focusInsideIframe(node); });\n};\n","import { getTabbableNodes } from './utils/DOMutils';\nimport { getAllAffectedNodes } from './utils/all-affected';\nimport { isGuard, isNotAGuard } from './utils/is';\nimport { getTopCommonParent } from './utils/parenting';\n/**\n * return list of focusable elements inside a given top node\n * @deprecated use {@link getFocusableIn}. Yep, there is typo in the function name\n */\nexport var getFocusabledIn = function (topNode) {\n    var entries = getAllAffectedNodes(topNode).filter(isNotAGuard);\n    var commonParent = getTopCommonParent(topNode, topNode, entries);\n    var visibilityCache = new Map();\n    var outerNodes = getTabbableNodes([commonParent], visibilityCache, true);\n    var innerElements = getTabbableNodes(entries, visibilityCache)\n        .filter(function (_a) {\n        var node = _a.node;\n        return isNotAGuard(node);\n    })\n        .map(function (_a) {\n        var node = _a.node;\n        return node;\n    });\n    return outerNodes.map(function (_a) {\n        var node = _a.node, index = _a.index;\n        return ({\n            node: node,\n            index: index,\n            lockItem: innerElements.indexOf(node) >= 0,\n            guard: isGuard(node),\n        });\n    });\n};\n/**\n * return list of focusable elements inside a given top node\n */\nexport var getFocusableIn = getFocusabledIn;\n","export function deferAction(action) {\n  // Hidding setImmediate from Webpack to avoid inserting polyfill\n  var _window = window,\n      setImmediate = _window.setImmediate;\n\n  if (typeof setImmediate !== 'undefined') {\n    setImmediate(action);\n  } else {\n    setTimeout(action, 1);\n  }\n}\nexport var inlineProp = function inlineProp(name, value) {\n  var obj = {};\n  obj[name] = value;\n  return obj;\n};","/* eslint-disable no-mixed-operators */\nimport * as React from 'react';\nimport PropTypes from 'prop-types';\nimport withSideEffect from 'react-clientside-effect';\nimport moveFocusInside, { focusInside, focusIsHidden, getFocusabledIn } from 'focus-lock';\nimport { deferAction } from './util';\nimport { mediumFocus, mediumBlur, mediumEffect } from './medium';\n\nvar focusOnBody = function focusOnBody() {\n  return document && document.activeElement === document.body;\n};\n\nvar isFreeFocus = function isFreeFocus() {\n  return focusOnBody() || focusIsHidden();\n};\n\nvar lastActiveTrap = null;\nvar lastActiveFocus = null;\nvar lastPortaledElement = null;\nvar focusWasOutsideWindow = false;\n\nvar defaultWhitelist = function defaultWhitelist() {\n  return true;\n};\n\nvar focusWhitelisted = function focusWhitelisted(activeElement) {\n  return (lastActiveTrap.whiteList || defaultWhitelist)(activeElement);\n};\n\nvar recordPortal = function recordPortal(observerNode, portaledElement) {\n  lastPortaledElement = {\n    observerNode: observerNode,\n    portaledElement: portaledElement\n  };\n};\n\nvar focusIsPortaledPair = function focusIsPortaledPair(element) {\n  return lastPortaledElement && lastPortaledElement.portaledElement === element;\n};\n\nfunction autoGuard(startIndex, end, step, allNodes) {\n  var lastGuard = null;\n  var i = startIndex;\n\n  do {\n    var item = allNodes[i];\n\n    if (item.guard) {\n      if (item.node.dataset.focusAutoGuard) {\n        lastGuard = item;\n      }\n    } else if (item.lockItem) {\n      if (i !== startIndex) {\n        // we will tab to the next element\n        return;\n      }\n\n      lastGuard = null;\n    } else {\n      break;\n    }\n  } while ((i += step) !== end);\n\n  if (lastGuard) {\n    lastGuard.node.tabIndex = 0;\n  }\n}\n\nvar extractRef = function extractRef(ref) {\n  return ref && 'current' in ref ? ref.current : ref;\n};\n\nvar focusWasOutside = function focusWasOutside(crossFrameOption) {\n  if (crossFrameOption) {\n    // with cross frame return true for any value\n    return Boolean(focusWasOutsideWindow);\n  } // in other case return only of focus went a while aho\n\n\n  return focusWasOutsideWindow === 'meanwhile';\n};\n\nvar checkInHost = function checkInHost(check, el, boundary) {\n  return el && ( // find host equal to active element and check nested active element\n  el.host === check && (!el.activeElement || boundary.contains(el.activeElement)) // dive up\n  || el.parentNode && checkInHost(check, el.parentNode, boundary));\n};\n\nvar withinHost = function withinHost(activeElement, workingArea) {\n  return workingArea.some(function (area) {\n    return checkInHost(activeElement, area, area);\n  });\n};\n\nvar activateTrap = function activateTrap() {\n  var result = false;\n\n  if (lastActiveTrap) {\n    var _lastActiveTrap = lastActiveTrap,\n        observed = _lastActiveTrap.observed,\n        persistentFocus = _lastActiveTrap.persistentFocus,\n        autoFocus = _lastActiveTrap.autoFocus,\n        shards = _lastActiveTrap.shards,\n        crossFrame = _lastActiveTrap.crossFrame,\n        focusOptions = _lastActiveTrap.focusOptions;\n    var workingNode = observed || lastPortaledElement && lastPortaledElement.portaledElement;\n    var activeElement = document && document.activeElement;\n\n    if (workingNode) {\n      var workingArea = [workingNode].concat(shards.map(extractRef).filter(Boolean));\n\n      if (!activeElement || focusWhitelisted(activeElement)) {\n        if (persistentFocus || focusWasOutside(crossFrame) || !isFreeFocus() || !lastActiveFocus && autoFocus) {\n          if (workingNode && !( // active element is \"inside\" working area\n          focusInside(workingArea) || // check for shadow-dom contained elements\n          activeElement && withinHost(activeElement, workingArea) || focusIsPortaledPair(activeElement, workingNode))) {\n            if (document && !lastActiveFocus && activeElement && !autoFocus) {\n              // Check if blur() exists, which is missing on certain elements on IE\n              if (activeElement.blur) {\n                activeElement.blur();\n              }\n\n              document.body.focus();\n            } else {\n              result = moveFocusInside(workingArea, lastActiveFocus, {\n                focusOptions: focusOptions\n              });\n              lastPortaledElement = {};\n            }\n          }\n\n          focusWasOutsideWindow = false;\n          lastActiveFocus = document && document.activeElement;\n        }\n      }\n\n      if (document) {\n        var newActiveElement = document && document.activeElement;\n        var allNodes = getFocusabledIn(workingArea);\n        var focusedIndex = allNodes.map(function (_ref) {\n          var node = _ref.node;\n          return node;\n        }).indexOf(newActiveElement);\n\n        if (focusedIndex > -1) {\n          // remove old focus\n          allNodes.filter(function (_ref2) {\n            var guard = _ref2.guard,\n                node = _ref2.node;\n            return guard && node.dataset.focusAutoGuard;\n          }).forEach(function (_ref3) {\n            var node = _ref3.node;\n            return node.removeAttribute('tabIndex');\n          });\n          autoGuard(focusedIndex, allNodes.length, +1, allNodes);\n          autoGuard(focusedIndex, -1, -1, allNodes);\n        }\n      }\n    }\n  }\n\n  return result;\n};\n\nvar onTrap = function onTrap(event) {\n  if (activateTrap() && event) {\n    // prevent scroll jump\n    event.stopPropagation();\n    event.preventDefault();\n  }\n};\n\nvar onBlur = function onBlur() {\n  return deferAction(activateTrap);\n};\n\nvar onFocus = function onFocus(event) {\n  // detect portal\n  var source = event.target;\n  var currentNode = event.currentTarget;\n\n  if (!currentNode.contains(source)) {\n    recordPortal(currentNode, source);\n  }\n};\n\nvar FocusWatcher = function FocusWatcher() {\n  return null;\n};\n\nvar FocusTrap = function FocusTrap(_ref4) {\n  var children = _ref4.children;\n  return /*#__PURE__*/React.createElement(\"div\", {\n    onBlur: onBlur,\n    onFocus: onFocus\n  }, children);\n};\n\nFocusTrap.propTypes = process.env.NODE_ENV !== \"production\" ? {\n  children: PropTypes.node.isRequired\n} : {};\n\nvar onWindowBlur = function onWindowBlur() {\n  focusWasOutsideWindow = 'just'; // using setTimeout to set  this variable after React/sidecar reaction\n\n  setTimeout(function () {\n    focusWasOutsideWindow = 'meanwhile';\n  }, 0);\n};\n\nvar attachHandler = function attachHandler() {\n  document.addEventListener('focusin', onTrap);\n  document.addEventListener('focusout', onBlur);\n  window.addEventListener('blur', onWindowBlur);\n};\n\nvar detachHandler = function detachHandler() {\n  document.removeEventListener('focusin', onTrap);\n  document.removeEventListener('focusout', onBlur);\n  window.removeEventListener('blur', onWindowBlur);\n};\n\nfunction reducePropsToState(propsList) {\n  return propsList.filter(function (_ref5) {\n    var disabled = _ref5.disabled;\n    return !disabled;\n  });\n}\n\nfunction handleStateChangeOnClient(traps) {\n  var trap = traps.slice(-1)[0];\n\n  if (trap && !lastActiveTrap) {\n    attachHandler();\n  }\n\n  var lastTrap = lastActiveTrap;\n  var sameTrap = lastTrap && trap && trap.id === lastTrap.id;\n  lastActiveTrap = trap;\n\n  if (lastTrap && !sameTrap) {\n    lastTrap.onDeactivation(); // return focus only of last trap was removed\n\n    if (!traps.filter(function (_ref6) {\n      var id = _ref6.id;\n      return id === lastTrap.id;\n    }).length) {\n      // allow defer is no other trap is awaiting restore\n      lastTrap.returnFocus(!trap);\n    }\n  }\n\n  if (trap) {\n    lastActiveFocus = null;\n\n    if (!sameTrap || lastTrap.observed !== trap.observed) {\n      trap.onActivation();\n    }\n\n    activateTrap(true);\n    deferAction(activateTrap);\n  } else {\n    detachHandler();\n    lastActiveFocus = null;\n  }\n} // bind medium\n\n\nmediumFocus.assignSyncMedium(onFocus);\nmediumBlur.assignMedium(onBlur);\nmediumEffect.assignMedium(function (cb) {\n  return cb({\n    moveFocusInside: moveFocusInside,\n    focusInside: focusInside\n  });\n});\nexport default withSideEffect(reducePropsToState, handleStateChangeOnClient)(FocusWatcher);","import { FOCUS_ALLOW } from './constants';\nimport { contains } from './utils/DOMutils';\nimport { toArray } from './utils/array';\nimport { getActiveElement } from './utils/getActiveElement';\n/**\n * focus is hidden FROM the focus-lock\n * ie contained inside a node focus-lock shall ignore\n * @returns {boolean} focus is currently is in \"allow\" area\n */\nexport var focusIsHidden = function () {\n    var activeElement = document && getActiveElement();\n    if (!activeElement) {\n        return false;\n    }\n    // this does not support setting FOCUS_ALLOW within shadow dom\n    return toArray(document.querySelectorAll(\"[\".concat(FOCUS_ALLOW, \"]\"))).some(function (node) { return contains(node, activeElement); });\n};\n","import _objectWithoutPropertiesLoose from \"@babel/runtime/helpers/esm/objectWithoutPropertiesLoose\";\nimport _extends from \"@babel/runtime/helpers/esm/extends\";\nimport * as React from 'react';\nimport FocusLockUI from './Lock';\nimport FocusTrap from './Trap';\n/* that would be a BREAKING CHANGE!\n// delaying sidecar execution till the first usage\nconst RequireSideCar = (props) => {\n  // eslint-disable-next-line global-require\n  const SideCar = require('./Trap').default;\n  return <SideCar {...props} />;\n};\n*/\n\nvar FocusLockCombination = /*#__PURE__*/React.forwardRef(function FocusLockUICombination(props, ref) {\n  return /*#__PURE__*/React.createElement(FocusLockUI, _extends({\n    sideCar: FocusTrap,\n    ref: ref\n  }, props));\n});\n\nvar _ref = FocusLockUI.propTypes || {},\n    sideCar = _ref.sideCar,\n    propTypes = _objectWithoutPropertiesLoose(_ref, [\"sideCar\"]);\n\nFocusLockCombination.propTypes = process.env.NODE_ENV !== \"production\" ? propTypes : {};\nexport default FocusLockCombination;","import FocusLock from './Combination';\nexport * from './UI';\nexport default FocusLock;","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","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, rest = __rest(props, [\"forwardProps\", \"children\", \"className\", \"removeScrollBar\", \"enabled\", \"shards\", \"sideCar\", \"noIsolation\", \"inert\", \"allowPinchZoom\", \"as\"]);\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 })),\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 { 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","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","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    if (process.env.NODE_ENV !== 'production') {\n        if (cs.overflowY === 'hidden') {\n            console.error('react-remove-scroll-bar: cannot calculate scrollbar size because it is removed (overflow:hidden on body');\n        }\n    }\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();\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 {\\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 {\\n    \").concat(removedBarSizeVariable, \": \").concat(gap, \"px;\\n  }\\n\");\n};\n/**\n * Removes page scrollbar and blocks page scroll when mounted\n */\nexport var RemoveScrollBar = function (props) {\n    var noRelative = props.noRelative, noImportant = props.noImportant, _a = props.gapMode, gapMode = _a === void 0 ? 'margin' : _a;\n    var gap = React.useMemo(function () { return getGapWidth(gapMode); }, [gapMode]);\n    return React.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? '!important' : '') });\n};\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    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 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), s = _a[1], d = _a[2];\n            if (s > d) {\n                return true;\n            }\n        }\n        current = current.parentNode;\n    } while (current && current !== document.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        target = target.parentNode;\n    } while (\n    // portaled content\n    (!targetInLock && target !== document.body) ||\n        // self content\n        (targetInLock && (endTarget.contains(target) || endTarget === target)));\n    if (isDeltaPositive && ((noOverscroll && availableScroll === 0) || (!noOverscroll && delta > availableScroll))) {\n        shouldCancelScroll = true;\n    }\n    else if (!isDeltaPositive &&\n        ((noOverscroll && availableScrollTop === 0) || (!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(function () { return 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) {\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 && 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 };\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: \"margin\" }) : null));\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","import React, { forwardRef, useEffect, useRef, useCallback } from 'react';\nimport Portal from '@reach/portal';\nimport { checkStyles, useForkedRef, wrapEvent, getOwnerDocument, noop, isString } from '@reach/utils';\nimport FocusLock from 'react-focus-lock';\nimport { RemoveScroll } from 'react-remove-scroll';\nimport PropTypes from 'prop-types';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nvar overlayPropTypes = {\n  allowPinchZoom: PropTypes.bool,\n  dangerouslyBypassFocusLock: PropTypes.bool,\n  dangerouslyBypassScrollLock: PropTypes.bool,\n  // TODO:\n  initialFocusRef: function initialFocusRef() {\n    return null;\n  },\n  onDismiss: PropTypes.func\n}; ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * DialogOverlay\r\n *\r\n * Low-level component if you need more control over the styles or rendering of\r\n * the dialog overlay.\r\n *\r\n * Note: You must render a `DialogContent` inside.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/dialog#dialogoverlay\r\n */\n\nvar DialogOverlay = /*#__PURE__*/forwardRef(function DialogOverlay(_ref, forwardedRef) {\n  var _ref$isOpen = _ref.isOpen,\n      isOpen = _ref$isOpen === void 0 ? true : _ref$isOpen,\n      props = _objectWithoutPropertiesLoose(_ref, [\"isOpen\"]);\n\n  useEffect(function () {\n    return checkStyles(\"dialog\");\n  }, []); // We want to ignore the immediate focus of a tooltip so it doesn't pop\n  // up again when the menu closes, only pops up when focus returns again\n  // to the tooltip (like native OS tooltips).\n\n  useEffect(function () {\n    if (isOpen) {\n      // @ts-ignore\n      window.__REACH_DISABLE_TOOLTIPS = true;\n    } else {\n      window.requestAnimationFrame(function () {\n        // Wait a frame so that this doesn't fire before tooltip does\n        // @ts-ignore\n        window.__REACH_DISABLE_TOOLTIPS = false;\n      });\n    }\n  }, [isOpen]);\n  return isOpen ? React.createElement(Portal, {\n    \"data-reach-dialog-wrapper\": \"\"\n  }, React.createElement(DialogInner, Object.assign({\n    ref: forwardedRef\n  }, props))) : null;\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  DialogOverlay.displayName = \"DialogOverlay\";\n  DialogOverlay.propTypes = /*#__PURE__*/_extends({}, overlayPropTypes, {\n    isOpen: PropTypes.bool\n  });\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * DialogInner\r\n */\n\n\nvar DialogInner = /*#__PURE__*/forwardRef(function DialogInner(_ref2, forwardedRef) {\n  var allowPinchZoom = _ref2.allowPinchZoom,\n      _ref2$dangerouslyBypa = _ref2.dangerouslyBypassFocusLock,\n      dangerouslyBypassFocusLock = _ref2$dangerouslyBypa === void 0 ? false : _ref2$dangerouslyBypa,\n      _ref2$dangerouslyBypa2 = _ref2.dangerouslyBypassScrollLock,\n      dangerouslyBypassScrollLock = _ref2$dangerouslyBypa2 === void 0 ? false : _ref2$dangerouslyBypa2,\n      initialFocusRef = _ref2.initialFocusRef,\n      onClick = _ref2.onClick,\n      _ref2$onDismiss = _ref2.onDismiss,\n      onDismiss = _ref2$onDismiss === void 0 ? noop : _ref2$onDismiss,\n      onKeyDown = _ref2.onKeyDown,\n      onMouseDown = _ref2.onMouseDown,\n      _ref2$unstable_lockFo = _ref2.unstable_lockFocusAcrossFrames,\n      unstable_lockFocusAcrossFrames = _ref2$unstable_lockFo === void 0 ? true : _ref2$unstable_lockFo,\n      props = _objectWithoutPropertiesLoose(_ref2, [\"allowPinchZoom\", \"dangerouslyBypassFocusLock\", \"dangerouslyBypassScrollLock\", \"initialFocusRef\", \"onClick\", \"onDismiss\", \"onKeyDown\", \"onMouseDown\", \"unstable_lockFocusAcrossFrames\"]);\n\n  var mouseDownTarget = useRef(null);\n  var overlayNode = useRef(null);\n  var ref = useForkedRef(overlayNode, forwardedRef);\n  var activateFocusLock = useCallback(function () {\n    if (initialFocusRef && initialFocusRef.current) {\n      initialFocusRef.current.focus();\n    }\n  }, [initialFocusRef]);\n\n  function handleClick(event) {\n    if (mouseDownTarget.current === event.target) {\n      event.stopPropagation();\n      onDismiss(event);\n    }\n  }\n\n  function handleKeyDown(event) {\n    if (event.key === \"Escape\") {\n      event.stopPropagation();\n      onDismiss(event);\n    }\n  }\n\n  function handleMouseDown(event) {\n    mouseDownTarget.current = event.target;\n  }\n\n  useEffect(function () {\n    return overlayNode.current ? createAriaHider(overlayNode.current) : void null;\n  }, []);\n  return React.createElement(FocusLock, {\n    autoFocus: true,\n    returnFocus: true,\n    onActivation: activateFocusLock,\n    disabled: dangerouslyBypassFocusLock,\n    crossFrame: unstable_lockFocusAcrossFrames\n  }, React.createElement(RemoveScroll, {\n    allowPinchZoom: allowPinchZoom,\n    enabled: !dangerouslyBypassScrollLock\n  }, React.createElement(\"div\", Object.assign({}, props, {\n    ref: ref,\n    \"data-reach-dialog-overlay\": \"\",\n\n    /*\r\n     * We can ignore the `no-static-element-interactions` warning here\r\n     * because our overlay is only designed to capture any outside\r\n     * clicks, not to serve as a clickable element itself.\r\n     */\n    onClick: wrapEvent(onClick, handleClick),\n    onKeyDown: wrapEvent(onKeyDown, handleKeyDown),\n    onMouseDown: wrapEvent(onMouseDown, handleMouseDown)\n  }))));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  DialogOverlay.displayName = \"DialogOverlay\";\n  DialogOverlay.propTypes = /*#__PURE__*/_extends({}, overlayPropTypes);\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * DialogContent\r\n *\r\n * Low-level component if you need more control over the styles or rendering of\r\n * the dialog content.\r\n *\r\n * Note: Must be a child of `DialogOverlay`.\r\n *\r\n * Note: You only need to use this when you are also styling `DialogOverlay`,\r\n * otherwise you can use the high-level `Dialog` component and pass the props\r\n * to it. Any props passed to `Dialog` component (besides `isOpen` and\r\n * `onDismiss`) will be spread onto `DialogContent`.\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/dialog#dialogcontent\r\n */\n\n\nvar DialogContent = /*#__PURE__*/forwardRef(function DialogContent(_ref3, forwardedRef) {\n  var onClick = _ref3.onClick,\n      onKeyDown = _ref3.onKeyDown,\n      props = _objectWithoutPropertiesLoose(_ref3, [\"onClick\", \"onKeyDown\"]);\n\n  return React.createElement(\"div\", Object.assign({\n    \"aria-modal\": \"true\",\n    role: \"dialog\",\n    tabIndex: -1\n  }, props, {\n    ref: forwardedRef,\n    \"data-reach-dialog-content\": \"\",\n    onClick: wrapEvent(onClick, function (event) {\n      event.stopPropagation();\n    })\n  }));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  DialogContent.displayName = \"DialogContent\";\n  DialogContent.propTypes = {\n    \"aria-label\": ariaLabelType,\n    \"aria-labelledby\": ariaLabelType\n  };\n} ////////////////////////////////////////////////////////////////////////////////\n\n/**\r\n * Dialog\r\n *\r\n * High-level component to render a modal dialog window over the top of the page\r\n * (or another dialog).\r\n *\r\n * @see Docs https://reacttraining.com/reach-ui/dialog#dialog\r\n */\n\n\nvar Dialog = /*#__PURE__*/forwardRef(function Dialog(_ref4, forwardedRef) {\n  var _ref4$allowPinchZoom = _ref4.allowPinchZoom,\n      allowPinchZoom = _ref4$allowPinchZoom === void 0 ? false : _ref4$allowPinchZoom,\n      initialFocusRef = _ref4.initialFocusRef,\n      isOpen = _ref4.isOpen,\n      _ref4$onDismiss = _ref4.onDismiss,\n      onDismiss = _ref4$onDismiss === void 0 ? noop : _ref4$onDismiss,\n      props = _objectWithoutPropertiesLoose(_ref4, [\"allowPinchZoom\", \"initialFocusRef\", \"isOpen\", \"onDismiss\"]);\n\n  return React.createElement(DialogOverlay, {\n    allowPinchZoom: allowPinchZoom,\n    initialFocusRef: initialFocusRef,\n    isOpen: isOpen,\n    onDismiss: onDismiss\n  }, React.createElement(DialogContent, Object.assign({\n    ref: forwardedRef\n  }, props)));\n});\n\nif (process.env.NODE_ENV !== \"production\") {\n  Dialog.displayName = \"Dialog\";\n  Dialog.propTypes = {\n    isOpen: PropTypes.bool,\n    onDismiss: PropTypes.func,\n    \"aria-label\": ariaLabelType,\n    \"aria-labelledby\": ariaLabelType\n  };\n}\n\nfunction createAriaHider(dialogNode) {\n  var originalValues = [];\n  var rootNodes = [];\n  var ownerDocument = getOwnerDocument(dialogNode) || document;\n\n  if (!dialogNode) {\n    if (process.env.NODE_ENV !== \"production\") {\n      console.warn(\"A ref has not yet been attached to a dialog node when attempting to call `createAriaHider`.\");\n    }\n\n    return noop;\n  }\n\n  Array.prototype.forEach.call(ownerDocument.querySelectorAll(\"body > *\"), function (node) {\n    var _dialogNode$parentNod, _dialogNode$parentNod2;\n\n    var portalNode = (_dialogNode$parentNod = dialogNode.parentNode) === null || _dialogNode$parentNod === void 0 ? void 0 : (_dialogNode$parentNod2 = _dialogNode$parentNod.parentNode) === null || _dialogNode$parentNod2 === void 0 ? void 0 : _dialogNode$parentNod2.parentNode;\n\n    if (node === portalNode) {\n      return;\n    }\n\n    var attr = node.getAttribute(\"aria-hidden\");\n    var alreadyHidden = attr !== null && attr !== \"false\";\n\n    if (alreadyHidden) {\n      return;\n    }\n\n    originalValues.push(attr);\n    rootNodes.push(node);\n    node.setAttribute(\"aria-hidden\", \"true\");\n  });\n  return function () {\n    rootNodes.forEach(function (node, index) {\n      var originalValue = originalValues[index];\n\n      if (originalValue === null) {\n        node.removeAttribute(\"aria-hidden\");\n      } else {\n        node.setAttribute(\"aria-hidden\", originalValue);\n      }\n    });\n  };\n}\n\nfunction ariaLabelType(props, propName, compName, location, propFullName) {\n  var details = \"\\nSee https://www.w3.org/TR/wai-aria/#aria-label for details.\";\n\n  if (!props[\"aria-label\"] && !props[\"aria-labelledby\"]) {\n    return new Error(\"A <\" + compName + \"> must have either an `aria-label` or `aria-labelledby` prop.\\n      \" + details);\n  }\n\n  if (props[\"aria-label\"] && props[\"aria-labelledby\"]) {\n    return new Error(\"You provided both `aria-label` and `aria-labelledby` props to a <\" + compName + \">. If the a label for this component is visible on the screen, that label's component should be given a unique ID prop, and that ID should be passed as the `aria-labelledby` prop into <\" + compName + \">. If the label cannot be determined programmatically from the content of the element, an alternative label should be provided as the `aria-label` prop, which will be used as an `aria-label` on the HTML tag.\" + details);\n  } else if (props[propName] != null && !isString(props[propName])) {\n    return new Error(\"Invalid prop `\" + propName + \"` supplied to `\" + compName + \"`. Expected `string`, received `\" + (Array.isArray(propFullName) ? \"array\" : typeof propFullName) + \"`.\");\n  }\n\n  return null;\n}\n\nexport default Dialog;\nexport { Dialog, DialogContent, DialogOverlay };\n//# sourceMappingURL=dialog.esm.js.map\n","// extracted by mini-css-extract-plugin\nexport default {\"overlay\":\"Modal--overlay--datCD\",\"dialog\":\"Modal--dialog--NJuNP\",\"close-button\":\"Modal--close-button--54bUs\",\"closeButton\":\"Modal--close-button--54bUs\",\"title\":\"Modal--title--sH-CW\",\"hero-image\":\"Modal--hero-image--jNDsp\",\"heroImage\":\"Modal--hero-image--jNDsp\",\"body\":\"Modal--body--X1CY9\",\"actions\":\"Modal--actions--Ld-Kr\"};","import React from 'react';\nimport PropTypes from 'prop-types';\nimport { DialogOverlay, DialogContent } from '@reach/dialog';\n\nimport ActionsCancelNormalXsmall from '@strava/icons/ActionsCancelNormalXsmall';\nimport colors from '../colors';\nimport Button from '../Button';\n\nimport styles from './styles.scss';\n\n//\n// ModalOverlay\n//\n// Reach UI docs: https://reach.tech/dialog/#dialogoverlay\n// --------------------\n\nexport function ModalOverlay({ className, children, ...otherProps }) {\n  const classNames = [styles.overlay];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <DialogOverlay className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </DialogOverlay>\n  );\n}\n\n// Override DialogContent display name so that error from prop types show 'ModalOverlay'\nDialogOverlay.displayName = 'ModalOverlay';\n\nModalOverlay.defaultProps = {\n  className: null,\n  isOpen: false,\n  onDismiss: () => {},\n  initialFocusRef: () => {},\n\n  allowPinchZoom: false,\n  dangerouslyBypassFocusLock: false,\n  dangerouslyBypassScrollLock: false\n};\n\nModalOverlay.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string,\n  isOpen: PropTypes.bool,\n  onDismiss: PropTypes.func,\n  initialFocusRef: PropTypes.func,\n  allowPinchZoom: PropTypes.bool,\n  dangerouslyBypassFocusLock: PropTypes.bool,\n  dangerouslyBypassScrollLock: PropTypes.bool\n};\n\n//\n// ModalContent\n//\n// Reach UI docs: https://reach.tech/dialog/#dialogcontent\n// --------------------\n\nexport function ModalContent({ className, children, ...otherProps }) {\n  const classNames = [styles.dialog];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <DialogContent className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </DialogContent>\n  );\n}\n\n// Override DialogContent display name so that error from prop types show 'ModalContent'\nDialogContent.displayName = 'ModalContent';\n\nModalContent.defaultProps = {\n  className: null\n};\n\nModalContent.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string,\n\n  //\n  // @reach/dialog will handle prop-type validation for us, but in order for this\n  // props to show up in Storybook we need to add them here.\n  //\n  /* eslint-disable react/require-default-props */\n  'aria-label': PropTypes.string,\n  'aria-labelledby': PropTypes.string\n  /* eslint-enable react/require-default-props */\n};\n\n//\n// ModalTitle\n// --------------------\n\nexport function ModalTitle({ className, children, ...otherProps }) {\n  const classNames = [styles.title];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <h2 className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </h2>\n  );\n}\n\nModalTitle.defaultProps = {\n  className: null\n};\n\nModalTitle.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string\n};\n\n//\n// ModalActions\n// --------------------\n\nexport function ModalActions({ className, children, ...otherProps }) {\n  const classNames = [styles.actions];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <div className={classNames.join(' ')} {...otherProps}>\n      {children}\n    </div>\n  );\n}\n\nModalActions.defaultProps = {\n  className: null\n};\n\nModalActions.propTypes = {\n  children: PropTypes.node.isRequired,\n  className: PropTypes.string\n};\n\n//\n// ModalHeroImage\n// --------------------\n\nexport function ModalHeroImage({ className, src, alt, ...otherProps }) {\n  const classNames = [styles.heroImage];\n  if (className) {\n    classNames.push(className);\n  }\n  return (\n    <img src={src} alt={alt} className={classNames.join(' ')} {...otherProps} />\n  );\n}\n\nModalHeroImage.defaultProps = {\n  className: null\n};\n\nModalHeroImage.propTypes = {\n  className: PropTypes.string,\n  src: PropTypes.string.isRequired,\n  alt: PropTypes.string.isRequired\n};\n\n//\n// ModalBody\n// --------------------\n\nexport function ModalBody({ className, ...otherProps }) {\n  const classNames = [styles.body];\n  if (className) {\n    classNames.push(className);\n  }\n  return <div className={classNames.join(' ')} {...otherProps} />;\n}\n\nModalBody.defaultProps = {\n  className: null\n};\n\nModalBody.propTypes = {\n  className: PropTypes.string,\n  children: PropTypes.node.isRequired\n};\n\n//\n// ModalCloseButton\n// --------------------\n\nexport function ModalCloseButton({ className, color, ...otherProps }) {\n  return (\n    <Button type=\"button\" variant=\"icon\" className={className} {...otherProps}>\n      <ActionsCancelNormalXsmall fill={color || colors.BLACK} />\n    </Button>\n  );\n}\n\nModalCloseButton.defaultProps = {\n  className: null,\n  color: null\n};\n\nModalCloseButton.propTypes = {\n  className: PropTypes.string,\n  color: PropTypes.string\n};\n\n//\n// Modal\n// --------------------\n\nfunction Modal({\n  className,\n  isOpen,\n  onDismiss,\n  hasClose,\n  children,\n  initialFocusRef,\n  ...otherProps\n}) {\n  return (\n    <ModalOverlay\n      isOpen={isOpen}\n      onDismiss={onDismiss}\n      initialFocusRef={initialFocusRef}\n    >\n      <ModalContent className={className} {...otherProps}>\n        {hasClose && (\n          <ModalCloseButton\n            className={styles.closeButton}\n            onClick={onDismiss}\n          />\n        )}\n        {children}\n      </ModalContent>\n    </ModalOverlay>\n  );\n}\n\nModal.defaultProps = {\n  className: null,\n  isOpen: false,\n  hasClose: false,\n  onDismiss: () => {},\n  initialFocusRef: () => {}\n};\n\nModal.propTypes = {\n  /**\n   * This style will be applied to ModalContent used by Modal component\n   */\n  className: PropTypes.string,\n\n  /**\n   * Whether modal is open or closed - aka visitable to the user\n   */\n  isOpen: PropTypes.bool,\n\n  /**\n   * Called when modal will be closed\n   */\n  onDismiss: PropTypes.func,\n\n  /**\n   * By default the first focusable element will receive focus when the dialog opens but you can provide a ref to focus instead.\n   */\n  initialFocusRef: PropTypes.func,\n\n  /**\n   * Whether to show close button or not\n   */\n  hasClose: PropTypes.bool,\n\n  children: PropTypes.oneOfType([\n    PropTypes.arrayOf(PropTypes.node),\n    PropTypes.node\n  ]).isRequired,\n\n  //\n  // @reach/dialog will handle prop-type validation for us, but in order for this\n  // props to show up in Storybook we need to add them here.\n  //\n  /* eslint-disable react/require-default-props */\n  'aria-label': PropTypes.string,\n  'aria-labelledby': PropTypes.string\n  /* eslint-enable react/require-default-props */\n};\n\nexport default Modal;\n","/**\n * Checks if `value` is `null` or `undefined`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n * @example\n *\n * _.isNil(null);\n * // => true\n *\n * _.isNil(void 0);\n * // => true\n *\n * _.isNil(NaN);\n * // => false\n */\nfunction isNil(value) {\n  return value == null;\n}\n\nexport default isNil;\n","export default function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}"],"names":["_extends","Object","assign","target","i","arguments","length","source","key","prototype","hasOwnProperty","call","apply","this","_excluded","VisuallyHidden","forwardRef","_ref","ref","_ref$as","as","Comp","_ref$style","style","props","excluded","sourceKeys","keys","indexOf","_objectWithoutPropertiesLoose","createElement","border","clip","height","margin","overflow","padding","position","width","whiteSpace","wordWrap","getOwnerDocument","element","window","document","ownerDocument","_arrayLikeToArray","arr","len","arr2","Array","_createForOfIteratorHelperLoose","o","allowArrayLike","it","Symbol","iterator","isArray","minLen","n","toString","slice","constructor","name","from","test","_unsupportedIterableToArray","done","value","TypeError","next","bind","assignRef","isFunction","current","error","Error","renderTimer","polite","assertive","liveRegions","Alert","forwardedRef","children","_ref$type","type","regionType","ownRef","useRef","_len","refs","_key","useCallback","node","_step","_iterator","useComposedRefs","child","useMemo","prevType","useEffect","usePrevious","mirror","mounted","unmount","createMirror","mount","update","useMirrorEffects","doc","renderAlerts","setAttribute","body","appendChild","clearTimeout","setTimeout","forEach","elementType","render","role","map","cloneElement","ReactPropTypesSecret","emptyFunction","emptyFunctionWithReset","resetWarningCache","module","exports","shim","propName","componentName","location","propFullName","secret","err","getShim","isRequired","ReactPropTypes","array","bigint","bool","func","number","object","string","symbol","any","arrayOf","instanceOf","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","FOCUS_GROUP","FOCUS_DISABLED","useMergeRefs","defaultValue","initialValue","callback","newValue","useState","facade","last","hiddenGuard","top","left","InFocusGuard","propTypes","defaultProps","ItoI","a","innerCreateMedium","defaults","middleware","buffer","assigned","read","useMedium","data","item","push","filter","x","assignSyncMedium","cb","cbs","assignMedium","pendingQueue","executeQueue","cycle","Promise","resolve","then","createMedium","createSidecarMedium","options","medium","async","ssr","mediumFocus","currentTarget","mediumBlur","mediumEffect","mediumSidecar","emptyArray","FocusLock","parentRef","_extends2","_React$useState","realObserved","setObserved","observed","isActive","originalFocusedElement","disabled","noFocusGuards","persistentFocus","crossFrame","autoFocus","group","allowTextSelection","className","whiteList","hasPositiveIndices","_props$shards","shards","_props$as","Container","_props$lockProps","lockProps","containerProps","SideCar","sideCar","shouldReturnFocus","returnFocus","focusOptions","onActivationCallback","onActivation","onDeactivationCallback","onDeactivation","id","activeElement","allowDefer","returnFocusTo","focus","howToReturnFocus","returnFocusOptions","undefined","onFocus","event","onBlur","setObserveNode","newObserved","hasLeadingGuards","hasTailingGuards","mergedRef","tabIndex","reducePropsToState","handleStateChangeOnClient","WrappedComponent","state","mountedInstances","emitChange","instance","SideEffect","_PureComponent","peek","_proto","componentDidMount","componentDidUpdate","componentWillUnmount","index","splice","PureComponent","displayName","getDisplayName","getParentNode","parentNode","nodeType","Node","DOCUMENT_FRAGMENT_NODE","host","isTopNode","DOCUMENT_NODE","isVisibleUncached","checkParent","ELEMENT_NODE","computedStyle","getComputedStyle","getPropertyValue","isElementHidden","isVisibleCached","visibilityCache","cached","get","result","set","isAutoFocusAllowedCached","cache","isAutoFocusAllowed","isAutoFocusAllowedUncached","getDataset","dataset","isHTMLInputElement","tagName","isRadioElement","attribute","getAttribute","includes","isGuard","_a","Boolean","focusGuard","isNotAGuard","isDefined","correctNode","nodes","el","checked","findSelectedRadio","pickFirstFocus","pickFocusable","NEW_FOCUS","newFocus","innerNodes","outerNodes","lastNode","cnt","firstFocus","lastFocus","isOnGuard","resultSet","activeIndex","lastIndex","lastNodeInside","indexDiff","firstNodeIndex","lastNodeIndex","correctedNodes","Set","add","has","correctedIndexDiff","returnFirstNode","returnLastNode","Math","abs","toArray","ret","asArray","tabSort","b","tabDiff","orderByTabIndex","filterNegative","keepGuards","sort","queryTabbables","join","queryGuardTabbables","concat","getFocusablesWithShadowDom","parent","withGuards","shadowRoot","reduce","acc","matches","getFocusables","parents","querySelectorAll","filterFocusable","isHTMLButtonElement","notHiddenInput","filterAutoFocusable","Map","getTabbableNodes","topNodes","getAllTabbableNodes","parentAutofocusables","topNode","parentFocus","contains","scope","getPrototypeOf","some","getTopParent","getAllAffectedNodes","currentNode","contained","l","j","compareDocumentPosition","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","_","filterNested","getNestedShadowActiveElement","getActiveElement","getParents","getCommonParent","nodeA","nodeB","parentsA","parentsB","currentParent","getTopCommonParent","baseActiveElement","leftEntry","rightEntries","activeElements","leftEntries","topCommon","entry","subEntry","common","getFocusMerge","entries","commonParent","anyFocusable","innerElements","srcNodes","dstNodes","remap","autoFocusables","orderedInnerElements","entity","newId","autoFocusable","allParentAutofocusables","autofocus","guardCount","lockDisabled","focusable","console","contentWindow","focusInsideIframe","focusInside","getFocusabledIn","lockItem","guard","deferAction","action","setImmediate","isFreeFocus","lastActiveTrap","lastActiveFocus","lastPortaledElement","focusWasOutsideWindow","defaultWhitelist","autoGuard","startIndex","end","step","allNodes","lastGuard","focusAutoGuard","extractRef","checkInHost","check","boundary","activateTrap","_lastActiveTrap","workingNode","portaledElement","workingArea","focusWhitelisted","area","withinHost","blur","newActiveElement","focusedIndex","_ref2","_ref3","removeAttribute","onTrap","stopPropagation","preventDefault","observerNode","onWindowBlur","moveFocusInside","propsList","_ref5","traps","trap","addEventListener","lastTrap","sameTrap","_ref6","removeEventListener","FocusLockCombination","zeroRightClassName","fullWidthClassName","effectCar","nothing","RemoveScroll","onScrollCapture","onWheelCapture","onTouchMoveCapture","callbacks","setCallbacks","forwardProps","removeScrollBar","enabled","noIsolation","inert","allowPinchZoom","_b","rest","containerRef","lockRef","classNames","fullWidth","zeroRight","currentNonce","Target","isSideCarExport","makeStyleTag","tag","nonce","stylesheetSingleton","counter","stylesheet","css","styleSheet","cssText","createTextNode","head","getElementsByTagName","insertStyleTag","remove","removeChild","styleSingleton","sheet","useStyle","styles","isDynamic","dynamic","zeroGap","right","gap","parse","parseInt","getGapWidth","gapMode","offsets","cs","getOffset","documentWidth","documentElement","clientWidth","windowWidth","innerWidth","max","Style","getStyles","allowRelative","important","RemoveScrollBar","noRelative","noImportant","passiveSupported","defineProperty","nonPassive","passive","elementCanBeScrolled","overflowY","overflowX","alwaysContainsScroll","locationCouldBeScrolled","axis","ShadowRoot","elementCouldBeScrolled","getScrollVariables","elementCouldBeVScrolled","elementCouldBeHScrolled","scrollTop","scrollHeight","clientHeight","scrollLeft","scrollWidth","getHScrollVariables","getTouchXY","changedTouches","clientX","clientY","getDeltaXY","deltaX","deltaY","generateStyle","idCounter","lockStack","exported","shouldPreventQueue","touchStartRef","activeAxis","lastProps","classList","allow_1","shouldCancelEvent","touches","currentAxis","touch","touchStart","moveDirection","canBeScrolledInMainDirection","cancelingAxis","endTarget","sourceDelta","noOverscroll","directionFactor","direction","getDirectionFactor","delta","targetInLock","shouldCancelScroll","isDeltaPositive","availableScroll","availableScrollTop","elementScroll","handleScroll","shouldPrevent","_event","sourceEvent","e","y","should","cancelable","shardNodes","shouldCancel","scrollTouchStart","scrollWheel","scrollTouchMove","inst","ReactRemoveScroll","DialogOverlay","_ref$isOpen","isOpen","__REACH_DISABLE_TOOLTIPS","requestAnimationFrame","DialogInner","_ref2$dangerouslyBypa","dangerouslyBypassFocusLock","_ref2$dangerouslyBypa2","dangerouslyBypassScrollLock","initialFocusRef","onClick","_ref2$onDismiss","onDismiss","onKeyDown","onMouseDown","_ref2$unstable_lockFo","unstable_lockFocusAcrossFrames","mouseDownTarget","overlayNode","activateFocusLock","dialogNode","originalValues","rootNodes","_dialogNode$parentNod","_dialogNode$parentNod2","attr","originalValue","createAriaHider","DialogContent","ModalOverlay","otherProps","ModalContent","ModalTitle","ModalActions","ModalHeroImage","src","alt","ModalBody","ModalCloseButton","color","Button","variant","ActionsCancelNormalXsmall","fill","colors","Modal","hasClose","_defineProperty","obj","enumerable","configurable","writable"],"sourceRoot":""}