{"version":3,"file":"static/js/3706_de28e1c85eaa08ed9942.js","mappings":";sQAMA,MAAMA,EAAyB,eACzBC,EAAqC,qBACrCC,EAAkC,CAAC,UAAW,yBAA0B,wBAAyB,yBAA0B,2BAA4B,cAAe,qBAAsB,oBAAqB,kBAAmB,mBAAmBC,KAAK,MAC5PC,EACY,EADZA,EAEM,EAFNA,EAGK,EA6BLC,EACO,EADPA,EAEc,EAFdA,EAGK,EAELC,EAAgB,CACpBC,OAAQ,EACRC,OAAQ,GAEJC,EAAkB,CACtBC,KAAM,EACNC,SAAU,EACVC,WAAY,EACZC,KAAM,EACNC,WAAY,GAGRC,EACK,EADLA,EAEO,EAFPA,EAGO,EAHPA,EAIQ,EAJRA,EAKI,EALJA,EAMM,EANNA,EAOE,EAPFA,EAQC,EAEDC,EAAwB,CAC5BC,UAAW,EACXC,QAAS,EACTC,iBAAkB,GAGdC,EACG,EAGHC,EAGK,EAQX,SAASC,EAAoBC,EAASC,GACpC,IAAIC,EAEJ,OAAgD,QAAxCA,EAAKF,EAAQG,aAAaF,UAA6B,IAAPC,OAAgB,EAASA,EAAGF,OACtF,CACA,SAASI,EAAyBJ,EAASC,EAASI,GAClD,IAAIH,EAAII,EAER,MAAMC,EAAeF,GAAWL,EAAQQ,WAAQC,EAAYR,EAAQS,aAAajC,GACjF,IACIkC,EADAC,EAAQZ,EAAQG,aAAaF,GAGjC,GAAIM,EAAc,CAChB,GAAIA,KAAsF,QAAnEL,EAAKU,aAAqC,EAASA,EAAMC,YAAyB,IAAPX,OAAgB,EAASA,EAAGY,QAkB5H,OAjBA,IACE,MAAMC,EAAWC,KAAKC,MAAMV,GAE5B,GAAwB,iBAAbQ,EACT,MAAM,IAAIG,MAAM,oCAAoCX,OAGtDI,EAAU,CACRG,OAAQP,EACRY,OAAQJ,EAEZ,CAAE,MAAOK,GACH,CAGN,CAIJ,MAAO,IAAKR,EACV,OAGGA,IAEHA,EAAQZ,EAAQG,aAAaF,GAAS,IAGnCW,EAAMZ,UACTY,EAAMZ,QAAU,CAAC,GAGnB,MAAMqB,EAAmBT,EAAMZ,SAAW,CAAC,EACrCsB,GAAyC,QAArBhB,EAAKM,EAAMC,YAAyB,IAAPP,OAAgB,EAASA,EAAGa,SAAW,CAAC,EACzFI,GAAmBZ,aAAyC,EAASA,EAAQQ,SAAW,CAAC,EAE/F,IAAK,MAAMK,KAAOC,OAAOC,KAAKJ,GAC5B,IAAKC,EAAgBC,GAAM,CACzB,GAAY,SAARA,EAAgB,CAClB,MAAMG,EAAON,EAAiBG,GAE1BG,GACF3B,EAAQ2B,KAAKC,OAAOD,GAAM,EAE9B,CAEA,OAAQH,GACN,IAAK,UACL,IAAK,OACL,IAAK,WACL,IAAK,YACL,IAAK,WACL,IAAK,QAEH,MAAMK,EAAOR,EAAiBG,GAE1BK,IACFA,EAAKxB,iBACEgB,EAAiBG,IAG1B,MAEF,IAAK,kBACIH,EAAiBG,GAEpBxB,EAAQ8B,iBACV9B,EAAQ8B,gBAAgBC,wBAAwB9B,GAGlD,MAEF,IAAK,YACL,IAAK,UACL,IAAK,eACL,IAAK,aACIoB,EAAiBG,GAG9B,CAGF,IAAK,MAAMA,KAAOC,OAAOC,KAAKH,GAAkB,CAC9C,MAAMS,EAAMT,EAAgBS,IAE5B,OAAQR,GACN,IAAK,UACCH,EAAiBY,QACnBZ,EAAiBY,QAAQC,SAASX,EAAgBU,SAE9CjC,EAAQiC,UACVZ,EAAiBY,QAAUjC,EAAQiC,QAAQE,cAAclC,EAASsB,EAAgBU,UAMtF,MAEF,IAAK,OACCZ,EAAiBM,KACnBN,EAAiBM,KAAKO,SAASX,EAAgBI,MAE/CN,EAAiBM,KAAO3B,EAAQ2B,KAAKS,WAAWnC,EAASsB,EAAgBI,KAAMK,GAGjFhC,EAAQ2B,KAAKC,OAAOP,EAAiBM,MACrC,MAEF,IAAK,YACCN,EAAiBgB,UACnBhB,EAAiBgB,UAAUH,SAASX,EAAgBc,WAEhDrC,EAAQqC,YACVhB,EAAiBgB,UAAYrC,EAAQqC,UAAUC,gBAAgBrC,EAASsB,EAAgBc,UAAWL,IAMvG,MAEF,IAAK,WACCX,EAAiBkB,SACnBlB,EAAiBkB,SAASL,SAASX,EAAgBgB,UAE/CvC,EAAQuC,UACNhB,EAAgBgB,WAClBlB,EAAiBkB,SAAWvC,EAAQuC,SAASC,eAAevC,EAASsB,EAAgBgB,WAO3F,MAEF,IAAK,YACHlB,EAAiBoB,UAAYlB,EAAgBkB,UAC7C,MAEF,IAAK,WACCpB,EAAiBqB,SACnBrB,EAAiBqB,SAASR,SAASX,EAAgBmB,UAE/C1C,EAAQ0C,WACVrB,EAAiBqB,SAAW1C,EAAQ0C,SAASC,eAAe1C,EAASsB,EAAgBmB,SAAUV,IAMnG,MAEF,IAAK,QACCX,EAAiBuB,MACnBvB,EAAiBuB,MAAMV,SAASX,EAAgBqB,OAE5C5C,EAAQ4C,QACVvB,EAAiBuB,MAAQ5C,EAAQ4C,MAAMC,YAAY5C,EAASsB,EAAgBqB,MAAOZ,IAMvF,MAEF,IAAK,WACChC,EAAQ8B,kBACVT,EAAiByB,SAAWvB,EAAgBuB,SAC5C9C,EAAQ8B,gBAAgBC,wBAAwB9B,IAKlD,MAEF,IAAK,eACHoB,EAAiB0B,aAAexB,EAAgBwB,aAChD,MAEF,IAAK,UACC/C,EAAQgD,UACV3B,EAAiB2B,QAAUzB,EAAgByB,SAK7C,MAEF,IAAK,MACH3B,EAAiBW,IAAMT,EAAgBS,IACvC,MAEF,QACEiB,QAAQC,MAAM,gBAAgB1B,uCAEpC,CAEIb,EACFC,EAAMC,KAAOF,GAEgC,IAAzCc,OAAOC,KAAKL,GAAkB8B,gBACzBvC,EAAMZ,eACNY,EAAMC,MAGfb,EAAQG,aAAaF,GAAS,GAElC,CAUA,MAKMmD,EAA4B,oBA8B5BC,EAA0B,0BAG1BC,EAAiC,kCAWjCC,EAA6B,6BAK7BC,EAAgC,iCAUhCC,EAAsC,oBAAhBC,YAA8BA,YAAc,WAExE,EACA,MAAMC,UAA2BF,EAC/B,WAAAG,CAAYC,EAAMC,GAChBC,MAAMF,EAAM,CACVG,SAAS,EACTC,YAAY,EACZC,UAAU,EACVJ,WAEFK,KAAKC,QAAUN,CACjB,EAGF,MAAMO,UAA4BV,EAChC,WAAAC,CAAYE,GACVC,MAjF4B,kBAiFGD,EACjC,EAGF,MAAMQ,UAA6BX,EACjC,WAAAC,CAAYE,GACVC,MAtF6B,mBAsFGD,EAClC,EAGF,MAAMS,UAA8BZ,EAClC,WAAAC,CAAYE,GACVC,MAAMX,EAA2BU,EACnC,EAGF,MAAMU,UAAwBb,EAC5B,WAAAC,CAAYE,GACVC,MAvEwB,sBAuEGD,EAC7B,EA6CF,MAAMW,UAAkCd,EACtC,WAAAC,GACEG,MAAMP,EACR,EAGF,MAAMkB,UAAuBf,EAC3B,WAAAC,CAAYE,GACVC,MA9FuB,qBA8FGD,EAC5B,EAGF,MAAMa,UAAsBhB,EAC1B,WAAAC,CAAYE,GACVC,MAnGsB,oBAmGGD,EAC3B,EAQF,MA8CMc,EAAM,CACVC,uBA/C8BC,GAAY,IAAIC,iBAAiBD,GAgD/DE,iBA9CwB,CAACC,EAAKtD,EAAMuD,EAAYC,IAAWF,EAAID,iBAAiBrD,EAAMuD,EAAYC,GA+ClGC,cA7CqBC,GAAQA,EAAOA,EAAKC,WAAa,KA8CtDC,iBA5CwBtF,GAAWA,EAAUA,EAAQuF,cAAgB,KA6CrEC,aA3CoB,CAACC,EAAQC,OAAaA,KAAUD,aAAuC,EAASA,EAAOE,SAASD,KA4CpHE,iBA1CwBZ,GAAOA,EAAIa,cA2CnCC,cAzCqB,CAAC9F,EAAS+F,IAAa/F,EAAQ8F,cAAcC,GA0ClEC,iBAxCwB,CAAChG,EAAS+F,IAAaE,MAAMC,UAAUC,MAAMC,KAAKpG,EAAQgG,iBAAiBD,GAAW,GAyC9GM,eAvCsB,CAACrB,EAAKsB,IAAOtB,EAAIqB,eAAeC,GAwCtDC,cAtCqBnB,IAASA,aAAmC,EAASA,EAAKoB,aAAe,KAuC9FC,aArCoBrB,IAASA,aAAmC,EAASA,EAAKsB,YAAc,KAsC5FC,eApCsBvB,IAASA,aAAmC,EAASA,EAAKwB,cAAgB,KAqChGC,mBAnC0BzB,IAASA,aAAmC,EAASA,EAAK0B,kBAAoB,KAoCxGC,qBAlC4B/G,IAAYA,aAAyC,EAASA,EAAQgH,oBAAsB,KAmCxHC,oBAjC2BjH,IAAYA,aAAyC,EAASA,EAAQkH,mBAAqB,KAkCtHC,sBAhC6BnH,IAAYA,aAAyC,EAASA,EAAQoH,qBAAuB,KAiC1HC,0BA/BiCrH,IAAYA,aAAyC,EAASA,EAAQsH,yBAA2B,KAgClIC,YA9BmB,CAAC9B,EAAQC,IAAUD,EAAO8B,YAAY7B,GA+BzD8B,aA7BoB,CAAC/B,EAAQC,EAAO+B,IAAmBhC,EAAO+B,aAAa9B,EAAO+B,GA8BlFC,aA5BoBC,IACpB,IAAI1H,EAEJ,OAAqC,QAA5BA,EAAK0H,EAAIC,qBAAkC,IAAP3H,OAAgB,EAASA,EAAGyH,iBAAmB,IAAI,EA0BhGG,kBAvByB,CAACC,EAAkBC,IAASD,EAAiBF,cAAcC,kBAAkBE,IAoCxG,IAAIC,EAEJ,MAAMC,EAA8B,oBAAZC,QAA0BA,QAAU,MAC1D,WAAAvE,CAAYwE,EAAGC,EAAGC,EAAOC,GACvBpE,KAAKqE,KAAOJ,GAAK,EACjBjE,KAAKsE,IAAMJ,GAAK,EAChBlE,KAAKuE,OAASN,GAAK,IAAME,GAAS,GAClCnE,KAAKwE,QAAUN,GAAK,IAAME,GAAU,EACtC,GAIF,IAAIK,EAAc,EAElB,IAIEC,SAAS7D,iBAAiB6D,SAAUC,WAAWC,cAC/Cd,GAAgB,CAClB,CAAE,MAAO7G,GACP6G,GAAgB,CAClB,CAGA,SAASe,EAAmBC,GAC1B,MAAMC,EAAMD,IACZ,IAAIE,EAAMD,EAAIE,yBAiBd,OAfKD,IACHA,EAAM,CACJE,aAAc,CAAC,EACfC,OAAQ,CACNC,QAASL,EAAIK,cAAW9I,EACxB+I,QAASN,EAAIM,cAAW/I,GAE1BgJ,2BAA4B,CAAC,EAC7BC,iCAAkC,EAClCC,aAAc,GACdC,qBAAqB,GAEvBV,EAAIE,yBAA2BD,GAG1BA,CACT,CA6BA,MAAMU,EACJ,WAAAjG,CAAYkG,GACV3F,KAAK4F,QAAUD,CACjB,CAEA,KAAAE,GACE,OAAO7F,KAAK4F,OACd,CAEA,cAAOE,CAAQC,EAAKC,GAClB,OAAKD,EAAIH,YAILI,GAAgBC,GAAiBF,EAAIH,QAAQlC,cAAeqC,EAAIH,mBAC3DG,EAAIH,SACJ,EAIX,EAIF,MAAMM,EACJ,WAAAzG,CAAYqF,EAAWhJ,EAASqK,GAC9B,MAAMC,EAAUvB,EAAmBC,GACnC,IAAIrB,EAEA2C,EAAQf,QACV5B,EAAM,IAAI2C,EAAQf,QAAQvJ,IAE1B2H,EAAM,IAAIiC,EAAY5J,GACtBsK,EAAQZ,aAAaa,KAAK5C,IAG5BzD,KAAKsG,KAAO7C,EACZzD,KAAKuG,MAAQJ,CACf,CAEA,GAAAK,GACE,MAAM/C,EAAMzD,KAAKsG,KACjB,IAAIxK,EAUJ,OARI2H,IACF3H,EAAU2H,EAAIoC,QAET/J,UACIkE,KAAKsG,MAITxK,CACT,CAEA,OAAA2K,GACE,OAAOzG,KAAKuG,KACd,EAGF,SAASG,EAAoB5B,EAAWkB,GACtC,MAAMI,EAAUvB,EAAmBC,GACnCsB,EAAQZ,aAAeY,EAAQZ,aAAaxE,QAAO/D,IAAMyI,EAAYI,QAAQ7I,EAAG+I,IAClF,CACA,SAASW,EAAyB7B,GAChC,MAAMsB,EAAUvB,EAAmBC,GAE9BsB,EAAQX,sBACXW,EAAQX,qBAAsB,EAC9BW,EAAQf,QAkOZ,SAAoBe,GAClB,OAAOA,EAAQjB,OAAOE,OACxB,CApOsBuB,CAAWR,IAG1BA,EAAQS,oBACXT,EAAQS,kBAAoB/B,IAAYgC,YAAW,KACjDV,EAAQS,uBAAoBvK,EAC5BoK,EAAoB5B,GACpB6B,EAAyB7B,EAAU,GAClC,MAEP,CAWA,SAASiC,EAAwBjG,EAAKtD,EAAMwJ,GAE1C,GAAIxJ,EAAKyJ,WAAaC,KAAKC,aACzB,OAIF,MAAMnG,EAAS8C,EAAgBkD,EAAa,CAC1CA,cAEF,OAAOvG,EAAII,iBAAiBC,EAAKtD,EAAMmH,WAAWC,aAAc5D,GAEhE,EAGF,CACA,SAASoG,EAAgBtC,EAAWhJ,GAClC,IAAIuL,EAAUvL,EAAQwL,iBACtB,MAAMlB,EAAUvB,EAAmBC,GAC7ByC,EAASF,EAAUjB,EAAQd,2BAA2B+B,QAAW/K,EAEvE,GAAIiL,EACF,OAAOA,EAAOC,KAGhB,MAAMC,EAAmB3L,EAAQ4H,eAAiB5H,EAAQ4H,cAAcgE,gBAExE,IAAKD,EACH,OAAO,IAAI1D,EAKb,IAAIM,EAAO,EACPC,EAAM,EACNC,EAAQkD,EAAiBE,YACzBnD,EAASiD,EAAiBG,aAE9B,GAAI9L,IAAY2L,EAAkB,CAChC,MAAMI,EAAI/L,EAAQgM,wBAClBzD,EAAO0D,KAAKC,IAAI3D,EAAMwD,EAAExD,MACxBC,EAAMyD,KAAKC,IAAI1D,EAAKuD,EAAEvD,KACtBC,EAAQwD,KAAKE,IAAI1D,EAAOsD,EAAEtD,OAC1BC,EAASuD,KAAKE,IAAIzD,EAAQqD,EAAErD,OAC9B,CAEA,MAAMgD,EAAO,IAAIzD,EAASM,EAAOE,EAAQF,GAAQ,EAAGC,EAAME,EAASF,GAAO,EAAGD,EAAOE,EAAQA,EAAQF,EAAO,EAAGC,EAAME,EAASA,EAASF,EAAM,GAwB5I,OAtBK+C,IACHA,EAAU,QAASjB,EAAQb,iCAC3BzJ,EAAQwL,iBAAmBD,GAG7BjB,EAAQd,2BAA2B+B,GAAW,CAC5CG,OACA1L,WAGGsK,EAAQ8B,kCACX9B,EAAQ8B,gCAAkCC,OAAOrB,YAAW,KAC1DV,EAAQ8B,qCAAkC5L,EAE1C,IAAK,MAAM8L,KAAO9K,OAAOC,KAAK6I,EAAQd,mCAC7Bc,EAAQd,2BAA2B8C,GAAKtM,QAAQwL,iBAGzDlB,EAAQd,2BAA6B,CAAC,CAAC,GACtC,KAGEkC,CACT,CACA,SAASa,EAAsCvD,EAAWhJ,EAASwM,GACjE,MAAMC,EAAYC,GAAuB1M,GAEzC,IAAKyM,EACH,OAAO,EAGT,MAAME,EAAgBrB,EAAgBtC,EAAWyD,GAC3CG,EAAc5M,EAAQgM,wBACtBa,EAAwBD,EAAYtE,QAAU,EAAIkE,GAGlDM,EAFkBb,KAAKC,IAAI,EAAGS,EAAcnE,IAAMoE,EAAYpE,KACzCyD,KAAKC,IAAI,EAAGU,EAAYlE,OAASiE,EAAcjE,QAE1E,OAA6B,IAAtBoE,GAA2BA,GAAqBD,CACzD,CAiBA,SAASH,GAAuB1M,GAC9B,MAAMgF,EAAMhF,EAAQ4H,cAEpB,GAAI5C,EAAK,CACP,IAAK,IAAI+H,EAAKpI,EAAIW,iBAAiBtF,GAAU+M,EAAIA,EAAKpI,EAAIW,iBAAiByH,GACzE,GAAIA,EAAGC,YAAcD,EAAGlB,aAAekB,EAAGE,aAAeF,EAAGjB,aAC1D,OAAOiB,EAIX,OAAO/H,EAAI4G,eACb,CAEA,OAAO,IACT,CAIA,SAASsB,GAAkBlN,GACzB,QAASA,EAAQmN,mBACnB,CACA,SAASC,GAAOC,GACd,MAAMC,EAAM,IAAIC,YAAY,GAE5B,GAAIF,EAAIG,QAAUH,EAAIG,OAAOC,gBAC3BJ,EAAIG,OAAOC,gBAAgBH,QACtB,GAAID,EAAIK,UAAYL,EAAIK,SAASD,gBACtCJ,EAAIK,SAASD,gBAAgBH,QAE7B,IAAK,IAAIK,EAAI,EAAGA,EAAIL,EAAIpK,OAAQyK,IAC9BL,EAAIK,GAAK,WAAa1B,KAAK2B,SAI/B,MAAMC,EAAO,GAEb,IAAK,IAAIF,EAAI,EAAGA,EAAIL,EAAIpK,OAAQyK,IAC9BE,EAAKtD,KAAK+C,EAAIK,GAAGG,SAAS,KAO5B,OAJAD,EAAKtD,KAAK,KACVsD,EAAKtD,QAAQ5B,GAAamF,SAAS,KACnCD,EAAKtD,KAAK,KACVsD,EAAKtD,KAAKwD,KAAKC,MAAMF,SAAS,KACvBD,EAAKlP,KAAK,GACnB,CACA,SAASsP,GAAcjF,EAAWhJ,GAChC,MAAMsK,EAAUvB,EAAmBC,GACnC,IAAIkF,EAAMlO,EAAQmO,oBAUlB,OARKD,IACHA,EAAMlO,EAAQmO,oBAAsBf,GAAOpE,OAGxCsB,EAAQlB,aAAa8E,IAAQ/D,GAAiBnK,EAAQ4H,cAAe5H,KACxEsK,EAAQlB,aAAa8E,GAAO,IAAI9D,EAAgBpB,EAAWhJ,IAGtDkO,CACT,CAUA,SAASE,GAAkBpF,EAAWvD,GACpC,MAAM6E,EAAUvB,EAAmBC,GAEnC,IAAK,MAAMzH,KAAOC,OAAOC,KAAK6I,EAAQlB,cAAe,CACnD,MAAMiF,EAAM/D,EAAQlB,aAAa7H,GAC3BwL,EAAKsB,GAAOA,EAAI3D,MAElBqC,GAAMtH,IACHd,EAAIa,aAAaC,EAAQsH,WAKzBzC,EAAQlB,aAAa7H,EAC9B,CACF,CAEA,SAAS4I,GAAiBnF,EAAKhF,GAC7B,OAAO2E,EAAIa,aAAaR,aAAiC,EAASA,EAAIsJ,KAAMtO,EAC9E,CACA,SAASuO,GAAgBvO,EAAS+F,GAChC,MAAMyI,EAAUxO,EAAQwO,SAAWxO,EAAQuO,iBAAmBvO,EAAQyO,mBAAqBzO,EAAQ0O,sBACnG,OAAOF,GAAWA,EAAQpI,KAAKpG,EAAS+F,EAC1C,CACA,SAAS4I,GAAW3F,GAClB,MAAMsB,EAAUvB,EAAmBC,GAEnC,GAAIsB,EAAQjB,OAAOC,QACjB,OAAOgB,EAAQjB,OAAOC,QAGxB,MAAM,IAAIrI,MAAM,sBAClB,CAIA,IAAI2N,GAAqB,EACzB,MAAMC,GACJ,WAAAlL,CAAY5D,EAASC,EAAS8O,GAC5B,MAAM9F,EAAYjJ,EAAQiJ,UAC1B9E,KAAK6K,SAAWhP,EAChBmE,KAAK8K,SAAW,IAAI5E,EAAgBpB,EAAWhJ,GAC/CkE,KAAK+K,OAAS,IAAKH,GAEnB5K,KAAKoC,GAAK,OAAQsI,EACpB,CAEA,UAAAM,GACE,OAAOhL,KAAK8K,SAAStE,KACvB,CAEA,QAAAyE,GACE,OAAOjL,KAAK+K,MACd,CAEA,QAAAhN,CAAS6M,GACP5K,KAAK+K,OAAS,IAAKH,EAErB,EAOF,MAAMM,GACJ,WAAAzL,CAAYqF,EAAWqG,EAAWP,EAAO9O,EAASsP,GAChD,IAAIrP,EAEJiE,KAAKqL,SAAWpO,IACd,GAAI+C,KAAKsL,aAAc,CACrB,MAAM3F,EAAS3F,KAAKsL,aAAa9E,MAMjC,YAJIb,IACF,QAAYA,GAIhB,CAEA,MAAM4F,EAAQvL,KAAKuL,MAEnB,GAAIvL,KAAKwL,WAAaD,EAAO,CAC3B,MAAME,EAAgBxO,EAAEwO,cACxBzL,KAAKwL,UAAUxL,KAAMA,KAAK0L,aAAY,EAAMH,EAAOE,GAAgBA,EACrE,GAGFzL,KAAK2L,UAAY1O,IACf,GAAI+C,KAAKsL,aACP,OAGFtL,KAAK4L,kBAAmB,EACxB,MAAML,EAAQvL,KAAKuL,MAEnB,GAAIvL,KAAK6L,YAAcN,EAAO,CAC5B,MAAME,EAAgBxO,EAAEwO,cACxBzL,KAAK6L,WAAW7L,KAAMA,KAAK0L,aAAY,EAAOH,EAAOE,GAAgBA,EACvE,GAGF,MAAM1G,EAAMD,IACNyG,EAAQxG,EAAIL,SAASoH,cAAc,KACzCP,EAAMQ,SAAW,EACjBR,EAAMS,aAAa,OAAQ,QAC3BT,EAAMS,aAAazR,EAAoC,IACvDgR,EAAMS,aAAa,cAAe,QAClC,MAAMC,EAAQV,EAAMU,MACpBA,EAAMC,SAAW,QACjBD,EAAM9H,MAAQ8H,EAAM7H,OAAS,MAC7B6H,EAAME,QAAU,QAChBF,EAAMG,OAAS,KACfH,EAAMI,YAAY,qBAAsB,UAvK5C,SAA0BvQ,GACxBA,EAAQmN,qBAAsB,CAChC,CAsKIqD,CAAiBf,GACjBvL,KAAKuL,MAAQA,EACbvL,KAAKuM,QAAU3B,EAAM2B,QACrBvM,KAAKmL,UAAYA,EACjBnL,KAAKwM,WAAwC,QAA1BzQ,EAAK6O,EAAM6B,iBAA8B,IAAP1Q,GAAgBA,EACrEiE,KAAKsL,aAAeF,EACpBG,EAAMmB,iBAAiB,UAAW1M,KAAKqL,UACvCE,EAAMmB,iBAAiB,WAAY1M,KAAK2L,WACxCJ,EAAMoB,wBAA0B7Q,EAE5BkE,KAAKwM,aACPxM,KAAK4M,cAAgB7H,EAAI+B,YAAW,YAC3B9G,KAAK4M,cACZ5M,KAAK9D,SAAS,GACb,GAEH8D,KAAK6M,qBAAuB,KACtB7M,KAAK4M,gBACP7H,EAAI+H,aAAa9M,KAAK4M,sBACf5M,KAAK4M,sBAGP5M,KAAK6M,oBAAoB,EAGtC,CAEA,OAAA3Q,GACE,IAAIH,EAEAiE,KAAK6M,sBACP7M,KAAK6M,uBAGP,MAAMtB,EAAQvL,KAAKuL,MAEdA,WAIEvL,KAAKsL,oBACLtL,KAAKwL,iBACLxL,KAAK6L,kBACL7L,KAAKuL,MACZA,EAAMwB,oBAAoB,UAAW/M,KAAKqL,UAC1CE,EAAMwB,oBAAoB,WAAY/M,KAAK2L,kBACpCJ,EAAMoB,wBACuB,QAAnC5Q,EAAK0E,EAAIQ,cAAcsK,UAA2B,IAAPxP,GAAyBA,EAAGiR,YAAYzB,GACtF,CAEA,UAAA0B,CAAW3I,EAAKD,GACd,IAAItI,EAEJ,MAAMkQ,EAA8B,QAArBlQ,EAAKiE,KAAKuL,aAA0B,IAAPxP,OAAgB,EAASA,EAAGkQ,MAEpEA,IACFA,EAAM3H,IAAM,GAAGA,MACf2H,EAAM5H,KAAO,GAAGA,MAEpB,CAEA,WAAAqH,CAAYwB,EAAMC,EAASC,GACzB,OAAOF,IAASE,GAAYpN,KAAKuM,WAAaa,GAAYD,EAAQE,wBAAwBD,GAAYlG,KAAKoG,4BAC7G,EAGF,MAAMC,GACE,EADFA,GAGG,EAHHA,GAIM,EAEZ,MAAMC,GACJ,WAAA/N,CAAY5D,EAASC,EAAS2R,EAAU5P,EAAK6P,EAAkBC,GAC7D3N,KAAK8K,SAAWhP,EAChBkE,KAAK4N,UAAY,IAAIC,GAAsBhS,EAASC,EAASkE,KAAMyN,EAAU5P,EAAK6P,EAAkBC,EACtG,CAEA,YAAAG,CAAatC,EAAWK,GACtB7L,KAAK+N,WAAavC,EAClBxL,KAAKgO,YAAcnC,CACrB,CAEA,OAAAoC,CAAQC,GACN,IAAInS,EAEsB,QAAzBA,EAAKiE,KAAK4N,iBAA8B,IAAP7R,GAAyBA,EAAGkS,QAAQC,EACxE,CAEA,wBAAAC,CAAyBD,EAAWE,GAClC,IAAIrS,EAEsB,QAAzBA,EAAKiE,KAAK4N,iBAA8B,IAAP7R,GAAyBA,EAAGoS,yBAAyBD,EAAWE,EACpG,CAEA,UAAAC,CAAWnB,GACT,OAAOA,EAAOlN,KAAK+N,WAAa/N,KAAKgO,WACvC,CAEA,WAAAM,CAAYC,GACV,IAAIxS,EAEsB,QAAzBA,EAAKiE,KAAK4N,iBAA8B,IAAP7R,GAAyBA,EAAGuS,YAAYtO,KAAMuO,EAClF,CAEA,OAAArS,GACM8D,KAAK4N,YACP5N,KAAK4N,UAAU1R,QAAQ8D,aAEhBA,KAAK4N,kBAGP5N,KAAK+N,kBACL/N,KAAKgO,WACd,CAEA,2BAAOQ,CAAqB3S,EAASC,EACrC2S,EACAC,EACAN,GAYE,MAIM7C,EAJQ,IAAIL,GAAWrP,EAAQiJ,WAAW,EAAM,CACpD2H,WAAW,EACXF,SAAS,IAEShB,MAEpB,GAAIA,EAAO,CACT,IAAIhK,EACA+B,EA8BJ,GAAwB,SAApBxH,EAAQ6S,QAEVpN,EAASzF,EACTwH,EAAemL,GAAoBC,IAAeD,IAAqBC,EAAajO,EAAIoC,qBAAqB/G,GAAW,SACnH,CASL,IAAI8S,EACAC,EATAJ,KAAsBC,GAAcA,IAAe7S,EAAQyC,UAAUwQ,YAAYhT,GAAS,GAAO,GAAM,KACzGyF,EAASzF,EACTwH,EAAeoL,EAAa5S,EAAQgH,kBAAoB,OAExDvB,EAASd,EAAIW,iBAAiBtF,GAC9BwH,EAAemL,GAAoBC,IAAeD,IAAqBC,EAAa5S,EAAU2E,EAAIwC,sBAAsBnH,IAM1H,GAKE8S,EAAiBH,GAAoBC,IAAeD,IAAqBC,EAAajO,EAAI0C,0BAA0BG,GAAgBA,EACpIuL,EAAWE,GAAuBH,GAE9BC,IAAa/S,EACfwH,EAAemL,GAAoBC,IAAeD,IAAqBC,EAAaE,EAAiBnO,EAAIwC,sBAAsB2L,GAE/HC,EAAW,WAENA,EACX,EAEItN,aAAuC,EAASA,EAAOyN,cAAc,IAAI5O,EAAsB,CACjG6O,GAAI,OACJC,MAAO3N,EACP4N,KAAM,KACNf,qBAEA3N,EAAI6C,aAAa/B,EAAQgK,EAAOjI,IAChC,QAAYiI,GAEhB,CACF,CAEA,gCAAO6D,CAA0BvT,EAASwT,EAAeX,EAAYY,GACnE,MAIM/D,EAJQ,IAAIL,GAAWrP,EAAQiJ,WAAW,EAAM,CACpD2H,WAAW,EACXF,SAAS,QACRjQ,EAAW,IAAI4J,EAAgBrK,EAAQiJ,UAAWwK,IACjC/D,MAEpB,GAAIA,EAAO,CACT,IAAIgE,EACAjM,EAEgB+L,EA3lBPzN,cAAcpH,KA2lBYkU,GACrCa,EAAcF,EACd/L,EAAe7C,EAAIoC,qBAAqBwM,KAExCE,EAAc9O,EAAIW,iBAAiBiO,GACnC/L,EAAeoL,EAAaW,EAAgB5O,EAAIwC,sBAAsBoM,IAGpEE,GACF9O,EAAI6C,aAAaiM,EAAahE,EAAOjI,EAEzC,CACF,EAgBF,MAAMkM,GACJ,WAAA/P,CAAYsF,GACV/E,KAAKyP,aAAe,IAAIC,IACxB1P,KAAK2P,qBAAuB,EAC5B3P,KAAK4P,gBAAkB,IAAIC,QAC3B7P,KAAK8P,eAAiB,GACtB9P,KAAK+P,gBAAkB,IAAIC,QAE3BhQ,KAAKiQ,YAAc1O,IACjB,IAAIxF,EAEAiE,KAAK4P,gBAAgBM,IAAI3O,KAI7BvB,KAAK4P,gBAAgBO,IAAI5O,GAErBvB,KAAKoQ,0BAITpQ,KAAKoQ,wBAA+C,QAApBrU,EAAKiE,KAAKqQ,YAAyB,IAAPtU,OAAgB,EAASA,EAAGmG,KAAKlC,MAAM8G,YAAW,YACrG9G,KAAKoQ,wBAEZ,IAAK,MAAM3M,KAAOzD,KAAK8P,eAAgB,CACrC,MAAMQ,EAAe7M,EAAI+C,MAEzB,GAAI8J,EAAc,CAChB,MAAM3P,EAAWX,KAAK+P,gBAAgBvJ,IAAI8J,GAE1C,GAAI3P,EAAU,CACZ,MAAM4O,EAAc9O,EAAIQ,cAAcqP,GAEjCf,IAAevP,KAAK4P,gBAAgBM,IAAIX,IAC3C5O,GAEJ,CACF,CACF,CAEAX,KAAK4P,gBAAkB,IAAIC,OAAS,GA9sBV,MA+sBC,EAG/B7P,KAAKqQ,KAAOtL,CACd,CAEA,GAAAoL,CAAII,EAAO5P,IACJX,KAAK+P,gBAAgBG,IAAIK,IAAUvQ,KAAKqQ,OAC3CrQ,KAAK8P,eAAezJ,KAAK,IAAIH,EAAgBlG,KAAKqQ,KAAME,IAExDvQ,KAAK+P,gBAAgBS,IAAID,EAAO5P,GAEhCX,KAAKyQ,WAAazQ,KAAKiQ,YAE3B,CAEA,MAAAS,CAAOH,GACLvQ,KAAK8P,eAAiB9P,KAAK8P,eAAe9O,QAAOyC,IAC/C,MAAM3H,EAAU2H,EAAI+C,MACpB,OAAO1K,GAAWA,IAAYyU,CAAK,IAGrCvQ,KAAK+P,gBAAgBY,OAAOJ,GAEO,IAA/BvQ,KAAK8P,eAAe9Q,eACfgB,KAAKyQ,UAEhB,CAEA,OAAAvU,GACE,IAAIH,EAEJ,MAAMgJ,EAA2B,QAApBhJ,EAAKiE,KAAKqQ,YAAyB,IAAPtU,OAAgB,EAASA,EAAGmG,KAAKlC,MAEtEA,KAAK4Q,eACP7L,SAA0CA,EAAI+H,aAAa9M,KAAK4Q,qBACzD5Q,KAAK4Q,cAGV5Q,KAAKoQ,0BACPrL,SAA0CA,EAAI+H,aAAa9M,KAAKoQ,gCACzDpQ,KAAKoQ,yBAGdpQ,KAAK4P,gBAAkB,IAAIC,QAC3B7P,KAAK+P,gBAAkB,IAAIC,QAC3BhQ,KAAK8P,eAAiB,GAEtB9P,KAAKyP,aAAaoB,eAEX7Q,KAAKyQ,kBACLzQ,KAAKqQ,IACd,CAEA,eAAAS,CAAgBC,GACT/Q,KAAKqQ,OAMVrQ,KAAKyP,aAAaU,IAAIY,GAEtB/Q,KAAK2P,qBAAuB9F,KAAKC,MAEjC9J,KAAKgR,4BACP,CAEA,yBAAAA,GACE,IAAIjV,EAEAiE,KAAK4Q,eAIT5Q,KAAK4Q,aAAoC,QAApB7U,EAAKiE,KAAKqQ,YAAyB,IAAPtU,OAAgB,EAASA,EAAGmG,KAAKlC,MAAM8G,YAAW,KAQjG,UAPO9G,KAAK4Q,aAOR5Q,KAAK2P,qBAlyBmB,KAkyBiC9F,KAAKC,MAAO,CAEvE,MAAMmH,EAAqB,IAAIC,IACzBC,EAAsB,GAE5B,IAAK,MAAMJ,KAAW/Q,KAAKyP,aACzB0B,EAAoB9K,KAAK0K,EAAQE,IAGnCjR,KAAKyP,aAAaoB,QAIlB,IAAK,MAAM5D,KAAckE,EACvBlE,IAIFgE,EAAmBJ,OACrB,MACE7Q,KAAKgR,2BACP,GAvzB4B,KAyzBhC,EAOF,MAAMnD,GACJ,WAAApO,CAAY5D,EAASC,EAASsV,EAAS3D,EAAU5P,EAAK6P,EAAkBC,GACtE3N,KAAKqR,UAAY,GACjBrR,KAAKsR,YAAa,EAClBtR,KAAKuR,mBAAqB,IAAI7B,IAE9B1P,KAAK+N,WAAa,CAACyD,EAAY9C,EAAYjD,KACzCzL,KAAKyR,UAAS,EAAMD,EAAY9C,EAAYjD,EAAc,EAG5DzL,KAAKgO,YAAc,CAACwD,EAAY9C,EAAYjD,KAC1CzL,KAAKyR,UAAS,EAAOD,EAAY9C,EAAYjD,EAAc,EAG7DzL,KAAKiO,QAAUC,IACb,IAAInS,EAEJ,MAAM2V,EAAQ1R,KAAK2R,YACbC,EAAO5R,KAAK6R,WAElB,GAAIH,GAASE,EAAM,CAIjB5R,KAAK8R,kBAEL,MAAMC,EAAaL,EAAMnG,MACnByG,EAAYJ,EAAKrG,MACjBzP,EAAmC,QAAxBC,EAAKiE,KAAK8K,gBAA6B,IAAP/O,OAAgB,EAASA,EAAGyK,MAE7E,GAAIuL,GAAcC,GAAalW,EAAS,CACtC,IAAImW,EAEA/D,GACF6D,EAAWhG,SAAW,EACtBkG,EAAUF,IAEVC,EAAUjG,SAAW,EACrBkG,EAAUD,GAGRC,IACF,QAAYA,EAEhB,CACF,GASFjS,KAAKmO,yBAA2B,CAACD,EAAWE,KAC1C,IAAIrS,EAEJ,MAAM2V,EAAQ1R,KAAK2R,YACbC,EAAO5R,KAAK6R,WAElB,GAAIH,GAASE,EAAM,CAIjB5R,KAAK8R,kBAEL,MAAMC,EAAaL,EAAMnG,MACnByG,EAAYJ,EAAKrG,MACjBzP,EAAmC,QAAxBC,EAAKiE,KAAK8K,gBAA6B,IAAP/O,OAAgB,EAASA,EAAGyK,MAE7E,GAAIuL,GAAcC,GAAalW,EAAS,CACtC,IAAImW,EAEA/D,GACGwD,EAAMvG,WAAanL,KAAK6K,SAASvM,UAAUwQ,YAAYhT,GAAS,GAAM,GAAM,GAC/EmW,EAAUnW,GAEV4V,EAAM9F,kBAAmB,EACzBmG,EAAWhG,SAAW,EACtBkG,EAAUF,IAGZH,EAAKhG,kBAAmB,EACxBoG,EAAUjG,SAAW,EACrBkG,EAAUD,GAGRC,GAAWnW,EAAQkT,cAAc,IAAI5O,EAAsB,CAC7D6O,GAAI,OACJC,MAAOpT,EACPqT,KAAM,KACNf,oBAEA,QAAY6D,EAEhB,CACF,GAGFjS,KAAKsO,YAAc,CAAC8C,EAAS7C,KAC3B,IAAIxS,EAAII,EAER,IAAK,MAAM+V,KAAKlS,KAAKqR,UACnB,GAAIa,EAAEd,UAAYA,EAAS,CACzBc,EAAE3D,SAAWA,EACb,KACF,CAGF,MAAM4D,EAAUnS,KAAKoS,cAErB,GAAID,EAAS,CACX,MAAMpG,EAAWoG,EAAQ5D,SAAW,GAAK,EACzC,IAAIhD,EAAoC,QAA3BxP,EAAKiE,KAAK2R,mBAAgC,IAAP5V,OAAgB,EAASA,EAAGwP,MAExEA,IACFA,EAAMQ,SAAWA,GAGnBR,EAAmC,QAA1BpP,EAAK6D,KAAK6R,kBAA+B,IAAP1V,OAAgB,EAASA,EAAGoP,MAEnEA,IACFA,EAAMQ,SAAWA,EAErB,CAE6C,EAW/C/L,KAAKqS,gBAAkB,KACjBrS,KAAKsS,YAITtS,KAAKsS,UAAYtS,KAAKuS,aAAazL,YAAW,YACrC9G,KAAKsS,UAEZtS,KAAK8R,kBAOL9R,KAAKwS,sBAAsB,GAC1B,GAAE,EAGPxS,KAAKwS,qBAAuB,KAC1BxS,KAAK6K,SAAS4H,eAAe3B,gBAAgB9Q,KAAK0S,yBAAyB,EAG7E1S,KAAK0S,yBAA2BzB,IAC9B,IAAIlV,EAAII,EAER,MAAMwW,GAAoC,QAA3B5W,EAAKiE,KAAK2R,mBAAgC,IAAP5V,OAAgB,EAASA,EAAGwP,SAAsC,QAA1BpP,EAAK6D,KAAK6R,kBAA+B,IAAP1V,OAAgB,EAASA,EAAGoP,OAClJqH,EAAoB5S,KAAKuR,mBACzBsB,EAAuB,IAAInD,IACjC,IAAIoD,EAAY,EACZC,EAAa,EAEjB,MAAMhO,EAAM/E,KAAKuS,aAEjB,IAAK,IAAIzW,EAAU6W,EAAM7W,GAAWA,EAAQmL,WAAaC,KAAKC,aAAcrL,EAAU2E,EAAIW,iBAAiBtF,GAAU,CACnH,IAAIkX,EAAgB/B,EAAmBzK,IAAI1K,GAG3C,QAAsBQ,IAAlB0W,EAA6B,CAC/B,MAAMC,EAAYlO,EAAImO,iBAAiBpX,GAASmX,UAE5CA,GAA2B,SAAdA,IACfD,EAAgB,CACdF,UAAWhX,EAAQgX,UACnBC,WAAYjX,EAAQiX,aAIxB9B,EAAmBT,IAAI1U,EAASkX,GAAiB,KACnD,CAEIA,IACFH,EAAqB1C,IAAIrU,GAEpB8W,EAAkB1C,IAAIpU,IACzBA,EAAQ4Q,iBAAiB,SAAU1M,KAAKwS,sBAG1CM,GAAaE,EAAcF,UAC3BC,GAAcC,EAAcD,WAEhC,CAEA,IAAK,MAAMlK,KAAM+J,EACVC,EAAqB3C,IAAIrH,IAC5BA,EAAGkE,oBAAoB,SAAU/M,KAAKwS,sBAK1C,OADAxS,KAAKuR,mBAAqBsB,EACnB,KACL,IAAI9W,EAAII,EAEoB,QAA3BJ,EAAKiE,KAAK2R,mBAAgC,IAAP5V,GAAyBA,EAAGkR,WAAW6F,EAAWC,GAC3D,QAA1B5W,EAAK6D,KAAK6R,kBAA+B,IAAP1V,GAAyBA,EAAG8Q,WAAW6F,EAAWC,EAAW,CACjG,EAGH,MAAMlK,EAAK/M,EAAQ0K,MAEnB,IAAKqC,EACH,MAAM,IAAI9L,MAAM,cAGlBiD,KAAK6K,SAAWhP,EAChBmE,KAAKuS,WAAa1W,EAAQiJ,UAC1B9E,KAAKmT,sBAAwBxF,EAC7B,MAAMyF,EAAWvK,EAAGwK,eAQpB,IANCD,GAAYpT,MAAMqR,UAAUhL,KAAK,CAChC+K,UACA3D,WACAc,UAAU,IAGR6E,EAMF,OAAOA,EAGTvK,EAAGwK,eAAiBrT,KAGpB,MAAMsT,EAAsBzV,aAAiC,EAASA,EAAI0V,oBACpE5E,EAAU9F,EAAG8F,QACnB3O,KAAKsR,WAAcgC,EAAyKA,IAAwB3X,GAA1K+R,GAAgC,OAAZiB,GAAgC,OAAZA,GAAgC,UAAZA,MAAsC,OAAZA,GAAgC,OAAZA,GAAgC,OAAZA,GACxK3O,KAAK2R,YAAc,IAAIzG,GAAWlL,KAAKuS,WAAYvS,KAAKsR,WAAY,CAClE/E,SAAS,GACRzQ,GACHkE,KAAK6R,WAAa,IAAI3G,GAAWlL,KAAKuS,WAAYvS,KAAKsR,WAAY,CACjE/E,SAAS,GACRzQ,GAIH,MAAMwU,EAAetQ,KAAK2R,YAAYpG,MACtC+E,GAAgBzU,EAAQ4W,eAAetC,IAAIG,EAActQ,KAAKqS,iBAC9DrS,KAAK2R,YAAYnG,UAAYxL,KAAK+N,WAClC/N,KAAK2R,YAAY9F,WAAa7L,KAAKgO,YACnChO,KAAK6R,WAAWrG,UAAYxL,KAAK+N,WACjC/N,KAAK6R,WAAWhG,WAAa7L,KAAKgO,YAClChO,KAAK8K,SAAWhP,EAEhBkE,KAAKqS,iBACP,CAEA,OAAAnW,CAAQkV,EAASoC,GACf,IAAIzX,EAAII,EAAIsX,EAAIC,EAShB,GAAwB,KAPP1T,KAAKqR,UAAYrR,KAAKqR,UAAUrQ,QAAOkR,GAAKA,EAAEd,UAAYA,IAAYoC,KAO1ExU,OAAc,QACQ,QAAxBjD,EAAKiE,KAAK8K,gBAA6B,IAAP/O,OAAgB,EAASA,EAAGyK,OAAO6M,eAE5E,IAAK,MAAMxK,KAAM7I,KAAKuR,mBACpB1I,EAAGkE,oBAAoB,SAAU/M,KAAKwS,sBAGxCxS,KAAKuR,mBAAmBV,QAExB,MAAM9L,EAAM/E,KAAKuS,aAEbvS,KAAKsS,YACPvN,EAAI+H,aAAa9M,KAAKsS,kBACftS,KAAKsS,WAGd,MAAMhC,EAA2C,QAA3BnU,EAAK6D,KAAK2R,mBAAgC,IAAPxV,OAAgB,EAASA,EAAGoP,MACrF+E,GAAgBtQ,KAAK6K,SAAS4H,eAAe/B,OAAOJ,GACxB,QAA3BmD,EAAKzT,KAAK2R,mBAAgC,IAAP8B,GAAyBA,EAAGvX,UACrC,QAA1BwX,EAAK1T,KAAK6R,kBAA+B,IAAP6B,GAAyBA,EAAGxX,SACjE,CACF,CAEA,QAAAuV,CAASvE,EAAMsE,EAAY9C,EAAYjD,GACrC,IAAI1P,EAEJ,MAAMoW,EAAUnS,KAAKoS,eAEjBD,GAAaX,EAAW5F,mBAAoB5L,KAAKmT,uBACP,QAA3CpX,EAAKoW,EAAQf,QAAQ/C,WAAWnB,UAA0B,IAAPnR,GAAyBA,EAAGyV,EAAY9C,EAAYjD,EAE5G,CAEA,WAAA2G,GASE,OARApS,KAAKqR,UAAUsC,MAAK,CAACC,EAAGC,IAClBD,EAAErF,WAAasF,EAAEtF,SACZqF,EAAErF,UAAY,EAAI,EAGpBqF,EAAEnG,SAAWoG,EAAEpG,WAGjBzN,KAAKqR,UAAU,EACxB,CAEA,eAAAS,GACE,IAAI/V,EAAII,EAAIsX,EAEZ,MAAM3X,EAAmC,QAAxBC,EAAKiE,KAAK8K,gBAA6B,IAAP/O,OAAgB,EAASA,EAAGyK,MACvEsN,EAA8C,QAA3B3X,EAAK6D,KAAK2R,mBAAgC,IAAPxV,OAAgB,EAASA,EAAGoP,MAClFwI,EAA4C,QAA1BN,EAAKzT,KAAK6R,kBAA+B,IAAP4B,OAAgB,EAASA,EAAGlI,MAEtF,GAAKzP,GAAYgY,GAAoBC,EAIrC,GAAI/T,KAAKsR,WAAY,CACnB,MAAM0C,EAAgBvT,EAAIQ,cAAcnF,GAExC,GAAIkY,EAAe,CACjB,MAAMtR,EAAcjC,EAAIgC,eAAe3G,GAEnC4G,IAAgBqR,GAClBtT,EAAI6C,aAAa0Q,EAAeD,EAAgBrR,GAG9CjC,EAAI0C,0BAA0BrH,KAAagY,GAC7CrT,EAAI6C,aAAa0Q,EAAeF,EAAiBhY,EAErD,CACF,KAAO,CACD2E,EAAIsC,oBAAoBjH,KAAaiY,GACvCtT,EAAI4C,YAAYvH,EAASiY,GAG3B,MAAMjR,EAAoBrC,EAAIoC,qBAAqB/G,GAE/CgH,GAAqBA,IAAsBgR,GAAmBhR,EAAkB3B,YAClFV,EAAI6C,aAAaR,EAAkB3B,WAAY2S,EAAiBhR,EAEpE,CACF,EAIF,SAASmR,GAAe1L,GACtB,IAAI/F,EAAY,KAEhB,IAAK,IAAIiH,EAAIhJ,EAAIsC,oBAAoBwF,GAAYkB,EAAGA,EAAIhJ,EAAIsC,oBAAoB0G,GAC9EjH,EAAYiH,EAGd,OAAOjH,QAAalG,CACtB,CAkEA,SAAS4X,GAAcpY,GACrB,IAAIC,EAAII,EAER,MAAMgY,EAAkBrY,EAAQ4H,cAC1B0Q,EAAuD,QAAtCrY,EAAKoY,EAAgBE,mBAAgC,IAAPtY,OAAgB,EAASA,EAAGmX,iBAAiBpX,GAElH,GAA6B,OAAzBA,EAAQwY,cAAyBH,EAAgB/J,OAAStO,GAAsG,WAA1FsY,aAAqD,EAASA,EAAclI,UACpJ,OAAO,EAKT,GAAiG,YAA5FkI,aAAqD,EAASA,EAAcG,YAC/E,OAAO,EAKT,GAA+F,WAA1FH,aAAqD,EAASA,EAAclI,UAAuB,CACtG,GAA8B,SAA1BkI,EAAcI,QAChB,OAAO,EAGT,GAA4F,QAAtD,QAAhCrY,EAAKL,EAAQuF,qBAAkC,IAAPlF,OAAgB,EAASA,EAAGmY,eAA0BH,EAAgB/J,OAAStO,EAAQuF,cACnI,OAAO,CAEX,CAEA,OAAO,CACT,CACA,SAASoT,GAAQ3Y,GACf,MAA2B,UAApBA,EAAQ6S,WAAyB7S,EAAQ+H,MAAyB,UAAjB/H,EAAQ4D,IAClE,CAgCA,SAASqP,GAAuBjT,GAC9B,IAAIC,EAEJ,OAAqG,QAA5FA,EAAKD,aAAyC,EAASA,EAAQ6Q,+BAA4C,IAAP5Q,OAAgB,EAASA,EAAGyK,QAAU,IACrJ,CAMA,SAASkO,GAAoB9J,EAAO+J,GAClC,MAAMjY,EAAOG,KAAK+X,UAAUhK,GAE5B,OAAc,IAAV+J,EACKjY,EAGF,CACL,CAACpC,GAAyBoC,EAE9B,CA+BA,SAASmY,GAAoB/Y,EAASgZ,EAAUC,GAC9C,IAAInK,EAEJ,GAAImK,EAAQ,CACV,MAAMrY,EAAOZ,EAAQS,aAAajC,GAElC,GAAIoC,EACF,IACEkO,EAAQ/N,KAAKC,MAAMJ,EACrB,CAAE,MAAOO,GACH,CAGN,CAEJ,CAEK2N,IACHA,EAAQ,CAAC,GAvCb,SAA2BA,EAAOkK,GAChC,IAAK,MAAMzX,KAAOC,OAAOC,KAAKuX,GAAW,CACvC,MAAME,EAAQF,EAASzX,GAEnB2X,EAEFpK,EAAMvN,GAAO2X,SAENpK,EAAMvN,EAEjB,CACF,CA+BE4X,CAAkBrK,EAAOkK,GAErBxX,OAAOC,KAAKqN,GAAO5L,OAAS,EAC9BlD,EAAQkQ,aAAa1R,EAAwBoa,GAAoB9J,GAAO,IAExE9O,EAAQoZ,gBAAgB5a,EAE5B,CAqBA,MAAM6a,WAAyB3H,GAC7B,WAAA/N,CAAY5D,EAASC,EAASsZ,EAAYvX,GACxC+B,MAAM/D,EAASC,EAASyR,GAAkC1P,OAAKvB,GAAW,GAE1E0D,KAAKqV,mBAAqB7D,IACxB,IAAIzV,EAEJ,GAAIyV,EAAW5F,iBAKb5L,KAAKsV,aAAY,OACZ,CAELtV,KAAK6K,SAAS0K,mBAAmBC,2BAA0B,GAE3D,MAAM1Z,EAAUkE,KAAK8K,SAAStE,MAE9B,GAAI1K,EAAS,CACXkE,KAAKsV,aAAY,GAEjB,MAAMrD,EAAUjS,KAAK6K,SAAS4K,eAAeC,uBAAuBlE,EAAWjF,QAAS,CACtFhE,UAAWzM,EACX6Z,qBAAqB,IAGvB,GAAI1D,EAEF,YADA,QAAYA,EAGhB,CAE4B,QAA3BlW,EAAKyV,EAAWjG,aAA0B,IAAPxP,GAAyBA,EAAG6Z,MAClE,GAGF5V,KAAK8N,aAAa9N,KAAKqV,oBAEvBrV,KAAK6K,SAAWhP,EAChBmE,KAAKsV,YAAcF,CACrB,EAIF,MAAMS,WAAalL,GACjB,WAAAlL,CAAY5D,EAASC,EAASga,EAAWlL,EAAO/M,GAC9C+B,MAAM/D,EAASC,EAAS8O,GACxB5K,KAAK+V,YAAa,EAElB/V,KAAKsV,YAAcU,IACjB,IAAIja,EAQJ,GANIiE,KAAKiW,mBACPjW,KAAK6K,SAAS/F,YAAYgI,aAAa9M,KAAKiW,yBAErCjW,KAAKiW,kBAGVjW,KAAK+V,aAAeC,EACtB,OAGF,MAAMla,EAAUkE,KAAK8K,SAAStE,MAE1B1K,IACEka,GACFhW,KAAK+V,YAAa,EACY,QAA7Bha,EAAKiE,KAAKkW,qBAAkC,IAAPna,GAAyBA,EAAGuS,aAAY,GAC9ExS,EAAQkT,cAAc,IAAIzO,EAAe,CACvCzE,cAGFkE,KAAKiW,iBAAmBjW,KAAK6K,SAAS/F,YAAYgC,YAAW,KAC3D,IAAI/K,SAEGiE,KAAKiW,iBACZjW,KAAK+V,YAAa,EACY,QAA7Bha,EAAKiE,KAAKkW,qBAAkC,IAAPna,GAAyBA,EAAGuS,aAAY,GAC9ExS,EAAQkT,cAAc,IAAIxO,EAAc,CACtC1E,YACC,GACF,GAEP,EAGFkE,KAAK+N,WAAaoI,IAChB,MAAMC,EAAYpW,KAAK6K,SAASuL,UAE1BC,EAAcrW,KAAK8K,SAAStE,MAElC,IAAI8P,EAAaH,EAAMI,eAAe,GAEtC,EAAG,CACD,GAAID,IAAeD,EAGjB,YAFArW,KAAKsV,aAAY,GAKnBgB,EAAaA,GAAcF,EAAUE,EACvC,OAASA,EAAW,EAGtBtW,KAAKgO,YAAc,KACjBhO,KAAKsV,aAAY,EAAM,EAGzBtV,KAAKwW,WAAaV,EAClB,MAAM/Q,EAAMlJ,EAAQiJ,UACpB9E,KAAKgK,IAAMD,GAAchF,EAAKjJ,GAC9BkE,KAAKyW,KAAO5Y,GAERhC,EAAQ6a,YAAc7a,EAAQ8a,kBAChC3W,KAAK4W,iBAGP,MACM9V,EADIiE,IACIL,SACd5D,EAAI4L,iBAAiB,KAAiB1M,KAAK+N,YAC3CjN,EAAI4L,iBAAiB,KAAkB1M,KAAKgO,aAE5ChO,KAAK6W,MACP,CAEA,cAAAD,GACO5W,KAAKkW,gBACRlW,KAAKkW,cAAgB,IAAIf,GAAiBnV,KAAK6K,SAAU7K,KAAK8K,SAAU9K,KAAKsV,YAAatV,KAAKyW,MAEnG,CAEA,OAAAva,GACE,IAAIH,EAEJiE,KAAKwW,WAAWxW,MAEhB,MAAM+E,EAAM/E,KAAK6K,SAAS/F,YAEpBhE,EAAMiE,EAAIL,SAChB5D,EAAIiM,oBAAoB,KAAiB/M,KAAK+N,YAC9CjN,EAAIiM,oBAAoB,KAAkB/M,KAAKgO,aAE3ChO,KAAKiW,mBACPlR,EAAI+H,aAAa9M,KAAKiW,yBACfjW,KAAKiW,kBAGgB,QAA7Bla,EAAKiE,KAAKkW,qBAAkC,IAAPna,GAAyBA,EAAGG,UAElE8D,KAAK8W,SACP,CAEA,wBAAA3I,CAAyBO,EAAYN,GACnC,MAAM2I,EAAe/W,KAAKkW,cAE1B,GAAIa,EACFA,EAAa5I,yBAAyBO,EAAYN,OAC7C,CACL,MAAMvF,EAAK7I,KAAKgL,aAEZnC,GACFsM,GAAiB3G,qBAAqBxO,KAAK6K,SAAUhC,GAAI,EAAM6F,EAAYN,EAE/E,CACF,CAEA,IAAAyI,GACM,CAGN,CAEA,OAAAC,GACM,CAGN,EAIF,MAAME,GACJ,WAAAvX,CAAY5D,EAASob,GACnBjX,KAAKkX,kBAAmB,EACxBlX,KAAKmX,OAAS,CAAC,EACfnX,KAAKoX,aAAc,EACnBpX,KAAKqX,SAAW,CAAC,EAEjBrX,KAAKsX,gBAAkB,KACrB,IAAIvb,EAEJ,MAAM+E,EAAMd,KAAKqQ,OAAO3L,SAElB0F,EAAOtJ,EAAIsJ,KAEjB,GAAIA,EAAM,CACRpK,KAAKuX,gBAAgBzW,GAErB,MAAM8J,EAAQ5K,KAAKwX,UAEnB,GAAI5M,EAKF,OAJAiK,GAAoBzK,EAAM,CACxB5M,KAAMoN,IACL,GACH3O,EAAyB+D,KAAK6K,SAAUT,GACmB,QAAnDrO,EAAKH,EAAoBoE,KAAK6K,SAAUT,UAA0B,IAAPrO,OAAgB,EAASA,EAAGyB,IAEnG,MAAYwC,KAAKkX,mBACflX,KAAKkX,kBAAmB,EACxBpW,EAAI4L,iBAAiB,mBAAoB1M,KAAKsX,iBAGhC,EAGlBtX,KAAKyX,eAAiBja,WACbwC,KAAKmX,OAAO3Z,EAAK4E,GAAG,EAG7BpC,KAAK6K,SAAWhP,EAChBmE,KAAKqQ,KAAOxU,EAAQiJ,UACpB9E,KAAKwX,UAAYP,EACjBpb,EAAQ6b,WAAU,KACZ1X,KAAKwX,WACPxX,KAAKsX,iBACP,GAEJ,CAEA,eAAAC,CAAgBzW,GACdA,EAAIiM,oBAAoB,mBAAoB/M,KAAKsX,iBACjDtX,KAAKkX,kBAAmB,CAC1B,CAEA,OAAAhb,GACE,MAAM6I,EAAM/E,KAAKqQ,OAEjBrQ,KAAKuX,gBAAgBxS,EAAIL,iBAElB1E,KAAKwX,UACZla,OAAOC,KAAKyC,KAAKmX,QAAQQ,SAAQC,IAC3B5X,KAAKmX,OAAOS,KACd5X,KAAKmX,OAAOS,GAAQ1b,iBAEb8D,KAAKmX,OAAOS,GACrB,IAEF5X,KAAKqX,SAAW,CAAC,CACnB,CAEA,UAAApZ,CAAWnC,EAAS8O,EAAO/M,GAGzB,MAAMga,EAAU,IAAIhC,GAAK7V,KAAK6K,SAAU/O,EAASkE,KAAKyX,eAAgB7M,EAAO/M,GAO7E,OANAmC,KAAKmX,OAAOU,EAAQzV,IAAMyV,EAEtB7X,KAAKoX,aACPS,EAAQjB,iBAGHiB,CACT,CAEA,cAAAjB,GACE5W,KAAKoX,aAAc,EACnB,MAAMU,EAAQ9X,KAAKmX,OAEnB,IAAK,MAAM/U,KAAM9E,OAAOC,KAAKua,GAC3BA,EAAM1V,GAAIwU,gBAEd,CAEA,mBAAOmB,CAAajT,EAAW1C,GAC7B,MAAMvG,EAAUiJ,IAAYkT,kBAE5B,OAAOnc,GAAWA,EAAQ2B,KAAK6Z,SAASjV,EAC1C,CAWA,wBAAO6V,CAAkBpc,EAASC,EAASoc,GAKzC,IAAInc,EAAII,EAAIsX,EAAIC,EAEhB,QANgB,IAAZwE,IACFA,EAAU,CAAC,IAKRpc,EAAQ4H,cACX,OAGF,MAAM,SACJyU,EAAQ,iBACRvU,GACEsU,EACE9B,EAAYva,EAAQua,UAK1B,IAAI5Y,EACAU,EACAK,EACAE,EAJJ5C,EAAQuc,iBAKR,IACIC,EACAC,EACAC,EACA3Z,EAJA4Z,GAAoB,EAKpBlC,EAAa1S,GAAoB9H,EACrC,MAAM2c,EAAgB,CAAC,EAEvB,KAAOnC,KAAgB9Y,GAAQ2a,IAAW,CACxC,MAAMjb,EAAmBtB,EAAoBC,EAASya,GAEtD,GAAI6B,QAA+B7b,IAAnBic,EAA8B,CAC5C,MAAMG,EAAMpC,EAAWoC,IAEnBA,IACFH,EAAuC,QAAtBG,EAAIC,cAEzB,CAEA,IAAKzb,EAAkB,CACrBoZ,EAAaF,EAAUE,GACvB,QACF,CAEA,MAAM3H,EAAU2H,EAAW3H,SAEvBzR,EAAiB0B,cAA4B,WAAZ+P,GAAoC,YAAZA,KAC3D/P,EAAe0X,GAGZ7X,KAAgD,QAArC1C,EAAKmB,EAAiBoB,iBAA8B,IAAPvC,OAAgB,EAASA,EAAG6c,mBAAsBra,IAC7Gia,GAAoB,GAGtB,MAAMK,EAAe3b,EAAiBgB,UAChC4a,EAAc5b,EAAiBqB,SAC/Bwa,EAAW7b,EAAiBuB,OAE7BP,GAAa2a,IAChB3a,EAAY2a,GAGTta,IAAYua,GAAiB5a,IAAa2a,IACzC3a,IAEG4a,EAAYE,YAAcF,EAAY7N,WAAWgO,aAAe/a,EAAUgb,UAAyC,QAA5B/c,EAAKN,EAAQqC,iBAA8B,IAAP/B,OAAgB,EAASA,EAAGgd,YAC1Jjb,OAAY5B,EACZiC,EAAWua,GAGbR,EAAsBQ,GAEtBva,EAAWua,GAIVra,IAASsa,GAAc7a,IAAa2a,GAAmBC,GAAexC,IAAexa,IAAYwa,EAAW7U,SAAS3F,KAExH2C,EAAQsa,EACRV,IAAwB9Z,GAAYA,IAAaua,GAG/C5b,EAAiBM,OACnBA,EAAON,EAAiBM,OAGgB,QAArCiW,EAAKvW,EAAiBoB,iBAA8B,IAAPmV,OAAgB,EAASA,EAAGgF,gBAC5Enb,OAAO8b,OAAOX,EAAevb,EAAiBoB,UAAUma,eAG1DnC,EAAaF,EAAUE,EACzB,CAGA,IAAK9Y,EAAM,CACT,MAAM6b,EAAUxd,EAAQ2B,KACP6b,EAAQ7B,YAGc,QAAhC9D,EAAK5X,EAAQ4H,qBAAkC,IAAPgQ,OAAgB,EAASA,EAAGtJ,QACvE5M,EAAO6b,EAAQ/B,kBAGrB,CAEI/Y,IAAaE,IACf4Z,GAAsB,GAWxB,OAAO7a,EAAO,CACZA,OACAU,YACAK,WACAE,QACA4Z,sBACAC,sBACAgB,IAAKnB,IAAaI,OAAiBjc,EACnCsC,eACA4Z,oBACAC,cAZ0BtC,KAAWsC,EAActC,EAAM9Y,WAavDf,CACN,CAEA,cAAOid,CAAQ1d,EAASC,GACtB,IAAIC,EAEJ,MAAMqa,EAAYva,EAAQua,UAE1B,IAAK,IAAIvN,EAAK/M,EAAS+M,EAAIA,EAAKuN,EAAUvN,GAAK,CAC7C,MAAMrL,EAAmD,QAA3CzB,EAAKH,EAAoBC,EAASgN,UAAwB,IAAP9M,OAAgB,EAASA,EAAGyB,KAE7F,GAAIA,EACF,OAAOA,CAEX,CAGF,CAEA,MAAAC,CAAOD,EAAMgc,GACPA,SACKxZ,KAAKqX,SAAS7Z,EAAKwM,KAE1BhK,KAAKqX,SAAS7Z,EAAKwM,KAAOxM,CAE9B,EAu2BF,MAAMic,GACJ,WAAAha,GACEO,KAAK0Z,WAAa,EACpB,CAEA,OAAAxd,GACE8D,KAAK0Z,WAAa,UACX1Z,KAAK2Z,IACd,CAEA,SAAAC,CAAUjZ,GACR,MAAMkZ,EAAY7Z,KAAK0Z,WACTG,EAAUC,QAAQnZ,GAEpB,GACVkZ,EAAUxT,KAAK1F,EAEnB,CAEA,cAAAoZ,CAAepZ,GACb,MAAMkZ,EAAY7Z,KAAK0Z,WACjBM,EAAQH,EAAUC,QAAQnZ,GAE5BqZ,GAAS,GACXH,EAAUI,OAAOD,EAAO,GAG1BH,EAAUK,QAAQvZ,EACpB,CAEA,WAAAwZ,CAAYxZ,GACV,MAAMqZ,EAAQha,KAAK0Z,WAAWI,QAAQnZ,GAElCqZ,GAAS,GACXha,KAAK0Z,WAAWO,OAAOD,EAAO,EAElC,CAEA,MAAAI,CAAOC,EAAK1a,GACNK,KAAK2Z,OAASU,IAIlBra,KAAK2Z,KAAOU,EAEZra,KAAKsa,eAAeD,EAAK1a,GAC3B,CAEA,MAAA4a,GACE,OAAOva,KAAK2Z,IACd,CAEA,OAAAa,CAAQH,EAAK1a,GACXK,KAAKsa,eAAeD,EAAK1a,EAC3B,CAEA,cAAA2a,CAAeD,EAAK1a,GAClBK,KAAK0Z,WAAW/B,SAAQhX,GAAYA,EAAS0Z,EAAK1a,IACpD,EAsoCF,MAAM8a,GACJ,WAAAhb,CAAY5D,GACVmE,KAAK6K,SAAWhP,CAClB,CAEA,OAAAK,GAEA,CAEA,QAAA+O,CAASnP,GACP,MAAMoB,EAAmBtB,EAAoBoE,KAAK6K,SAAU/O,GAC5D,OAAOoB,GAAoBA,EAAiBoB,WAAa,CAAC,CAC5D,CAEA,WAAAwQ,CAAYjG,EAAI6R,EAAkCC,EAAgBC,GAChE,SAAIvQ,GAAgBxB,EAAIrO,KAAwBkgB,IAAqD,IAAjB7R,EAAGkD,aAC7E4O,GAAkB3a,KAAK6a,UAAUhS,MAAS+R,GAAqB5a,KAAK8a,aAAajS,IAI7F,CAEA,SAAAgS,CAAUhS,GACR,IAAKA,EAAGnF,eAAiBmF,EAAG5B,WAAaC,KAAKC,aAC5C,OAAO,EAGT,GAAI+M,GAAcrL,GAChB,OAAO,EAGT,MAAMrB,EAAOqB,EAAGnF,cAAc0G,KAAKtC,wBAEnC,OAAmB,IAAfN,EAAKrD,OAA+B,IAAhBqD,EAAKpD,MAM/B,CAEA,YAAA0W,CAAajS,GACX,IAAI9M,EAEJ,IAAK,IAAIkB,EAAI4L,EAAI5L,EAAGA,EAAIwD,EAAIW,iBAAiBnE,GAAI,CAC/C,MAAMC,EAAmBtB,EAAoBoE,KAAK6K,SAAU5N,GAE5D,GAAI+C,KAAK+a,UAAU9d,GACjB,OAAO,EAKT,KAFiI,QAAzGlB,EAAKmB,aAA2D,EAASA,EAAiBoB,iBAA8B,IAAPvC,OAAgB,EAASA,EAAGif,qBAE9Ihb,KAAKib,YAAYhe,GACtC,OAAO,CAEX,CAEA,OAAO,CACT,CAEA,WAAAge,CAAYpS,GACV,OAAOA,EAAGqS,aAAa,WACzB,CAEA,SAAAH,CAAUlS,GACR,IAAI9M,EAEJ,MAAMof,EAAUtS,EAAGtM,aAAa,eAEhC,SAAI4e,GAAqC,SAA1BA,EAAQxC,gBACoB,QAAlC5c,EAAKiE,KAAK6K,SAAS3M,iBAA8B,IAAPnC,OAAgB,EAASA,EAAGqf,YAAYvS,IAM7F,CAEA,SAAAwS,CAAUnD,EAASoD,GACjB,OAAOtb,KAAKub,YAAY,IAAKrD,GAC1BoD,EACL,CAEA,QAAAE,CAAStD,EAASoD,GAChB,OAAOtb,KAAKub,YAAY,CACtB7M,YAAY,KACTwJ,GACFoD,EACL,CAEA,QAAAG,CAASvD,EAASoD,GAChB,OAAOtb,KAAKub,YAAY,IAAKrD,GAC1BoD,EACL,CAEA,QAAAI,CAASxD,EAASoD,GAChB,OAAOtb,KAAKub,YAAY,IAAKrD,EAC3BxJ,YAAY,GACX4M,EACL,CAEA,WAAAK,CAAYzD,EAASoD,GACnB,OAAOtb,KAAKub,YAAY,IAAKrD,EAC3B0D,gBAAiB/S,GAAM7I,KAAK8O,YAAYjG,EAAIqP,EAAQwC,qCAAuC1a,KAAKiL,SAASpC,GAAIgT,WAC5GP,IAAQ,IACb,CAEA,OAAAQ,CAAQ5D,GACN,OAAOlY,KAAK+b,eAAc,EAAM7D,IAAY,EAC9C,CAEA,WAAAqD,CAAYrD,EAASoD,GACnB,MAAMU,EAAQhc,KAAK+b,eAAc,EAAO7D,EAASoD,GAEjD,OAAOU,EAAQA,EAAM,GAAKA,CAC5B,CAEA,aAAAD,CAAcE,EAAW/D,EAASoD,GAChC,IAAIvf,EAAII,EAAIsX,EAEZ,MAAM,UACJlL,EAAS,eACT2T,EAAiB,KAAI,iCACrBxB,EAAgC,mBAChCyB,EAAkB,oBAClBxG,EAAmB,YACnByG,EAAW,WACX1N,EAAU,UACV2N,GACEnE,EAECoD,IACHA,EAAM,CAAC,GAGT,MAAMgB,EAAW,GACjB,IAAI,gBACFV,GACE1D,EACJ,MAAMqE,IAAuBX,EAE7B,IAAKrT,EACH,OAAO,KAGJqT,IACHA,EAAkB/S,GAAM7I,KAAK8O,YAAYjG,EAAI6R,GAAkC,EAAO/E,IAGxF,MAAM6G,EAAqB,CACzBjU,YACAkU,qBAAiCngB,IAAhB8f,GAA6BD,EAAwD,QAAlCpgB,EAAKiE,KAAK6K,SAAS3M,iBAA8B,IAAPnC,OAAgB,EAASA,EAAGod,SAAWiD,IAAwI,QAAvH3I,EAAoE,QAA9DtX,EAAK6a,GAAQiB,kBAAkBjY,KAAK6K,SAAUtC,UAA+B,IAAPpM,OAAgB,EAASA,EAAG+B,iBAA8B,IAAPuV,OAAgB,EAASA,EAAGyF,QACjUvG,KAAMuJ,GAAkB3T,EACxBmG,aACAuN,YACAL,kBACAW,qBACA7B,mCACA/E,sBACA+G,gBAAiB,CAAC,EAClBC,kBAAmB,CAAC,GAEhBC,EAAS7V,EAAwBwB,EAAU7E,cAAe6E,GAAWrH,GAAQlB,KAAK6c,eAAe3b,EAAMsb,KAE7G,IAAKI,EACH,OAAO,KAGT,MAAME,EAAwBC,IAC5B,IAAIhhB,EAAII,EAER,MAAM6gB,EAA0D,QAA1CjhB,EAAKygB,EAAmBQ,oBAAiC,IAAPjhB,EAAgBA,EAAKygB,EAAmBS,cAMhH,OAJID,GACFV,EAASjW,KAAK2W,GAGZf,IACEe,IACFR,EAAmBR,OAAQ,SACpBQ,EAAmBQ,oBACnBR,EAAmBS,qBACnBT,EAAmBU,QAC1BV,EAAmB7J,KAAOqK,EAEtBX,IAAcA,EAAUW,SAKpBA,IAAgBD,IAEtBC,GAAgB1B,IAClBA,EAAI1c,aAAiF,QAAjEzC,EAAK6a,GAAQiB,kBAAkBjY,KAAK6K,SAAUmS,UAAkC,IAAP7gB,OAAgB,EAASA,EAAGyC,iBAGjHme,GAA6BC,GACzC,EAOF,GAJKd,IACHZ,EAAI6B,eAAgB,GAGlBjB,GAAkBzb,EAAIa,aAAaiH,EAAW2T,GAChDU,EAAOQ,YAAclB,OAChB,GAAIxN,EAAY,CACrB,MAAMlM,EAAYyR,GAAe1L,GAEjC,IAAK/F,EACH,OAAO,KAGT,GAAIxC,KAAK6c,eAAera,EAAWga,KAAwB7X,WAAW0Y,gBAAkBP,GAAsB,GAK5G,OAJIN,EAAmBc,mBACrBhC,EAAI6B,eAAgB,GAGfb,EAGTM,EAAOQ,YAAc5a,CACvB,CAEA,GACMkM,EACFkO,EAAOW,eAEPX,EAAOY,iBAEFV,KAMT,OAJIN,EAAmBc,mBACrBhC,EAAI6B,eAAgB,GAGfb,EAAStd,OAASsd,EAAW,IACtC,CAEA,cAAAO,CAAe/gB,EAAS2hB,GACtB,IAAI1hB,EAAII,EAAIsX,EAEZ,GAAIgK,EAAMzB,MACR,OAAOrX,WAAW0Y,cAGpB,MAAMJ,EAAgBQ,EAAMR,cAE5B,GAAIA,IAAkBnhB,IAAYmhB,IAAkBxc,EAAIa,aAAa2b,EAAenhB,IAGlF,OAFA2hB,EAAMzB,OAAQ,EACdyB,EAAMT,aAAeC,EACdtY,WAAW0Y,cAGpB,MAAM9U,EAAYkV,EAAMlV,UAExB,GAAIzM,IAAYyM,EACd,OAAO5D,WAAW+Y,YAGpB,IAAKjd,EAAIa,aAAaiH,EAAWzM,GAC/B,OAAO6I,WAAWgZ,cAGpB,GAAI5O,GAAuBjT,GACzB,OAAO6I,WAAWgZ,cAGpB,GAAIld,EAAIa,aAAamc,EAAMG,mBAAoB9hB,GAC7C,OAAO6I,WAAWgZ,cAGpB,MAAM3Y,EAAMyY,EAAMI,WAAa7G,GAAQiB,kBAAkBjY,KAAK6K,SAAU/O,GAExE,IAAKkJ,EACH,OAAOL,WAAW+Y,YAGpB,GAAI1U,GAAkBlN,GAKpB,OAJIkE,KAAK8O,YAAYhT,OAASQ,GAAW,GAAM,KAC7CmhB,EAAMH,kBAAmB,GAGpB3Y,WAAW+Y,YAMpB,IAAKD,EAAMlB,qBAA2C,WAApBzgB,EAAQ6S,SAA4C,YAApB7S,EAAQ6S,SACxE,OAA8B,QAAxB5S,EAAKiJ,EAAI9G,iBAA8B,IAAPnC,OAAgB,EAASA,EAAGmd,WAAgD,QAAlC/c,EAAK6D,KAAK6K,SAAS3M,iBAA8B,IAAP/B,OAAgB,EAASA,EAAGgd,WACpJsE,EAAMzB,OAAQ,EACdyB,EAAMG,mBAAqBH,EAAMT,aAAelhB,EACzC6I,WAAW0Y,eAEX1Y,WAAWgZ,cAItB,IAAKF,EAAM9H,sBAAwB3V,KAAK8a,aAAahf,GAKnD,OAJIkE,KAAK8O,YAAYhT,GAAS,GAAO,GAAM,KACzC2hB,EAAMH,kBAAmB,GAGpB3Y,WAAWgZ,cAGpB,IAAIG,EACAZ,EAAUO,EAAMP,QAEfA,IACHA,EAAUO,EAAMP,QAAUlG,GAAQiB,kBAAkBjY,KAAK6K,SAAU4S,EAAM9K,OAG3E,MAAMoL,EAAYb,aAAyC,EAASA,EAAQze,MAC5E,IAAIF,EAAWyG,EAAIzG,SACfE,EAAQuG,EAAIvG,MAOhB,GANAqf,EAA4C,QAAlCrK,EAAKzT,KAAK6K,SAAS3M,iBAA8B,IAAPuV,OAAgB,EAASA,EAAGuK,cAAcliB,EAAS2hB,QAExFnhB,IAAXwhB,IACFL,EAAMH,kBAAmB,QAGZhhB,IAAXwhB,IAAyBvf,GAAYE,GAASsf,GAAY,CAC5D,MAAME,EAAkB1f,aAA2C,EAASA,EAASyM,aAC/EkT,EAAmBH,aAA6C,EAASA,EAAU/S,aACzF,IAAImT,EAAe1f,aAAqC,EAASA,EAAMuM,aAEnEmT,GAAgB1d,EAAIa,aAAa4c,EAAkBC,IAAiB1d,EAAIa,aAAaiH,EAAW2V,MAAuBD,IAAoBxf,GAASgC,EAAIa,aAAa4c,EAAkBD,MACzLxf,EAAQsf,EACRI,EAAeD,IAGbD,GAAoBA,IAAoB1V,GAAc9H,EAAIa,aAAaiH,EAAW0V,KACpF1f,OAAWjC,GAGT6hB,IAAiB1d,EAAIa,aAAaiH,EAAW4V,KAC/C1f,OAAQnC,GAGNiC,GAAYE,IACV0f,GAAgBF,IAAoBxd,EAAIa,aAAa2c,EAAiBE,GACxE1f,OAAQnC,EAERiC,OAAWjC,GAIXiC,IACFuf,EAASvf,EAASyf,cAAcliB,EAAS2hB,IAGvChf,IACFqf,EAASrf,EAAMuf,cAAcliB,EAAS2hB,GAE1C,CAUA,QARenhB,IAAXwhB,IACFA,EAASL,EAAM7B,gBAAgB9f,GAAW6I,WAAW0Y,cAAgB1Y,WAAW+Y,YAE5EI,IAAWnZ,WAAW+Y,aAAe1d,KAAK8O,YAAYhT,GAAS,GAAO,GAAM,KAC9E2hB,EAAMH,kBAAmB,IAIzBQ,IAAWnZ,WAAW0Y,gBAAkBI,EAAMzB,MAAO,CACvD,IAAKyB,EAAMxB,WAAaxH,GAAQ3Y,KAAaA,EAAQsiB,QAAS,CAE5D,MAAMC,EAAiBviB,EAAQ+H,KAC/B,IAAIya,EAAab,EAAMd,kBAAkB0B,GAUzC,GARKC,IACHA,EA59FV,SAA6BxiB,GAC3B,IAAK2Y,GAAQ3Y,GACX,OAGF,MAAM+H,EAAO/H,EAAQ+H,KACrB,IACIua,EADAG,EAAexc,MAAM4Q,KAAKlS,EAAIkD,kBAAkB7H,EAAS+H,IAa7D,OAXA0a,EAAeA,EAAavd,QAAO6H,KAC7B4L,GAAQ5L,KACNA,EAAGuV,UACLA,EAAUvV,IAGL,KAKJ,CACLhF,OACA2a,QAAS,IAAI9O,IAAI6O,GACjBH,UAEJ,CAo8FuBK,CAAoB3iB,GAE7BwiB,IACFb,EAAMd,kBAAkB0B,GAAkBC,KAIzCA,aAA+C,EAASA,EAAWF,UAAYE,EAAWF,UAAYtiB,EAEzG,OAAO6I,WAAW+Y,WAEtB,CAEID,EAAM/O,YAIR+O,EAAMR,cAAgBnhB,EACtBgiB,EAASnZ,WAAW+Y,cAEpBD,EAAMzB,OAAQ,EACdyB,EAAMT,aAAelhB,EAEzB,CAEA,OAAOgiB,CACT,EAQF,MAAMY,GACC,MADDA,GAEG,QAFHA,GAGI,SAHJA,GAKI,SALJA,GAMM,WANNA,GAOC,MAPDA,GAQE,OARFA,GASO,YATPA,GAUK,UAVLA,GAWQ,aAXRA,GAYO,YA2Bb,MAAMC,GAAmC,CACvC,CAACjkB,GAA6B,EAC9B,CAACA,GAA4B,EAC7B,CAACA,GAAmC,GAEtC,MAAMkkB,WAA4BnF,GAChC,WAAAha,CAAY5D,EAASiJ,GACnBlF,QAEAI,KAAK6e,MAAQ,KACX,MAAM9Z,EAAM/E,KAAKqQ,OAEXvP,EAAMiE,EAAIL,SAEhB5D,EAAI4L,iBAAiB,KAAiB1M,KAAK+N,YAAY,GACvDjN,EAAI4L,iBAAiB,KAAkB1M,KAAKgO,aAAa,GACzDjJ,EAAI2H,iBAAiB,UAAW1M,KAAK8e,YAAY,GACjD,MAAMnd,EAAgBlB,EAAIiB,iBAAiBZ,GAEvCa,GAAiBA,IAAkBb,EAAIsJ,MACzCpK,KAAK+e,mBAAmBpd,GAG1B3B,KAAK4Z,UAAU5Z,KAAKgf,WAAW,EAGjChf,KAAK+N,WAAa9Q,IAChB,MAAM0I,EAAS1I,EAAEsZ,eAAe,GAE5B5Q,GACF3F,KAAK+e,mBAAmBpZ,EAAQ1I,EAAE0C,OAAO8L,cAAexO,EAAE0C,OAAOsf,0BACnE,EAGFjf,KAAKgO,YAAc/Q,IACjB,IAAIlB,EAEJiE,KAAK+e,wBAAmBziB,EAA+B,QAAnBP,EAAKkB,EAAE0C,cAA2B,IAAP5D,OAAgB,EAASA,EAAGmjB,cAAczT,cAAc,EAIzHzL,KAAKmf,wBAA0BrjB,MAG/BkE,KAAK8e,WAAa3I,IAChB,GAAIA,EAAM9Y,MAAQqhB,IAAYvI,EAAMiJ,QAClC,OAGF,MAAMlD,EAAiBlc,KAAKua,SAE5B,IAAK2B,IAAmBA,EAAexY,eAAoD,SAAnCwY,EAAemD,gBACrE,OAGF,MAAMxjB,EAAUmE,KAAK6K,SACf6L,EAAa7a,EAAQ6a,WACrB1R,EAAMgS,GAAQiB,kBAAkBpc,EAASqgB,GAE/C,IAAKlX,GAAOA,EAAIyT,cAActC,GAC5B,OAGF,MAAMzH,EAAayH,EAAMmJ,SACnBnQ,EAAOyP,GAAoBW,iBAAiB1jB,EAASmJ,OAAK1I,EAAW4f,OAAgB5f,EAAWoS,GAAY,GAC5G2H,EAAcrR,EAAIxH,KAAKwN,aAE7B,IAAKqL,EACH,OAGF,MAAMmJ,EAAcrQ,aAAmC,EAASA,EAAKrT,QAC/D2jB,EA3FZ,SAA4C5jB,EAASC,GACnD,IAAIC,EAEJ,MAAMqa,EAAYva,EAAQua,UAC1B,IAAIvN,EAAK/M,EAET,EAAG,CACD,MAAM4jB,EAAoE,QAA3C3jB,EAAKH,EAAoBC,EAASgN,UAAwB,IAAP9M,OAAgB,EAASA,EAAG6C,aAE9G,GAAI8gB,GAAyB7jB,EAAQ+C,aAAa+gB,yBAAyB9W,IAAM6W,EAAsBE,YACrG,OAAO/W,EAGTA,EAAKuN,EAAUvN,EACjB,OAASA,EAGX,CA0E8CgX,CAAmChkB,EAASqgB,GAEpF,GAAIsD,EAAa,CACf,MAAMM,EAAmB3Q,EAAKvQ,aAE9B,GAAIoG,EAAIpG,cAAgB6B,EAAIa,aAAawe,EAAkB5D,GAAiB,CAC1E,IAAK/M,EAAKgO,eAAiB2C,IAAqB9a,EAAIpG,cAAgB6gB,IAAoChf,EAAIa,aAAame,EAAiCD,GAGxJ,OASF,YADAhS,GAAkB4B,0BAA0BvT,EAASqgB,EAAgBxN,EAAY8Q,EAEnF,CAEA,GAAIM,GAA4C,WAAxBN,EAAY7Q,QAYlC,YATI0H,EAAYrH,cAAc,IAAI5O,EAAsB,CACtD6O,GAAI,OACJC,MAAOmH,EACPlH,KAAMqQ,EACNpR,aAAc+H,MAEd3I,GAAkBgB,qBAAqBxO,KAAK6K,SAAUiV,QAA2DA,EAAmBN,GAAa,EAAO9Q,EAAYyH,KAMpKO,IAAevH,aAAmC,EAASA,EAAKgO,iBAC9D9G,EAAYrH,cAAc,IAAI5O,EAAsB,CACtD6O,GAAI,OACJC,MAAOmH,EACPlH,KAAMqQ,EACNpR,aAAc+H,OAEdA,EAAM4J,iBACN5J,EAAM6J,4BACN,QAAYR,GAGlB,MACOC,GAAmCpJ,EAAYrH,cAAc,IAAI5O,EAAsB,CAC1F6O,GAAI,OACJC,MAAOmH,EACPlH,KAAM,KACNf,aAAc+H,MAEdnR,EAAIxH,KAAK2Q,yBAAyBO,EAAYyH,EAElD,EAGFnW,KAAKgf,WAAa,CAACljB,EAAS6D,KAC1B,IAAI5D,EAAII,EAER,GAAIL,EACFA,EAAQkT,cAAc,IAAI9O,EAAoBP,QACzC,CACL,MAAMiS,EAAgC,QAAxB7V,EAAKiE,KAAKigB,gBAA6B,IAAPlkB,OAAgB,EAASA,EAAGyK,MAE1E,GAAIoL,EAAM,CACR,MAAMsO,EAAI,IAAKvgB,GAETwgB,EAAUnJ,GAAQiB,kBAAkBjY,KAAK6K,SAAU+G,GACnDwK,EAA6F,QAA9EjgB,EAAKgkB,aAAyC,EAASA,EAAQjiB,iBAA8B,IAAP/B,OAAgB,EAASA,EAAG+c,OAEnIkD,IACF8D,EAAE9D,YAAcA,GAGlBxK,EAAK5C,cAAc,IAAI7O,EAAqB+f,GAC9C,CACF,GAGFlgB,KAAK6K,SAAWhP,EAChBmE,KAAKqQ,KAAOvL,EACZjJ,EAAQ6b,UAAU1X,KAAK6e,MACzB,CAEA,OAAA3iB,GACE0D,MAAM1D,UAEN,MAAM6I,EAAM/E,KAAKqQ,OAEXvP,EAAMiE,EAAIL,SAChB5D,EAAIiM,oBAAoB,KAAiB/M,KAAK+N,YAAY,GAC1DjN,EAAIiM,oBAAoB,KAAkB/M,KAAKgO,aAAa,GAC5DjJ,EAAIgI,oBAAoB,UAAW/M,KAAK8e,YAAY,GACpD9e,KAAKma,YAAYna,KAAKgf,YACtB,MAAMoB,EAAapgB,KAAKqgB,YAEpBD,IACFrb,EAAI+H,aAAasT,EAAWE,gBACrBtgB,KAAKqgB,oBAGPzB,GAAoB2B,yBACpBvgB,KAAKwgB,gBACLxgB,KAAKigB,QACd,CAEA,sBAAOQ,CAAgBrN,EAAU7R,GAC/B,IAAIxF,EAAII,EAER,IAAIgO,EAAMyU,GAAoB2B,kBAC1B1X,EAAKsB,GAAOA,EAAI3D,MAEhBqC,GAAMpI,EAAIa,aAAaC,EAAQsH,WAC1B+V,GAAoB2B,kBAG7B1X,EAAyF,QAAnF1M,EAAkC,QAA5BJ,EAAKqX,EAASoN,gBAA6B,IAAPzkB,OAAgB,EAASA,EAAGD,eAA4B,IAAPK,OAAgB,EAASA,EAAGqK,MAEzHqC,GAAMpI,EAAIa,aAAaC,EAAQsH,WAC1BuK,EAASoN,SAGlBrW,EAAMiJ,EAAS6M,SACfpX,EAAKsB,GAAOA,EAAI3D,MAEZqC,GAAMpI,EAAIa,aAAaC,EAAQsH,WAC1BuK,EAAS6M,QAEpB,CAEA,iBAAAS,GACE,OAAO1gB,KAAKua,QACd,CAEA,qBAAAoG,GACE,IAAI5kB,EAEJ,IAAI8M,EAA8B,QAAxB9M,EAAKiE,KAAKigB,gBAA6B,IAAPlkB,OAAgB,EAASA,EAAGyK,MAMtE,QAJKqC,GAAMA,IAAO5C,GAAiB4C,EAAGnF,cAAemF,MACnD7I,KAAKigB,SAAWpX,OAAKvM,GAGhBuM,CACT,CAEA,KAAA+X,CAAM9kB,EAAS+kB,EAA+BjG,EAAmBkG,GAC/D,QAAK9gB,KAAK6K,SAASvM,UAAUwQ,YAAYhT,EAAS+kB,GAA+B,EAAOjG,KAIxF9e,EAAQ8kB,MAAM,CACZE,mBAEK,EACT,CAEA,YAAAC,CAAaxY,GACX,MAAMM,EAAK7I,KAAK6K,SAASvM,UAAUqd,YAAY,CAC7CpT,cAGF,QAAIM,IACF7I,KAAK6K,SAAS4K,eAAemL,MAAM/X,IAE5B,EAIX,CAEA,sBAAA6M,CAAuBnJ,EAAS3B,GAC9B,IAAI7O,EAEJ,MAAM,UACJwM,EAAS,oBACToN,GACE/K,EACJ,IAAIqH,EAEJ,GAAI1J,EAAW,CACb,MAAMvD,EAAMgS,GAAQiB,kBAAkBjY,KAAK6K,SAAUtC,GAEjDvD,IACFiN,EAA8I,QAAnIlW,EAAK6iB,GAAoBW,iBAAiBvf,KAAK6K,SAAU7F,EAAKuD,OAAWjM,OAAWA,GAAYiQ,EAASoJ,UAAyC,IAAP5Z,OAAgB,EAASA,EAAGD,QAEtL,CAMA,OAJImW,IAAYxR,EAAIa,aAAaiH,EAAW0J,KAC1CA,OAAU3V,GAGL2V,QAAW3V,CACpB,CAEA,iBAAA0kB,CAAkBzU,EAAS3B,GACzB,MAAMqH,EAAUjS,KAAK0V,uBAAuBnJ,EAAS3B,GAErD,QAAIqH,IACFjS,KAAK4gB,MAAM3O,GAAS,GAAO,IACpB,EAIX,CAEA,UAAAgP,CAAWrW,GACT,OAAO5K,KAAKghB,mBAAkB,EAAMpW,EACtC,CAEA,SAAAsW,CAAUtW,GACR,OAAO5K,KAAKghB,mBAAkB,EAAOpW,EACvC,CAEA,UAAAuW,CAAW5Y,GACT,IAAKvI,KAAK6K,SAASvM,UAAUuc,UAAUtS,GACrC,OAAO,EAGT,GAAKvI,KAAK6K,SAASvM,UAAUwQ,YAAYvG,GAAW,GAAM,GAAM,GAY9DvI,KAAK4gB,MAAMrY,OAZ0D,CACrE,MAAM6Y,EAAe7Y,EAAUhM,aAAa,YACtC8kB,EAAiB9Y,EAAUhM,aAAa,eAC9CgM,EAAUwD,UAAY,EACtBxD,EAAUyD,aAAa,cAAe,QACtC4S,GAAoB2B,kBAAoB,IAAIra,EAAgBlG,KAAKqQ,KAAM9H,GACvEvI,KAAK4gB,MAAMrY,GAAW,GAAM,GAE5BvI,KAAKshB,sBAAsB/Y,EAAW,WAAY6Y,GAElDphB,KAAKshB,sBAAsB/Y,EAAW,cAAe8Y,EACvD,CAIA,OAAO,CACT,CAEA,iBAAAE,CAAkBC,EAAQ7gB,EAAU8gB,GAClC,MAAM1c,EAAM/E,KAAK6K,SAAS/F,YAEpB4c,EAAoB1hB,KAAKqgB,YAE/B,GAAIqB,EAAmB,CACrB,GAAI/C,GAAiC6C,GAAU7C,GAAiC+C,EAAkBF,QAEhG,OAIFzc,EAAI+H,aAAa4U,EAAkBpB,QACrC,CAEAtgB,KAAKqgB,YAAc,CACjBmB,SACA7gB,WACA2f,QAASvb,EAAI+B,YAAW,KACtB9G,KAAKqgB,iBAAc/jB,EACnBqE,GAAU,GACT8gB,GAEP,CAEA,gBAAAE,CAAiBH,GACf,MAAMpB,EAAapgB,KAAKqgB,aAEnBD,aAA+C,EAASA,EAAWoB,UAAYA,IAClFxhB,KAAK6K,SAAS/F,YAAYgI,aAAasT,EAAWE,SAElDtgB,KAAKqgB,iBAAc/jB,EAEvB,CAEA,qBAAAglB,CAAsBxlB,EAAS+H,EAAMmR,GACrB,OAAVA,EACFlZ,EAAQoZ,gBAAgBrR,GAExB/H,EAAQkQ,aAAanI,EAAMmR,EAE/B,CAEA,kBAAA+J,CAAmBjjB,EAAS2P,EAAewT,GACzC,IAAIljB,EAAII,EAER,GAAI6D,KAAK6K,SAASxO,MAChB,OAGF,MAAMsD,EAAS,CACb8L,iBAGF,GAAI3P,EAAS,CACX,MAAM8lB,EAAoE,QAAhD7lB,EAAK6iB,GAAoB2B,yBAAsC,IAAPxkB,OAAgB,EAASA,EAAGyK,MAG9G,GAFAoY,GAAoB2B,uBAAoBjkB,EAEpCslB,IAAqB9lB,GAAWkN,GAAkBlN,GACpD,OAGF6D,EAAOsf,0BAA4BA,EACnC,MAAMja,EAAMgS,GAAQiB,kBAAkBjY,KAAK6K,SAAU/O,GAC/CsgB,EAAiF,QAAlEjgB,EAAK6I,aAAiC,EAASA,EAAI9G,iBAA8B,IAAP/B,OAAgB,EAASA,EAAG+c,OAEvHkD,IACFzc,EAAOyc,YAAcA,EAEzB,CAEA,MAAMyF,EAAU7hB,KAAKwgB,SAAW,CAC9B1kB,QAASA,EAAU,IAAIoK,EAAgBlG,KAAKqQ,KAAMvU,QAAWQ,EAC7DqD,UAGE7D,GAAWA,IAAYkE,KAAK2Z,MAC9B3Z,KAAKmf,wBAAwBrjB,GAK3BkE,KAAKwgB,WAAaqB,GACpB7hB,KAAKoa,OAAOte,EAAS6D,GAGvBK,KAAKwgB,cAAWlkB,CAClB,CAEA,MAAA8d,CAAOC,EAAK1a,GACVC,MAAMwa,OAAOC,EAAK1a,GAEd0a,IACFra,KAAKigB,SAAW,IAAI/Z,EAAgBlG,KAAKqQ,KAAMgK,GAEnD,CAEA,uBAAOkF,CAAiB1jB,EAASmJ,EAAKuD,EAAW2T,EAAgBtY,EAAkB8K,EAAYiH,GAC7F,MAAMmM,EAAkBvZ,GAAavD,EAAIxH,KAAKwN,aAE9C,IAAK8W,EACH,OAAO,KAGT,IAAI3S,EAAO,KACX,MAAM4S,EAAiBnD,GAAoBoD,gBACrCjd,EAAMlJ,EAAQiJ,YAEhBid,GACFhd,EAAI+H,aAAaiV,GAGnBnD,GAAoBqD,WAAY,EAChCrD,GAAoBoD,gBAAkBjd,EAAI+B,YAAW,YAC5C8X,GAAoBoD,gBAC3BpD,GAAoBqD,WAAY,CAAK,GACpC,GACH,MAAM/jB,EAAY8G,EAAI9G,UAChBK,EAAWyG,EAAIzG,SACfE,EAAQuG,EAAIvG,MAEZyjB,EAAeC,IAGnB,GAFAhT,EAAOgT,EAAK5C,iBAAiBrD,EAAgBtY,EAAkB8K,EAAYiH,GAEvEuG,KAAoB/M,aAAmC,EAASA,EAAKrT,SAAU,CACjF,MAAMuF,EAAgB8gB,IAASjkB,GAAauC,EAAIW,iBAAiB+gB,EAAKnX,cAEtE,GAAI3J,EAAe,CACjB,MAAM+gB,EAAYpL,GAAQiB,kBAAkBpc,EAASqgB,EAAgB,CACnEtY,iBAAkBvC,IAGpB,GAAI+gB,EAAW,CACb,MAAMC,EAAsBF,EAAKnX,aAC3BsX,EAAa5T,EAAa2T,EAAsBA,GAAuBpO,GAAeoO,IAAwBA,EAEhHC,IACFnT,EAAOyP,GAAoBW,iBAAiB1jB,EAASumB,EAAW7Z,EAAW+Z,EAAYjhB,EAAeqN,EAAYiH,GAE9GxG,IACFA,EAAKgO,eAAgB,GAG3B,CACF,CACF,GAGF,GAAI5e,GAAYE,EACdyjB,EAAald,EAAIqT,oBAAsB9Z,EAAWE,QAC7C,GAAIF,EACT2jB,EAAa3jB,QACR,GAAIE,EACTyjB,EAAazjB,QACR,GAAIP,EACTgkB,EAAahkB,OACR,CACL,MAAMqkB,EAAY,CAChBha,UAAWuZ,EACX5F,iBACAtY,mBACA+R,sBACAwG,oBAAoB,GAEhBqG,EAAe,CAAC,EAChBhD,EAAc3jB,EAAQyC,UAAUoQ,EAAa,WAAa,YAAY6T,EAAWC,GACvFrT,EAAO,CACLrT,QAAS0jB,EACTrC,cAAeqF,EAAarF,cAC5Bve,aAAc4jB,EAAa5jB,aAE/B,CAEA,OAAOuQ,CACT,EAGFyP,GAAoBqD,WAAY,EAOhC,MAAMQ,WAA6BjV,GACjC,WAAA/N,CAAY3D,EAASyC,EAAU1C,EAASgC,GACtC+B,MAAM/D,EAASC,EAASyR,GAAsC1P,GAAK,GAEnEmC,KAAK8N,cAAa,CAAC0D,EAAY9C,EAAYjD,KACzC,IAAI1P,EAAII,EAER,MAAMoM,EAAYzM,EAAQ0K,MACpB+E,EAAQiG,EAAWjG,MAEzB,GAAIhD,GAAagD,EAAO,CACtB,MAAMvG,EAAMgS,GAAQiB,kBAAkBpc,EAAS0P,GAE/C,GAAIvG,EAAK,CACP,IAAImK,EACJA,EAAqG,QAA7FpT,EAAKwC,EAASghB,iBAAiB9T,QAAiBnP,OAAWA,EAAWoS,GAAY,UAA0B,IAAP3S,OAAgB,EAASA,EAAGD,QAEpIqT,IACHA,EAAwL,QAAhLhT,EAAKyiB,GAAoBW,iBAAiB1jB,EAASmJ,OAAK1I,EAAWkV,EAAWrG,UAAYI,EA1oH9G,SAA4BoH,EAAM+P,GAChC,IAAIC,EAAMhQ,EACNiQ,EAAW,KAEf,KAAOD,IAAQC,GACbA,EAAWF,EAAOjiB,EAAI0C,0BAA0Bwf,GAAOliB,EAAIwC,sBAAsB0f,GACjFA,EAAMliB,EAAIW,iBAAiBuhB,GAG7B,OAAOC,QAAYtmB,CACrB,CAgoHsHumB,CAAmBta,GAAYmG,QAAapS,EAAWoS,GAAY,UAA0B,IAAPvS,OAAgB,EAASA,EAAGL,SAG1NqT,IACF,QAAYA,EAEhB,CACF,IAEJ,EAIF,MAAM2T,WAAiBnY,GACrB,WAAAlL,CAAY5D,EAASC,EAASga,EAAWlL,EAAO/M,GAC9C+B,MAAM/D,EAASC,EAAS8O,GACxB5K,KAAK+iB,kBAAmB,EACxB/iB,KAAKgjB,cAAa,GAClBhjB,KAAKwW,WAAaV,EAEbja,EAAQ6a,aACX1W,KAAK+W,aAAe,IAAI0L,GAAqBziB,KAAK8K,SAAU9K,KAAMnE,EAASgC,GAE/E,CAEA,OAAA3B,GACE,IAAIH,EAEJiE,KAAKwW,WAAWxW,MAEAA,KAAK8K,SAAStE,MAED,QAA5BzK,EAAKiE,KAAK+W,oBAAiC,IAAPhb,GAAyBA,EAAGG,iBAC1D8D,KAAK+W,oBAQL/W,KAAKijB,MACd,CAEA,gBAAA1D,CAAiBrD,EAAgBtY,EAAkB8K,EAAYiH,GAC7D,MAAMsI,EAAkBje,KAAKgL,aAE7B,IAAKiT,EACH,OAAO,KAGT,MAAMiF,EAAiBnU,GAAuBmN,KAAoB+B,EAElE,IAAKje,KAAK+iB,kBAAoB7G,GAAkBzb,EAAIa,aAAa2c,EAAiB/B,KAAoBgH,EACpG,MAAO,CACLpnB,aAASQ,EACT6gB,eAAe,GAInB,MAAMgG,EAAyBnjB,KAAKojB,UAAS,GAE7C,IAAKlH,IAAmBzb,EAAIa,aAAa2c,EAAiB/B,IAAmBgH,EAC3E,MAAO,CACLpnB,QAASqnB,EACThG,eAAe,GAInB,MAAMthB,EAAUmE,KAAK6K,SACrB,IAEIjM,EAFAuQ,EAAO,KACPgO,GAAgB,EAGpB,GAAInd,KAAK+iB,kBAAoBI,EAAwB,CACnD,MAAMZ,EAAY,CAChBha,UAAW0V,EACX/B,iBACAtY,mBACA+R,sBACAwG,oBAAoB,GAEhBqG,EAAe,CAAC,EACtBrT,EAAOtT,EAAQyC,UAAUoQ,EAAa,WAAa,YAAY6T,EAAWC,GAC1ErF,IAAkBqF,EAAarF,cAE1BhO,GAAQnP,KAAK+K,OAAOkO,cAAgB3d,EAAsBG,mBAC7D0T,EAAOtT,EAAQyC,UAAUoQ,EAAa,WAAa,aAAa,CAC9DnG,UAAW0V,EACXtI,sBACAwG,oBAAoB,GACnBqG,GACHrF,GAAgB,GAGlBve,EAAe4jB,EAAa5jB,YAC9B,CAEA,MAAO,CACL9C,QAASqT,EACTvQ,eACAue,gBAEJ,CAEA,YAAA6F,CAAaK,GACXrjB,KAAK+iB,iBAAmBM,IAAerjB,KAAK+K,OAAOkO,WAKrD,CAEA,QAAAD,CAASsK,GACP,IAAIvnB,EAEJ,MAAMD,EAAUkE,KAAKgL,cAAgB,KACrC,IAAIuY,GAAiB,EAErB,IAAK,IAAItmB,EAAIwD,EAAIW,iBAAiBtF,GAAUmB,EAAGA,EAAIwD,EAAIW,iBAAiBnE,GAAI,CAC1E,MAAMumB,EAAqD,QAAhDznB,EAAKH,EAAoBoE,KAAK6K,SAAU5N,UAAuB,IAAPlB,OAAgB,EAASA,EAAGwC,SAE3FilB,IACGA,EAAET,mBACLQ,GAAiB,GAGvB,CAEA,IAAIE,EAAMF,IAAiBvjB,KAAK+K,OAAOkO,aAAcjZ,KAAK+iB,sBAA2BzmB,EAErF,GAAImnB,GAAOH,EAAoB,CAC7B,MAAMI,EAAU1jB,KAAK6K,SAAS4K,eAAeiL,oBAEzCgD,IACFD,EAAMC,IAAY1jB,KAAKojB,UAAS,GAEpC,CAEA,OAAOK,CACT,CAEA,QAAAL,CAASO,GACP,IAAI5nB,EAEJ,MAAMkiB,EAAkBje,KAAKgL,aAC7B,IAAI0G,EAEJ,GAAIuM,EAAiB,CACnB,GAAI0F,GAAe3jB,KAAK6K,SAASvM,UAAUwQ,YAAYmP,GACrD,OAAOA,EAGTvM,EAA+B,QAAtB3V,EAAKiE,KAAKijB,cAA2B,IAAPlnB,OAAgB,EAASA,EAAGyK,MAE9DkL,IACHA,EAAQ1R,KAAK6K,SAASvM,UAAU+c,UAAU,CACxC9S,UAAW0V,EACX9B,oBAAoB,UAChB7f,EAEFoV,GACF1R,KAAK4jB,SAASlS,GAGpB,CAEA,OAAOA,CACT,CAEA,QAAAkS,CAAS9nB,GACHA,EACFkE,KAAKijB,OAAS,IAAI/c,EAAgBlG,KAAK6K,SAAS/F,UAAWhJ,UAEpDkE,KAAKijB,MAEhB,CAEA,aAAAjF,CAAcliB,EAAS2hB,GACrB,MAAMf,EAAkBe,EAAMf,gBACxBrb,EAAgBZ,EAAIW,iBAAiBpB,KAAKgL,cAC1CoX,EAAY/gB,GAAiB2V,GAAQiB,kBAAkBjY,KAAK6K,SAAUxJ,GACtEwiB,EAAoBzB,aAA6C,EAASA,EAAU7jB,SACpFulB,GAAkB1B,aAA6C,EAASA,EAAU/J,qBAAuBwL,OAAoBvnB,EACnI,IAAIynB,EAEJ,MAAMC,EAAczlB,IAClB,IACIya,EADAzR,EAASmV,EAAgBne,EAAS6D,IAYtC,OATImF,EACFyR,EAAWzR,EAAOyR,UAElBA,EAAWhZ,KAAKgZ,UAAS,GACzBzR,EAASmV,EAAgBne,EAAS6D,IAAM,CACtC4W,aAIGA,CAAQ,EAGjB,GAAI8K,IACFC,EAAwBD,EAAe9Y,cAElCgZ,EAAYF,IAAmBC,GAAyBtG,EAAMlV,YAAcwb,GAAyBtjB,EAAIa,aAAamc,EAAMlV,UAAWwb,IAG1I,OADAtG,EAAMH,kBAAmB,EAClB3Y,WAAWgZ,cAItB,MAAM3E,EAAWgL,EAAYhkB,MACvBie,EAAkBje,KAAKgL,aAE7B,GAAIiT,IACe,IAAbjF,EAAmB,CACrB,GAAIiF,IAAoBniB,GAAW+nB,IAC5BE,IACHA,EAAwBF,EAAkB7Y,cAGxC+Y,IAA0BC,EAAYH,IAAsBpjB,EAAIa,aAAamc,EAAMlV,UAAWwb,IAA0BA,IAA0BtG,EAAMlV,WAE1J,OADAkV,EAAMH,kBAAmB,EAClB3Y,WAAWgZ,cAItB,GAAIM,IAAoBniB,GAAW2E,EAAIa,aAAa2c,EAAiBniB,GAEnE,OADA2hB,EAAMH,kBAAmB,EAClB3Y,WAAWgZ,cAGpB,MAAMpW,EAASmV,EAAgB1c,KAAKoC,IACpC,IAAIsP,EAQJ,GALEA,EADE,UAAWnK,EACLA,EAAOmK,MAEPnK,EAAOmK,MAAQ1R,KAAKojB,UAAS,GAGnC1R,GAAS+L,EAAM7B,gBAAgBlK,GAIjC,OAHA+L,EAAMG,mBAAqBK,EAC3BR,EAAMH,kBAAmB,EAErB5L,IAAU+L,EAAM9K,MAClB8K,EAAMzB,OAAQ,EACdyB,EAAMT,aAAetL,EACd/M,WAAW0Y,eAEX1Y,WAAWgZ,aAGxB,CAIJ,EAIF,MAAMsG,GACJ,WAAAxkB,CAAY5D,EAASiJ,GACnB9E,KAAKkkB,SAAW,CAAC,EACjBlkB,KAAKmkB,WAAa,CAAC,EAEnBnkB,KAAK6e,MAAQ,KACX,MAAM9Z,EAAM/E,KAAKqQ,OAGjBrQ,KAAK6K,SAAS4K,eAAesE,eAAe/Z,KAAKyR,UAEjD,MAAM3Q,EAAMiE,EAAIL,SACV/C,EAAgBlB,EAAIiB,iBAAiBZ,GAEvCa,GACF3B,KAAKyR,SAAS9P,GAGhBb,EAAI4L,iBAAiB,YAAa1M,KAAKokB,cAAc,GACrDrf,EAAI2H,iBAAiB,UAAW1M,KAAK8e,YAAY,GACjD/Z,EAAI2H,iBAAiBtN,EAA4BY,KAAKqkB,aAAa,EAGrErkB,KAAKskB,mBAAqB/lB,WACjByB,KAAKmkB,WAAW5lB,EAAS6D,GAAG,EAGrCpC,KAAKyR,SAAW3V,IACVA,GACFkE,KAAKukB,eAAezoB,GAAS,GAAM,EACrC,EAGFkE,KAAKokB,aAAennB,IACdA,EAAE0I,QACJ3F,KAAKukB,eAAetnB,EAAE0I,QAAQ,EAChC,EAGF3F,KAAK8e,WAAa3I,IAChB,GAAIA,EAAM9Y,MAAQqhB,IAAcvI,EAAM9Y,MAAQqhB,GAC5C,OAIF,GAAIvI,EAAMiJ,SAAWjJ,EAAMqO,QAAUrO,EAAMmJ,UAAYnJ,EAAMsO,QAC3D,OAGF,MAAM3oB,EAAUkE,KAAK6K,SAAS4K,eAAeiL,oBAEzC5kB,GACFkE,KAAK0kB,eAAe5oB,EAASqa,EAC/B,EAGFnW,KAAKqkB,aAAepnB,IAClB,IAAIlB,EAEJ,MAAMD,EAAUmB,EAAEsZ,eAAe,GAC3BoO,EAA6B,QAAnB5oB,EAAKkB,EAAE0C,cAA2B,IAAP5D,OAAgB,EAASA,EAAG4oB,OAEnE7oB,QAAsBQ,IAAXqoB,IAAyB1nB,EAAE2nB,mBACpCD,IAAWjpB,EACbsE,KAAK6kB,eAAe/oB,GAEpBkE,KAAK8kB,gBAAgBhpB,GAGvBmB,EAAE+iB,2BACJ,EAGFhgB,KAAK6K,SAAWhP,EAChBmE,KAAKqQ,KAAOvL,EACZjJ,EAAQ6b,UAAU1X,KAAK6e,MACzB,CAEA,OAAA3iB,GACE,MAAM6I,EAAM/E,KAAKqQ,OAEjBrQ,KAAK6K,SAAS4K,eAAekM,iBAAiBjnB,GAE9CsF,KAAKkkB,SAAW,CAAC,EAEblkB,KAAK4Q,eACP7L,EAAI+H,aAAa9M,KAAK4Q,qBACf5Q,KAAK4Q,cAGd5Q,KAAK6K,SAAS4K,eAAe0E,YAAYna,KAAKyR,UAE9C1M,EAAIL,SAASqI,oBAAoB,YAAa/M,KAAKokB,cAAc,GACjErf,EAAIgI,oBAAoB,UAAW/M,KAAK8e,YAAY,GACpD/Z,EAAIgI,oBAAoB3N,EAA4BY,KAAKqkB,cACzD/mB,OAAOC,KAAKyC,KAAKmkB,YAAYxM,SAAQoN,IAC/B/kB,KAAKmkB,WAAWY,KAClB/kB,KAAKmkB,WAAWY,GAAY7oB,iBAErB8D,KAAKmkB,WAAWY,GACzB,GAEJ,CAEA,cAAAvmB,CAAe1C,EAAS8O,EAAO/M,GAG7B,MAAMmnB,EAAc,IAAIlC,GAAS9iB,KAAK6K,SAAU/O,EAASkE,KAAKskB,mBAAoB1Z,EAAO/M,GACzFmC,KAAKmkB,WAAWa,EAAY5iB,IAAM4iB,EAElC,MAAMvP,EAAiBzV,KAAK6K,SAAS4K,eAAeiL,oBAcpD,OAVIjL,GAAkBhV,EAAIa,aAAaxF,EAAS2Z,KAAoBzV,KAAK4Q,eACvE5Q,KAAK4Q,aAAe5Q,KAAKqQ,OAAOvJ,YAAW,YAClC9G,KAAK4Q,aAER6E,IAAmBzV,KAAK6K,SAAS4K,eAAeiL,qBAClD1gB,KAAKukB,eAAe9O,GAAgB,GAAM,EAC5C,GACC,IAGEuP,CACT,CAEA,sBAAAC,GACEjlB,KAAKkkB,SAAW,CAAC,CACnB,CAEA,cAAAK,CAAezoB,EAASopB,EAAeC,GACrC,IAAIppB,EAEAiE,KAAK4Q,eACP5Q,KAAKqQ,OAAOvD,aAAa9M,KAAK4Q,qBAEvB5Q,KAAK4Q,cAGd,MAAMwU,EAAS,CAAC,EAChB,IAAIC,GAAW,EAEf,IAAK,IAAIxc,EAAK/M,EAAS+M,EAAIA,EAAKpI,EAAIW,iBAAiByH,GAAK,CACxD,MAAMtK,EAA6D,QAAjDxC,EAAKH,EAAoBoE,KAAK6K,SAAUhC,UAAwB,IAAP9M,OAAgB,EAASA,EAAGwC,SAEvG,GAAIA,EAAU,CAOZ,GANA6mB,EAAO7mB,EAAS6D,KAAM,EAElBijB,GAAYF,GAAetc,IAAO/M,IACpCupB,GAAW,GAGTH,IAAkBG,EAAU,CAC9BrlB,KAAKkkB,SAAS3lB,EAAS6D,IAAM7D,EAC7B,MAAM8kB,EAAa9kB,EAASya,YAAcld,IAAY+M,KAAQtK,EAAS0M,WAAWqa,WAAa/mB,EAAS6kB,UAAS,KAAWtnB,GAC5HyC,EAASykB,aAAaK,EACxB,CAEAgC,GAAW,CACb,CACF,CAEA,IAAK,MAAMjjB,KAAM9E,OAAOC,KAAKyC,KAAKkkB,UAAW,CAC3C,MAAM3lB,EAAWyB,KAAKkkB,SAAS9hB,GAEzB7D,EAAS6D,MAAMgjB,IACnB7mB,EAASykB,cAAa,GACtBzkB,EAASqlB,cAAStnB,UACX0D,KAAKkkB,SAAS9hB,GAEzB,CACF,CAEA,cAAAyiB,CAAe/oB,EAASsS,GACtB,MAAMvS,EAAUmE,KAAK6K,SACf7F,EAAMgS,GAAQiB,kBAAkBpc,EAASC,GACzCyC,GAAYyG,aAAiC,EAASA,EAAIzG,YAAcyG,aAAiC,EAASA,EAAIsT,qBACtH2F,EAAkB1f,aAA2C,EAASA,EAASyM,aAErF,GAAIzM,GAAY0f,IAAoBniB,IAAYmiB,GAAmB1f,EAAS0M,WAAWqa,WAAaxpB,IAAYyC,EAAS6kB,UAAS,IAAS,CACzI,MAAMjU,EAAOtT,EAAQyC,UAAUmd,SAAS,CACtClT,UAAW0V,EACX/B,eAAgBpgB,EAChBqgB,oBAAoB,IAGtB,GAAIhN,KAAUf,GAAgBA,GAAgB6P,EAAgBjP,cAAc,IAAI5O,EAAsB,CACpG6O,GAAI,WACJC,MAAO+O,EACP9O,OACAf,mBAYA,OAVIA,IAKFA,EAAa2R,iBACb3R,EAAa4R,4BAGf7Q,EAAKyR,QACEzR,CAEX,CAEA,OAAO,IACT,CAEA,eAAA2V,CAAgBhpB,EAASsS,EAAcmX,GACrC,IAAIxpB,EAEJ,MAAMF,EAAUmE,KAAK6K,SACf7F,EAAMgS,GAAQiB,kBAAkBpc,EAASC,GACzCwc,EAAsBtT,aAAiC,EAASA,EAAIsT,oBAC1E,IAAI/Z,GAAYyG,aAAiC,EAASA,EAAIzG,WAAa+Z,EAC3E,MAAM2F,EAAkB1f,aAA2C,EAASA,EAASyM,aAErF,GAAIzM,GAAY0f,GAAmBxd,EAAIa,aAAa2c,EAAiBniB,GAAU,CAC7E,IAAIqT,EAEJ,GAAIrT,IAAYmiB,GAAmBsH,EACjCpW,EAAO5Q,EAAS6kB,UAAS,OACpB,CACL,MAAM/hB,EAAgBZ,EAAIW,iBAAiB6c,GACrCmE,EAAY/gB,EAAgB2V,GAAQiB,kBAAkBpc,EAASwF,QAAiB/E,EACtFiC,EAAW6jB,aAA6C,EAASA,EAAU7jB,SAC3E4Q,EAAO5Q,aAA2C,EAASA,EAAS6kB,UAAS,EAC/E,CAEA,GAAIjU,KAAUf,GAAgBA,GAAgB6P,EAAgBjP,cAAc,IAAI5O,EAAsB,CACpG6O,GAAI,WACJC,MAAO+O,EACP9O,OACAf,mBAaA,OAXI7P,IACFA,EAASykB,cAAa,GAElB1K,IAC2B,QAA5Bvc,EAAKF,EAAQqC,iBAA8B,IAAPnC,GAAyBA,EAAGypB,eAAUlpB,KAM/E6S,EAAKyR,QACEzR,CAEX,CAEA,OAAO,IACT,CAEA,SAAAsW,CAAU3pB,EAAS6oB,GACjB,OAAOA,IAAWjpB,EAAiCsE,KAAK6kB,eAAe/oB,GAAWkE,KAAK8kB,gBAAgBhpB,EACzG,CAEA,cAAA4oB,CAAe5oB,EAASqa,EAAOoP,GAC7B,MAAM1pB,EAAUmE,KAAK6K,SACf7F,EAAMgS,GAAQiB,kBAAkBpc,EAASC,GAE/C,GAAIkJ,KAASA,aAAiC,EAASA,EAAIzG,YAAcyG,aAAiC,EAASA,EAAIsT,sBAAuB,CAG5I,GAFAzc,EAAQ4Z,eAAekM,iBAAiBjnB,GAEpCsK,EAAIyT,cAActC,GACpB,OAGF,GAAIA,EAAM9Y,MAAQqhB,GAChB1e,KAAK6kB,eAAe/oB,EAASqa,QACxB,GAAIA,EAAM9Y,MAAQqhB,GAAa,CAGpC,MAAMjJ,EAAiB5Z,EAAQ4Z,eAAeiL,oBAC9C7kB,EAAQ4Z,eAAe8L,kBAAkB7mB,GAAkC,MACrE+a,IAAmB5Z,EAAQ4Z,eAAeiL,uBAE9C6E,GAAkB9P,IAAmB8P,IAKrCvlB,KAAK8kB,gBAAgBhpB,EAASqa,EAAOoP,EAAc,GAClD,EACL,CACF,CACF,EAsBF,MAAMG,WAAgCjM,GACpC,WAAAha,CAAYqF,GACVlF,QAEAI,KAAK2lB,UAAYC,IACf5lB,KAAKoa,OAAOwL,OAA0BtpB,EAAU,EAGlD0D,KAAK6lB,UAAW,QAAc/gB,KAE9B9E,KAAK6lB,SAASjM,UAAU5Z,KAAK2lB,UAC/B,CAEA,OAAAzpB,GACE0D,MAAM1D,UAEF8D,KAAK6lB,WACP7lB,KAAK6lB,SAAS1L,YAAYna,KAAK2lB,YAE/B,QAAe3lB,KAAK6lB,iBACb7lB,KAAK6lB,SAEhB,CAEA,yBAAArQ,CAA0BoQ,GACxB,IAAI7pB,EAEqB,QAAxBA,EAAKiE,KAAK6lB,gBAA6B,IAAP9pB,GAAyBA,EAAGqe,OAAOwL,EACtE,CAEA,wBAAAA,GACE,IAAI7pB,EAEJ,SAAmC,QAAxBA,EAAKiE,KAAK6lB,gBAA6B,IAAP9pB,OAAgB,EAASA,EAAG6pB,2BACzE,EA6tBF,MAAME,GAA8B,CAAC,QAAS,WAAY,sBAAsBrrB,KAAK,MAErF,MAAMsrB,WAA0BvY,GAC9B,WAAA/N,CAAY3D,EAASD,EAASmqB,EAAcnoB,GAC1C+B,MAAM/D,EAASC,EAASyR,GAAmC1P,GAE3DmC,KAAKimB,mBAAqBzU,IACxB,IAAIzV,EAAII,EAER,MAAMoM,EAAYvI,KAAK8K,SAAStE,MAE1B+E,EAAQiG,EAAWjG,MAEzB,GAAIhD,GAAagD,EAAO,CACtB,MAAMvG,EAAMgS,GAAQiB,kBAAkBjY,KAAK6K,SAAUtC,GACrD,IAAI0J,EAEAjN,IACFiN,EAAsI,QAA3HlW,EAAK6iB,GAAoBW,iBAAiBvf,KAAK6K,SAAU7F,OAAK1I,EAAWiP,OAAOjP,GAAYkV,EAAWjF,SAAS,UAA0B,IAAPxQ,OAAgB,EAASA,EAAGD,SAG5K,MAAMoqB,EAA4C,QAA/B/pB,EAAK6D,KAAKmmB,uBAAoC,IAAPhqB,OAAgB,EAASA,EAAGqK,MAElF0f,GAAalmB,KAAK6K,SAASvM,UAAUwQ,YAAYoX,KACnDjU,EAAUiU,GAGRjU,IACF,QAAYA,EAEhB,GAGFjS,KAAK6K,SAAWhP,EAChBmE,KAAKmmB,cAAgBH,EAErBhmB,KAAK8N,aAAa9N,KAAKimB,mBACzB,EASF,MAAMG,WAAczb,GAClB,WAAAlL,CAAY5D,EAASC,EAASga,EAAWlL,EAAO/M,GAC9C,IAAI9B,EAEJ6D,MAAM/D,EAASC,EAAS8O,GACxB5K,KAAKqmB,SAAW,CAAC,EAEjBrmB,KAAKsmB,gBAAkBC,IACrB,IAAK,MAAM9pB,KAAS8pB,EAAS,CAC3B,MAAM1d,EAAKpM,EAAMkJ,OACXvD,EAAK2H,GAAc/J,KAAKqQ,KAAMxH,GACpC,IAAI2d,EACAC,EAAezmB,KAAK0mB,cAYxB,GAVIjqB,EAAMkqB,mBAAqB,KAC7BH,EAAgB/pB,EAAMkqB,mBAAqB,IAAOhsB,EAAuBA,EAErE6rB,IAAkB7rB,IACpB8rB,EAAerkB,IAGjBokB,EAAgB7rB,EAGdqF,KAAKqmB,SAASjkB,KAAQokB,EAAe,MACjBlqB,IAAlBkqB,UACKxmB,KAAKqmB,SAASjkB,GAEjBqkB,IAAiBrkB,UACZpC,KAAK0mB,gBAGd1mB,KAAKqmB,SAASjkB,GAAMokB,EACpBxmB,KAAK0mB,cAAgBD,GAGvB,MAAMhJ,EAAQzd,KAAK4mB,SAAS/d,GAExB4U,GACF5U,EAAGmG,cAAc,IAAI3O,EAAgBod,GAEzC,CACF,GAGFzd,KAAKqQ,KAAOxU,EAAQiJ,UACpB9E,KAAK6mB,oBAA2D,QAApC9qB,EAAK6O,EAAMic,2BAAwC,IAAP9qB,EAAgBA,EAAK,IAEzFiE,KAAK+K,OAAO+b,YAAc9mB,KAAK+K,OAAOgc,mBACxC/mB,KAAKgnB,sBAAwB,IAAIC,qBAAqBjnB,KAAKsmB,gBAAiB,CAC1EY,UAAW,CAAC,EAAG,IAAM,GAAK,IAAM,KAGlClnB,KAAKmnB,iBAGPnnB,KAAKwW,WAAaV,EAElB,MAAMkQ,EAAe,IAAMpb,EAAMwc,gBAAkBpnB,KAAKkkB,cAAW5nB,EAE9DT,EAAQ6a,aACX1W,KAAK+W,aAAe,IAAIgP,GAAkB/lB,KAAK8K,SAAUjP,EAASmqB,EAAcnoB,GAEpF,CAEA,OAAA3B,GACE,IAAIH,EAEJiE,KAAKwW,WAAWxW,MAEZA,KAAKgnB,wBACPhnB,KAAKgnB,sBAAsBK,oBAEpBrnB,KAAKgnB,8BAGPhnB,KAAKkkB,gBACLlkB,KAAK0mB,qBACL1mB,KAAKsnB,oBACLtnB,KAAKyP,aAERzP,KAAKunB,aACPvnB,KAAKunB,oBAEEvnB,KAAKunB,YAGd,MAAMxiB,EAAM/E,KAAKqQ,OAEbrQ,KAAKwnB,mBACPziB,EAAI+H,aAAa9M,KAAKwnB,yBACfxnB,KAAKwnB,kBAGVxnB,KAAK4Q,eACP7L,EAAI+H,aAAa9M,KAAK4Q,qBACf5Q,KAAK4Q,cAGe,QAA5B7U,EAAKiE,KAAK+W,oBAAiC,IAAPhb,GAAyBA,EAAGG,iBAC1D8D,KAAK+W,YACd,CAEA,UAAA0Q,CAAW3rB,GAEPkE,KAAKkkB,SADHpoB,EACc,IAAIoK,EAAgBlG,KAAKqQ,KAAMvU,QAE/BQ,GAGb0D,KAAK+K,OAAO+b,aAAc9mB,KAAK+K,OAAOgc,iBAAqB/mB,KAAKwnB,mBACnExnB,KAAKwnB,iBAAmBxnB,KAAKqQ,OAAOvJ,YAAW,KAC7C,IAAI/K,SAEGiE,KAAKwnB,iBACZ,MAAME,EAAU,GAEZ1nB,KAAKkkB,WAAalkB,KAAK2nB,eACzBD,EAAQrhB,KAAKrG,KAAKkkB,UAClBwD,EAAQrhB,KAAKrG,KAAK2nB,cAClB3nB,KAAK2nB,aAAe3nB,KAAKkkB,UAG3B,IAAK,MAAM0D,KAAQF,EAAS,CAC1B,MAAM7e,EAAK+e,aAAmC,EAASA,EAAKphB,MAE5D,GAAIqC,IAAoC,QAA5B9M,EAAKiE,KAAKsnB,oBAAiC,IAAPvrB,OAAgB,EAASA,EAAGyK,IAAIqC,MAAS7I,KAAM,CAC7F,MAAM4K,EAAQ5K,KAAK+K,OAEnB,GAAIlC,SAAiCvM,IAA1BsO,EAAMmc,iBAAiCnc,EAAMkc,YAAa,CACnE,MAAMrJ,EAAQzd,KAAK4mB,SAAS/d,GAExB4U,GACF5U,EAAGmG,cAAc,IAAI3O,EAAgBod,GAEzC,CACF,CACF,KAGN,CAEA,UAAAoK,GACE,IAAI9rB,EAEJ,OAAiC,QAAxBA,EAAKiE,KAAKkkB,gBAA6B,IAAPnoB,OAAgB,EAASA,EAAGyK,QAAU,IACjF,CAEA,gBAAA+Y,CAAiBrD,EAAgBtY,EAAkB8K,EAAYiH,GAC7D,MAAMpN,EAAYvI,KAAKgL,aACjBkY,EAAiB3a,GAAawG,GAAuBmN,KAAoB3T,EAE/E,IAAKA,EACH,OAAO,KAGT,IAEI3J,EAFAuQ,EAAO,KACPgO,GAAgB,EAGpB,GAAInd,KAAK+K,OAAOwD,UAAY2U,GAAkBhH,IAAmBzb,EAAIa,aAAaiH,EAAW2T,GAAiB,CAC5G,MAAMqG,EAAY,CAChBrG,iBACAtY,mBACA2E,YACAoN,sBACAwG,oBAAoB,GAEhBqG,EAAe,CAAC,EACtBrT,EAAOnP,KAAK6K,SAASvM,UAAUoQ,EAAa,WAAa,YAAY6T,EAAWC,GAChFrF,IAAkBqF,EAAarF,cAC/Bve,EAAe4jB,EAAa5jB,YAC9B,CAEA,MAAO,CACL9C,QAASqT,EACTvQ,eACAue,gBAEJ,CAEA,aAAAa,CAAcliB,EAAS2hB,GACrB,IAAI1hB,EAAII,EAER,IAAKyiB,GAAoBqD,UACvB,OAAoC,QAA3BlmB,EAAK0hB,EAAMI,kBAA+B,IAAP9hB,OAAgB,EAASA,EAAGyc,mBAAqB7T,WAAWgZ,mBAAgBrhB,EAG1H,MAAM,gBACJ8qB,EAAe,gBACfL,EAAe,WACfe,GAAa,GACX9nB,KAAK+K,OACHoT,EAAene,KAAKgL,aAE1B,GAAImT,IAAiBiJ,GAAmBL,GAAmBe,MAAiBrnB,EAAIa,aAAa6c,EAAcV,EAAM9K,OAAS5D,GAAuB0O,EAAM9K,QAAUwL,GAAe,CAC9K,IAAInC,EAEJ,GAAIoL,EAAiB,CACnB,MAAMja,EAAmC,QAAxBhR,EAAK6D,KAAKkkB,gBAA6B,IAAP/nB,OAAgB,EAASA,EAAGqK,MAEzE2G,GAAWsQ,EAAM7B,gBAAgBzO,KACnC6O,EAAQ7O,EAEZ,CAwBA,IAtBK6O,GAAS8L,IACZ9L,EAAQhc,KAAK6K,SAASvM,UAAUqd,YAAY,CAC1CpT,UAAW4V,EACXhC,oBAAoB,MAInBH,GAAS+K,IACZ/K,EAAQhc,KAAK6K,SAASvM,UAAUid,YAAY,CAC1ChT,UAAW4V,EACXhC,oBAAoB,EACpBzN,WAAY+O,EAAM/O,WAClBkN,gBAAiB/S,IACf,IAAI9M,EAEJ,MAAMqG,EAAK2H,GAAc/J,KAAKqQ,KAAMxH,GAC9B0L,EAAavU,KAAKqmB,SAASjkB,GACjC,OAAO+b,IAAiBtV,MAAsC,QAA5B9M,EAAKiE,KAAKsnB,oBAAiC,IAAPvrB,OAAgB,EAASA,EAAGyK,IAAIqC,KAAQ4U,EAAM7B,gBAAgB/S,KAAQ0L,IAAe5Z,GAAwB4Z,IAAe5Z,IAAkCosB,IAAoBpsB,IAAkCqF,KAAK0mB,eAAe,KAKhT1K,EAKF,OAJAyB,EAAMzB,OAAQ,EACdyB,EAAMT,aAAehB,EACrByB,EAAMG,mBAAqBO,EAC3BV,EAAMH,kBAAmB,EAClB3Y,WAAW0Y,aAEtB,CAGF,CAEA,aAAA8J,GACE,MAAMrrB,EAAUkE,KAAKgL,aAErB,GAAIhL,KAAKunB,aAAezrB,GAAuC,oBAArB8E,iBACxC,OAGF,MAAMmE,EAAM/E,KAAKqQ,OAEX0X,EAAc/nB,KAAKsnB,aAAe,IAAItX,QACtCgY,EAAmBhoB,KAAK6K,SAASvM,UACvC,IAAI2pB,EAAcjoB,KAAKyP,aAAe,GACtC,MAAMyY,EAAWznB,EAAIC,wBAAuBynB,IAC1C,IAAK,MAAMC,KAAYD,EAAW,CAChC,MAAMxiB,EAASyiB,EAASziB,OAClB6T,EAAU4O,EAASC,aACnBC,EAAQF,EAASG,WAEvB,GAAsB,eAAlBH,EAAS1oB,KACoB,aAA3B0oB,EAASI,eACXP,EAAY5hB,KAAK,CACfvK,QAAS6J,EACTjG,KAxQW,QA2QV,CACL,IAAK,IAAI+J,EAAI,EAAGA,EAAI+P,EAAQxa,OAAQyK,IAClCwe,EAAY5hB,KAAK,CACfvK,QAAS0d,EAAQ/P,GACjB/J,KA9Qa,IAkRjB,IAAK,IAAI+J,EAAI,EAAGA,EAAI6e,EAAMtpB,OAAQyK,IAChCwe,EAAY5hB,KAAK,CACfvK,QAASwsB,EAAM7e,GACf/J,KAvRU,GA0RhB,CACF,CAEA+oB,GAAe,IAGXC,EAAa,CAAC5sB,EAAS4U,KAC3B,IAAI3U,EAAII,EAER,MAAMgR,EAAU4a,EAAYvhB,IAAI1K,GAE5BqR,GAAWuD,IACyB,QAArC3U,EAAKiE,KAAKgnB,6BAA0C,IAAPjrB,GAAyBA,EAAG4sB,UAAU7sB,GACpFisB,EAAYpX,OAAO7U,IAGhBqR,GAAYuD,IACfqX,EAAYvX,IAAI1U,EAASkE,MACa,QAArC7D,EAAK6D,KAAKgnB,6BAA0C,IAAP7qB,GAAyBA,EAAGysB,QAAQ9sB,GACpF,EAGI+sB,EAAgB/sB,IACpB,MAAMgT,EAAckZ,EAAiBlZ,YAAYhT,GACjCisB,EAAYvhB,IAAI1K,GAGzBgT,GACH4Z,EAAW5sB,GAAS,GAGlBgT,GACF4Z,EAAW5sB,EAEf,EAGIgtB,EAAiBhtB,IACrB,MAAM,MACJ2C,GACEsqB,EAAiBjtB,GAErB,GAAI2C,GAASA,IAAUuB,KAAM,CAC3B,GAAIvB,EAAMuM,eAAiBlP,IAAWksB,EAAiBlZ,YAAYhT,GAGjE,OAFA4sB,EAAW5sB,EAIf,CAEA,MAAM8gB,EAAS7V,EAAwBhC,EAAIL,SAAU5I,GAASoF,IAC5D,MAAM,MACJzC,EAAK,SACLF,GACEwqB,EAAiB7nB,GAErB,GAAIzC,GAASA,IAAUuB,KACrB,OAAO2E,WAAWgZ,cAGpB,MAAMwF,EAAyB5kB,aAA2C,EAASA,EAAS6kB,UAAS,GAErG,OAAI7kB,GAAYA,EAASyM,eAAiB9J,GAAQiiB,GAA0BA,IAA2BjiB,EAC9FyD,WAAWgZ,eAGhBqK,EAAiBlZ,YAAY5N,IAC/BwnB,EAAWxnB,GAGNyD,WAAW+Y,YAAW,IAG/B,GAAId,EAGF,IAFAA,EAAOQ,YAActhB,EAEd8gB,EAAOY,aAGhB,EAGIwL,EAAaltB,IACDisB,EAAYvhB,IAAI1K,IAG9B4sB,EAAW5sB,GAAS,GAGtB,IAAK,IAAI+M,EAAKpI,EAAIoC,qBAAqB/G,GAAU+M,EAAIA,EAAKpI,EAAIwC,sBAAsB4F,GAClFmgB,EAAWngB,EACb,EAGI4f,EAAgB,MACfzoB,KAAK4Q,cAAgBqX,EAAYjpB,SACpCgB,KAAK4Q,aAAe7L,EAAI+B,YAAW,YAC1B9G,KAAK4Q,aAEZ,IAAK,MAAM,QACT9U,EAAO,KACP4D,KACGuoB,EACH,OAAQvoB,GACN,KAjYW,EAkYTmpB,EAAc/sB,GACd,MAEF,KAtYU,EAuYRgtB,EAAehtB,GACf,MAEF,KAxYa,EAyYXktB,EAAWltB,GAKjBmsB,EAAcjoB,KAAKyP,aAAe,EAAE,GACnC,GACL,EAGIsZ,EAAmBjtB,IACvB,MAAM2nB,EAAM,CAAC,EAEb,IAAK,IAAI5a,EAAK/M,EAAS+M,EAAIA,EAAKpI,EAAIW,iBAAiByH,GAAK,CACxD,MAAMogB,EAAMrtB,EAAoBoE,KAAK6K,SAAUhC,GAE/C,GAAIogB,IACEA,EAAI1qB,WAAaklB,EAAIllB,WACvBklB,EAAIllB,SAAW0qB,EAAI1qB,UAGjB0qB,EAAIxqB,OAAO,CACbglB,EAAIhlB,MAAQwqB,EAAIxqB,MAChB,KACF,CAEJ,CAEA,OAAOglB,CAAG,EAGZwE,EAAY5hB,KAAK,CACfvK,UACA4D,KA5akB,IA8apB+oB,IACAP,EAASU,QAAQ9sB,EAAS,CACxBotB,WAAW,EACXC,SAAS,EACTC,YAAY,EACZC,gBAAiB,CAAC,cAGpBrpB,KAAKunB,WAAa,KAChBW,EAASb,YAAY,CAEzB,CAEA,QAAAT,CAAS9qB,GACP,MAAMsG,EAAK2H,GAAc/J,KAAKqQ,KAAMvU,GAEpC,GAAIsG,KAAMpC,KAAKqmB,SAAU,CACvB,MAAM9R,EAAavU,KAAKqmB,SAASjkB,IAAOzH,EAExC,MAAO,CACL2uB,UAFgBtpB,KAAKkkB,SAAWlkB,KAAKkkB,SAAS1d,QAAU1K,OAAUQ,EAGlEiY,aAEJ,CAGF,EAwBF,MAAMgV,GACJ,WAAA9pB,CAAY5D,EAASiJ,GACnB9E,KAAK6e,MAAQ,KACX,MAAM9Z,EAAM/E,KAAKqQ,OAEjBtL,EAAI2H,iBAAiB,UAAW1M,KAAK8e,YAAY,GACjD/Z,EAAI2H,iBAAiBxN,EAAyBc,KAAKqkB,cACnDtf,EAAI2H,iBAAiBvN,EAAgCa,KAAKwpB,qBAE1DxpB,KAAK6K,SAAS4K,eAAemE,UAAU5Z,KAAKyR,SAAS,EAGvDzR,KAAKypB,gBAAkBhrB,WACduB,KAAK0pB,QAAQjrB,EAAM2D,GAAG,EAG/BpC,KAAKyR,SAAW3V,IACd,IAAIC,EAQJ,IAAI4tB,EAA0B7tB,EAC1B8tB,EAA0B9tB,EAE9B,IAAK,IAAI+M,EAAKpI,EAAIW,iBAAiBtF,GAAU+M,EAAIA,EAAKpI,EAAIW,iBAAiByH,GAAK,CAI9E,MAAMpK,EAA0D,QAAjD1C,EAAKH,EAAoBoE,KAAK6K,SAAUhC,UAAwB,IAAP9M,OAAgB,EAASA,EAAG0C,MAEhGA,IACFA,EAAMgpB,WAAWmC,GACjBD,OAA0BrtB,IAGvBqtB,GAA2B3pB,KAAK6K,SAASvM,UAAUwQ,YAAYjG,KAClE8gB,EAA0BC,EAA0B/gB,EAExD,GAGF7I,KAAK8e,WAAa+K,UAChB,IAAI9tB,EAWJ,GATIiE,KAAK8pB,qBACP9pB,KAAKqQ,OAAOvD,aAAa9M,KAAK8pB,2BAEvB9pB,KAAK8pB,oBAGuB,QAApC/tB,EAAKiE,KAAK+pB,4BAAyC,IAAPhuB,GAAyBA,EAAGmG,KAAKlC,MAAM,GAGhFmW,EAAMiJ,SAAWjJ,EAAMqO,QAAUrO,EAAMmJ,UAAYnJ,EAAMsO,QAC3D,OAGF,MAAMpnB,EAAM8Y,EAAM9Y,IAClB,IAAI2sB,EAoBJ,GAlBI3sB,IAAQqhB,GACVsL,EAAW3uB,EACFgC,IAAQqhB,GACjBsL,EAAW3uB,EACFgC,IAAQqhB,GACjBsL,EAAW3uB,EACFgC,IAAQqhB,GACjBsL,EAAW3uB,EACFgC,IAAQqhB,GACjBsL,EAAW3uB,EACFgC,IAAQqhB,GACjBsL,EAAW3uB,EACFgC,IAAQqhB,GACjBsL,EAAW3uB,EACFgC,IAAQqhB,KACjBsL,EAAW3uB,IAGR2uB,EACH,OAGF,MAAMtG,EAAU1jB,KAAK6K,SAAS4K,eAAeiL,oBAExCgD,UAAkB1jB,KAAKiqB,gBAAgBvG,EAASrmB,IAIrD2C,KAAKkqB,WAAWxG,EAASsG,EAAU7T,EAAM,EAG3CnW,KAAKqkB,aAAepnB,IAClB,IAAIlB,EAEJ,MAAMD,EAAUmB,EAAEsZ,eAAe,GAC3BlZ,EAA0B,QAAnBtB,EAAKkB,EAAE0C,cAA2B,IAAP5D,OAAgB,EAASA,EAAGsB,IAEhEvB,QAAmBQ,IAARe,IAAsBJ,EAAE2nB,mBACrC5kB,KAAKkqB,WAAWpuB,EAASuB,GAEzBJ,EAAE+iB,2BACJ,EAGFhgB,KAAKwpB,oBAAsBvsB,IACzB,IAAIlB,EAEJ,MAAM4J,EAAS1I,EAAEsZ,eAAe,GAChC,IAAI4T,EAAuC,QAAnBpuB,EAAKkB,EAAE0C,cAA2B,IAAP5D,OAAgB,EAASA,EAAGouB,iBAE/E,GAAIxkB,EAAQ,CACV,MAAMX,EAAMgS,GAAQiB,kBAAkBjY,KAAK6K,SAAUlF,GAC/ClH,EAAQuG,aAAiC,EAASA,EAAIvG,MAExDA,IACE0rB,IAAqB1pB,EAAIa,aAAa7C,EAAMuM,aAAcmf,KAC5DA,OAAmB7tB,GAGrBmC,EAAMgpB,WAAW0C,GACjBltB,EAAE+iB,2BAEN,GAGFhgB,KAAK6K,SAAWhP,EAChBmE,KAAKqQ,KAAOvL,EACZ9E,KAAK0pB,QAAU,CAAC,EAChB7tB,EAAQ6b,UAAU1X,KAAK6e,MACzB,CAEA,OAAA3iB,GACE,IAAIH,EAEJ,MAAMgJ,EAAM/E,KAAKqQ,OAEjBrQ,KAAK6K,SAAS4K,eAAe0E,YAAYna,KAAKyR,UAET,QAApC1V,EAAKiE,KAAK+pB,4BAAyC,IAAPhuB,GAAyBA,EAAGmG,KAAKlC,MAAM,GAEhFA,KAAK8pB,qBACP/kB,EAAI+H,aAAa9M,KAAK8pB,2BACf9pB,KAAK8pB,oBAGd/kB,EAAIgI,oBAAoB,UAAW/M,KAAK8e,YAAY,GACpD/Z,EAAIgI,oBAAoB7N,EAAyBc,KAAKqkB,cACtDtf,EAAIgI,oBAAoB5N,EAAgCa,KAAKwpB,qBAC7DlsB,OAAOC,KAAKyC,KAAK0pB,SAAS/R,SAAQyS,IAC5BpqB,KAAK0pB,QAAQU,KACfpqB,KAAK0pB,QAAQU,GAASluB,iBAEf8D,KAAK0pB,QAAQU,GACtB,GAEJ,CAEA,WAAA1rB,CAAY5C,EAAS8O,EAAO/M,GAG1B,MAAMwsB,EAAW,IAAIjE,GAAMpmB,KAAK6K,SAAU/O,EAASkE,KAAKypB,gBAAiB7e,EAAO/M,GAEhF,OADAmC,KAAK0pB,QAAQW,EAASjoB,IAAMioB,EACrBA,CACT,CAEA,SAAA5E,CAAU6E,EAAajtB,GACrB,OAAO2C,KAAKkqB,WAAWI,EAAajtB,EACtC,CAEA,UAAA6sB,CAAWI,EAAajtB,EAAK+Q,GAC3B,IAAIrS,EAAII,EAER,MAAMN,EAAUmE,KAAK6K,SACf7F,EAAMgS,GAAQiB,kBAAkBpc,EAASyuB,EAAa,CAC1DnS,UAAU,IAGZ,IAAKnT,IAAQA,EAAIvG,OAASuG,EAAIwT,mBAAqBpK,GAAgBpJ,EAAIyT,cAAcrK,GACnF,OAAO,KAGT,MAAM3P,EAAQuG,EAAIvG,MACZ8J,EAAY9J,EAAMuM,aAExB,GAAIhG,EAAIqT,oBAAqB,CAC3B,MAAM9Z,EAAWyG,EAAIzG,SAErB,IAAIA,GAAaA,EAASya,UAAS,GASjC,OAAO,KANP,IAAK,IAAInQ,EAAKpI,EAAIW,iBAAiB7C,EAASyM,cAAenC,GAAMA,IAAON,EAAWM,EAAKpI,EAAIW,iBAAiByH,GAC3G,GAAwG,QAAnG1M,EAAiD,QAA3CJ,EAAKH,EAAoBC,EAASgN,UAAwB,IAAP9M,OAAgB,EAASA,EAAGwC,gBAA6B,IAAPpC,OAAgB,EAASA,EAAG6c,UAAS,GACnJ,OAAO,IAMf,CAEA,IAAKzQ,EACH,OAAO,KAGT,MAAMjK,EAAYzC,EAAQyC,UACpBisB,EAAa9rB,EAAMwM,WACnBuf,EAAYD,EAAWC,WAAazvB,EAAgBC,KACpDyvB,EAASD,IAAczvB,EAAgBC,KACvC0vB,EAAaD,GAAUD,IAAczvB,EAAgBE,SACrD0vB,EAAeF,GAAUD,IAAczvB,EAAgBG,WACvD0vB,EAAeJ,IAAczvB,EAAgBK,WAC7CyvB,EAASD,GAAgBJ,IAAczvB,EAAgBI,KACvD2vB,EAAWP,EAAWQ,OAC5B,IAAI5b,EACA6b,EACAC,EACAC,EAAmB,EACnBC,EAAmB,EAgBvB,GAdIN,IACFI,EAAqBX,EAAYxiB,wBACjCojB,EAAmBnjB,KAAKqjB,KAAKH,EAAmB5mB,MAChD8mB,EAAmBpjB,KAAKsjB,MAAMJ,EAAmB1mB,QAG/CS,EAAIsU,MACFjc,IAAQhC,EACVgC,EAAMhC,EACGgC,IAAQhC,IACjBgC,EAAMhC,IAINgC,IAAQhC,GAAuBqvB,GAAcrtB,IAAQhC,IAAyBsvB,GAAgBE,GAOhG,GANA1b,EAAO7Q,EAAUmd,SAAS,CACxBS,eAAgBoO,EAChB/hB,YACA4T,oBAAoB,IAGlBhN,GAAQ0b,EAAQ,CAClB,MAAMS,EAAgBvjB,KAAKqjB,KAAKjc,EAAKrH,wBAAwBzD,OAExDumB,GAAgBO,EAAmBG,IACtCnc,OAAO7S,EAEX,MAAY6S,GAAQ2b,IAClB3b,EAAO7Q,EAAU+c,UAAU,CACzB9S,YACA4T,oBAAoB,UAGnB,GAAI9e,IAAQhC,GAAqBqvB,GAAcrtB,IAAQhC,IAAwBsvB,GAAgBE,GAOpG,GANA1b,EAAO7Q,EAAUod,SAAS,CACxBQ,eAAgBoO,EAChB/hB,YACA4T,oBAAoB,IAGlBhN,GAAQ0b,EAAQ,CAClB,MAAMU,EAAgBxjB,KAAKsjB,MAAMlc,EAAKrH,wBAAwBvD,QAEzDqmB,GAAgBW,EAAgBL,IACnC/b,OAAO7S,EAEX,MAAY6S,GAAQ2b,IAClB3b,EAAO7Q,EAAUkd,SAAS,CACxBjT,YACA4T,oBAAoB,UAGnB,GAAI9e,IAAQhC,EACbwvB,EACFvsB,EAAUid,YAAY,CACpBhT,YACA2T,eAAgBoO,EAChBnO,oBAAoB,EACpBzN,YAAY,EACZkN,gBAAiB/S,IACf,IAAI9M,EAEJ,IAAKuC,EAAUwQ,YAAYjG,GACzB,OAAO,EAGT,MAAMyiB,EAAgBvjB,KAAKqjB,KAAgD,QAA1CrvB,EAAK8M,EAAGf,wBAAwBzD,YAAyB,IAAPtI,EAAgBA,EAAK,GAExG,OAAI8M,IAAOyhB,GAAeY,GAAoBI,IAI9Cnc,EAAOtG,GACA,EAAK,IAIhBsG,EAAO7Q,EAAU+c,UAAU,CACzB9S,YACA4T,oBAAoB,SAGnB,GAAI9e,IAAQhC,EACbwvB,EACFvsB,EAAUid,YAAY,CACpBhT,YACA2T,eAAgBoO,EAChBnO,oBAAoB,EACpBP,gBAAiB/S,IACf,IAAI9M,EAEJ,IAAKuC,EAAUwQ,YAAYjG,GACzB,OAAO,EAGT,MAAMyiB,EAAgBvjB,KAAKqjB,KAAgD,QAA1CrvB,EAAK8M,EAAGf,wBAAwBzD,YAAyB,IAAPtI,EAAgBA,EAAK,GAExG,OAAI8M,IAAOyhB,GAAeY,GAAoBI,IAI9Cnc,EAAOtG,GACA,EAAK,IAIhBsG,EAAO7Q,EAAUkd,SAAS,CACxBjT,YACA4T,oBAAoB,SAGnB,GAAI9e,IAAQhC,EAAkB,CAoBnC,GAnBAiD,EAAUid,YAAY,CACpBW,eAAgBoO,EAChB/hB,YACA4T,oBAAoB,EACpBzN,YAAY,EACZkN,gBAAiB/S,KACVvK,EAAUwQ,YAAYjG,MAIvBR,EAAsCrI,KAAKqQ,KAAMxH,EAAIpK,EAAMooB,uBAC7D1X,EAAOtG,GACA,MAOTgiB,GAAU1b,EAAM,CAClB,MAAMqc,EAAgBzjB,KAAKqjB,KAAKjc,EAAKrH,wBAAwBzD,MAC7D/F,EAAUid,YAAY,CACpBW,eAAgB/M,EAChB5G,YACA4T,oBAAoB,EACpBP,gBAAiB/S,IACf,IAAKvK,EAAUwQ,YAAYjG,GACzB,OAAO,EAGT,MAAMyiB,EAAgBvjB,KAAKqjB,KAAKviB,EAAGf,wBAAwBzD,MAE3D,OAAI6mB,EAAmBI,GAAiBE,GAAiBF,IAIzDnc,EAAOtG,GACA,EAAK,GAGlB,CAEAmiB,GAAoB,CACtB,MAAO,GAAI3tB,IAAQhC,EAAoB,CAmBrC,GAlBAiD,EAAUid,YAAY,CACpBW,eAAgBoO,EAChB/hB,YACA4T,oBAAoB,EACpBP,gBAAiB/S,KACVvK,EAAUwQ,YAAYjG,MAIvBR,EAAsCrI,KAAKqQ,KAAMxH,EAAIpK,EAAMooB,uBAC7D1X,EAAOtG,GACA,MAOTgiB,GAAU1b,EAAM,CAClB,MAAMsc,EAAe1jB,KAAKqjB,KAAKjc,EAAKrH,wBAAwBzD,MAC5D/F,EAAUid,YAAY,CACpBW,eAAgB/M,EAChB5G,YACA4T,oBAAoB,EACpBzN,YAAY,EACZkN,gBAAiB/S,IACf,IAAKvK,EAAUwQ,YAAYjG,GACzB,OAAO,EAGT,MAAMyiB,EAAgBvjB,KAAKqjB,KAAKviB,EAAGf,wBAAwBzD,MAE3D,OAAI6mB,EAAmBI,GAAiBG,GAAgBH,IAIxDnc,EAAOtG,GACA,EAAK,GAGlB,CAEAmiB,GAAoB,CACtB,MAAO,GAAIH,EAAQ,CACjB,MAAMnc,EAAarR,IAAQhC,EACrBqwB,EAAMR,EAENS,EAAM5jB,KAAKqjB,KAAKH,EAAmB3mB,KACnCsnB,EAAMT,EAENU,EAAM9jB,KAAKsjB,MAAMJ,EAAmBzmB,QAC1C,IAAI8K,EACAwc,EACAC,EAAmB,EACvBztB,EAAUwd,QAAQ,CAChBvT,YACA2T,eAAgBoO,EAChB5b,aACA2N,UAAWxT,IAGT,MAAMrB,EAAOqB,EAAGf,wBACVkkB,EAAMjkB,KAAKqjB,KAAK5jB,EAAKnD,MACrB4nB,EAAMlkB,KAAKqjB,KAAK5jB,EAAKlD,KACrB4nB,EAAMnkB,KAAKsjB,MAAM7jB,EAAKjD,OACtB4nB,EAAMpkB,KAAKsjB,MAAM7jB,EAAKhD,QAE5B,GAAIkK,GAAcid,EAAMQ,IAAQzd,GAAcmd,EAAMI,EAElD,OAAO,EAGT,MAAMG,EAAqBrkB,KAAKqjB,KAAKrjB,KAAKE,IAAI2jB,EAAKM,IAAQnkB,KAAKsjB,MAAMtjB,KAAKC,IAAI0jB,EAAKM,IAC9EK,EAAWtkB,KAAKqjB,KAAKrjB,KAAKE,IAAI2jB,EAAMF,EAAKQ,EAAMF,IAErD,GAAII,EAAqB,GAAKC,GAAYD,EAAoB,CAE5D,MAAME,EAAeF,EAAqBC,EAEtCC,EAAeP,IACjBzc,EAAgBzG,EAChBkjB,EAAmBO,EAEvB,MAAO,GAAyB,IAArBP,EAAwB,CAEjC,MAAMQ,EAtdlB,SAAqBb,EAAKC,EAAKC,EAAKC,EAAKG,EAAKC,EAAKC,EAAKC,GACtD,MAAMK,EAAYZ,EAAMI,EAAMA,EAAMJ,EAAMM,EAAMR,EAAMA,EAAMQ,EAAM,EAC5DO,EAAYZ,EAAMI,EAAMA,EAAMJ,EAAMM,EAAMR,EAAMA,EAAMQ,EAAM,EAClE,OAAqB,IAAdK,EAAkBC,EAA0B,IAAdA,EAAkBD,EAAYzkB,KAAK2kB,KAAKF,EAAYA,EAAYC,EAAYA,EACnH,CAkd6BE,CAAYjB,EAAKC,EAAKC,EAAKC,EAAKG,EAAKC,EAAKC,EAAKC,SAE3C7vB,IAAjBwvB,GAA8BS,EAAWT,KAC3CA,EAAeS,EACfjd,EAAgBzG,EAEpB,MAAO,GAAIkjB,EAAmB,EAE5B,OAAO,EAGT,OAAO,CAAI,IAGf5c,EAAOG,CACT,CAEA,OAAIH,KAAUf,GAAgBA,GAAgB7F,EAAUyG,cAAc,IAAI5O,EAAsB,CAC9F6O,GAAI,QACJC,MAAO3G,EACP4G,OACAf,yBAE0B9R,IAAtB0uB,GAv4NV,SAAwBlmB,EAAWhJ,EAAS8wB,GAG1C,MAAMrkB,EAAYC,GAAuB1M,GAEzC,GAAIyM,EAAW,CACb,MAAME,EAAgBrB,EAAgBtC,EAAWyD,GAC3CG,EAAc5M,EAAQgM,wBAG1BS,EAAUuK,WADR8Z,EACqBlkB,EAAYpE,IAAMmE,EAAcnE,IAEhCoE,EAAYlE,OAASiE,EAAcjE,MAE9D,CACF,CAy3NQqoB,CAAe7sB,KAAKqQ,KAAMlB,EAAM6b,GAG9B5c,IACFA,EAAa2R,iBACb3R,EAAa4R,6BAGf,QAAY7Q,GACLA,GAGF,IACT,CAEA,qBAAM8a,CAAgBnuB,EAASuB,GAC7B,GAA8C,SAA1CvB,EAAQS,aAAa,kBAA+BT,EAAQof,aAAa,yBAG3E,OAAO,EAGT,GAAI7Q,GAAgBvO,EAASgqB,IAAiB,CAC5C,IAGIgH,EAHAC,EAAiB,EACjBC,EAAe,EACfC,EAAa,EAGjB,GAAwB,UAApBnxB,EAAQ6S,SAA2C,aAApB7S,EAAQ6S,QAAwB,CACjE,MAAMjP,EAAO5D,EAAQ4D,KACfsV,EAAQlZ,EAAQkZ,MAGtB,GAFAiY,GAAcjY,GAAS,IAAIhW,OAEd,UAATU,GAA6B,WAATA,GAKtB,GAAIutB,EAAY,CACd,MAAMC,EAAYzsB,EAAI+C,aAAa1H,GAEnC,GAAIoxB,EAAW,CACb,MAAMC,EAAgBD,EAAUtjB,WAAW5K,OACrC0P,EAAarR,IAAQqhB,IAAkBrhB,IAAQqhB,GAGrD,GAFAwO,EAAUE,OAAO,SAAU1e,EAAa,WAAa,UAAW,aAE5Dye,IAAkBD,EAAUtjB,WAAW5K,OAIzC,OADAkuB,EAAUE,OAAO,SAAU1e,EAAa,UAAY,WAAY,cACzD,EAEPue,EAAa,CAEjB,CACF,MACK,CACL,MAAMI,EAAWvxB,EAAQixB,eAEzB,GAAiB,OAAbM,EAEF,MAAgB,WAAT3tB,EAGTqtB,EAAiBM,GAAY,EAC7BL,EAAelxB,EAAQkxB,cAAgB,CACzC,CACF,KAAuC,SAA5BlxB,EAAQujB,kBACjByN,EAAW,IAAKriB,GAAWzK,KAAKqQ,MAArB,EAA4Bid,IACrCttB,KAAK+pB,qBAAuB/U,WACnBhV,KAAK+pB,qBACZuD,EAAQtY,EAAM,EAGhB,MAAMjQ,EAAM/E,KAAKqQ,OAEbrQ,KAAK8pB,oBACP/kB,EAAI+H,aAAa9M,KAAK8pB,oBAGxB,MACEyD,WAAYC,EACZC,UAAWC,EACXC,aAAcC,EACdC,YAAaC,GACXrtB,EAAI+C,aAAa1H,IAAY,CAAC,EAElCkE,KAAK8pB,mBAAqB/kB,EAAI+B,YAAW,KACvC,IAAI/K,EAAII,EAAIsX,SAELzT,KAAK8pB,mBACZ,MAAM,WACJyD,EAAU,UACVE,EAAS,aACTE,EAAY,YACZE,GACEptB,EAAI+C,aAAa1H,IAAY,CAAC,EAElC,GAAIyxB,IAAeC,GAAkBC,IAAcC,GAAiBC,IAAiBC,GAAoBC,IAAgBC,EAAzH,CASA,GAJAf,EAAiBY,GAAgB,EACjCX,EAAea,GAAe,EAC9BZ,GAA6C,QAA9B9wB,EAAKL,EAAQiyB,mBAAgC,IAAP5xB,OAAgB,EAASA,EAAG6C,SAAW,EAExFuuB,GAAcE,GACZhtB,EAAIa,aAAaxF,EAASyxB,IAAe9sB,EAAIa,aAAaxF,EAAS2xB,IACjEF,IAAezxB,EAAS,CAC1B,IAAIkyB,GAAc,EAElB,MAAMC,EAAa/sB,IACjB,GAAIA,IAASqsB,EACXS,GAAc,OACT,GAAI9sB,IAASusB,EAClB,OAAO,EAGT,MAAMS,EAAWhtB,EAAK6sB,YAEtB,GAAIG,IAAaztB,EAAI4B,cAAcnB,GAAO,CACxC,MAAMitB,EAAMD,EAASlvB,OAEjBgvB,EACEP,IAAcF,IAChBP,GAAgBmB,IAGlBpB,GAAkBoB,EAClBnB,GAAgBmB,EAEpB,CAEA,IAAIC,GAAO,EAEX,IAAK,IAAInxB,EAAIwD,EAAI4B,cAAcnB,GAAOjE,IAAMmxB,EAAMnxB,EAAIA,EAAEyF,YACtD0rB,EAAOH,EAAWhxB,GAGpB,OAAOmxB,CAAI,EAGbH,EAAWnyB,EACb,CAIiC,QAApC2X,EAAKzT,KAAK+pB,4BAAyC,IAAPtW,GAAyBA,EAAGvR,KAAKlC,MAAM,EA/CpF,MAFuC,QAApCjE,EAAKiE,KAAK+pB,4BAAyC,IAAPhuB,GAAyBA,EAAGmG,KAAKlC,MAAM,EAiDG,GACxF,EAAE,KAIT,GAAI8sB,UAAoBA,EACtB,OAAO,EAGT,GAAIC,IAAmBC,EACrB,OAAO,EAGT,GAAID,EAAiB,IAAM1vB,IAAQqhB,IAAkBrhB,IAAQqhB,IAAgBrhB,IAAQqhB,IACnF,OAAO,EAGT,GAAIqO,EAAiBE,IAAe5vB,IAAQqhB,IAAmBrhB,IAAQqhB,IAAkBrhB,IAAQqhB,IAC/F,OAAO,CAEX,CAEA,OAAO,CACT,EAu9BF,MAAM2P,GACJ,WAAA5uB,CAAYkgB,GACV3f,KAAKsuB,0BAA4B3O,CACnC,CAEA,wBAAAA,CAAyB7jB,EAAS8jB,GAChC,IAAI7jB,EAEJ,MAAM4jB,EAAqE,QAAzC5jB,EAAKiE,KAAKsuB,iCAA8C,IAAPvyB,OAAgB,EAASA,EAAGmG,KAAKlC,KAAMlE,EAAS8jB,GAGnI,YAAoCtjB,IAA7BqjB,EAAyCC,EAAaD,CAC/D,EASF,MAAM4O,WAAiB5jB,GACrB,WAAAlL,CAAY5D,EAASC,EAAS8O,GAC5B,IAAI7O,EAuBJ,GArBA6D,MAAM/D,EAASC,EAAS8O,GACxB5K,KAAKwuB,WAAY,EAEjBxuB,KAAKgO,YAAc/Q,IACjB,IAAIlB,EAEJ,MAAMD,EAAmC,QAAxBC,EAAKiE,KAAK8K,gBAA6B,IAAP/O,OAAgB,EAASA,EAAGyK,MAEzE1K,GAA+B,OAApBmB,EAAEwO,eACf3P,EAAQkT,cAAc,IAAI1O,GAGxBxE,IAAY2E,EAAIa,aAAaxF,EAASmB,EAAEwO,iBAC1CzL,KAAKwuB,WAAY,EACnB,EAGFxuB,KAAK+N,WAAa,KAChB/N,KAAKwuB,WAAY,CAAI,EAGnBxuB,KAAK+K,OAAOrL,OAAS9E,EAAcC,OAAQ,CAC7C,MAAMiB,EAAmC,QAAxBC,EAAKiE,KAAK8K,gBAA6B,IAAP/O,OAAgB,EAASA,EAAGyK,MAC7E1K,SAAkDA,EAAQ4Q,iBAAiB,WAAY1M,KAAKgO,aAC5FlS,SAAkDA,EAAQ4Q,iBAAiB,UAAW1M,KAAK+N,YAE3F/N,KAAKwuB,UAAY/tB,EAAIa,aAAaxF,EAASA,GAAW2E,EAAIiB,iBAAiB5F,EAAQ4H,eACrF,CACF,CAEA,OAAAxH,GACE,IAAIH,EAEJ,GAAIiE,KAAK+K,OAAOrL,OAAS9E,EAAcC,OAAQ,CAC7C,MAAMiB,EAAmC,QAAxBC,EAAKiE,KAAK8K,gBAA6B,IAAP/O,OAAgB,EAASA,EAAGyK,MAI7E,GAHA1K,SAAkDA,EAAQiR,oBAAoB,WAAY/M,KAAKgO,aAC/FlS,SAAkDA,EAAQiR,oBAAoB,UAAW/M,KAAK+N,YAE1F/N,KAAKwuB,UAAW,CACNxuB,KAAK6K,SAAS/F,YAAYJ,SAElC0F,KAAK4E,cAAc,IAAI1O,EAC7B,CACF,CACF,EAIF,MAAMmuB,GACJ,WAAAhvB,CAAYqF,GACV9E,KAAK0uB,OAAS,GACd1uB,KAAKuS,WAAazN,CACpB,CAQA,IAAAuB,CAAKvK,GACH,IAAIC,GAGgD,QAA9CA,EAAKiE,KAAK0uB,OAAO1uB,KAAK0uB,OAAO1vB,OAAS,UAAuB,IAAPjD,OAAgB,EAASA,EAAGyK,SAAW1K,IAI/FkE,KAAK0uB,OAAO1vB,OAASyvB,GAAQE,OAC/B3uB,KAAK0uB,OAAOE,QAGd5uB,KAAK0uB,OAAOroB,KAAK,IAAIH,EAAgBlG,KAAKuS,WAAYzW,IACxD,CAcA,GAAA+yB,CAAI7tB,GAKF,IAAIjF,OAJW,IAAXiF,IACFA,EAAS,KAAM,GAKjB,MAAMF,EAAMd,KAAKuS,aAAa7N,SAE9B,IAAK,IAAIsV,EAAQha,KAAK0uB,OAAO1vB,OAAS,EAAGgb,GAAS,EAAGA,IAAS,CAC5D,MAAM8U,EAA4C,QAA5B/yB,EAAKiE,KAAK0uB,OAAOG,aAA0B,IAAP9yB,OAAgB,EAASA,EAAGyK,MAEtF,GAAIsoB,GAAgBruB,EAAIa,aAAaR,EAAIsJ,KAAM3J,EAAIW,iBAAiB0tB,KAAkB9tB,EAAO8tB,GAC3F,OAAOA,CAEX,CAGF,EAIFL,GAAQE,MAAQ,GAChB,MAAMI,GACJ,WAAAtvB,CAAY5D,GACVmE,KAAKgvB,gBAAkB/xB,IACrB,IAAIlB,EAAII,EAER6D,KAAKivB,qBAAqBtN,iBAAiBjnB,GAG3C,MAAM8mB,EAASvkB,EAAEsZ,eAAe,GAEhC,GAAIiL,EAAQ,CAIV,MAAM0N,EAAyH,QAA7G/yB,EAA2D,QAArDJ,EAAKH,EAAoBoE,KAAK6K,SAAU2W,UAA4B,IAAPzlB,OAAgB,EAASA,EAAGqC,gBAA6B,IAAPjC,OAAgB,EAASA,EAAG8O,WAAW7I,GAE9KpC,KAAKivB,qBAAqB1N,kBAAkB7mB,GAA4B,IAAMsF,KAAKmvB,cAAc3N,EAAQ0N,IAAW,EACtH,GAGFlvB,KAAK+N,WAAajS,IAChB,IAAIC,EAEJ,IAAKD,EACH,OAGF,MAAMszB,EAAmBxzB,EAAoBoE,KAAK6K,SAAU/O,IAEkD,QAAxGC,EAAKqzB,aAA2D,EAASA,EAAiBhxB,gBAA6B,IAAPrC,OAAgB,EAASA,EAAGkP,WAAWvL,QAAU9E,EAAcE,QAIrLkF,KAAKqvB,SAAShpB,KAAKvK,EAAQ,EAG7BkE,KAAKmvB,cAAgB,CAAC3N,EAAQ0N,KAC5B,IAAInzB,EAGJ,MAAM+E,EAAMd,KAAKuS,aAAa7N,SAE9B,GAAIjE,EAAIiB,iBAAiBZ,KAASA,EAAIsJ,KACpC,OAGF,IACCpK,KAAKsvB,kBAAkB1J,4BACxBnlB,EAAIa,aAAaR,EAAIsJ,KAAMoX,GACzB,OAGF,MAAM+N,EAAQzzB,IACZ,IAAIC,EAAII,EAER,OAAsH,QAA9GA,EAA4D,QAAtDJ,EAAKH,EAAoBoE,KAAK6K,SAAU/O,UAA6B,IAAPC,OAAgB,EAASA,EAAGqC,gBAA6B,IAAPjC,OAAgB,EAASA,EAAG8O,WAAW7I,EAAE,EAGtG,QAAlErG,EAAKiE,KAAKqvB,SAASR,KAAIlpB,GAAUupB,IAAaK,EAAM5pB,YAA6B,IAAP5J,GAAyBA,EAAG6kB,OAAO,EAGhH5gB,KAAK6K,SAAWhP,EAChBmE,KAAKuS,WAAa1W,EAAQiJ,UAE1B9E,KAAKuS,aAAa7F,iBAAiBrN,EAA+BW,KAAKgvB,iBAEvEhvB,KAAKqvB,SAAW,IAAIZ,GAAQzuB,KAAKuS,YACjCvS,KAAKsvB,kBAAoBzzB,EAAQ0Z,mBACjCvV,KAAKivB,qBAAuBpzB,EAAQ4Z,eAEpCzV,KAAKivB,qBAAqBrV,UAAU5Z,KAAK+N,WAC3C,CAEA,OAAA7R,GACE,MAAM6I,EAAM/E,KAAKuS,aAEjBvS,KAAKivB,qBAAqB9U,YAAYna,KAAK+N,YAE3C/N,KAAKivB,qBAAqBtN,iBAAiBjnB,GAE3CqK,EAAIgI,oBAAoB1N,EAA+BW,KAAKgvB,gBAC9D,CAEA,cAAA3wB,CAAevC,EAAS8O,GACtB,MAAMxM,EAAW,IAAImwB,GAASvuB,KAAK6K,SAAU/O,EAAS8O,GAMtD,OAJIA,EAAMlL,OAAS9E,EAAcE,QAAU2F,EAAIiB,iBAAiB5F,EAAQ4H,iBAAmB5H,GACzFkE,KAAKqvB,SAAShpB,KAAKvK,GAGdsC,CACT,EAmBF,SAASkD,GAAaJ,EAAMsuB,GAC1B,IAAIzzB,EAAII,EAER,IAAK+E,IAASsuB,EACZ,OAAO,EAGT,IAAIpS,EAAcoS,EAElB,KAAOpS,GAAa,CAClB,GAAIA,IAAgBlc,EAClB,OAAO,EAKPkc,EAF0C,mBAAjCA,EAAYqS,mBAAwE,QAAnC1zB,EAAKqhB,EAAYsS,oBAAiC,IAAP3zB,OAAgB,EAASA,EAAGoF,YAE/E,QAAnChF,EAAKihB,EAAYsS,oBAAiC,IAAPvzB,OAAgB,EAASA,EAAGgF,WAC7Eic,EAAYnW,WAAavC,SAASirB,uBAE7BvS,EAAYwS,KAEZxS,EAAYjc,UAE9B,CAEA,OAAO,CACT,CA+ZA,MAAM0uB,GACJ,4BAAOC,CAAsB/qB,GAC3B,MAAMgrB,EAAmBhrB,EAAIirB,QAAQhuB,UAAUiuB,aAE3CF,EAAiBG,qBAIrBF,QAAQhuB,UAAUiuB,aAAe,SAAU/X,GACzC,MAAMiY,EAAaJ,EAAiB7tB,KAAKlC,KAAMkY,GAE/C,IAAK,MAAMkY,KAAkBP,GAAuBQ,iBAClDD,EAAeE,gBAAgBH,GAGjC,OAAOA,CACT,EAEAH,QAAQhuB,UAAUiuB,aAAaC,mBAAqBH,EACtD,CAEA,WAAAtwB,CAAYkB,GACVX,KAAKuwB,cAAe,EAEpBvwB,KAAKwwB,iBAAmB,CAACrI,EAAWD,KAClC,IAAK,MAAME,KAAYD,EACrB,GAAsB,cAAlBC,EAAS1oB,KAAsB,CACjC,MAAM8Z,EAAU4O,EAASC,aACnBC,EAAQF,EAASG,WAEvB,IAAK,IAAI9e,EAAI,EAAGA,EAAI+P,EAAQxa,OAAQyK,IAClCzJ,KAAKywB,aAAajX,EAAQ/P,IAAI,GAGhC,IAAK,IAAIA,EAAI,EAAGA,EAAI6e,EAAMtpB,OAAQyK,IAChCzJ,KAAKywB,aAAanI,EAAM7e,GAE5B,CAGFzJ,KAAK0wB,UAAUvI,EAAWD,EAAS,EAGrCloB,KAAK0wB,UAAY/vB,EACjBX,KAAK2wB,UAAY,IAAI/vB,iBAAiBZ,KAAKwwB,kBAC3CxwB,KAAK4wB,cAAgB,IAAI1f,GAC3B,CAEA,eAAAof,CAAgBH,GACd,GAAKnwB,KAAK6wB,UAAa7wB,KAAK0wB,YAAa1wB,KAAK4wB,cAAc1gB,IAAIigB,IAI5DnwB,KAAK6wB,SAAS1H,SAAW7nB,GAAatB,KAAK8wB,MAAOX,GAAa,CACjE,MAAMY,EAAc,IAAInwB,iBAAiBZ,KAAKwwB,kBAE9CxwB,KAAK4wB,cAAcpgB,IAAI2f,EAAYY,GAE/B/wB,KAAKuwB,cACPQ,EAAYnI,QAAQuH,EAAYnwB,KAAK6wB,UAGvC7wB,KAAKywB,aAAaN,EACpB,CACF,CAEA,UAAA9I,GACErnB,KAAKuwB,cAAe,SACbvwB,KAAK6wB,SAEZhB,GAAuBQ,iBAAiB1f,OAAO3Q,MAE/C,IAAK,MAAM+wB,KAAe/wB,KAAK4wB,cAAcI,SAC3CD,EAAY1J,aAGdrnB,KAAK4wB,cAAc/f,QAEnB7Q,KAAK2wB,UAAUtJ,YACjB,CAEA,OAAAuB,CAAQjjB,EAAQuS,GACd,MAAMpX,EAAM6E,EAAOsB,WAAaC,KAAK+pB,cAAgBtrB,EAASA,EAAOjC,cAC/DqB,EAAMjE,aAAiC,EAASA,EAAIuT,YAErDvT,GAAQiE,IAIb8qB,GAAuBC,sBAAsB/qB,GAE7C8qB,GAAuBQ,iBAAiBlgB,IAAInQ,MAE5CA,KAAK8wB,MAAQnrB,EACb3F,KAAK6wB,SAAW3Y,EAChBlY,KAAKuwB,cAAe,EAEpBvwB,KAAK2wB,UAAU/H,QAAQjjB,EAAQuS,GAE/BlY,KAAKywB,aAAa9qB,GACpB,CAEA,YAAA8qB,CAAa9qB,EAAQ+K,GACnB,MAAM5P,EAAM6E,EAAOsB,WAAaC,KAAK+pB,cAAgBtrB,EAASA,EAAOjC,cAErE,IAAK5C,EACH,OAGF,GAAI6E,IAAW7E,EACb6E,EAAS7E,EAAIsJ,SACR,CACL,MAAM+lB,EAAaxqB,EAAOwqB,WAE1B,GAAIA,EAGF,YAFAnwB,KAAKswB,gBAAgBH,EAIzB,CAEervB,EAAID,iBAAiB8E,EAAQhB,WAAWC,aAAc,CACnEoC,WAAY9F,IACV,GAAIA,EAAK+F,WAAaC,KAAKC,aACzB,GAAIuJ,EAAQ,CACV,MAAMqgB,EAAc/wB,KAAK4wB,cAAcpqB,IAAItF,GAEvC6vB,IACFA,EAAY1J,aAEZrnB,KAAK4wB,cAAcjgB,OAAOzP,GAE9B,KAAO,CACL,MAAMivB,EAAajvB,EAAKivB,WAEpBA,GACFnwB,KAAKswB,gBAAgBH,EAEzB,CAGF,OAAOxrB,WAAW+Y,WAAW,IAG1BF,UACT,CAEA,WAAA0T,GACE,MAAMC,EAAUnxB,KAAK2wB,UAAUO,cAE/B,IAAK,MAAMH,KAAe/wB,KAAK4wB,cAAcI,SAC3CG,EAAQ9qB,QAAQ0qB,EAAYG,eAG9B,OAAOC,CACT,EAGFtB,GAAuBQ,iBAAgC,IAAI3gB,IAuF3D,MAAM0hB,GACJ,WAAA3xB,CAAY5D,GACVmE,KAAKuV,mBAAqB1Z,EAAQ0Z,mBAClCvV,KAAKyV,eAAiB5Z,EAAQ4Z,eAC9BzV,KAAK1B,UAAYzC,EAAQyC,UACzB0B,KAAKxC,KAAO3B,EAAQ2B,KACpBwC,KAAKpB,aAAe/C,EAAQ+C,aAC5BoB,KAAKqxB,KAAOx1B,CACd,EAQF,MAAMy1B,GACJ,WAAA7xB,CAAYsF,EAAK6F,GACf,IAAI7O,EAAII,EAER6D,KAAKuxB,yBAA2B,GAChCvxB,KAAKqR,UAAY,IAAI3B,IACrB1P,KAAKwxB,WAAa,GAClBxxB,KAAKyxB,SAAW,QAChBzxB,KAAK3D,OAAQ,EAEb2D,KAAK8E,UAAY,KACf,IAAK9E,KAAKqQ,KACR,MAAM,IAAItT,MAAM,2BAGlB,OAAOiD,KAAKqQ,IAAI,EAGlBrQ,KAAK0xB,SAxoST,SAAuB3sB,GACrB,MAAMC,EAAMD,EAAIE,yBAChB,OAAO,KAAMD,aAAiC,EAASA,EAAIG,OAAO6K,UAAYA,QAChF,CAqoSoB2hB,CAAc5sB,GAC9B/E,KAAKqQ,KAAOtL,EACZ,MAAMD,EAAY9E,KAAK8E,WAEnB8F,aAAqC,EAASA,EAAMgnB,SAztS5D,SAAmBC,GACjB,IAAK,MAAMx0B,KAAOC,OAAOC,KAAKs0B,GAC5BpxB,EAAIpD,GAAOw0B,EAAOx0B,EAEtB,CAstSMy0B,CAAU,IAAKlnB,EAAMgnB,SAIvB5xB,KAAKuV,mBAAqB,IAAImQ,GAAwB5gB,GACtD9E,KAAKyV,eAAiB,IAAImJ,GAAoB5e,KAAM8E,GACpD9E,KAAK1B,UAAY,IAAImc,GAAaza,MAClCA,KAAKxC,KAAO,IAAIwZ,GAAQhX,KAAM4K,aAAqC,EAASA,EAAMqM,UAClFjX,KAAKpB,aAAe,IAAIyvB,IACvBzjB,aAAqC,EAASA,EAAMmnB,+BAAiCnnB,aAAqC,EAASA,EAAMonB,iCAC1IhyB,KAAK0W,WAAuF,QAAzE3a,EAAK6O,aAAqC,EAASA,EAAM8L,kBAA+B,IAAP3a,GAAgBA,EACpHiE,KAAK2W,mBAAqB/L,aAAqC,EAASA,EAAM+L,iBAC9E3W,KAAKyS,eAAiB,IAAIjD,GAAmB1K,GAC7C9E,KAAKoW,UAAqF,QAAxEja,EAAKyO,aAAqC,EAASA,EAAMwL,iBAA8B,IAAPja,EAAgBA,EAAKsE,EAAIQ,cAC3HjB,KAAKiyB,SAAW,CACdC,aAAc,KACRlyB,KAAKunB,aACPvnB,KAAKunB,oBAEEvnB,KAAKunB,WACd,EAEF4K,eAAgBC,IACd,IAAKpyB,KAAKunB,WAAY,CACpB,MAAMzmB,EAAMgE,IAAYJ,SACxB1E,KAAKunB,WAl7Df,SAA0BzmB,EAAKjF,EAASI,EAA0Bm2B,GAChE,GAAgC,oBAArBxxB,iBACT,MAAO,OAKT,MAAMkE,EAAYjJ,EAAQiJ,UAC1B,IAAII,EA4CJ,SAASmtB,EAAsBnxB,EAAMsY,GAC9BtU,IACHA,EAAeL,EAAmBC,GAAWI,cAG/CotB,EAAYpxB,EAAMsY,GAClB,MAAMoD,EAAS7V,EAAwBjG,EAAKI,GAAMpF,GACzCw2B,EAAYx2B,EAAS0d,KAG9B,GAAIoD,EACF,KAAOA,EAAOY,aAIlB,CAEA,SAAS8U,EAAYx2B,EAAS0d,GAC5B,IAAIzd,EAEJ,IAAKD,EAAQS,aAEX,OAAOoI,WAAW+Y,YAGpB,MAAM1T,EAAMlO,EAAQmO,oBAcpB,OAZID,GAAO9E,IACLsU,SACKtU,EAAa8E,GAES,QAA5BjO,EAAKmJ,EAAa8E,UAAyB,IAAPjO,IAAqBmJ,EAAa8E,GAAO,IAAI9D,EAAgBpB,EAAWhJ,MAI7GF,EAAoBC,EAASC,IAAYA,EAAQof,aAAa5gB,KAChE2B,EAAyBJ,EAASC,EAAS0d,GAGtC7U,WAAW+Y,WACpB,CAEA,MAAMwK,EAAWznB,EAAIC,wBApFFynB,IACjB,IAAIpsB,EAAII,EAAIsX,EAAIC,EAAI6e,EAEpB,MAAMlK,EAAe,IAAI3Y,IAEzB,IAAK,MAAM0Y,KAAYD,EAAW,CAChC,MAAMxiB,EAASyiB,EAASziB,OAClB6T,EAAU4O,EAASC,aACnBC,EAAQF,EAASG,WAEvB,GAAsB,eAAlBH,EAAS1oB,KACP0oB,EAASI,gBAAkBluB,IAQxB+tB,EAAanY,IAAIvK,IACpB1J,EAAyBJ,EAAS8J,QAGjC,CACL,IAAK,IAAI8D,EAAI,EAAGA,EAAI+P,EAAQxa,OAAQyK,IAAK,CACvC,MAAM+oB,EAAchZ,EAAQ/P,GAC5B4e,EAAalY,IAAIqiB,GACjBH,EAAsBG,GAAa,GACiB,QAAnDr2B,GAAMJ,EAAKF,EAAQ4W,gBAAgBhC,kBAA+B,IAAPtU,GAAyBA,EAAG+F,KAAKnG,EAAI4J,EACnG,CAEA,IAAK,IAAI8D,EAAI,EAAGA,EAAI6e,EAAMtpB,OAAQyK,IAChC4oB,EAAsB/J,EAAM7e,IACwB,QAAnDiK,GAAMD,EAAK5X,EAAQ4W,gBAAgBhC,kBAA+B,IAAPiD,GAAyBA,EAAGxR,KAAKuR,EAAI9N,EAErG,CACF,CAEA0iB,EAAaxX,QACgB,QAA5B0hB,EAAK12B,EAAQqC,iBAA8B,IAAPq0B,GAAyBA,EAAGE,cAAc,IAyDjF,OAVIL,GACFC,EAAsBvtB,IAAYJ,SAAS0F,MAG7C8d,EAASU,QAAQ9nB,EAAK,CACpBooB,WAAW,EACXC,SAAS,EACTC,YAAY,EACZC,gBAAiB,CAAC/uB,KAEb,KACL4tB,EAASb,YAAY,CAEzB,CAq0D4BqL,CAAiB5xB,EAAKd,KAAM/D,EAA0Bm2B,EAC1E,IAGJzrB,EAAyB7B,GAGzB9E,KAAK0X,WAAU,KACb1X,KAAKiyB,SAASE,gBAAe,EAAK,GAEtC,CAQA,WAAAQ,CAAY/nB,GACV,IAAI7O,EAEC6O,IAIL5K,KAAKoW,UAAuC,QAA1Bra,EAAK6O,EAAMwL,iBAA8B,IAAPra,EAAgBA,EAAKiE,KAAKoW,UAChF,CAEA,aAAAwc,CAAcC,EAAYjoB,GACxB,MAAMuH,EAAU,IAAIif,GAAQpxB,MAQ5B,OANK6yB,GACH7yB,KAAKqR,UAAUlB,IAAIgC,GAGrBnS,KAAK2yB,YAAY/nB,GAEVuH,CACT,CAEA,cAAA2gB,CAAe3gB,EAAS4gB,GAClBA,EACF/yB,KAAKqR,UAAUR,QAEf7Q,KAAKqR,UAAUV,OAAOwB,GAGI,IAAxBnS,KAAKqR,UAAU2hB,MACjBhzB,KAAK9D,SAET,CAEA,OAAAA,GACE,IAAIH,EAAII,EAAIsX,EAAIC,EAAI6e,EAAIU,EAAIC,EAAIC,EAEhCnzB,KAAKiyB,SAASC,eACd,MAAMntB,EAAM/E,KAAKqQ,KACjBtL,SAA0CA,EAAI+H,aAAa9M,KAAKozB,mBACzDpzB,KAAKozB,WACZpzB,KAAKwxB,WAAa,GAClBxxB,KAAKuxB,yBAA2B,GAE5BxsB,GAAO/E,KAAKqzB,wBACdtuB,EAAI+H,aAAa9M,KAAKqzB,8BACfrzB,KAAKqzB,uBAGU,QAAvBt3B,EAAKiE,KAAKnB,eAA4B,IAAP9C,GAAyBA,EAAGG,UAChC,QAA3BC,EAAK6D,KAAKszB,mBAAgC,IAAPn3B,GAAyBA,EAAGD,UACxC,QAAvBuX,EAAKzT,KAAKlC,eAA4B,IAAP2V,GAAyBA,EAAGvX,UACnC,QAAxBwX,EAAK1T,KAAKzB,gBAA6B,IAAPmV,GAAyBA,EAAGxX,UACvC,QAArBq2B,EAAKvyB,KAAKvB,aAA0B,IAAP8zB,GAAyBA,EAAGr2B,UAChC,QAAzB+2B,EAAKjzB,KAAK9B,iBAA8B,IAAP+0B,GAAyBA,EAAG/2B,UAC9B,QAA/Bg3B,EAAKlzB,KAAKrC,uBAAoC,IAAPu1B,GAAyBA,EAAGh3B,UAC3C,QAAxBi3B,EAAKnzB,KAAK5B,gBAA6B,IAAP+0B,GAAyBA,EAAGj3B,UAC7D8D,KAAKuV,mBAAmBrZ,UACxB8D,KAAK1B,UAAUpC,UACf8D,KAAKyV,eAAevZ,UACpB8D,KAAKxC,KAAKtB,UAEV8D,KAAKyS,eAAevW,UA9pSxB,SAAgD4I,GAC9C,MAAMsB,EAAUvB,EAAmBC,GACnCsB,EAAQX,qBAAsB,EAE1BW,EAAQS,oBACV/B,IAAYgI,aAAa1G,EAAQS,mBACjCT,EAAQS,uBAAoBvK,EAC5B8J,EAAQZ,aAAe,GAE3B,CAupSI+tB,CAAuCvzB,KAAK8E,WAC5CoF,GAAkBlK,KAAK8E,WACvB9E,KAAK0xB,SAAW,IAAI1hB,QAEpBhQ,KAAKqR,UAAUR,QAEX9L,KAlxSR,SAAgCA,GAC9B,MAAMC,EAAMD,EAAIE,yBAEZD,IACFA,EAAIE,aAAe,CAAC,SACbF,EAAIK,QACXL,EAAIM,2BAA6B,CAAC,EAE9BN,EAAIkD,iCACNnD,EAAI+H,aAAa9H,EAAIkD,iCAGnBlD,EAAI6B,mBACN9B,EAAI+H,aAAa9H,EAAI6B,mBAGvB7B,EAAIQ,aAAe,UACZT,EAAIE,yBAEf,CAgwSMuuB,CAAuBzuB,UAChBA,EAAIiT,yBACJhY,KAAKqQ,KAEhB,CAEA,YAAArU,CAAaF,EAAS23B,GACpB,MAAMC,EAAU1zB,KAAK0xB,SACrB,IAAIj1B,EAAQi3B,EAAQltB,IAAI1K,GAWxB,OATIW,GACgB,IAAdg3B,GAAqD,IAA9Bn2B,OAAOC,KAAKd,GAAOuC,QAC5C00B,EAAQ/iB,OAAO7U,IAEM,IAAd23B,IACTh3B,EAAQ,CAAC,EACTi3B,EAAQljB,IAAI1U,EAASW,IAGhBA,CACT,CAEA,YAAAk3B,GACO3zB,KAAKqQ,OAIVrQ,KAAKuxB,yBAAyBlrB,KAAKrG,KAAKqQ,KAAK3L,SAAS0F,MAElDpK,KAAKqzB,wBAITrzB,KAAKqzB,sBAAwBrzB,KAAKqQ,KAAKvJ,YAAW,YACzC9G,KAAKqzB,sBAEZ,IAAK,IAAIxqB,EAAK7I,KAAKuxB,yBAAyB3C,QAAS/lB,EAAIA,EAAK7I,KAAKuxB,yBAAyB3C,QAC1F1kB,GAAkBlK,KAAK8E,UAAW+D,GAClC+V,GAAoB6B,gBAAgBzgB,KAAKyV,eAAgB5M,EAC3D,GACC,GACHnC,EAAoB1G,KAAK8E,WAAW,IACtC,CAEA,SAAA4S,CAAU/W,GACR,IAAI5E,EAECiE,KAAKqQ,OAIVrQ,KAAKwxB,WAAWnrB,KAAK1F,GAEhBX,KAAKozB,aACRpzB,KAAKozB,WAAkC,QAApBr3B,EAAKiE,KAAKqQ,YAAyB,IAAPtU,OAAgB,EAASA,EAAG+K,YAAW,YAC7E9G,KAAKozB,WACZpzB,KAAKoY,gBAAgB,GACpB,IAEP,CAEA,cAAAA,GACE,IAAKpY,KAAKqQ,KACR,OAGF,MAAMujB,EAAQ5zB,KAAKwxB,WAEnBxxB,KAAKwxB,WAAa,GAClBoC,EAAMjc,SAAQhX,GAAYA,KAC5B,EAcF,SAASiyB,GAAc7tB,EAAK6F,GAC1B,IAAI/O,EAAUg4B,GAAkB9uB,GAEhC,OAAIlJ,EACKA,EAAQ+2B,eAAc,EAAOhoB,IAGtC/O,EAAU,IAAIy1B,GAAYvsB,EAAK6F,GAC/B7F,EAAIiT,kBAAoBnc,EACjBA,EAAQ+2B,gBACjB,CAiBA,SAASkB,GAAYj4B,GACnB,MAAMk4B,EAAcl4B,EAAQw1B,KAM5B,OAJK0C,EAAYx1B,WACfw1B,EAAYx1B,SAAW,IAAI0lB,GAAY8P,EAAaA,EAAYjvB,YAG3DivB,EAAYx1B,QACrB,CAMA,SAASy1B,GAASn4B,GAChB,MAAMk4B,EAAcl4B,EAAQw1B,KAM5B,OAJK0C,EAAYt1B,QACfs1B,EAAYt1B,MAAQ,IAAI8qB,GAASwK,EAAaA,EAAYjvB,YAGrDivB,EAAYt1B,KACrB,CA8EA,SAASw1B,GAAYp4B,GACnB,MAAMk4B,EAAcl4B,EAAQw1B,KAM5B,OAJK0C,EAAY31B,WACf21B,EAAY31B,SAAW,IAAI2wB,GAAYgF,IAGlCA,EAAY31B,QACrB,CACA,SAAS00B,GAAej3B,EAASk3B,GAC/Bl3B,EAAQw1B,KAAKyB,eAAej3B,EAASk3B,EACvC,CAMA,SAASc,GAAkB9uB,GACzB,OAAOA,EAAIiT,iBACb","sources":["file:////home/runner/work/platform/platform/common/temp/node_modules/.pnpm/tabster@8.2.0/node_modules/tabster/dist/tabster.esm.js"],"sourcesContent":["import { nativeFocus, KEYBORG_FOCUSIN, KEYBORG_FOCUSOUT, createKeyborg, disposeKeyborg } from 'keyborg';\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst TABSTER_ATTRIBUTE_NAME = \"data-tabster\";\nconst TABSTER_DUMMY_INPUT_ATTRIBUTE_NAME = \"data-tabster-dummy\";\nconst FOCUSABLE_SELECTOR = /*#__PURE__*/[\"a[href]\", \"button:not([disabled])\", \"input:not([disabled])\", \"select:not([disabled])\", \"textarea:not([disabled])\", \"*[tabindex]\", \"*[contenteditable]\", \"details > summary\", \"audio[controls]\", \"video[controls]\"].join(\", \");\nconst AsyncFocusSources = {\n  EscapeGroupper: 1,\n  Restorer: 2,\n  Deloser: 3\n};\nconst ObservedElementAccessibilities = {\n  Any: 0,\n  Accessible: 1,\n  Focusable: 2\n};\nconst RestoreFocusOrders = {\n  History: 0,\n  DeloserDefault: 1,\n  RootDefault: 2,\n  DeloserFirst: 3,\n  RootFirst: 4\n};\nconst DeloserStrategies = {\n  /**\r\n   * If the focus is lost, the focus will be restored automatically using all available focus history.\r\n   * This is the default strategy.\r\n   */\n  Auto: 0,\n\n  /**\r\n   * If the focus is lost from this Deloser instance, the focus will not be restored automatically.\r\n   * The application might listen to the event and restore the focus manually.\r\n   * But if it is lost from another Deloser instance, the history of this Deloser could be used finding\r\n   * the element to focus.\r\n   */\n  Manual: 1\n};\nconst Visibilities = {\n  Invisible: 0,\n  PartiallyVisible: 1,\n  Visible: 2\n};\nconst RestorerTypes = {\n  Source: 0,\n  Target: 1\n};\nconst MoverDirections = {\n  Both: 0,\n  Vertical: 1,\n  Horizontal: 2,\n  Grid: 3,\n  GridLinear: 4 // Two-dimentional movement depending on the visual placement. Allows linear movement.\n\n};\nconst MoverKeys = {\n  ArrowUp: 1,\n  ArrowDown: 2,\n  ArrowLeft: 3,\n  ArrowRight: 4,\n  PageUp: 5,\n  PageDown: 6,\n  Home: 7,\n  End: 8\n};\nconst GroupperTabbabilities = {\n  Unlimited: 0,\n  Limited: 1,\n  LimitedTrapFocus: 2 // The focus is limited as above, plus trapped when inside.\n\n};\nconst GroupperMoveFocusActions = {\n  Enter: 1,\n  Escape: 2\n};\nconst SysDummyInputsPositions = {\n  Auto: 0,\n  Inside: 1,\n  Outside: 2 // Tabster will always place dummy inputs outside of the container.\n\n};\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction getTabsterOnElement(tabster, element) {\n  var _a;\n\n  return (_a = tabster.storageEntry(element)) === null || _a === void 0 ? void 0 : _a.tabster;\n}\nfunction updateTabsterByAttribute(tabster, element, dispose) {\n  var _a, _b;\n\n  const newAttrValue = dispose || tabster._noop ? undefined : element.getAttribute(TABSTER_ATTRIBUTE_NAME);\n  let entry = tabster.storageEntry(element);\n  let newAttr;\n\n  if (newAttrValue) {\n    if (newAttrValue !== ((_a = entry === null || entry === void 0 ? void 0 : entry.attr) === null || _a === void 0 ? void 0 : _a.string)) {\n      try {\n        const newValue = JSON.parse(newAttrValue);\n\n        if (typeof newValue !== \"object\") {\n          throw new Error(`Value is not a JSON object, got '${newAttrValue}'.`);\n        }\n\n        newAttr = {\n          string: newAttrValue,\n          object: newValue\n        };\n      } catch (e) {\n        if (process.env.NODE_ENV === 'development') {\n          console.error(`data-tabster attribute error: ${e}`, element);\n        }\n      }\n    } else {\n      return;\n    }\n  } else if (!entry) {\n    return;\n  }\n\n  if (!entry) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    entry = tabster.storageEntry(element, true);\n  }\n\n  if (!entry.tabster) {\n    entry.tabster = {};\n  }\n\n  const tabsterOnElement = entry.tabster || {};\n  const oldTabsterProps = ((_b = entry.attr) === null || _b === void 0 ? void 0 : _b.object) || {};\n  const newTabsterProps = (newAttr === null || newAttr === void 0 ? void 0 : newAttr.object) || {};\n\n  for (const key of Object.keys(oldTabsterProps)) {\n    if (!newTabsterProps[key]) {\n      if (key === \"root\") {\n        const root = tabsterOnElement[key];\n\n        if (root) {\n          tabster.root.onRoot(root, true);\n        }\n      }\n\n      switch (key) {\n        case \"deloser\":\n        case \"root\":\n        case \"groupper\":\n        case \"modalizer\":\n        case \"restorer\":\n        case \"mover\":\n          // eslint-disable-next-line no-case-declarations\n          const part = tabsterOnElement[key];\n\n          if (part) {\n            part.dispose();\n            delete tabsterOnElement[key];\n          }\n\n          break;\n\n        case \"observed\":\n          delete tabsterOnElement[key];\n\n          if (tabster.observedElement) {\n            tabster.observedElement.onObservedElementUpdate(element);\n          }\n\n          break;\n\n        case \"focusable\":\n        case \"outline\":\n        case \"uncontrolled\":\n        case \"sys\":\n          delete tabsterOnElement[key];\n          break;\n      }\n    }\n  }\n\n  for (const key of Object.keys(newTabsterProps)) {\n    const sys = newTabsterProps.sys;\n\n    switch (key) {\n      case \"deloser\":\n        if (tabsterOnElement.deloser) {\n          tabsterOnElement.deloser.setProps(newTabsterProps.deloser);\n        } else {\n          if (tabster.deloser) {\n            tabsterOnElement.deloser = tabster.deloser.createDeloser(element, newTabsterProps.deloser);\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Deloser API used before initialization, please call `getDeloser()`\");\n          }\n        }\n\n        break;\n\n      case \"root\":\n        if (tabsterOnElement.root) {\n          tabsterOnElement.root.setProps(newTabsterProps.root);\n        } else {\n          tabsterOnElement.root = tabster.root.createRoot(element, newTabsterProps.root, sys);\n        }\n\n        tabster.root.onRoot(tabsterOnElement.root);\n        break;\n\n      case \"modalizer\":\n        if (tabsterOnElement.modalizer) {\n          tabsterOnElement.modalizer.setProps(newTabsterProps.modalizer);\n        } else {\n          if (tabster.modalizer) {\n            tabsterOnElement.modalizer = tabster.modalizer.createModalizer(element, newTabsterProps.modalizer, sys);\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Modalizer API used before initialization, please call `getModalizer()`\");\n          }\n        }\n\n        break;\n\n      case \"restorer\":\n        if (tabsterOnElement.restorer) {\n          tabsterOnElement.restorer.setProps(newTabsterProps.restorer);\n        } else {\n          if (tabster.restorer) {\n            if (newTabsterProps.restorer) {\n              tabsterOnElement.restorer = tabster.restorer.createRestorer(element, newTabsterProps.restorer);\n            }\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Restorer API used before initialization, please call `getRestorer()`\");\n          }\n        }\n\n        break;\n\n      case \"focusable\":\n        tabsterOnElement.focusable = newTabsterProps.focusable;\n        break;\n\n      case \"groupper\":\n        if (tabsterOnElement.groupper) {\n          tabsterOnElement.groupper.setProps(newTabsterProps.groupper);\n        } else {\n          if (tabster.groupper) {\n            tabsterOnElement.groupper = tabster.groupper.createGroupper(element, newTabsterProps.groupper, sys);\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Groupper API used before initialization, please call `getGroupper()`\");\n          }\n        }\n\n        break;\n\n      case \"mover\":\n        if (tabsterOnElement.mover) {\n          tabsterOnElement.mover.setProps(newTabsterProps.mover);\n        } else {\n          if (tabster.mover) {\n            tabsterOnElement.mover = tabster.mover.createMover(element, newTabsterProps.mover, sys);\n          } else if (process.env.NODE_ENV === 'development') {\n            console.error(\"Mover API used before initialization, please call `getMover()`\");\n          }\n        }\n\n        break;\n\n      case \"observed\":\n        if (tabster.observedElement) {\n          tabsterOnElement.observed = newTabsterProps.observed;\n          tabster.observedElement.onObservedElementUpdate(element);\n        } else if (process.env.NODE_ENV === 'development') {\n          console.error(\"ObservedElement API used before initialization, please call `getObservedElement()`\");\n        }\n\n        break;\n\n      case \"uncontrolled\":\n        tabsterOnElement.uncontrolled = newTabsterProps.uncontrolled;\n        break;\n\n      case \"outline\":\n        if (tabster.outline) {\n          tabsterOnElement.outline = newTabsterProps.outline;\n        } else if (process.env.NODE_ENV === 'development') {\n          console.error(\"Outline API used before initialization, please call `getOutline()`\");\n        }\n\n        break;\n\n      case \"sys\":\n        tabsterOnElement.sys = newTabsterProps.sys;\n        break;\n\n      default:\n        console.error(`Unknown key '${key}' in data-tabster attribute value.`);\n    }\n  }\n\n  if (newAttr) {\n    entry.attr = newAttr;\n  } else {\n    if (Object.keys(tabsterOnElement).length === 0) {\n      delete entry.tabster;\n      delete entry.attr;\n    }\n\n    tabster.storageEntry(element, false);\n  }\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\n/**\r\n * Events sent by Tabster.\r\n */\nconst TabsterFocusInEventName = \"tabster:focusin\";\nconst TabsterFocusOutEventName = \"tabster:focusout\"; // Event is dispatched when Tabster wants to move focus as the result of\n// handling keyboard event. This allows to preventDefault() if you want to have\n// some custom logic.\n\nconst TabsterMoveFocusEventName = \"tabster:movefocus\";\n/**\r\n * Events sent by Deloser.\r\n */\n\nconst DeloserFocusLostEventName = \"tabster:deloser:focus-lost\";\n/**\r\n * Events to be sent to Deloser by the application.\r\n */\n\nconst DeloserRestoreFocusEventName = \"tabster:deloser:restore-focus\";\n/**\r\n * Events sent by Modalizer.\r\n */\n\nconst ModalizerActiveEventName = \"tabster:modalizer:active\";\nconst ModalizerInactiveEventName = \"tabster:modalizer:inactive\";\nconst ModalizerFocusInEventName = \"tabster:modalizer:focusin\";\nconst ModalizerFocusOutEventName = \"tabster:modalizer:focusout\";\n/**\r\n * Events sent by Mover.\r\n */\n\nconst MoverStateEventName = \"tabster:mover:state\";\n/**\r\n * Events to be sent to Mover by the application.\r\n */\n// Event that can be dispatched by the application to programmatically move\n// focus inside Mover.\n\nconst MoverMoveFocusEventName = \"tabster:mover:movefocus\"; // Event that can be dispatched by the application to forget or modify\n// memorized element in Mover with memorizeCurrent property.\n\nconst MoverMemorizedElementEventName = \"tabster:mover:memorized-element\";\n/**\r\n * Events sent by Groupper.\r\n */\n\n/**\r\n * Events to be sent to Groupper by the application.\r\n */\n// Event that can be dispatched by the application to programmatically enter\n// or escape Groupper.\n\nconst GroupperMoveFocusEventName = \"tabster:groupper:movefocus\";\n/**\r\n * Events sent by Restorer.\r\n */\n\nconst RestorerRestoreFocusEventName = \"tabster:restorer:restore-focus\";\n/**\r\n * Events sent by Root.\r\n */\n\nconst RootFocusEventName = \"tabster:root:focus\";\nconst RootBlurEventName = \"tabster:root:blur\"; // Node.js environments do not have CustomEvent and it is needed for the events to be\n// evaluated. It doesn't matter if it works or not in Node.js environment.\n// So, we just need to make sure that it doesn't throw undefined reference.\n\nconst CustomEvent_ = typeof CustomEvent !== \"undefined\" ? CustomEvent : function () {\n  /* no-op */\n};\nclass TabsterCustomEvent extends CustomEvent_ {\n  constructor(type, detail) {\n    super(type, {\n      bubbles: true,\n      cancelable: true,\n      composed: true,\n      detail\n    });\n    this.details = detail;\n  }\n\n}\nclass TabsterFocusInEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(TabsterFocusInEventName, detail);\n  }\n\n}\nclass TabsterFocusOutEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(TabsterFocusOutEventName, detail);\n  }\n\n}\nclass TabsterMoveFocusEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(TabsterMoveFocusEventName, detail);\n  }\n\n}\nclass MoverStateEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(MoverStateEventName, detail);\n  }\n\n}\nclass MoverMoveFocusEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(MoverMoveFocusEventName, detail);\n  }\n\n}\nclass MoverMemorizedElementEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(MoverMemorizedElementEventName, detail);\n  }\n\n}\nclass GroupperMoveFocusEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(GroupperMoveFocusEventName, detail);\n  }\n\n}\nclass ModalizerActiveEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(ModalizerActiveEventName, detail);\n  }\n\n}\nclass ModalizerInactiveEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(ModalizerInactiveEventName, detail);\n  }\n\n}\nclass DeloserFocusLostEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(DeloserFocusLostEventName, detail);\n  }\n\n}\nclass DeloserRestoreFocusEvent extends TabsterCustomEvent {\n  constructor() {\n    super(DeloserRestoreFocusEventName);\n  }\n\n}\nclass RestorerRestoreFocusEvent extends TabsterCustomEvent {\n  constructor() {\n    super(RestorerRestoreFocusEventName);\n  }\n\n}\nclass RootFocusEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(RootFocusEventName, detail);\n  }\n\n}\nclass RootBlurEvent extends TabsterCustomEvent {\n  constructor(detail) {\n    super(RootBlurEventName, detail);\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst _createMutationObserver = callback => new MutationObserver(callback);\n\nconst _createTreeWalker = (doc, root, whatToShow, filter) => doc.createTreeWalker(root, whatToShow, filter);\n\nconst _getParentNode = node => node ? node.parentNode : null;\n\nconst _getParentElement = element => element ? element.parentElement : null;\n\nconst _nodeContains = (parent, child) => !!(child && (parent === null || parent === void 0 ? void 0 : parent.contains(child)));\n\nconst _getActiveElement = doc => doc.activeElement;\n\nconst _querySelector = (element, selector) => element.querySelector(selector);\n\nconst _querySelectorAll = (element, selector) => Array.prototype.slice.call(element.querySelectorAll(selector), 0);\n\nconst _getElementById = (doc, id) => doc.getElementById(id);\n\nconst _getFirstChild = node => (node === null || node === void 0 ? void 0 : node.firstChild) || null;\n\nconst _getLastChild = node => (node === null || node === void 0 ? void 0 : node.lastChild) || null;\n\nconst _getNextSibling = node => (node === null || node === void 0 ? void 0 : node.nextSibling) || null;\n\nconst _getPreviousSibling = node => (node === null || node === void 0 ? void 0 : node.previousSibling) || null;\n\nconst _getFirstElementChild = element => (element === null || element === void 0 ? void 0 : element.firstElementChild) || null;\n\nconst _getLastElementChild = element => (element === null || element === void 0 ? void 0 : element.lastElementChild) || null;\n\nconst _getNextElementSibling = element => (element === null || element === void 0 ? void 0 : element.nextElementSibling) || null;\n\nconst _getPreviousElementSibling = element => (element === null || element === void 0 ? void 0 : element.previousElementSibling) || null;\n\nconst _appendChild = (parent, child) => parent.appendChild(child);\n\nconst _insertBefore = (parent, child, referenceChild) => parent.insertBefore(child, referenceChild);\n\nconst _getSelection = ref => {\n  var _a;\n\n  return ((_a = ref.ownerDocument) === null || _a === void 0 ? void 0 : _a.getSelection()) || null;\n};\n\nconst _getElementsByName = (referenceElement, name) => referenceElement.ownerDocument.getElementsByName(name);\n\nconst dom = {\n  createMutationObserver: _createMutationObserver,\n  createTreeWalker: _createTreeWalker,\n  getParentNode: _getParentNode,\n  getParentElement: _getParentElement,\n  nodeContains: _nodeContains,\n  getActiveElement: _getActiveElement,\n  querySelector: _querySelector,\n  querySelectorAll: _querySelectorAll,\n  getElementById: _getElementById,\n  getFirstChild: _getFirstChild,\n  getLastChild: _getLastChild,\n  getNextSibling: _getNextSibling,\n  getPreviousSibling: _getPreviousSibling,\n  getFirstElementChild: _getFirstElementChild,\n  getLastElementChild: _getLastElementChild,\n  getNextElementSibling: _getNextElementSibling,\n  getPreviousElementSibling: _getPreviousElementSibling,\n  appendChild: _appendChild,\n  insertBefore: _insertBefore,\n  getSelection: _getSelection,\n  getElementsByName: _getElementsByName\n};\nfunction setDOMAPI(domapi) {\n  for (const key of Object.keys(domapi)) {\n    dom[key] = domapi[key];\n  }\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nlet _isBrokenIE11;\n\nconst _DOMRect = typeof DOMRect !== \"undefined\" ? DOMRect : class {\n  constructor(x, y, width, height) {\n    this.left = x || 0;\n    this.top = y || 0;\n    this.right = (x || 0) + (width || 0);\n    this.bottom = (y || 0) + (height || 0);\n  }\n\n};\n\nlet _uidCounter = 0;\n\ntry {\n  // IE11 only accepts `filter` argument as a function (not object with the `acceptNode`\n  // property as the docs define). Also `entityReferenceExpansion` argument is not\n  // optional. And it throws exception when the above arguments aren't there.\n  document.createTreeWalker(document, NodeFilter.SHOW_ELEMENT);\n  _isBrokenIE11 = false;\n} catch (e) {\n  _isBrokenIE11 = true;\n}\n\nconst _updateDummyInputsTimeout = 100;\nfunction getInstanceContext(getWindow) {\n  const win = getWindow();\n  let ctx = win.__tabsterInstanceContext;\n\n  if (!ctx) {\n    ctx = {\n      elementByUId: {},\n      basics: {\n        Promise: win.Promise || undefined,\n        WeakRef: win.WeakRef || undefined\n      },\n      containerBoundingRectCache: {},\n      lastContainerBoundingRectCacheId: 0,\n      fakeWeakRefs: [],\n      fakeWeakRefsStarted: false\n    };\n    win.__tabsterInstanceContext = ctx;\n  }\n\n  return ctx;\n}\nfunction disposeInstanceContext(win) {\n  const ctx = win.__tabsterInstanceContext;\n\n  if (ctx) {\n    ctx.elementByUId = {};\n    delete ctx.WeakRef;\n    ctx.containerBoundingRectCache = {};\n\n    if (ctx.containerBoundingRectCacheTimer) {\n      win.clearTimeout(ctx.containerBoundingRectCacheTimer);\n    }\n\n    if (ctx.fakeWeakRefsTimer) {\n      win.clearTimeout(ctx.fakeWeakRefsTimer);\n    }\n\n    ctx.fakeWeakRefs = [];\n    delete win.__tabsterInstanceContext;\n  }\n}\nfunction createWeakMap(win) {\n  const ctx = win.__tabsterInstanceContext;\n  return new ((ctx === null || ctx === void 0 ? void 0 : ctx.basics.WeakMap) || WeakMap)();\n}\nfunction hasSubFocusable(element) {\n  return !!element.querySelector(FOCUSABLE_SELECTOR);\n}\n\nclass FakeWeakRef {\n  constructor(target) {\n    this._target = target;\n  }\n\n  deref() {\n    return this._target;\n  }\n\n  static cleanup(fwr, forceRemove) {\n    if (!fwr._target) {\n      return true;\n    }\n\n    if (forceRemove || !documentContains(fwr._target.ownerDocument, fwr._target)) {\n      delete fwr._target;\n      return true;\n    }\n\n    return false;\n  }\n\n}\n\nclass WeakHTMLElement {\n  constructor(getWindow, element, data) {\n    const context = getInstanceContext(getWindow);\n    let ref;\n\n    if (context.WeakRef) {\n      ref = new context.WeakRef(element);\n    } else {\n      ref = new FakeWeakRef(element);\n      context.fakeWeakRefs.push(ref);\n    }\n\n    this._ref = ref;\n    this._data = data;\n  }\n\n  get() {\n    const ref = this._ref;\n    let element;\n\n    if (ref) {\n      element = ref.deref();\n\n      if (!element) {\n        delete this._ref;\n      }\n    }\n\n    return element;\n  }\n\n  getData() {\n    return this._data;\n  }\n\n}\nfunction cleanupFakeWeakRefs(getWindow, forceRemove) {\n  const context = getInstanceContext(getWindow);\n  context.fakeWeakRefs = context.fakeWeakRefs.filter(e => !FakeWeakRef.cleanup(e, forceRemove));\n}\nfunction startFakeWeakRefsCleanup(getWindow) {\n  const context = getInstanceContext(getWindow);\n\n  if (!context.fakeWeakRefsStarted) {\n    context.fakeWeakRefsStarted = true;\n    context.WeakRef = getWeakRef(context);\n  }\n\n  if (!context.fakeWeakRefsTimer) {\n    context.fakeWeakRefsTimer = getWindow().setTimeout(() => {\n      context.fakeWeakRefsTimer = undefined;\n      cleanupFakeWeakRefs(getWindow);\n      startFakeWeakRefsCleanup(getWindow);\n    }, 2 * 60 * 1000); // 2 minutes.\n  }\n}\nfunction stopFakeWeakRefsCleanupAndClearStorage(getWindow) {\n  const context = getInstanceContext(getWindow);\n  context.fakeWeakRefsStarted = false;\n\n  if (context.fakeWeakRefsTimer) {\n    getWindow().clearTimeout(context.fakeWeakRefsTimer);\n    context.fakeWeakRefsTimer = undefined;\n    context.fakeWeakRefs = [];\n  }\n}\nfunction createElementTreeWalker(doc, root, acceptNode) {\n  // IE11 will throw an exception when the TreeWalker root is not an Element.\n  if (root.nodeType !== Node.ELEMENT_NODE) {\n    return undefined;\n  } // TypeScript isn't aware of IE11 behaving badly.\n\n\n  const filter = _isBrokenIE11 ? acceptNode : {\n    acceptNode\n  };\n  return dom.createTreeWalker(doc, root, NodeFilter.SHOW_ELEMENT, filter, // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore: We still don't want to completely break IE11, so, entityReferenceExpansion argument is not optional.\n  false\n  /* Last argument is not optional for IE11! */\n  );\n}\nfunction getBoundingRect(getWindow, element) {\n  let cacheId = element.__tabsterCacheId;\n  const context = getInstanceContext(getWindow);\n  const cached = cacheId ? context.containerBoundingRectCache[cacheId] : undefined;\n\n  if (cached) {\n    return cached.rect;\n  }\n\n  const scrollingElement = element.ownerDocument && element.ownerDocument.documentElement;\n\n  if (!scrollingElement) {\n    return new _DOMRect();\n  } // A bounding rect of the top-level element contains the whole page regardless of the\n  // scrollbar. So, we improvise a little and limiting the final result...\n\n\n  let left = 0;\n  let top = 0;\n  let right = scrollingElement.clientWidth;\n  let bottom = scrollingElement.clientHeight;\n\n  if (element !== scrollingElement) {\n    const r = element.getBoundingClientRect();\n    left = Math.max(left, r.left);\n    top = Math.max(top, r.top);\n    right = Math.min(right, r.right);\n    bottom = Math.min(bottom, r.bottom);\n  }\n\n  const rect = new _DOMRect(left < right ? left : -1, top < bottom ? top : -1, left < right ? right - left : 0, top < bottom ? bottom - top : 0);\n\n  if (!cacheId) {\n    cacheId = \"r-\" + ++context.lastContainerBoundingRectCacheId;\n    element.__tabsterCacheId = cacheId;\n  }\n\n  context.containerBoundingRectCache[cacheId] = {\n    rect,\n    element\n  };\n\n  if (!context.containerBoundingRectCacheTimer) {\n    context.containerBoundingRectCacheTimer = window.setTimeout(() => {\n      context.containerBoundingRectCacheTimer = undefined;\n\n      for (const cId of Object.keys(context.containerBoundingRectCache)) {\n        delete context.containerBoundingRectCache[cId].element.__tabsterCacheId;\n      }\n\n      context.containerBoundingRectCache = {};\n    }, 50);\n  }\n\n  return rect;\n}\nfunction isElementVerticallyVisibleInContainer(getWindow, element, tolerance) {\n  const container = getScrollableContainer(element);\n\n  if (!container) {\n    return false;\n  }\n\n  const containerRect = getBoundingRect(getWindow, container);\n  const elementRect = element.getBoundingClientRect();\n  const intersectionTolerance = elementRect.height * (1 - tolerance);\n  const topIntersection = Math.max(0, containerRect.top - elementRect.top);\n  const bottomIntersection = Math.max(0, elementRect.bottom - containerRect.bottom);\n  const totalIntersection = topIntersection + bottomIntersection;\n  return totalIntersection === 0 || totalIntersection <= intersectionTolerance;\n}\nfunction scrollIntoView(getWindow, element, alignToTop) {\n  // Built-in DOM's scrollIntoView() is cool, but when we have nested containers,\n  // it scrolls all of them, not just the deepest one. So, trying to work it around.\n  const container = getScrollableContainer(element);\n\n  if (container) {\n    const containerRect = getBoundingRect(getWindow, container);\n    const elementRect = element.getBoundingClientRect();\n\n    if (alignToTop) {\n      container.scrollTop += elementRect.top - containerRect.top;\n    } else {\n      container.scrollTop += elementRect.bottom - containerRect.bottom;\n    }\n  }\n}\nfunction getScrollableContainer(element) {\n  const doc = element.ownerDocument;\n\n  if (doc) {\n    for (let el = dom.getParentElement(element); el; el = dom.getParentElement(el)) {\n      if (el.scrollWidth > el.clientWidth || el.scrollHeight > el.clientHeight) {\n        return el;\n      }\n    }\n\n    return doc.documentElement;\n  }\n\n  return null;\n}\nfunction makeFocusIgnored(element) {\n  element.__shouldIgnoreFocus = true;\n}\nfunction shouldIgnoreFocus(element) {\n  return !!element.__shouldIgnoreFocus;\n}\nfunction getUId(wnd) {\n  const rnd = new Uint32Array(4);\n\n  if (wnd.crypto && wnd.crypto.getRandomValues) {\n    wnd.crypto.getRandomValues(rnd);\n  } else if (wnd.msCrypto && wnd.msCrypto.getRandomValues) {\n    wnd.msCrypto.getRandomValues(rnd);\n  } else {\n    for (let i = 0; i < rnd.length; i++) {\n      rnd[i] = 0xffffffff * Math.random();\n    }\n  }\n\n  const srnd = [];\n\n  for (let i = 0; i < rnd.length; i++) {\n    srnd.push(rnd[i].toString(36));\n  }\n\n  srnd.push(\"|\");\n  srnd.push((++_uidCounter).toString(36));\n  srnd.push(\"|\");\n  srnd.push(Date.now().toString(36));\n  return srnd.join(\"\");\n}\nfunction getElementUId(getWindow, element) {\n  const context = getInstanceContext(getWindow);\n  let uid = element.__tabsterElementUID;\n\n  if (!uid) {\n    uid = element.__tabsterElementUID = getUId(getWindow());\n  }\n\n  if (!context.elementByUId[uid] && documentContains(element.ownerDocument, element)) {\n    context.elementByUId[uid] = new WeakHTMLElement(getWindow, element);\n  }\n\n  return uid;\n}\nfunction getWindowUId(win) {\n  let uid = win.__tabsterCrossOriginWindowUID;\n\n  if (!uid) {\n    uid = win.__tabsterCrossOriginWindowUID = getUId(win);\n  }\n\n  return uid;\n}\nfunction clearElementCache(getWindow, parent) {\n  const context = getInstanceContext(getWindow);\n\n  for (const key of Object.keys(context.elementByUId)) {\n    const wel = context.elementByUId[key];\n    const el = wel && wel.get();\n\n    if (el && parent) {\n      if (!dom.nodeContains(parent, el)) {\n        continue;\n      }\n    }\n\n    delete context.elementByUId[key];\n  }\n} // IE11 doesn't have document.contains()...\n\nfunction documentContains(doc, element) {\n  return dom.nodeContains(doc === null || doc === void 0 ? void 0 : doc.body, element);\n}\nfunction matchesSelector(element, selector) {\n  const matches = element.matches || element.matchesSelector || element.msMatchesSelector || element.webkitMatchesSelector;\n  return matches && matches.call(element, selector);\n}\nfunction getPromise(getWindow) {\n  const context = getInstanceContext(getWindow);\n\n  if (context.basics.Promise) {\n    return context.basics.Promise;\n  }\n\n  throw new Error(\"No Promise defined.\");\n}\nfunction getWeakRef(context) {\n  return context.basics.WeakRef;\n}\nlet _lastTabsterPartId = 0;\nclass TabsterPart {\n  constructor(tabster, element, props) {\n    const getWindow = tabster.getWindow;\n    this._tabster = tabster;\n    this._element = new WeakHTMLElement(getWindow, element);\n    this._props = { ...props\n    };\n    this.id = \"i\" + ++_lastTabsterPartId;\n  }\n\n  getElement() {\n    return this._element.get();\n  }\n\n  getProps() {\n    return this._props;\n  }\n\n  setProps(props) {\n    this._props = { ...props\n    };\n  }\n\n}\n/**\r\n * Dummy HTML elements that are used as focus sentinels for the DOM enclosed within them\r\n */\n\nclass DummyInput {\n  constructor(getWindow, isOutside, props, element, fixedTarget) {\n    var _a;\n\n    this._focusIn = e => {\n      if (this._fixedTarget) {\n        const target = this._fixedTarget.get();\n\n        if (target) {\n          nativeFocus(target);\n        }\n\n        return;\n      }\n\n      const input = this.input;\n\n      if (this.onFocusIn && input) {\n        const relatedTarget = e.relatedTarget;\n        this.onFocusIn(this, this._isBackward(true, input, relatedTarget), relatedTarget);\n      }\n    };\n\n    this._focusOut = e => {\n      if (this._fixedTarget) {\n        return;\n      }\n\n      this.useDefaultAction = false;\n      const input = this.input;\n\n      if (this.onFocusOut && input) {\n        const relatedTarget = e.relatedTarget;\n        this.onFocusOut(this, this._isBackward(false, input, relatedTarget), relatedTarget);\n      }\n    };\n\n    const win = getWindow();\n    const input = win.document.createElement(\"i\");\n    input.tabIndex = 0;\n    input.setAttribute(\"role\", \"none\");\n    input.setAttribute(TABSTER_DUMMY_INPUT_ATTRIBUTE_NAME, \"\");\n    input.setAttribute(\"aria-hidden\", \"true\");\n    const style = input.style;\n    style.position = \"fixed\";\n    style.width = style.height = \"1px\";\n    style.opacity = \"0.001\";\n    style.zIndex = \"-1\";\n    style.setProperty(\"content-visibility\", \"hidden\");\n    makeFocusIgnored(input);\n    this.input = input;\n    this.isFirst = props.isFirst;\n    this.isOutside = isOutside;\n    this._isPhantom = (_a = props.isPhantom) !== null && _a !== void 0 ? _a : false;\n    this._fixedTarget = fixedTarget;\n    input.addEventListener(\"focusin\", this._focusIn);\n    input.addEventListener(\"focusout\", this._focusOut);\n    input.__tabsterDummyContainer = element;\n\n    if (this._isPhantom) {\n      this._disposeTimer = win.setTimeout(() => {\n        delete this._disposeTimer;\n        this.dispose();\n      }, 0);\n\n      this._clearDisposeTimeout = () => {\n        if (this._disposeTimer) {\n          win.clearTimeout(this._disposeTimer);\n          delete this._disposeTimer;\n        }\n\n        delete this._clearDisposeTimeout;\n      };\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    if (this._clearDisposeTimeout) {\n      this._clearDisposeTimeout();\n    }\n\n    const input = this.input;\n\n    if (!input) {\n      return;\n    }\n\n    delete this._fixedTarget;\n    delete this.onFocusIn;\n    delete this.onFocusOut;\n    delete this.input;\n    input.removeEventListener(\"focusin\", this._focusIn);\n    input.removeEventListener(\"focusout\", this._focusOut);\n    delete input.__tabsterDummyContainer;\n    (_a = dom.getParentNode(input)) === null || _a === void 0 ? void 0 : _a.removeChild(input);\n  }\n\n  setTopLeft(top, left) {\n    var _a;\n\n    const style = (_a = this.input) === null || _a === void 0 ? void 0 : _a.style;\n\n    if (style) {\n      style.top = `${top}px`;\n      style.left = `${left}px`;\n    }\n  }\n\n  _isBackward(isIn, current, previous) {\n    return isIn && !previous ? !this.isFirst : !!(previous && current.compareDocumentPosition(previous) & Node.DOCUMENT_POSITION_FOLLOWING);\n  }\n\n}\nconst DummyInputManagerPriorities = {\n  Root: 1,\n  Modalizer: 2,\n  Mover: 3,\n  Groupper: 4\n};\nclass DummyInputManager {\n  constructor(tabster, element, priority, sys, outsideByDefault, callForDefaultAction) {\n    this._element = element;\n    this._instance = new DummyInputManagerCore(tabster, element, this, priority, sys, outsideByDefault, callForDefaultAction);\n  }\n\n  _setHandlers(onFocusIn, onFocusOut) {\n    this._onFocusIn = onFocusIn;\n    this._onFocusOut = onFocusOut;\n  }\n\n  moveOut(backwards) {\n    var _a;\n\n    (_a = this._instance) === null || _a === void 0 ? void 0 : _a.moveOut(backwards);\n  }\n\n  moveOutWithDefaultAction(backwards, relatedEvent) {\n    var _a;\n\n    (_a = this._instance) === null || _a === void 0 ? void 0 : _a.moveOutWithDefaultAction(backwards, relatedEvent);\n  }\n\n  getHandler(isIn) {\n    return isIn ? this._onFocusIn : this._onFocusOut;\n  }\n\n  setTabbable(tabbable) {\n    var _a;\n\n    (_a = this._instance) === null || _a === void 0 ? void 0 : _a.setTabbable(this, tabbable);\n  }\n\n  dispose() {\n    if (this._instance) {\n      this._instance.dispose(this);\n\n      delete this._instance;\n    }\n\n    delete this._onFocusIn;\n    delete this._onFocusOut;\n  }\n\n  static moveWithPhantomDummy(tabster, element, // The target element to move to or out of.\n  moveOutOfElement, // Whether to move out of the element or into it.\n  isBackward, // Are we tabbing of shift-tabbing?\n  relatedEvent // The event that triggered the move.\n  ) {\n    // Phantom dummy is a hack to use browser's default action to move\n    // focus from a specific point in the application to the next/previous\n    // element. Default action is needed because next focusable element\n    // is not always available to focus directly (for example, next focusable\n    // is inside isolated iframe) or for uncontrolled areas we want to make\n    // sure that something that controls it takes care of the focusing.\n    // It works in a way that during the Tab key handling, we create a dummy\n    // input element, place it to the specific place in the DOM and focus it,\n    // then the default action of the Tab press will move focus from our dummy\n    // input. And we remove it from the DOM right after that.\n    const dummy = new DummyInput(tabster.getWindow, true, {\n      isPhantom: true,\n      isFirst: true\n    });\n    const input = dummy.input;\n\n    if (input) {\n      let parent;\n      let insertBefore; // Let's say we have a following DOM structure:\n      // <div>\n      //   <button>Button1</button>\n      //   <div id=\"uncontrolled\" data-tabster={uncontrolled: {}}>\n      //     <button>Button2</button>\n      //     <button>Button3</button>\n      //   </div>\n      //   <button>Button4</button>\n      // </div>\n      //\n      // We pass the \"uncontrolled\" div as the element to move to or out of.\n      //\n      // When we pass moveOutOfElement=true and isBackward=false,\n      // the phantom dummy input will be inserted before Button4.\n      //\n      // When we pass moveOutOfElement=true and isBackward=true, there are\n      // two cases. If the uncontrolled element is focusable (has tabindex=0),\n      // the phantom dummy input will be inserted after Button1. If the\n      // uncontrolled element is not focusable, the phantom dummy input will be\n      // inserted before Button2.\n      //\n      // When we pass moveOutOfElement=false and isBackward=false, the\n      // phantom dummy input will be inserted after Button1.\n      //\n      // When we pass moveOutOfElement=false and isBackward=true, the phantom\n      // dummy input will be inserted before Button4.\n      //\n      // And we have a corner case for <body> and we make sure that the inserted\n      // dummy is inserted properly when there are existing permanent dummies.\n\n      if (element.tagName === \"BODY\") {\n        // We cannot insert elements outside of BODY.\n        parent = element;\n        insertBefore = moveOutOfElement && isBackward || !moveOutOfElement && !isBackward ? dom.getFirstElementChild(element) : null;\n      } else {\n        if (moveOutOfElement && (!isBackward || isBackward && !tabster.focusable.isFocusable(element, false, true, true))) {\n          parent = element;\n          insertBefore = isBackward ? element.firstElementChild : null;\n        } else {\n          parent = dom.getParentElement(element);\n          insertBefore = moveOutOfElement && isBackward || !moveOutOfElement && !isBackward ? element : dom.getNextElementSibling(element);\n        }\n\n        let potentialDummy;\n        let dummyFor;\n\n        do {\n          // This is a safety pillow for the cases when someone, combines\n          // groupper with uncontrolled on the same node. Which is technically\n          // not correct, but moving into the container element via its dummy\n          // input would produce a correct behaviour in uncontrolled mode.\n          potentialDummy = moveOutOfElement && isBackward || !moveOutOfElement && !isBackward ? dom.getPreviousElementSibling(insertBefore) : insertBefore;\n          dummyFor = getDummyInputContainer(potentialDummy);\n\n          if (dummyFor === element) {\n            insertBefore = moveOutOfElement && isBackward || !moveOutOfElement && !isBackward ? potentialDummy : dom.getNextElementSibling(potentialDummy);\n          } else {\n            dummyFor = null;\n          }\n        } while (dummyFor);\n      }\n\n      if (parent === null || parent === void 0 ? void 0 : parent.dispatchEvent(new TabsterMoveFocusEvent({\n        by: \"root\",\n        owner: parent,\n        next: null,\n        relatedEvent\n      }))) {\n        dom.insertBefore(parent, input, insertBefore);\n        nativeFocus(input);\n      }\n    }\n  }\n\n  static addPhantomDummyWithTarget(tabster, sourceElement, isBackward, targetElement) {\n    const dummy = new DummyInput(tabster.getWindow, true, {\n      isPhantom: true,\n      isFirst: true\n    }, undefined, new WeakHTMLElement(tabster.getWindow, targetElement));\n    const input = dummy.input;\n\n    if (input) {\n      let dummyParent;\n      let insertBefore;\n\n      if (hasSubFocusable(sourceElement) && !isBackward) {\n        dummyParent = sourceElement;\n        insertBefore = dom.getFirstElementChild(sourceElement);\n      } else {\n        dummyParent = dom.getParentElement(sourceElement);\n        insertBefore = isBackward ? sourceElement : dom.getNextElementSibling(sourceElement);\n      }\n\n      if (dummyParent) {\n        dom.insertBefore(dummyParent, input, insertBefore);\n      }\n    }\n  }\n\n}\n\nfunction setDummyInputDebugValue(dummy, wrappers) {\n  var _a;\n\n  const what = {\n    1: \"Root\",\n    2: \"Modalizer\",\n    3: \"Mover\",\n    4: \"Groupper\"\n  };\n  (_a = dummy.input) === null || _a === void 0 ? void 0 : _a.setAttribute(TABSTER_DUMMY_INPUT_ATTRIBUTE_NAME, [`isFirst=${dummy.isFirst}`, `isOutside=${dummy.isOutside}`, ...wrappers.map(w => `(${what[w.priority]}, tabbable=${w.tabbable})`)].join(\", \"));\n}\n\nclass DummyInputObserver {\n  constructor(win) {\n    this._updateQueue = new Set();\n    this._lastUpdateQueueTime = 0;\n    this._changedParents = new WeakSet();\n    this._dummyElements = [];\n    this._dummyCallbacks = new WeakMap();\n\n    this._domChanged = parent => {\n      var _a;\n\n      if (this._changedParents.has(parent)) {\n        return;\n      }\n\n      this._changedParents.add(parent);\n\n      if (this._updateDummyInputsTimer) {\n        return;\n      }\n\n      this._updateDummyInputsTimer = (_a = this._win) === null || _a === void 0 ? void 0 : _a.call(this).setTimeout(() => {\n        delete this._updateDummyInputsTimer;\n\n        for (const ref of this._dummyElements) {\n          const dummyElement = ref.get();\n\n          if (dummyElement) {\n            const callback = this._dummyCallbacks.get(dummyElement);\n\n            if (callback) {\n              const dummyParent = dom.getParentNode(dummyElement);\n\n              if (!dummyParent || this._changedParents.has(dummyParent)) {\n                callback();\n              }\n            }\n          }\n        }\n\n        this._changedParents = new WeakSet();\n      }, _updateDummyInputsTimeout);\n    };\n\n    this._win = win;\n  }\n\n  add(dummy, callback) {\n    if (!this._dummyCallbacks.has(dummy) && this._win) {\n      this._dummyElements.push(new WeakHTMLElement(this._win, dummy));\n\n      this._dummyCallbacks.set(dummy, callback);\n\n      this.domChanged = this._domChanged;\n    }\n  }\n\n  remove(dummy) {\n    this._dummyElements = this._dummyElements.filter(ref => {\n      const element = ref.get();\n      return element && element !== dummy;\n    });\n\n    this._dummyCallbacks.delete(dummy);\n\n    if (this._dummyElements.length === 0) {\n      delete this.domChanged;\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    const win = (_a = this._win) === null || _a === void 0 ? void 0 : _a.call(this);\n\n    if (this._updateTimer) {\n      win === null || win === void 0 ? void 0 : win.clearTimeout(this._updateTimer);\n      delete this._updateTimer;\n    }\n\n    if (this._updateDummyInputsTimer) {\n      win === null || win === void 0 ? void 0 : win.clearTimeout(this._updateDummyInputsTimer);\n      delete this._updateDummyInputsTimer;\n    }\n\n    this._changedParents = new WeakSet();\n    this._dummyCallbacks = new WeakMap();\n    this._dummyElements = [];\n\n    this._updateQueue.clear();\n\n    delete this.domChanged;\n    delete this._win;\n  }\n\n  updatePositions(compute) {\n    if (!this._win) {\n      // As this is a public method, we make sure that it has no effect when\n      // called after dispose().\n      return;\n    }\n\n    this._updateQueue.add(compute);\n\n    this._lastUpdateQueueTime = Date.now();\n\n    this._scheduledUpdatePositions();\n  }\n\n  _scheduledUpdatePositions() {\n    var _a;\n\n    if (this._updateTimer) {\n      return;\n    }\n\n    this._updateTimer = (_a = this._win) === null || _a === void 0 ? void 0 : _a.call(this).setTimeout(() => {\n      delete this._updateTimer; // updatePositions() might be called quite a lot during the scrolling.\n      // So, instead of clearing the timeout and scheduling a new one, we\n      // check if enough time has passed since the last updatePositions() call\n      // and only schedule a new one if not.\n      // At maximum, we will update dummy inputs positions\n      // _updateDummyInputsTimeout * 2 after the last updatePositions() call.\n\n      if (this._lastUpdateQueueTime + _updateDummyInputsTimeout <= Date.now()) {\n        // A cache for current bulk of updates to reduce getComputedStyle() calls.\n        const scrollTopLeftCache = new Map();\n        const setTopLeftCallbacks = [];\n\n        for (const compute of this._updateQueue) {\n          setTopLeftCallbacks.push(compute(scrollTopLeftCache));\n        }\n\n        this._updateQueue.clear(); // We're splitting the computation of offsets and setting them to avoid extra\n        // reflows.\n\n\n        for (const setTopLeft of setTopLeftCallbacks) {\n          setTopLeft();\n        } // Explicitly clear to not hold references till the next garbage collection.\n\n\n        scrollTopLeftCache.clear();\n      } else {\n        this._scheduledUpdatePositions();\n      }\n    }, _updateDummyInputsTimeout);\n  }\n\n}\n/**\r\n * Parent class that encapsulates the behaviour of dummy inputs (focus sentinels)\r\n */\n\nclass DummyInputManagerCore {\n  constructor(tabster, element, manager, priority, sys, outsideByDefault, callForDefaultAction) {\n    this._wrappers = [];\n    this._isOutside = false;\n    this._transformElements = new Set();\n\n    this._onFocusIn = (dummyInput, isBackward, relatedTarget) => {\n      this._onFocus(true, dummyInput, isBackward, relatedTarget);\n    };\n\n    this._onFocusOut = (dummyInput, isBackward, relatedTarget) => {\n      this._onFocus(false, dummyInput, isBackward, relatedTarget);\n    };\n\n    this.moveOut = backwards => {\n      var _a;\n\n      const first = this._firstDummy;\n      const last = this._lastDummy;\n\n      if (first && last) {\n        // For the sake of performance optimization, the dummy input\n        // position in the DOM updates asynchronously from the DOM change.\n        // Calling _ensurePosition() to make sure the position is correct.\n        this._ensurePosition();\n\n        const firstInput = first.input;\n        const lastInput = last.input;\n        const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n\n        if (firstInput && lastInput && element) {\n          let toFocus;\n\n          if (backwards) {\n            firstInput.tabIndex = 0;\n            toFocus = firstInput;\n          } else {\n            lastInput.tabIndex = 0;\n            toFocus = lastInput;\n          }\n\n          if (toFocus) {\n            nativeFocus(toFocus);\n          }\n        }\n      }\n    };\n    /**\r\n     * Prepares to move focus out of the given element by focusing\r\n     * one of the dummy inputs and setting the `useDefaultAction` flag\r\n     * @param backwards focus moving to an element behind the given element\r\n     */\n\n\n    this.moveOutWithDefaultAction = (backwards, relatedEvent) => {\n      var _a;\n\n      const first = this._firstDummy;\n      const last = this._lastDummy;\n\n      if (first && last) {\n        // For the sake of performance optimization, the dummy input\n        // position in the DOM updates asynchronously from the DOM change.\n        // Calling _ensurePosition() to make sure the position is correct.\n        this._ensurePosition();\n\n        const firstInput = first.input;\n        const lastInput = last.input;\n        const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n\n        if (firstInput && lastInput && element) {\n          let toFocus;\n\n          if (backwards) {\n            if (!first.isOutside && this._tabster.focusable.isFocusable(element, true, true, true)) {\n              toFocus = element;\n            } else {\n              first.useDefaultAction = true;\n              firstInput.tabIndex = 0;\n              toFocus = firstInput;\n            }\n          } else {\n            last.useDefaultAction = true;\n            lastInput.tabIndex = 0;\n            toFocus = lastInput;\n          }\n\n          if (toFocus && element.dispatchEvent(new TabsterMoveFocusEvent({\n            by: \"root\",\n            owner: element,\n            next: null,\n            relatedEvent\n          }))) {\n            nativeFocus(toFocus);\n          }\n        }\n      }\n    };\n\n    this.setTabbable = (manager, tabbable) => {\n      var _a, _b;\n\n      for (const w of this._wrappers) {\n        if (w.manager === manager) {\n          w.tabbable = tabbable;\n          break;\n        }\n      }\n\n      const wrapper = this._getCurrent();\n\n      if (wrapper) {\n        const tabIndex = wrapper.tabbable ? 0 : -1;\n        let input = (_a = this._firstDummy) === null || _a === void 0 ? void 0 : _a.input;\n\n        if (input) {\n          input.tabIndex = tabIndex;\n        }\n\n        input = (_b = this._lastDummy) === null || _b === void 0 ? void 0 : _b.input;\n\n        if (input) {\n          input.tabIndex = tabIndex;\n        }\n      }\n\n      if (process.env.NODE_ENV === 'development') {\n        this._firstDummy && setDummyInputDebugValue(this._firstDummy, this._wrappers);\n        this._lastDummy && setDummyInputDebugValue(this._lastDummy, this._wrappers);\n      }\n    };\n    /**\r\n     * Adds dummy inputs as the first and last child of the given element\r\n     * Called each time the children under the element is mutated\r\n     */\n\n\n    this._addDummyInputs = () => {\n      if (this._addTimer) {\n        return;\n      }\n\n      this._addTimer = this._getWindow().setTimeout(() => {\n        delete this._addTimer;\n\n        this._ensurePosition();\n\n        if (process.env.NODE_ENV === 'development') {\n          this._firstDummy && setDummyInputDebugValue(this._firstDummy, this._wrappers);\n          this._lastDummy && setDummyInputDebugValue(this._lastDummy, this._wrappers);\n        }\n\n        this._addTransformOffsets();\n      }, 0);\n    };\n\n    this._addTransformOffsets = () => {\n      this._tabster._dummyObserver.updatePositions(this._computeTransformOffsets);\n    };\n\n    this._computeTransformOffsets = scrollTopLeftCache => {\n      var _a, _b;\n\n      const from = ((_a = this._firstDummy) === null || _a === void 0 ? void 0 : _a.input) || ((_b = this._lastDummy) === null || _b === void 0 ? void 0 : _b.input);\n      const transformElements = this._transformElements;\n      const newTransformElements = new Set();\n      let scrollTop = 0;\n      let scrollLeft = 0;\n\n      const win = this._getWindow();\n\n      for (let element = from; element && element.nodeType === Node.ELEMENT_NODE; element = dom.getParentElement(element)) {\n        let scrollTopLeft = scrollTopLeftCache.get(element); // getComputedStyle() and element.scrollLeft/Top() cause style recalculation,\n        // so we cache the result across all elements in the current bulk.\n\n        if (scrollTopLeft === undefined) {\n          const transform = win.getComputedStyle(element).transform;\n\n          if (transform && transform !== \"none\") {\n            scrollTopLeft = {\n              scrollTop: element.scrollTop,\n              scrollLeft: element.scrollLeft\n            };\n          }\n\n          scrollTopLeftCache.set(element, scrollTopLeft || null);\n        }\n\n        if (scrollTopLeft) {\n          newTransformElements.add(element);\n\n          if (!transformElements.has(element)) {\n            element.addEventListener(\"scroll\", this._addTransformOffsets);\n          }\n\n          scrollTop += scrollTopLeft.scrollTop;\n          scrollLeft += scrollTopLeft.scrollLeft;\n        }\n      }\n\n      for (const el of transformElements) {\n        if (!newTransformElements.has(el)) {\n          el.removeEventListener(\"scroll\", this._addTransformOffsets);\n        }\n      }\n\n      this._transformElements = newTransformElements;\n      return () => {\n        var _a, _b;\n\n        (_a = this._firstDummy) === null || _a === void 0 ? void 0 : _a.setTopLeft(scrollTop, scrollLeft);\n        (_b = this._lastDummy) === null || _b === void 0 ? void 0 : _b.setTopLeft(scrollTop, scrollLeft);\n      };\n    };\n\n    const el = element.get();\n\n    if (!el) {\n      throw new Error(\"No element\");\n    }\n\n    this._tabster = tabster;\n    this._getWindow = tabster.getWindow;\n    this._callForDefaultAction = callForDefaultAction;\n    const instance = el.__tabsterDummy;\n\n    (instance || this)._wrappers.push({\n      manager,\n      priority,\n      tabbable: true\n    });\n\n    if (instance) {\n      if (process.env.NODE_ENV === 'development') {\n        this._firstDummy && setDummyInputDebugValue(this._firstDummy, instance._wrappers);\n        this._lastDummy && setDummyInputDebugValue(this._lastDummy, instance._wrappers);\n      }\n\n      return instance;\n    }\n\n    el.__tabsterDummy = this; // Some elements allow only specific types of direct descendants and we need to\n    // put our dummy inputs inside or outside of the element accordingly.\n\n    const forcedDummyPosition = sys === null || sys === void 0 ? void 0 : sys.dummyInputsPosition;\n    const tagName = el.tagName;\n    this._isOutside = !forcedDummyPosition ? (outsideByDefault || tagName === \"UL\" || tagName === \"OL\" || tagName === \"TABLE\") && !(tagName === \"LI\" || tagName === \"TD\" || tagName === \"TH\") : forcedDummyPosition === SysDummyInputsPositions.Outside;\n    this._firstDummy = new DummyInput(this._getWindow, this._isOutside, {\n      isFirst: true\n    }, element);\n    this._lastDummy = new DummyInput(this._getWindow, this._isOutside, {\n      isFirst: false\n    }, element); // We will be checking dummy input parents to see if their child list have changed.\n    // So, it is enough to have just one of the inputs observed, because\n    // both dummy inputs always have the same parent.\n\n    const dummyElement = this._firstDummy.input;\n    dummyElement && tabster._dummyObserver.add(dummyElement, this._addDummyInputs);\n    this._firstDummy.onFocusIn = this._onFocusIn;\n    this._firstDummy.onFocusOut = this._onFocusOut;\n    this._lastDummy.onFocusIn = this._onFocusIn;\n    this._lastDummy.onFocusOut = this._onFocusOut;\n    this._element = element;\n\n    this._addDummyInputs();\n  }\n\n  dispose(manager, force) {\n    var _a, _b, _c, _d;\n\n    const wrappers = this._wrappers = this._wrappers.filter(w => w.manager !== manager && !force);\n\n    if (process.env.NODE_ENV === 'development') {\n      this._firstDummy && setDummyInputDebugValue(this._firstDummy, wrappers);\n      this._lastDummy && setDummyInputDebugValue(this._lastDummy, wrappers);\n    }\n\n    if (wrappers.length === 0) {\n      delete ((_a = this._element) === null || _a === void 0 ? void 0 : _a.get()).__tabsterDummy;\n\n      for (const el of this._transformElements) {\n        el.removeEventListener(\"scroll\", this._addTransformOffsets);\n      }\n\n      this._transformElements.clear();\n\n      const win = this._getWindow();\n\n      if (this._addTimer) {\n        win.clearTimeout(this._addTimer);\n        delete this._addTimer;\n      }\n\n      const dummyElement = (_b = this._firstDummy) === null || _b === void 0 ? void 0 : _b.input;\n      dummyElement && this._tabster._dummyObserver.remove(dummyElement);\n      (_c = this._firstDummy) === null || _c === void 0 ? void 0 : _c.dispose();\n      (_d = this._lastDummy) === null || _d === void 0 ? void 0 : _d.dispose();\n    }\n  }\n\n  _onFocus(isIn, dummyInput, isBackward, relatedTarget) {\n    var _a;\n\n    const wrapper = this._getCurrent();\n\n    if (wrapper && (!dummyInput.useDefaultAction || this._callForDefaultAction)) {\n      (_a = wrapper.manager.getHandler(isIn)) === null || _a === void 0 ? void 0 : _a(dummyInput, isBackward, relatedTarget);\n    }\n  }\n\n  _getCurrent() {\n    this._wrappers.sort((a, b) => {\n      if (a.tabbable !== b.tabbable) {\n        return a.tabbable ? -1 : 1;\n      }\n\n      return a.priority - b.priority;\n    });\n\n    return this._wrappers[0];\n  }\n\n  _ensurePosition() {\n    var _a, _b, _c;\n\n    const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n    const firstDummyInput = (_b = this._firstDummy) === null || _b === void 0 ? void 0 : _b.input;\n    const lastDummyInput = (_c = this._lastDummy) === null || _c === void 0 ? void 0 : _c.input;\n\n    if (!element || !firstDummyInput || !lastDummyInput) {\n      return;\n    }\n\n    if (this._isOutside) {\n      const elementParent = dom.getParentNode(element);\n\n      if (elementParent) {\n        const nextSibling = dom.getNextSibling(element);\n\n        if (nextSibling !== lastDummyInput) {\n          dom.insertBefore(elementParent, lastDummyInput, nextSibling);\n        }\n\n        if (dom.getPreviousElementSibling(element) !== firstDummyInput) {\n          dom.insertBefore(elementParent, firstDummyInput, element);\n        }\n      }\n    } else {\n      if (dom.getLastElementChild(element) !== lastDummyInput) {\n        dom.appendChild(element, lastDummyInput);\n      }\n\n      const firstElementChild = dom.getFirstElementChild(element);\n\n      if (firstElementChild && firstElementChild !== firstDummyInput && firstElementChild.parentNode) {\n        dom.insertBefore(firstElementChild.parentNode, firstDummyInput, firstElementChild);\n      }\n    }\n  }\n\n}\n\nfunction getLastChild$2(container) {\n  let lastChild = null;\n\n  for (let i = dom.getLastElementChild(container); i; i = dom.getLastElementChild(i)) {\n    lastChild = i;\n  }\n\n  return lastChild || undefined;\n}\nfunction getAdjacentElement(from, prev) {\n  let cur = from;\n  let adjacent = null;\n\n  while (cur && !adjacent) {\n    adjacent = prev ? dom.getPreviousElementSibling(cur) : dom.getNextElementSibling(cur);\n    cur = dom.getParentElement(cur);\n  }\n\n  return adjacent || undefined;\n}\nfunction augmentAttribute(tabster, element, name, value // Restore original value when undefined.\n) {\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const entry = tabster.storageEntry(element, true);\n  let ret = false;\n\n  if (!entry.aug) {\n    if (value === undefined) {\n      return ret;\n    }\n\n    entry.aug = {};\n  }\n\n  if (value === undefined) {\n    if (name in entry.aug) {\n      const origVal = entry.aug[name];\n      delete entry.aug[name];\n\n      if (origVal === null) {\n        element.removeAttribute(name);\n      } else {\n        element.setAttribute(name, origVal);\n      }\n\n      ret = true;\n    }\n  } else {\n    let origValue;\n\n    if (!(name in entry.aug)) {\n      origValue = element.getAttribute(name);\n    }\n\n    if (origValue !== undefined && origValue !== value) {\n      entry.aug[name] = origValue;\n\n      if (value === null) {\n        element.removeAttribute(name);\n      } else {\n        element.setAttribute(name, value);\n      }\n\n      ret = true;\n    }\n  }\n\n  if (value === undefined && Object.keys(entry.aug).length === 0) {\n    delete entry.aug;\n    tabster.storageEntry(element, false);\n  }\n\n  return ret;\n}\nfunction isDisplayNone(element) {\n  var _a, _b;\n\n  const elementDocument = element.ownerDocument;\n  const computedStyle = (_a = elementDocument.defaultView) === null || _a === void 0 ? void 0 : _a.getComputedStyle(element); // offsetParent is null for elements with display:none, display:fixed and for <body>.\n\n  if (element.offsetParent === null && elementDocument.body !== element && (computedStyle === null || computedStyle === void 0 ? void 0 : computedStyle.position) !== \"fixed\") {\n    return true;\n  } // For our purposes of looking for focusable elements, visibility:hidden has the same\n  // effect as display:none.\n\n\n  if ((computedStyle === null || computedStyle === void 0 ? void 0 : computedStyle.visibility) === \"hidden\") {\n    return true;\n  } // if an element has display: fixed, we need to check if it is also hidden with CSS,\n  // or within a parent hidden with CSS\n\n\n  if ((computedStyle === null || computedStyle === void 0 ? void 0 : computedStyle.position) === \"fixed\") {\n    if (computedStyle.display === \"none\") {\n      return true;\n    }\n\n    if (((_b = element.parentElement) === null || _b === void 0 ? void 0 : _b.offsetParent) === null && elementDocument.body !== element.parentElement) {\n      return true;\n    }\n  }\n\n  return false;\n}\nfunction isRadio(element) {\n  return element.tagName === \"INPUT\" && !!element.name && element.type === \"radio\";\n}\nfunction getRadioButtonGroup(element) {\n  if (!isRadio(element)) {\n    return;\n  }\n\n  const name = element.name;\n  let radioButtons = Array.from(dom.getElementsByName(element, name));\n  let checked;\n  radioButtons = radioButtons.filter(el => {\n    if (isRadio(el)) {\n      if (el.checked) {\n        checked = el;\n      }\n\n      return true;\n    }\n\n    return false;\n  });\n  return {\n    name,\n    buttons: new Set(radioButtons),\n    checked\n  };\n}\n/**\r\n * If the passed element is Tabster dummy input, returns the container element this dummy input belongs to.\r\n * @param element Element to check for being dummy input.\r\n * @returns Dummy input container element (if the passed element is a dummy input) or null.\r\n */\n\nfunction getDummyInputContainer(element) {\n  var _a;\n\n  return ((_a = element === null || element === void 0 ? void 0 : element.__tabsterDummyContainer) === null || _a === void 0 ? void 0 : _a.get()) || null;\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction getTabsterAttribute(props, plain) {\n  const attr = JSON.stringify(props);\n\n  if (plain === true) {\n    return attr;\n  }\n\n  return {\n    [TABSTER_ATTRIBUTE_NAME]: attr\n  };\n}\n/**\r\n * Updates Tabster props object with new props.\r\n * @param element an element to set data-tabster attribute on.\r\n * @param props current Tabster props to update.\r\n * @param newProps new Tabster props to add.\r\n *  When the value of a property in newProps is undefined, the property\r\n *  will be removed from the attribute.\r\n */\n\nfunction mergeTabsterProps(props, newProps) {\n  for (const key of Object.keys(newProps)) {\n    const value = newProps[key];\n\n    if (value) {\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      props[key] = value;\n    } else {\n      delete props[key];\n    }\n  }\n}\n/**\r\n * Sets or updates Tabster attribute of the element.\r\n * @param element an element to set data-tabster attribute on.\r\n * @param newProps new Tabster props to set.\r\n * @param update if true, newProps will be merged with the existing props.\r\n *  When true and the value of a property in newProps is undefined, the property\r\n *  will be removed from the attribute.\r\n */\n\nfunction setTabsterAttribute(element, newProps, update) {\n  let props;\n\n  if (update) {\n    const attr = element.getAttribute(TABSTER_ATTRIBUTE_NAME);\n\n    if (attr) {\n      try {\n        props = JSON.parse(attr);\n      } catch (e) {\n        if (process.env.NODE_ENV === 'development') {\n          console.error(`data-tabster attribute error: ${e}`, element);\n        }\n      }\n    }\n  }\n\n  if (!props) {\n    props = {};\n  }\n\n  mergeTabsterProps(props, newProps);\n\n  if (Object.keys(props).length > 0) {\n    element.setAttribute(TABSTER_ATTRIBUTE_NAME, getTabsterAttribute(props, true));\n  } else {\n    element.removeAttribute(TABSTER_ATTRIBUTE_NAME);\n  }\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nfunction _setInformativeStyle$3(weakElement, remove, id) {\n  if (process.env.NODE_ENV === 'development') {\n    const element = weakElement.get();\n\n    if (element) {\n      if (remove) {\n        element.style.removeProperty(\"--tabster-root\");\n      } else {\n        element.style.setProperty(\"--tabster-root\", id + \",\");\n      }\n    }\n  }\n}\n\nclass RootDummyManager extends DummyInputManager {\n  constructor(tabster, element, setFocused, sys) {\n    super(tabster, element, DummyInputManagerPriorities.Root, sys, undefined, true);\n\n    this._onDummyInputFocus = dummyInput => {\n      var _a;\n\n      if (dummyInput.useDefaultAction) {\n        // When we've reached the last focusable element, we want to let the browser\n        // to move the focus outside of the page. In order to do that we're synchronously\n        // calling focus() of the dummy input from the Tab key handler and allowing\n        // the default action to move the focus out.\n        this._setFocused(false);\n      } else {\n        // The only way a dummy input gets focused is during the keyboard navigation.\n        this._tabster.keyboardNavigation.setNavigatingWithKeyboard(true);\n\n        const element = this._element.get();\n\n        if (element) {\n          this._setFocused(true);\n\n          const toFocus = this._tabster.focusedElement.getFirstOrLastTabbable(dummyInput.isFirst, {\n            container: element,\n            ignoreAccessibility: true\n          });\n\n          if (toFocus) {\n            nativeFocus(toFocus);\n            return;\n          }\n        }\n\n        (_a = dummyInput.input) === null || _a === void 0 ? void 0 : _a.blur();\n      }\n    };\n\n    this._setHandlers(this._onDummyInputFocus);\n\n    this._tabster = tabster;\n    this._setFocused = setFocused;\n  }\n\n}\n\nclass Root extends TabsterPart {\n  constructor(tabster, element, onDispose, props, sys) {\n    super(tabster, element, props);\n    this._isFocused = false;\n\n    this._setFocused = hasFocused => {\n      var _a;\n\n      if (this._setFocusedTimer) {\n        this._tabster.getWindow().clearTimeout(this._setFocusedTimer);\n\n        delete this._setFocusedTimer;\n      }\n\n      if (this._isFocused === hasFocused) {\n        return;\n      }\n\n      const element = this._element.get();\n\n      if (element) {\n        if (hasFocused) {\n          this._isFocused = true;\n          (_a = this._dummyManager) === null || _a === void 0 ? void 0 : _a.setTabbable(false);\n          element.dispatchEvent(new RootFocusEvent({\n            element\n          }));\n        } else {\n          this._setFocusedTimer = this._tabster.getWindow().setTimeout(() => {\n            var _a;\n\n            delete this._setFocusedTimer;\n            this._isFocused = false;\n            (_a = this._dummyManager) === null || _a === void 0 ? void 0 : _a.setTabbable(true);\n            element.dispatchEvent(new RootBlurEvent({\n              element\n            }));\n          }, 0);\n        }\n      }\n    };\n\n    this._onFocusIn = event => {\n      const getParent = this._tabster.getParent;\n\n      const rootElement = this._element.get();\n\n      let curElement = event.composedPath()[0];\n\n      do {\n        if (curElement === rootElement) {\n          this._setFocused(true);\n\n          return;\n        }\n\n        curElement = curElement && getParent(curElement);\n      } while (curElement);\n    };\n\n    this._onFocusOut = () => {\n      this._setFocused(false);\n    };\n\n    this._onDispose = onDispose;\n    const win = tabster.getWindow;\n    this.uid = getElementUId(win, element);\n    this._sys = sys;\n\n    if (tabster.controlTab || tabster.rootDummyInputs) {\n      this.addDummyInputs();\n    }\n\n    const w = win();\n    const doc = w.document;\n    doc.addEventListener(KEYBORG_FOCUSIN, this._onFocusIn);\n    doc.addEventListener(KEYBORG_FOCUSOUT, this._onFocusOut);\n\n    this._add();\n  }\n\n  addDummyInputs() {\n    if (!this._dummyManager) {\n      this._dummyManager = new RootDummyManager(this._tabster, this._element, this._setFocused, this._sys);\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    this._onDispose(this);\n\n    const win = this._tabster.getWindow();\n\n    const doc = win.document;\n    doc.removeEventListener(KEYBORG_FOCUSIN, this._onFocusIn);\n    doc.removeEventListener(KEYBORG_FOCUSOUT, this._onFocusOut);\n\n    if (this._setFocusedTimer) {\n      win.clearTimeout(this._setFocusedTimer);\n      delete this._setFocusedTimer;\n    }\n\n    (_a = this._dummyManager) === null || _a === void 0 ? void 0 : _a.dispose();\n\n    this._remove();\n  }\n\n  moveOutWithDefaultAction(isBackward, relatedEvent) {\n    const dummyManager = this._dummyManager;\n\n    if (dummyManager) {\n      dummyManager.moveOutWithDefaultAction(isBackward, relatedEvent);\n    } else {\n      const el = this.getElement();\n\n      if (el) {\n        RootDummyManager.moveWithPhantomDummy(this._tabster, el, true, isBackward, relatedEvent);\n      }\n    }\n  }\n\n  _add() {\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$3(this._element, false, this.uid);\n    }\n  }\n\n  _remove() {\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$3(this._element, true);\n    }\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\nclass RootAPI {\n  constructor(tabster, autoRoot) {\n    this._autoRootWaiting = false;\n    this._roots = {};\n    this._forceDummy = false;\n    this.rootById = {};\n\n    this._autoRootCreate = () => {\n      var _a;\n\n      const doc = this._win().document;\n\n      const body = doc.body;\n\n      if (body) {\n        this._autoRootUnwait(doc);\n\n        const props = this._autoRoot;\n\n        if (props) {\n          setTabsterAttribute(body, {\n            root: props\n          }, true);\n          updateTabsterByAttribute(this._tabster, body);\n          return (_a = getTabsterOnElement(this._tabster, body)) === null || _a === void 0 ? void 0 : _a.root;\n        }\n      } else if (!this._autoRootWaiting) {\n        this._autoRootWaiting = true;\n        doc.addEventListener(\"readystatechange\", this._autoRootCreate);\n      }\n\n      return undefined;\n    };\n\n    this._onRootDispose = root => {\n      delete this._roots[root.id];\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    this._autoRoot = autoRoot;\n    tabster.queueInit(() => {\n      if (this._autoRoot) {\n        this._autoRootCreate();\n      }\n    });\n  }\n\n  _autoRootUnwait(doc) {\n    doc.removeEventListener(\"readystatechange\", this._autoRootCreate);\n    this._autoRootWaiting = false;\n  }\n\n  dispose() {\n    const win = this._win();\n\n    this._autoRootUnwait(win.document);\n\n    delete this._autoRoot;\n    Object.keys(this._roots).forEach(rootId => {\n      if (this._roots[rootId]) {\n        this._roots[rootId].dispose();\n\n        delete this._roots[rootId];\n      }\n    });\n    this.rootById = {};\n  }\n\n  createRoot(element, props, sys) {\n    if (process.env.NODE_ENV === 'development') ;\n\n    const newRoot = new Root(this._tabster, element, this._onRootDispose, props, sys);\n    this._roots[newRoot.id] = newRoot;\n\n    if (this._forceDummy) {\n      newRoot.addDummyInputs();\n    }\n\n    return newRoot;\n  }\n\n  addDummyInputs() {\n    this._forceDummy = true;\n    const roots = this._roots;\n\n    for (const id of Object.keys(roots)) {\n      roots[id].addDummyInputs();\n    }\n  }\n\n  static getRootByUId(getWindow, id) {\n    const tabster = getWindow().__tabsterInstance;\n\n    return tabster && tabster.root.rootById[id];\n  }\n  /**\r\n   * Fetches the tabster context for an element walking up its ancestors\r\n   *\r\n   * @param tabster Tabster instance\r\n   * @param element The element the tabster context should represent\r\n   * @param options Additional options\r\n   * @returns undefined if the element is not a child of a tabster root, otherwise all applicable tabster behaviours and configurations\r\n   */\n\n\n  static getTabsterContext(tabster, element, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    var _a, _b, _c, _d;\n\n    if (!element.ownerDocument) {\n      return undefined;\n    }\n\n    const {\n      checkRtl,\n      referenceElement\n    } = options;\n    const getParent = tabster.getParent; // Normally, the initialization starts on the next tick after the tabster\n    // instance creation. However, if the application starts using it before\n    // the next tick, we need to make sure the initialization is done.\n\n    tabster.drainInitQueue();\n    let root;\n    let modalizer;\n    let groupper;\n    let mover;\n    let excludedFromMover = false;\n    let groupperBeforeMover;\n    let modalizerInGroupper;\n    let dirRightToLeft;\n    let uncontrolled;\n    let curElement = referenceElement || element;\n    const ignoreKeydown = {};\n\n    while (curElement && (!root || checkRtl)) {\n      const tabsterOnElement = getTabsterOnElement(tabster, curElement);\n\n      if (checkRtl && dirRightToLeft === undefined) {\n        const dir = curElement.dir;\n\n        if (dir) {\n          dirRightToLeft = dir.toLowerCase() === \"rtl\";\n        }\n      }\n\n      if (!tabsterOnElement) {\n        curElement = getParent(curElement);\n        continue;\n      }\n\n      const tagName = curElement.tagName;\n\n      if (tabsterOnElement.uncontrolled || tagName === \"IFRAME\" || tagName === \"WEBVIEW\") {\n        uncontrolled = curElement;\n      }\n\n      if (!mover && ((_a = tabsterOnElement.focusable) === null || _a === void 0 ? void 0 : _a.excludeFromMover) && !groupper) {\n        excludedFromMover = true;\n      }\n\n      const curModalizer = tabsterOnElement.modalizer;\n      const curGroupper = tabsterOnElement.groupper;\n      const curMover = tabsterOnElement.mover;\n\n      if (!modalizer && curModalizer) {\n        modalizer = curModalizer;\n      }\n\n      if (!groupper && curGroupper && (!modalizer || curModalizer)) {\n        if (modalizer) {\n          // Modalizer dominates the groupper when they are on the same node and the groupper is active.\n          if (!curGroupper.isActive() && curGroupper.getProps().tabbability && modalizer.userId !== ((_b = tabster.modalizer) === null || _b === void 0 ? void 0 : _b.activeId)) {\n            modalizer = undefined;\n            groupper = curGroupper;\n          }\n\n          modalizerInGroupper = curGroupper;\n        } else {\n          groupper = curGroupper;\n        }\n      }\n\n      if (!mover && curMover && (!modalizer || curModalizer) && (!curGroupper || curElement !== element) && curElement.contains(element) // Mover makes sense only for really inside elements, not for virutal out of the DOM order children.\n      ) {\n        mover = curMover;\n        groupperBeforeMover = !!groupper && groupper !== curGroupper;\n      }\n\n      if (tabsterOnElement.root) {\n        root = tabsterOnElement.root;\n      }\n\n      if ((_c = tabsterOnElement.focusable) === null || _c === void 0 ? void 0 : _c.ignoreKeydown) {\n        Object.assign(ignoreKeydown, tabsterOnElement.focusable.ignoreKeydown);\n      }\n\n      curElement = getParent(curElement);\n    } // No root element could be found, try to get an auto root\n\n\n    if (!root) {\n      const rootAPI = tabster.root;\n      const autoRoot = rootAPI._autoRoot;\n\n      if (autoRoot) {\n        if ((_d = element.ownerDocument) === null || _d === void 0 ? void 0 : _d.body) {\n          root = rootAPI._autoRootCreate();\n        }\n      }\n    }\n\n    if (groupper && !mover) {\n      groupperBeforeMover = true;\n    }\n\n    if (process.env.NODE_ENV === 'development' && !root) {\n      if (modalizer || groupper || mover) {\n        console.error(\"Tabster Root is required for Mover, Groupper and Modalizer to work.\");\n      }\n    }\n\n    const shouldIgnoreKeydown = event => !!ignoreKeydown[event.key];\n\n    return root ? {\n      root,\n      modalizer,\n      groupper,\n      mover,\n      groupperBeforeMover,\n      modalizerInGroupper,\n      rtl: checkRtl ? !!dirRightToLeft : undefined,\n      uncontrolled,\n      excludedFromMover,\n      ignoreKeydown: shouldIgnoreKeydown\n    } : undefined;\n  }\n\n  static getRoot(tabster, element) {\n    var _a;\n\n    const getParent = tabster.getParent;\n\n    for (let el = element; el; el = getParent(el)) {\n      const root = (_a = getTabsterOnElement(tabster, el)) === null || _a === void 0 ? void 0 : _a.root;\n\n      if (root) {\n        return root;\n      }\n    }\n\n    return undefined;\n  }\n\n  onRoot(root, removed) {\n    if (removed) {\n      delete this.rootById[root.uid];\n    } else {\n      this.rootById[root.uid] = root;\n    }\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst _containerHistoryLength = 10;\nclass DeloserItemBase {}\nclass DeloserItem extends DeloserItemBase {\n  constructor(tabster, deloser) {\n    super();\n    this.uid = deloser.uid;\n    this._tabster = tabster;\n    this._deloser = deloser;\n  }\n\n  belongsTo(deloser) {\n    return deloser === this._deloser;\n  }\n\n  unshift(element) {\n    this._deloser.unshift(element);\n  }\n\n  async focusAvailable() {\n    const available = this._deloser.findAvailable();\n\n    const deloserElement = this._deloser.getElement();\n\n    if (available && deloserElement) {\n      if (!deloserElement.dispatchEvent(new TabsterMoveFocusEvent({\n        by: \"deloser\",\n        owner: deloserElement,\n        next: available\n      }))) {\n        // Default action is prevented, don't look further.\n        return null;\n      }\n\n      return this._tabster.focusedElement.focus(available);\n    }\n\n    return false;\n  }\n\n  async resetFocus() {\n    const getWindow = this._tabster.getWindow;\n    return getPromise(getWindow).resolve(this._deloser.resetFocus());\n  }\n\n}\nclass DeloserHistoryByRootBase {\n  constructor(tabster, rootUId) {\n    this._history = [];\n    this._tabster = tabster;\n    this.rootUId = rootUId;\n  }\n\n  getLength() {\n    return this._history.length;\n  }\n\n  removeDeloser(deloser) {\n    this._history = this._history.filter(c => !c.belongsTo(deloser));\n  }\n\n  hasDeloser(deloser) {\n    return this._history.some(d => d.belongsTo(deloser));\n  }\n\n}\n\nclass DeloserHistoryByRoot extends DeloserHistoryByRootBase {\n  unshiftToDeloser(deloser, element) {\n    let item;\n\n    for (let i = 0; i < this._history.length; i++) {\n      if (this._history[i].belongsTo(deloser)) {\n        item = this._history[i];\n\n        this._history.splice(i, 1);\n\n        break;\n      }\n    }\n\n    if (!item) {\n      item = new DeloserItem(this._tabster, deloser);\n    }\n\n    item.unshift(element);\n\n    this._history.unshift(item);\n\n    this._history.splice(_containerHistoryLength, this._history.length - _containerHistoryLength);\n  }\n\n  async focusAvailable(from) {\n    let skip = !!from;\n\n    for (const i of this._history) {\n      if (from && i.belongsTo(from)) {\n        skip = false;\n      }\n\n      if (!skip) {\n        const result = await i.focusAvailable(); // Result is null when the default action is prevented by the application\n        // and we don't need to look further.\n\n        if (result || result === null) {\n          return result;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  async resetFocus(from) {\n    let skip = !!from;\n    const resetQueue = {};\n\n    for (const i of this._history) {\n      if (from && i.belongsTo(from)) {\n        skip = false;\n      }\n\n      if (!skip && !resetQueue[i.uid]) {\n        resetQueue[i.uid] = i;\n      }\n    } // Nothing is found, at least try to reset.\n\n\n    for (const id of Object.keys(resetQueue)) {\n      if (await resetQueue[id].resetFocus()) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n}\n\nclass DeloserHistory {\n  constructor(tabster) {\n    // eslint-disable-next-line @typescript-eslint/ban-types\n    this._history = [];\n    this._tabster = tabster;\n  }\n\n  dispose() {\n    this._history = [];\n  }\n\n  process(element) {\n    var _a;\n\n    const ctx = RootAPI.getTabsterContext(this._tabster, element);\n    const rootUId = ctx && ctx.root.uid;\n    const deloser = DeloserAPI.getDeloser(this._tabster, element);\n\n    if (!rootUId || !deloser) {\n      return undefined;\n    }\n\n    const historyByRoot = this.make(rootUId, () => new DeloserHistoryByRoot(this._tabster, rootUId));\n\n    if (!ctx || !ctx.modalizer || ((_a = ctx.modalizer) === null || _a === void 0 ? void 0 : _a.isActive())) {\n      historyByRoot.unshiftToDeloser(deloser, element);\n    }\n\n    return deloser;\n  }\n\n  make(rootUId, createInstance) {\n    let historyByRoot;\n\n    for (let i = 0; i < this._history.length; i++) {\n      const hbr = this._history[i];\n\n      if (hbr.rootUId === rootUId) {\n        historyByRoot = hbr;\n\n        this._history.splice(i, 1);\n\n        break;\n      }\n    }\n\n    if (!historyByRoot) {\n      historyByRoot = createInstance();\n    }\n\n    this._history.unshift(historyByRoot);\n\n    this._history.splice(_containerHistoryLength, this._history.length - _containerHistoryLength);\n\n    return historyByRoot;\n  }\n\n  removeDeloser(deloser) {\n    this._history.forEach(i => {\n      i.removeDeloser(deloser);\n    });\n\n    this._history = this._history.filter(i => i.getLength() > 0);\n  }\n\n  async focusAvailable(from) {\n    let skip = !!from;\n\n    for (const h of this._history) {\n      if (from && h.hasDeloser(from)) {\n        skip = false;\n      }\n\n      if (!skip) {\n        const result = await h.focusAvailable(from); // Result is null when the default action is prevented by the application\n        // and we don't need to look further.\n\n        if (result || result === null) {\n          return result;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  async resetFocus(from) {\n    let skip = !!from;\n\n    for (const h of this._history) {\n      if (from && h.hasDeloser(from)) {\n        skip = false;\n      }\n\n      if (!skip && (await h.resetFocus(from))) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n}\n\nfunction _setInformativeStyle$2(weakElement, remove, isActive, snapshotIndex) {\n  if (process.env.NODE_ENV === 'development') {\n    const element = weakElement.get();\n\n    if (element) {\n      if (remove) {\n        element.style.removeProperty(\"--tabster-deloser\");\n      } else {\n        element.style.setProperty(\"--tabster-deloser\", (isActive ? \"active\" : \"inactive\") + \",\" + (\"snapshot-\" + snapshotIndex));\n      }\n    }\n  }\n}\n\nfunction buildElementSelector(element, withClass, withIndex) {\n  const selector = [];\n  const escapeRegExp = /(:|\\.|\\[|\\]|,|=|@)/g;\n  const escapeReplaceValue = \"\\\\$1\";\n  const elementId = element.getAttribute(\"id\");\n\n  if (elementId) {\n    selector.push(\"#\" + elementId.replace(escapeRegExp, escapeReplaceValue));\n  }\n\n  if (withClass !== false && element.className) {\n    element.className.split(\" \").forEach(cls => {\n      cls = cls.trim();\n\n      if (cls) {\n        selector.push(\".\" + cls.replace(escapeRegExp, escapeReplaceValue));\n      }\n    });\n  }\n\n  let index = 0;\n  let el;\n\n  if (withIndex !== false && selector.length === 0) {\n    el = element;\n\n    while (el) {\n      index++;\n      el = el.previousElementSibling;\n    }\n\n    selector.unshift(\":nth-child(\" + index + \")\");\n  }\n\n  selector.unshift(element.tagName.toLowerCase());\n  return selector.join(\"\");\n}\n\nfunction buildSelector(element) {\n  if (!documentContains(element.ownerDocument, element)) {\n    return undefined;\n  }\n\n  const selector = [buildElementSelector(element)];\n  let node = dom.getParentNode(element);\n\n  while (node && node.nodeType !== Node.DOCUMENT_FRAGMENT_NODE) {\n    // Stop at the shadow root as cross shadow selectors won't work.\n    if (node.nodeType === Node.ELEMENT_NODE) {\n      const isBody = node.tagName === \"BODY\";\n      selector.unshift(buildElementSelector(node, false, !isBody));\n\n      if (isBody) {\n        break;\n      }\n    }\n\n    node = dom.getParentNode(node);\n  }\n\n  return selector.join(\" \");\n}\n\nclass Deloser extends TabsterPart {\n  constructor(tabster, element, onDispose, props) {\n    super(tabster, element, props);\n    this._isActive = false;\n    this._history = [[]];\n    this._snapshotIndex = 0;\n\n    this.isActive = () => {\n      return this._isActive;\n    };\n\n    this.setSnapshot = index => {\n      this._snapshotIndex = index;\n\n      if (this._history.length > index + 1) {\n        this._history.splice(index + 1, this._history.length - index - 1);\n      }\n\n      if (!this._history[index]) {\n        this._history[index] = [];\n      }\n\n      if (process.env.NODE_ENV === 'development') {\n        _setInformativeStyle$2(this._element, false, this._isActive, this._snapshotIndex);\n      }\n    };\n\n    this.focusFirst = () => {\n      const e = this._element.get();\n\n      return !!e && this._tabster.focusedElement.focusFirst({\n        container: e\n      });\n    };\n\n    this.focusDefault = () => {\n      const e = this._element.get();\n\n      return !!e && this._tabster.focusedElement.focusDefault(e);\n    };\n\n    this.resetFocus = () => {\n      const e = this._element.get();\n\n      return !!e && this._tabster.focusedElement.resetFocus(e);\n    };\n\n    this.clearHistory = preserveExisting => {\n      const element = this._element.get();\n\n      if (!element) {\n        this._history[this._snapshotIndex] = [];\n        return;\n      }\n\n      this._history[this._snapshotIndex] = this._history[this._snapshotIndex].filter(we => {\n        const e = we.get();\n        return e && preserveExisting ? dom.nodeContains(element, e) : false;\n      });\n    };\n\n    this.uid = getElementUId(tabster.getWindow, element);\n    this.strategy = props.strategy || DeloserStrategies.Auto;\n    this._onDispose = onDispose;\n\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$2(this._element, false, this._isActive, this._snapshotIndex);\n    }\n  }\n\n  dispose() {\n    this._remove();\n\n    this._onDispose(this);\n\n    this._isActive = false;\n    this._snapshotIndex = 0;\n    this._props = {};\n    this._history = [];\n  }\n\n  setActive(active) {\n    this._isActive = active;\n\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$2(this._element, false, this._isActive, this._snapshotIndex);\n    }\n  }\n\n  getActions() {\n    return {\n      focusDefault: this.focusDefault,\n      focusFirst: this.focusFirst,\n      resetFocus: this.resetFocus,\n      clearHistory: this.clearHistory,\n      setSnapshot: this.setSnapshot,\n      isActive: this.isActive\n    };\n  }\n\n  unshift(element) {\n    let cur = this._history[this._snapshotIndex];\n    cur = this._history[this._snapshotIndex] = cur.filter(we => {\n      const e = we.get();\n      return e && e !== element;\n    });\n    cur.unshift(new WeakHTMLElement(this._tabster.getWindow, element, buildSelector(element)));\n\n    while (cur.length > _containerHistoryLength) {\n      cur.pop();\n    }\n  }\n\n  findAvailable() {\n    const element = this._element.get();\n\n    if (!element || !this._tabster.focusable.isVisible(element)) {\n      return null;\n    }\n\n    let restoreFocusOrder = this._props.restoreFocusOrder;\n    let available = null;\n    const ctx = RootAPI.getTabsterContext(this._tabster, element);\n\n    if (!ctx) {\n      return null;\n    }\n\n    const root = ctx.root;\n    const rootElement = root.getElement();\n\n    if (!rootElement) {\n      return null;\n    }\n\n    if (restoreFocusOrder === undefined) {\n      restoreFocusOrder = root.getProps().restoreFocusOrder;\n    }\n\n    if (restoreFocusOrder === RestoreFocusOrders.RootDefault) {\n      available = this._tabster.focusable.findDefault({\n        container: rootElement\n      });\n    }\n\n    if (!available && restoreFocusOrder === RestoreFocusOrders.RootFirst) {\n      available = this._findFirst(rootElement);\n    }\n\n    if (available) {\n      return available;\n    }\n\n    const availableInHistory = this._findInHistory();\n\n    if (availableInHistory && restoreFocusOrder === RestoreFocusOrders.History) {\n      return availableInHistory;\n    }\n\n    const availableDefault = this._tabster.focusable.findDefault({\n      container: element\n    });\n\n    if (availableDefault && restoreFocusOrder === RestoreFocusOrders.DeloserDefault) {\n      return availableDefault;\n    }\n\n    const availableFirst = this._findFirst(element);\n\n    if (availableFirst && restoreFocusOrder === RestoreFocusOrders.DeloserFirst) {\n      return availableFirst;\n    }\n\n    return availableDefault || availableInHistory || availableFirst || null;\n  }\n\n  customFocusLostHandler(element) {\n    return element.dispatchEvent(new DeloserFocusLostEvent(this.getActions()));\n  }\n\n  _findInHistory() {\n    const cur = this._history[this._snapshotIndex].slice(0);\n\n    this.clearHistory(true);\n\n    for (let i = 0; i < cur.length; i++) {\n      const we = cur[i];\n      const e = we.get();\n\n      const element = this._element.get();\n\n      if (e && element && dom.nodeContains(element, e)) {\n        if (this._tabster.focusable.isFocusable(e)) {\n          return e;\n        }\n      } else if (!this._props.noSelectorCheck) {\n        // Element is not in the DOM, try to locate the node by it's\n        // selector. This might return not exactly the right node,\n        // but it would be easily fixable by having more detailed selectors.\n        const selector = we.getData();\n\n        if (selector && element) {\n          let els;\n\n          try {\n            els = dom.querySelectorAll(element.ownerDocument, selector);\n          } catch (e) {\n            if (process.env.NODE_ENV === 'development') {\n              // This should never happen, unless there is some bug in buildElementSelector().\n              console.error(`Failed to querySelectorAll('${selector}')`);\n            }\n\n            continue;\n          }\n\n          for (let i = 0; i < els.length; i++) {\n            const el = els[i];\n\n            if (el && this._tabster.focusable.isFocusable(el)) {\n              return el;\n            }\n          }\n        }\n      }\n    }\n\n    return null;\n  }\n\n  _findFirst(element) {\n    if (this._tabster.keyboardNavigation.isNavigatingWithKeyboard()) {\n      const first = this._tabster.focusable.findFirst({\n        container: element,\n        useActiveModalizer: true\n      });\n\n      if (first) {\n        return first;\n      }\n    }\n\n    return null;\n  }\n\n  _remove() {\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$2(this._element, true);\n    }\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\nclass DeloserAPI {\n  constructor(tabster, props) {\n    /**\r\n     * Tracks if focus is inside a deloser\r\n     */\n    this._inDeloser = false;\n    this._isRestoringFocus = false;\n    this._isPaused = false;\n\n    this._onRestoreFocus = event => {\n      var _a;\n\n      const target = event.composedPath()[0];\n\n      if (target) {\n        const available = (_a = DeloserAPI.getDeloser(this._tabster, target)) === null || _a === void 0 ? void 0 : _a.findAvailable();\n\n        if (available) {\n          this._tabster.focusedElement.focus(available);\n        }\n\n        event.stopImmediatePropagation();\n      }\n    };\n\n    this._onFocus = e => {\n      if (this._restoreFocusTimer) {\n        this._win().clearTimeout(this._restoreFocusTimer);\n\n        this._restoreFocusTimer = undefined;\n      }\n\n      if (!e) {\n        this._scheduleRestoreFocus();\n\n        return;\n      }\n\n      const deloser = this._history.process(e);\n\n      if (deloser) {\n        this._activate(deloser);\n      } else {\n        this._deactivate();\n      }\n    };\n\n    this._onDeloserDispose = deloser => {\n      this._history.removeDeloser(deloser);\n\n      if (deloser.isActive()) {\n        this._scheduleRestoreFocus();\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    this._history = new DeloserHistory(tabster);\n    tabster.queueInit(() => {\n      this._tabster.focusedElement.subscribe(this._onFocus);\n\n      const doc = this._win().document;\n\n      doc.addEventListener(DeloserRestoreFocusEventName, this._onRestoreFocus);\n      const activeElement = dom.getActiveElement(doc);\n\n      if (activeElement && activeElement !== doc.body) {\n        // Adding currently focused element to the deloser history.\n        this._onFocus(activeElement);\n      }\n    });\n    const autoDeloser = props === null || props === void 0 ? void 0 : props.autoDeloser;\n\n    if (autoDeloser) {\n      this._autoDeloser = autoDeloser;\n    }\n  }\n\n  dispose() {\n    const win = this._win();\n\n    if (this._restoreFocusTimer) {\n      win.clearTimeout(this._restoreFocusTimer);\n      this._restoreFocusTimer = undefined;\n    }\n\n    if (this._autoDeloserInstance) {\n      this._autoDeloserInstance.dispose();\n\n      delete this._autoDeloserInstance;\n      delete this._autoDeloser;\n    }\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    win.document.removeEventListener(DeloserRestoreFocusEventName, this._onRestoreFocus);\n\n    this._history.dispose();\n\n    delete this._curDeloser;\n  }\n\n  createDeloser(element, props) {\n    var _a;\n\n    if (process.env.NODE_ENV === 'development') ;\n\n    const deloser = new Deloser(this._tabster, element, this._onDeloserDispose, props);\n\n    if (dom.nodeContains(element, (_a = this._tabster.focusedElement.getFocusedElement()) !== null && _a !== void 0 ? _a : null)) {\n      this._activate(deloser);\n    }\n\n    return deloser;\n  }\n\n  getActions(element) {\n    for (let e = element; e; e = dom.getParentElement(e)) {\n      const tabsterOnElement = getTabsterOnElement(this._tabster, e);\n\n      if (tabsterOnElement && tabsterOnElement.deloser) {\n        return tabsterOnElement.deloser.getActions();\n      }\n    }\n\n    return undefined;\n  }\n\n  pause() {\n    this._isPaused = true;\n\n    if (this._restoreFocusTimer) {\n      this._win().clearTimeout(this._restoreFocusTimer);\n\n      this._restoreFocusTimer = undefined;\n    }\n  }\n\n  resume(restore) {\n    this._isPaused = false;\n\n    if (restore) {\n      this._scheduleRestoreFocus();\n    }\n  }\n  /**\r\n   * Activates and sets the current deloser\r\n   */\n\n\n  _activate(deloser) {\n    const curDeloser = this._curDeloser;\n\n    if (curDeloser !== deloser) {\n      this._inDeloser = true;\n      curDeloser === null || curDeloser === void 0 ? void 0 : curDeloser.setActive(false);\n      deloser.setActive(true);\n      this._curDeloser = deloser;\n    }\n  }\n  /**\r\n   * Called when focus should no longer be in a deloser\r\n   */\n\n\n  _deactivate() {\n    var _a;\n\n    this._inDeloser = false;\n    (_a = this._curDeloser) === null || _a === void 0 ? void 0 : _a.setActive(false);\n    this._curDeloser = undefined;\n  }\n\n  _scheduleRestoreFocus(force) {\n    if (this._isPaused || this._isRestoringFocus) {\n      return;\n    }\n\n    const restoreFocus = async () => {\n      this._restoreFocusTimer = undefined;\n\n      const lastFocused = this._tabster.focusedElement.getLastFocusedElement();\n\n      if (!force && (this._isRestoringFocus || !this._inDeloser || lastFocused && !isDisplayNone(lastFocused))) {\n        return;\n      }\n\n      const curDeloser = this._curDeloser;\n      let isManual = false;\n\n      if (curDeloser) {\n        if (lastFocused && curDeloser.customFocusLostHandler(lastFocused)) {\n          return;\n        }\n\n        if (curDeloser.strategy === DeloserStrategies.Manual) {\n          isManual = true;\n        } else {\n          const curDeloserElement = curDeloser.getElement();\n          const el = curDeloser.findAvailable();\n\n          if (el && (!(curDeloserElement === null || curDeloserElement === void 0 ? void 0 : curDeloserElement.dispatchEvent(new TabsterMoveFocusEvent({\n            by: \"deloser\",\n            owner: curDeloserElement,\n            next: el\n          }))) || this._tabster.focusedElement.focus(el))) {\n            return;\n          }\n        }\n      }\n\n      this._deactivate();\n\n      if (isManual) {\n        return;\n      }\n\n      this._isRestoringFocus = true; // focusAvailable returns null when the default action is prevented by the application, false\n      // when nothing was focused and true when something was focused.\n\n      if ((await this._history.focusAvailable(null)) === false) {\n        await this._history.resetFocus(null);\n      }\n\n      this._isRestoringFocus = false;\n    };\n\n    if (force) {\n      restoreFocus();\n    } else {\n      this._restoreFocusTimer = this._win().setTimeout(restoreFocus, 100);\n    }\n  }\n\n  static getDeloser(tabster, element) {\n    var _a;\n\n    let root;\n\n    for (let e = element; e; e = dom.getParentElement(e)) {\n      const tabsterOnElement = getTabsterOnElement(tabster, e);\n\n      if (tabsterOnElement) {\n        if (!root) {\n          root = tabsterOnElement.root;\n        }\n\n        const deloser = tabsterOnElement.deloser;\n\n        if (deloser) {\n          return deloser;\n        }\n      }\n    }\n\n    const deloserAPI = tabster.deloser && tabster.deloser;\n\n    if (deloserAPI) {\n      if (deloserAPI._autoDeloserInstance) {\n        return deloserAPI._autoDeloserInstance;\n      }\n\n      const autoDeloserProps = deloserAPI._autoDeloser;\n\n      if (root && !deloserAPI._autoDeloserInstance && autoDeloserProps) {\n        const body = (_a = element.ownerDocument) === null || _a === void 0 ? void 0 : _a.body;\n\n        if (body) {\n          deloserAPI._autoDeloserInstance = new Deloser(tabster, body, tabster.deloser._onDeloserDispose, autoDeloserProps);\n        }\n      }\n\n      return deloserAPI._autoDeloserInstance;\n    }\n\n    return undefined;\n  }\n\n  static getHistory(instance) {\n    return instance._history;\n  }\n\n  static forceRestoreFocus(instance) {\n    instance._scheduleRestoreFocus(true);\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nclass Subscribable {\n  constructor() {\n    this._callbacks = [];\n  }\n\n  dispose() {\n    this._callbacks = [];\n    delete this._val;\n  }\n\n  subscribe(callback) {\n    const callbacks = this._callbacks;\n    const index = callbacks.indexOf(callback);\n\n    if (index < 0) {\n      callbacks.push(callback);\n    }\n  }\n\n  subscribeFirst(callback) {\n    const callbacks = this._callbacks;\n    const index = callbacks.indexOf(callback);\n\n    if (index >= 0) {\n      callbacks.splice(index, 1);\n    }\n\n    callbacks.unshift(callback);\n  }\n\n  unsubscribe(callback) {\n    const index = this._callbacks.indexOf(callback);\n\n    if (index >= 0) {\n      this._callbacks.splice(index, 1);\n    }\n  }\n\n  setVal(val, detail) {\n    if (this._val === val) {\n      return;\n    }\n\n    this._val = val;\n\n    this._callCallbacks(val, detail);\n  }\n\n  getVal() {\n    return this._val;\n  }\n\n  trigger(val, detail) {\n    this._callCallbacks(val, detail);\n  }\n\n  _callCallbacks(val, detail) {\n    this._callbacks.forEach(callback => callback(val, detail));\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst _transactionTimeout = 1500;\nconst _pingTimeout = 3000;\nconst _targetIdUp = \"up\";\nconst CrossOriginTransactionTypes = {\n  Bootstrap: 1,\n  FocusElement: 2,\n  State: 3,\n  GetElement: 4,\n  RestoreFocusInDeloser: 5,\n  Ping: 6\n};\n\nclass CrossOriginDeloserItem extends DeloserItemBase {\n  constructor(tabster, deloser, trasactions) {\n    super();\n    this._deloser = deloser;\n    this._transactions = trasactions;\n  }\n\n  belongsTo(deloser) {\n    return deloser.deloserUId === this._deloser.deloserUId;\n  }\n\n  async focusAvailable() {\n    const data = { ...this._deloser,\n      reset: false\n    };\n    return this._transactions.beginTransaction(RestoreFocusInDeloserTransaction, data).then(value => !!value);\n  }\n\n  async resetFocus() {\n    const data = { ...this._deloser,\n      reset: true\n    };\n    return this._transactions.beginTransaction(RestoreFocusInDeloserTransaction, data).then(value => !!value);\n  }\n\n}\n\nclass CrossOriginDeloserHistoryByRoot extends DeloserHistoryByRootBase {\n  constructor(tabster, rootUId, transactions) {\n    super(tabster, rootUId);\n    this._transactions = transactions;\n  }\n\n  unshift(deloser) {\n    let item;\n\n    for (let i = 0; i < this._history.length; i++) {\n      if (this._history[i].belongsTo(deloser)) {\n        item = this._history[i];\n\n        this._history.splice(i, 1);\n\n        break;\n      }\n    }\n\n    if (!item) {\n      item = new CrossOriginDeloserItem(this._tabster, deloser, this._transactions);\n    }\n\n    this._history.unshift(item);\n\n    this._history.splice(10, this._history.length - 10);\n  }\n\n  async focusAvailable() {\n    for (const i of this._history) {\n      if (await i.focusAvailable()) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  async resetFocus() {\n    for (const i of this._history) {\n      if (await i.resetFocus()) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n}\n\nclass CrossOriginTransaction {\n  constructor(tabster, getOwner, knownTargets, value, timeout, sentTo, targetId, sendUp) {\n    this._inProgress = {};\n    this._isDone = false;\n    this._isSelfResponding = false;\n    this._sentCount = 0;\n    this.tabster = tabster;\n    this.owner = getOwner;\n    this.ownerId = getWindowUId(getOwner());\n    this.id = getUId(getOwner());\n    this.beginData = value;\n    this._knownTargets = knownTargets;\n    this._sentTo = sentTo || {\n      [this.ownerId]: true\n    };\n    this.targetId = targetId;\n    this.sendUp = sendUp;\n    this.timeout = timeout;\n    this._promise = new (getPromise(getOwner))((resolve, reject) => {\n      this._resolve = resolve;\n      this._reject = reject;\n    });\n  }\n\n  getTargets(knownTargets) {\n    return this.targetId === _targetIdUp ? this.sendUp ? {\n      [_targetIdUp]: {\n        send: this.sendUp\n      }\n    } : null : this.targetId ? knownTargets[this.targetId] ? {\n      [this.targetId]: {\n        send: knownTargets[this.targetId].send\n      }\n    } : null : Object.keys(knownTargets).length === 0 && this.sendUp ? {\n      [_targetIdUp]: {\n        send: this.sendUp\n      }\n    } : Object.keys(knownTargets).length > 0 ? knownTargets : null;\n  }\n\n  begin(selfResponse) {\n    const targets = this.getTargets(this._knownTargets);\n    const sentTo = { ...this._sentTo\n    };\n\n    if (targets) {\n      for (const id of Object.keys(targets)) {\n        sentTo[id] = true;\n      }\n    }\n\n    const data = {\n      transaction: this.id,\n      type: this.type,\n      isResponse: false,\n      timestamp: Date.now(),\n      owner: this.ownerId,\n      sentto: sentTo,\n      timeout: this.timeout,\n      beginData: this.beginData\n    };\n\n    if (this.targetId) {\n      data.target = this.targetId;\n    }\n\n    if (selfResponse) {\n      this._isSelfResponding = true;\n      selfResponse(data).then(value => {\n        this._isSelfResponding = false;\n\n        if (value !== undefined) {\n          if (!this.endData) {\n            this.endData = value;\n          }\n        }\n\n        if (this.endData || this._sentCount === 0) {\n          this.end();\n        }\n      });\n    }\n\n    if (targets) {\n      for (const id of Object.keys(targets)) {\n        if (!(id in this._sentTo)) {\n          this._send(targets[id].send, id, data);\n        }\n      }\n    }\n\n    if (this._sentCount === 0 && !this._isSelfResponding) {\n      this.end();\n    }\n\n    return this._promise;\n  }\n\n  _send(send, targetId, data) {\n    if (this._inProgress[targetId] === undefined) {\n      this._inProgress[targetId] = true;\n      this._sentCount++;\n      send(data);\n    }\n  }\n\n  end(error) {\n    if (this._isDone) {\n      return;\n    }\n\n    this._isDone = true;\n\n    if (this.endData === undefined && error) {\n      if (this._reject) {\n        this._reject(error);\n      }\n    } else if (this._resolve) {\n      this._resolve(this.endData);\n    }\n  }\n\n  onResponse(data) {\n    const endData = data.endData;\n\n    if (endData !== undefined && !this.endData) {\n      this.endData = endData;\n    }\n\n    const inProgressId = data.target === _targetIdUp ? _targetIdUp : data.owner;\n\n    if (this._inProgress[inProgressId]) {\n      this._inProgress[inProgressId] = false;\n      this._sentCount--;\n\n      if (this.endData || this._sentCount === 0 && !this._isSelfResponding) {\n        this.end();\n      }\n    }\n  }\n\n}\n\nclass BootstrapTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.Bootstrap;\n  }\n\n  static shouldForward() {\n    return false;\n  }\n\n  static async makeResponse(tabster) {\n    return {\n      isNavigatingWithKeyboard: tabster.keyboardNavigation.isNavigatingWithKeyboard()\n    };\n  }\n\n}\n\nclass FocusElementTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.FocusElement;\n  }\n\n  static shouldSelfRespond() {\n    return true;\n  }\n\n  static shouldForward(tabster, data, getOwner) {\n    const el = GetElementTransaction.findElement(tabster, getOwner, data.beginData);\n    return !el || !tabster.focusable.isFocusable(el);\n  }\n\n  static async makeResponse(tabster, data, getOwner, ownerId, transactions, forwardResult) {\n    const el = GetElementTransaction.findElement(tabster, getOwner, data.beginData);\n    return !!el && tabster.focusedElement.focus(el, true) || !!(await forwardResult);\n  }\n\n}\n\nconst CrossOriginStates = {\n  Focused: 1,\n  Blurred: 2,\n  Observed: 3,\n  DeadWindow: 4,\n  KeyboardNavigation: 5,\n  Outline: 6\n};\n\nclass StateTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.State;\n  }\n\n  static shouldSelfRespond(tabster, data) {\n    return data.state !== CrossOriginStates.DeadWindow && data.state !== CrossOriginStates.KeyboardNavigation;\n  }\n\n  static async makeResponse(tabster, data, getOwner, ownerId, transactions, forwardResult, isSelfResponse) {\n    const timestamp = data.timestamp;\n    const beginData = data.beginData;\n\n    if (timestamp && beginData) {\n      switch (beginData.state) {\n        case CrossOriginStates.Focused:\n          return StateTransaction._makeFocusedResponse(tabster, timestamp, beginData, transactions, isSelfResponse);\n\n        case CrossOriginStates.Blurred:\n          return StateTransaction._makeBlurredResponse(tabster, timestamp, beginData, transactions.ctx);\n\n        case CrossOriginStates.Observed:\n          return StateTransaction._makeObservedResponse(tabster, beginData);\n\n        case CrossOriginStates.DeadWindow:\n          return StateTransaction._makeDeadWindowResponse(tabster, beginData, transactions, forwardResult);\n\n        case CrossOriginStates.KeyboardNavigation:\n          return StateTransaction._makeKeyboardNavigationResponse(tabster, transactions.ctx, beginData.isNavigatingWithKeyboard);\n\n        case CrossOriginStates.Outline:\n          return StateTransaction._makeOutlineResponse(tabster, transactions.ctx, beginData.outline);\n      }\n    }\n\n    return true;\n  }\n\n  static createElement(tabster, beginData) {\n    return beginData.uid ? new CrossOriginElement(tabster, beginData.uid, beginData.ownerUId, beginData.id, beginData.rootUId, beginData.observedName, beginData.observedDetails) : null;\n  }\n\n  static async _makeFocusedResponse(tabster, timestamp, beginData, transactions, isSelfResponse) {\n    const element = StateTransaction.createElement(tabster, beginData);\n\n    if (beginData && beginData.ownerUId && element) {\n      transactions.ctx.focusOwner = beginData.ownerUId;\n      transactions.ctx.focusOwnerTimestamp = timestamp;\n\n      if (!isSelfResponse && beginData.rootUId && beginData.deloserUId) {\n        const deloserAPI = tabster.deloser;\n\n        if (deloserAPI) {\n          const history = DeloserAPI.getHistory(deloserAPI);\n          const deloser = {\n            ownerUId: beginData.ownerUId,\n            deloserUId: beginData.deloserUId,\n            rootUId: beginData.rootUId\n          };\n          const historyItem = history.make(beginData.rootUId, () => new CrossOriginDeloserHistoryByRoot(tabster, deloser.rootUId, transactions));\n          historyItem.unshift(deloser);\n        }\n      }\n\n      CrossOriginFocusedElementState.setVal( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      tabster.crossOrigin.focusedElement, element, {\n        isFocusedProgrammatically: beginData.isFocusedProgrammatically\n      });\n    }\n\n    return true;\n  }\n\n  static async _makeBlurredResponse(tabster, timestamp, beginData, context) {\n    if (beginData && (beginData.ownerUId === context.focusOwner || beginData.force) && (!context.focusOwnerTimestamp || context.focusOwnerTimestamp < timestamp)) {\n      CrossOriginFocusedElementState.setVal( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      tabster.crossOrigin.focusedElement, undefined, {});\n    }\n\n    return true;\n  }\n\n  static async _makeObservedResponse(tabster, beginData) {\n    const name = beginData.observedName;\n    const element = StateTransaction.createElement(tabster, beginData);\n\n    if (name && element) {\n      CrossOriginObservedElementState.trigger( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      tabster.crossOrigin.observedElement, element, {\n        names: [name],\n        details: beginData.observedDetails\n      });\n    }\n\n    return true;\n  }\n\n  static async _makeDeadWindowResponse(tabster, beginData, transactions, forwardResult) {\n    const deadUId = beginData && beginData.ownerUId;\n\n    if (deadUId) {\n      transactions.removeTarget(deadUId);\n    }\n\n    return forwardResult.then(() => {\n      if (deadUId === transactions.ctx.focusOwner) {\n        const deloserAPI = tabster.deloser;\n\n        if (deloserAPI) {\n          DeloserAPI.forceRestoreFocus(deloserAPI);\n        }\n      }\n\n      return true;\n    });\n  }\n\n  static async _makeKeyboardNavigationResponse(tabster, context, isNavigatingWithKeyboard) {\n    if (isNavigatingWithKeyboard !== undefined && tabster.keyboardNavigation.isNavigatingWithKeyboard() !== isNavigatingWithKeyboard) {\n      context.ignoreKeyboardNavigationStateUpdate = true;\n      tabster.keyboardNavigation.setNavigatingWithKeyboard(isNavigatingWithKeyboard);\n      context.ignoreKeyboardNavigationStateUpdate = false;\n    }\n\n    return true;\n  }\n\n  static async _makeOutlineResponse(tabster, context, props) {\n    if (context.origOutlineSetup) {\n      context.origOutlineSetup.call( // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      tabster.outline, props);\n    }\n\n    return true;\n  }\n\n}\n\nclass GetElementTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.GetElement;\n  }\n\n  static shouldSelfRespond() {\n    return true;\n  }\n\n  static findElement(tabster, getOwner, data) {\n    let element;\n\n    if (data && (!data.ownerId || data.ownerId === getWindowUId(getOwner()))) {\n      if (data.id) {\n        element = dom.getElementById(getOwner().document, data.id);\n\n        if (element && data.rootId) {\n          const ctx = RootAPI.getTabsterContext(tabster, element);\n\n          if (!ctx || ctx.root.uid !== data.rootId) {\n            return null;\n          }\n        }\n      } else if (data.uid) {\n        const ref = getInstanceContext(getOwner).elementByUId[data.uid];\n        element = ref && ref.get();\n      } else if (data.observedName) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        element = tabster.observedElement.getElement(data.observedName, data.accessibility);\n      }\n    }\n\n    return element || null;\n  }\n\n  static getElementData(tabster, element, getOwner, context, ownerUId) {\n    const deloser = DeloserAPI.getDeloser(tabster, element);\n    const ctx = RootAPI.getTabsterContext(tabster, element);\n    const tabsterOnElement = getTabsterOnElement(tabster, element);\n    const observed = tabsterOnElement && tabsterOnElement.observed;\n    return {\n      uid: getElementUId(getOwner, element),\n      ownerUId,\n      id: element.id || undefined,\n      rootUId: ctx ? ctx.root.uid : undefined,\n      deloserUId: deloser ? getDeloserUID(getOwner, context, deloser) : undefined,\n      observedName: observed && observed.names && observed.names[0],\n      observedDetails: observed && observed.details\n    };\n  }\n\n  static async makeResponse(tabster, data, getOwner, ownerUId, transactions, forwardResult) {\n    const beginData = data.beginData;\n    let element;\n    let dataOut;\n\n    if (beginData === undefined) {\n      element = tabster.focusedElement.getFocusedElement();\n    } else if (beginData) {\n      element = GetElementTransaction.findElement(tabster, getOwner, beginData) || undefined;\n    }\n\n    if (!element && beginData) {\n      const name = beginData.observedName;\n      const timeout = data.timeout;\n      const accessibility = beginData.accessibility;\n\n      if (name && timeout) {\n        const e = await new (getPromise(getOwner))(resolve => {\n          let isWaitElementResolved = false;\n          let isForwardResolved = false;\n          let isResolved = false; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n          tabster.observedElement.waitElement(name, timeout, accessibility).result.then(value => {\n            isWaitElementResolved = true;\n\n            if (!isResolved && (value || isForwardResolved)) {\n              isResolved = true;\n              resolve({\n                element: value\n              });\n            }\n          });\n          forwardResult.then(value => {\n            isForwardResolved = true;\n\n            if (!isResolved && (value || isWaitElementResolved)) {\n              isResolved = true;\n              resolve({\n                crossOrigin: value\n              });\n            }\n          });\n        });\n\n        if (e.element) {\n          element = e.element;\n        } else if (e.crossOrigin) {\n          dataOut = e.crossOrigin;\n        }\n      }\n    }\n\n    return element ? GetElementTransaction.getElementData(tabster, element, getOwner, transactions.ctx, ownerUId) : dataOut;\n  }\n\n}\n\nclass RestoreFocusInDeloserTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.RestoreFocusInDeloser;\n  }\n\n  static async makeResponse(tabster, data, getOwner, ownerId, transactions, forwardResult) {\n    const forwardRet = await forwardResult;\n    const begin = !forwardRet && data.beginData;\n    const uid = begin && begin.deloserUId;\n    const deloser = uid && transactions.ctx.deloserByUId[uid];\n    const deloserAPI = tabster.deloser;\n\n    if (begin && deloser && deloserAPI) {\n      const history = DeloserAPI.getHistory(deloserAPI);\n      return begin.reset ? history.resetFocus(deloser) : history.focusAvailable(deloser);\n    }\n\n    return !!forwardRet;\n  }\n\n}\n\nclass PingTransaction extends CrossOriginTransaction {\n  constructor() {\n    super(...arguments);\n    this.type = CrossOriginTransactionTypes.Ping;\n  }\n\n  static shouldForward() {\n    return false;\n  }\n\n  static async makeResponse() {\n    return true;\n  }\n\n}\n\nclass CrossOriginTransactions {\n  constructor(tabster, getOwner, context) {\n    this._knownTargets = {};\n    this._transactions = {};\n    this._isDefaultSendUp = false;\n    this.isSetUp = false;\n\n    this._onMessage = e => {\n      if (e.data.owner === this._ownerUId || !this._tabster) {\n        return;\n      } // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\n      const data = e.data;\n      let transactionId;\n\n      if (!data || !(transactionId = data.transaction) || !data.type || !data.timestamp || !data.owner || !data.sentto) {\n        return;\n      }\n\n      let knownTarget = this._knownTargets[data.owner];\n\n      if (!knownTarget && e.send && data.owner !== this._ownerUId) {\n        knownTarget = this._knownTargets[data.owner] = {\n          send: e.send\n        };\n      }\n\n      if (knownTarget) {\n        knownTarget.last = Date.now();\n      }\n\n      if (data.isResponse) {\n        const t = this._transactions[transactionId];\n\n        if (t && t.transaction && t.transaction.type === data.type) {\n          t.transaction.onResponse(data);\n        }\n      } else {\n        const Transaction = this._getTransactionClass(data.type);\n\n        const forwardResult = this.forwardTransaction(data);\n\n        if (Transaction && e.send) {\n          Transaction.makeResponse(this._tabster, data, this._owner, this._ownerUId, this, forwardResult, false).then(r => {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            const response = {\n              transaction: data.transaction,\n              type: data.type,\n              isResponse: true,\n              timestamp: Date.now(),\n              owner: this._ownerUId,\n              timeout: data.timeout,\n              sentto: {},\n              target: data.target === _targetIdUp ? _targetIdUp : data.owner,\n              endData: r\n            };\n            e.send(response);\n          });\n        }\n      }\n    };\n\n    this._onPageHide = () => {\n      this._dead();\n    };\n\n    this._onBrowserMessage = e => {\n      if (e.source === this._owner()) {\n        return;\n      } // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\n      const send = data => {\n        if (e.source && e.source.postMessage) {\n          // eslint-disable-next-line @typescript-eslint/ban-types\n          e.source.postMessage(JSON.stringify(data), \"*\");\n        }\n      };\n\n      try {\n        this._onMessage({\n          data: JSON.parse(e.data),\n          send\n        });\n      } catch (e) {\n        /* Ignore */\n      }\n    };\n\n    this._tabster = tabster;\n    this._owner = getOwner;\n    this._ownerUId = getWindowUId(getOwner());\n    this.ctx = context;\n  }\n\n  setup(sendUp) {\n    if (this.isSetUp) {\n      if (process.env.NODE_ENV === 'development') {\n        console.error(\"CrossOrigin is already set up.\");\n      }\n    } else {\n      this.isSetUp = true;\n      this.setSendUp(sendUp);\n\n      this._owner().addEventListener(\"pagehide\", this._onPageHide);\n\n      this._ping();\n    }\n\n    return this._onMessage;\n  }\n\n  setSendUp(sendUp) {\n    if (!this.isSetUp) {\n      throw new Error(\"CrossOrigin is not set up.\");\n    }\n\n    this.sendUp = sendUp || undefined;\n\n    const owner = this._owner();\n\n    if (sendUp === undefined) {\n      if (!this._isDefaultSendUp) {\n        if (owner.document) {\n          this._isDefaultSendUp = true;\n\n          if (owner.parent && owner.parent !== owner && owner.parent.postMessage) {\n            this.sendUp = ( // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            data) => {\n              owner.parent.postMessage(JSON.stringify(data), \"*\");\n            };\n          }\n\n          owner.addEventListener(\"message\", this._onBrowserMessage);\n        }\n      }\n    } else if (this._isDefaultSendUp) {\n      owner.removeEventListener(\"message\", this._onBrowserMessage);\n      this._isDefaultSendUp = false;\n    }\n\n    return this._onMessage;\n  }\n\n  async dispose() {\n    const owner = this._owner();\n\n    if (this._pingTimer) {\n      owner.clearTimeout(this._pingTimer);\n      this._pingTimer = undefined;\n    }\n\n    owner.removeEventListener(\"message\", this._onBrowserMessage);\n    owner.removeEventListener(\"pagehide\", this._onPageHide);\n    await this._dead();\n    delete this._deadPromise;\n\n    for (const id of Object.keys(this._transactions)) {\n      const t = this._transactions[id];\n\n      if (t.timer) {\n        owner.clearTimeout(t.timer);\n        delete t.timer;\n      }\n\n      t.transaction.end();\n    }\n\n    this._knownTargets = {};\n    delete this.sendUp;\n  }\n\n  beginTransaction(Transaction, value, timeout, sentTo, targetId, withReject) {\n    if (!this._owner) {\n      return getPromise(this._owner).reject();\n    }\n\n    const transaction = new Transaction(this._tabster, this._owner, this._knownTargets, value, timeout, sentTo, targetId, this.sendUp);\n    let selfResponse;\n\n    if (Transaction.shouldSelfRespond && Transaction.shouldSelfRespond(this._tabster, value, this._owner, this._ownerUId)) {\n      selfResponse = data => {\n        return Transaction.makeResponse(this._tabster, data, this._owner, this._ownerUId, this, getPromise(this._owner).resolve(undefined), true);\n      };\n    }\n\n    return this._beginTransaction(transaction, timeout, selfResponse, withReject);\n  }\n\n  removeTarget(uid) {\n    delete this._knownTargets[uid];\n  }\n\n  _beginTransaction(transaction, timeout, selfResponse, withReject) {\n    const owner = this._owner();\n\n    const wrapper = {\n      transaction,\n      timer: owner.setTimeout(() => {\n        delete wrapper.timer;\n        transaction.end(\"Cross origin transaction timed out.\");\n      }, _transactionTimeout + (timeout || 0))\n    };\n    this._transactions[transaction.id] = wrapper;\n    const ret = transaction.begin(selfResponse);\n    ret.catch(() => {\n      /**/\n    }).finally(() => {\n      if (wrapper.timer) {\n        owner.clearTimeout(wrapper.timer);\n      }\n\n      delete this._transactions[transaction.id];\n    });\n    return ret.then(value => value, withReject ? undefined : () => undefined);\n  }\n\n  forwardTransaction( // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  data // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ) {\n    const owner = this._owner;\n    let targetId = data.target;\n\n    if (targetId === this._ownerUId) {\n      return getPromise(owner).resolve();\n    }\n\n    const Transaction = this._getTransactionClass(data.type);\n\n    if (Transaction) {\n      if (Transaction.shouldForward === undefined || Transaction.shouldForward(this._tabster, data, owner, this._ownerUId)) {\n        const sentTo = data.sentto;\n\n        if (targetId === _targetIdUp) {\n          targetId = undefined;\n          sentTo[this._ownerUId] = true;\n        }\n\n        delete sentTo[_targetIdUp];\n        return this._beginTransaction(new Transaction(this._tabster, owner, this._knownTargets, data.beginData, data.timeout, sentTo, targetId, this.sendUp), data.timeout);\n      } else {\n        return getPromise(owner).resolve();\n      }\n    }\n\n    return getPromise(owner).reject(`Unknown transaction type ${data.type}`);\n  }\n\n  _getTransactionClass(type // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  ) {\n    switch (type) {\n      case CrossOriginTransactionTypes.Bootstrap:\n        return BootstrapTransaction;\n\n      case CrossOriginTransactionTypes.FocusElement:\n        return FocusElementTransaction;\n\n      case CrossOriginTransactionTypes.State:\n        return StateTransaction;\n\n      case CrossOriginTransactionTypes.GetElement:\n        return GetElementTransaction;\n\n      case CrossOriginTransactionTypes.RestoreFocusInDeloser:\n        return RestoreFocusInDeloserTransaction;\n\n      case CrossOriginTransactionTypes.Ping:\n        return PingTransaction;\n\n      default:\n        return null;\n    }\n  }\n\n  async _dead() {\n    if (!this._deadPromise && this.ctx.focusOwner === this._ownerUId) {\n      this._deadPromise = this.beginTransaction(StateTransaction, {\n        ownerUId: this._ownerUId,\n        state: CrossOriginStates.DeadWindow\n      });\n    }\n\n    if (this._deadPromise) {\n      await this._deadPromise;\n    }\n  }\n\n  async _ping() {\n    if (this._pingTimer) {\n      return;\n    }\n\n    let deadWindows;\n    const now = Date.now();\n    const targets = Object.keys(this._knownTargets).filter(uid => now - (this._knownTargets[uid].last || 0) > _pingTimeout);\n\n    if (this.sendUp) {\n      targets.push(_targetIdUp);\n    }\n\n    if (targets.length) {\n      await getPromise(this._owner).all(targets.map(uid => this.beginTransaction(PingTransaction, undefined, undefined, undefined, uid, true).then(() => true, () => {\n        if (uid !== _targetIdUp) {\n          if (!deadWindows) {\n            deadWindows = {};\n          }\n\n          deadWindows[uid] = true;\n          delete this._knownTargets[uid];\n        }\n\n        return false;\n      })));\n    }\n\n    if (deadWindows) {\n      const focused = await this.beginTransaction(GetElementTransaction, undefined);\n\n      if (!focused && this.ctx.focusOwner && this.ctx.focusOwner in deadWindows) {\n        await this.beginTransaction(StateTransaction, {\n          ownerUId: this._ownerUId,\n          state: CrossOriginStates.Blurred,\n          force: true\n        });\n        const deloserAPI = this._tabster.deloser;\n\n        if (deloserAPI) {\n          DeloserAPI.forceRestoreFocus(deloserAPI);\n        }\n      }\n    }\n\n    this._pingTimer = this._owner().setTimeout(() => {\n      this._pingTimer = undefined;\n\n      this._ping();\n    }, _pingTimeout);\n  }\n\n}\n\nclass CrossOriginElement {\n  constructor(tabster, uid, ownerId, id, rootId, observedName, observedDetails) {\n    this._tabster = tabster;\n    this.uid = uid;\n    this.ownerId = ownerId;\n    this.id = id;\n    this.rootId = rootId;\n    this.observedName = observedName;\n    this.observedDetails = observedDetails;\n  }\n\n  focus(noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return this._tabster.crossOrigin.focusedElement.focus(this, noFocusedProgrammaticallyFlag, noAccessibleCheck);\n  }\n\n}\nclass CrossOriginFocusedElementState extends Subscribable {\n  constructor(transactions) {\n    super();\n    this._transactions = transactions;\n  }\n\n  async focus(element, noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    return this._focus({\n      uid: element.uid,\n      id: element.id,\n      rootId: element.rootId,\n      ownerId: element.ownerId,\n      observedName: element.observedName\n    }, noFocusedProgrammaticallyFlag, noAccessibleCheck);\n  }\n\n  async focusById(elementId, rootId, noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    return this._focus({\n      id: elementId,\n      rootId\n    }, noFocusedProgrammaticallyFlag, noAccessibleCheck);\n  }\n\n  async focusByObservedName(observedName, timeout, rootId, noFocusedProgrammaticallyFlag, noAccessibleCheck) {\n    return this._focus({\n      observedName,\n      rootId\n    }, noFocusedProgrammaticallyFlag, noAccessibleCheck, timeout);\n  }\n\n  async _focus(elementData, noFocusedProgrammaticallyFlag, noAccessibleCheck, timeout) {\n    return this._transactions.beginTransaction(FocusElementTransaction, { ...elementData,\n      noFocusedProgrammaticallyFlag,\n      noAccessibleCheck\n    }, timeout).then(value => !!value);\n  }\n\n  static setVal(instance, val, detail) {\n    instance.setVal(val, detail);\n  }\n\n}\nclass CrossOriginObservedElementState extends Subscribable {\n  constructor(tabster, transactions) {\n    super();\n    this._lastRequestFocusId = 0;\n    this._tabster = tabster;\n    this._transactions = transactions;\n  }\n\n  async getElement(observedName, accessibility) {\n    return this.waitElement(observedName, 0, accessibility);\n  }\n\n  async waitElement(observedName, timeout, accessibility) {\n    return this._transactions.beginTransaction(GetElementTransaction, {\n      observedName,\n      accessibility\n    }, timeout).then(value => value ? StateTransaction.createElement(this._tabster, value) : null);\n  }\n\n  async requestFocus(observedName, timeout) {\n    const requestId = ++this._lastRequestFocusId;\n    return this.waitElement(observedName, timeout, ObservedElementAccessibilities.Focusable).then(element => this._lastRequestFocusId === requestId && element ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    this._tabster.crossOrigin.focusedElement.focus(element, true) : false);\n  }\n\n  static trigger(instance, element, details) {\n    instance.trigger(element, details);\n  }\n\n}\nclass CrossOriginAPI {\n  constructor(tabster) {\n    this._init = () => {\n      const tabster = this._tabster;\n      tabster.keyboardNavigation.subscribe(this._onKeyboardNavigationStateChanged);\n      tabster.focusedElement.subscribe(this._onFocus); // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n      tabster.observedElement.subscribe(this._onObserved);\n\n      if (!this._ctx.origOutlineSetup) {\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        this._ctx.origOutlineSetup = tabster.outline.setup; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n        tabster.outline.setup = this._outlineSetup;\n      }\n\n      this._transactions.beginTransaction(BootstrapTransaction, undefined, undefined, undefined, _targetIdUp).then(data => {\n        if (data && this._tabster.keyboardNavigation.isNavigatingWithKeyboard() !== data.isNavigatingWithKeyboard) {\n          this._ctx.ignoreKeyboardNavigationStateUpdate = true;\n\n          this._tabster.keyboardNavigation.setNavigatingWithKeyboard(data.isNavigatingWithKeyboard);\n\n          this._ctx.ignoreKeyboardNavigationStateUpdate = false;\n        }\n      });\n    };\n\n    this._onKeyboardNavigationStateChanged = value => {\n      if (!this._ctx.ignoreKeyboardNavigationStateUpdate) {\n        this._transactions.beginTransaction(StateTransaction, {\n          state: CrossOriginStates.KeyboardNavigation,\n          ownerUId: getWindowUId(this._win()),\n          isNavigatingWithKeyboard: value\n        });\n      }\n    };\n\n    this._onFocus = element => {\n      const win = this._win();\n\n      const ownerUId = getWindowUId(win);\n\n      if (this._blurTimer) {\n        win.clearTimeout(this._blurTimer);\n        this._blurTimer = undefined;\n      }\n\n      if (element) {\n        this._transactions.beginTransaction(StateTransaction, { ...GetElementTransaction.getElementData(this._tabster, element, this._win, this._ctx, ownerUId),\n          state: CrossOriginStates.Focused\n        });\n      } else {\n        this._blurTimer = win.setTimeout(() => {\n          this._blurTimer = undefined;\n\n          if (this._ctx.focusOwner && this._ctx.focusOwner === ownerUId) {\n            this._transactions.beginTransaction(GetElementTransaction, undefined).then(value => {\n              if (!value && this._ctx.focusOwner === ownerUId) {\n                this._transactions.beginTransaction(StateTransaction, {\n                  ownerUId,\n                  state: CrossOriginStates.Blurred,\n                  force: false\n                });\n              }\n            });\n          }\n        }, 0);\n      }\n    };\n\n    this._onObserved = (element, details) => {\n      var _a;\n\n      const d = GetElementTransaction.getElementData(this._tabster, element, this._win, this._ctx, getWindowUId(this._win()));\n      d.state = CrossOriginStates.Observed;\n      d.observedName = (_a = details.names) === null || _a === void 0 ? void 0 : _a[0];\n      d.observedDetails = details.details;\n\n      this._transactions.beginTransaction(StateTransaction, d);\n    };\n\n    this._outlineSetup = props => {\n      this._transactions.beginTransaction(StateTransaction, {\n        state: CrossOriginStates.Outline,\n        ownerUId: getWindowUId(this._win()),\n        outline: props\n      });\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    this._ctx = {\n      ignoreKeyboardNavigationStateUpdate: false,\n      deloserByUId: {}\n    };\n    this._transactions = new CrossOriginTransactions(tabster, this._win, this._ctx);\n    this.focusedElement = new CrossOriginFocusedElementState(this._transactions);\n    this.observedElement = new CrossOriginObservedElementState(tabster, this._transactions);\n  }\n\n  setup(sendUp) {\n    if (this.isSetUp()) {\n      return this._transactions.setSendUp(sendUp);\n    } else {\n      this._tabster.queueInit(this._init);\n\n      return this._transactions.setup(sendUp);\n    }\n  }\n\n  isSetUp() {\n    return this._transactions.isSetUp;\n  }\n\n  dispose() {\n    var _a;\n\n    const tabster = this._tabster;\n    tabster.keyboardNavigation.unsubscribe(this._onKeyboardNavigationStateChanged);\n    tabster.focusedElement.unsubscribe(this._onFocus);\n    (_a = tabster.observedElement) === null || _a === void 0 ? void 0 : _a.unsubscribe(this._onObserved);\n\n    this._transactions.dispose();\n\n    this.focusedElement.dispose();\n    this.observedElement.dispose();\n    this._ctx.deloserByUId = {};\n  }\n\n}\n\nfunction getDeloserUID(getWindow, context, deloser) {\n  const deloserElement = deloser.getElement();\n\n  if (deloserElement) {\n    const uid = getElementUId(getWindow, deloserElement);\n\n    if (!context.deloserByUId[uid]) {\n      context.deloserByUId[uid] = deloser;\n    }\n\n    return uid;\n  }\n\n  return undefined;\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nclass FocusableAPI {\n  constructor(tabster) {\n    this._tabster = tabster;\n  }\n\n  dispose() {\n    /**/\n  }\n\n  getProps(element) {\n    const tabsterOnElement = getTabsterOnElement(this._tabster, element);\n    return tabsterOnElement && tabsterOnElement.focusable || {};\n  }\n\n  isFocusable(el, includeProgrammaticallyFocusable, noVisibleCheck, noAccessibleCheck) {\n    if (matchesSelector(el, FOCUSABLE_SELECTOR) && (includeProgrammaticallyFocusable || el.tabIndex !== -1)) {\n      return (noVisibleCheck || this.isVisible(el)) && (noAccessibleCheck || this.isAccessible(el));\n    }\n\n    return false;\n  }\n\n  isVisible(el) {\n    if (!el.ownerDocument || el.nodeType !== Node.ELEMENT_NODE) {\n      return false;\n    }\n\n    if (isDisplayNone(el)) {\n      return false;\n    }\n\n    const rect = el.ownerDocument.body.getBoundingClientRect();\n\n    if (rect.width === 0 && rect.height === 0) {\n      // This might happen, for example, if our <body> is in hidden <iframe>.\n      return false;\n    }\n\n    return true;\n  }\n\n  isAccessible(el) {\n    var _a;\n\n    for (let e = el; e; e = dom.getParentElement(e)) {\n      const tabsterOnElement = getTabsterOnElement(this._tabster, e);\n\n      if (this._isHidden(e)) {\n        return false;\n      }\n\n      const ignoreDisabled = (_a = tabsterOnElement === null || tabsterOnElement === void 0 ? void 0 : tabsterOnElement.focusable) === null || _a === void 0 ? void 0 : _a.ignoreAriaDisabled;\n\n      if (!ignoreDisabled && this._isDisabled(e)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  _isDisabled(el) {\n    return el.hasAttribute(\"disabled\");\n  }\n\n  _isHidden(el) {\n    var _a;\n\n    const attrVal = el.getAttribute(\"aria-hidden\");\n\n    if (attrVal && attrVal.toLowerCase() === \"true\") {\n      if (!((_a = this._tabster.modalizer) === null || _a === void 0 ? void 0 : _a.isAugmented(el))) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  findFirst(options, out) {\n    return this.findElement({ ...options\n    }, out);\n  }\n\n  findLast(options, out) {\n    return this.findElement({\n      isBackward: true,\n      ...options\n    }, out);\n  }\n\n  findNext(options, out) {\n    return this.findElement({ ...options\n    }, out);\n  }\n\n  findPrev(options, out) {\n    return this.findElement({ ...options,\n      isBackward: true\n    }, out);\n  }\n\n  findDefault(options, out) {\n    return this.findElement({ ...options,\n      acceptCondition: el => this.isFocusable(el, options.includeProgrammaticallyFocusable) && !!this.getProps(el).isDefault\n    }, out) || null;\n  }\n\n  findAll(options) {\n    return this._findElements(true, options) || [];\n  }\n\n  findElement(options, out) {\n    const found = this._findElements(false, options, out);\n\n    return found ? found[0] : found;\n  }\n\n  _findElements(isFindAll, options, out) {\n    var _a, _b, _c;\n\n    const {\n      container,\n      currentElement = null,\n      includeProgrammaticallyFocusable,\n      useActiveModalizer,\n      ignoreAccessibility,\n      modalizerId,\n      isBackward,\n      onElement\n    } = options;\n\n    if (!out) {\n      out = {};\n    }\n\n    const elements = [];\n    let {\n      acceptCondition\n    } = options;\n    const hasCustomCondition = !!acceptCondition;\n\n    if (!container) {\n      return null;\n    }\n\n    if (!acceptCondition) {\n      acceptCondition = el => this.isFocusable(el, includeProgrammaticallyFocusable, false, ignoreAccessibility);\n    }\n\n    const acceptElementState = {\n      container,\n      modalizerUserId: modalizerId === undefined && useActiveModalizer ? (_a = this._tabster.modalizer) === null || _a === void 0 ? void 0 : _a.activeId : modalizerId || ((_c = (_b = RootAPI.getTabsterContext(this._tabster, container)) === null || _b === void 0 ? void 0 : _b.modalizer) === null || _c === void 0 ? void 0 : _c.userId),\n      from: currentElement || container,\n      isBackward,\n      isFindAll,\n      acceptCondition,\n      hasCustomCondition,\n      includeProgrammaticallyFocusable,\n      ignoreAccessibility,\n      cachedGrouppers: {},\n      cachedRadioGroups: {}\n    };\n    const walker = createElementTreeWalker(container.ownerDocument, container, node => this._acceptElement(node, acceptElementState));\n\n    if (!walker) {\n      return null;\n    }\n\n    const prepareForNextElement = shouldContinueIfNotFound => {\n      var _a, _b;\n\n      const foundElement = (_a = acceptElementState.foundElement) !== null && _a !== void 0 ? _a : acceptElementState.foundBackward;\n\n      if (foundElement) {\n        elements.push(foundElement);\n      }\n\n      if (isFindAll) {\n        if (foundElement) {\n          acceptElementState.found = false;\n          delete acceptElementState.foundElement;\n          delete acceptElementState.foundBackward;\n          delete acceptElementState.fromCtx;\n          acceptElementState.from = foundElement;\n\n          if (onElement && !onElement(foundElement)) {\n            return false;\n          }\n        }\n\n        return !!(foundElement || shouldContinueIfNotFound);\n      } else {\n        if (foundElement && out) {\n          out.uncontrolled = (_b = RootAPI.getTabsterContext(this._tabster, foundElement)) === null || _b === void 0 ? void 0 : _b.uncontrolled;\n        }\n\n        return !!(shouldContinueIfNotFound && !foundElement);\n      }\n    };\n\n    if (!currentElement) {\n      out.outOfDOMOrder = true;\n    }\n\n    if (currentElement && dom.nodeContains(container, currentElement)) {\n      walker.currentNode = currentElement;\n    } else if (isBackward) {\n      const lastChild = getLastChild$2(container);\n\n      if (!lastChild) {\n        return null;\n      }\n\n      if (this._acceptElement(lastChild, acceptElementState) === NodeFilter.FILTER_ACCEPT && !prepareForNextElement(true)) {\n        if (acceptElementState.skippedFocusable) {\n          out.outOfDOMOrder = true;\n        }\n\n        return elements;\n      }\n\n      walker.currentNode = lastChild;\n    }\n\n    do {\n      if (isBackward) {\n        walker.previousNode();\n      } else {\n        walker.nextNode();\n      }\n    } while (prepareForNextElement());\n\n    if (acceptElementState.skippedFocusable) {\n      out.outOfDOMOrder = true;\n    }\n\n    return elements.length ? elements : null;\n  }\n\n  _acceptElement(element, state) {\n    var _a, _b, _c;\n\n    if (state.found) {\n      return NodeFilter.FILTER_ACCEPT;\n    }\n\n    const foundBackward = state.foundBackward;\n\n    if (foundBackward && (element === foundBackward || !dom.nodeContains(foundBackward, element))) {\n      state.found = true;\n      state.foundElement = foundBackward;\n      return NodeFilter.FILTER_ACCEPT;\n    }\n\n    const container = state.container;\n\n    if (element === container) {\n      return NodeFilter.FILTER_SKIP;\n    }\n\n    if (!dom.nodeContains(container, element)) {\n      return NodeFilter.FILTER_REJECT;\n    }\n\n    if (getDummyInputContainer(element)) {\n      return NodeFilter.FILTER_REJECT;\n    }\n\n    if (dom.nodeContains(state.rejectElementsFrom, element)) {\n      return NodeFilter.FILTER_REJECT;\n    }\n\n    const ctx = state.currentCtx = RootAPI.getTabsterContext(this._tabster, element); // Tabster is opt in, if it is not managed, don't try and get do anything special\n\n    if (!ctx) {\n      return NodeFilter.FILTER_SKIP;\n    }\n\n    if (shouldIgnoreFocus(element)) {\n      if (this.isFocusable(element, undefined, true, true)) {\n        state.skippedFocusable = true;\n      }\n\n      return NodeFilter.FILTER_SKIP;\n    } // We assume iframes are focusable because native tab behaviour would tab inside.\n    // But we do it only during the standard search when there is no custom accept\n    // element condition.\n\n\n    if (!state.hasCustomCondition && (element.tagName === \"IFRAME\" || element.tagName === \"WEBVIEW\")) {\n      if (((_a = ctx.modalizer) === null || _a === void 0 ? void 0 : _a.userId) === ((_b = this._tabster.modalizer) === null || _b === void 0 ? void 0 : _b.activeId)) {\n        state.found = true;\n        state.rejectElementsFrom = state.foundElement = element;\n        return NodeFilter.FILTER_ACCEPT;\n      } else {\n        return NodeFilter.FILTER_REJECT;\n      }\n    }\n\n    if (!state.ignoreAccessibility && !this.isAccessible(element)) {\n      if (this.isFocusable(element, false, true, true)) {\n        state.skippedFocusable = true;\n      }\n\n      return NodeFilter.FILTER_REJECT;\n    }\n\n    let result;\n    let fromCtx = state.fromCtx;\n\n    if (!fromCtx) {\n      fromCtx = state.fromCtx = RootAPI.getTabsterContext(this._tabster, state.from);\n    }\n\n    const fromMover = fromCtx === null || fromCtx === void 0 ? void 0 : fromCtx.mover;\n    let groupper = ctx.groupper;\n    let mover = ctx.mover;\n    result = (_c = this._tabster.modalizer) === null || _c === void 0 ? void 0 : _c.acceptElement(element, state);\n\n    if (result !== undefined) {\n      state.skippedFocusable = true;\n    }\n\n    if (result === undefined && (groupper || mover || fromMover)) {\n      const groupperElement = groupper === null || groupper === void 0 ? void 0 : groupper.getElement();\n      const fromMoverElement = fromMover === null || fromMover === void 0 ? void 0 : fromMover.getElement();\n      let moverElement = mover === null || mover === void 0 ? void 0 : mover.getElement();\n\n      if (moverElement && dom.nodeContains(fromMoverElement, moverElement) && dom.nodeContains(container, fromMoverElement) && (!groupperElement || !mover || dom.nodeContains(fromMoverElement, groupperElement))) {\n        mover = fromMover;\n        moverElement = fromMoverElement;\n      }\n\n      if (groupperElement && (groupperElement === container || !dom.nodeContains(container, groupperElement))) {\n        groupper = undefined;\n      }\n\n      if (moverElement && !dom.nodeContains(container, moverElement)) {\n        mover = undefined;\n      }\n\n      if (groupper && mover) {\n        if (moverElement && groupperElement && !dom.nodeContains(groupperElement, moverElement)) {\n          mover = undefined;\n        } else {\n          groupper = undefined;\n        }\n      }\n\n      if (groupper) {\n        result = groupper.acceptElement(element, state);\n      }\n\n      if (mover) {\n        result = mover.acceptElement(element, state);\n      }\n    }\n\n    if (result === undefined) {\n      result = state.acceptCondition(element) ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n\n      if (result === NodeFilter.FILTER_SKIP && this.isFocusable(element, false, true, true)) {\n        state.skippedFocusable = true;\n      }\n    }\n\n    if (result === NodeFilter.FILTER_ACCEPT && !state.found) {\n      if (!state.isFindAll && isRadio(element) && !element.checked) {\n        // We need to mimic the browser's behaviour to skip unchecked radio buttons.\n        const radioGroupName = element.name;\n        let radioGroup = state.cachedRadioGroups[radioGroupName];\n\n        if (!radioGroup) {\n          radioGroup = getRadioButtonGroup(element);\n\n          if (radioGroup) {\n            state.cachedRadioGroups[radioGroupName] = radioGroup;\n          }\n        }\n\n        if ((radioGroup === null || radioGroup === void 0 ? void 0 : radioGroup.checked) && radioGroup.checked !== element) {\n          // Currently found element is a radio button in a group that has another radio button checked.\n          return NodeFilter.FILTER_SKIP;\n        }\n      }\n\n      if (state.isBackward) {\n        // When TreeWalker goes backwards, it visits the container first,\n        // then it goes inside. So, if the container is accepted, we remember it,\n        // but allowing the TreeWalker to check inside.\n        state.foundBackward = element;\n        result = NodeFilter.FILTER_SKIP;\n      } else {\n        state.found = true;\n        state.foundElement = element;\n      }\n    }\n\n    return result;\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst Keys = {\n  Tab: \"Tab\",\n  Enter: \"Enter\",\n  Escape: \"Escape\",\n  Space: \" \",\n  PageUp: \"PageUp\",\n  PageDown: \"PageDown\",\n  End: \"End\",\n  Home: \"Home\",\n  ArrowLeft: \"ArrowLeft\",\n  ArrowUp: \"ArrowUp\",\n  ArrowRight: \"ArrowRight\",\n  ArrowDown: \"ArrowDown\"\n};\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nfunction getUncontrolledCompletelyContainer(tabster, element) {\n  var _a;\n\n  const getParent = tabster.getParent;\n  let el = element;\n\n  do {\n    const uncontrolledOnElement = (_a = getTabsterOnElement(tabster, el)) === null || _a === void 0 ? void 0 : _a.uncontrolled;\n\n    if (uncontrolledOnElement && tabster.uncontrolled.isUncontrolledCompletely(el, !!uncontrolledOnElement.completely)) {\n      return el;\n    }\n\n    el = getParent(el);\n  } while (el);\n\n  return undefined;\n}\n\nconst AsyncFocusIntentPriorityBySource = {\n  [AsyncFocusSources.Restorer]: 0,\n  [AsyncFocusSources.Deloser]: 1,\n  [AsyncFocusSources.EscapeGroupper]: 2\n};\nclass FocusedElementState extends Subscribable {\n  constructor(tabster, getWindow) {\n    super();\n\n    this._init = () => {\n      const win = this._win();\n\n      const doc = win.document; // Add these event listeners as capture - we want Tabster to run before user event handlers\n\n      doc.addEventListener(KEYBORG_FOCUSIN, this._onFocusIn, true);\n      doc.addEventListener(KEYBORG_FOCUSOUT, this._onFocusOut, true);\n      win.addEventListener(\"keydown\", this._onKeyDown, true);\n      const activeElement = dom.getActiveElement(doc);\n\n      if (activeElement && activeElement !== doc.body) {\n        this._setFocusedElement(activeElement);\n      }\n\n      this.subscribe(this._onChanged);\n    };\n\n    this._onFocusIn = e => {\n      const target = e.composedPath()[0];\n\n      if (target) {\n        this._setFocusedElement(target, e.detail.relatedTarget, e.detail.isFocusedProgrammatically);\n      }\n    };\n\n    this._onFocusOut = e => {\n      var _a;\n\n      this._setFocusedElement(undefined, (_a = e.detail) === null || _a === void 0 ? void 0 : _a.originalEvent.relatedTarget);\n    }; // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\n\n    this._validateFocusedElement = element => {// TODO: Make sure this is not needed anymore and write tests.\n    };\n\n    this._onKeyDown = event => {\n      if (event.key !== Keys.Tab || event.ctrlKey) {\n        return;\n      }\n\n      const currentElement = this.getVal();\n\n      if (!currentElement || !currentElement.ownerDocument || currentElement.contentEditable === \"true\") {\n        return;\n      }\n\n      const tabster = this._tabster;\n      const controlTab = tabster.controlTab;\n      const ctx = RootAPI.getTabsterContext(tabster, currentElement);\n\n      if (!ctx || ctx.ignoreKeydown(event)) {\n        return;\n      }\n\n      const isBackward = event.shiftKey;\n      const next = FocusedElementState.findNextTabbable(tabster, ctx, undefined, currentElement, undefined, isBackward, true);\n      const rootElement = ctx.root.getElement();\n\n      if (!rootElement) {\n        return;\n      }\n\n      const nextElement = next === null || next === void 0 ? void 0 : next.element;\n      const uncontrolledCompletelyContainer = getUncontrolledCompletelyContainer(tabster, currentElement);\n\n      if (nextElement) {\n        const nextUncontrolled = next.uncontrolled;\n\n        if (ctx.uncontrolled || dom.nodeContains(nextUncontrolled, currentElement)) {\n          if (!next.outOfDOMOrder && nextUncontrolled === ctx.uncontrolled || uncontrolledCompletelyContainer && !dom.nodeContains(uncontrolledCompletelyContainer, nextElement)) {\n            // Nothing to do, everything will be done by the browser or something\n            // that controls the uncontrolled area.\n            return;\n          } // We are in uncontrolled area. We allow whatever controls it to move\n          // focus, but we add a phantom dummy to make sure the focus is moved\n          // to the correct place if the uncontrolled area allows default action.\n          // We only need that in the controlled mode, because in uncontrolled\n          // mode we have dummy inputs around everything that redirects focus.\n\n\n          DummyInputManager.addPhantomDummyWithTarget(tabster, currentElement, isBackward, nextElement);\n          return;\n        }\n\n        if (nextUncontrolled || nextElement.tagName === \"IFRAME\") {\n          // For iframes and uncontrolled areas we always want to use default action to\n          // move focus into.\n          if (rootElement.dispatchEvent(new TabsterMoveFocusEvent({\n            by: \"root\",\n            owner: rootElement,\n            next: nextElement,\n            relatedEvent: event\n          }))) {\n            DummyInputManager.moveWithPhantomDummy(this._tabster, nextUncontrolled !== null && nextUncontrolled !== void 0 ? nextUncontrolled : nextElement, false, isBackward, event);\n          }\n\n          return;\n        }\n\n        if (controlTab || (next === null || next === void 0 ? void 0 : next.outOfDOMOrder)) {\n          if (rootElement.dispatchEvent(new TabsterMoveFocusEvent({\n            by: \"root\",\n            owner: rootElement,\n            next: nextElement,\n            relatedEvent: event\n          }))) {\n            event.preventDefault();\n            event.stopImmediatePropagation();\n            nativeFocus(nextElement);\n          }\n        }\n      } else {\n        if (!uncontrolledCompletelyContainer && rootElement.dispatchEvent(new TabsterMoveFocusEvent({\n          by: \"root\",\n          owner: rootElement,\n          next: null,\n          relatedEvent: event\n        }))) {\n          ctx.root.moveOutWithDefaultAction(isBackward, event);\n        }\n      }\n    };\n\n    this._onChanged = (element, detail) => {\n      var _a, _b;\n\n      if (element) {\n        element.dispatchEvent(new TabsterFocusInEvent(detail));\n      } else {\n        const last = (_a = this._lastVal) === null || _a === void 0 ? void 0 : _a.get();\n\n        if (last) {\n          const d = { ...detail\n          };\n          const lastCtx = RootAPI.getTabsterContext(this._tabster, last);\n          const modalizerId = (_b = lastCtx === null || lastCtx === void 0 ? void 0 : lastCtx.modalizer) === null || _b === void 0 ? void 0 : _b.userId;\n\n          if (modalizerId) {\n            d.modalizerId = modalizerId;\n          }\n\n          last.dispatchEvent(new TabsterFocusOutEvent(d));\n        }\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = getWindow;\n    tabster.queueInit(this._init);\n  }\n\n  dispose() {\n    super.dispose();\n\n    const win = this._win();\n\n    const doc = win.document;\n    doc.removeEventListener(KEYBORG_FOCUSIN, this._onFocusIn, true);\n    doc.removeEventListener(KEYBORG_FOCUSOUT, this._onFocusOut, true);\n    win.removeEventListener(\"keydown\", this._onKeyDown, true);\n    this.unsubscribe(this._onChanged);\n    const asyncFocus = this._asyncFocus;\n\n    if (asyncFocus) {\n      win.clearTimeout(asyncFocus.timeout);\n      delete this._asyncFocus;\n    }\n\n    delete FocusedElementState._lastResetElement;\n    delete this._nextVal;\n    delete this._lastVal;\n  }\n\n  static forgetMemorized(instance, parent) {\n    var _a, _b;\n\n    let wel = FocusedElementState._lastResetElement;\n    let el = wel && wel.get();\n\n    if (el && dom.nodeContains(parent, el)) {\n      delete FocusedElementState._lastResetElement;\n    }\n\n    el = (_b = (_a = instance._nextVal) === null || _a === void 0 ? void 0 : _a.element) === null || _b === void 0 ? void 0 : _b.get();\n\n    if (el && dom.nodeContains(parent, el)) {\n      delete instance._nextVal;\n    }\n\n    wel = instance._lastVal;\n    el = wel && wel.get();\n\n    if (el && dom.nodeContains(parent, el)) {\n      delete instance._lastVal;\n    }\n  }\n\n  getFocusedElement() {\n    return this.getVal();\n  }\n\n  getLastFocusedElement() {\n    var _a;\n\n    let el = (_a = this._lastVal) === null || _a === void 0 ? void 0 : _a.get();\n\n    if (!el || el && !documentContains(el.ownerDocument, el)) {\n      this._lastVal = el = undefined;\n    }\n\n    return el;\n  }\n\n  focus(element, noFocusedProgrammaticallyFlag, noAccessibleCheck, preventScroll) {\n    if (!this._tabster.focusable.isFocusable(element, noFocusedProgrammaticallyFlag, false, noAccessibleCheck)) {\n      return false;\n    }\n\n    element.focus({\n      preventScroll\n    });\n    return true;\n  }\n\n  focusDefault(container) {\n    const el = this._tabster.focusable.findDefault({\n      container\n    });\n\n    if (el) {\n      this._tabster.focusedElement.focus(el);\n\n      return true;\n    }\n\n    return false;\n  }\n\n  getFirstOrLastTabbable(isFirst, props) {\n    var _a;\n\n    const {\n      container,\n      ignoreAccessibility\n    } = props;\n    let toFocus;\n\n    if (container) {\n      const ctx = RootAPI.getTabsterContext(this._tabster, container);\n\n      if (ctx) {\n        toFocus = (_a = FocusedElementState.findNextTabbable(this._tabster, ctx, container, undefined, undefined, !isFirst, ignoreAccessibility)) === null || _a === void 0 ? void 0 : _a.element;\n      }\n    }\n\n    if (toFocus && !dom.nodeContains(container, toFocus)) {\n      toFocus = undefined;\n    }\n\n    return toFocus || undefined;\n  }\n\n  _focusFirstOrLast(isFirst, props) {\n    const toFocus = this.getFirstOrLastTabbable(isFirst, props);\n\n    if (toFocus) {\n      this.focus(toFocus, false, true);\n      return true;\n    }\n\n    return false;\n  }\n\n  focusFirst(props) {\n    return this._focusFirstOrLast(true, props);\n  }\n\n  focusLast(props) {\n    return this._focusFirstOrLast(false, props);\n  }\n\n  resetFocus(container) {\n    if (!this._tabster.focusable.isVisible(container)) {\n      return false;\n    }\n\n    if (!this._tabster.focusable.isFocusable(container, true, true, true)) {\n      const prevTabIndex = container.getAttribute(\"tabindex\");\n      const prevAriaHidden = container.getAttribute(\"aria-hidden\");\n      container.tabIndex = -1;\n      container.setAttribute(\"aria-hidden\", \"true\");\n      FocusedElementState._lastResetElement = new WeakHTMLElement(this._win, container);\n      this.focus(container, true, true);\n\n      this._setOrRemoveAttribute(container, \"tabindex\", prevTabIndex);\n\n      this._setOrRemoveAttribute(container, \"aria-hidden\", prevAriaHidden);\n    } else {\n      this.focus(container);\n    }\n\n    return true;\n  }\n\n  requestAsyncFocus(source, callback, delay) {\n    const win = this._tabster.getWindow();\n\n    const currentAsyncFocus = this._asyncFocus;\n\n    if (currentAsyncFocus) {\n      if (AsyncFocusIntentPriorityBySource[source] > AsyncFocusIntentPriorityBySource[currentAsyncFocus.source]) {\n        // Previously registered intent has higher priority.\n        return;\n      } // New intent has higher priority.\n\n\n      win.clearTimeout(currentAsyncFocus.timeout);\n    }\n\n    this._asyncFocus = {\n      source,\n      callback,\n      timeout: win.setTimeout(() => {\n        this._asyncFocus = undefined;\n        callback();\n      }, delay)\n    };\n  }\n\n  cancelAsyncFocus(source) {\n    const asyncFocus = this._asyncFocus;\n\n    if ((asyncFocus === null || asyncFocus === void 0 ? void 0 : asyncFocus.source) === source) {\n      this._tabster.getWindow().clearTimeout(asyncFocus.timeout);\n\n      this._asyncFocus = undefined;\n    }\n  }\n\n  _setOrRemoveAttribute(element, name, value) {\n    if (value === null) {\n      element.removeAttribute(name);\n    } else {\n      element.setAttribute(name, value);\n    }\n  }\n\n  _setFocusedElement(element, relatedTarget, isFocusedProgrammatically) {\n    var _a, _b;\n\n    if (this._tabster._noop) {\n      return;\n    }\n\n    const detail = {\n      relatedTarget\n    };\n\n    if (element) {\n      const lastResetElement = (_a = FocusedElementState._lastResetElement) === null || _a === void 0 ? void 0 : _a.get();\n      FocusedElementState._lastResetElement = undefined;\n\n      if (lastResetElement === element || shouldIgnoreFocus(element)) {\n        return;\n      }\n\n      detail.isFocusedProgrammatically = isFocusedProgrammatically;\n      const ctx = RootAPI.getTabsterContext(this._tabster, element);\n      const modalizerId = (_b = ctx === null || ctx === void 0 ? void 0 : ctx.modalizer) === null || _b === void 0 ? void 0 : _b.userId;\n\n      if (modalizerId) {\n        detail.modalizerId = modalizerId;\n      }\n    }\n\n    const nextVal = this._nextVal = {\n      element: element ? new WeakHTMLElement(this._win, element) : undefined,\n      detail\n    };\n\n    if (element && element !== this._val) {\n      this._validateFocusedElement(element);\n    } // _validateFocusedElement() might cause the refocus which will trigger\n    // another call to this function. Making sure that the value is correct.\n\n\n    if (this._nextVal === nextVal) {\n      this.setVal(element, detail);\n    }\n\n    this._nextVal = undefined;\n  }\n\n  setVal(val, detail) {\n    super.setVal(val, detail);\n\n    if (val) {\n      this._lastVal = new WeakHTMLElement(this._win, val);\n    }\n  }\n\n  static findNextTabbable(tabster, ctx, container, currentElement, referenceElement, isBackward, ignoreAccessibility) {\n    const actualContainer = container || ctx.root.getElement();\n\n    if (!actualContainer) {\n      return null;\n    }\n\n    let next = null;\n    const isTabbingTimer = FocusedElementState._isTabbingTimer;\n    const win = tabster.getWindow();\n\n    if (isTabbingTimer) {\n      win.clearTimeout(isTabbingTimer);\n    }\n\n    FocusedElementState.isTabbing = true;\n    FocusedElementState._isTabbingTimer = win.setTimeout(() => {\n      delete FocusedElementState._isTabbingTimer;\n      FocusedElementState.isTabbing = false;\n    }, 0);\n    const modalizer = ctx.modalizer;\n    const groupper = ctx.groupper;\n    const mover = ctx.mover;\n\n    const callFindNext = what => {\n      next = what.findNextTabbable(currentElement, referenceElement, isBackward, ignoreAccessibility);\n\n      if (currentElement && !(next === null || next === void 0 ? void 0 : next.element)) {\n        const parentElement = what !== modalizer && dom.getParentElement(what.getElement());\n\n        if (parentElement) {\n          const parentCtx = RootAPI.getTabsterContext(tabster, currentElement, {\n            referenceElement: parentElement\n          });\n\n          if (parentCtx) {\n            const currentScopeElement = what.getElement();\n            const newCurrent = isBackward ? currentScopeElement : currentScopeElement && getLastChild$2(currentScopeElement) || currentScopeElement;\n\n            if (newCurrent) {\n              next = FocusedElementState.findNextTabbable(tabster, parentCtx, container, newCurrent, parentElement, isBackward, ignoreAccessibility);\n\n              if (next) {\n                next.outOfDOMOrder = true;\n              }\n            }\n          }\n        }\n      }\n    };\n\n    if (groupper && mover) {\n      callFindNext(ctx.groupperBeforeMover ? groupper : mover);\n    } else if (groupper) {\n      callFindNext(groupper);\n    } else if (mover) {\n      callFindNext(mover);\n    } else if (modalizer) {\n      callFindNext(modalizer);\n    } else {\n      const findProps = {\n        container: actualContainer,\n        currentElement,\n        referenceElement,\n        ignoreAccessibility,\n        useActiveModalizer: true\n      };\n      const findPropsOut = {};\n      const nextElement = tabster.focusable[isBackward ? \"findPrev\" : \"findNext\"](findProps, findPropsOut);\n      next = {\n        element: nextElement,\n        outOfDOMOrder: findPropsOut.outOfDOMOrder,\n        uncontrolled: findPropsOut.uncontrolled\n      };\n    }\n\n    return next;\n  }\n\n}\nFocusedElementState.isTabbing = false;\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nclass GroupperDummyManager extends DummyInputManager {\n  constructor(element, groupper, tabster, sys) {\n    super(tabster, element, DummyInputManagerPriorities.Groupper, sys, true);\n\n    this._setHandlers((dummyInput, isBackward, relatedTarget) => {\n      var _a, _b;\n\n      const container = element.get();\n      const input = dummyInput.input;\n\n      if (container && input) {\n        const ctx = RootAPI.getTabsterContext(tabster, input);\n\n        if (ctx) {\n          let next;\n          next = (_a = groupper.findNextTabbable(relatedTarget || undefined, undefined, isBackward, true)) === null || _a === void 0 ? void 0 : _a.element;\n\n          if (!next) {\n            next = (_b = FocusedElementState.findNextTabbable(tabster, ctx, undefined, dummyInput.isOutside ? input : getAdjacentElement(container, !isBackward), undefined, isBackward, true)) === null || _b === void 0 ? void 0 : _b.element;\n          }\n\n          if (next) {\n            nativeFocus(next);\n          }\n        }\n      }\n    });\n  }\n\n}\n\nclass Groupper extends TabsterPart {\n  constructor(tabster, element, onDispose, props, sys) {\n    super(tabster, element, props);\n    this._shouldTabInside = false;\n    this.makeTabbable(false);\n    this._onDispose = onDispose;\n\n    if (!tabster.controlTab) {\n      this.dummyManager = new GroupperDummyManager(this._element, this, tabster, sys);\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    this._onDispose(this);\n\n    const element = this._element.get();\n\n    (_a = this.dummyManager) === null || _a === void 0 ? void 0 : _a.dispose();\n    delete this.dummyManager;\n\n    if (element) {\n      if (process.env.NODE_ENV === 'development') {\n        _setInformativeStyle$1(this._element, true);\n      }\n    }\n\n    delete this._first;\n  }\n\n  findNextTabbable(currentElement, referenceElement, isBackward, ignoreAccessibility) {\n    const groupperElement = this.getElement();\n\n    if (!groupperElement) {\n      return null;\n    }\n\n    const currentIsDummy = getDummyInputContainer(currentElement) === groupperElement;\n\n    if (!this._shouldTabInside && currentElement && dom.nodeContains(groupperElement, currentElement) && !currentIsDummy) {\n      return {\n        element: undefined,\n        outOfDOMOrder: true\n      };\n    }\n\n    const groupperFirstFocusable = this.getFirst(true);\n\n    if (!currentElement || !dom.nodeContains(groupperElement, currentElement) || currentIsDummy) {\n      return {\n        element: groupperFirstFocusable,\n        outOfDOMOrder: true\n      };\n    }\n\n    const tabster = this._tabster;\n    let next = null;\n    let outOfDOMOrder = false;\n    let uncontrolled;\n\n    if (this._shouldTabInside && groupperFirstFocusable) {\n      const findProps = {\n        container: groupperElement,\n        currentElement,\n        referenceElement,\n        ignoreAccessibility,\n        useActiveModalizer: true\n      };\n      const findPropsOut = {};\n      next = tabster.focusable[isBackward ? \"findPrev\" : \"findNext\"](findProps, findPropsOut);\n      outOfDOMOrder = !!findPropsOut.outOfDOMOrder;\n\n      if (!next && this._props.tabbability === GroupperTabbabilities.LimitedTrapFocus) {\n        next = tabster.focusable[isBackward ? \"findLast\" : \"findFirst\"]({\n          container: groupperElement,\n          ignoreAccessibility,\n          useActiveModalizer: true\n        }, findPropsOut);\n        outOfDOMOrder = true;\n      }\n\n      uncontrolled = findPropsOut.uncontrolled;\n    }\n\n    return {\n      element: next,\n      uncontrolled,\n      outOfDOMOrder\n    };\n  }\n\n  makeTabbable(isTabbable) {\n    this._shouldTabInside = isTabbable || !this._props.tabbability;\n\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle$1(this._element, !this._shouldTabInside);\n    }\n  }\n\n  isActive(noIfFirstIsFocused) {\n    var _a;\n\n    const element = this.getElement() || null;\n    let isParentActive = true;\n\n    for (let e = dom.getParentElement(element); e; e = dom.getParentElement(e)) {\n      const g = (_a = getTabsterOnElement(this._tabster, e)) === null || _a === void 0 ? void 0 : _a.groupper;\n\n      if (g) {\n        if (!g._shouldTabInside) {\n          isParentActive = false;\n        }\n      }\n    }\n\n    let ret = isParentActive ? this._props.tabbability ? this._shouldTabInside : false : undefined;\n\n    if (ret && noIfFirstIsFocused) {\n      const focused = this._tabster.focusedElement.getFocusedElement();\n\n      if (focused) {\n        ret = focused !== this.getFirst(true);\n      }\n    }\n\n    return ret;\n  }\n\n  getFirst(orContainer) {\n    var _a;\n\n    const groupperElement = this.getElement();\n    let first;\n\n    if (groupperElement) {\n      if (orContainer && this._tabster.focusable.isFocusable(groupperElement)) {\n        return groupperElement;\n      }\n\n      first = (_a = this._first) === null || _a === void 0 ? void 0 : _a.get();\n\n      if (!first) {\n        first = this._tabster.focusable.findFirst({\n          container: groupperElement,\n          useActiveModalizer: true\n        }) || undefined;\n\n        if (first) {\n          this.setFirst(first);\n        }\n      }\n    }\n\n    return first;\n  }\n\n  setFirst(element) {\n    if (element) {\n      this._first = new WeakHTMLElement(this._tabster.getWindow, element);\n    } else {\n      delete this._first;\n    }\n  }\n\n  acceptElement(element, state) {\n    const cachedGrouppers = state.cachedGrouppers;\n    const parentElement = dom.getParentElement(this.getElement());\n    const parentCtx = parentElement && RootAPI.getTabsterContext(this._tabster, parentElement);\n    const parentCtxGroupper = parentCtx === null || parentCtx === void 0 ? void 0 : parentCtx.groupper;\n    const parentGroupper = (parentCtx === null || parentCtx === void 0 ? void 0 : parentCtx.groupperBeforeMover) ? parentCtxGroupper : undefined;\n    let parentGroupperElement;\n\n    const getIsActive = groupper => {\n      let cached = cachedGrouppers[groupper.id];\n      let isActive;\n\n      if (cached) {\n        isActive = cached.isActive;\n      } else {\n        isActive = this.isActive(true);\n        cached = cachedGrouppers[groupper.id] = {\n          isActive\n        };\n      }\n\n      return isActive;\n    };\n\n    if (parentGroupper) {\n      parentGroupperElement = parentGroupper.getElement();\n\n      if (!getIsActive(parentGroupper) && parentGroupperElement && state.container !== parentGroupperElement && dom.nodeContains(state.container, parentGroupperElement)) {\n        // Do not fall into a child groupper of inactive parent groupper if it's in the scope of the search.\n        state.skippedFocusable = true;\n        return NodeFilter.FILTER_REJECT;\n      }\n    }\n\n    const isActive = getIsActive(this);\n    const groupperElement = this.getElement();\n\n    if (groupperElement) {\n      if (isActive !== true) {\n        if (groupperElement === element && parentCtxGroupper) {\n          if (!parentGroupperElement) {\n            parentGroupperElement = parentCtxGroupper.getElement();\n          }\n\n          if (parentGroupperElement && !getIsActive(parentCtxGroupper) && dom.nodeContains(state.container, parentGroupperElement) && parentGroupperElement !== state.container) {\n            state.skippedFocusable = true;\n            return NodeFilter.FILTER_REJECT;\n          }\n        }\n\n        if (groupperElement !== element && dom.nodeContains(groupperElement, element)) {\n          state.skippedFocusable = true;\n          return NodeFilter.FILTER_REJECT;\n        }\n\n        const cached = cachedGrouppers[this.id];\n        let first;\n\n        if (\"first\" in cached) {\n          first = cached.first;\n        } else {\n          first = cached.first = this.getFirst(true);\n        }\n\n        if (first && state.acceptCondition(first)) {\n          state.rejectElementsFrom = groupperElement;\n          state.skippedFocusable = true;\n\n          if (first !== state.from) {\n            state.found = true;\n            state.foundElement = first;\n            return NodeFilter.FILTER_ACCEPT;\n          } else {\n            return NodeFilter.FILTER_REJECT;\n          }\n        }\n      }\n    }\n\n    return undefined;\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\nclass GroupperAPI {\n  constructor(tabster, getWindow) {\n    this._current = {};\n    this._grouppers = {};\n\n    this._init = () => {\n      const win = this._win(); // Making sure groupper's onFocus is called before modalizer's onFocus.\n\n\n      this._tabster.focusedElement.subscribeFirst(this._onFocus);\n\n      const doc = win.document;\n      const activeElement = dom.getActiveElement(doc);\n\n      if (activeElement) {\n        this._onFocus(activeElement);\n      }\n\n      doc.addEventListener(\"mousedown\", this._onMouseDown, true);\n      win.addEventListener(\"keydown\", this._onKeyDown, true);\n      win.addEventListener(GroupperMoveFocusEventName, this._onMoveFocus);\n    };\n\n    this._onGroupperDispose = groupper => {\n      delete this._grouppers[groupper.id];\n    };\n\n    this._onFocus = element => {\n      if (element) {\n        this._updateCurrent(element, true, true);\n      }\n    };\n\n    this._onMouseDown = e => {\n      if (e.target) {\n        this._updateCurrent(e.target, true);\n      }\n    };\n\n    this._onKeyDown = event => {\n      if (event.key !== Keys.Enter && event.key !== Keys.Escape) {\n        return;\n      } // Give a chance to other listeners to handle the event.\n\n\n      if (event.ctrlKey || event.altKey || event.shiftKey || event.metaKey) {\n        return;\n      }\n\n      const element = this._tabster.focusedElement.getFocusedElement();\n\n      if (element) {\n        this.handleKeyPress(element, event);\n      }\n    };\n\n    this._onMoveFocus = e => {\n      var _a;\n\n      const element = e.composedPath()[0];\n      const action = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.action;\n\n      if (element && action !== undefined && !e.defaultPrevented) {\n        if (action === GroupperMoveFocusActions.Enter) {\n          this._enterGroupper(element);\n        } else {\n          this._escapeGroupper(element);\n        }\n\n        e.stopImmediatePropagation();\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = getWindow;\n    tabster.queueInit(this._init);\n  }\n\n  dispose() {\n    const win = this._win();\n\n    this._tabster.focusedElement.cancelAsyncFocus(AsyncFocusSources.EscapeGroupper);\n\n    this._current = {};\n\n    if (this._updateTimer) {\n      win.clearTimeout(this._updateTimer);\n      delete this._updateTimer;\n    }\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    win.document.removeEventListener(\"mousedown\", this._onMouseDown, true);\n    win.removeEventListener(\"keydown\", this._onKeyDown, true);\n    win.removeEventListener(GroupperMoveFocusEventName, this._onMoveFocus);\n    Object.keys(this._grouppers).forEach(groupperId => {\n      if (this._grouppers[groupperId]) {\n        this._grouppers[groupperId].dispose();\n\n        delete this._grouppers[groupperId];\n      }\n    });\n  }\n\n  createGroupper(element, props, sys) {\n    if (process.env.NODE_ENV === 'development') ;\n\n    const newGroupper = new Groupper(this._tabster, element, this._onGroupperDispose, props, sys);\n    this._grouppers[newGroupper.id] = newGroupper;\n\n    const focusedElement = this._tabster.focusedElement.getFocusedElement(); // Newly created groupper contains currently focused element, update the state on the next tick (to\n    // make sure all grouppers are processed).\n\n\n    if (focusedElement && dom.nodeContains(element, focusedElement) && !this._updateTimer) {\n      this._updateTimer = this._win().setTimeout(() => {\n        delete this._updateTimer; // Making sure the focused element hasn't changed.\n\n        if (focusedElement === this._tabster.focusedElement.getFocusedElement()) {\n          this._updateCurrent(focusedElement, true, true);\n        }\n      }, 0);\n    }\n\n    return newGroupper;\n  }\n\n  forgetCurrentGrouppers() {\n    this._current = {};\n  }\n\n  _updateCurrent(element, includeTarget, checkTarget) {\n    var _a;\n\n    if (this._updateTimer) {\n      this._win().clearTimeout(this._updateTimer);\n\n      delete this._updateTimer;\n    }\n\n    const newIds = {};\n    let isTarget = true;\n\n    for (let el = element; el; el = dom.getParentElement(el)) {\n      const groupper = (_a = getTabsterOnElement(this._tabster, el)) === null || _a === void 0 ? void 0 : _a.groupper;\n\n      if (groupper) {\n        newIds[groupper.id] = true;\n\n        if (isTarget && checkTarget && el !== element) {\n          isTarget = false;\n        }\n\n        if (includeTarget || !isTarget) {\n          this._current[groupper.id] = groupper;\n          const isTabbable = groupper.isActive() || element !== el && (!groupper.getProps().delegated || groupper.getFirst(false) !== element);\n          groupper.makeTabbable(isTabbable);\n        }\n\n        isTarget = false;\n      }\n    }\n\n    for (const id of Object.keys(this._current)) {\n      const groupper = this._current[id];\n\n      if (!(groupper.id in newIds)) {\n        groupper.makeTabbable(false);\n        groupper.setFirst(undefined);\n        delete this._current[id];\n      }\n    }\n  }\n\n  _enterGroupper(element, relatedEvent) {\n    const tabster = this._tabster;\n    const ctx = RootAPI.getTabsterContext(tabster, element);\n    const groupper = (ctx === null || ctx === void 0 ? void 0 : ctx.groupper) || (ctx === null || ctx === void 0 ? void 0 : ctx.modalizerInGroupper);\n    const groupperElement = groupper === null || groupper === void 0 ? void 0 : groupper.getElement();\n\n    if (groupper && groupperElement && (element === groupperElement || groupper.getProps().delegated && element === groupper.getFirst(false))) {\n      const next = tabster.focusable.findNext({\n        container: groupperElement,\n        currentElement: element,\n        useActiveModalizer: true\n      });\n\n      if (next && (!relatedEvent || relatedEvent && groupperElement.dispatchEvent(new TabsterMoveFocusEvent({\n        by: \"groupper\",\n        owner: groupperElement,\n        next,\n        relatedEvent\n      })))) {\n        if (relatedEvent) {\n          // When the application hasn't prevented default,\n          // we consider the event completely handled, hence we\n          // prevent the initial event's default action and stop\n          // propagation.\n          relatedEvent.preventDefault();\n          relatedEvent.stopImmediatePropagation();\n        }\n\n        next.focus();\n        return next;\n      }\n    }\n\n    return null;\n  }\n\n  _escapeGroupper(element, relatedEvent, fromModalizer) {\n    var _a;\n\n    const tabster = this._tabster;\n    const ctx = RootAPI.getTabsterContext(tabster, element);\n    const modalizerInGroupper = ctx === null || ctx === void 0 ? void 0 : ctx.modalizerInGroupper;\n    let groupper = (ctx === null || ctx === void 0 ? void 0 : ctx.groupper) || modalizerInGroupper;\n    const groupperElement = groupper === null || groupper === void 0 ? void 0 : groupper.getElement();\n\n    if (groupper && groupperElement && dom.nodeContains(groupperElement, element)) {\n      let next;\n\n      if (element !== groupperElement || fromModalizer) {\n        next = groupper.getFirst(true);\n      } else {\n        const parentElement = dom.getParentElement(groupperElement);\n        const parentCtx = parentElement ? RootAPI.getTabsterContext(tabster, parentElement) : undefined;\n        groupper = parentCtx === null || parentCtx === void 0 ? void 0 : parentCtx.groupper;\n        next = groupper === null || groupper === void 0 ? void 0 : groupper.getFirst(true);\n      }\n\n      if (next && (!relatedEvent || relatedEvent && groupperElement.dispatchEvent(new TabsterMoveFocusEvent({\n        by: \"groupper\",\n        owner: groupperElement,\n        next,\n        relatedEvent\n      })))) {\n        if (groupper) {\n          groupper.makeTabbable(false);\n\n          if (modalizerInGroupper) {\n            (_a = tabster.modalizer) === null || _a === void 0 ? void 0 : _a.setActive(undefined);\n          }\n        } // This part happens asynchronously inside setTimeout,\n        // so no need to prevent default or stop propagation.\n\n\n        next.focus();\n        return next;\n      }\n    }\n\n    return null;\n  }\n\n  moveFocus(element, action) {\n    return action === GroupperMoveFocusActions.Enter ? this._enterGroupper(element) : this._escapeGroupper(element);\n  }\n\n  handleKeyPress(element, event, fromModalizer) {\n    const tabster = this._tabster;\n    const ctx = RootAPI.getTabsterContext(tabster, element);\n\n    if (ctx && ((ctx === null || ctx === void 0 ? void 0 : ctx.groupper) || (ctx === null || ctx === void 0 ? void 0 : ctx.modalizerInGroupper))) {\n      tabster.focusedElement.cancelAsyncFocus(AsyncFocusSources.EscapeGroupper);\n\n      if (ctx.ignoreKeydown(event)) {\n        return;\n      }\n\n      if (event.key === Keys.Enter) {\n        this._enterGroupper(element, event);\n      } else if (event.key === Keys.Escape) {\n        // We will handle Esc asynchronously, if something in the application will\n        // move focus during the keypress handling, we will not interfere.\n        const focusedElement = tabster.focusedElement.getFocusedElement();\n        tabster.focusedElement.requestAsyncFocus(AsyncFocusSources.EscapeGroupper, () => {\n          if (focusedElement !== tabster.focusedElement.getFocusedElement() && ( // A part of Modalizer that has called this handler to escape the active groupper\n          // might have been removed from DOM, if the focus is on body, we still want to handle Esc.\n          fromModalizer && !focusedElement || !fromModalizer)) {\n            // Something else in the application has moved focus, we will not handle Esc.\n            return;\n          }\n\n          this._escapeGroupper(element, event, fromModalizer);\n        }, 0);\n      }\n    }\n  }\n\n}\n\nfunction _setInformativeStyle$1(weakElement, remove) {\n  if (process.env.NODE_ENV === 'development') {\n    const element = weakElement.get();\n\n    if (element) {\n      if (remove) {\n        element.style.removeProperty(\"--tabster-groupper\");\n      } else {\n        element.style.setProperty(\"--tabster-groupper\", \"unlimited\");\n      }\n    }\n  }\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nclass KeyboardNavigationState extends Subscribable {\n  constructor(getWindow) {\n    super();\n\n    this._onChange = isNavigatingWithKeyboard => {\n      this.setVal(isNavigatingWithKeyboard, undefined);\n    };\n\n    this._keyborg = createKeyborg(getWindow());\n\n    this._keyborg.subscribe(this._onChange);\n  }\n\n  dispose() {\n    super.dispose();\n\n    if (this._keyborg) {\n      this._keyborg.unsubscribe(this._onChange);\n\n      disposeKeyborg(this._keyborg);\n      delete this._keyborg;\n    }\n  }\n\n  setNavigatingWithKeyboard(isNavigatingWithKeyboard) {\n    var _a;\n\n    (_a = this._keyborg) === null || _a === void 0 ? void 0 : _a.setVal(isNavigatingWithKeyboard);\n  }\n\n  isNavigatingWithKeyboard() {\n    var _a;\n\n    return !!((_a = this._keyborg) === null || _a === void 0 ? void 0 : _a.isNavigatingWithKeyboard());\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nlet _wasFocusedCounter = 0;\nconst _ariaHidden = \"aria-hidden\";\n\nfunction _setInformativeStyle(weakElement, remove, internalId, userId, isActive, wasFocused) {\n  if (process.env.NODE_ENV === 'development') {\n    const element = weakElement.get();\n\n    if (element) {\n      if (remove) {\n        element.style.removeProperty(\"--tabster-modalizer\");\n      } else {\n        element.style.setProperty(\"--tabster-modalizer\", internalId + \",\" + userId + \",\" + (isActive ? \"active\" : \"inactive\") + \",\" + \",\" + (wasFocused ? `focused(${wasFocused})` : \"not-focused\"));\n      }\n    }\n  }\n}\n/**\r\n * Manages the dummy inputs for the Modalizer.\r\n */\n\n\nclass ModalizerDummyManager extends DummyInputManager {\n  constructor(element, tabster, sys) {\n    super(tabster, element, DummyInputManagerPriorities.Modalizer, sys);\n\n    this._setHandlers((dummyInput, isBackward) => {\n      var _a, _b;\n\n      const el = element.get();\n      const container = el && ((_a = RootAPI.getRoot(tabster, el)) === null || _a === void 0 ? void 0 : _a.getElement());\n      const input = dummyInput.input;\n      let toFocus;\n\n      if (container && input) {\n        const dummyContainer = getDummyInputContainer(input);\n        const ctx = RootAPI.getTabsterContext(tabster, dummyContainer || input);\n\n        if (ctx) {\n          toFocus = (_b = FocusedElementState.findNextTabbable(tabster, ctx, container, input, undefined, isBackward, true)) === null || _b === void 0 ? void 0 : _b.element;\n        }\n\n        if (toFocus) {\n          nativeFocus(toFocus);\n        }\n      }\n    });\n  }\n\n}\n\nclass Modalizer extends TabsterPart {\n  constructor(tabster, element, onDispose, props, sys, activeElements) {\n    super(tabster, element, props);\n    this._wasFocused = 0;\n    this.userId = props.id;\n    this._onDispose = onDispose;\n    this._activeElements = activeElements;\n\n    if (!tabster.controlTab) {\n      this.dummyManager = new ModalizerDummyManager(this._element, tabster, sys);\n    }\n\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle(this._element, false, this.id, this.userId, this._isActive, this._wasFocused);\n    }\n  }\n\n  makeActive(isActive) {\n    if (this._isActive !== isActive) {\n      this._isActive = isActive;\n      const element = this.getElement();\n\n      if (element) {\n        const activeElements = this._activeElements;\n        const index = activeElements.map(e => e.get()).indexOf(element);\n\n        if (isActive) {\n          if (index < 0) {\n            activeElements.push(new WeakHTMLElement(this._tabster.getWindow, element));\n          }\n        } else {\n          if (index >= 0) {\n            activeElements.splice(index, 1);\n          }\n        }\n      }\n\n      if (process.env.NODE_ENV === 'development') {\n        _setInformativeStyle(this._element, false, this.id, this.userId, this._isActive, this._wasFocused);\n      }\n\n      this._dispatchEvent(isActive);\n    }\n  }\n\n  focused(noIncrement) {\n    if (!noIncrement) {\n      this._wasFocused = ++_wasFocusedCounter;\n    }\n\n    return this._wasFocused;\n  }\n\n  setProps(props) {\n    if (props.id) {\n      this.userId = props.id;\n    }\n\n    this._props = { ...props\n    };\n  }\n\n  dispose() {\n    var _a;\n\n    this.makeActive(false);\n\n    this._onDispose(this);\n\n    (_a = this.dummyManager) === null || _a === void 0 ? void 0 : _a.dispose();\n    delete this.dummyManager;\n    this._activeElements = [];\n\n    this._remove();\n  }\n\n  isActive() {\n    return !!this._isActive;\n  }\n\n  contains(element) {\n    return dom.nodeContains(this.getElement(), element);\n  }\n\n  findNextTabbable(currentElement, referenceElement, isBackward, ignoreAccessibility) {\n    var _a, _b;\n\n    const modalizerElement = this.getElement();\n\n    if (!modalizerElement) {\n      return null;\n    }\n\n    const tabster = this._tabster;\n    let next = null;\n    let outOfDOMOrder = false;\n    let uncontrolled;\n    const container = currentElement && ((_a = RootAPI.getRoot(tabster, currentElement)) === null || _a === void 0 ? void 0 : _a.getElement());\n\n    if (container) {\n      const findProps = {\n        container,\n        currentElement,\n        referenceElement,\n        ignoreAccessibility,\n        useActiveModalizer: true\n      };\n      const findPropsOut = {};\n      next = tabster.focusable[isBackward ? \"findPrev\" : \"findNext\"](findProps, findPropsOut);\n\n      if (!next && this._props.isTrapped && ((_b = tabster.modalizer) === null || _b === void 0 ? void 0 : _b.activeId)) {\n        next = tabster.focusable[isBackward ? \"findLast\" : \"findFirst\"]({\n          container,\n          ignoreAccessibility,\n          useActiveModalizer: true\n        }, findPropsOut);\n\n        if (next === null) {\n          next = currentElement;\n        }\n\n        outOfDOMOrder = true;\n      } else {\n        outOfDOMOrder = !!findPropsOut.outOfDOMOrder;\n      }\n\n      uncontrolled = findPropsOut.uncontrolled;\n    }\n\n    return {\n      element: next,\n      uncontrolled,\n      outOfDOMOrder\n    };\n  }\n\n  _dispatchEvent(isActive, allElements) {\n    const element = this.getElement();\n    let defaultPrevented = false;\n\n    if (element) {\n      const elements = allElements ? this._activeElements.map(e => e.get()) : [element];\n\n      for (const el of elements) {\n        if (el) {\n          const eventDetail = {\n            id: this.userId,\n            element\n          };\n          const event = isActive ? new ModalizerActiveEvent(eventDetail) : new ModalizerInactiveEvent(eventDetail);\n          el.dispatchEvent(event);\n\n          if (event.defaultPrevented) {\n            defaultPrevented = true;\n          }\n        }\n      }\n    }\n\n    return defaultPrevented;\n  }\n\n  _remove() {\n    if (process.env.NODE_ENV === 'development') {\n      _setInformativeStyle(this._element, true);\n    }\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n\nclass ModalizerAPI {\n  constructor(tabster, // @deprecated use accessibleCheck.\n  alwaysAccessibleSelector, accessibleCheck) {\n    this._onModalizerDispose = modalizer => {\n      const id = modalizer.id;\n      const userId = modalizer.userId;\n      const part = this._parts[userId];\n      delete this._modalizers[id];\n\n      if (part) {\n        delete part[id];\n\n        if (Object.keys(part).length === 0) {\n          delete this._parts[userId];\n\n          if (this.activeId === userId) {\n            this.setActive(undefined);\n          }\n        }\n      }\n    };\n\n    this._onKeyDown = event => {\n      var _a;\n\n      if (event.key !== Keys.Escape) {\n        return;\n      }\n\n      const tabster = this._tabster;\n      const element = tabster.focusedElement.getFocusedElement();\n\n      if (element) {\n        const ctx = RootAPI.getTabsterContext(tabster, element);\n        const modalizer = ctx === null || ctx === void 0 ? void 0 : ctx.modalizer;\n\n        if (ctx && !ctx.groupper && (modalizer === null || modalizer === void 0 ? void 0 : modalizer.isActive()) && !ctx.ignoreKeydown(event)) {\n          const activeId = modalizer.userId;\n\n          if (activeId) {\n            const part = this._parts[activeId];\n\n            if (part) {\n              const focusedSince = Object.keys(part).map(id => {\n                var _a;\n\n                const m = part[id];\n                const el = m.getElement();\n                let groupper;\n\n                if (el) {\n                  groupper = (_a = getTabsterOnElement(this._tabster, el)) === null || _a === void 0 ? void 0 : _a.groupper;\n                }\n\n                return m && el && groupper ? {\n                  el,\n                  focusedSince: m.focused(true)\n                } : {\n                  focusedSince: 0\n                };\n              }).filter(f => f.focusedSince > 0).sort((a, b) => a.focusedSince > b.focusedSince ? -1 : a.focusedSince < b.focusedSince ? 1 : 0);\n\n              if (focusedSince.length) {\n                const groupperElement = focusedSince[0].el;\n\n                if (groupperElement) {\n                  (_a = tabster.groupper) === null || _a === void 0 ? void 0 : _a.handleKeyPress(groupperElement, event, true);\n                }\n              }\n            }\n          }\n        }\n      }\n    };\n    /**\r\n     * Subscribes to the focus state and handles modalizer related focus events\r\n     * @param focusedElement - Element that is focused\r\n     * @param detail - Additional data about the focus event\r\n     */\n\n\n    this._onFocus = (focusedElement, detail) => {\n      var _a, _b;\n\n      const ctx = focusedElement && RootAPI.getTabsterContext(this._tabster, focusedElement); // Modalizer behaviour is opt in, only apply to elements that have a tabster context\n\n      if (!ctx || !focusedElement) {\n        return;\n      }\n\n      const augmentedMap = this._augMap;\n\n      for (let e = focusedElement; e; e = dom.getParentElement(e)) {\n        // If the newly focused element is inside some of the hidden containers,\n        // remove aria-hidden from those synchronously for the screen readers\n        // to be able to read the element. The rest of aria-hiddens, will be removed\n        // acynchronously for the sake of performance.\n        if (augmentedMap.has(e)) {\n          augmentedMap.delete(e);\n          augmentAttribute(this._tabster, e, _ariaHidden);\n        }\n      }\n\n      const modalizer = ctx.modalizer; // An inactive groupper with the modalizer on the same node will not give the modalizer\n      // in the context, yet we still want to track that the modalizer's container was focused.\n\n      (_b = modalizer || ((_a = getTabsterOnElement(this._tabster, focusedElement)) === null || _a === void 0 ? void 0 : _a.modalizer)) === null || _b === void 0 ? void 0 : _b.focused();\n\n      if ((modalizer === null || modalizer === void 0 ? void 0 : modalizer.userId) === this.activeId) {\n        this.currentIsOthersAccessible = modalizer === null || modalizer === void 0 ? void 0 : modalizer.getProps().isOthersAccessible;\n        return;\n      } // Developers calling `element.focus()` should change/deactivate active modalizer\n\n\n      if (detail.isFocusedProgrammatically || this.currentIsOthersAccessible || (modalizer === null || modalizer === void 0 ? void 0 : modalizer.getProps().isAlwaysAccessible)) {\n        this.setActive(modalizer);\n      } else {\n        // Focused outside of the active modalizer, try pull focus back to current modalizer\n        const win = this._win();\n\n        win.clearTimeout(this._restoreModalizerFocusTimer); // TODO some rendering frameworks (i.e. React) might async rerender the DOM so we need to wait for a duration\n        // Figure out a better way of doing this rather than a 100ms timeout\n\n        this._restoreModalizerFocusTimer = win.setTimeout(() => this._restoreModalizerFocus(focusedElement), 100);\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    this._modalizers = {};\n    this._parts = {};\n    this._augMap = new WeakMap();\n    this._aug = [];\n    this._alwaysAccessibleSelector = alwaysAccessibleSelector;\n    this._accessibleCheck = accessibleCheck;\n    this.activeElements = [];\n\n    if (!tabster.controlTab) {\n      tabster.root.addDummyInputs();\n    }\n\n    const win = this._win();\n\n    win.addEventListener(\"keydown\", this._onKeyDown, true);\n    tabster.queueInit(() => {\n      this._tabster.focusedElement.subscribe(this._onFocus);\n    });\n  }\n\n  dispose() {\n    const win = this._win();\n\n    win.removeEventListener(\"keydown\", this._onKeyDown, true); // Dispose all modalizers managed by the API\n\n    Object.keys(this._modalizers).forEach(modalizerId => {\n      if (this._modalizers[modalizerId]) {\n        this._modalizers[modalizerId].dispose();\n\n        delete this._modalizers[modalizerId];\n      }\n    });\n    win.clearTimeout(this._restoreModalizerFocusTimer);\n    win.clearTimeout(this._hiddenUpdateTimer);\n    this._parts = {};\n    delete this.activeId;\n    this.activeElements = [];\n    this._augMap = new WeakMap();\n    this._aug = [];\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n  }\n\n  createModalizer(element, props, sys) {\n    var _a;\n\n    if (process.env.NODE_ENV === 'development') ;\n\n    const modalizer = new Modalizer(this._tabster, element, this._onModalizerDispose, props, sys, this.activeElements);\n    const id = modalizer.id;\n    const userId = props.id;\n    this._modalizers[id] = modalizer;\n    let part = this._parts[userId];\n\n    if (!part) {\n      part = this._parts[userId] = {};\n    }\n\n    part[id] = modalizer; // Adding a modalizer which is already focused, activate it\n\n    if (dom.nodeContains(element, (_a = this._tabster.focusedElement.getFocusedElement()) !== null && _a !== void 0 ? _a : null)) {\n      if (userId !== this.activeId) {\n        this.setActive(modalizer);\n      } else {\n        modalizer.makeActive(true);\n      }\n    }\n\n    return modalizer;\n  }\n\n  isAugmented(element) {\n    return this._augMap.has(element);\n  }\n\n  hiddenUpdate() {\n    if (this._hiddenUpdateTimer) {\n      return;\n    }\n\n    this._hiddenUpdateTimer = this._win().setTimeout(() => {\n      delete this._hiddenUpdateTimer;\n\n      this._hiddenUpdate();\n    }, 250);\n  }\n\n  setActive(modalizer) {\n    const userId = modalizer === null || modalizer === void 0 ? void 0 : modalizer.userId;\n    const activeId = this.activeId;\n\n    if (activeId === userId) {\n      return;\n    }\n\n    this.activeId = userId;\n\n    if (activeId) {\n      const part = this._parts[activeId];\n\n      if (part) {\n        for (const id of Object.keys(part)) {\n          part[id].makeActive(false);\n        }\n      }\n    }\n\n    if (userId) {\n      const part = this._parts[userId];\n\n      if (part) {\n        for (const id of Object.keys(part)) {\n          part[id].makeActive(true);\n        }\n      }\n    }\n\n    this.currentIsOthersAccessible = modalizer === null || modalizer === void 0 ? void 0 : modalizer.getProps().isOthersAccessible;\n    this.hiddenUpdate();\n  }\n\n  focus(elementFromModalizer, noFocusFirst, noFocusDefault) {\n    const ctx = RootAPI.getTabsterContext(this._tabster, elementFromModalizer);\n    const modalizer = ctx === null || ctx === void 0 ? void 0 : ctx.modalizer;\n\n    if (modalizer) {\n      this.setActive(modalizer);\n      const props = modalizer.getProps();\n      const modalizerRoot = modalizer.getElement();\n\n      if (modalizerRoot) {\n        if (noFocusFirst === undefined) {\n          noFocusFirst = props.isNoFocusFirst;\n        }\n\n        if (!noFocusFirst && this._tabster.keyboardNavigation.isNavigatingWithKeyboard() && this._tabster.focusedElement.focusFirst({\n          container: modalizerRoot\n        })) {\n          return true;\n        }\n\n        if (noFocusDefault === undefined) {\n          noFocusDefault = props.isNoFocusDefault;\n        }\n\n        if (!noFocusDefault && this._tabster.focusedElement.focusDefault(modalizerRoot)) {\n          return true;\n        }\n\n        this._tabster.focusedElement.resetFocus(modalizerRoot);\n      }\n    } else if (process.env.NODE_ENV === 'development') {\n      console.error(\"Element is not in Modalizer.\", elementFromModalizer);\n    }\n\n    return false;\n  }\n\n  acceptElement(element, state) {\n    var _a;\n\n    const modalizerUserId = state.modalizerUserId;\n    const currentModalizer = (_a = state.currentCtx) === null || _a === void 0 ? void 0 : _a.modalizer;\n\n    if (modalizerUserId) {\n      for (const e of this.activeElements) {\n        const el = e.get();\n\n        if (el && (dom.nodeContains(element, el) || el === element)) {\n          // We have a part of currently active modalizer somewhere deeper in the DOM,\n          // skipping all other checks.\n          return NodeFilter.FILTER_SKIP;\n        }\n      }\n    }\n\n    const ret = modalizerUserId === (currentModalizer === null || currentModalizer === void 0 ? void 0 : currentModalizer.userId) || !modalizerUserId && (currentModalizer === null || currentModalizer === void 0 ? void 0 : currentModalizer.getProps().isAlwaysAccessible) ? undefined : NodeFilter.FILTER_SKIP;\n\n    if (ret !== undefined) {\n      state.skippedFocusable = true;\n    }\n\n    return ret;\n  }\n\n  _hiddenUpdate() {\n    var _a;\n\n    const tabster = this._tabster;\n    const body = tabster.getWindow().document.body;\n    const activeId = this.activeId;\n    const parts = this._parts;\n    const visibleElements = [];\n    const hiddenElements = [];\n    const alwaysAccessibleSelector = this._alwaysAccessibleSelector;\n    const alwaysAccessibleElements = alwaysAccessibleSelector ? Array.from(dom.querySelectorAll(body, alwaysAccessibleSelector)) : [];\n    const activeModalizerElements = [];\n\n    for (const userId of Object.keys(parts)) {\n      const modalizerParts = parts[userId];\n\n      for (const id of Object.keys(modalizerParts)) {\n        const modalizer = modalizerParts[id];\n        const el = modalizer.getElement();\n        const props = modalizer.getProps();\n        const isAlwaysAccessible = props.isAlwaysAccessible;\n\n        if (el) {\n          if (userId === activeId) {\n            activeModalizerElements.push(el);\n\n            if (!this.currentIsOthersAccessible) {\n              visibleElements.push(el);\n            }\n          } else if (isAlwaysAccessible) {\n            alwaysAccessibleElements.push(el);\n          } else {\n            hiddenElements.push(el);\n          }\n        }\n      }\n    }\n\n    const augmentedMap = this._augMap;\n    const allVisibleElements = visibleElements.length > 0 ? [...visibleElements, ...alwaysAccessibleElements] : undefined;\n    const newAugmented = [];\n    const newAugmentedMap = new WeakMap();\n\n    const toggle = (element, hide) => {\n      var _a;\n\n      const tagName = element.tagName;\n\n      if (tagName === \"SCRIPT\" || tagName === \"STYLE\") {\n        return;\n      }\n\n      let isAugmented = false;\n\n      if (augmentedMap.has(element)) {\n        if (hide) {\n          isAugmented = true;\n        } else {\n          augmentedMap.delete(element);\n          augmentAttribute(tabster, element, _ariaHidden);\n        }\n      } else if (hide && !((_a = this._accessibleCheck) === null || _a === void 0 ? void 0 : _a.call(this, element, activeModalizerElements)) && augmentAttribute(tabster, element, _ariaHidden, \"true\")) {\n        augmentedMap.set(element, true);\n        isAugmented = true;\n      }\n\n      if (isAugmented) {\n        newAugmented.push(new WeakHTMLElement(tabster.getWindow, element));\n        newAugmentedMap.set(element, true);\n      }\n    };\n\n    const walk = element => {\n      var _a;\n\n      for (let el = dom.getFirstElementChild(element); el; el = dom.getNextElementSibling(el)) {\n        let skip = false;\n        let containsModalizer = false;\n        let containedByModalizer = false;\n\n        if (allVisibleElements) {\n          const elParent = tabster.getParent(el);\n\n          for (const c of allVisibleElements) {\n            if (el === c) {\n              skip = true;\n              break;\n            }\n\n            if (dom.nodeContains(el, c)) {\n              containsModalizer = true;\n              break;\n            } else if (dom.nodeContains(c, elParent)) {\n              // tabster.getParent() could be provided by the application to\n              // handle, for example, virtual parents. Making sure, we are\n              // not setting aria-hidden on elements which are virtually\n              // inside modalizer.\n              containedByModalizer = true;\n            }\n          }\n\n          if (containsModalizer || ((_a = el.__tabsterElementFlags) === null || _a === void 0 ? void 0 : _a.noDirectAriaHidden)) {\n            walk(el);\n          } else if (!skip && !containedByModalizer) {\n            toggle(el, true);\n          }\n        } else {\n          toggle(el, false);\n        }\n      }\n    };\n\n    if (!allVisibleElements) {\n      alwaysAccessibleElements.forEach(e => toggle(e, false));\n    }\n\n    hiddenElements.forEach(e => toggle(e, true));\n\n    if (body) {\n      walk(body);\n    }\n\n    (_a = this._aug) === null || _a === void 0 ? void 0 : _a.map(e => e.get()).forEach(e => {\n      if (e && !newAugmentedMap.get(e)) {\n        toggle(e, false);\n      }\n    });\n    this._aug = newAugmented;\n    this._augMap = newAugmentedMap;\n  }\n  /**\r\n   * Called when an element is focused outside of an active modalizer.\r\n   * Attempts to pull focus back into the active modalizer\r\n   * @param outsideElement - An element being focused outside of the modalizer\r\n   */\n\n\n  _restoreModalizerFocus(outsideElement) {\n    const ownerDocument = outsideElement === null || outsideElement === void 0 ? void 0 : outsideElement.ownerDocument;\n\n    if (!outsideElement || !ownerDocument) {\n      return;\n    }\n\n    const ctx = RootAPI.getTabsterContext(this._tabster, outsideElement);\n    const modalizer = ctx === null || ctx === void 0 ? void 0 : ctx.modalizer;\n    const activeId = this.activeId;\n\n    if (!modalizer && !activeId || modalizer && activeId === modalizer.userId) {\n      return;\n    }\n\n    const container = ctx === null || ctx === void 0 ? void 0 : ctx.root.getElement();\n\n    if (container) {\n      let toFocus = this._tabster.focusable.findFirst({\n        container,\n        useActiveModalizer: true\n      });\n\n      if (toFocus) {\n        if (outsideElement.compareDocumentPosition(toFocus) & document.DOCUMENT_POSITION_PRECEDING) {\n          toFocus = this._tabster.focusable.findLast({\n            container,\n            useActiveModalizer: true\n          });\n\n          if (!toFocus) {\n            // This only might mean that findFirst/findLast are buggy and inconsistent.\n            throw new Error(\"Something went wrong.\");\n          }\n        }\n\n        this._tabster.focusedElement.focus(toFocus);\n\n        return;\n      }\n    } // Current Modalizer doesn't seem to have focusable elements.\n    // Blurring the currently focused element which is outside of the current Modalizer.\n\n\n    outsideElement.blur();\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nconst _inputSelector = /*#__PURE__*/[\"input\", \"textarea\", \"*[contenteditable]\"].join(\", \");\n\nclass MoverDummyManager extends DummyInputManager {\n  constructor(element, tabster, getMemorized, sys) {\n    super(tabster, element, DummyInputManagerPriorities.Mover, sys);\n\n    this._onFocusDummyInput = dummyInput => {\n      var _a, _b;\n\n      const container = this._element.get();\n\n      const input = dummyInput.input;\n\n      if (container && input) {\n        const ctx = RootAPI.getTabsterContext(this._tabster, container);\n        let toFocus;\n\n        if (ctx) {\n          toFocus = (_a = FocusedElementState.findNextTabbable(this._tabster, ctx, undefined, input, undefined, !dummyInput.isFirst, true)) === null || _a === void 0 ? void 0 : _a.element;\n        }\n\n        const memorized = (_b = this._getMemorized()) === null || _b === void 0 ? void 0 : _b.get();\n\n        if (memorized && this._tabster.focusable.isFocusable(memorized)) {\n          toFocus = memorized;\n        }\n\n        if (toFocus) {\n          nativeFocus(toFocus);\n        }\n      }\n    };\n\n    this._tabster = tabster;\n    this._getMemorized = getMemorized;\n\n    this._setHandlers(this._onFocusDummyInput);\n  }\n\n} // TypeScript enums produce depressing JavaScript code, so, we're just using\n// a few old style constants here.\n\n\nconst _moverUpdateAdd = 1;\nconst _moverUpdateAttr = 2;\nconst _moverUpdateRemove = 3;\nclass Mover extends TabsterPart {\n  constructor(tabster, element, onDispose, props, sys) {\n    var _a;\n\n    super(tabster, element, props);\n    this._visible = {};\n\n    this._onIntersection = entries => {\n      for (const entry of entries) {\n        const el = entry.target;\n        const id = getElementUId(this._win, el);\n        let newVisibility;\n        let fullyVisible = this._fullyVisible;\n\n        if (entry.intersectionRatio >= 0.25) {\n          newVisibility = entry.intersectionRatio >= 0.75 ? Visibilities.Visible : Visibilities.PartiallyVisible;\n\n          if (newVisibility === Visibilities.Visible) {\n            fullyVisible = id;\n          }\n        } else {\n          newVisibility = Visibilities.Invisible;\n        }\n\n        if (this._visible[id] !== newVisibility) {\n          if (newVisibility === undefined) {\n            delete this._visible[id];\n\n            if (fullyVisible === id) {\n              delete this._fullyVisible;\n            }\n          } else {\n            this._visible[id] = newVisibility;\n            this._fullyVisible = fullyVisible;\n          }\n\n          const state = this.getState(el);\n\n          if (state) {\n            el.dispatchEvent(new MoverStateEvent(state));\n          }\n        }\n      }\n    };\n\n    this._win = tabster.getWindow;\n    this.visibilityTolerance = (_a = props.visibilityTolerance) !== null && _a !== void 0 ? _a : 0.8;\n\n    if (this._props.trackState || this._props.visibilityAware) {\n      this._intersectionObserver = new IntersectionObserver(this._onIntersection, {\n        threshold: [0, 0.25, 0.5, 0.75, 1]\n      });\n\n      this._observeState();\n    }\n\n    this._onDispose = onDispose;\n\n    const getMemorized = () => props.memorizeCurrent ? this._current : undefined;\n\n    if (!tabster.controlTab) {\n      this.dummyManager = new MoverDummyManager(this._element, tabster, getMemorized, sys);\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    this._onDispose(this);\n\n    if (this._intersectionObserver) {\n      this._intersectionObserver.disconnect();\n\n      delete this._intersectionObserver;\n    }\n\n    delete this._current;\n    delete this._fullyVisible;\n    delete this._allElements;\n    delete this._updateQueue;\n\n    if (this._unobserve) {\n      this._unobserve();\n\n      delete this._unobserve;\n    }\n\n    const win = this._win();\n\n    if (this._setCurrentTimer) {\n      win.clearTimeout(this._setCurrentTimer);\n      delete this._setCurrentTimer;\n    }\n\n    if (this._updateTimer) {\n      win.clearTimeout(this._updateTimer);\n      delete this._updateTimer;\n    }\n\n    (_a = this.dummyManager) === null || _a === void 0 ? void 0 : _a.dispose();\n    delete this.dummyManager;\n  }\n\n  setCurrent(element) {\n    if (element) {\n      this._current = new WeakHTMLElement(this._win, element);\n    } else {\n      this._current = undefined;\n    }\n\n    if ((this._props.trackState || this._props.visibilityAware) && !this._setCurrentTimer) {\n      this._setCurrentTimer = this._win().setTimeout(() => {\n        var _a;\n\n        delete this._setCurrentTimer;\n        const changed = [];\n\n        if (this._current !== this._prevCurrent) {\n          changed.push(this._current);\n          changed.push(this._prevCurrent);\n          this._prevCurrent = this._current;\n        }\n\n        for (const weak of changed) {\n          const el = weak === null || weak === void 0 ? void 0 : weak.get();\n\n          if (el && ((_a = this._allElements) === null || _a === void 0 ? void 0 : _a.get(el)) === this) {\n            const props = this._props;\n\n            if (el && (props.visibilityAware !== undefined || props.trackState)) {\n              const state = this.getState(el);\n\n              if (state) {\n                el.dispatchEvent(new MoverStateEvent(state));\n              }\n            }\n          }\n        }\n      });\n    }\n  }\n\n  getCurrent() {\n    var _a;\n\n    return ((_a = this._current) === null || _a === void 0 ? void 0 : _a.get()) || null;\n  }\n\n  findNextTabbable(currentElement, referenceElement, isBackward, ignoreAccessibility) {\n    const container = this.getElement();\n    const currentIsDummy = container && getDummyInputContainer(currentElement) === container;\n\n    if (!container) {\n      return null;\n    }\n\n    let next = null;\n    let outOfDOMOrder = false;\n    let uncontrolled;\n\n    if (this._props.tabbable || currentIsDummy || currentElement && !dom.nodeContains(container, currentElement)) {\n      const findProps = {\n        currentElement,\n        referenceElement,\n        container,\n        ignoreAccessibility,\n        useActiveModalizer: true\n      };\n      const findPropsOut = {};\n      next = this._tabster.focusable[isBackward ? \"findPrev\" : \"findNext\"](findProps, findPropsOut);\n      outOfDOMOrder = !!findPropsOut.outOfDOMOrder;\n      uncontrolled = findPropsOut.uncontrolled;\n    }\n\n    return {\n      element: next,\n      uncontrolled,\n      outOfDOMOrder\n    };\n  }\n\n  acceptElement(element, state) {\n    var _a, _b;\n\n    if (!FocusedElementState.isTabbing) {\n      return ((_a = state.currentCtx) === null || _a === void 0 ? void 0 : _a.excludedFromMover) ? NodeFilter.FILTER_REJECT : undefined;\n    }\n\n    const {\n      memorizeCurrent,\n      visibilityAware,\n      hasDefault = true\n    } = this._props;\n    const moverElement = this.getElement();\n\n    if (moverElement && (memorizeCurrent || visibilityAware || hasDefault) && (!dom.nodeContains(moverElement, state.from) || getDummyInputContainer(state.from) === moverElement)) {\n      let found;\n\n      if (memorizeCurrent) {\n        const current = (_b = this._current) === null || _b === void 0 ? void 0 : _b.get();\n\n        if (current && state.acceptCondition(current)) {\n          found = current;\n        }\n      }\n\n      if (!found && hasDefault) {\n        found = this._tabster.focusable.findDefault({\n          container: moverElement,\n          useActiveModalizer: true\n        });\n      }\n\n      if (!found && visibilityAware) {\n        found = this._tabster.focusable.findElement({\n          container: moverElement,\n          useActiveModalizer: true,\n          isBackward: state.isBackward,\n          acceptCondition: el => {\n            var _a;\n\n            const id = getElementUId(this._win, el);\n            const visibility = this._visible[id];\n            return moverElement !== el && !!((_a = this._allElements) === null || _a === void 0 ? void 0 : _a.get(el)) && state.acceptCondition(el) && (visibility === Visibilities.Visible || visibility === Visibilities.PartiallyVisible && (visibilityAware === Visibilities.PartiallyVisible || !this._fullyVisible));\n          }\n        });\n      }\n\n      if (found) {\n        state.found = true;\n        state.foundElement = found;\n        state.rejectElementsFrom = moverElement;\n        state.skippedFocusable = true;\n        return NodeFilter.FILTER_ACCEPT;\n      }\n    }\n\n    return undefined;\n  }\n\n  _observeState() {\n    const element = this.getElement();\n\n    if (this._unobserve || !element || typeof MutationObserver === \"undefined\") {\n      return;\n    }\n\n    const win = this._win();\n\n    const allElements = this._allElements = new WeakMap();\n    const tabsterFocusable = this._tabster.focusable;\n    let updateQueue = this._updateQueue = [];\n    const observer = dom.createMutationObserver(mutations => {\n      for (const mutation of mutations) {\n        const target = mutation.target;\n        const removed = mutation.removedNodes;\n        const added = mutation.addedNodes;\n\n        if (mutation.type === \"attributes\") {\n          if (mutation.attributeName === \"tabindex\") {\n            updateQueue.push({\n              element: target,\n              type: _moverUpdateAttr\n            });\n          }\n        } else {\n          for (let i = 0; i < removed.length; i++) {\n            updateQueue.push({\n              element: removed[i],\n              type: _moverUpdateRemove\n            });\n          }\n\n          for (let i = 0; i < added.length; i++) {\n            updateQueue.push({\n              element: added[i],\n              type: _moverUpdateAdd\n            });\n          }\n        }\n      }\n\n      requestUpdate();\n    });\n\n    const setElement = (element, remove) => {\n      var _a, _b;\n\n      const current = allElements.get(element);\n\n      if (current && remove) {\n        (_a = this._intersectionObserver) === null || _a === void 0 ? void 0 : _a.unobserve(element);\n        allElements.delete(element);\n      }\n\n      if (!current && !remove) {\n        allElements.set(element, this);\n        (_b = this._intersectionObserver) === null || _b === void 0 ? void 0 : _b.observe(element);\n      }\n    };\n\n    const updateElement = element => {\n      const isFocusable = tabsterFocusable.isFocusable(element);\n      const current = allElements.get(element);\n\n      if (current) {\n        if (!isFocusable) {\n          setElement(element, true);\n        }\n      } else {\n        if (isFocusable) {\n          setElement(element);\n        }\n      }\n    };\n\n    const addNewElements = element => {\n      const {\n        mover\n      } = getMoverGroupper(element);\n\n      if (mover && mover !== this) {\n        if (mover.getElement() === element && tabsterFocusable.isFocusable(element)) {\n          setElement(element);\n        } else {\n          return;\n        }\n      }\n\n      const walker = createElementTreeWalker(win.document, element, node => {\n        const {\n          mover,\n          groupper\n        } = getMoverGroupper(node);\n\n        if (mover && mover !== this) {\n          return NodeFilter.FILTER_REJECT;\n        }\n\n        const groupperFirstFocusable = groupper === null || groupper === void 0 ? void 0 : groupper.getFirst(true);\n\n        if (groupper && groupper.getElement() !== node && groupperFirstFocusable && groupperFirstFocusable !== node) {\n          return NodeFilter.FILTER_REJECT;\n        }\n\n        if (tabsterFocusable.isFocusable(node)) {\n          setElement(node);\n        }\n\n        return NodeFilter.FILTER_SKIP;\n      });\n\n      if (walker) {\n        walker.currentNode = element;\n\n        while (walker.nextNode()) {\n          /* Iterating for the sake of calling processNode() callback. */\n        }\n      }\n    };\n\n    const removeWalk = element => {\n      const current = allElements.get(element);\n\n      if (current) {\n        setElement(element, true);\n      }\n\n      for (let el = dom.getFirstElementChild(element); el; el = dom.getNextElementSibling(el)) {\n        removeWalk(el);\n      }\n    };\n\n    const requestUpdate = () => {\n      if (!this._updateTimer && updateQueue.length) {\n        this._updateTimer = win.setTimeout(() => {\n          delete this._updateTimer;\n\n          for (const {\n            element,\n            type\n          } of updateQueue) {\n            switch (type) {\n              case _moverUpdateAttr:\n                updateElement(element);\n                break;\n\n              case _moverUpdateAdd:\n                addNewElements(element);\n                break;\n\n              case _moverUpdateRemove:\n                removeWalk(element);\n                break;\n            }\n          }\n\n          updateQueue = this._updateQueue = [];\n        }, 0);\n      }\n    };\n\n    const getMoverGroupper = element => {\n      const ret = {};\n\n      for (let el = element; el; el = dom.getParentElement(el)) {\n        const toe = getTabsterOnElement(this._tabster, el);\n\n        if (toe) {\n          if (toe.groupper && !ret.groupper) {\n            ret.groupper = toe.groupper;\n          }\n\n          if (toe.mover) {\n            ret.mover = toe.mover;\n            break;\n          }\n        }\n      }\n\n      return ret;\n    };\n\n    updateQueue.push({\n      element,\n      type: _moverUpdateAdd\n    });\n    requestUpdate();\n    observer.observe(element, {\n      childList: true,\n      subtree: true,\n      attributes: true,\n      attributeFilter: [\"tabindex\"]\n    });\n\n    this._unobserve = () => {\n      observer.disconnect();\n    };\n  }\n\n  getState(element) {\n    const id = getElementUId(this._win, element);\n\n    if (id in this._visible) {\n      const visibility = this._visible[id] || Visibilities.Invisible;\n      const isCurrent = this._current ? this._current.get() === element : undefined;\n      return {\n        isCurrent,\n        visibility\n      };\n    }\n\n    return undefined;\n  }\n\n} // eslint-disable-next-line @typescript-eslint/no-unused-vars\n/**\r\n * Calculates distance between two rectangles.\r\n *\r\n * @param ax1 first rectangle left\r\n * @param ay1 first rectangle top\r\n * @param ax2 first rectangle right\r\n * @param ay2 first rectangle bottom\r\n * @param bx1 second rectangle left\r\n * @param by1 second rectangle top\r\n * @param bx2 second rectangle right\r\n * @param by2 second rectangle bottom\r\n * @returns number, shortest distance between the rectangles.\r\n */\n\n\nfunction getDistance(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2) {\n  const xDistance = ax2 < bx1 ? bx1 - ax2 : bx2 < ax1 ? ax1 - bx2 : 0;\n  const yDistance = ay2 < by1 ? by1 - ay2 : by2 < ay1 ? ay1 - by2 : 0;\n  return xDistance === 0 ? yDistance : yDistance === 0 ? xDistance : Math.sqrt(xDistance * xDistance + yDistance * yDistance);\n}\n\nclass MoverAPI {\n  constructor(tabster, getWindow) {\n    this._init = () => {\n      const win = this._win();\n\n      win.addEventListener(\"keydown\", this._onKeyDown, true);\n      win.addEventListener(MoverMoveFocusEventName, this._onMoveFocus);\n      win.addEventListener(MoverMemorizedElementEventName, this._onMemorizedElement);\n\n      this._tabster.focusedElement.subscribe(this._onFocus);\n    };\n\n    this._onMoverDispose = mover => {\n      delete this._movers[mover.id];\n    };\n\n    this._onFocus = element => {\n      var _a; // When something in the app gets focused, we are making sure that\n      // the relevant context Mover is aware of it.\n      // Looking for the relevant context Mover from the currently\n      // focused element parent, not from the element itself, because the\n      // Mover element itself cannot be its own current (but might be\n      // current for its parent Mover).\n\n\n      let currentFocusableElement = element;\n      let deepestFocusableElement = element;\n\n      for (let el = dom.getParentElement(element); el; el = dom.getParentElement(el)) {\n        // We go through all Movers up from the focused element and\n        // set their current element to the deepest focusable of that\n        // Mover.\n        const mover = (_a = getTabsterOnElement(this._tabster, el)) === null || _a === void 0 ? void 0 : _a.mover;\n\n        if (mover) {\n          mover.setCurrent(deepestFocusableElement);\n          currentFocusableElement = undefined;\n        }\n\n        if (!currentFocusableElement && this._tabster.focusable.isFocusable(el)) {\n          currentFocusableElement = deepestFocusableElement = el;\n        }\n      }\n    };\n\n    this._onKeyDown = async event => {\n      var _a;\n\n      if (this._ignoredInputTimer) {\n        this._win().clearTimeout(this._ignoredInputTimer);\n\n        delete this._ignoredInputTimer;\n      }\n\n      (_a = this._ignoredInputResolve) === null || _a === void 0 ? void 0 : _a.call(this, false); // Give a chance to other listeners to handle the event (for example,\n      // to scroll instead of moving focus).\n\n      if (event.ctrlKey || event.altKey || event.shiftKey || event.metaKey) {\n        return;\n      }\n\n      const key = event.key;\n      let moverKey;\n\n      if (key === Keys.ArrowDown) {\n        moverKey = MoverKeys.ArrowDown;\n      } else if (key === Keys.ArrowRight) {\n        moverKey = MoverKeys.ArrowRight;\n      } else if (key === Keys.ArrowUp) {\n        moverKey = MoverKeys.ArrowUp;\n      } else if (key === Keys.ArrowLeft) {\n        moverKey = MoverKeys.ArrowLeft;\n      } else if (key === Keys.PageDown) {\n        moverKey = MoverKeys.PageDown;\n      } else if (key === Keys.PageUp) {\n        moverKey = MoverKeys.PageUp;\n      } else if (key === Keys.Home) {\n        moverKey = MoverKeys.Home;\n      } else if (key === Keys.End) {\n        moverKey = MoverKeys.End;\n      }\n\n      if (!moverKey) {\n        return;\n      }\n\n      const focused = this._tabster.focusedElement.getFocusedElement();\n\n      if (!focused || (await this._isIgnoredInput(focused, key))) {\n        return;\n      }\n\n      this._moveFocus(focused, moverKey, event);\n    };\n\n    this._onMoveFocus = e => {\n      var _a;\n\n      const element = e.composedPath()[0];\n      const key = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.key;\n\n      if (element && key !== undefined && !e.defaultPrevented) {\n        this._moveFocus(element, key);\n\n        e.stopImmediatePropagation();\n      }\n    };\n\n    this._onMemorizedElement = e => {\n      var _a;\n\n      const target = e.composedPath()[0];\n      let memorizedElement = (_a = e.detail) === null || _a === void 0 ? void 0 : _a.memorizedElement;\n\n      if (target) {\n        const ctx = RootAPI.getTabsterContext(this._tabster, target);\n        const mover = ctx === null || ctx === void 0 ? void 0 : ctx.mover;\n\n        if (mover) {\n          if (memorizedElement && !dom.nodeContains(mover.getElement(), memorizedElement)) {\n            memorizedElement = undefined;\n          }\n\n          mover.setCurrent(memorizedElement);\n          e.stopImmediatePropagation();\n        }\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = getWindow;\n    this._movers = {};\n    tabster.queueInit(this._init);\n  }\n\n  dispose() {\n    var _a;\n\n    const win = this._win();\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    (_a = this._ignoredInputResolve) === null || _a === void 0 ? void 0 : _a.call(this, false);\n\n    if (this._ignoredInputTimer) {\n      win.clearTimeout(this._ignoredInputTimer);\n      delete this._ignoredInputTimer;\n    }\n\n    win.removeEventListener(\"keydown\", this._onKeyDown, true);\n    win.removeEventListener(MoverMoveFocusEventName, this._onMoveFocus);\n    win.removeEventListener(MoverMemorizedElementEventName, this._onMemorizedElement);\n    Object.keys(this._movers).forEach(moverId => {\n      if (this._movers[moverId]) {\n        this._movers[moverId].dispose();\n\n        delete this._movers[moverId];\n      }\n    });\n  }\n\n  createMover(element, props, sys) {\n    if (process.env.NODE_ENV === 'development') ;\n\n    const newMover = new Mover(this._tabster, element, this._onMoverDispose, props, sys);\n    this._movers[newMover.id] = newMover;\n    return newMover;\n  }\n\n  moveFocus(fromElement, key) {\n    return this._moveFocus(fromElement, key);\n  }\n\n  _moveFocus(fromElement, key, relatedEvent) {\n    var _a, _b;\n\n    const tabster = this._tabster;\n    const ctx = RootAPI.getTabsterContext(tabster, fromElement, {\n      checkRtl: true\n    });\n\n    if (!ctx || !ctx.mover || ctx.excludedFromMover || relatedEvent && ctx.ignoreKeydown(relatedEvent)) {\n      return null;\n    }\n\n    const mover = ctx.mover;\n    const container = mover.getElement();\n\n    if (ctx.groupperBeforeMover) {\n      const groupper = ctx.groupper;\n\n      if (groupper && !groupper.isActive(true)) {\n        // For the cases when we have Mover/Active Groupper/Inactive Groupper, we need to check\n        // the grouppers between the current element and the current mover.\n        for (let el = dom.getParentElement(groupper.getElement()); el && el !== container; el = dom.getParentElement(el)) {\n          if ((_b = (_a = getTabsterOnElement(tabster, el)) === null || _a === void 0 ? void 0 : _a.groupper) === null || _b === void 0 ? void 0 : _b.isActive(true)) {\n            return null;\n          }\n        }\n      } else {\n        return null;\n      }\n    }\n\n    if (!container) {\n      return null;\n    }\n\n    const focusable = tabster.focusable;\n    const moverProps = mover.getProps();\n    const direction = moverProps.direction || MoverDirections.Both;\n    const isBoth = direction === MoverDirections.Both;\n    const isVertical = isBoth || direction === MoverDirections.Vertical;\n    const isHorizontal = isBoth || direction === MoverDirections.Horizontal;\n    const isGridLinear = direction === MoverDirections.GridLinear;\n    const isGrid = isGridLinear || direction === MoverDirections.Grid;\n    const isCyclic = moverProps.cyclic;\n    let next;\n    let scrollIntoViewArg;\n    let focusedElementRect;\n    let focusedElementX1 = 0;\n    let focusedElementX2 = 0;\n\n    if (isGrid) {\n      focusedElementRect = fromElement.getBoundingClientRect();\n      focusedElementX1 = Math.ceil(focusedElementRect.left);\n      focusedElementX2 = Math.floor(focusedElementRect.right);\n    }\n\n    if (ctx.rtl) {\n      if (key === MoverKeys.ArrowRight) {\n        key = MoverKeys.ArrowLeft;\n      } else if (key === MoverKeys.ArrowLeft) {\n        key = MoverKeys.ArrowRight;\n      }\n    }\n\n    if (key === MoverKeys.ArrowDown && isVertical || key === MoverKeys.ArrowRight && (isHorizontal || isGrid)) {\n      next = focusable.findNext({\n        currentElement: fromElement,\n        container,\n        useActiveModalizer: true\n      });\n\n      if (next && isGrid) {\n        const nextElementX1 = Math.ceil(next.getBoundingClientRect().left);\n\n        if (!isGridLinear && focusedElementX2 > nextElementX1) {\n          next = undefined;\n        }\n      } else if (!next && isCyclic) {\n        next = focusable.findFirst({\n          container,\n          useActiveModalizer: true\n        });\n      }\n    } else if (key === MoverKeys.ArrowUp && isVertical || key === MoverKeys.ArrowLeft && (isHorizontal || isGrid)) {\n      next = focusable.findPrev({\n        currentElement: fromElement,\n        container,\n        useActiveModalizer: true\n      });\n\n      if (next && isGrid) {\n        const nextElementX2 = Math.floor(next.getBoundingClientRect().right);\n\n        if (!isGridLinear && nextElementX2 > focusedElementX1) {\n          next = undefined;\n        }\n      } else if (!next && isCyclic) {\n        next = focusable.findLast({\n          container,\n          useActiveModalizer: true\n        });\n      }\n    } else if (key === MoverKeys.Home) {\n      if (isGrid) {\n        focusable.findElement({\n          container,\n          currentElement: fromElement,\n          useActiveModalizer: true,\n          isBackward: true,\n          acceptCondition: el => {\n            var _a;\n\n            if (!focusable.isFocusable(el)) {\n              return false;\n            }\n\n            const nextElementX1 = Math.ceil((_a = el.getBoundingClientRect().left) !== null && _a !== void 0 ? _a : 0);\n\n            if (el !== fromElement && focusedElementX1 <= nextElementX1) {\n              return true;\n            }\n\n            next = el;\n            return false;\n          }\n        });\n      } else {\n        next = focusable.findFirst({\n          container,\n          useActiveModalizer: true\n        });\n      }\n    } else if (key === MoverKeys.End) {\n      if (isGrid) {\n        focusable.findElement({\n          container,\n          currentElement: fromElement,\n          useActiveModalizer: true,\n          acceptCondition: el => {\n            var _a;\n\n            if (!focusable.isFocusable(el)) {\n              return false;\n            }\n\n            const nextElementX1 = Math.ceil((_a = el.getBoundingClientRect().left) !== null && _a !== void 0 ? _a : 0);\n\n            if (el !== fromElement && focusedElementX1 >= nextElementX1) {\n              return true;\n            }\n\n            next = el;\n            return false;\n          }\n        });\n      } else {\n        next = focusable.findLast({\n          container,\n          useActiveModalizer: true\n        });\n      }\n    } else if (key === MoverKeys.PageUp) {\n      focusable.findElement({\n        currentElement: fromElement,\n        container,\n        useActiveModalizer: true,\n        isBackward: true,\n        acceptCondition: el => {\n          if (!focusable.isFocusable(el)) {\n            return false;\n          }\n\n          if (isElementVerticallyVisibleInContainer(this._win, el, mover.visibilityTolerance)) {\n            next = el;\n            return false;\n          }\n\n          return true;\n        }\n      }); // will be on the first column move forward and preserve previous column\n\n      if (isGrid && next) {\n        const firstColumnX1 = Math.ceil(next.getBoundingClientRect().left);\n        focusable.findElement({\n          currentElement: next,\n          container,\n          useActiveModalizer: true,\n          acceptCondition: el => {\n            if (!focusable.isFocusable(el)) {\n              return false;\n            }\n\n            const nextElementX1 = Math.ceil(el.getBoundingClientRect().left);\n\n            if (focusedElementX1 < nextElementX1 || firstColumnX1 >= nextElementX1) {\n              return true;\n            }\n\n            next = el;\n            return false;\n          }\n        });\n      }\n\n      scrollIntoViewArg = false;\n    } else if (key === MoverKeys.PageDown) {\n      focusable.findElement({\n        currentElement: fromElement,\n        container,\n        useActiveModalizer: true,\n        acceptCondition: el => {\n          if (!focusable.isFocusable(el)) {\n            return false;\n          }\n\n          if (isElementVerticallyVisibleInContainer(this._win, el, mover.visibilityTolerance)) {\n            next = el;\n            return false;\n          }\n\n          return true;\n        }\n      }); // will be on the last column move backwards and preserve previous column\n\n      if (isGrid && next) {\n        const lastColumnX1 = Math.ceil(next.getBoundingClientRect().left);\n        focusable.findElement({\n          currentElement: next,\n          container,\n          useActiveModalizer: true,\n          isBackward: true,\n          acceptCondition: el => {\n            if (!focusable.isFocusable(el)) {\n              return false;\n            }\n\n            const nextElementX1 = Math.ceil(el.getBoundingClientRect().left);\n\n            if (focusedElementX1 > nextElementX1 || lastColumnX1 <= nextElementX1) {\n              return true;\n            }\n\n            next = el;\n            return false;\n          }\n        });\n      }\n\n      scrollIntoViewArg = true;\n    } else if (isGrid) {\n      const isBackward = key === MoverKeys.ArrowUp;\n      const ax1 = focusedElementX1; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n      const ay1 = Math.ceil(focusedElementRect.top);\n      const ax2 = focusedElementX2; // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n      const ay2 = Math.floor(focusedElementRect.bottom);\n      let targetElement;\n      let lastDistance;\n      let lastIntersection = 0;\n      focusable.findAll({\n        container,\n        currentElement: fromElement,\n        isBackward,\n        onElement: el => {\n          // Find element which has maximal intersection with the focused element horizontally,\n          // or the closest one.\n          const rect = el.getBoundingClientRect();\n          const bx1 = Math.ceil(rect.left);\n          const by1 = Math.ceil(rect.top);\n          const bx2 = Math.floor(rect.right);\n          const by2 = Math.floor(rect.bottom);\n\n          if (isBackward && ay1 < by2 || !isBackward && ay2 > by1) {\n            // Only consider elements which are below/above curretly focused.\n            return true;\n          }\n\n          const xIntersectionWidth = Math.ceil(Math.min(ax2, bx2)) - Math.floor(Math.max(ax1, bx1));\n          const minWidth = Math.ceil(Math.min(ax2 - ax1, bx2 - bx1));\n\n          if (xIntersectionWidth > 0 && minWidth >= xIntersectionWidth) {\n            // Element intersects with the focused element on X axis.\n            const intersection = xIntersectionWidth / minWidth;\n\n            if (intersection > lastIntersection) {\n              targetElement = el;\n              lastIntersection = intersection;\n            }\n          } else if (lastIntersection === 0) {\n            // If we didn't have intersection, try just the closest one.\n            const distance = getDistance(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2);\n\n            if (lastDistance === undefined || distance < lastDistance) {\n              lastDistance = distance;\n              targetElement = el;\n            }\n          } else if (lastIntersection > 0) {\n            // Element doesn't intersect, but we had intersection already, stop search.\n            return false;\n          }\n\n          return true;\n        }\n      });\n      next = targetElement;\n    }\n\n    if (next && (!relatedEvent || relatedEvent && container.dispatchEvent(new TabsterMoveFocusEvent({\n      by: \"mover\",\n      owner: container,\n      next,\n      relatedEvent\n    })))) {\n      if (scrollIntoViewArg !== undefined) {\n        scrollIntoView(this._win, next, scrollIntoViewArg);\n      }\n\n      if (relatedEvent) {\n        relatedEvent.preventDefault();\n        relatedEvent.stopImmediatePropagation();\n      }\n\n      nativeFocus(next);\n      return next;\n    }\n\n    return null;\n  }\n\n  async _isIgnoredInput(element, key) {\n    if (element.getAttribute(\"aria-expanded\") === \"true\" && element.hasAttribute(\"aria-activedescendant\")) {\n      // It is likely a combobox with expanded options and arrow keys are\n      // controlled by it.\n      return true;\n    }\n\n    if (matchesSelector(element, _inputSelector)) {\n      let selectionStart = 0;\n      let selectionEnd = 0;\n      let textLength = 0;\n      let asyncRet;\n\n      if (element.tagName === \"INPUT\" || element.tagName === \"TEXTAREA\") {\n        const type = element.type;\n        const value = element.value;\n        textLength = (value || \"\").length;\n\n        if (type === \"email\" || type === \"number\") {\n          // For these types Chromium doesn't provide selectionStart and selectionEnd.\n          // Hence the ugly workaround to find if the caret position is changed with\n          // the keypress.\n          // TODO: Have a look at range, week, time, time, date, datetime-local.\n          if (textLength) {\n            const selection = dom.getSelection(element);\n\n            if (selection) {\n              const initialLength = selection.toString().length;\n              const isBackward = key === Keys.ArrowLeft || key === Keys.ArrowUp;\n              selection.modify(\"extend\", isBackward ? \"backward\" : \"forward\", \"character\");\n\n              if (initialLength !== selection.toString().length) {\n                // The caret is moved, so, we're not on the edge of the value.\n                // Restore original selection.\n                selection.modify(\"extend\", isBackward ? \"forward\" : \"backward\", \"character\");\n                return true;\n              } else {\n                textLength = 0;\n              }\n            }\n          }\n        } else {\n          const selStart = element.selectionStart;\n\n          if (selStart === null) {\n            // Do not ignore not text editable inputs like checkboxes and radios (but ignore hidden).\n            return type === \"hidden\";\n          }\n\n          selectionStart = selStart || 0;\n          selectionEnd = element.selectionEnd || 0;\n        }\n      } else if (element.contentEditable === \"true\") {\n        asyncRet = new (getPromise(this._win))(resolve => {\n          this._ignoredInputResolve = value => {\n            delete this._ignoredInputResolve;\n            resolve(value);\n          };\n\n          const win = this._win();\n\n          if (this._ignoredInputTimer) {\n            win.clearTimeout(this._ignoredInputTimer);\n          }\n\n          const {\n            anchorNode: prevAnchorNode,\n            focusNode: prevFocusNode,\n            anchorOffset: prevAnchorOffset,\n            focusOffset: prevFocusOffset\n          } = dom.getSelection(element) || {}; // Get selection gives incorrect value if we call it syncronously onKeyDown.\n\n          this._ignoredInputTimer = win.setTimeout(() => {\n            var _a, _b, _c;\n\n            delete this._ignoredInputTimer;\n            const {\n              anchorNode,\n              focusNode,\n              anchorOffset,\n              focusOffset\n            } = dom.getSelection(element) || {};\n\n            if (anchorNode !== prevAnchorNode || focusNode !== prevFocusNode || anchorOffset !== prevAnchorOffset || focusOffset !== prevFocusOffset) {\n              (_a = this._ignoredInputResolve) === null || _a === void 0 ? void 0 : _a.call(this, false);\n              return;\n            }\n\n            selectionStart = anchorOffset || 0;\n            selectionEnd = focusOffset || 0;\n            textLength = ((_b = element.textContent) === null || _b === void 0 ? void 0 : _b.length) || 0;\n\n            if (anchorNode && focusNode) {\n              if (dom.nodeContains(element, anchorNode) && dom.nodeContains(element, focusNode)) {\n                if (anchorNode !== element) {\n                  let anchorFound = false;\n\n                  const addOffsets = node => {\n                    if (node === anchorNode) {\n                      anchorFound = true;\n                    } else if (node === focusNode) {\n                      return true;\n                    }\n\n                    const nodeText = node.textContent;\n\n                    if (nodeText && !dom.getFirstChild(node)) {\n                      const len = nodeText.length;\n\n                      if (anchorFound) {\n                        if (focusNode !== anchorNode) {\n                          selectionEnd += len;\n                        }\n                      } else {\n                        selectionStart += len;\n                        selectionEnd += len;\n                      }\n                    }\n\n                    let stop = false;\n\n                    for (let e = dom.getFirstChild(node); e && !stop; e = e.nextSibling) {\n                      stop = addOffsets(e);\n                    }\n\n                    return stop;\n                  };\n\n                  addOffsets(element);\n                }\n              }\n            }\n\n            (_c = this._ignoredInputResolve) === null || _c === void 0 ? void 0 : _c.call(this, true);\n          }, 0);\n        });\n      }\n\n      if (asyncRet && !(await asyncRet)) {\n        return true;\n      }\n\n      if (selectionStart !== selectionEnd) {\n        return true;\n      }\n\n      if (selectionStart > 0 && (key === Keys.ArrowLeft || key === Keys.ArrowUp || key === Keys.Home)) {\n        return true;\n      }\n\n      if (selectionStart < textLength && (key === Keys.ArrowRight || key === Keys.ArrowDown || key === Keys.End)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction observeMutations(doc, tabster, updateTabsterByAttribute, syncState) {\n  if (typeof MutationObserver === \"undefined\") {\n    return () => {\n      /* Noop */\n    };\n  }\n\n  const getWindow = tabster.getWindow;\n  let elementByUId;\n\n  const onMutation = mutations => {\n    var _a, _b, _c, _d, _e;\n\n    const removedNodes = new Set();\n\n    for (const mutation of mutations) {\n      const target = mutation.target;\n      const removed = mutation.removedNodes;\n      const added = mutation.addedNodes;\n\n      if (mutation.type === \"attributes\") {\n        if (mutation.attributeName === TABSTER_ATTRIBUTE_NAME) {\n          // removedNodes helps to make sure we are not recreating things\n          // for the removed elements.\n          // For some reason, if we do removeChild() and setAttribute() on the\n          // removed child in the same tick, both the child removal and the attribute\n          // change will be present in the mutation records. And the attribute change\n          // will follow the child removal.\n          // So, we remember the removed nodes and ignore attribute changes for them.\n          if (!removedNodes.has(target)) {\n            updateTabsterByAttribute(tabster, target);\n          }\n        }\n      } else {\n        for (let i = 0; i < removed.length; i++) {\n          const removedNode = removed[i];\n          removedNodes.add(removedNode);\n          updateTabsterElements(removedNode, true);\n          (_b = (_a = tabster._dummyObserver).domChanged) === null || _b === void 0 ? void 0 : _b.call(_a, target);\n        }\n\n        for (let i = 0; i < added.length; i++) {\n          updateTabsterElements(added[i]);\n          (_d = (_c = tabster._dummyObserver).domChanged) === null || _d === void 0 ? void 0 : _d.call(_c, target);\n        }\n      }\n    }\n\n    removedNodes.clear();\n    (_e = tabster.modalizer) === null || _e === void 0 ? void 0 : _e.hiddenUpdate();\n  };\n\n  function updateTabsterElements(node, removed) {\n    if (!elementByUId) {\n      elementByUId = getInstanceContext(getWindow).elementByUId;\n    }\n\n    processNode(node, removed);\n    const walker = createElementTreeWalker(doc, node, element => {\n      return processNode(element, removed);\n    });\n\n    if (walker) {\n      while (walker.nextNode()) {\n        /* Iterating for the sake of calling processNode() callback. */\n      }\n    }\n  }\n\n  function processNode(element, removed) {\n    var _a;\n\n    if (!element.getAttribute) {\n      // It might actually be a text node.\n      return NodeFilter.FILTER_SKIP;\n    }\n\n    const uid = element.__tabsterElementUID;\n\n    if (uid && elementByUId) {\n      if (removed) {\n        delete elementByUId[uid];\n      } else {\n        (_a = elementByUId[uid]) !== null && _a !== void 0 ? _a : elementByUId[uid] = new WeakHTMLElement(getWindow, element);\n      }\n    }\n\n    if (getTabsterOnElement(tabster, element) || element.hasAttribute(TABSTER_ATTRIBUTE_NAME)) {\n      updateTabsterByAttribute(tabster, element, removed);\n    }\n\n    return NodeFilter.FILTER_SKIP;\n  }\n\n  const observer = dom.createMutationObserver(onMutation);\n\n  if (syncState) {\n    updateTabsterElements(getWindow().document.body);\n  }\n\n  observer.observe(doc, {\n    childList: true,\n    subtree: true,\n    attributes: true,\n    attributeFilter: [TABSTER_ATTRIBUTE_NAME]\n  });\n  return () => {\n    observer.disconnect();\n  };\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst _conditionCheckTimeout = 100;\nclass ObservedElementAPI extends Subscribable {\n  constructor(tabster) {\n    super();\n    this._waiting = {};\n    this._lastRequestFocusId = 0;\n    this._observedById = {};\n    this._observedByName = {};\n    this._currentRequestTimestamp = 0;\n\n    this._onFocus = e => {\n      if (e) {\n        const current = this._currentRequest;\n\n        if (current) {\n          const delta = Date.now() - this._currentRequestTimestamp;\n\n          const settleTime = 300;\n\n          if (delta >= settleTime) {\n            // Giving some time for the focus to settle before\n            // automatically cancelling the current request on focus change.\n            delete this._currentRequest;\n            current.cancel();\n          }\n        }\n      }\n    };\n\n    this.onObservedElementUpdate = element => {\n      var _a;\n\n      const observed = (_a = getTabsterOnElement(this._tabster, element)) === null || _a === void 0 ? void 0 : _a.observed;\n      const uid = getElementUId(this._win, element);\n      let info = this._observedById[uid];\n\n      if (observed && documentContains(element.ownerDocument, element)) {\n        if (!info) {\n          info = this._observedById[uid] = {\n            element: new WeakHTMLElement(this._win, element)\n          };\n        }\n\n        observed.names.sort();\n        const observedNames = observed.names;\n        const prevNames = info.prevNames; // prevNames are already sorted\n\n        if (this._isObservedNamesUpdated(observedNames, prevNames)) {\n          if (prevNames) {\n            prevNames.forEach(prevName => {\n              const obn = this._observedByName[prevName];\n\n              if (obn && obn[uid]) {\n                if (Object.keys(obn).length > 1) {\n                  delete obn[uid];\n                } else {\n                  delete this._observedByName[prevName];\n                }\n              }\n            });\n          }\n\n          info.prevNames = observedNames;\n        }\n\n        observedNames.forEach(observedName => {\n          let obn = this._observedByName[observedName];\n\n          if (!obn) {\n            obn = this._observedByName[observedName] = {};\n          } // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n\n\n          obn[uid] = info;\n\n          this._waitConditional(observedName);\n        });\n      } else if (info) {\n        const prevNames = info.prevNames;\n\n        if (prevNames) {\n          prevNames.forEach(prevName => {\n            const obn = this._observedByName[prevName];\n\n            if (obn && obn[uid]) {\n              if (Object.keys(obn).length > 1) {\n                delete obn[uid];\n              } else {\n                delete this._observedByName[prevName];\n              }\n            }\n          });\n        }\n\n        delete this._observedById[uid];\n      }\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    tabster.queueInit(() => {\n      this._tabster.focusedElement.subscribe(this._onFocus);\n    });\n  }\n\n  dispose() {\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    for (const key of Object.keys(this._waiting)) {\n      this._rejectWaiting(key);\n    }\n\n    this._observedById = {};\n    this._observedByName = {};\n  }\n\n  _rejectWaiting(key, shouldResolve) {\n    const w = this._waiting[key];\n\n    if (w) {\n      const win = this._win();\n\n      if (w.timer) {\n        win.clearTimeout(w.timer);\n      }\n\n      if (w.conditionTimer) {\n        win.clearTimeout(w.conditionTimer);\n      }\n\n      if (!shouldResolve && w.reject) {\n        w.reject();\n      } else if (shouldResolve && w.resolve) {\n        w.resolve(null);\n      }\n\n      delete this._waiting[key];\n    }\n  }\n\n  _isObservedNamesUpdated(cur, prev) {\n    if (!prev || cur.length !== prev.length) {\n      return true;\n    }\n\n    for (let i = 0; i < cur.length; ++i) {\n      if (cur[i] !== prev[i]) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n  /**\r\n   * Returns existing element by observed name\r\n   *\r\n   * @param observedName An observed name\r\n   * @param accessibility Optionally, return only if the element is accessible or focusable\r\n   * @returns HTMLElement | null\r\n   */\n\n\n  getElement(observedName, accessibility) {\n    const o = this._observedByName[observedName];\n\n    if (o) {\n      for (const uid of Object.keys(o)) {\n        let el = o[uid].element.get() || null;\n\n        if (el) {\n          if (accessibility === ObservedElementAccessibilities.Accessible && !this._tabster.focusable.isAccessible(el) || accessibility === ObservedElementAccessibilities.Focusable && !this._tabster.focusable.isFocusable(el, true)) {\n            el = null;\n          }\n        } else {\n          delete o[uid];\n          delete this._observedById[uid];\n        }\n\n        return el;\n      }\n    }\n\n    return null;\n  }\n  /**\r\n   * Waits for the element to appear in the DOM and returns it.\r\n   *\r\n   * @param observedName An observed name\r\n   * @param timeout Wait no longer than this timeout\r\n   * @param accessibility Optionally, wait for the element to also become accessible or focusable before returning it\r\n   * @returns Promise<HTMLElement | null>\r\n   */\n\n\n  waitElement(observedName, timeout, accessibility) {\n    const el = this.getElement(observedName, accessibility);\n\n    if (el) {\n      return {\n        result: getPromise(this._win).resolve(el),\n        cancel: () => {\n          /**/\n        }\n      };\n    }\n\n    let prefix;\n\n    if (accessibility === ObservedElementAccessibilities.Accessible) {\n      prefix = \"a\";\n    } else if (accessibility === ObservedElementAccessibilities.Focusable) {\n      prefix = \"f\";\n    } else {\n      prefix = \"_\";\n    }\n\n    const key = prefix + observedName;\n    let w = this._waiting[key];\n\n    if (w && w.request) {\n      return w.request;\n    }\n\n    w = this._waiting[key] = {\n      timer: this._win().setTimeout(() => {\n        if (w.conditionTimer) {\n          this._win().clearTimeout(w.conditionTimer);\n        }\n\n        delete this._waiting[key];\n\n        if (w.resolve) {\n          w.resolve(null);\n        }\n      }, timeout)\n    };\n    const promise = new (getPromise(this._win))((resolve, reject) => {\n      w.resolve = resolve;\n      w.reject = reject;\n    });\n    w.request = {\n      result: promise,\n      cancel: () => {\n        this._rejectWaiting(key, true);\n      }\n    };\n\n    if (accessibility && this.getElement(observedName)) {\n      // If the observed element is alread in DOM, but not accessible yet,\n      // we need to run the wait logic.\n      this._waitConditional(observedName);\n    }\n\n    return w.request;\n  }\n\n  requestFocus(observedName, timeout, options) {\n    if (options === void 0) {\n      options = {};\n    }\n\n    const requestId = ++this._lastRequestFocusId;\n    const currentRequestFocus = this._currentRequest;\n\n    if (currentRequestFocus) {\n      currentRequestFocus.cancel();\n    }\n\n    const request = this.waitElement(observedName, timeout, ObservedElementAccessibilities.Focusable);\n    this._currentRequest = request;\n    this._currentRequestTimestamp = Date.now();\n    request.result.finally(() => {\n      if (this._currentRequest === request) {\n        delete this._currentRequest;\n      }\n    });\n    return {\n      result: request.result.then(element => this._lastRequestFocusId === requestId && element ? this._tabster.focusedElement.focus(element, true, undefined, options.preventScroll) : false),\n      cancel: () => {\n        request.cancel();\n      }\n    };\n  }\n\n  _waitConditional(observedName) {\n    const waitingElementKey = \"_\" + observedName;\n    const waitingAccessibleElementKey = \"a\" + observedName;\n    const waitingFocusableElementKey = \"f\" + observedName;\n    const waitingElement = this._waiting[waitingElementKey];\n    const waitingAccessibleElement = this._waiting[waitingAccessibleElementKey];\n    const waitingFocusableElement = this._waiting[waitingFocusableElementKey];\n\n    const win = this._win();\n\n    const resolve = (element, key, waiting, accessibility) => {\n      var _a;\n\n      const observed = (_a = getTabsterOnElement(this._tabster, element)) === null || _a === void 0 ? void 0 : _a.observed;\n\n      if (!observed || !observed.names.includes(observedName)) {\n        return;\n      }\n\n      if (waiting.timer) {\n        win.clearTimeout(waiting.timer);\n      }\n\n      delete this._waiting[key];\n\n      if (waiting.resolve) {\n        waiting.resolve(element);\n      }\n\n      this.trigger(element, {\n        names: [observedName],\n        details: observed.details,\n        accessibility\n      });\n    };\n\n    if (waitingElement) {\n      const element = this.getElement(observedName);\n\n      if (element && documentContains(element.ownerDocument, element)) {\n        resolve(element, waitingElementKey, waitingElement, ObservedElementAccessibilities.Any);\n      }\n    }\n\n    if (waitingAccessibleElement && !waitingAccessibleElement.conditionTimer) {\n      const resolveAccessible = () => {\n        const element = this.getElement(observedName);\n\n        if (element && documentContains(element.ownerDocument, element) && this._tabster.focusable.isAccessible(element)) {\n          resolve(element, waitingAccessibleElementKey, waitingAccessibleElement, ObservedElementAccessibilities.Accessible);\n        } else {\n          waitingAccessibleElement.conditionTimer = win.setTimeout(resolveAccessible, _conditionCheckTimeout);\n        }\n      };\n\n      resolveAccessible();\n    }\n\n    if (waitingFocusableElement && !waitingFocusableElement.conditionTimer) {\n      const resolveFocusable = () => {\n        const element = this.getElement(observedName);\n\n        if (element && documentContains(element.ownerDocument, element) && this._tabster.focusable.isFocusable(element, true)) {\n          resolve(element, waitingFocusableElementKey, waitingFocusableElement, ObservedElementAccessibilities.Focusable);\n        } else {\n          waitingFocusableElement.conditionTimer = win.setTimeout(resolveFocusable, _conditionCheckTimeout);\n        }\n      };\n\n      resolveFocusable();\n    }\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nconst defaultProps = {\n  areaClass: \"tabster-focus-outline-area\",\n  outlineClass: \"tabster-focus-outline\",\n  outlineColor: \"#ff4500\",\n  outlineWidth: 2,\n  zIndex: 2147483647\n};\nlet _props = defaultProps;\n\nclass OutlinePosition {\n  constructor(left, top, right, bottom) {\n    this.left = left;\n    this.top = top;\n    this.right = right;\n    this.bottom = bottom;\n  }\n\n  equalsTo(other) {\n    return this.left === other.left && this.top === other.top && this.right === other.right && this.bottom === other.bottom;\n  }\n\n  clone() {\n    return new OutlinePosition(this.left, this.top, this.right, this.bottom);\n  }\n\n}\n\nclass OutlineAPI {\n  constructor(tabster) {\n    this._isVisible = false;\n    this._allOutlineElements = [];\n\n    this._init = () => {\n      this._tabster.keyboardNavigation.subscribe(this._onKeyboardNavigationStateChanged);\n\n      this._tabster.focusedElement.subscribe(this._onFocus);\n\n      const win = this._win();\n\n      win.addEventListener(\"scroll\", this._onScroll, true); // Capture!\n\n      if (this._fullScreenEventName) {\n        win.document.addEventListener(this._fullScreenEventName, this._onFullScreenChanged);\n      }\n    };\n\n    this._onFullScreenChanged = e => {\n      if (!this._fullScreenElementName || !e.target) {\n        return;\n      }\n\n      const target = e.target.body || e.target;\n\n      const outlineElements = this._getDOM(target);\n\n      if (target.ownerDocument && outlineElements) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        const fsElement = target.ownerDocument[this._fullScreenElementName];\n\n        if (fsElement) {\n          fsElement.appendChild(outlineElements.container);\n          this._fullScreenElement = fsElement;\n        } else {\n          target.ownerDocument.body.appendChild(outlineElements.container);\n          this._fullScreenElement = undefined;\n        }\n      }\n    };\n\n    this._onKeyboardNavigationStateChanged = () => {\n      this._onFocus(this._tabster.focusedElement.getFocusedElement());\n    };\n\n    this._onFocus = e => {\n      if (!this._updateElement(e) && this._isVisible) {\n        this._setVisibility(false);\n      }\n    };\n\n    this._onScroll = e => {\n      if (!this._outlinedElement || !OutlineAPI._isParentChild(e.target, this._outlinedElement)) {\n        return;\n      }\n\n      this._curPos = undefined;\n\n      this._setOutlinePosition();\n    };\n\n    this._tabster = tabster;\n    this._win = tabster.getWindow;\n    tabster.queueInit(this._init);\n\n    if (typeof document !== \"undefined\") {\n      if (\"onfullscreenchange\" in document) {\n        this._fullScreenEventName = \"fullscreenchange\";\n        this._fullScreenElementName = \"fullscreenElement\";\n      } else if (\"onwebkitfullscreenchange\" in document) {\n        this._fullScreenEventName = \"webkitfullscreenchange\";\n        this._fullScreenElementName = \"webkitFullscreenElement\";\n      } else if (\"onmozfullscreenchange\" in document) {\n        this._fullScreenEventName = \"mozfullscreenchange\";\n        this._fullScreenElementName = \"mozFullScreenElement\";\n      } else if (\"onmsfullscreenchange\" in document) {\n        this._fullScreenEventName = \"msfullscreenchange\";\n        this._fullScreenElementName = \"msFullscreenElement\";\n      }\n    }\n  }\n\n  setup(props) {\n    _props = { ..._props,\n      ...props\n    };\n\n    const win = this._win();\n\n    if (!win.__tabsterOutline) {\n      win.__tabsterOutline = {};\n    }\n\n    if (!win.__tabsterOutline.style) {\n      win.__tabsterOutline.style = appendStyles(win.document, _props);\n    }\n\n    if (!props || !props.areaClass) {\n      win.document.body.classList.add(defaultProps.areaClass);\n    } else {\n      win.document.body.classList.remove(defaultProps.areaClass);\n    }\n  }\n\n  dispose() {\n    const win = this._win();\n\n    if (this._updateTimer) {\n      win.clearTimeout(this._updateTimer);\n      this._updateTimer = undefined;\n    }\n\n    this._tabster.keyboardNavigation.unsubscribe(this._onKeyboardNavigationStateChanged);\n\n    this._tabster.focusedElement.unsubscribe(this._onFocus);\n\n    win.removeEventListener(\"scroll\", this._onScroll, true);\n\n    if (this._fullScreenEventName) {\n      win.document.removeEventListener(this._fullScreenEventName, this._onFullScreenChanged);\n    }\n\n    this._allOutlineElements.forEach(outlineElements => this._removeDOM(outlineElements.container));\n\n    this._allOutlineElements = [];\n    delete this._outlinedElement;\n    delete this._curPos;\n    delete this._curOutlineElements;\n    delete this._fullScreenElement;\n  }\n\n  _shouldShowCustomOutline(element) {\n    const tabsterOnElement = getTabsterOnElement(this._tabster, element);\n\n    if (tabsterOnElement && tabsterOnElement.outline && tabsterOnElement.outline.isIgnored) {\n      return false;\n    }\n\n    for (let i = element; i; i = i.parentElement) {\n      if (i.classList && i.classList.contains(_props.areaClass)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  _updateElement(e) {\n    this._outlinedElement = undefined;\n\n    if (this._updateTimer) {\n      this._win().clearTimeout(this._updateTimer);\n\n      this._updateTimer = undefined;\n    }\n\n    this._curPos = undefined;\n\n    if (!this._tabster.keyboardNavigation.isNavigatingWithKeyboard()) {\n      return false;\n    }\n\n    if (e) {\n      // TODO: It's hard (and not necessary) to come up with every possible\n      // condition when there should be no outline, it's better to add an\n      // API to customize the ignores.\n      if (e.tagName === \"INPUT\") {\n        const inputType = e.type;\n        const outlinedInputTypes = {\n          button: true,\n          checkbox: true,\n          file: true,\n          image: true,\n          radio: true,\n          range: true,\n          reset: true,\n          submit: true\n        };\n\n        if (!(inputType in outlinedInputTypes)) {\n          return false;\n        }\n      } else if (e.tagName === \"TEXTAREA\" || e.contentEditable === \"true\" || e.tagName === \"IFRAME\") {\n        return false;\n      }\n\n      if (!this._shouldShowCustomOutline(e)) {\n        return false;\n      }\n\n      if (this._tabster.keyboardNavigation.isNavigatingWithKeyboard()) {\n        this._outlinedElement = e;\n\n        this._updateOutline();\n      }\n\n      return true;\n    }\n\n    return false;\n  }\n\n  _updateOutline() {\n    this._setOutlinePosition();\n\n    if (this._updateTimer) {\n      this._win().clearTimeout(this._updateTimer);\n\n      this._updateTimer = undefined;\n    }\n\n    if (!this._outlinedElement) {\n      return;\n    }\n\n    this._updateTimer = this._win().setTimeout(() => {\n      this._updateTimer = undefined;\n\n      this._updateOutline();\n    }, 30);\n  }\n\n  _setVisibility(visible) {\n    this._isVisible = visible;\n\n    if (this._curOutlineElements) {\n      if (visible) {\n        this._curOutlineElements.container.classList.add(`${_props.outlineClass}_visible`);\n      } else {\n        this._curOutlineElements.container.classList.remove(`${_props.outlineClass}_visible`);\n\n        this._curPos = undefined;\n      }\n    }\n  }\n\n  _setOutlinePosition() {\n    if (!this._outlinedElement) {\n      return;\n    }\n\n    let boundingRect = getBoundingRect(this._win, this._outlinedElement);\n    const position = new OutlinePosition(boundingRect.left, boundingRect.top, boundingRect.right, boundingRect.bottom);\n\n    if (this._curPos && position.equalsTo(this._curPos)) {\n      return;\n    }\n\n    const outlineElements = this._getDOM(this._outlinedElement);\n\n    const win = this._outlinedElement.ownerDocument && this._outlinedElement.ownerDocument.defaultView;\n\n    if (!outlineElements || !win) {\n      return;\n    }\n\n    if (this._curOutlineElements !== outlineElements) {\n      this._setVisibility(false);\n\n      this._curOutlineElements = outlineElements;\n    }\n\n    this._curPos = position;\n    const p = position.clone();\n    let hasAbsolutePositionedParent = false;\n    let hasFixedPositionedParent = false;\n    const container = outlineElements.container;\n    const scrollingElement = container && container.ownerDocument && container.ownerDocument.scrollingElement;\n\n    if (!scrollingElement) {\n      return;\n    }\n\n    for (let parent = this._outlinedElement.parentElement; parent && parent.nodeType === Node.ELEMENT_NODE; parent = parent.parentElement) {\n      // The element might be partially visible within its scrollable parent,\n      // reduce the bounding rect if this is the case.\n      if (parent === this._fullScreenElement) {\n        break;\n      }\n\n      boundingRect = getBoundingRect(this._win, parent);\n      const win = parent.ownerDocument && parent.ownerDocument.defaultView;\n\n      if (!win) {\n        return;\n      }\n\n      const computedStyle = win.getComputedStyle(parent);\n      const position = computedStyle.position;\n\n      if (position === \"absolute\") {\n        hasAbsolutePositionedParent = true;\n      } else if (position === \"fixed\" || position === \"sticky\") {\n        hasFixedPositionedParent = true;\n      }\n\n      if (computedStyle.overflow === \"visible\") {\n        continue;\n      }\n\n      if (!hasAbsolutePositionedParent && !hasFixedPositionedParent || computedStyle.overflow === \"hidden\") {\n        if (boundingRect.left > p.left) {\n          p.left = boundingRect.left;\n        }\n\n        if (boundingRect.top > p.top) {\n          p.top = boundingRect.top;\n        }\n\n        if (boundingRect.right < p.right) {\n          p.right = boundingRect.right;\n        }\n\n        if (boundingRect.bottom < p.bottom) {\n          p.bottom = boundingRect.bottom;\n        }\n      }\n    }\n\n    const allRect = getBoundingRect(this._win, scrollingElement);\n    const allWidth = allRect.left + allRect.right;\n    const allHeight = allRect.top + allRect.bottom;\n    const ow = _props.outlineWidth;\n    p.left = p.left > ow ? p.left - ow : 0;\n    p.top = p.top > ow ? p.top - ow : 0;\n    p.right = p.right < allWidth - ow ? p.right + ow : allWidth;\n    p.bottom = p.bottom < allHeight - ow ? p.bottom + ow : allHeight;\n    const width = p.right - p.left;\n    const height = p.bottom - p.top;\n\n    if (width > ow * 2 && height > ow * 2) {\n      const leftBorderNode = outlineElements.left;\n      const topBorderNode = outlineElements.top;\n      const rightBorderNode = outlineElements.right;\n      const bottomBorderNode = outlineElements.bottom;\n      const sx = this._fullScreenElement || hasFixedPositionedParent ? 0 : win.pageXOffset;\n      const sy = this._fullScreenElement || hasFixedPositionedParent ? 0 : win.pageYOffset;\n      container.style.position = hasFixedPositionedParent ? \"fixed\" : \"absolute\";\n      container.style.background = _props.outlineColor;\n      leftBorderNode.style.width = rightBorderNode.style.width = topBorderNode.style.height = bottomBorderNode.style.height = _props.outlineWidth + \"px\";\n      leftBorderNode.style.left = topBorderNode.style.left = bottomBorderNode.style.left = p.left + sx + \"px\";\n      rightBorderNode.style.left = p.left + sx + width - ow + \"px\";\n      leftBorderNode.style.top = rightBorderNode.style.top = topBorderNode.style.top = p.top + sy + \"px\";\n      bottomBorderNode.style.top = p.top + sy + height - ow + \"px\";\n      leftBorderNode.style.height = rightBorderNode.style.height = height + \"px\";\n      topBorderNode.style.width = bottomBorderNode.style.width = width + \"px\";\n\n      this._setVisibility(true);\n    } else {\n      this._setVisibility(false);\n    }\n  }\n\n  _getDOM(contextElement) {\n    const doc = contextElement.ownerDocument;\n    const win = doc && doc.defaultView;\n\n    if (!doc || !win || !win.__tabsterOutline) {\n      return undefined;\n    }\n\n    if (!win.__tabsterOutline.style) {\n      win.__tabsterOutline.style = appendStyles(doc, _props);\n    }\n\n    if (!win.__tabsterOutline.elements) {\n      const outlineElements = {\n        container: doc.createElement(\"div\"),\n        left: doc.createElement(\"div\"),\n        top: doc.createElement(\"div\"),\n        right: doc.createElement(\"div\"),\n        bottom: doc.createElement(\"div\")\n      };\n      outlineElements.container.className = _props.outlineClass;\n      outlineElements.left.className = `${_props.outlineClass}__left`;\n      outlineElements.top.className = `${_props.outlineClass}__top`;\n      outlineElements.right.className = `${_props.outlineClass}__right`;\n      outlineElements.bottom.className = `${_props.outlineClass}__bottom`;\n      outlineElements.container.appendChild(outlineElements.left);\n      outlineElements.container.appendChild(outlineElements.top);\n      outlineElements.container.appendChild(outlineElements.right);\n      outlineElements.container.appendChild(outlineElements.bottom);\n      doc.body.appendChild(outlineElements.container);\n      win.__tabsterOutline.elements = outlineElements; // TODO: Make a garbage collector to remove the references\n      // to the outlines which are nowhere in the DOM anymore.\n\n      this._allOutlineElements.push(outlineElements);\n    }\n\n    return win.__tabsterOutline.elements;\n  }\n\n  _removeDOM(contextElement) {\n    const win = contextElement.ownerDocument && contextElement.ownerDocument.defaultView;\n    const outline = win && win.__tabsterOutline;\n\n    if (!outline) {\n      return;\n    }\n\n    if (outline.style && outline.style.parentNode) {\n      outline.style.parentNode.removeChild(outline.style);\n      delete outline.style;\n    }\n\n    const outlineElements = outline && outline.elements;\n\n    if (outlineElements) {\n      if (outlineElements.container.parentNode) {\n        outlineElements.container.parentNode.removeChild(outlineElements.container);\n      }\n\n      delete outline.elements;\n    }\n  }\n\n  static _isParentChild(parent, child) {\n    return child === parent || // tslint:disable-next-line:no-bitwise\n    !!(parent.compareDocumentPosition(child) & document.DOCUMENT_POSITION_CONTAINED_BY);\n  }\n\n}\n\nfunction appendStyles(document, props) {\n  const style = document.createElement(\"style\");\n  style.type = \"text/css\";\n  style.appendChild(document.createTextNode(getOutlineStyles(props)));\n  document.head.appendChild(style);\n  return style;\n}\n\nfunction getOutlineStyles(props) {\n  return `\n.${props.areaClass} *, .${props.areaClass} *:focus {\noutline: none !important;\n}\n\n.${props.outlineClass} {\ndisplay: none;\nposition: absolute;\nwidth: 0;\nheight: 0;\nleft: 0;\ntop: 0;\nz-index: ${props.zIndex};\n}\n\n.${props.outlineClass}.${props.outlineClass}_visible {\ndisplay: block;\n}\n\n.${props.outlineClass}__left,\n.${props.outlineClass}__top,\n.${props.outlineClass}__right,\n.${props.outlineClass}__bottom {\nposition: absolute;\nbackground: inherit;\n}`;\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\n/**\r\n * Allows default or user focus behaviour on the DOM subtree\r\n * i.e. Tabster will not control focus events within an uncontrolled area\r\n */\nclass UncontrolledAPI {\n  constructor(isUncontrolledCompletely) {\n    this._isUncontrolledCompletely = isUncontrolledCompletely;\n  }\n\n  isUncontrolledCompletely(element, completely) {\n    var _a;\n\n    const isUncontrolledCompletely = (_a = this._isUncontrolledCompletely) === null || _a === void 0 ? void 0 : _a.call(this, element, completely); // If isUncontrolledCompletely callback is not defined or returns undefined, then the default\n    // behaviour is to return the uncontrolled.completely value from the element.\n\n    return isUncontrolledCompletely === undefined ? completely : isUncontrolledCompletely;\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nclass Restorer extends TabsterPart {\n  constructor(tabster, element, props) {\n    var _a;\n\n    super(tabster, element, props);\n    this._hasFocus = false;\n\n    this._onFocusOut = e => {\n      var _a;\n\n      const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n\n      if (element && e.relatedTarget === null) {\n        element.dispatchEvent(new RestorerRestoreFocusEvent());\n      }\n\n      if (element && !dom.nodeContains(element, e.relatedTarget)) {\n        this._hasFocus = false;\n      }\n    };\n\n    this._onFocusIn = () => {\n      this._hasFocus = true;\n    };\n\n    if (this._props.type === RestorerTypes.Source) {\n      const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n      element === null || element === void 0 ? void 0 : element.addEventListener(\"focusout\", this._onFocusOut);\n      element === null || element === void 0 ? void 0 : element.addEventListener(\"focusin\", this._onFocusIn); // set hasFocus when the instance is created, in case focus has already moved within it\n\n      this._hasFocus = dom.nodeContains(element, element && dom.getActiveElement(element.ownerDocument));\n    }\n  }\n\n  dispose() {\n    var _a;\n\n    if (this._props.type === RestorerTypes.Source) {\n      const element = (_a = this._element) === null || _a === void 0 ? void 0 : _a.get();\n      element === null || element === void 0 ? void 0 : element.removeEventListener(\"focusout\", this._onFocusOut);\n      element === null || element === void 0 ? void 0 : element.removeEventListener(\"focusin\", this._onFocusIn);\n\n      if (this._hasFocus) {\n        const doc = this._tabster.getWindow().document;\n\n        doc.body.dispatchEvent(new RestorerRestoreFocusEvent());\n      }\n    }\n  }\n\n}\n\nclass History {\n  constructor(getWindow) {\n    this._stack = [];\n    this._getWindow = getWindow;\n  }\n  /**\r\n   * Push a weak element to the top of the history stack.\r\n   * If the stack is full, the bottom weak element is removed.\r\n   * If the element is already at the top of the stack, it is not duplicated.\r\n   */\n\n\n  push(element) {\n    var _a; // Don't duplicate the top of history\n\n\n    if (((_a = this._stack[this._stack.length - 1]) === null || _a === void 0 ? void 0 : _a.get()) === element) {\n      return;\n    }\n\n    if (this._stack.length > History.DEPTH) {\n      this._stack.shift();\n    }\n\n    this._stack.push(new WeakHTMLElement(this._getWindow, element));\n  }\n  /**\r\n   * Pop the first element from the history that satisfies the callback.\r\n   * The history is searched from the top to the bottom (from the most recent to the least recent).\r\n   *\r\n   * If a weak reference to the element is broken,\r\n   * or the element is no longer in the DOM,\r\n   * the element is removed from the top of the stack while popping.\r\n   *\r\n   * If no matching element is found, undefined is returned.\r\n   * If the stack is empty, undefined is returned.\r\n   */\n\n\n  pop(filter) {\n    if (filter === void 0) {\n      filter = () => true;\n    }\n\n    var _a;\n\n    const doc = this._getWindow().document;\n\n    for (let index = this._stack.length - 1; index >= 0; index--) {\n      const maybeElement = (_a = this._stack.pop()) === null || _a === void 0 ? void 0 : _a.get();\n\n      if (maybeElement && dom.nodeContains(doc.body, dom.getParentElement(maybeElement)) && filter(maybeElement)) {\n        return maybeElement;\n      }\n    }\n\n    return undefined;\n  }\n\n}\n\nHistory.DEPTH = 10;\nclass RestorerAPI {\n  constructor(tabster) {\n    this._onRestoreFocus = e => {\n      var _a, _b;\n\n      this._focusedElementState.cancelAsyncFocus(AsyncFocusSources.Restorer); // ShadowDOM will have shadowRoot as e.target.\n\n\n      const source = e.composedPath()[0];\n\n      if (source) {\n        // source id must be recovered before source is removed from DOM\n        // otherwise it'll be unreachable\n        // (as tabster on element will not be available through getTabsterOnElement)\n        const sourceId = (_b = (_a = getTabsterOnElement(this._tabster, source)) === null || _a === void 0 ? void 0 : _a.restorer) === null || _b === void 0 ? void 0 : _b.getProps().id;\n\n        this._focusedElementState.requestAsyncFocus(AsyncFocusSources.Restorer, () => this._restoreFocus(source, sourceId), 0);\n      }\n    };\n\n    this._onFocusIn = element => {\n      var _a;\n\n      if (!element) {\n        return;\n      }\n\n      const tabsterAttribute = getTabsterOnElement(this._tabster, element);\n\n      if (((_a = tabsterAttribute === null || tabsterAttribute === void 0 ? void 0 : tabsterAttribute.restorer) === null || _a === void 0 ? void 0 : _a.getProps().type) !== RestorerTypes.Target) {\n        return;\n      }\n\n      this._history.push(element);\n    };\n\n    this._restoreFocus = (source, sourceId) => {\n      var _a; // don't restore focus if focus isn't lost to body\n\n\n      const doc = this._getWindow().document;\n\n      if (dom.getActiveElement(doc) !== doc.body) {\n        return;\n      }\n\n      if ( // clicking on any empty space focuses body - this is can be a false positive\n      !this._keyboardNavState.isNavigatingWithKeyboard() && // Source no longer exists on DOM - always restore focus\n      dom.nodeContains(doc.body, source)) {\n        return;\n      }\n\n      const getId = element => {\n        var _a, _b;\n\n        return (_b = (_a = getTabsterOnElement(this._tabster, element)) === null || _a === void 0 ? void 0 : _a.restorer) === null || _b === void 0 ? void 0 : _b.getProps().id;\n      };\n\n      (_a = this._history.pop(target => sourceId === getId(target))) === null || _a === void 0 ? void 0 : _a.focus();\n    };\n\n    this._tabster = tabster;\n    this._getWindow = tabster.getWindow;\n\n    this._getWindow().addEventListener(RestorerRestoreFocusEventName, this._onRestoreFocus);\n\n    this._history = new History(this._getWindow);\n    this._keyboardNavState = tabster.keyboardNavigation;\n    this._focusedElementState = tabster.focusedElement;\n\n    this._focusedElementState.subscribe(this._onFocusIn);\n  }\n\n  dispose() {\n    const win = this._getWindow();\n\n    this._focusedElementState.unsubscribe(this._onFocusIn);\n\n    this._focusedElementState.cancelAsyncFocus(AsyncFocusSources.Restorer);\n\n    win.removeEventListener(RestorerRestoreFocusEventName, this._onRestoreFocus);\n  }\n\n  createRestorer(element, props) {\n    const restorer = new Restorer(this._tabster, element, props); // Focus might already be on a restorer target when it gets created so the focusin will not do anything\n\n    if (props.type === RestorerTypes.Target && dom.getActiveElement(element.ownerDocument) === element) {\n      this._history.push(element);\n    }\n\n    return restorer;\n  }\n\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction getActiveElement(doc) {\n  var _a;\n\n  let activeElement = doc.activeElement;\n\n  while ((_a = activeElement === null || activeElement === void 0 ? void 0 : activeElement.shadowRoot) === null || _a === void 0 ? void 0 : _a.activeElement) {\n    activeElement = activeElement.shadowRoot.activeElement;\n  }\n\n  return activeElement;\n}\nfunction nodeContains(node, otherNode) {\n  var _a, _b;\n\n  if (!node || !otherNode) {\n    return false;\n  }\n\n  let currentNode = otherNode;\n\n  while (currentNode) {\n    if (currentNode === node) {\n      return true;\n    }\n\n    if (typeof currentNode.assignedElements !== \"function\" && ((_a = currentNode.assignedSlot) === null || _a === void 0 ? void 0 : _a.parentNode)) {\n      // Element is slotted\n      currentNode = (_b = currentNode.assignedSlot) === null || _b === void 0 ? void 0 : _b.parentNode;\n    } else if (currentNode.nodeType === document.DOCUMENT_FRAGMENT_NODE) {\n      // Element is in shadow root\n      currentNode = currentNode.host;\n    } else {\n      currentNode = currentNode.parentNode;\n    }\n  }\n\n  return false;\n}\nfunction getParentNode(node) {\n  if (!node) {\n    return null;\n  }\n\n  if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE && node.host) {\n    return node.host;\n  }\n\n  return node.parentNode;\n}\nfunction getParentElement(element) {\n  for (let parentNode = getParentNode(element); parentNode; parentNode = getParentNode(parentNode)) {\n    if (parentNode.nodeType === Node.ELEMENT_NODE) {\n      return parentNode;\n    }\n  }\n\n  return null;\n}\nfunction getFirstChild(node) {\n  if (!node) {\n    return null;\n  }\n\n  if (node.shadowRoot) {\n    const child = getFirstChild(node.shadowRoot);\n\n    if (child) {\n      return child;\n    } // If the attached shadowRoot has no children, just try ordinary children,\n    // that might come after.\n\n  }\n\n  return node.firstChild;\n}\nfunction getLastChild$1(node) {\n  if (!node) {\n    return null;\n  }\n\n  if (!node.lastChild && node.shadowRoot) {\n    return getLastChild$1(node.shadowRoot);\n  }\n\n  return node.lastChild;\n}\nfunction getNextSibling(node) {\n  return (node === null || node === void 0 ? void 0 : node.nextSibling) || null;\n}\nfunction getPreviousSibling(node) {\n  var _a;\n\n  if (!node) {\n    return null;\n  }\n\n  let sibling = node.previousSibling;\n\n  if (!sibling && ((_a = node.parentElement) === null || _a === void 0 ? void 0 : _a.shadowRoot)) {\n    sibling = getLastChild$1(node.parentElement.shadowRoot);\n  }\n\n  return sibling;\n}\nfunction getFirstElementChild(element) {\n  let child = getFirstChild(element);\n\n  while (child && child.nodeType !== Node.ELEMENT_NODE) {\n    child = getNextSibling(child);\n  }\n\n  return child;\n}\nfunction getLastElementChild(element) {\n  let child = getLastChild$1(element);\n\n  while (child && child.nodeType !== Node.ELEMENT_NODE) {\n    child = getPreviousSibling(child);\n  }\n\n  return child;\n}\nfunction getNextElementSibling(element) {\n  let sibling = getNextSibling(element);\n\n  while (sibling && sibling.nodeType !== Node.ELEMENT_NODE) {\n    sibling = getNextSibling(sibling);\n  }\n\n  return sibling;\n}\nfunction getPreviousElementSibling(element) {\n  let sibling = getPreviousSibling(element);\n\n  while (sibling && sibling.nodeType !== Node.ELEMENT_NODE) {\n    sibling = getPreviousSibling(sibling);\n  }\n\n  return sibling;\n}\nfunction appendChild(parent, child) {\n  const shadowRoot = parent.shadowRoot;\n  return shadowRoot ? shadowRoot.appendChild(child) : parent.appendChild(child);\n}\nfunction insertBefore(parent, child, referenceChild) {\n  const shadowRoot = parent.shadowRoot;\n  return shadowRoot ? shadowRoot.insertBefore(child, referenceChild) : parent.insertBefore(child, referenceChild);\n}\nfunction getSelection(ref) {\n  var _a;\n\n  const win = (_a = ref.ownerDocument) === null || _a === void 0 ? void 0 : _a.defaultView;\n\n  if (!win) {\n    return null;\n  }\n\n  for (let el = ref; el; el = el.parentNode) {\n    if (el.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n      const tmp = el; // ShadowRoot.getSelection() exists only in Chrome.\n\n      if (tmp.getSelection) {\n        return tmp.getSelection() || null;\n      }\n\n      break;\n    }\n  }\n\n  return win.getSelection() || null;\n}\nfunction getElementsByName(referenceElement, name) {\n  for (let el = referenceElement; el; el = el.parentNode) {\n    if (el.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n      // Shadow root doesn't have getElementsByName()...\n      return el.querySelectorAll(`[name=${name}]`);\n    }\n  }\n\n  return referenceElement.ownerDocument.getElementsByName(name);\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nfunction getLastChild(container) {\n  let lastChild = null;\n\n  for (let i = getLastElementChild(container); i; i = getLastElementChild(i)) {\n    lastChild = i;\n  }\n\n  return lastChild || undefined;\n}\n\nclass ShadowTreeWalker {\n  constructor(doc, root, whatToShow, filter) {\n    this._walkerStack = [];\n    this._currentSetFor = new Set();\n\n    this._acceptNode = node => {\n      var _a;\n\n      if (node.nodeType === Node.ELEMENT_NODE) {\n        const shadowRoot = node.shadowRoot;\n\n        if (shadowRoot) {\n          const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, {\n            acceptNode: this._acceptNode\n          });\n\n          this._walkerStack.unshift(walker);\n\n          return NodeFilter.FILTER_ACCEPT;\n        } else {\n          if (typeof this.filter === \"function\") {\n            return this.filter(node);\n          } else if ((_a = this.filter) === null || _a === void 0 ? void 0 : _a.acceptNode) {\n            return this.filter.acceptNode(node);\n          } else if (this.filter === null) {\n            return NodeFilter.FILTER_ACCEPT;\n          }\n        }\n      }\n\n      return NodeFilter.FILTER_SKIP;\n    };\n\n    this._doc = doc;\n    this.root = root;\n    this.filter = filter !== null && filter !== void 0 ? filter : null;\n    this.whatToShow = whatToShow !== null && whatToShow !== void 0 ? whatToShow : NodeFilter.SHOW_ALL;\n    this._currentNode = root;\n\n    this._walkerStack.unshift(doc.createTreeWalker(root, whatToShow, this._acceptNode));\n\n    const shadowRoot = root.shadowRoot;\n\n    if (shadowRoot) {\n      const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, {\n        acceptNode: this._acceptNode\n      });\n\n      this._walkerStack.unshift(walker);\n    }\n  }\n\n  get currentNode() {\n    return this._currentNode;\n  }\n\n  set currentNode(node) {\n    if (!nodeContains(this.root, node)) {\n      throw new Error(\"Cannot set currentNode to a node that is not contained by the root node.\");\n    }\n\n    const walkers = [];\n    let curNode = node;\n    let currentWalkerCurrentNode = node;\n    this._currentNode = node;\n\n    while (curNode && curNode !== this.root) {\n      if (curNode.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {\n        const shadowRoot = curNode;\n\n        const walker = this._doc.createTreeWalker(shadowRoot, this.whatToShow, {\n          acceptNode: this._acceptNode\n        });\n\n        walkers.push(walker);\n        walker.currentNode = currentWalkerCurrentNode;\n\n        this._currentSetFor.add(walker);\n\n        curNode = currentWalkerCurrentNode = shadowRoot.host;\n      } else {\n        curNode = curNode.parentNode;\n      }\n    }\n\n    const walker = this._doc.createTreeWalker(this.root, this.whatToShow, {\n      acceptNode: this._acceptNode\n    });\n\n    walkers.push(walker);\n    walker.currentNode = currentWalkerCurrentNode;\n\n    this._currentSetFor.add(walker);\n\n    this._walkerStack = walkers;\n  }\n\n  firstChild() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n  lastChild() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n  nextNode() {\n    var _a;\n\n    const nextNode = this._walkerStack[0].nextNode();\n\n    if (nextNode) {\n      const shadowRoot = nextNode.shadowRoot;\n\n      if (shadowRoot) {\n        let nodeResult;\n\n        if (typeof this.filter === \"function\") {\n          nodeResult = this.filter(nextNode);\n        } else if ((_a = this.filter) === null || _a === void 0 ? void 0 : _a.acceptNode) {\n          nodeResult = this.filter.acceptNode(nextNode);\n        }\n\n        if (nodeResult === NodeFilter.FILTER_ACCEPT) {\n          return nextNode;\n        } // _acceptNode should have added new walker for this shadow,\n        // go in recursively.\n\n\n        return this.nextNode();\n      }\n\n      return nextNode;\n    } else {\n      if (this._walkerStack.length > 1) {\n        this._walkerStack.shift();\n\n        return this.nextNode();\n      } else {\n        return null;\n      }\n    }\n  }\n\n  previousNode() {\n    var _a, _b;\n\n    const currentWalker = this._walkerStack[0];\n\n    if (currentWalker.currentNode === currentWalker.root) {\n      if (this._currentSetFor.has(currentWalker)) {\n        this._currentSetFor.delete(currentWalker);\n\n        if (this._walkerStack.length > 1) {\n          this._walkerStack.shift();\n\n          return this.previousNode();\n        } else {\n          return null;\n        }\n      }\n\n      const lastChild = getLastChild(currentWalker.root);\n\n      if (lastChild) {\n        currentWalker.currentNode = lastChild;\n        let nodeResult;\n\n        if (typeof this.filter === \"function\") {\n          nodeResult = this.filter(lastChild);\n        } else if ((_a = this.filter) === null || _a === void 0 ? void 0 : _a.acceptNode) {\n          nodeResult = this.filter.acceptNode(lastChild);\n        }\n\n        if (nodeResult === NodeFilter.FILTER_ACCEPT) {\n          return lastChild;\n        }\n      }\n    }\n\n    const previousNode = currentWalker.previousNode();\n\n    if (previousNode) {\n      const shadowRoot = previousNode.shadowRoot;\n\n      if (shadowRoot) {\n        let nodeResult;\n\n        if (typeof this.filter === \"function\") {\n          nodeResult = this.filter(previousNode);\n        } else if ((_b = this.filter) === null || _b === void 0 ? void 0 : _b.acceptNode) {\n          nodeResult = this.filter.acceptNode(previousNode);\n        }\n\n        if (nodeResult === NodeFilter.FILTER_ACCEPT) {\n          return previousNode;\n        } // _acceptNode should have added new walker for this shadow,\n        // go in recursively.\n\n\n        return this.previousNode();\n      }\n\n      return previousNode;\n    } else {\n      if (this._walkerStack.length > 1) {\n        this._walkerStack.shift();\n\n        return this.previousNode();\n      } else {\n        return null;\n      }\n    }\n  }\n\n  nextSibling() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n  previousSibling() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n  parentNode() {\n    if (process.env.NODE_ENV === 'development') {\n      throw new Error(\"Method not implemented.\");\n    }\n\n    return null;\n  }\n\n}\nfunction createShadowTreeWalker(doc, root, whatToShow, filter) {\n  return new ShadowTreeWalker(doc, root, whatToShow, filter);\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nclass ShadowMutationObserver {\n  static _overrideAttachShadow(win) {\n    const origAttachShadow = win.Element.prototype.attachShadow;\n\n    if (origAttachShadow.__origAttachShadow) {\n      return;\n    }\n\n    Element.prototype.attachShadow = function (options) {\n      const shadowRoot = origAttachShadow.call(this, options);\n\n      for (const shadowObserver of ShadowMutationObserver._shadowObservers) {\n        shadowObserver._addSubObserver(shadowRoot);\n      }\n\n      return shadowRoot;\n    };\n\n    Element.prototype.attachShadow.__origAttachShadow = origAttachShadow;\n  }\n\n  constructor(callback) {\n    this._isObserving = false;\n\n    this._callbackWrapper = (mutations, observer) => {\n      for (const mutation of mutations) {\n        if (mutation.type === \"childList\") {\n          const removed = mutation.removedNodes;\n          const added = mutation.addedNodes;\n\n          for (let i = 0; i < removed.length; i++) {\n            this._walkShadows(removed[i], true);\n          }\n\n          for (let i = 0; i < added.length; i++) {\n            this._walkShadows(added[i]);\n          }\n        }\n      }\n\n      this._callback(mutations, observer);\n    };\n\n    this._callback = callback;\n    this._observer = new MutationObserver(this._callbackWrapper);\n    this._subObservers = new Map();\n  }\n\n  _addSubObserver(shadowRoot) {\n    if (!this._options || !this._callback || this._subObservers.has(shadowRoot)) {\n      return;\n    }\n\n    if (this._options.subtree && nodeContains(this._root, shadowRoot)) {\n      const subObserver = new MutationObserver(this._callbackWrapper);\n\n      this._subObservers.set(shadowRoot, subObserver);\n\n      if (this._isObserving) {\n        subObserver.observe(shadowRoot, this._options);\n      }\n\n      this._walkShadows(shadowRoot);\n    }\n  }\n\n  disconnect() {\n    this._isObserving = false;\n    delete this._options;\n\n    ShadowMutationObserver._shadowObservers.delete(this);\n\n    for (const subObserver of this._subObservers.values()) {\n      subObserver.disconnect();\n    }\n\n    this._subObservers.clear();\n\n    this._observer.disconnect();\n  }\n\n  observe(target, options) {\n    const doc = target.nodeType === Node.DOCUMENT_NODE ? target : target.ownerDocument;\n    const win = doc === null || doc === void 0 ? void 0 : doc.defaultView;\n\n    if (!doc || !win) {\n      return;\n    }\n\n    ShadowMutationObserver._overrideAttachShadow(win);\n\n    ShadowMutationObserver._shadowObservers.add(this);\n\n    this._root = target;\n    this._options = options;\n    this._isObserving = true;\n\n    this._observer.observe(target, options);\n\n    this._walkShadows(target);\n  }\n\n  _walkShadows(target, remove) {\n    const doc = target.nodeType === Node.DOCUMENT_NODE ? target : target.ownerDocument;\n\n    if (!doc) {\n      return;\n    }\n\n    if (target === doc) {\n      target = doc.body;\n    } else {\n      const shadowRoot = target.shadowRoot;\n\n      if (shadowRoot) {\n        this._addSubObserver(shadowRoot);\n\n        return;\n      }\n    }\n\n    const walker = doc.createTreeWalker(target, NodeFilter.SHOW_ELEMENT, {\n      acceptNode: node => {\n        if (node.nodeType === Node.ELEMENT_NODE) {\n          if (remove) {\n            const subObserver = this._subObservers.get(node);\n\n            if (subObserver) {\n              subObserver.disconnect();\n\n              this._subObservers.delete(node);\n            }\n          } else {\n            const shadowRoot = node.shadowRoot;\n\n            if (shadowRoot) {\n              this._addSubObserver(shadowRoot);\n            }\n          }\n        }\n\n        return NodeFilter.FILTER_SKIP;\n      }\n    });\n    walker.nextNode();\n  }\n\n  takeRecords() {\n    const records = this._observer.takeRecords();\n\n    for (const subObserver of this._subObservers.values()) {\n      records.push(...subObserver.takeRecords());\n    }\n\n    return records;\n  }\n\n}\nShadowMutationObserver._shadowObservers = /*#__PURE__*/new Set();\nfunction createShadowMutationObserver(callback) {\n  return new ShadowMutationObserver(callback);\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\nfunction shadowQuerySelector(node, selector, all) {\n  // TODO: This is probably slow. Optimize to use each shadowRoot's querySelector/querySelectorAll\n  //       instead of walking the tree.\n  const elements = [];\n  walk(node, selector);\n  return elements;\n\n  function walk(from, selector) {\n    let el = null;\n    const walker = document.createTreeWalker(from, NodeFilter.SHOW_ELEMENT, {\n      acceptNode: n => {\n        if (n.nodeType === Node.ELEMENT_NODE) {\n          if (n.matches(selector)) {\n            el = n;\n            elements.push(el);\n            return all ? NodeFilter.FILTER_SKIP : NodeFilter.FILTER_ACCEPT;\n          }\n\n          const shadowRoot = n.shadowRoot;\n\n          if (shadowRoot) {\n            walk(shadowRoot, selector);\n            return !all && elements.length ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n          }\n        }\n\n        return NodeFilter.FILTER_SKIP;\n      }\n    });\n    walker.nextNode();\n  }\n}\n\nfunction querySelectorAll(node, selector) {\n  return shadowQuerySelector(node, selector, true);\n}\nfunction querySelector(node, selector) {\n  return shadowQuerySelector(node, selector, false)[0] || null;\n}\nfunction getElementById(doc, id) {\n  return querySelector(doc, \"#\" + id);\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nvar shadowDOMAPI = /*#__PURE__*/Object.freeze({\n    __proto__: null,\n    createTreeWalker: createShadowTreeWalker,\n    createMutationObserver: createShadowMutationObserver,\n    appendChild: appendChild,\n    getActiveElement: getActiveElement,\n    getFirstChild: getFirstChild,\n    getFirstElementChild: getFirstElementChild,\n    getLastChild: getLastChild$1,\n    getLastElementChild: getLastElementChild,\n    getNextElementSibling: getNextElementSibling,\n    getNextSibling: getNextSibling,\n    getParentElement: getParentElement,\n    getParentNode: getParentNode,\n    getPreviousElementSibling: getPreviousElementSibling,\n    getPreviousSibling: getPreviousSibling,\n    getSelection: getSelection,\n    getElementsByName: getElementsByName,\n    insertBefore: insertBefore,\n    nodeContains: nodeContains,\n    getElementById: getElementById,\n    querySelector: querySelector,\n    querySelectorAll: querySelectorAll\n});\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nclass Tabster {\n  constructor(tabster) {\n    this.keyboardNavigation = tabster.keyboardNavigation;\n    this.focusedElement = tabster.focusedElement;\n    this.focusable = tabster.focusable;\n    this.root = tabster.root;\n    this.uncontrolled = tabster.uncontrolled;\n    this.core = tabster;\n  }\n\n}\n/**\r\n * Extends Window to include an internal Tabster instance.\r\n */\n\n\nclass TabsterCore {\n  constructor(win, props) {\n    var _a, _b;\n\n    this._forgetMemorizedElements = [];\n    this._wrappers = new Set();\n    this._initQueue = [];\n    this._version = \"8.2.0\";\n    this._noop = false;\n\n    this.getWindow = () => {\n      if (!this._win) {\n        throw new Error(\"Using disposed Tabster.\");\n      }\n\n      return this._win;\n    };\n\n    this._storage = createWeakMap(win);\n    this._win = win;\n    const getWindow = this.getWindow;\n\n    if (props === null || props === void 0 ? void 0 : props.DOMAPI) {\n      setDOMAPI({ ...props.DOMAPI\n      });\n    }\n\n    this.keyboardNavigation = new KeyboardNavigationState(getWindow);\n    this.focusedElement = new FocusedElementState(this, getWindow);\n    this.focusable = new FocusableAPI(this);\n    this.root = new RootAPI(this, props === null || props === void 0 ? void 0 : props.autoRoot);\n    this.uncontrolled = new UncontrolledAPI( // TODO: Remove checkUncontrolledTrappingFocus in the next major version.\n    (props === null || props === void 0 ? void 0 : props.checkUncontrolledCompletely) || (props === null || props === void 0 ? void 0 : props.checkUncontrolledTrappingFocus));\n    this.controlTab = (_a = props === null || props === void 0 ? void 0 : props.controlTab) !== null && _a !== void 0 ? _a : true;\n    this.rootDummyInputs = !!(props === null || props === void 0 ? void 0 : props.rootDummyInputs);\n    this._dummyObserver = new DummyInputObserver(getWindow);\n    this.getParent = (_b = props === null || props === void 0 ? void 0 : props.getParent) !== null && _b !== void 0 ? _b : dom.getParentNode;\n    this.internal = {\n      stopObserver: () => {\n        if (this._unobserve) {\n          this._unobserve();\n\n          delete this._unobserve;\n        }\n      },\n      resumeObserver: syncState => {\n        if (!this._unobserve) {\n          const doc = getWindow().document;\n          this._unobserve = observeMutations(doc, this, updateTabsterByAttribute, syncState);\n        }\n      }\n    };\n    startFakeWeakRefsCleanup(getWindow); // Gives a tick to the host app to initialize other tabster\n    // APIs before tabster starts observing attributes.\n\n    this.queueInit(() => {\n      this.internal.resumeObserver(true);\n    });\n  }\n  /**\r\n   * Merges external props with the current props. Not all\r\n   * props can/should be mergeable, so let's add more as we move on.\r\n   * @param props Tabster props\r\n   */\n\n\n  _mergeProps(props) {\n    var _a;\n\n    if (!props) {\n      return;\n    }\n\n    this.getParent = (_a = props.getParent) !== null && _a !== void 0 ? _a : this.getParent;\n  }\n\n  createTabster(noRefCount, props) {\n    const wrapper = new Tabster(this);\n\n    if (!noRefCount) {\n      this._wrappers.add(wrapper);\n    }\n\n    this._mergeProps(props);\n\n    return wrapper;\n  }\n\n  disposeTabster(wrapper, allInstances) {\n    if (allInstances) {\n      this._wrappers.clear();\n    } else {\n      this._wrappers.delete(wrapper);\n    }\n\n    if (this._wrappers.size === 0) {\n      this.dispose();\n    }\n  }\n\n  dispose() {\n    var _a, _b, _c, _d, _e, _f, _g, _h;\n\n    this.internal.stopObserver();\n    const win = this._win;\n    win === null || win === void 0 ? void 0 : win.clearTimeout(this._initTimer);\n    delete this._initTimer;\n    this._initQueue = [];\n    this._forgetMemorizedElements = [];\n\n    if (win && this._forgetMemorizedTimer) {\n      win.clearTimeout(this._forgetMemorizedTimer);\n      delete this._forgetMemorizedTimer;\n    }\n\n    (_a = this.outline) === null || _a === void 0 ? void 0 : _a.dispose();\n    (_b = this.crossOrigin) === null || _b === void 0 ? void 0 : _b.dispose();\n    (_c = this.deloser) === null || _c === void 0 ? void 0 : _c.dispose();\n    (_d = this.groupper) === null || _d === void 0 ? void 0 : _d.dispose();\n    (_e = this.mover) === null || _e === void 0 ? void 0 : _e.dispose();\n    (_f = this.modalizer) === null || _f === void 0 ? void 0 : _f.dispose();\n    (_g = this.observedElement) === null || _g === void 0 ? void 0 : _g.dispose();\n    (_h = this.restorer) === null || _h === void 0 ? void 0 : _h.dispose();\n    this.keyboardNavigation.dispose();\n    this.focusable.dispose();\n    this.focusedElement.dispose();\n    this.root.dispose();\n\n    this._dummyObserver.dispose();\n\n    stopFakeWeakRefsCleanupAndClearStorage(this.getWindow);\n    clearElementCache(this.getWindow);\n    this._storage = new WeakMap();\n\n    this._wrappers.clear();\n\n    if (win) {\n      disposeInstanceContext(win);\n      delete win.__tabsterInstance;\n      delete this._win;\n    }\n  }\n\n  storageEntry(element, addremove) {\n    const storage = this._storage;\n    let entry = storage.get(element);\n\n    if (entry) {\n      if (addremove === false && Object.keys(entry).length === 0) {\n        storage.delete(element);\n      }\n    } else if (addremove === true) {\n      entry = {};\n      storage.set(element, entry);\n    }\n\n    return entry;\n  }\n\n  forceCleanup() {\n    if (!this._win) {\n      return;\n    }\n\n    this._forgetMemorizedElements.push(this._win.document.body);\n\n    if (this._forgetMemorizedTimer) {\n      return;\n    }\n\n    this._forgetMemorizedTimer = this._win.setTimeout(() => {\n      delete this._forgetMemorizedTimer;\n\n      for (let el = this._forgetMemorizedElements.shift(); el; el = this._forgetMemorizedElements.shift()) {\n        clearElementCache(this.getWindow, el);\n        FocusedElementState.forgetMemorized(this.focusedElement, el);\n      }\n    }, 0);\n    cleanupFakeWeakRefs(this.getWindow, true);\n  }\n\n  queueInit(callback) {\n    var _a;\n\n    if (!this._win) {\n      return;\n    }\n\n    this._initQueue.push(callback);\n\n    if (!this._initTimer) {\n      this._initTimer = (_a = this._win) === null || _a === void 0 ? void 0 : _a.setTimeout(() => {\n        delete this._initTimer;\n        this.drainInitQueue();\n      }, 0);\n    }\n  }\n\n  drainInitQueue() {\n    if (!this._win) {\n      return;\n    }\n\n    const queue = this._initQueue; // Resetting the queue before calling the callbacks to avoid recursion.\n\n    this._initQueue = [];\n    queue.forEach(callback => callback());\n  }\n\n}\n\nfunction forceCleanup(tabster) {\n  // The only legit case for calling this method is when you've completely removed\n  // the application DOM and not going to add the new one for a while.\n  const tabsterCore = tabster.core;\n  tabsterCore.forceCleanup();\n}\n/**\r\n * Creates an instance of Tabster, returns the current window instance if it already exists.\r\n */\n\nfunction createTabster(win, props) {\n  let tabster = getCurrentTabster(win);\n\n  if (tabster) {\n    return tabster.createTabster(false, props);\n  }\n\n  tabster = new TabsterCore(win, props);\n  win.__tabsterInstance = tabster;\n  return tabster.createTabster();\n}\n/**\r\n * Returns an instance of Tabster if it was created before or null.\r\n */\n\nfunction getTabster(win) {\n  const tabster = getCurrentTabster(win);\n  return tabster ? tabster.createTabster(true) : null;\n}\nfunction getShadowDOMAPI() {\n  return shadowDOMAPI;\n}\n/**\r\n * Creates a new groupper instance or returns an existing one\r\n * @param tabster Tabster instance\r\n */\n\nfunction getGroupper(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.groupper) {\n    tabsterCore.groupper = new GroupperAPI(tabsterCore, tabsterCore.getWindow);\n  }\n\n  return tabsterCore.groupper;\n}\n/**\r\n * Creates a new mover instance or returns an existing one\r\n * @param tabster Tabster instance\r\n */\n\nfunction getMover(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.mover) {\n    tabsterCore.mover = new MoverAPI(tabsterCore, tabsterCore.getWindow);\n  }\n\n  return tabsterCore.mover;\n}\nfunction getOutline(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.outline) {\n    tabsterCore.outline = new OutlineAPI(tabsterCore);\n  }\n\n  return tabsterCore.outline;\n}\n/**\r\n * Creates a new new deloser instance or returns an existing one\r\n * @param tabster Tabster instance\r\n * @param props Deloser props\r\n */\n\nfunction getDeloser(tabster, props) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.deloser) {\n    tabsterCore.deloser = new DeloserAPI(tabsterCore, props);\n  }\n\n  return tabsterCore.deloser;\n}\n/**\r\n * Creates a new modalizer instance or returns an existing one\r\n * @param tabster Tabster instance\r\n * @param alwaysAccessibleSelector When Modalizer is active, we put\r\n * aria-hidden to everything else to hide it from screen readers. This CSS\r\n * selector allows to exclude some elements from this behaviour. For example,\r\n * this could be used to exclude aria-live region with the application-wide\r\n * status announcements.\r\n * @param accessibleCheck An optional callback that will be called when\r\n * active Modalizer wants to hide an element that doesn't belong to it from\r\n * the screen readers by setting aria-hidden. Similar to alwaysAccessibleSelector\r\n * but allows to address the elements programmatically rather than with a selector.\r\n * If the callback returns true, the element will not receive aria-hidden.\r\n */\n\nfunction getModalizer(tabster, // @deprecated use accessibleCheck.\nalwaysAccessibleSelector, accessibleCheck) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.modalizer) {\n    tabsterCore.modalizer = new ModalizerAPI(tabsterCore, alwaysAccessibleSelector, accessibleCheck);\n  }\n\n  return tabsterCore.modalizer;\n}\nfunction getObservedElement(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.observedElement) {\n    tabsterCore.observedElement = new ObservedElementAPI(tabsterCore);\n  }\n\n  return tabsterCore.observedElement;\n}\nfunction getCrossOrigin(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.crossOrigin) {\n    getDeloser(tabster);\n    getModalizer(tabster);\n    getMover(tabster);\n    getGroupper(tabster);\n    getOutline(tabster);\n    getObservedElement(tabster);\n    tabsterCore.crossOrigin = new CrossOriginAPI(tabsterCore);\n  }\n\n  return tabsterCore.crossOrigin;\n}\nfunction getInternal(tabster) {\n  const tabsterCore = tabster.core;\n  return tabsterCore.internal;\n}\nfunction getRestorer(tabster) {\n  const tabsterCore = tabster.core;\n\n  if (!tabsterCore.restorer) {\n    tabsterCore.restorer = new RestorerAPI(tabsterCore);\n  }\n\n  return tabsterCore.restorer;\n}\nfunction disposeTabster(tabster, allInstances) {\n  tabster.core.disposeTabster(tabster, allInstances);\n}\n/**\r\n * Returns an instance of Tabster if it already exists on the window .\r\n * @param win window instance that could contain an Tabster instance.\r\n */\n\nfunction getCurrentTabster(win) {\n  return win.__tabsterInstance;\n}\n/**\r\n * Allows to make Tabster non operational. Intended for performance debugging (and other\r\n * kinds of debugging), you can switch Tabster off without changing the application code\r\n * that consumes it.\r\n * @param tabster a reference created by createTabster().\r\n * @param noop true if you want to make Tabster noop, false if you want to turn it back.\r\n */\n\nfunction makeNoOp(tabster, noop) {\n  const core = tabster.core;\n\n  if (core._noop !== noop) {\n    core._noop = noop;\n\n    const processNode = element => {\n      if (!element.getAttribute) {\n        return NodeFilter.FILTER_SKIP;\n      }\n\n      if (getTabsterOnElement(core, element) || element.hasAttribute(TABSTER_ATTRIBUTE_NAME)) {\n        updateTabsterByAttribute(core, element);\n      }\n\n      return NodeFilter.FILTER_SKIP;\n    };\n\n    const doc = core.getWindow().document;\n    const body = doc.body;\n    processNode(body);\n    const walker = createElementTreeWalker(doc, body, processNode);\n\n    if (walker) {\n      while (walker.nextNode()) {\n        /* Iterating for the sake of calling processNode() callback. */\n      }\n    }\n  }\n}\nfunction isNoOp(tabster) {\n  return tabster._noop;\n}\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nvar Types = /*#__PURE__*/Object.freeze({\n    __proto__: null\n});\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n\nvar EventsTypes = /*#__PURE__*/Object.freeze({\n    __proto__: null\n});\n\n/*!\r\n * Copyright (c) Microsoft Corporation. All rights reserved.\r\n * Licensed under the MIT License.\r\n */\n/** @deprecated This function is obsolete, use native element.dispatchEvent(new GroupperMoveFocusEvent(...)). */\n\nfunction dispatchGroupperMoveFocusEvent(target, action) {\n  return target.dispatchEvent(new GroupperMoveFocusEvent({\n    action\n  }));\n}\n/** @deprecated This function is obsolete, use native element.dispatchEvent(new MoverMoveFocusEvent(...)). */\n\nfunction dispatchMoverMoveFocusEvent(target, key) {\n  return target.dispatchEvent(new MoverMoveFocusEvent({\n    key\n  }));\n}\n/** @deprecated This function is obsolete, use native element.dispatchEvent(new MoverMemorizedElementEvent(...)). */\n\nfunction dispatchMoverMemorizedElementEvent(target, memorizedElement) {\n  return target.dispatchEvent(new MoverMemorizedElementEvent({\n    memorizedElement\n  }));\n}\n\nexport { AsyncFocusSources, DeloserFocusLostEvent, DeloserFocusLostEventName, DeloserRestoreFocusEvent, DeloserRestoreFocusEventName, DeloserStrategies, EventsTypes, FOCUSABLE_SELECTOR, GroupperMoveFocusActions, GroupperMoveFocusEvent, GroupperMoveFocusEventName, GroupperTabbabilities, ModalizerActiveEvent, ModalizerActiveEventName, ModalizerFocusInEventName, ModalizerFocusOutEventName, ModalizerInactiveEvent, ModalizerInactiveEventName, MoverDirections, MoverKeys, MoverMemorizedElementEvent, MoverMemorizedElementEventName, MoverMoveFocusEvent, MoverMoveFocusEventName, MoverStateEvent, MoverStateEventName, ObservedElementAccessibilities, RestoreFocusOrders, RestorerRestoreFocusEvent, RestorerRestoreFocusEventName, RestorerTypes, RootBlurEvent, RootBlurEventName, RootFocusEvent, RootFocusEventName, SysDummyInputsPositions, TABSTER_ATTRIBUTE_NAME, TABSTER_DUMMY_INPUT_ATTRIBUTE_NAME, TabsterCustomEvent, TabsterFocusInEvent, TabsterFocusInEventName, TabsterFocusOutEvent, TabsterFocusOutEventName, TabsterMoveFocusEvent, TabsterMoveFocusEventName, Types, Visibilities, createTabster, dispatchGroupperMoveFocusEvent, dispatchMoverMemorizedElementEvent, dispatchMoverMoveFocusEvent, disposeTabster, forceCleanup, getCrossOrigin, getDeloser, getDummyInputContainer, getGroupper, getInternal, getModalizer, getMover, getObservedElement, getOutline, getRestorer, getShadowDOMAPI, getTabster, getTabsterAttribute, isNoOp, makeNoOp, mergeTabsterProps, setTabsterAttribute };\n//# sourceMappingURL=tabster.esm.js.map\n"],"names":["TABSTER_ATTRIBUTE_NAME","TABSTER_DUMMY_INPUT_ATTRIBUTE_NAME","FOCUSABLE_SELECTOR","join","AsyncFocusSources","Visibilities","RestorerTypes","Source","Target","MoverDirections","Both","Vertical","Horizontal","Grid","GridLinear","MoverKeys","GroupperTabbabilities","Unlimited","Limited","LimitedTrapFocus","GroupperMoveFocusActions","SysDummyInputsPositions","getTabsterOnElement","tabster","element","_a","storageEntry","updateTabsterByAttribute","dispose","_b","newAttrValue","_noop","undefined","getAttribute","newAttr","entry","attr","string","newValue","JSON","parse","Error","object","e","tabsterOnElement","oldTabsterProps","newTabsterProps","key","Object","keys","root","onRoot","part","observedElement","onObservedElementUpdate","sys","deloser","setProps","createDeloser","createRoot","modalizer","createModalizer","restorer","createRestorer","focusable","groupper","createGroupper","mover","createMover","observed","uncontrolled","outline","console","error","length","TabsterMoveFocusEventName","MoverMoveFocusEventName","MoverMemorizedElementEventName","GroupperMoveFocusEventName","RestorerRestoreFocusEventName","CustomEvent_","CustomEvent","TabsterCustomEvent","constructor","type","detail","super","bubbles","cancelable","composed","this","details","TabsterFocusInEvent","TabsterFocusOutEvent","TabsterMoveFocusEvent","MoverStateEvent","RestorerRestoreFocusEvent","RootFocusEvent","RootBlurEvent","dom","createMutationObserver","callback","MutationObserver","createTreeWalker","doc","whatToShow","filter","getParentNode","node","parentNode","getParentElement","parentElement","nodeContains","parent","child","contains","getActiveElement","activeElement","querySelector","selector","querySelectorAll","Array","prototype","slice","call","getElementById","id","getFirstChild","firstChild","getLastChild","lastChild","getNextSibling","nextSibling","getPreviousSibling","previousSibling","getFirstElementChild","firstElementChild","getLastElementChild","lastElementChild","getNextElementSibling","nextElementSibling","getPreviousElementSibling","previousElementSibling","appendChild","insertBefore","referenceChild","getSelection","ref","ownerDocument","getElementsByName","referenceElement","name","_isBrokenIE11","_DOMRect","DOMRect","x","y","width","height","left","top","right","bottom","_uidCounter","document","NodeFilter","SHOW_ELEMENT","getInstanceContext","getWindow","win","ctx","__tabsterInstanceContext","elementByUId","basics","Promise","WeakRef","containerBoundingRectCache","lastContainerBoundingRectCacheId","fakeWeakRefs","fakeWeakRefsStarted","FakeWeakRef","target","_target","deref","cleanup","fwr","forceRemove","documentContains","WeakHTMLElement","data","context","push","_ref","_data","get","getData","cleanupFakeWeakRefs","startFakeWeakRefsCleanup","getWeakRef","fakeWeakRefsTimer","setTimeout","createElementTreeWalker","acceptNode","nodeType","Node","ELEMENT_NODE","getBoundingRect","cacheId","__tabsterCacheId","cached","rect","scrollingElement","documentElement","clientWidth","clientHeight","r","getBoundingClientRect","Math","max","min","containerBoundingRectCacheTimer","window","cId","isElementVerticallyVisibleInContainer","tolerance","container","getScrollableContainer","containerRect","elementRect","intersectionTolerance","totalIntersection","el","scrollWidth","scrollHeight","shouldIgnoreFocus","__shouldIgnoreFocus","getUId","wnd","rnd","Uint32Array","crypto","getRandomValues","msCrypto","i","random","srnd","toString","Date","now","getElementUId","uid","__tabsterElementUID","clearElementCache","wel","body","matchesSelector","matches","msMatchesSelector","webkitMatchesSelector","getPromise","_lastTabsterPartId","TabsterPart","props","_tabster","_element","_props","getElement","getProps","DummyInput","isOutside","fixedTarget","_focusIn","_fixedTarget","input","onFocusIn","relatedTarget","_isBackward","_focusOut","useDefaultAction","onFocusOut","createElement","tabIndex","setAttribute","style","position","opacity","zIndex","setProperty","makeFocusIgnored","isFirst","_isPhantom","isPhantom","addEventListener","__tabsterDummyContainer","_disposeTimer","_clearDisposeTimeout","clearTimeout","removeEventListener","removeChild","setTopLeft","isIn","current","previous","compareDocumentPosition","DOCUMENT_POSITION_FOLLOWING","DummyInputManagerPriorities","DummyInputManager","priority","outsideByDefault","callForDefaultAction","_instance","DummyInputManagerCore","_setHandlers","_onFocusIn","_onFocusOut","moveOut","backwards","moveOutWithDefaultAction","relatedEvent","getHandler","setTabbable","tabbable","moveWithPhantomDummy","moveOutOfElement","isBackward","tagName","potentialDummy","dummyFor","isFocusable","getDummyInputContainer","dispatchEvent","by","owner","next","addPhantomDummyWithTarget","sourceElement","targetElement","dummyParent","DummyInputObserver","_updateQueue","Set","_lastUpdateQueueTime","_changedParents","WeakSet","_dummyElements","_dummyCallbacks","WeakMap","_domChanged","has","add","_updateDummyInputsTimer","_win","dummyElement","dummy","set","domChanged","remove","delete","_updateTimer","clear","updatePositions","compute","_scheduledUpdatePositions","scrollTopLeftCache","Map","setTopLeftCallbacks","manager","_wrappers","_isOutside","_transformElements","dummyInput","_onFocus","first","_firstDummy","last","_lastDummy","_ensurePosition","firstInput","lastInput","toFocus","w","wrapper","_getCurrent","_addDummyInputs","_addTimer","_getWindow","_addTransformOffsets","_dummyObserver","_computeTransformOffsets","from","transformElements","newTransformElements","scrollTop","scrollLeft","scrollTopLeft","transform","getComputedStyle","_callForDefaultAction","instance","__tabsterDummy","forcedDummyPosition","dummyInputsPosition","force","_c","_d","sort","a","b","firstDummyInput","lastDummyInput","elementParent","getLastChild$2","isDisplayNone","elementDocument","computedStyle","defaultView","offsetParent","visibility","display","isRadio","getTabsterAttribute","plain","stringify","setTabsterAttribute","newProps","update","value","mergeTabsterProps","removeAttribute","RootDummyManager","setFocused","_onDummyInputFocus","_setFocused","keyboardNavigation","setNavigatingWithKeyboard","focusedElement","getFirstOrLastTabbable","ignoreAccessibility","blur","Root","onDispose","_isFocused","hasFocused","_setFocusedTimer","_dummyManager","event","getParent","rootElement","curElement","composedPath","_onDispose","_sys","controlTab","rootDummyInputs","addDummyInputs","_add","_remove","dummyManager","RootAPI","autoRoot","_autoRootWaiting","_roots","_forceDummy","rootById","_autoRootCreate","_autoRootUnwait","_autoRoot","_onRootDispose","queueInit","forEach","rootId","newRoot","roots","getRootByUId","__tabsterInstance","getTabsterContext","options","checkRtl","drainInitQueue","groupperBeforeMover","modalizerInGroupper","dirRightToLeft","excludedFromMover","ignoreKeydown","dir","toLowerCase","excludeFromMover","curModalizer","curGroupper","curMover","isActive","tabbability","userId","activeId","assign","rootAPI","rtl","getRoot","removed","Subscribable","_callbacks","_val","subscribe","callbacks","indexOf","subscribeFirst","index","splice","unshift","unsubscribe","setVal","val","_callCallbacks","getVal","trigger","FocusableAPI","includeProgrammaticallyFocusable","noVisibleCheck","noAccessibleCheck","isVisible","isAccessible","_isHidden","ignoreAriaDisabled","_isDisabled","hasAttribute","attrVal","isAugmented","findFirst","out","findElement","findLast","findNext","findPrev","findDefault","acceptCondition","isDefault","findAll","_findElements","found","isFindAll","currentElement","useActiveModalizer","modalizerId","onElement","elements","hasCustomCondition","acceptElementState","modalizerUserId","cachedGrouppers","cachedRadioGroups","walker","_acceptElement","prepareForNextElement","shouldContinueIfNotFound","foundElement","foundBackward","fromCtx","outOfDOMOrder","currentNode","FILTER_ACCEPT","skippedFocusable","previousNode","nextNode","state","FILTER_SKIP","FILTER_REJECT","rejectElementsFrom","currentCtx","result","fromMover","acceptElement","groupperElement","fromMoverElement","moverElement","checked","radioGroupName","radioGroup","radioButtons","buttons","getRadioButtonGroup","Keys","AsyncFocusIntentPriorityBySource","FocusedElementState","_init","_onKeyDown","_setFocusedElement","_onChanged","isFocusedProgrammatically","originalEvent","_validateFocusedElement","ctrlKey","contentEditable","shiftKey","findNextTabbable","nextElement","uncontrolledCompletelyContainer","uncontrolledOnElement","isUncontrolledCompletely","completely","getUncontrolledCompletelyContainer","nextUncontrolled","preventDefault","stopImmediatePropagation","_lastVal","d","lastCtx","asyncFocus","_asyncFocus","timeout","_lastResetElement","_nextVal","forgetMemorized","getFocusedElement","getLastFocusedElement","focus","noFocusedProgrammaticallyFlag","preventScroll","focusDefault","_focusFirstOrLast","focusFirst","focusLast","resetFocus","prevTabIndex","prevAriaHidden","_setOrRemoveAttribute","requestAsyncFocus","source","delay","currentAsyncFocus","cancelAsyncFocus","lastResetElement","nextVal","actualContainer","isTabbingTimer","_isTabbingTimer","isTabbing","callFindNext","what","parentCtx","currentScopeElement","newCurrent","findProps","findPropsOut","GroupperDummyManager","prev","cur","adjacent","getAdjacentElement","Groupper","_shouldTabInside","makeTabbable","_first","currentIsDummy","groupperFirstFocusable","getFirst","isTabbable","noIfFirstIsFocused","isParentActive","g","ret","focused","orContainer","setFirst","parentCtxGroupper","parentGroupper","parentGroupperElement","getIsActive","GroupperAPI","_current","_grouppers","_onMouseDown","_onMoveFocus","_onGroupperDispose","_updateCurrent","altKey","metaKey","handleKeyPress","action","defaultPrevented","_enterGroupper","_escapeGroupper","groupperId","newGroupper","forgetCurrentGrouppers","includeTarget","checkTarget","newIds","isTarget","delegated","fromModalizer","setActive","moveFocus","KeyboardNavigationState","_onChange","isNavigatingWithKeyboard","_keyborg","_inputSelector","MoverDummyManager","getMemorized","_onFocusDummyInput","memorized","_getMemorized","Mover","_visible","_onIntersection","entries","newVisibility","fullyVisible","_fullyVisible","intersectionRatio","getState","visibilityTolerance","trackState","visibilityAware","_intersectionObserver","IntersectionObserver","threshold","_observeState","memorizeCurrent","disconnect","_allElements","_unobserve","_setCurrentTimer","setCurrent","changed","_prevCurrent","weak","getCurrent","hasDefault","allElements","tabsterFocusable","updateQueue","observer","mutations","mutation","removedNodes","added","addedNodes","attributeName","requestUpdate","setElement","unobserve","observe","updateElement","addNewElements","getMoverGroupper","removeWalk","toe","childList","subtree","attributes","attributeFilter","isCurrent","MoverAPI","_onMemorizedElement","_onMoverDispose","_movers","currentFocusableElement","deepestFocusableElement","async","_ignoredInputTimer","_ignoredInputResolve","moverKey","_isIgnoredInput","_moveFocus","memorizedElement","moverId","newMover","fromElement","moverProps","direction","isBoth","isVertical","isHorizontal","isGridLinear","isGrid","isCyclic","cyclic","scrollIntoViewArg","focusedElementRect","focusedElementX1","focusedElementX2","ceil","floor","nextElementX1","nextElementX2","firstColumnX1","lastColumnX1","ax1","ay1","ax2","ay2","lastDistance","lastIntersection","bx1","by1","bx2","by2","xIntersectionWidth","minWidth","intersection","distance","xDistance","yDistance","sqrt","getDistance","alignToTop","scrollIntoView","asyncRet","selectionStart","selectionEnd","textLength","selection","initialLength","modify","selStart","resolve","anchorNode","prevAnchorNode","focusNode","prevFocusNode","anchorOffset","prevAnchorOffset","focusOffset","prevFocusOffset","textContent","anchorFound","addOffsets","nodeText","len","stop","UncontrolledAPI","_isUncontrolledCompletely","Restorer","_hasFocus","History","_stack","DEPTH","shift","pop","maybeElement","RestorerAPI","_onRestoreFocus","_focusedElementState","sourceId","_restoreFocus","tabsterAttribute","_history","_keyboardNavState","getId","otherNode","assignedElements","assignedSlot","DOCUMENT_FRAGMENT_NODE","host","ShadowMutationObserver","_overrideAttachShadow","origAttachShadow","Element","attachShadow","__origAttachShadow","shadowRoot","shadowObserver","_shadowObservers","_addSubObserver","_isObserving","_callbackWrapper","_walkShadows","_callback","_observer","_subObservers","_options","_root","subObserver","values","DOCUMENT_NODE","takeRecords","records","Tabster","core","TabsterCore","_forgetMemorizedElements","_initQueue","_version","_storage","createWeakMap","DOMAPI","domapi","setDOMAPI","checkUncontrolledCompletely","checkUncontrolledTrappingFocus","internal","stopObserver","resumeObserver","syncState","updateTabsterElements","processNode","_e","removedNode","hiddenUpdate","observeMutations","_mergeProps","createTabster","noRefCount","disposeTabster","allInstances","size","_f","_g","_h","_initTimer","_forgetMemorizedTimer","crossOrigin","stopFakeWeakRefsCleanupAndClearStorage","disposeInstanceContext","addremove","storage","forceCleanup","queue","getCurrentTabster","getGroupper","tabsterCore","getMover","getRestorer"],"sourceRoot":""}