{"version":3,"file":"static/js/vendors-a30a93ff.2aa5ea31.js","mappings":"yGAAA,SAASA,EAAQC,GAaf,OATED,EADoB,mBAAXE,QAAoD,iBAApBA,OAAOC,SACtC,SAAUF,GAClB,cAAcA,CAChB,EAEU,SAAUA,GAClB,OAAOA,GAAyB,mBAAXC,QAAyBD,EAAIG,cAAgBF,QAAUD,IAAQC,OAAOG,UAAY,gBAAkBJ,CAC3H,EAGKD,EAAQC,EACjB,C,kBAoDA,IAAIK,EAAW,YAAC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,KAAI,KACtwCC,EAAW,YAAC,EAAG,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,IAAG,KAqE1gC,SAASC,EAAuBC,EAAQC,EAAMC,EAAMC,EAAOC,GAKzD,GAJsB,iBAAXJ,IACTA,EAASK,SAASC,eAAeN,KAG9BA,GAA8B,WAApBT,EAAQS,MAA0B,eAAgBA,GAC/D,MAAM,IAAIO,UAAU,2EAGtB,IAAIC,EAAUR,EAAOS,WAAW,MAEhC,IACE,OAAOD,EAAQE,aAAaT,EAAMC,EAAMC,EAAOC,EACjD,CAAE,MAAOO,GACP,MAAM,IAAIC,MAAM,gCAAkCD,EACpD,CACF,CAYA,SAASE,EAAkBb,EAAQC,EAAMC,EAAMC,EAAOC,EAAQU,GAC5D,KAAIC,MAAMD,IAAWA,EAAS,GAA9B,CAIAA,GAAU,EACV,IAAIE,EAAYjB,EAAuBC,EAAQC,EAAMC,EAAMC,EAAOC,GAClEY,EAcF,SAA8BA,EAAWf,EAAMC,EAAMC,EAAOC,EAAQU,GAYlE,IAXA,IASIG,EATAC,EAASF,EAAUG,KACnBC,EAAM,EAAIN,EAAS,EAEnBO,EAAclB,EAAQ,EACtBmB,EAAelB,EAAS,EACxBmB,EAAcT,EAAS,EACvBU,EAAYD,GAAeA,EAAc,GAAK,EAC9CE,EAAa,IAAIC,EACjBC,EAAQF,EAGHG,EAAI,EAAGA,EAAIR,EAAKQ,IACvBD,EAAQA,EAAME,KAAO,IAAIH,EAErBE,IAAML,IACRN,EAAWU,GAIfA,EAAME,KAAOJ,EAQb,IAPA,IAAIK,EAAU,KACVC,EAAW,KACXC,EAAK,EACLC,EAAK,EACLC,EAASrC,EAASiB,GAClBqB,EAASrC,EAASgB,GAEbsB,EAAI,EAAGA,EAAIhC,EAAQgC,IAAK,CAC/BT,EAAQF,EAMR,IALA,IAAIY,EAAKnB,EAAOe,GACZK,EAAKpB,EAAOe,EAAK,GACjBM,EAAKrB,EAAOe,EAAK,GACjBO,EAAKtB,EAAOe,EAAK,GAEZQ,EAAK,EAAGA,EAAKlB,EAAakB,IACjCd,EAAMe,EAAIL,EACVV,EAAMgB,EAAIL,EACVX,EAAMiB,EAAIL,EACVZ,EAAMkB,EAAIL,EACVb,EAAQA,EAAME,KAgBhB,IAbA,IAAIiB,EAAS,EACTC,EAAS,EACTC,EAAS,EACTC,EAAS,EACTC,EAAU3B,EAAcc,EACxBc,EAAU5B,EAAce,EACxBc,EAAU7B,EAAcgB,EACxBc,EAAU9B,EAAciB,EACxBc,EAAO9B,EAAYa,EACnBkB,EAAO/B,EAAYc,EACnBkB,EAAOhC,EAAYe,EACnBkB,EAAOjC,EAAYgB,EAEdkB,EAAM,EAAGA,EAAMnC,EAAamC,IAAO,CAC1C,IAAIC,EAAI1B,IAAOZ,EAAcqC,EAAMrC,EAAcqC,IAAQ,GACrDhB,EAAIxB,EAAOyC,GACXhB,EAAIzB,EAAOyC,EAAI,GACff,EAAI1B,EAAOyC,EAAI,GACfd,EAAI3B,EAAOyC,EAAI,GACfC,EAAMrC,EAAcmC,EACxBJ,IAAS3B,EAAMe,EAAIA,GAAKkB,EACxBL,IAAS5B,EAAMgB,EAAIA,GAAKiB,EACxBJ,IAAS7B,EAAMiB,EAAIA,GAAKgB,EACxBH,IAAS9B,EAAMkB,EAAIA,GAAKe,EACxBd,GAAUJ,EACVK,GAAUJ,EACVK,GAAUJ,EACVK,GAAUJ,EACVlB,EAAQA,EAAME,IAChB,CAEAC,EAAUL,EACVM,EAAWd,EAEX,IAAK,IAAI4C,EAAI,EAAGA,EAAI1D,EAAO0D,IAAK,CAC9B,IAAIC,EAAYL,EAAOvB,IAAWC,EAGlC,GAFAjB,EAAOe,EAAK,GAAK6B,EAEC,IAAdA,EAAiB,CACnB,IAAIC,EAAM,IAAMD,EAEhB5C,EAAOe,IAAOqB,EAAOpB,IAAWC,GAAU4B,EAC1C7C,EAAOe,EAAK,IAAMsB,EAAOrB,IAAWC,GAAU4B,EAC9C7C,EAAOe,EAAK,IAAMuB,EAAOtB,IAAWC,GAAU4B,CAChD,MACE7C,EAAOe,GAAMf,EAAOe,EAAK,GAAKf,EAAOe,EAAK,GAAK,EAGjDqB,GAAQJ,EACRK,GAAQJ,EACRK,GAAQJ,EACRK,GAAQJ,EACRH,GAAWpB,EAAQY,EACnBS,GAAWrB,EAAQa,EACnBS,GAAWtB,EAAQc,EACnBS,GAAWvB,EAAQe,EAEnB,IAAImB,EAAKH,EAAI/C,EAAS,EAEtBkD,EAAKhC,GAAMgC,EAAK3C,EAAc2C,EAAK3C,IAAgB,EAKnDiC,GAJAR,GAAUhB,EAAQY,EAAIxB,EAAO8C,GAK7BT,GAJAR,GAAUjB,EAAQa,EAAIzB,EAAO8C,EAAK,GAKlCR,GAJAR,GAAUlB,EAAQc,EAAI1B,EAAO8C,EAAK,GAKlCP,GAJAR,GAAUnB,EAAQe,EAAI3B,EAAO8C,EAAK,GAKlClC,EAAUA,EAAQD,KAClB,IAAIoC,GAAYlC,EACZmC,GAAKD,GAAUvB,EACfyB,GAAKF,GAAUtB,EACfyB,GAAKH,GAAUrB,EACfyB,GAAKJ,GAAUpB,EACnBK,GAAWgB,GACXf,GAAWgB,GACXf,GAAWgB,GACXf,GAAWgB,GACXvB,GAAUoB,GACVnB,GAAUoB,GACVnB,GAAUoB,GACVnB,GAAUoB,GACVtC,EAAWA,EAASF,KACpBI,GAAM,CACR,CAEAD,GAAM7B,CACR,CAEA,IAAK,IAAImE,GAAK,EAAGA,GAAKnE,EAAOmE,KAAM,CAGjC,IAAIC,GAAMrD,EAFVe,EAAKqC,IAAM,GAGPE,GAAMtD,EAAOe,EAAK,GAClBwC,GAAMvD,EAAOe,EAAK,GAClByC,GAAMxD,EAAOe,EAAK,GAClB0C,GAAWpD,EAAcgD,GACzBK,GAAWrD,EAAciD,GACzBK,GAAWtD,EAAckD,GACzBK,GAAWvD,EAAcmD,GACzBK,GAAQvD,EAAY+C,GACpBS,GAAQxD,EAAYgD,GACpBS,GAAQzD,EAAYiD,GACpBS,GAAQ1D,EAAYkD,GAExB/C,EAAQF,EAER,IAAK,IAAI0D,GAAM,EAAGA,GAAM5D,EAAa4D,KACnCxD,EAAMe,EAAI6B,GACV5C,EAAMgB,EAAI6B,GACV7C,EAAMiB,EAAI6B,GACV9C,EAAMkB,EAAI6B,GACV/C,EAAQA,EAAME,KAShB,IANA,IAAIuD,GAAKjF,EACLkF,GAAU,EACVC,GAAU,EACVC,GAAU,EACVC,GAAU,EAELC,GAAM,EAAGA,IAAO3E,EAAQ2E,KAAO,CACtCxD,EAAKmD,GAAKd,IAAM,EAEhB,IAAIoB,GAAOnE,EAAckE,GAEzBV,KAAUpD,EAAMe,EAAI6B,GAAMrD,EAAOe,IAAOyD,GACxCV,KAAUrD,EAAMgB,EAAI6B,GAAMtD,EAAOe,EAAK,IAAMyD,GAC5CT,KAAUtD,EAAMiB,EAAI6B,GAAMvD,EAAOe,EAAK,IAAMyD,GAC5CR,KAAUvD,EAAMkB,EAAI6B,GAAMxD,EAAOe,EAAK,IAAMyD,GAC5CF,IAAWjB,GACXc,IAAWb,GACXc,IAAWb,GACXc,IAAWb,GACX/C,EAAQA,EAAME,KAEV4D,GAAMnE,IACR8D,IAAMjF,EAEV,CAEA8B,EAAKqC,GACLxC,EAAUL,EACVM,EAAWd,EAEX,IAAK,IAAI0E,GAAK,EAAGA,GAAKvF,EAAQuF,KAAM,CAClC,IAAIC,GAAM3D,GAAM,EAEhBf,EAAO0E,GAAM,GAAKlB,GAAMQ,GAAQhD,IAAWC,EAEvCuC,GAAM,GACRA,GAAM,IAAMA,GACZxD,EAAO0E,KAAQb,GAAQ7C,IAAWC,GAAUuC,GAC5CxD,EAAO0E,GAAM,IAAMZ,GAAQ9C,IAAWC,GAAUuC,GAChDxD,EAAO0E,GAAM,IAAMX,GAAQ/C,IAAWC,GAAUuC,IAEhDxD,EAAO0E,IAAO1E,EAAO0E,GAAM,GAAK1E,EAAO0E,GAAM,GAAK,EAGpDb,IAASJ,GACTK,IAASJ,GACTK,IAASJ,GACTK,IAASJ,GACTH,IAAY7C,EAAQY,EACpBkC,IAAY9C,EAAQa,EACpBkC,IAAY/C,EAAQc,EACpBkC,IAAYhD,EAAQe,EACpB+C,GAAMtB,KAAOsB,GAAMD,GAAKpE,GAAeD,EAAesE,GAAMtE,GAAgBnB,GAAS,EACrF4E,IAASS,IAAW1D,EAAQY,EAAIxB,EAAO0E,IACvCZ,IAASK,IAAWvD,EAAQa,EAAIzB,EAAO0E,GAAM,GAC7CX,IAASK,IAAWxD,EAAQc,EAAI1B,EAAO0E,GAAM,GAC7CV,IAASK,IAAWzD,EAAQe,EAAI3B,EAAO0E,GAAM,GAC7C9D,EAAUA,EAAQD,KAClB8C,IAAYJ,GAAMxC,EAASW,EAC3BkC,IAAYJ,GAAMzC,EAASY,EAC3BkC,IAAYJ,GAAM1C,EAASa,EAC3BkC,IAAYJ,GAAM3C,EAASc,EAC3B2C,IAAWjB,GACXc,IAAWb,GACXc,IAAWb,GACXc,IAAWb,GACX3C,EAAWA,EAASF,KACpBI,GAAM9B,CACR,CACF,CAEA,OAAOa,CACT,CApPc6E,CAAqB7E,EAAWf,EAAMC,EAAMC,EAAOC,EAAQU,GACvEd,EAAOS,WAAW,MAAMqF,aAAa9E,EAAWf,EAAMC,EALtD,CAMF,CAmcA,IAAIwB,EAIJ,SAASA,KApmBT,SAAyBqE,EAAUC,GACjC,KAAMD,aAAoBC,GACxB,MAAM,IAAIzF,UAAU,oCAExB,CAimBE0F,CAAgBC,KAAMxE,GAEtBwE,KAAKxD,EAAI,EACTwD,KAAKvD,EAAI,EACTuD,KAAKtD,EAAI,EACTsD,KAAKrD,EAAI,EACTqD,KAAKrE,KAAO,IACd,C,mBCtnBO,SAASsE,EAAQ3G,GACtB,GAAIA,EAAK,OAWX,SAAeA,GACb,IAAK,IAAI4G,KAAOD,EAAQvG,UACtBJ,EAAI4G,GAAOD,EAAQvG,UAAUwG,GAE/B,OAAO5G,CACT,CAhBkB6G,CAAM7G,EACxB,C,iBA0BA2G,EAAQvG,UAAU0G,GAClBH,EAAQvG,UAAU2G,iBAAmB,SAASC,EAAOC,GAInD,OAHAP,KAAKQ,WAAaR,KAAKQ,YAAc,CAAC,GACrCR,KAAKQ,WAAW,IAAMF,GAASN,KAAKQ,WAAW,IAAMF,IAAU,IAC7DG,KAAKF,GACDP,IACT,EAYAC,EAAQvG,UAAUgH,KAAO,SAASJ,EAAOC,GACvC,SAASH,IACPJ,KAAKW,IAAIL,EAAOF,GAChBG,EAAGK,MAAMZ,KAAMa,UACjB,CAIA,OAFAT,EAAGG,GAAKA,EACRP,KAAKI,GAAGE,EAAOF,GACRJ,IACT,EAYAC,EAAQvG,UAAUiH,IAClBV,EAAQvG,UAAUoH,eAClBb,EAAQvG,UAAUqH,mBAClBd,EAAQvG,UAAUsH,oBAAsB,SAASV,EAAOC,GAItD,GAHAP,KAAKQ,WAAaR,KAAKQ,YAAc,CAAC,EAGlC,GAAKK,UAAUI,OAEjB,OADAjB,KAAKQ,WAAa,CAAC,EACZR,KAIT,IAUIkB,EAVAC,EAAYnB,KAAKQ,WAAW,IAAMF,GACtC,IAAKa,EAAW,OAAOnB,KAGvB,GAAI,GAAKa,UAAUI,OAEjB,cADOjB,KAAKQ,WAAW,IAAMF,GACtBN,KAKT,IAAK,IAAItE,EAAI,EAAGA,EAAIyF,EAAUF,OAAQvF,IAEpC,IADAwF,EAAKC,EAAUzF,MACJ6E,GAAMW,EAAGX,KAAOA,EAAI,CAC7BY,EAAUC,OAAO1F,EAAG,GACpB,KACF,CASF,OAJyB,IAArByF,EAAUF,eACLjB,KAAKQ,WAAW,IAAMF,GAGxBN,IACT,EAUAC,EAAQvG,UAAU2H,KAAO,SAASf,GAChCN,KAAKQ,WAAaR,KAAKQ,YAAc,CAAC,EAKtC,IAHA,IAAIc,EAAO,IAAIC,MAAMV,UAAUI,OAAS,GACpCE,EAAYnB,KAAKQ,WAAW,IAAMF,GAE7B5E,EAAI,EAAGA,EAAImF,UAAUI,OAAQvF,IACpC4F,EAAK5F,EAAI,GAAKmF,UAAUnF,GAG1B,GAAIyF,EAEG,CAAIzF,EAAI,EAAb,IAAK,IAAW8F,GADhBL,EAAYA,EAAUM,MAAM,IACIR,OAAQvF,EAAI8F,IAAO9F,EACjDyF,EAAUzF,GAAGkF,MAAMZ,KAAMsB,EADKL,CAKlC,OAAOjB,IACT,EAGAC,EAAQvG,UAAUgI,aAAezB,EAAQvG,UAAU2H,KAUnDpB,EAAQvG,UAAUiI,UAAY,SAASrB,GAErC,OADAN,KAAKQ,WAAaR,KAAKQ,YAAc,CAAC,EAC/BR,KAAKQ,WAAW,IAAMF,IAAU,EACzC,EAUAL,EAAQvG,UAAUkI,aAAe,SAAStB,GACxC,QAAUN,KAAK2B,UAAUrB,GAAOW,MAClC,C,yJCxKA,MAAMY,EAA+C,mBAAhBC,YAM/BC,EAAWC,OAAOtI,UAAUqI,SAC5BE,EAAiC,mBAATC,MACT,oBAATA,MACoB,6BAAxBH,EAASI,KAAKD,MAChBE,EAAiC,mBAATC,MACT,oBAATA,MACoB,6BAAxBN,EAASI,KAAKE,MAMf,SAASC,EAAShJ,GACrB,OAASuI,IAA0BvI,aAAewI,aAlBtCxI,IACyB,mBAAvBwI,YAAYS,OACpBT,YAAYS,OAAOjJ,GACnBA,EAAIkJ,kBAAkBV,YAeqCS,CAAOjJ,KACnE2I,GAAkB3I,aAAe4I,MACjCE,GAAkB9I,aAAe+I,IAC1C,CACO,SAASI,EAAUnJ,EAAKoJ,GAC3B,IAAKpJ,GAAsB,iBAARA,EACf,OAAO,EAEX,GAAIiI,MAAMoB,QAAQrJ,GAAM,CACpB,IAAK,IAAIoC,EAAI,EAAGkH,EAAItJ,EAAI2H,OAAQvF,EAAIkH,EAAGlH,IACnC,GAAI+G,EAAUnJ,EAAIoC,IACd,OAAO,EAGf,OAAO,CACX,CACA,GAAI4G,EAAShJ,GACT,OAAO,EAEX,GAAIA,EAAIoJ,QACkB,mBAAfpJ,EAAIoJ,QACU,IAArB7B,UAAUI,OACV,OAAOwB,EAAUnJ,EAAIoJ,UAAU,GAEnC,IAAK,MAAMxC,KAAO5G,EACd,GAAI0I,OAAOtI,UAAUmJ,eAAeV,KAAK7I,EAAK4G,IAAQuC,EAAUnJ,EAAI4G,IAChE,OAAO,EAGf,OAAO,CACX,CCzCO,SAAS4C,EAAkBC,GAC9B,MAAMC,EAAU,GACVC,EAAaF,EAAO9H,KACpBiI,EAAOH,EAGb,OAFAG,EAAKjI,KAAOkI,EAAmBF,EAAYD,GAC3CE,EAAKE,YAAcJ,EAAQ/B,OACpB,CAAE8B,OAAQG,EAAMF,QAASA,EACpC,CACA,SAASG,EAAmBlI,EAAM+H,GAC9B,IAAK/H,EACD,OAAOA,EACX,GAAIqH,EAASrH,GAAO,CAChB,MAAMoI,EAAc,CAAEC,cAAc,EAAMC,IAAKP,EAAQ/B,QAEvD,OADA+B,EAAQvC,KAAKxF,GACNoI,CACX,CACK,GAAI9B,MAAMoB,QAAQ1H,GAAO,CAC1B,MAAMuI,EAAU,IAAIjC,MAAMtG,EAAKgG,QAC/B,IAAK,IAAIvF,EAAI,EAAGA,EAAIT,EAAKgG,OAAQvF,IAC7B8H,EAAQ9H,GAAKyH,EAAmBlI,EAAKS,GAAIsH,GAE7C,OAAOQ,CACX,CACK,GAAoB,iBAATvI,KAAuBA,aAAgBwI,MAAO,CAC1D,MAAMD,EAAU,CAAC,EACjB,IAAK,MAAMtD,KAAOjF,EACV+G,OAAOtI,UAAUmJ,eAAeV,KAAKlH,EAAMiF,KAC3CsD,EAAQtD,GAAOiD,EAAmBlI,EAAKiF,GAAM8C,IAGrD,OAAOQ,CACX,CACA,OAAOvI,CACX,CASO,SAASyI,EAAkBX,EAAQC,GAGtC,OAFAD,EAAO9H,KAAO0I,EAAmBZ,EAAO9H,KAAM+H,UACvCD,EAAOK,YACPL,CACX,CACA,SAASY,EAAmB1I,EAAM+H,GAC9B,IAAK/H,EACD,OAAOA,EACX,GAAIA,IAA8B,IAAtBA,EAAKqI,aAAuB,CAIpC,GAHyC,iBAAbrI,EAAKsI,KAC7BtI,EAAKsI,KAAO,GACZtI,EAAKsI,IAAMP,EAAQ/B,OAEnB,OAAO+B,EAAQ/H,EAAKsI,KAGpB,MAAM,IAAI7I,MAAM,sBAExB,CACK,GAAI6G,MAAMoB,QAAQ1H,GACnB,IAAK,IAAIS,EAAI,EAAGA,EAAIT,EAAKgG,OAAQvF,IAC7BT,EAAKS,GAAKiI,EAAmB1I,EAAKS,GAAIsH,QAGzC,GAAoB,iBAAT/H,EACZ,IAAK,MAAMiF,KAAOjF,EACV+G,OAAOtI,UAAUmJ,eAAeV,KAAKlH,EAAMiF,KAC3CjF,EAAKiF,GAAOyD,EAAmB1I,EAAKiF,GAAM8C,IAItD,OAAO/H,CACX,CC5EA,MAAM2I,EAAkB,CACpB,UACA,gBACA,aACA,gBACA,cACA,kBAOSC,EAAW,EACjB,IAAIC,GACX,SAAWA,GACPA,EAAWA,EAAoB,QAAI,GAAK,UACxCA,EAAWA,EAAuB,WAAI,GAAK,aAC3CA,EAAWA,EAAkB,MAAI,GAAK,QACtCA,EAAWA,EAAgB,IAAI,GAAK,MACpCA,EAAWA,EAA0B,cAAI,GAAK,gBAC9CA,EAAWA,EAAyB,aAAI,GAAK,eAC7CA,EAAWA,EAAuB,WAAI,GAAK,YAC9C,CARD,CAQGA,IAAeA,EAAa,CAAC,IAIzB,MAAMC,EAMTtK,WAAAA,CAAYuK,GACRhE,KAAKgE,SAAWA,CACpB,CAOAC,MAAAA,CAAO3K,GACH,OAAIA,EAAI4K,OAASJ,EAAWK,OAAS7K,EAAI4K,OAASJ,EAAWM,MACrD3B,EAAUnJ,GAWX,CAAC0G,KAAKqE,eAAe/K,IAVb0G,KAAKsE,eAAe,CACvBJ,KAAM5K,EAAI4K,OAASJ,EAAWK,MACxBL,EAAWS,aACXT,EAAWU,WACjBC,IAAKnL,EAAImL,IACTxJ,KAAM3B,EAAI2B,KACVyJ,GAAIpL,EAAIoL,IAKxB,CAIAL,cAAAA,CAAe/K,GAEX,IAAIqL,EAAM,GAAKrL,EAAI4K,KAmBnB,OAjBI5K,EAAI4K,OAASJ,EAAWS,cACxBjL,EAAI4K,OAASJ,EAAWU,aACxBG,GAAOrL,EAAI8J,YAAc,KAIzB9J,EAAImL,KAAO,MAAQnL,EAAImL,MACvBE,GAAOrL,EAAImL,IAAM,KAGjB,MAAQnL,EAAIoL,KACZC,GAAOrL,EAAIoL,IAGX,MAAQpL,EAAI2B,OACZ0J,GAAOC,KAAKC,UAAUvL,EAAI2B,KAAM+E,KAAKgE,WAElCW,CACX,CAMAL,cAAAA,CAAehL,GACX,MAAMwL,EAAiBhC,EAAkBxJ,GACnC4J,EAAOlD,KAAKqE,eAAeS,EAAe/B,QAC1CC,EAAU8B,EAAe9B,QAE/B,OADAA,EAAQ+B,QAAQ7B,GACTF,CACX,EAGJ,SAASgC,EAASC,GACd,MAAiD,oBAA1CjD,OAAOtI,UAAUqI,SAASI,KAAK8C,EAC1C,CAMO,MAAMC,UAAgBjF,EAAAA,EAMzBxG,WAAAA,CAAY0L,GACRC,QACApF,KAAKmF,QAAUA,CACnB,CAMAE,GAAAA,CAAI/L,GACA,IAAIyJ,EACJ,GAAmB,iBAARzJ,EAAkB,CACzB,GAAI0G,KAAKsF,cACL,MAAM,IAAI5K,MAAM,mDAEpBqI,EAAS/C,KAAKuF,aAAajM,GAC3B,MAAMkM,EAAgBzC,EAAOmB,OAASJ,EAAWS,aAC7CiB,GAAiBzC,EAAOmB,OAASJ,EAAWU,YAC5CzB,EAAOmB,KAAOsB,EAAgB1B,EAAWK,MAAQL,EAAWM,IAE5DpE,KAAKsF,cAAgB,IAAIG,EAAoB1C,GAElB,IAAvBA,EAAOK,aACPgC,MAAM1D,aAAa,UAAWqB,IAKlCqC,MAAM1D,aAAa,UAAWqB,EAEtC,KACK,KAAIT,EAAShJ,KAAQA,EAAIoM,OAe1B,MAAM,IAAIhL,MAAM,iBAAmBpB,GAbnC,IAAK0G,KAAKsF,cACN,MAAM,IAAI5K,MAAM,oDAGhBqI,EAAS/C,KAAKsF,cAAcK,eAAerM,GACvCyJ,IAEA/C,KAAKsF,cAAgB,KACrBF,MAAM1D,aAAa,UAAWqB,GAM1C,CACJ,CAOAwC,YAAAA,CAAaZ,GACT,IAAIjJ,EAAI,EAER,MAAM+B,EAAI,CACNyG,KAAM0B,OAAOjB,EAAIkB,OAAO,KAE5B,QAA2BC,IAAvBhC,EAAWrG,EAAEyG,MACb,MAAM,IAAIxJ,MAAM,uBAAyB+C,EAAEyG,MAG/C,GAAIzG,EAAEyG,OAASJ,EAAWS,cACtB9G,EAAEyG,OAASJ,EAAWU,WAAY,CAClC,MAAMuB,EAAQrK,EAAI,EAClB,KAA2B,MAApBiJ,EAAIkB,SAASnK,IAAcA,GAAKiJ,EAAI1D,SAC3C,MAAM+E,EAAMrB,EAAIsB,UAAUF,EAAOrK,GACjC,GAAIsK,GAAOJ,OAAOI,IAA0B,MAAlBrB,EAAIkB,OAAOnK,GACjC,MAAM,IAAIhB,MAAM,uBAEpB+C,EAAE2F,YAAcwC,OAAOI,EAC3B,CAEA,GAAI,MAAQrB,EAAIkB,OAAOnK,EAAI,GAAI,CAC3B,MAAMqK,EAAQrK,EAAI,EAClB,OAASA,GAAG,CAER,GAAI,MADMiJ,EAAIkB,OAAOnK,GAEjB,MACJ,GAAIA,IAAMiJ,EAAI1D,OACV,KACR,CACAxD,EAAEgH,IAAME,EAAIsB,UAAUF,EAAOrK,EACjC,MAEI+B,EAAEgH,IAAM,IAGZ,MAAM9I,EAAOgJ,EAAIkB,OAAOnK,EAAI,GAC5B,GAAI,KAAOC,GAAQiK,OAAOjK,IAASA,EAAM,CACrC,MAAMoK,EAAQrK,EAAI,EAClB,OAASA,GAAG,CACR,MAAMwK,EAAIvB,EAAIkB,OAAOnK,GACrB,GAAI,MAAQwK,GAAKN,OAAOM,IAAMA,EAAG,GAC3BxK,EACF,KACJ,CACA,GAAIA,IAAMiJ,EAAI1D,OACV,KACR,CACAxD,EAAEiH,GAAKkB,OAAOjB,EAAIsB,UAAUF,EAAOrK,EAAI,GAC3C,CAEA,GAAIiJ,EAAIkB,SAASnK,GAAI,CACjB,MAAMyK,EAAUnG,KAAKoG,SAASzB,EAAI0B,OAAO3K,IACzC,IAAIwJ,EAAQoB,eAAe7I,EAAEyG,KAAMiC,GAI/B,MAAM,IAAIzL,MAAM,mBAHhB+C,EAAExC,KAAOkL,CAKjB,CACA,OAAO1I,CACX,CACA2I,QAAAA,CAASzB,GACL,IACI,OAAOC,KAAK2B,MAAM5B,EAAK3E,KAAKmF,QAChC,CACA,MAAO1K,GACH,OAAO,CACX,CACJ,CACA,qBAAO6L,CAAepC,EAAMiC,GACxB,OAAQjC,GACJ,KAAKJ,EAAW0C,QACZ,OAAOxB,EAASmB,GACpB,KAAKrC,EAAW2C,WACZ,YAAmBX,IAAZK,EACX,KAAKrC,EAAW4C,cACZ,MAA0B,iBAAZP,GAAwBnB,EAASmB,GACnD,KAAKrC,EAAWK,MAChB,KAAKL,EAAWS,aACZ,OAAQhD,MAAMoB,QAAQwD,KACK,iBAAfA,EAAQ,IACW,iBAAfA,EAAQ,KAC6B,IAAzCvC,EAAgB+C,QAAQR,EAAQ,KAChD,KAAKrC,EAAWM,IAChB,KAAKN,EAAWU,WACZ,OAAOjD,MAAMoB,QAAQwD,GAEjC,CAIAS,OAAAA,GACQ5G,KAAKsF,gBACLtF,KAAKsF,cAAcuB,yBACnB7G,KAAKsF,cAAgB,KAE7B,EAUJ,MAAMG,EACFhM,WAAAA,CAAYsJ,GACR/C,KAAK+C,OAASA,EACd/C,KAAKgD,QAAU,GACfhD,KAAK8G,UAAY/D,CACrB,CASA4C,cAAAA,CAAeoB,GAEX,GADA/G,KAAKgD,QAAQvC,KAAKsG,GACd/G,KAAKgD,QAAQ/B,SAAWjB,KAAK8G,UAAU1D,YAAa,CAEpD,MAAML,EAASW,EAAkB1D,KAAK8G,UAAW9G,KAAKgD,SAEtD,OADAhD,KAAK6G,yBACE9D,CACX,CACA,OAAO,IACX,CAIA8D,sBAAAA,GACI7G,KAAK8G,UAAY,KACjB9G,KAAKgD,QAAU,EACnB,ECrTG,SAAS5C,EAAG9G,EAAK0N,EAAIzG,GAExB,OADAjH,EAAI8G,GAAG4G,EAAIzG,GACJ,WACHjH,EAAIqH,IAAIqG,EAAIzG,EAChB,CACJ,CCEA,MAAMqD,EAAkB5B,OAAOiF,OAAO,CAClCC,QAAS,EACTC,cAAe,EACfC,WAAY,EACZC,cAAe,EAEfC,YAAa,EACbxG,eAAgB,IA0Bb,MAAMyG,UAAetH,EAAAA,EAIxBxG,WAAAA,CAAY+N,EAAI/C,EAAKgD,GACjBrC,QAeApF,KAAK0H,WAAY,EAKjB1H,KAAK2H,WAAY,EAIjB3H,KAAK4H,cAAgB,GAIrB5H,KAAK6H,WAAa,GAOlB7H,KAAK8H,OAAS,GAKd9H,KAAK+H,UAAY,EACjB/H,KAAKgI,IAAM,EAwBXhI,KAAKiI,KAAO,CAAC,EACbjI,KAAKkI,MAAQ,CAAC,EACdlI,KAAKwH,GAAKA,EACVxH,KAAKyE,IAAMA,EACPgD,GAAQA,EAAKU,OACbnI,KAAKmI,KAAOV,EAAKU,MAErBnI,KAAKoI,MAAQpG,OAAOqG,OAAO,CAAC,EAAGZ,GAC3BzH,KAAKwH,GAAGc,cACRtI,KAAKuI,MACb,CAeA,gBAAIC,GACA,OAAQxI,KAAK0H,SACjB,CAMAe,SAAAA,GACI,GAAIzI,KAAK0I,KACL,OACJ,MAAMlB,EAAKxH,KAAKwH,GAChBxH,KAAK0I,KAAO,CACRtI,EAAGoH,EAAI,OAAQxH,KAAK2I,OAAOC,KAAK5I,OAChCI,EAAGoH,EAAI,SAAUxH,KAAK6I,SAASD,KAAK5I,OACpCI,EAAGoH,EAAI,QAASxH,KAAK8I,QAAQF,KAAK5I,OAClCI,EAAGoH,EAAI,QAASxH,KAAK+I,QAAQH,KAAK5I,OAE1C,CAkBA,UAAIgJ,GACA,QAAShJ,KAAK0I,IAClB,CAWAxB,OAAAA,GACI,OAAIlH,KAAK0H,YAET1H,KAAKyI,YACAzI,KAAKwH,GAAkB,eACxBxH,KAAKwH,GAAGe,OACR,SAAWvI,KAAKwH,GAAGyB,aACnBjJ,KAAK2I,UALE3I,IAOf,CAIAuI,IAAAA,GACI,OAAOvI,KAAKkH,SAChB,CAgBAgC,IAAAA,GAAc,QAAAC,EAAAtI,UAAAI,OAANK,EAAI,IAAAC,MAAA4H,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJ9H,EAAI8H,GAAAvI,UAAAuI,GAGR,OAFA9H,EAAKyD,QAAQ,WACb/E,KAAKqB,KAAKT,MAAMZ,KAAMsB,GACftB,IACX,CAkBAqB,IAAAA,CAAK2F,GACD,IAAI7I,EAAID,EAAImL,EACZ,GAAIzF,EAAgBf,eAAemE,GAC/B,MAAM,IAAItM,MAAM,IAAMsM,EAAGjF,WAAa,8BACzC,QAAAuH,EAAAzI,UAAAI,OAJOK,EAAI,IAAAC,MAAA+H,EAAA,EAAAA,EAAA,KAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJjI,EAAIiI,EAAA,GAAA1I,UAAA0I,GAMZ,GADAjI,EAAKyD,QAAQiC,GACThH,KAAKoI,MAAMoB,UAAYxJ,KAAKkI,MAAMuB,YAAczJ,KAAKkI,MAAMwB,SAE3D,OADA1J,KAAK2J,YAAYrI,GACVtB,KAEX,MAAM+C,EAAS,CACXmB,KAAMJ,EAAWK,MACjBlJ,KAAMqG,EAEVyB,QAAiB,CAAC,GAGlB,GAFAA,EAAO6G,QAAQC,UAAmC,IAAxB7J,KAAKkI,MAAM2B,SAEjC,mBAAsBvI,EAAKA,EAAKL,OAAS,GAAI,CAC7C,MAAMyD,EAAK1E,KAAKgI,MACV8B,EAAMxI,EAAKyI,MACjB/J,KAAKgK,qBAAqBtF,EAAIoF,GAC9B/G,EAAO2B,GAAKA,CAChB,CACA,MAAMuF,EAAyG,QAAlF/L,EAA+B,QAAzBC,EAAK6B,KAAKwH,GAAG0C,cAA2B,IAAP/L,OAAgB,EAASA,EAAGgM,iBAA8B,IAAPjM,OAAgB,EAASA,EAAGkM,SAC7IC,EAAcrK,KAAK0H,aAAyC,QAAzB2B,EAAKrJ,KAAKwH,GAAG0C,cAA2B,IAAPb,OAAgB,EAASA,EAAGiB,mBAYtG,OAXsBtK,KAAKkI,MAAMwB,WAAaO,IAGrCI,GACLrK,KAAKuK,wBAAwBxH,GAC7B/C,KAAK+C,OAAOA,IAGZ/C,KAAK6H,WAAWpH,KAAKsC,IAEzB/C,KAAKkI,MAAQ,CAAC,EACPlI,IACX,CAIAgK,oBAAAA,CAAqBtF,EAAIoF,GAAK,IACtB3L,EADsBqM,EAAA,KAE1B,MAAMC,EAAwC,QAA7BtM,EAAK6B,KAAKkI,MAAMuC,eAA4B,IAAPtM,EAAgBA,EAAK6B,KAAKoI,MAAMsC,WACtF,QAAgB5E,IAAZ2E,EAEA,YADAzK,KAAKiI,KAAKvD,GAAMoF,GAIpB,MAAMa,EAAQ3K,KAAKwH,GAAGoD,cAAa,YACxB5K,KAAKiI,KAAKvD,GACjB,IAAK,IAAIhJ,EAAI,EAAGA,EAAIsE,KAAK6H,WAAW5G,OAAQvF,IACpCsE,KAAK6H,WAAWnM,GAAGgJ,KAAOA,GAC1B1E,KAAK6H,WAAWzG,OAAO1F,EAAG,GAGlCoO,EAAI3H,KAAKnC,KAAM,IAAItF,MAAM,2BAA2B,GACrD+P,GACGlK,EAAK,WAEPiK,EAAKhD,GAAGqD,eAAeF,GAAO,QAAAG,EAAAjK,UAAAI,OAFnBK,EAAI,IAAAC,MAAAuJ,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJzJ,EAAIyJ,GAAAlK,UAAAkK,GAGfjB,EAAIlJ,MAAM4J,EAAMlJ,EACpB,EACAf,EAAGyK,WAAY,EACfhL,KAAKiI,KAAKvD,GAAMnE,CACpB,CAiBA0K,WAAAA,CAAYjE,GAAa,QAAAkE,EAAArK,UAAAI,OAANK,EAAI,IAAAC,MAAA2J,EAAA,EAAAA,EAAA,KAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJ7J,EAAI6J,EAAA,GAAAtK,UAAAsK,GACnB,OAAO,IAAIC,SAAQ,CAACC,EAASC,KACzB,MAAM/K,EAAKA,CAACgL,EAAMC,IACPD,EAAOD,EAAOC,GAAQF,EAAQG,GAEzCjL,EAAGyK,WAAY,EACf1J,EAAKb,KAAKF,GACVP,KAAKqB,KAAK2F,KAAO1F,EAAK,GAE9B,CAMAqI,WAAAA,CAAYrI,GAAM,IAAAmK,EAAA,KACd,IAAI3B,EACiC,mBAA1BxI,EAAKA,EAAKL,OAAS,KAC1B6I,EAAMxI,EAAKyI,OAEf,MAAMhH,EAAS,CACX2B,GAAI1E,KAAK+H,YACT2D,SAAU,EACVC,SAAS,EACTrK,OACA4G,MAAOlG,OAAOqG,OAAO,CAAEoB,WAAW,GAAQzJ,KAAKkI,QAEnD5G,EAAKb,MAAK,SAACmL,GACP,GAAI7I,IAAW0I,EAAK3D,OAAO,GAEvB,OAGJ,GADyB,OAAR8D,EAET7I,EAAO2I,SAAWD,EAAKrD,MAAMoB,UAC7BiC,EAAK3D,OAAO+D,QACR/B,GACAA,EAAI8B,SAMZ,GADAH,EAAK3D,OAAO+D,QACR/B,EAAK,SAAAgC,EAAAjL,UAAAI,OAhBE8K,EAAY,IAAAxK,MAAAuK,EAAA,EAAAA,EAAA,KAAAE,EAAA,EAAAA,EAAAF,EAAAE,IAAZD,EAAYC,EAAA,GAAAnL,UAAAmL,GAiBnBlC,EAAI,QAASiC,EACjB,CAGJ,OADAhJ,EAAO4I,SAAU,EACVF,EAAKQ,aAChB,IACAjM,KAAK8H,OAAOrH,KAAKsC,GACjB/C,KAAKiM,aACT,CAOAA,WAAAA,GAA2B,IAAfC,EAAKrL,UAAAI,OAAA,QAAA6E,IAAAjF,UAAA,IAAAA,UAAA,GACb,IAAKb,KAAK0H,WAAoC,IAAvB1H,KAAK8H,OAAO7G,OAC/B,OAEJ,MAAM8B,EAAS/C,KAAK8H,OAAO,GACvB/E,EAAO4I,UAAYO,IAGvBnJ,EAAO4I,SAAU,EACjB5I,EAAO2I,WACP1L,KAAKkI,MAAQnF,EAAOmF,MACpBlI,KAAKqB,KAAKT,MAAMZ,KAAM+C,EAAOzB,MACjC,CAOAyB,MAAAA,CAAOA,GACHA,EAAO0B,IAAMzE,KAAKyE,IAClBzE,KAAKwH,GAAG2E,QAAQpJ,EACpB,CAMA4F,MAAAA,GAC4B,mBAAb3I,KAAKmI,KACZnI,KAAKmI,MAAMlN,IACP+E,KAAKoM,mBAAmBnR,EAAK,IAIjC+E,KAAKoM,mBAAmBpM,KAAKmI,KAErC,CAOAiE,kBAAAA,CAAmBnR,GACf+E,KAAK+C,OAAO,CACRmB,KAAMJ,EAAW0C,QACjBvL,KAAM+E,KAAKqM,KACLrK,OAAOqG,OAAO,CAAEiE,IAAKtM,KAAKqM,KAAME,OAAQvM,KAAKwM,aAAevR,GAC5DA,GAEd,CAOA6N,OAAAA,CAAQ8C,GACC5L,KAAK0H,WACN1H,KAAK0B,aAAa,gBAAiBkK,EAE3C,CAQA7C,OAAAA,CAAQ0D,EAAQC,GACZ1M,KAAK0H,WAAY,SACV1H,KAAK0E,GACZ1E,KAAK0B,aAAa,aAAc+K,EAAQC,GACxC1M,KAAK2M,YACT,CAOAA,UAAAA,GACI3K,OAAO4K,KAAK5M,KAAKiI,MAAM4E,SAASnI,IAE5B,IADmB1E,KAAK6H,WAAWiF,MAAM/J,GAAWgK,OAAOhK,EAAO2B,MAAQA,IACzD,CAEb,MAAMoF,EAAM9J,KAAKiI,KAAKvD,UACf1E,KAAKiI,KAAKvD,GACboF,EAAIkB,WACJlB,EAAI3H,KAAKnC,KAAM,IAAItF,MAAM,gCAEjC,IAER,CAOAmO,QAAAA,CAAS9F,GAEL,GADsBA,EAAO0B,MAAQzE,KAAKyE,IAG1C,OAAQ1B,EAAOmB,MACX,KAAKJ,EAAW0C,QACRzD,EAAO9H,MAAQ8H,EAAO9H,KAAK+R,IAC3BhN,KAAKiN,UAAUlK,EAAO9H,KAAK+R,IAAKjK,EAAO9H,KAAKqR,KAG5CtM,KAAK0B,aAAa,gBAAiB,IAAIhH,MAAM,8LAEjD,MACJ,KAAKoJ,EAAWK,MAChB,KAAKL,EAAWS,aACZvE,KAAKkN,QAAQnK,GACb,MACJ,KAAKe,EAAWM,IAChB,KAAKN,EAAWU,WACZxE,KAAKmN,MAAMpK,GACX,MACJ,KAAKe,EAAW2C,WACZzG,KAAKoN,eACL,MACJ,KAAKtJ,EAAW4C,cACZ1G,KAAK4G,UACL,MAAMgF,EAAM,IAAIlR,MAAMqI,EAAO9H,KAAKoS,SAElCzB,EAAI3Q,KAAO8H,EAAO9H,KAAKA,KACvB+E,KAAK0B,aAAa,gBAAiBkK,GAG/C,CAOAsB,OAAAA,CAAQnK,GACJ,MAAMzB,EAAOyB,EAAO9H,MAAQ,GACxB,MAAQ8H,EAAO2B,IACfpD,EAAKb,KAAKT,KAAK8J,IAAI/G,EAAO2B,KAE1B1E,KAAK0H,UACL1H,KAAKsN,UAAUhM,GAGftB,KAAK4H,cAAcnH,KAAKuB,OAAOiF,OAAO3F,GAE9C,CACAgM,SAAAA,CAAUhM,GACN,GAAItB,KAAKuN,eAAiBvN,KAAKuN,cAActM,OAAQ,CACjD,MAAMU,EAAY3B,KAAKuN,cAAc9L,QACrC,IAAK,MAAM+L,KAAY7L,EACnB6L,EAAS5M,MAAMZ,KAAMsB,EAE7B,CACA8D,MAAM/D,KAAKT,MAAMZ,KAAMsB,GACnBtB,KAAKqM,MAAQ/K,EAAKL,QAA2C,iBAA1BK,EAAKA,EAAKL,OAAS,KACtDjB,KAAKwM,YAAclL,EAAKA,EAAKL,OAAS,GAE9C,CAMA6I,GAAAA,CAAIpF,GACA,MAAM+I,EAAOzN,KACb,IAAI0N,GAAO,EACX,OAAO,WAEH,IAAIA,EAAJ,CAEAA,GAAO,EAAK,QAAAC,EAAA9M,UAAAI,OAJIK,EAAI,IAAAC,MAAAoM,GAAAC,EAAA,EAAAA,EAAAD,EAAAC,IAAJtM,EAAIsM,GAAA/M,UAAA+M,GAKpBH,EAAK1K,OAAO,CACRmB,KAAMJ,EAAWM,IACjBM,GAAIA,EACJzJ,KAAMqG,GALA,CAOd,CACJ,CAOA6L,KAAAA,CAAMpK,GACF,MAAM+G,EAAM9J,KAAKiI,KAAKlF,EAAO2B,IACV,mBAARoF,WAGJ9J,KAAKiI,KAAKlF,EAAO2B,IAEpBoF,EAAIkB,WACJjI,EAAO9H,KAAK8J,QAAQ,MAGxB+E,EAAIlJ,MAAMZ,KAAM+C,EAAO9H,MAC3B,CAMAgS,SAAAA,CAAUvI,EAAI4H,GACVtM,KAAK0E,GAAKA,EACV1E,KAAK2H,UAAY2E,GAAOtM,KAAKqM,OAASC,EACtCtM,KAAKqM,KAAOC,EACZtM,KAAK0H,WAAY,EACjB1H,KAAK6N,eACL7N,KAAK0B,aAAa,WAClB1B,KAAKiM,aAAY,EACrB,CAMA4B,YAAAA,GACI7N,KAAK4H,cAAciF,SAASvL,GAAStB,KAAKsN,UAAUhM,KACpDtB,KAAK4H,cAAgB,GACrB5H,KAAK6H,WAAWgF,SAAS9J,IACrB/C,KAAKuK,wBAAwBxH,GAC7B/C,KAAK+C,OAAOA,EAAO,IAEvB/C,KAAK6H,WAAa,EACtB,CAMAuF,YAAAA,GACIpN,KAAK4G,UACL5G,KAAK+I,QAAQ,uBACjB,CAQAnC,OAAAA,GACQ5G,KAAK0I,OAEL1I,KAAK0I,KAAKmE,SAASiB,GAAeA,MAClC9N,KAAK0I,UAAO5C,GAEhB9F,KAAKwH,GAAa,SAAExH,KACxB,CAiBAoH,UAAAA,GAUI,OATIpH,KAAK0H,WACL1H,KAAK+C,OAAO,CAAEmB,KAAMJ,EAAW2C,aAGnCzG,KAAK4G,UACD5G,KAAK0H,WAEL1H,KAAK+I,QAAQ,wBAEV/I,IACX,CAMA+N,KAAAA,GACI,OAAO/N,KAAKoH,YAChB,CAUAyC,QAAAA,CAASA,GAEL,OADA7J,KAAKkI,MAAM2B,SAAWA,EACf7J,IACX,CAUA,YAAI0J,GAEA,OADA1J,KAAKkI,MAAMwB,UAAW,EACf1J,IACX,CAcAyK,OAAAA,CAAQA,GAEJ,OADAzK,KAAKkI,MAAMuC,QAAUA,EACdzK,IACX,CAYAgO,KAAAA,CAAMR,GAGF,OAFAxN,KAAKuN,cAAgBvN,KAAKuN,eAAiB,GAC3CvN,KAAKuN,cAAc9M,KAAK+M,GACjBxN,IACX,CAYAiO,UAAAA,CAAWT,GAGP,OAFAxN,KAAKuN,cAAgBvN,KAAKuN,eAAiB,GAC3CvN,KAAKuN,cAAcxI,QAAQyI,GACpBxN,IACX,CAmBAkO,MAAAA,CAAOV,GACH,IAAKxN,KAAKuN,cACN,OAAOvN,KAEX,GAAIwN,EAAU,CACV,MAAM7L,EAAY3B,KAAKuN,cACvB,IAAK,IAAI7R,EAAI,EAAGA,EAAIiG,EAAUV,OAAQvF,IAClC,GAAI8R,IAAa7L,EAAUjG,GAEvB,OADAiG,EAAUP,OAAO1F,EAAG,GACbsE,IAGnB,MAEIA,KAAKuN,cAAgB,GAEzB,OAAOvN,IACX,CAKAmO,YAAAA,GACI,OAAOnO,KAAKuN,eAAiB,EACjC,CAcAa,aAAAA,CAAcZ,GAGV,OAFAxN,KAAKqO,sBAAwBrO,KAAKqO,uBAAyB,GAC3DrO,KAAKqO,sBAAsB5N,KAAK+M,GACzBxN,IACX,CAcAsO,kBAAAA,CAAmBd,GAGf,OAFAxN,KAAKqO,sBAAwBrO,KAAKqO,uBAAyB,GAC3DrO,KAAKqO,sBAAsBtJ,QAAQyI,GAC5BxN,IACX,CAmBAuO,cAAAA,CAAef,GACX,IAAKxN,KAAKqO,sBACN,OAAOrO,KAEX,GAAIwN,EAAU,CACV,MAAM7L,EAAY3B,KAAKqO,sBACvB,IAAK,IAAI3S,EAAI,EAAGA,EAAIiG,EAAUV,OAAQvF,IAClC,GAAI8R,IAAa7L,EAAUjG,GAEvB,OADAiG,EAAUP,OAAO1F,EAAG,GACbsE,IAGnB,MAEIA,KAAKqO,sBAAwB,GAEjC,OAAOrO,IACX,CAKAwO,oBAAAA,GACI,OAAOxO,KAAKqO,uBAAyB,EACzC,CAQA9D,uBAAAA,CAAwBxH,GACpB,GAAI/C,KAAKqO,uBAAyBrO,KAAKqO,sBAAsBpN,OAAQ,CACjE,MAAMU,EAAY3B,KAAKqO,sBAAsB5M,QAC7C,IAAK,MAAM+L,KAAY7L,EACnB6L,EAAS5M,MAAMZ,KAAM+C,EAAO9H,KAEpC,CACJ,ECr2BG,SAASwT,EAAQhH,GACpBA,EAAOA,GAAQ,CAAC,EAChBzH,KAAK0O,GAAKjH,EAAKkH,KAAO,IACtB3O,KAAK4O,IAAMnH,EAAKmH,KAAO,IACvB5O,KAAK6O,OAASpH,EAAKoH,QAAU,EAC7B7O,KAAK8O,OAASrH,EAAKqH,OAAS,GAAKrH,EAAKqH,QAAU,EAAIrH,EAAKqH,OAAS,EAClE9O,KAAK+O,SAAW,CACpB,CAOAN,EAAQ/U,UAAUsV,SAAW,WACzB,IAAIN,EAAK1O,KAAK0O,GAAKO,KAAKC,IAAIlP,KAAK6O,OAAQ7O,KAAK+O,YAC9C,GAAI/O,KAAK8O,OAAQ,CACb,IAAIK,EAAOF,KAAKG,SACZC,EAAYJ,KAAKK,MAAMH,EAAOnP,KAAK8O,OAASJ,GAChDA,EAA8B,EAAxBO,KAAKK,MAAa,GAAPH,GAAwCT,EAAKW,EAAtBX,EAAKW,CACjD,CACA,OAAgC,EAAzBJ,KAAKN,IAAID,EAAI1O,KAAK4O,IAC7B,EAMAH,EAAQ/U,UAAU6V,MAAQ,WACtBvP,KAAK+O,SAAW,CACpB,EAMAN,EAAQ/U,UAAU8V,OAAS,SAAUb,GACjC3O,KAAK0O,GAAKC,CACd,EAMAF,EAAQ/U,UAAU+V,OAAS,SAAUb,GACjC5O,KAAK4O,IAAMA,CACf,EAMAH,EAAQ/U,UAAUgW,UAAY,SAAUZ,GACpC9O,KAAK8O,OAASA,CAClB,EC3DO,MAAMa,UAAgB1P,EAAAA,EACzBxG,WAAAA,CAAYmW,EAAKnI,GACb,IAAItJ,EACJiH,QACApF,KAAK6P,KAAO,CAAC,EACb7P,KAAK0I,KAAO,GACRkH,GAAO,iBAAoBA,IAC3BnI,EAAOmI,EACPA,OAAM9J,IAEV2B,EAAOA,GAAQ,CAAC,GACXqI,KAAOrI,EAAKqI,MAAQ,aACzB9P,KAAKyH,KAAOA,GACZsI,EAAAA,EAAAA,IAAsB/P,KAAMyH,GAC5BzH,KAAKgQ,cAAmC,IAAtBvI,EAAKuI,cACvBhQ,KAAKiQ,qBAAqBxI,EAAKwI,sBAAwBC,KACvDlQ,KAAKmQ,kBAAkB1I,EAAK0I,mBAAqB,KACjDnQ,KAAKoQ,qBAAqB3I,EAAK2I,sBAAwB,KACvDpQ,KAAKqQ,oBAAwD,QAAnClS,EAAKsJ,EAAK4I,2BAAwC,IAAPlS,EAAgBA,EAAK,IAC1F6B,KAAKsQ,QAAU,IAAI7B,EAAQ,CACvBE,IAAK3O,KAAKmQ,oBACVvB,IAAK5O,KAAKoQ,uBACVtB,OAAQ9O,KAAKqQ,wBAEjBrQ,KAAKyK,QAAQ,MAAQhD,EAAKgD,QAAU,IAAQhD,EAAKgD,SACjDzK,KAAKiJ,YAAc,SACnBjJ,KAAK4P,IAAMA,EACX,MAAMW,EAAU9I,EAAK+I,QAAUA,EAC/BxQ,KAAKyQ,QAAU,IAAIF,EAAQxM,QAC3B/D,KAAK0Q,QAAU,IAAIH,EAAQrL,QAC3BlF,KAAKsI,cAAoC,IAArBb,EAAKkJ,YACrB3Q,KAAKsI,cACLtI,KAAKuI,MACb,CACAyH,YAAAA,CAAaY,GACT,OAAK/P,UAAUI,QAEfjB,KAAK6Q,gBAAkBD,EAClBA,IACD5Q,KAAK8Q,eAAgB,GAElB9Q,MALIA,KAAK6Q,aAMpB,CACAZ,oBAAAA,CAAqBW,GACjB,YAAU9K,IAAN8K,EACO5Q,KAAK+Q,uBAChB/Q,KAAK+Q,sBAAwBH,EACtB5Q,KACX,CACAmQ,iBAAAA,CAAkBS,GACd,IAAIzS,EACJ,YAAU2H,IAAN8K,EACO5Q,KAAKgR,oBAChBhR,KAAKgR,mBAAqBJ,EACF,QAAvBzS,EAAK6B,KAAKsQ,eAA4B,IAAPnS,GAAyBA,EAAGqR,OAAOoB,GAC5D5Q,KACX,CACAqQ,mBAAAA,CAAoBO,GAChB,IAAIzS,EACJ,YAAU2H,IAAN8K,EACO5Q,KAAKiR,sBAChBjR,KAAKiR,qBAAuBL,EACJ,QAAvBzS,EAAK6B,KAAKsQ,eAA4B,IAAPnS,GAAyBA,EAAGuR,UAAUkB,GAC/D5Q,KACX,CACAoQ,oBAAAA,CAAqBQ,GACjB,IAAIzS,EACJ,YAAU2H,IAAN8K,EACO5Q,KAAKkR,uBAChBlR,KAAKkR,sBAAwBN,EACL,QAAvBzS,EAAK6B,KAAKsQ,eAA4B,IAAPnS,GAAyBA,EAAGsR,OAAOmB,GAC5D5Q,KACX,CACAyK,OAAAA,CAAQmG,GACJ,OAAK/P,UAAUI,QAEfjB,KAAKmR,SAAWP,EACT5Q,MAFIA,KAAKmR,QAGpB,CAOAC,oBAAAA,IAESpR,KAAKqR,eACNrR,KAAK6Q,eACqB,IAA1B7Q,KAAKsQ,QAAQvB,UAEb/O,KAAKsR,WAEb,CAQA/I,IAAAA,CAAKhI,GACD,IAAKP,KAAKiJ,YAAYtC,QAAQ,QAC1B,OAAO3G,KACXA,KAAKkK,OAAS,IAAIqH,EAAAA,GAAOvR,KAAK4P,IAAK5P,KAAKyH,MACxC,MAAM+J,EAASxR,KAAKkK,OACduD,EAAOzN,KACbA,KAAKiJ,YAAc,UACnBjJ,KAAK8Q,eAAgB,EAErB,MAAMW,EAAiBrR,EAAGoR,EAAQ,QAAQ,WACtC/D,EAAK9E,SACLpI,GAAMA,GACV,IACMmR,EAAW9F,IACb5L,KAAK2R,UACL3R,KAAKiJ,YAAc,SACnBjJ,KAAK0B,aAAa,QAASkK,GACvBrL,EACAA,EAAGqL,GAIH5L,KAAKoR,sBACT,EAGEQ,EAAWxR,EAAGoR,EAAQ,QAASE,GACrC,IAAI,IAAU1R,KAAKmR,SAAU,CACzB,MAAM1G,EAAUzK,KAAKmR,SAEfxG,EAAQ3K,KAAK4K,cAAa,KAC5B6G,IACAC,EAAQ,IAAIhX,MAAM,YAClB8W,EAAOzD,OAAO,GACftD,GACCzK,KAAKyH,KAAKoK,WACVlH,EAAMmH,QAEV9R,KAAK0I,KAAKjI,MAAK,KACXT,KAAK6K,eAAeF,EAAM,GAElC,CAGA,OAFA3K,KAAK0I,KAAKjI,KAAKgR,GACfzR,KAAK0I,KAAKjI,KAAKmR,GACR5R,IACX,CAOAkH,OAAAA,CAAQ3G,GACJ,OAAOP,KAAKuI,KAAKhI,EACrB,CAMAoI,MAAAA,GAEI3I,KAAK2R,UAEL3R,KAAKiJ,YAAc,OACnBjJ,KAAK0B,aAAa,QAElB,MAAM8P,EAASxR,KAAKkK,OACpBlK,KAAK0I,KAAKjI,KAAKL,EAAGoR,EAAQ,OAAQxR,KAAK+R,OAAOnJ,KAAK5I,OAAQI,EAAGoR,EAAQ,OAAQxR,KAAKgS,OAAOpJ,KAAK5I,OAAQI,EAAGoR,EAAQ,QAASxR,KAAK8I,QAAQF,KAAK5I,OAAQI,EAAGoR,EAAQ,QAASxR,KAAK+I,QAAQH,KAAK5I,OAE3LI,EAAGJ,KAAK0Q,QAAS,UAAW1Q,KAAKiS,UAAUrJ,KAAK5I,OACpD,CAMA+R,MAAAA,GACI/R,KAAK0B,aAAa,OACtB,CAMAsQ,MAAAA,CAAO/W,GACH,IACI+E,KAAK0Q,QAAQrL,IAAIpK,EACrB,CACA,MAAOR,GACHuF,KAAK+I,QAAQ,cAAetO,EAChC,CACJ,CAMAwX,SAAAA,CAAUlP,IAENmP,EAAAA,EAAAA,KAAS,KACLlS,KAAK0B,aAAa,SAAUqB,EAAO,GACpC/C,KAAK4K,aACZ,CAMA9B,OAAAA,CAAQ8C,GACJ5L,KAAK0B,aAAa,QAASkK,EAC/B,CAOA4F,MAAAA,CAAO/M,EAAKgD,GACR,IAAI+J,EAASxR,KAAK6P,KAAKpL,GAQvB,OAPK+M,EAIIxR,KAAKsI,eAAiBkJ,EAAOxI,QAClCwI,EAAOtK,WAJPsK,EAAS,IAAIjK,EAAOvH,KAAMyE,EAAKgD,GAC/BzH,KAAK6P,KAAKpL,GAAO+M,GAKdA,CACX,CAOAW,QAAAA,CAASX,GACL,MAAM3B,EAAO7N,OAAO4K,KAAK5M,KAAK6P,MAC9B,IAAK,MAAMpL,KAAOoL,EAAM,CAEpB,GADe7P,KAAK6P,KAAKpL,GACduE,OACP,MAER,CACAhJ,KAAKoS,QACT,CAOAjG,OAAAA,CAAQpJ,GACJ,MAAMsP,EAAiBrS,KAAKyQ,QAAQxM,OAAOlB,GAC3C,IAAK,IAAIrH,EAAI,EAAGA,EAAI2W,EAAepR,OAAQvF,IACvCsE,KAAKkK,OAAOoI,MAAMD,EAAe3W,GAAIqH,EAAO6G,QAEpD,CAMA+H,OAAAA,GACI3R,KAAK0I,KAAKmE,SAASiB,GAAeA,MAClC9N,KAAK0I,KAAKzH,OAAS,EACnBjB,KAAK0Q,QAAQ9J,SACjB,CAMAwL,MAAAA,GACIpS,KAAK8Q,eAAgB,EACrB9Q,KAAKqR,eAAgB,EACrBrR,KAAK+I,QAAQ,eACjB,CAMA3B,UAAAA,GACI,OAAOpH,KAAKoS,QAChB,CAUArJ,OAAAA,CAAQ0D,EAAQC,GACZ,IAAIvO,EACJ6B,KAAK2R,UACkB,QAAtBxT,EAAK6B,KAAKkK,cAA2B,IAAP/L,GAAyBA,EAAG4P,QAC3D/N,KAAKsQ,QAAQf,QACbvP,KAAKiJ,YAAc,SACnBjJ,KAAK0B,aAAa,QAAS+K,EAAQC,GAC/B1M,KAAK6Q,gBAAkB7Q,KAAK8Q,eAC5B9Q,KAAKsR,WAEb,CAMAA,SAAAA,GACI,GAAItR,KAAKqR,eAAiBrR,KAAK8Q,cAC3B,OAAO9Q,KACX,MAAMyN,EAAOzN,KACb,GAAIA,KAAKsQ,QAAQvB,UAAY/O,KAAK+Q,sBAC9B/Q,KAAKsQ,QAAQf,QACbvP,KAAK0B,aAAa,oBAClB1B,KAAKqR,eAAgB,MAEpB,CACD,MAAMkB,EAAQvS,KAAKsQ,QAAQtB,WAC3BhP,KAAKqR,eAAgB,EACrB,MAAM1G,EAAQ3K,KAAK4K,cAAa,KACxB6C,EAAKqD,gBAET9Q,KAAK0B,aAAa,oBAAqB+L,EAAK6C,QAAQvB,UAEhDtB,EAAKqD,eAETrD,EAAKlF,MAAMqD,IACHA,GACA6B,EAAK4D,eAAgB,EACrB5D,EAAK6D,YACLtR,KAAK0B,aAAa,kBAAmBkK,IAGrC6B,EAAK+E,aACT,IACF,GACHD,GACCvS,KAAKyH,KAAKoK,WACVlH,EAAMmH,QAEV9R,KAAK0I,KAAKjI,MAAK,KACXT,KAAK6K,eAAeF,EAAM,GAElC,CACJ,CAMA6H,WAAAA,GACI,MAAMC,EAAUzS,KAAKsQ,QAAQvB,SAC7B/O,KAAKqR,eAAgB,EACrBrR,KAAKsQ,QAAQf,QACbvP,KAAK0B,aAAa,YAAa+Q,EACnC,ECvWJ,MAAMC,EAAQ,CAAC,EACf,SAASC,EAAO/C,EAAKnI,GACE,iBAARmI,IACPnI,EAAOmI,EACPA,OAAM9J,GAGV,MAAM8M,ECHH,SAAahD,GAAqB,IAAhBE,EAAIjP,UAAAI,OAAA,QAAA6E,IAAAjF,UAAA,GAAAA,UAAA,GAAG,GAAIgS,EAAGhS,UAAAI,OAAA,EAAAJ,UAAA,QAAAiF,EAC/BxM,EAAMsW,EAEViD,EAAMA,GAA4B,oBAAbC,UAA4BA,SAC7C,MAAQlD,IACRA,EAAMiD,EAAIhP,SAAW,KAAOgP,EAAIE,MAEjB,iBAARnD,IACH,MAAQA,EAAI/J,OAAO,KAEf+J,EADA,MAAQA,EAAI/J,OAAO,GACbgN,EAAIhP,SAAW+L,EAGfiD,EAAIE,KAAOnD,GAGpB,sBAAsBoD,KAAKpD,KAExBA,OADA,IAAuBiD,EACjBA,EAAIhP,SAAW,KAAO+L,EAGtB,WAAaA,GAI3BtW,GAAMiN,EAAAA,EAAAA,IAAMqJ,IAGXtW,EAAI2Z,OACD,cAAcD,KAAK1Z,EAAIuK,UACvBvK,EAAI2Z,KAAO,KAEN,eAAeD,KAAK1Z,EAAIuK,YAC7BvK,EAAI2Z,KAAO,QAGnB3Z,EAAIwW,KAAOxW,EAAIwW,MAAQ,IACvB,MACMiD,GADkC,IAA3BzZ,EAAIyZ,KAAKpM,QAAQ,KACV,IAAMrN,EAAIyZ,KAAO,IAAMzZ,EAAIyZ,KAS/C,OAPAzZ,EAAIoL,GAAKpL,EAAIuK,SAAW,MAAQkP,EAAO,IAAMzZ,EAAI2Z,KAAOnD,EAExDxW,EAAI4Z,KACA5Z,EAAIuK,SACA,MACAkP,GACCF,GAAOA,EAAII,OAAS3Z,EAAI2Z,KAAO,GAAK,IAAM3Z,EAAI2Z,MAChD3Z,CACX,CD7CmB6Z,CAAIvD,GADnBnI,EAAOA,GAAQ,CAAC,GACaqI,MAAQ,cAC/BsD,EAASR,EAAOQ,OAChB1O,EAAKkO,EAAOlO,GACZoL,EAAO8C,EAAO9C,KACduD,EAAgBX,EAAMhO,IAAOoL,KAAQ4C,EAAMhO,GAAU,KAK3D,IAAI8C,EAaJ,OAjBsBC,EAAK6L,UACvB7L,EAAK,0BACL,IAAUA,EAAK8L,WACfF,EAGA7L,EAAK,IAAImI,EAAQyD,EAAQ3L,IAGpBiL,EAAMhO,KACPgO,EAAMhO,GAAM,IAAIiL,EAAQyD,EAAQ3L,IAEpCD,EAAKkL,EAAMhO,IAEXkO,EAAOY,QAAU/L,EAAK+L,QACtB/L,EAAK+L,MAAQZ,EAAOa,UAEjBjM,EAAGgK,OAAOoB,EAAO9C,KAAMrI,EAClC,CAGAzF,OAAOqG,OAAOsK,EAAQ,CAClBhD,QAAO,EACPpI,OAAM,EACNC,GAAImL,EACJzL,QAASyL,G","sources":["../node_modules/stackblur-canvas/dist/stackblur-es.js","../node_modules/@socket.io/component-emitter/lib/esm/index.js","../node_modules/socket.io-parser/build/esm/is-binary.js","../node_modules/socket.io-parser/build/esm/binary.js","../node_modules/socket.io-parser/build/esm/index.js","../node_modules/socket.io-client/build/esm/on.js","../node_modules/socket.io-client/build/esm/socket.js","../node_modules/socket.io-client/build/esm/contrib/backo2.js","../node_modules/socket.io-client/build/esm/manager.js","../node_modules/socket.io-client/build/esm/index.js","../node_modules/socket.io-client/build/esm/url.js"],"sourcesContent":["function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\n/* eslint-disable no-bitwise -- used for calculations */\n\n/* eslint-disable unicorn/prefer-query-selector -- aiming at\n  backward-compatibility */\n\n/**\n* StackBlur - a fast almost Gaussian Blur For Canvas\n*\n* In case you find this class useful - especially in commercial projects -\n* I am not totally unhappy for a small donation to my PayPal account\n* mario@quasimondo.de\n*\n* Or support me on flattr:\n* {@link https://flattr.com/thing/72791/StackBlur-a-fast-almost-Gaussian-Blur-Effect-for-CanvasJavascript}.\n*\n* @module StackBlur\n* @author Mario Klingemann\n* Contact: mario@quasimondo.com\n* Website: {@link http://www.quasimondo.com/StackBlurForCanvas/StackBlurDemo.html}\n* Twitter: @quasimondo\n*\n* @copyright (c) 2010 Mario Klingemann\n*\n* Permission is hereby granted, free of charge, to any person\n* obtaining a copy of this software and associated documentation\n* files (the \"Software\"), to deal in the Software without\n* restriction, including without limitation the rights to use,\n* copy, modify, merge, publish, distribute, sublicense, and/or sell\n* copies of the Software, and to permit persons to whom the\n* Software is furnished to do so, subject to the following\n* conditions:\n*\n* The above copyright notice and this permission notice shall be\n* included in all copies or substantial portions of the Software.\n*\n* THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES\n* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\n* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,\n* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR\n* OTHER DEALINGS IN THE SOFTWARE.\n*/\nvar mulTable = [512, 512, 456, 512, 328, 456, 335, 512, 405, 328, 271, 456, 388, 335, 292, 512, 454, 405, 364, 328, 298, 271, 496, 456, 420, 388, 360, 335, 312, 292, 273, 512, 482, 454, 428, 405, 383, 364, 345, 328, 312, 298, 284, 271, 259, 496, 475, 456, 437, 420, 404, 388, 374, 360, 347, 335, 323, 312, 302, 292, 282, 273, 265, 512, 497, 482, 468, 454, 441, 428, 417, 405, 394, 383, 373, 364, 354, 345, 337, 328, 320, 312, 305, 298, 291, 284, 278, 271, 265, 259, 507, 496, 485, 475, 465, 456, 446, 437, 428, 420, 412, 404, 396, 388, 381, 374, 367, 360, 354, 347, 341, 335, 329, 323, 318, 312, 307, 302, 297, 292, 287, 282, 278, 273, 269, 265, 261, 512, 505, 497, 489, 482, 475, 468, 461, 454, 447, 441, 435, 428, 422, 417, 411, 405, 399, 394, 389, 383, 378, 373, 368, 364, 359, 354, 350, 345, 341, 337, 332, 328, 324, 320, 316, 312, 309, 305, 301, 298, 294, 291, 287, 284, 281, 278, 274, 271, 268, 265, 262, 259, 257, 507, 501, 496, 491, 485, 480, 475, 470, 465, 460, 456, 451, 446, 442, 437, 433, 428, 424, 420, 416, 412, 408, 404, 400, 396, 392, 388, 385, 381, 377, 374, 370, 367, 363, 360, 357, 354, 350, 347, 344, 341, 338, 335, 332, 329, 326, 323, 320, 318, 315, 312, 310, 307, 304, 302, 299, 297, 294, 292, 289, 287, 285, 282, 280, 278, 275, 273, 271, 269, 267, 265, 263, 261, 259];\nvar shgTable = [9, 11, 12, 13, 13, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24];\n/**\n * @param {string|HTMLImageElement} img\n * @param {string|HTMLCanvasElement} canvas\n * @param {Float} radius\n * @param {boolean} blurAlphaChannel\n * @param {boolean} useOffset\n * @param {boolean} skipStyles\n * @returns {undefined}\n */\n\nfunction processImage(img, canvas, radius, blurAlphaChannel, useOffset, skipStyles) {\n  if (typeof img === 'string') {\n    img = document.getElementById(img);\n  }\n\n  if (!img || Object.prototype.toString.call(img).slice(8, -1) === 'HTMLImageElement' && !('naturalWidth' in img)) {\n    return;\n  }\n\n  var dimensionType = useOffset ? 'offset' : 'natural';\n  var w = img[dimensionType + 'Width'];\n  var h = img[dimensionType + 'Height']; // add ImageBitmap support,can blur texture source\n\n  if (Object.prototype.toString.call(img).slice(8, -1) === 'ImageBitmap') {\n    w = img.width;\n    h = img.height;\n  }\n\n  if (typeof canvas === 'string') {\n    canvas = document.getElementById(canvas);\n  }\n\n  if (!canvas || !('getContext' in canvas)) {\n    return;\n  }\n\n  if (!skipStyles) {\n    canvas.style.width = w + 'px';\n    canvas.style.height = h + 'px';\n  }\n\n  canvas.width = w;\n  canvas.height = h;\n  var context = canvas.getContext('2d');\n  context.clearRect(0, 0, w, h);\n  context.drawImage(img, 0, 0, img.naturalWidth, img.naturalHeight, 0, 0, w, h);\n\n  if (isNaN(radius) || radius < 1) {\n    return;\n  }\n\n  if (blurAlphaChannel) {\n    processCanvasRGBA(canvas, 0, 0, w, h, radius);\n  } else {\n    processCanvasRGB(canvas, 0, 0, w, h, radius);\n  }\n}\n/**\n * @param {string|HTMLCanvasElement} canvas\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @throws {Error|TypeError}\n * @returns {ImageData} See {@link https://html.spec.whatwg.org/multipage/canvas.html#imagedata}\n */\n\n\nfunction getImageDataFromCanvas(canvas, topX, topY, width, height) {\n  if (typeof canvas === 'string') {\n    canvas = document.getElementById(canvas);\n  }\n\n  if (!canvas || _typeof(canvas) !== 'object' || !('getContext' in canvas)) {\n    throw new TypeError('Expecting canvas with `getContext` method ' + 'in processCanvasRGB(A) calls!');\n  }\n\n  var context = canvas.getContext('2d');\n\n  try {\n    return context.getImageData(topX, topY, width, height);\n  } catch (e) {\n    throw new Error('unable to access image data: ' + e);\n  }\n}\n/**\n * @param {HTMLCanvasElement} canvas\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @param {Float} radius\n * @returns {undefined}\n */\n\n\nfunction processCanvasRGBA(canvas, topX, topY, width, height, radius) {\n  if (isNaN(radius) || radius < 1) {\n    return;\n  }\n\n  radius |= 0;\n  var imageData = getImageDataFromCanvas(canvas, topX, topY, width, height);\n  imageData = processImageDataRGBA(imageData, topX, topY, width, height, radius);\n  canvas.getContext('2d').putImageData(imageData, topX, topY);\n}\n/**\n * @param {ImageData} imageData\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @param {Float} radius\n * @returns {ImageData}\n */\n\n\nfunction processImageDataRGBA(imageData, topX, topY, width, height, radius) {\n  var pixels = imageData.data;\n  var div = 2 * radius + 1; // const w4 = width << 2;\n\n  var widthMinus1 = width - 1;\n  var heightMinus1 = height - 1;\n  var radiusPlus1 = radius + 1;\n  var sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;\n  var stackStart = new BlurStack();\n  var stack = stackStart;\n  var stackEnd;\n\n  for (var i = 1; i < div; i++) {\n    stack = stack.next = new BlurStack();\n\n    if (i === radiusPlus1) {\n      stackEnd = stack;\n    }\n  }\n\n  stack.next = stackStart;\n  var stackIn = null,\n      stackOut = null,\n      yw = 0,\n      yi = 0;\n  var mulSum = mulTable[radius];\n  var shgSum = shgTable[radius];\n\n  for (var y = 0; y < height; y++) {\n    stack = stackStart;\n    var pr = pixels[yi],\n        pg = pixels[yi + 1],\n        pb = pixels[yi + 2],\n        pa = pixels[yi + 3];\n\n    for (var _i = 0; _i < radiusPlus1; _i++) {\n      stack.r = pr;\n      stack.g = pg;\n      stack.b = pb;\n      stack.a = pa;\n      stack = stack.next;\n    }\n\n    var rInSum = 0,\n        gInSum = 0,\n        bInSum = 0,\n        aInSum = 0,\n        rOutSum = radiusPlus1 * pr,\n        gOutSum = radiusPlus1 * pg,\n        bOutSum = radiusPlus1 * pb,\n        aOutSum = radiusPlus1 * pa,\n        rSum = sumFactor * pr,\n        gSum = sumFactor * pg,\n        bSum = sumFactor * pb,\n        aSum = sumFactor * pa;\n\n    for (var _i2 = 1; _i2 < radiusPlus1; _i2++) {\n      var p = yi + ((widthMinus1 < _i2 ? widthMinus1 : _i2) << 2);\n      var r = pixels[p],\n          g = pixels[p + 1],\n          b = pixels[p + 2],\n          a = pixels[p + 3];\n      var rbs = radiusPlus1 - _i2;\n      rSum += (stack.r = r) * rbs;\n      gSum += (stack.g = g) * rbs;\n      bSum += (stack.b = b) * rbs;\n      aSum += (stack.a = a) * rbs;\n      rInSum += r;\n      gInSum += g;\n      bInSum += b;\n      aInSum += a;\n      stack = stack.next;\n    }\n\n    stackIn = stackStart;\n    stackOut = stackEnd;\n\n    for (var x = 0; x < width; x++) {\n      var paInitial = aSum * mulSum >>> shgSum;\n      pixels[yi + 3] = paInitial;\n\n      if (paInitial !== 0) {\n        var _a2 = 255 / paInitial;\n\n        pixels[yi] = (rSum * mulSum >>> shgSum) * _a2;\n        pixels[yi + 1] = (gSum * mulSum >>> shgSum) * _a2;\n        pixels[yi + 2] = (bSum * mulSum >>> shgSum) * _a2;\n      } else {\n        pixels[yi] = pixels[yi + 1] = pixels[yi + 2] = 0;\n      }\n\n      rSum -= rOutSum;\n      gSum -= gOutSum;\n      bSum -= bOutSum;\n      aSum -= aOutSum;\n      rOutSum -= stackIn.r;\n      gOutSum -= stackIn.g;\n      bOutSum -= stackIn.b;\n      aOutSum -= stackIn.a;\n\n      var _p = x + radius + 1;\n\n      _p = yw + (_p < widthMinus1 ? _p : widthMinus1) << 2;\n      rInSum += stackIn.r = pixels[_p];\n      gInSum += stackIn.g = pixels[_p + 1];\n      bInSum += stackIn.b = pixels[_p + 2];\n      aInSum += stackIn.a = pixels[_p + 3];\n      rSum += rInSum;\n      gSum += gInSum;\n      bSum += bInSum;\n      aSum += aInSum;\n      stackIn = stackIn.next;\n      var _stackOut = stackOut,\n          _r = _stackOut.r,\n          _g = _stackOut.g,\n          _b = _stackOut.b,\n          _a = _stackOut.a;\n      rOutSum += _r;\n      gOutSum += _g;\n      bOutSum += _b;\n      aOutSum += _a;\n      rInSum -= _r;\n      gInSum -= _g;\n      bInSum -= _b;\n      aInSum -= _a;\n      stackOut = stackOut.next;\n      yi += 4;\n    }\n\n    yw += width;\n  }\n\n  for (var _x = 0; _x < width; _x++) {\n    yi = _x << 2;\n\n    var _pr = pixels[yi],\n        _pg = pixels[yi + 1],\n        _pb = pixels[yi + 2],\n        _pa = pixels[yi + 3],\n        _rOutSum = radiusPlus1 * _pr,\n        _gOutSum = radiusPlus1 * _pg,\n        _bOutSum = radiusPlus1 * _pb,\n        _aOutSum = radiusPlus1 * _pa,\n        _rSum = sumFactor * _pr,\n        _gSum = sumFactor * _pg,\n        _bSum = sumFactor * _pb,\n        _aSum = sumFactor * _pa;\n\n    stack = stackStart;\n\n    for (var _i3 = 0; _i3 < radiusPlus1; _i3++) {\n      stack.r = _pr;\n      stack.g = _pg;\n      stack.b = _pb;\n      stack.a = _pa;\n      stack = stack.next;\n    }\n\n    var yp = width;\n    var _gInSum = 0,\n        _bInSum = 0,\n        _aInSum = 0,\n        _rInSum = 0;\n\n    for (var _i4 = 1; _i4 <= radius; _i4++) {\n      yi = yp + _x << 2;\n\n      var _rbs = radiusPlus1 - _i4;\n\n      _rSum += (stack.r = _pr = pixels[yi]) * _rbs;\n      _gSum += (stack.g = _pg = pixels[yi + 1]) * _rbs;\n      _bSum += (stack.b = _pb = pixels[yi + 2]) * _rbs;\n      _aSum += (stack.a = _pa = pixels[yi + 3]) * _rbs;\n      _rInSum += _pr;\n      _gInSum += _pg;\n      _bInSum += _pb;\n      _aInSum += _pa;\n      stack = stack.next;\n\n      if (_i4 < heightMinus1) {\n        yp += width;\n      }\n    }\n\n    yi = _x;\n    stackIn = stackStart;\n    stackOut = stackEnd;\n\n    for (var _y = 0; _y < height; _y++) {\n      var _p2 = yi << 2;\n\n      pixels[_p2 + 3] = _pa = _aSum * mulSum >>> shgSum;\n\n      if (_pa > 0) {\n        _pa = 255 / _pa;\n        pixels[_p2] = (_rSum * mulSum >>> shgSum) * _pa;\n        pixels[_p2 + 1] = (_gSum * mulSum >>> shgSum) * _pa;\n        pixels[_p2 + 2] = (_bSum * mulSum >>> shgSum) * _pa;\n      } else {\n        pixels[_p2] = pixels[_p2 + 1] = pixels[_p2 + 2] = 0;\n      }\n\n      _rSum -= _rOutSum;\n      _gSum -= _gOutSum;\n      _bSum -= _bOutSum;\n      _aSum -= _aOutSum;\n      _rOutSum -= stackIn.r;\n      _gOutSum -= stackIn.g;\n      _bOutSum -= stackIn.b;\n      _aOutSum -= stackIn.a;\n      _p2 = _x + ((_p2 = _y + radiusPlus1) < heightMinus1 ? _p2 : heightMinus1) * width << 2;\n      _rSum += _rInSum += stackIn.r = pixels[_p2];\n      _gSum += _gInSum += stackIn.g = pixels[_p2 + 1];\n      _bSum += _bInSum += stackIn.b = pixels[_p2 + 2];\n      _aSum += _aInSum += stackIn.a = pixels[_p2 + 3];\n      stackIn = stackIn.next;\n      _rOutSum += _pr = stackOut.r;\n      _gOutSum += _pg = stackOut.g;\n      _bOutSum += _pb = stackOut.b;\n      _aOutSum += _pa = stackOut.a;\n      _rInSum -= _pr;\n      _gInSum -= _pg;\n      _bInSum -= _pb;\n      _aInSum -= _pa;\n      stackOut = stackOut.next;\n      yi += width;\n    }\n  }\n\n  return imageData;\n}\n/**\n * @param {HTMLCanvasElement} canvas\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @param {Float} radius\n * @returns {undefined}\n */\n\n\nfunction processCanvasRGB(canvas, topX, topY, width, height, radius) {\n  if (isNaN(radius) || radius < 1) {\n    return;\n  }\n\n  radius |= 0;\n  var imageData = getImageDataFromCanvas(canvas, topX, topY, width, height);\n  imageData = processImageDataRGB(imageData, topX, topY, width, height, radius);\n  canvas.getContext('2d').putImageData(imageData, topX, topY);\n}\n/**\n * @param {ImageData} imageData\n * @param {Integer} topX\n * @param {Integer} topY\n * @param {Integer} width\n * @param {Integer} height\n * @param {Float} radius\n * @returns {ImageData}\n */\n\n\nfunction processImageDataRGB(imageData, topX, topY, width, height, radius) {\n  var pixels = imageData.data;\n  var div = 2 * radius + 1; // const w4 = width << 2;\n\n  var widthMinus1 = width - 1;\n  var heightMinus1 = height - 1;\n  var radiusPlus1 = radius + 1;\n  var sumFactor = radiusPlus1 * (radiusPlus1 + 1) / 2;\n  var stackStart = new BlurStack();\n  var stack = stackStart;\n  var stackEnd;\n\n  for (var i = 1; i < div; i++) {\n    stack = stack.next = new BlurStack();\n\n    if (i === radiusPlus1) {\n      stackEnd = stack;\n    }\n  }\n\n  stack.next = stackStart;\n  var stackIn = null;\n  var stackOut = null;\n  var mulSum = mulTable[radius];\n  var shgSum = shgTable[radius];\n  var p, rbs;\n  var yw = 0,\n      yi = 0;\n\n  for (var y = 0; y < height; y++) {\n    var pr = pixels[yi],\n        pg = pixels[yi + 1],\n        pb = pixels[yi + 2],\n        rOutSum = radiusPlus1 * pr,\n        gOutSum = radiusPlus1 * pg,\n        bOutSum = radiusPlus1 * pb,\n        rSum = sumFactor * pr,\n        gSum = sumFactor * pg,\n        bSum = sumFactor * pb;\n    stack = stackStart;\n\n    for (var _i5 = 0; _i5 < radiusPlus1; _i5++) {\n      stack.r = pr;\n      stack.g = pg;\n      stack.b = pb;\n      stack = stack.next;\n    }\n\n    var rInSum = 0,\n        gInSum = 0,\n        bInSum = 0;\n\n    for (var _i6 = 1; _i6 < radiusPlus1; _i6++) {\n      p = yi + ((widthMinus1 < _i6 ? widthMinus1 : _i6) << 2);\n      rSum += (stack.r = pr = pixels[p]) * (rbs = radiusPlus1 - _i6);\n      gSum += (stack.g = pg = pixels[p + 1]) * rbs;\n      bSum += (stack.b = pb = pixels[p + 2]) * rbs;\n      rInSum += pr;\n      gInSum += pg;\n      bInSum += pb;\n      stack = stack.next;\n    }\n\n    stackIn = stackStart;\n    stackOut = stackEnd;\n\n    for (var x = 0; x < width; x++) {\n      pixels[yi] = rSum * mulSum >>> shgSum;\n      pixels[yi + 1] = gSum * mulSum >>> shgSum;\n      pixels[yi + 2] = bSum * mulSum >>> shgSum;\n      rSum -= rOutSum;\n      gSum -= gOutSum;\n      bSum -= bOutSum;\n      rOutSum -= stackIn.r;\n      gOutSum -= stackIn.g;\n      bOutSum -= stackIn.b;\n      p = yw + ((p = x + radius + 1) < widthMinus1 ? p : widthMinus1) << 2;\n      rInSum += stackIn.r = pixels[p];\n      gInSum += stackIn.g = pixels[p + 1];\n      bInSum += stackIn.b = pixels[p + 2];\n      rSum += rInSum;\n      gSum += gInSum;\n      bSum += bInSum;\n      stackIn = stackIn.next;\n      rOutSum += pr = stackOut.r;\n      gOutSum += pg = stackOut.g;\n      bOutSum += pb = stackOut.b;\n      rInSum -= pr;\n      gInSum -= pg;\n      bInSum -= pb;\n      stackOut = stackOut.next;\n      yi += 4;\n    }\n\n    yw += width;\n  }\n\n  for (var _x2 = 0; _x2 < width; _x2++) {\n    yi = _x2 << 2;\n\n    var _pr2 = pixels[yi],\n        _pg2 = pixels[yi + 1],\n        _pb2 = pixels[yi + 2],\n        _rOutSum2 = radiusPlus1 * _pr2,\n        _gOutSum2 = radiusPlus1 * _pg2,\n        _bOutSum2 = radiusPlus1 * _pb2,\n        _rSum2 = sumFactor * _pr2,\n        _gSum2 = sumFactor * _pg2,\n        _bSum2 = sumFactor * _pb2;\n\n    stack = stackStart;\n\n    for (var _i7 = 0; _i7 < radiusPlus1; _i7++) {\n      stack.r = _pr2;\n      stack.g = _pg2;\n      stack.b = _pb2;\n      stack = stack.next;\n    }\n\n    var _rInSum2 = 0,\n        _gInSum2 = 0,\n        _bInSum2 = 0;\n\n    for (var _i8 = 1, yp = width; _i8 <= radius; _i8++) {\n      yi = yp + _x2 << 2;\n      _rSum2 += (stack.r = _pr2 = pixels[yi]) * (rbs = radiusPlus1 - _i8);\n      _gSum2 += (stack.g = _pg2 = pixels[yi + 1]) * rbs;\n      _bSum2 += (stack.b = _pb2 = pixels[yi + 2]) * rbs;\n      _rInSum2 += _pr2;\n      _gInSum2 += _pg2;\n      _bInSum2 += _pb2;\n      stack = stack.next;\n\n      if (_i8 < heightMinus1) {\n        yp += width;\n      }\n    }\n\n    yi = _x2;\n    stackIn = stackStart;\n    stackOut = stackEnd;\n\n    for (var _y2 = 0; _y2 < height; _y2++) {\n      p = yi << 2;\n      pixels[p] = _rSum2 * mulSum >>> shgSum;\n      pixels[p + 1] = _gSum2 * mulSum >>> shgSum;\n      pixels[p + 2] = _bSum2 * mulSum >>> shgSum;\n      _rSum2 -= _rOutSum2;\n      _gSum2 -= _gOutSum2;\n      _bSum2 -= _bOutSum2;\n      _rOutSum2 -= stackIn.r;\n      _gOutSum2 -= stackIn.g;\n      _bOutSum2 -= stackIn.b;\n      p = _x2 + ((p = _y2 + radiusPlus1) < heightMinus1 ? p : heightMinus1) * width << 2;\n      _rSum2 += _rInSum2 += stackIn.r = pixels[p];\n      _gSum2 += _gInSum2 += stackIn.g = pixels[p + 1];\n      _bSum2 += _bInSum2 += stackIn.b = pixels[p + 2];\n      stackIn = stackIn.next;\n      _rOutSum2 += _pr2 = stackOut.r;\n      _gOutSum2 += _pg2 = stackOut.g;\n      _bOutSum2 += _pb2 = stackOut.b;\n      _rInSum2 -= _pr2;\n      _gInSum2 -= _pg2;\n      _bInSum2 -= _pb2;\n      stackOut = stackOut.next;\n      yi += width;\n    }\n  }\n\n  return imageData;\n}\n/**\n *\n */\n\n\nvar BlurStack =\n/**\n * Set properties.\n */\nfunction BlurStack() {\n  _classCallCheck(this, BlurStack);\n\n  this.r = 0;\n  this.g = 0;\n  this.b = 0;\n  this.a = 0;\n  this.next = null;\n};\n\nexport { BlurStack, processCanvasRGB as canvasRGB, processCanvasRGBA as canvasRGBA, processImage as image, processImageDataRGB as imageDataRGB, processImageDataRGBA as imageDataRGBA };\n","/**\n * Initialize a new `Emitter`.\n *\n * @api public\n */\n\nexport function Emitter(obj) {\n  if (obj) return mixin(obj);\n}\n\n/**\n * Mixin the emitter properties.\n *\n * @param {Object} obj\n * @return {Object}\n * @api private\n */\n\nfunction mixin(obj) {\n  for (var key in Emitter.prototype) {\n    obj[key] = Emitter.prototype[key];\n  }\n  return obj;\n}\n\n/**\n * Listen on the given `event` with `fn`.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.on =\nEmitter.prototype.addEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n  (this._callbacks['$' + event] = this._callbacks['$' + event] || [])\n    .push(fn);\n  return this;\n};\n\n/**\n * Adds an `event` listener that will be invoked a single\n * time then automatically removed.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.once = function(event, fn){\n  function on() {\n    this.off(event, on);\n    fn.apply(this, arguments);\n  }\n\n  on.fn = fn;\n  this.on(event, on);\n  return this;\n};\n\n/**\n * Remove the given callback for `event` or all\n * registered callbacks.\n *\n * @param {String} event\n * @param {Function} fn\n * @return {Emitter}\n * @api public\n */\n\nEmitter.prototype.off =\nEmitter.prototype.removeListener =\nEmitter.prototype.removeAllListeners =\nEmitter.prototype.removeEventListener = function(event, fn){\n  this._callbacks = this._callbacks || {};\n\n  // all\n  if (0 == arguments.length) {\n    this._callbacks = {};\n    return this;\n  }\n\n  // specific event\n  var callbacks = this._callbacks['$' + event];\n  if (!callbacks) return this;\n\n  // remove all handlers\n  if (1 == arguments.length) {\n    delete this._callbacks['$' + event];\n    return this;\n  }\n\n  // remove specific handler\n  var cb;\n  for (var i = 0; i < callbacks.length; i++) {\n    cb = callbacks[i];\n    if (cb === fn || cb.fn === fn) {\n      callbacks.splice(i, 1);\n      break;\n    }\n  }\n\n  // Remove event specific arrays for event types that no\n  // one is subscribed for to avoid memory leak.\n  if (callbacks.length === 0) {\n    delete this._callbacks['$' + event];\n  }\n\n  return this;\n};\n\n/**\n * Emit `event` with the given args.\n *\n * @param {String} event\n * @param {Mixed} ...\n * @return {Emitter}\n */\n\nEmitter.prototype.emit = function(event){\n  this._callbacks = this._callbacks || {};\n\n  var args = new Array(arguments.length - 1)\n    , callbacks = this._callbacks['$' + event];\n\n  for (var i = 1; i < arguments.length; i++) {\n    args[i - 1] = arguments[i];\n  }\n\n  if (callbacks) {\n    callbacks = callbacks.slice(0);\n    for (var i = 0, len = callbacks.length; i < len; ++i) {\n      callbacks[i].apply(this, args);\n    }\n  }\n\n  return this;\n};\n\n// alias used for reserved events (protected method)\nEmitter.prototype.emitReserved = Emitter.prototype.emit;\n\n/**\n * Return array of callbacks for `event`.\n *\n * @param {String} event\n * @return {Array}\n * @api public\n */\n\nEmitter.prototype.listeners = function(event){\n  this._callbacks = this._callbacks || {};\n  return this._callbacks['$' + event] || [];\n};\n\n/**\n * Check if this emitter has `event` handlers.\n *\n * @param {String} event\n * @return {Boolean}\n * @api public\n */\n\nEmitter.prototype.hasListeners = function(event){\n  return !! this.listeners(event).length;\n};\n","const withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\nconst isView = (obj) => {\n    return typeof ArrayBuffer.isView === \"function\"\n        ? ArrayBuffer.isView(obj)\n        : obj.buffer instanceof ArrayBuffer;\n};\nconst toString = Object.prototype.toString;\nconst withNativeBlob = typeof Blob === \"function\" ||\n    (typeof Blob !== \"undefined\" &&\n        toString.call(Blob) === \"[object BlobConstructor]\");\nconst withNativeFile = typeof File === \"function\" ||\n    (typeof File !== \"undefined\" &&\n        toString.call(File) === \"[object FileConstructor]\");\n/**\n * Returns true if obj is a Buffer, an ArrayBuffer, a Blob or a File.\n *\n * @private\n */\nexport function isBinary(obj) {\n    return ((withNativeArrayBuffer && (obj instanceof ArrayBuffer || isView(obj))) ||\n        (withNativeBlob && obj instanceof Blob) ||\n        (withNativeFile && obj instanceof File));\n}\nexport function hasBinary(obj, toJSON) {\n    if (!obj || typeof obj !== \"object\") {\n        return false;\n    }\n    if (Array.isArray(obj)) {\n        for (let i = 0, l = obj.length; i < l; i++) {\n            if (hasBinary(obj[i])) {\n                return true;\n            }\n        }\n        return false;\n    }\n    if (isBinary(obj)) {\n        return true;\n    }\n    if (obj.toJSON &&\n        typeof obj.toJSON === \"function\" &&\n        arguments.length === 1) {\n        return hasBinary(obj.toJSON(), true);\n    }\n    for (const key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key) && hasBinary(obj[key])) {\n            return true;\n        }\n    }\n    return false;\n}\n","import { isBinary } from \"./is-binary.js\";\n/**\n * Replaces every Buffer | ArrayBuffer | Blob | File in packet with a numbered placeholder.\n *\n * @param {Object} packet - socket.io event packet\n * @return {Object} with deconstructed packet and list of buffers\n * @public\n */\nexport function deconstructPacket(packet) {\n    const buffers = [];\n    const packetData = packet.data;\n    const pack = packet;\n    pack.data = _deconstructPacket(packetData, buffers);\n    pack.attachments = buffers.length; // number of binary 'attachments'\n    return { packet: pack, buffers: buffers };\n}\nfunction _deconstructPacket(data, buffers) {\n    if (!data)\n        return data;\n    if (isBinary(data)) {\n        const placeholder = { _placeholder: true, num: buffers.length };\n        buffers.push(data);\n        return placeholder;\n    }\n    else if (Array.isArray(data)) {\n        const newData = new Array(data.length);\n        for (let i = 0; i < data.length; i++) {\n            newData[i] = _deconstructPacket(data[i], buffers);\n        }\n        return newData;\n    }\n    else if (typeof data === \"object\" && !(data instanceof Date)) {\n        const newData = {};\n        for (const key in data) {\n            if (Object.prototype.hasOwnProperty.call(data, key)) {\n                newData[key] = _deconstructPacket(data[key], buffers);\n            }\n        }\n        return newData;\n    }\n    return data;\n}\n/**\n * Reconstructs a binary packet from its placeholder packet and buffers\n *\n * @param {Object} packet - event packet with placeholders\n * @param {Array} buffers - binary buffers to put in placeholder positions\n * @return {Object} reconstructed packet\n * @public\n */\nexport function reconstructPacket(packet, buffers) {\n    packet.data = _reconstructPacket(packet.data, buffers);\n    delete packet.attachments; // no longer useful\n    return packet;\n}\nfunction _reconstructPacket(data, buffers) {\n    if (!data)\n        return data;\n    if (data && data._placeholder === true) {\n        const isIndexValid = typeof data.num === \"number\" &&\n            data.num >= 0 &&\n            data.num < buffers.length;\n        if (isIndexValid) {\n            return buffers[data.num]; // appropriate buffer (should be natural order anyway)\n        }\n        else {\n            throw new Error(\"illegal attachments\");\n        }\n    }\n    else if (Array.isArray(data)) {\n        for (let i = 0; i < data.length; i++) {\n            data[i] = _reconstructPacket(data[i], buffers);\n        }\n    }\n    else if (typeof data === \"object\") {\n        for (const key in data) {\n            if (Object.prototype.hasOwnProperty.call(data, key)) {\n                data[key] = _reconstructPacket(data[key], buffers);\n            }\n        }\n    }\n    return data;\n}\n","import { Emitter } from \"@socket.io/component-emitter\";\nimport { deconstructPacket, reconstructPacket } from \"./binary.js\";\nimport { isBinary, hasBinary } from \"./is-binary.js\";\n/**\n * These strings must not be used as event names, as they have a special meaning.\n */\nconst RESERVED_EVENTS = [\n    \"connect\",\n    \"connect_error\",\n    \"disconnect\",\n    \"disconnecting\",\n    \"newListener\",\n    \"removeListener\", // used by the Node.js EventEmitter\n];\n/**\n * Protocol version.\n *\n * @public\n */\nexport const protocol = 5;\nexport var PacketType;\n(function (PacketType) {\n    PacketType[PacketType[\"CONNECT\"] = 0] = \"CONNECT\";\n    PacketType[PacketType[\"DISCONNECT\"] = 1] = \"DISCONNECT\";\n    PacketType[PacketType[\"EVENT\"] = 2] = \"EVENT\";\n    PacketType[PacketType[\"ACK\"] = 3] = \"ACK\";\n    PacketType[PacketType[\"CONNECT_ERROR\"] = 4] = \"CONNECT_ERROR\";\n    PacketType[PacketType[\"BINARY_EVENT\"] = 5] = \"BINARY_EVENT\";\n    PacketType[PacketType[\"BINARY_ACK\"] = 6] = \"BINARY_ACK\";\n})(PacketType || (PacketType = {}));\n/**\n * A socket.io Encoder instance\n */\nexport class Encoder {\n    /**\n     * Encoder constructor\n     *\n     * @param {function} replacer - custom replacer to pass down to JSON.parse\n     */\n    constructor(replacer) {\n        this.replacer = replacer;\n    }\n    /**\n     * Encode a packet as a single string if non-binary, or as a\n     * buffer sequence, depending on packet type.\n     *\n     * @param {Object} obj - packet object\n     */\n    encode(obj) {\n        if (obj.type === PacketType.EVENT || obj.type === PacketType.ACK) {\n            if (hasBinary(obj)) {\n                return this.encodeAsBinary({\n                    type: obj.type === PacketType.EVENT\n                        ? PacketType.BINARY_EVENT\n                        : PacketType.BINARY_ACK,\n                    nsp: obj.nsp,\n                    data: obj.data,\n                    id: obj.id,\n                });\n            }\n        }\n        return [this.encodeAsString(obj)];\n    }\n    /**\n     * Encode packet as string.\n     */\n    encodeAsString(obj) {\n        // first is type\n        let str = \"\" + obj.type;\n        // attachments if we have them\n        if (obj.type === PacketType.BINARY_EVENT ||\n            obj.type === PacketType.BINARY_ACK) {\n            str += obj.attachments + \"-\";\n        }\n        // if we have a namespace other than `/`\n        // we append it followed by a comma `,`\n        if (obj.nsp && \"/\" !== obj.nsp) {\n            str += obj.nsp + \",\";\n        }\n        // immediately followed by the id\n        if (null != obj.id) {\n            str += obj.id;\n        }\n        // json data\n        if (null != obj.data) {\n            str += JSON.stringify(obj.data, this.replacer);\n        }\n        return str;\n    }\n    /**\n     * Encode packet as 'buffer sequence' by removing blobs, and\n     * deconstructing packet into object with placeholders and\n     * a list of buffers.\n     */\n    encodeAsBinary(obj) {\n        const deconstruction = deconstructPacket(obj);\n        const pack = this.encodeAsString(deconstruction.packet);\n        const buffers = deconstruction.buffers;\n        buffers.unshift(pack); // add packet info to beginning of data list\n        return buffers; // write all the buffers\n    }\n}\n// see https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript\nfunction isObject(value) {\n    return Object.prototype.toString.call(value) === \"[object Object]\";\n}\n/**\n * A socket.io Decoder instance\n *\n * @return {Object} decoder\n */\nexport class Decoder extends Emitter {\n    /**\n     * Decoder constructor\n     *\n     * @param {function} reviver - custom reviver to pass down to JSON.stringify\n     */\n    constructor(reviver) {\n        super();\n        this.reviver = reviver;\n    }\n    /**\n     * Decodes an encoded packet string into packet JSON.\n     *\n     * @param {String} obj - encoded packet\n     */\n    add(obj) {\n        let packet;\n        if (typeof obj === \"string\") {\n            if (this.reconstructor) {\n                throw new Error(\"got plaintext data when reconstructing a packet\");\n            }\n            packet = this.decodeString(obj);\n            const isBinaryEvent = packet.type === PacketType.BINARY_EVENT;\n            if (isBinaryEvent || packet.type === PacketType.BINARY_ACK) {\n                packet.type = isBinaryEvent ? PacketType.EVENT : PacketType.ACK;\n                // binary packet's json\n                this.reconstructor = new BinaryReconstructor(packet);\n                // no attachments, labeled binary but no binary data to follow\n                if (packet.attachments === 0) {\n                    super.emitReserved(\"decoded\", packet);\n                }\n            }\n            else {\n                // non-binary full packet\n                super.emitReserved(\"decoded\", packet);\n            }\n        }\n        else if (isBinary(obj) || obj.base64) {\n            // raw binary data\n            if (!this.reconstructor) {\n                throw new Error(\"got binary data when not reconstructing a packet\");\n            }\n            else {\n                packet = this.reconstructor.takeBinaryData(obj);\n                if (packet) {\n                    // received final buffer\n                    this.reconstructor = null;\n                    super.emitReserved(\"decoded\", packet);\n                }\n            }\n        }\n        else {\n            throw new Error(\"Unknown type: \" + obj);\n        }\n    }\n    /**\n     * Decode a packet String (JSON data)\n     *\n     * @param {String} str\n     * @return {Object} packet\n     */\n    decodeString(str) {\n        let i = 0;\n        // look up type\n        const p = {\n            type: Number(str.charAt(0)),\n        };\n        if (PacketType[p.type] === undefined) {\n            throw new Error(\"unknown packet type \" + p.type);\n        }\n        // look up attachments if type binary\n        if (p.type === PacketType.BINARY_EVENT ||\n            p.type === PacketType.BINARY_ACK) {\n            const start = i + 1;\n            while (str.charAt(++i) !== \"-\" && i != str.length) { }\n            const buf = str.substring(start, i);\n            if (buf != Number(buf) || str.charAt(i) !== \"-\") {\n                throw new Error(\"Illegal attachments\");\n            }\n            p.attachments = Number(buf);\n        }\n        // look up namespace (if any)\n        if (\"/\" === str.charAt(i + 1)) {\n            const start = i + 1;\n            while (++i) {\n                const c = str.charAt(i);\n                if (\",\" === c)\n                    break;\n                if (i === str.length)\n                    break;\n            }\n            p.nsp = str.substring(start, i);\n        }\n        else {\n            p.nsp = \"/\";\n        }\n        // look up id\n        const next = str.charAt(i + 1);\n        if (\"\" !== next && Number(next) == next) {\n            const start = i + 1;\n            while (++i) {\n                const c = str.charAt(i);\n                if (null == c || Number(c) != c) {\n                    --i;\n                    break;\n                }\n                if (i === str.length)\n                    break;\n            }\n            p.id = Number(str.substring(start, i + 1));\n        }\n        // look up json data\n        if (str.charAt(++i)) {\n            const payload = this.tryParse(str.substr(i));\n            if (Decoder.isPayloadValid(p.type, payload)) {\n                p.data = payload;\n            }\n            else {\n                throw new Error(\"invalid payload\");\n            }\n        }\n        return p;\n    }\n    tryParse(str) {\n        try {\n            return JSON.parse(str, this.reviver);\n        }\n        catch (e) {\n            return false;\n        }\n    }\n    static isPayloadValid(type, payload) {\n        switch (type) {\n            case PacketType.CONNECT:\n                return isObject(payload);\n            case PacketType.DISCONNECT:\n                return payload === undefined;\n            case PacketType.CONNECT_ERROR:\n                return typeof payload === \"string\" || isObject(payload);\n            case PacketType.EVENT:\n            case PacketType.BINARY_EVENT:\n                return (Array.isArray(payload) &&\n                    (typeof payload[0] === \"number\" ||\n                        (typeof payload[0] === \"string\" &&\n                            RESERVED_EVENTS.indexOf(payload[0]) === -1)));\n            case PacketType.ACK:\n            case PacketType.BINARY_ACK:\n                return Array.isArray(payload);\n        }\n    }\n    /**\n     * Deallocates a parser's resources\n     */\n    destroy() {\n        if (this.reconstructor) {\n            this.reconstructor.finishedReconstruction();\n            this.reconstructor = null;\n        }\n    }\n}\n/**\n * A manager of a binary event's 'buffer sequence'. Should\n * be constructed whenever a packet of type BINARY_EVENT is\n * decoded.\n *\n * @param {Object} packet\n * @return {BinaryReconstructor} initialized reconstructor\n */\nclass BinaryReconstructor {\n    constructor(packet) {\n        this.packet = packet;\n        this.buffers = [];\n        this.reconPack = packet;\n    }\n    /**\n     * Method to be called when binary data received from connection\n     * after a BINARY_EVENT packet.\n     *\n     * @param {Buffer | ArrayBuffer} binData - the raw binary data received\n     * @return {null | Object} returns null if more binary data is expected or\n     *   a reconstructed packet object if all buffers have been received.\n     */\n    takeBinaryData(binData) {\n        this.buffers.push(binData);\n        if (this.buffers.length === this.reconPack.attachments) {\n            // done with buffer list\n            const packet = reconstructPacket(this.reconPack, this.buffers);\n            this.finishedReconstruction();\n            return packet;\n        }\n        return null;\n    }\n    /**\n     * Cleans up binary packet reconstruction variables.\n     */\n    finishedReconstruction() {\n        this.reconPack = null;\n        this.buffers = [];\n    }\n}\n","export function on(obj, ev, fn) {\n    obj.on(ev, fn);\n    return function subDestroy() {\n        obj.off(ev, fn);\n    };\n}\n","import { PacketType } from \"socket.io-parser\";\nimport { on } from \"./on.js\";\nimport { Emitter, } from \"@socket.io/component-emitter\";\n/**\n * Internal events.\n * These events can't be emitted by the user.\n */\nconst RESERVED_EVENTS = Object.freeze({\n    connect: 1,\n    connect_error: 1,\n    disconnect: 1,\n    disconnecting: 1,\n    // EventEmitter reserved events: https://nodejs.org/api/events.html#events_event_newlistener\n    newListener: 1,\n    removeListener: 1,\n});\n/**\n * A Socket is the fundamental class for interacting with the server.\n *\n * A Socket belongs to a certain Namespace (by default /) and uses an underlying {@link Manager} to communicate.\n *\n * @example\n * const socket = io();\n *\n * socket.on(\"connect\", () => {\n *   console.log(\"connected\");\n * });\n *\n * // send an event to the server\n * socket.emit(\"foo\", \"bar\");\n *\n * socket.on(\"foobar\", () => {\n *   // an event was received from the server\n * });\n *\n * // upon disconnection\n * socket.on(\"disconnect\", (reason) => {\n *   console.log(`disconnected due to ${reason}`);\n * });\n */\nexport class Socket extends Emitter {\n    /**\n     * `Socket` constructor.\n     */\n    constructor(io, nsp, opts) {\n        super();\n        /**\n         * Whether the socket is currently connected to the server.\n         *\n         * @example\n         * const socket = io();\n         *\n         * socket.on(\"connect\", () => {\n         *   console.log(socket.connected); // true\n         * });\n         *\n         * socket.on(\"disconnect\", () => {\n         *   console.log(socket.connected); // false\n         * });\n         */\n        this.connected = false;\n        /**\n         * Whether the connection state was recovered after a temporary disconnection. In that case, any missed packets will\n         * be transmitted by the server.\n         */\n        this.recovered = false;\n        /**\n         * Buffer for packets received before the CONNECT packet\n         */\n        this.receiveBuffer = [];\n        /**\n         * Buffer for packets that will be sent once the socket is connected\n         */\n        this.sendBuffer = [];\n        /**\n         * The queue of packets to be sent with retry in case of failure.\n         *\n         * Packets are sent one by one, each waiting for the server acknowledgement, in order to guarantee the delivery order.\n         * @private\n         */\n        this._queue = [];\n        /**\n         * A sequence to generate the ID of the {@link QueuedPacket}.\n         * @private\n         */\n        this._queueSeq = 0;\n        this.ids = 0;\n        /**\n         * A map containing acknowledgement handlers.\n         *\n         * The `withError` attribute is used to differentiate handlers that accept an error as first argument:\n         *\n         * - `socket.emit(\"test\", (err, value) => { ... })` with `ackTimeout` option\n         * - `socket.timeout(5000).emit(\"test\", (err, value) => { ... })`\n         * - `const value = await socket.emitWithAck(\"test\")`\n         *\n         * From those that don't:\n         *\n         * - `socket.emit(\"test\", (value) => { ... });`\n         *\n         * In the first case, the handlers will be called with an error when:\n         *\n         * - the timeout is reached\n         * - the socket gets disconnected\n         *\n         * In the second case, the handlers will be simply discarded upon disconnection, since the client will never receive\n         * an acknowledgement from the server.\n         *\n         * @private\n         */\n        this.acks = {};\n        this.flags = {};\n        this.io = io;\n        this.nsp = nsp;\n        if (opts && opts.auth) {\n            this.auth = opts.auth;\n        }\n        this._opts = Object.assign({}, opts);\n        if (this.io._autoConnect)\n            this.open();\n    }\n    /**\n     * Whether the socket is currently disconnected\n     *\n     * @example\n     * const socket = io();\n     *\n     * socket.on(\"connect\", () => {\n     *   console.log(socket.disconnected); // false\n     * });\n     *\n     * socket.on(\"disconnect\", () => {\n     *   console.log(socket.disconnected); // true\n     * });\n     */\n    get disconnected() {\n        return !this.connected;\n    }\n    /**\n     * Subscribe to open, close and packet events\n     *\n     * @private\n     */\n    subEvents() {\n        if (this.subs)\n            return;\n        const io = this.io;\n        this.subs = [\n            on(io, \"open\", this.onopen.bind(this)),\n            on(io, \"packet\", this.onpacket.bind(this)),\n            on(io, \"error\", this.onerror.bind(this)),\n            on(io, \"close\", this.onclose.bind(this)),\n        ];\n    }\n    /**\n     * Whether the Socket will try to reconnect when its Manager connects or reconnects.\n     *\n     * @example\n     * const socket = io();\n     *\n     * console.log(socket.active); // true\n     *\n     * socket.on(\"disconnect\", (reason) => {\n     *   if (reason === \"io server disconnect\") {\n     *     // the disconnection was initiated by the server, you need to manually reconnect\n     *     console.log(socket.active); // false\n     *   }\n     *   // else the socket will automatically try to reconnect\n     *   console.log(socket.active); // true\n     * });\n     */\n    get active() {\n        return !!this.subs;\n    }\n    /**\n     * \"Opens\" the socket.\n     *\n     * @example\n     * const socket = io({\n     *   autoConnect: false\n     * });\n     *\n     * socket.connect();\n     */\n    connect() {\n        if (this.connected)\n            return this;\n        this.subEvents();\n        if (!this.io[\"_reconnecting\"])\n            this.io.open(); // ensure open\n        if (\"open\" === this.io._readyState)\n            this.onopen();\n        return this;\n    }\n    /**\n     * Alias for {@link connect()}.\n     */\n    open() {\n        return this.connect();\n    }\n    /**\n     * Sends a `message` event.\n     *\n     * This method mimics the WebSocket.send() method.\n     *\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send\n     *\n     * @example\n     * socket.send(\"hello\");\n     *\n     * // this is equivalent to\n     * socket.emit(\"message\", \"hello\");\n     *\n     * @return self\n     */\n    send(...args) {\n        args.unshift(\"message\");\n        this.emit.apply(this, args);\n        return this;\n    }\n    /**\n     * Override `emit`.\n     * If the event is in `events`, it's emitted normally.\n     *\n     * @example\n     * socket.emit(\"hello\", \"world\");\n     *\n     * // all serializable datastructures are supported (no need to call JSON.stringify)\n     * socket.emit(\"hello\", 1, \"2\", { 3: [\"4\"], 5: Uint8Array.from([6]) });\n     *\n     * // with an acknowledgement from the server\n     * socket.emit(\"hello\", \"world\", (val) => {\n     *   // ...\n     * });\n     *\n     * @return self\n     */\n    emit(ev, ...args) {\n        var _a, _b, _c;\n        if (RESERVED_EVENTS.hasOwnProperty(ev)) {\n            throw new Error('\"' + ev.toString() + '\" is a reserved event name');\n        }\n        args.unshift(ev);\n        if (this._opts.retries && !this.flags.fromQueue && !this.flags.volatile) {\n            this._addToQueue(args);\n            return this;\n        }\n        const packet = {\n            type: PacketType.EVENT,\n            data: args,\n        };\n        packet.options = {};\n        packet.options.compress = this.flags.compress !== false;\n        // event ack callback\n        if (\"function\" === typeof args[args.length - 1]) {\n            const id = this.ids++;\n            const ack = args.pop();\n            this._registerAckCallback(id, ack);\n            packet.id = id;\n        }\n        const isTransportWritable = (_b = (_a = this.io.engine) === null || _a === void 0 ? void 0 : _a.transport) === null || _b === void 0 ? void 0 : _b.writable;\n        const isConnected = this.connected && !((_c = this.io.engine) === null || _c === void 0 ? void 0 : _c._hasPingExpired());\n        const discardPacket = this.flags.volatile && !isTransportWritable;\n        if (discardPacket) {\n        }\n        else if (isConnected) {\n            this.notifyOutgoingListeners(packet);\n            this.packet(packet);\n        }\n        else {\n            this.sendBuffer.push(packet);\n        }\n        this.flags = {};\n        return this;\n    }\n    /**\n     * @private\n     */\n    _registerAckCallback(id, ack) {\n        var _a;\n        const timeout = (_a = this.flags.timeout) !== null && _a !== void 0 ? _a : this._opts.ackTimeout;\n        if (timeout === undefined) {\n            this.acks[id] = ack;\n            return;\n        }\n        // @ts-ignore\n        const timer = this.io.setTimeoutFn(() => {\n            delete this.acks[id];\n            for (let i = 0; i < this.sendBuffer.length; i++) {\n                if (this.sendBuffer[i].id === id) {\n                    this.sendBuffer.splice(i, 1);\n                }\n            }\n            ack.call(this, new Error(\"operation has timed out\"));\n        }, timeout);\n        const fn = (...args) => {\n            // @ts-ignore\n            this.io.clearTimeoutFn(timer);\n            ack.apply(this, args);\n        };\n        fn.withError = true;\n        this.acks[id] = fn;\n    }\n    /**\n     * Emits an event and waits for an acknowledgement\n     *\n     * @example\n     * // without timeout\n     * const response = await socket.emitWithAck(\"hello\", \"world\");\n     *\n     * // with a specific timeout\n     * try {\n     *   const response = await socket.timeout(1000).emitWithAck(\"hello\", \"world\");\n     * } catch (err) {\n     *   // the server did not acknowledge the event in the given delay\n     * }\n     *\n     * @return a Promise that will be fulfilled when the server acknowledges the event\n     */\n    emitWithAck(ev, ...args) {\n        return new Promise((resolve, reject) => {\n            const fn = (arg1, arg2) => {\n                return arg1 ? reject(arg1) : resolve(arg2);\n            };\n            fn.withError = true;\n            args.push(fn);\n            this.emit(ev, ...args);\n        });\n    }\n    /**\n     * Add the packet to the queue.\n     * @param args\n     * @private\n     */\n    _addToQueue(args) {\n        let ack;\n        if (typeof args[args.length - 1] === \"function\") {\n            ack = args.pop();\n        }\n        const packet = {\n            id: this._queueSeq++,\n            tryCount: 0,\n            pending: false,\n            args,\n            flags: Object.assign({ fromQueue: true }, this.flags),\n        };\n        args.push((err, ...responseArgs) => {\n            if (packet !== this._queue[0]) {\n                // the packet has already been acknowledged\n                return;\n            }\n            const hasError = err !== null;\n            if (hasError) {\n                if (packet.tryCount > this._opts.retries) {\n                    this._queue.shift();\n                    if (ack) {\n                        ack(err);\n                    }\n                }\n            }\n            else {\n                this._queue.shift();\n                if (ack) {\n                    ack(null, ...responseArgs);\n                }\n            }\n            packet.pending = false;\n            return this._drainQueue();\n        });\n        this._queue.push(packet);\n        this._drainQueue();\n    }\n    /**\n     * Send the first packet of the queue, and wait for an acknowledgement from the server.\n     * @param force - whether to resend a packet that has not been acknowledged yet\n     *\n     * @private\n     */\n    _drainQueue(force = false) {\n        if (!this.connected || this._queue.length === 0) {\n            return;\n        }\n        const packet = this._queue[0];\n        if (packet.pending && !force) {\n            return;\n        }\n        packet.pending = true;\n        packet.tryCount++;\n        this.flags = packet.flags;\n        this.emit.apply(this, packet.args);\n    }\n    /**\n     * Sends a packet.\n     *\n     * @param packet\n     * @private\n     */\n    packet(packet) {\n        packet.nsp = this.nsp;\n        this.io._packet(packet);\n    }\n    /**\n     * Called upon engine `open`.\n     *\n     * @private\n     */\n    onopen() {\n        if (typeof this.auth == \"function\") {\n            this.auth((data) => {\n                this._sendConnectPacket(data);\n            });\n        }\n        else {\n            this._sendConnectPacket(this.auth);\n        }\n    }\n    /**\n     * Sends a CONNECT packet to initiate the Socket.IO session.\n     *\n     * @param data\n     * @private\n     */\n    _sendConnectPacket(data) {\n        this.packet({\n            type: PacketType.CONNECT,\n            data: this._pid\n                ? Object.assign({ pid: this._pid, offset: this._lastOffset }, data)\n                : data,\n        });\n    }\n    /**\n     * Called upon engine or manager `error`.\n     *\n     * @param err\n     * @private\n     */\n    onerror(err) {\n        if (!this.connected) {\n            this.emitReserved(\"connect_error\", err);\n        }\n    }\n    /**\n     * Called upon engine `close`.\n     *\n     * @param reason\n     * @param description\n     * @private\n     */\n    onclose(reason, description) {\n        this.connected = false;\n        delete this.id;\n        this.emitReserved(\"disconnect\", reason, description);\n        this._clearAcks();\n    }\n    /**\n     * Clears the acknowledgement handlers upon disconnection, since the client will never receive an acknowledgement from\n     * the server.\n     *\n     * @private\n     */\n    _clearAcks() {\n        Object.keys(this.acks).forEach((id) => {\n            const isBuffered = this.sendBuffer.some((packet) => String(packet.id) === id);\n            if (!isBuffered) {\n                // note: handlers that do not accept an error as first argument are ignored here\n                const ack = this.acks[id];\n                delete this.acks[id];\n                if (ack.withError) {\n                    ack.call(this, new Error(\"socket has been disconnected\"));\n                }\n            }\n        });\n    }\n    /**\n     * Called with socket packet.\n     *\n     * @param packet\n     * @private\n     */\n    onpacket(packet) {\n        const sameNamespace = packet.nsp === this.nsp;\n        if (!sameNamespace)\n            return;\n        switch (packet.type) {\n            case PacketType.CONNECT:\n                if (packet.data && packet.data.sid) {\n                    this.onconnect(packet.data.sid, packet.data.pid);\n                }\n                else {\n                    this.emitReserved(\"connect_error\", new Error(\"It seems you are trying to reach a Socket.IO server in v2.x with a v3.x client, but they are not compatible (more information here: https://socket.io/docs/v3/migrating-from-2-x-to-3-0/)\"));\n                }\n                break;\n            case PacketType.EVENT:\n            case PacketType.BINARY_EVENT:\n                this.onevent(packet);\n                break;\n            case PacketType.ACK:\n            case PacketType.BINARY_ACK:\n                this.onack(packet);\n                break;\n            case PacketType.DISCONNECT:\n                this.ondisconnect();\n                break;\n            case PacketType.CONNECT_ERROR:\n                this.destroy();\n                const err = new Error(packet.data.message);\n                // @ts-ignore\n                err.data = packet.data.data;\n                this.emitReserved(\"connect_error\", err);\n                break;\n        }\n    }\n    /**\n     * Called upon a server event.\n     *\n     * @param packet\n     * @private\n     */\n    onevent(packet) {\n        const args = packet.data || [];\n        if (null != packet.id) {\n            args.push(this.ack(packet.id));\n        }\n        if (this.connected) {\n            this.emitEvent(args);\n        }\n        else {\n            this.receiveBuffer.push(Object.freeze(args));\n        }\n    }\n    emitEvent(args) {\n        if (this._anyListeners && this._anyListeners.length) {\n            const listeners = this._anyListeners.slice();\n            for (const listener of listeners) {\n                listener.apply(this, args);\n            }\n        }\n        super.emit.apply(this, args);\n        if (this._pid && args.length && typeof args[args.length - 1] === \"string\") {\n            this._lastOffset = args[args.length - 1];\n        }\n    }\n    /**\n     * Produces an ack callback to emit with an event.\n     *\n     * @private\n     */\n    ack(id) {\n        const self = this;\n        let sent = false;\n        return function (...args) {\n            // prevent double callbacks\n            if (sent)\n                return;\n            sent = true;\n            self.packet({\n                type: PacketType.ACK,\n                id: id,\n                data: args,\n            });\n        };\n    }\n    /**\n     * Called upon a server acknowledgement.\n     *\n     * @param packet\n     * @private\n     */\n    onack(packet) {\n        const ack = this.acks[packet.id];\n        if (typeof ack !== \"function\") {\n            return;\n        }\n        delete this.acks[packet.id];\n        // @ts-ignore FIXME ack is incorrectly inferred as 'never'\n        if (ack.withError) {\n            packet.data.unshift(null);\n        }\n        // @ts-ignore\n        ack.apply(this, packet.data);\n    }\n    /**\n     * Called upon server connect.\n     *\n     * @private\n     */\n    onconnect(id, pid) {\n        this.id = id;\n        this.recovered = pid && this._pid === pid;\n        this._pid = pid; // defined only if connection state recovery is enabled\n        this.connected = true;\n        this.emitBuffered();\n        this.emitReserved(\"connect\");\n        this._drainQueue(true);\n    }\n    /**\n     * Emit buffered events (received and emitted).\n     *\n     * @private\n     */\n    emitBuffered() {\n        this.receiveBuffer.forEach((args) => this.emitEvent(args));\n        this.receiveBuffer = [];\n        this.sendBuffer.forEach((packet) => {\n            this.notifyOutgoingListeners(packet);\n            this.packet(packet);\n        });\n        this.sendBuffer = [];\n    }\n    /**\n     * Called upon server disconnect.\n     *\n     * @private\n     */\n    ondisconnect() {\n        this.destroy();\n        this.onclose(\"io server disconnect\");\n    }\n    /**\n     * Called upon forced client/server side disconnections,\n     * this method ensures the manager stops tracking us and\n     * that reconnections don't get triggered for this.\n     *\n     * @private\n     */\n    destroy() {\n        if (this.subs) {\n            // clean subscriptions to avoid reconnections\n            this.subs.forEach((subDestroy) => subDestroy());\n            this.subs = undefined;\n        }\n        this.io[\"_destroy\"](this);\n    }\n    /**\n     * Disconnects the socket manually. In that case, the socket will not try to reconnect.\n     *\n     * If this is the last active Socket instance of the {@link Manager}, the low-level connection will be closed.\n     *\n     * @example\n     * const socket = io();\n     *\n     * socket.on(\"disconnect\", (reason) => {\n     *   // console.log(reason); prints \"io client disconnect\"\n     * });\n     *\n     * socket.disconnect();\n     *\n     * @return self\n     */\n    disconnect() {\n        if (this.connected) {\n            this.packet({ type: PacketType.DISCONNECT });\n        }\n        // remove socket from pool\n        this.destroy();\n        if (this.connected) {\n            // fire events\n            this.onclose(\"io client disconnect\");\n        }\n        return this;\n    }\n    /**\n     * Alias for {@link disconnect()}.\n     *\n     * @return self\n     */\n    close() {\n        return this.disconnect();\n    }\n    /**\n     * Sets the compress flag.\n     *\n     * @example\n     * socket.compress(false).emit(\"hello\");\n     *\n     * @param compress - if `true`, compresses the sending data\n     * @return self\n     */\n    compress(compress) {\n        this.flags.compress = compress;\n        return this;\n    }\n    /**\n     * Sets a modifier for a subsequent event emission that the event message will be dropped when this socket is not\n     * ready to send messages.\n     *\n     * @example\n     * socket.volatile.emit(\"hello\"); // the server may or may not receive it\n     *\n     * @returns self\n     */\n    get volatile() {\n        this.flags.volatile = true;\n        return this;\n    }\n    /**\n     * Sets a modifier for a subsequent event emission that the callback will be called with an error when the\n     * given number of milliseconds have elapsed without an acknowledgement from the server:\n     *\n     * @example\n     * socket.timeout(5000).emit(\"my-event\", (err) => {\n     *   if (err) {\n     *     // the server did not acknowledge the event in the given delay\n     *   }\n     * });\n     *\n     * @returns self\n     */\n    timeout(timeout) {\n        this.flags.timeout = timeout;\n        return this;\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback.\n     *\n     * @example\n     * socket.onAny((event, ...args) => {\n     *   console.log(`got ${event}`);\n     * });\n     *\n     * @param listener\n     */\n    onAny(listener) {\n        this._anyListeners = this._anyListeners || [];\n        this._anyListeners.push(listener);\n        return this;\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback. The listener is added to the beginning of the listeners array.\n     *\n     * @example\n     * socket.prependAny((event, ...args) => {\n     *   console.log(`got event ${event}`);\n     * });\n     *\n     * @param listener\n     */\n    prependAny(listener) {\n        this._anyListeners = this._anyListeners || [];\n        this._anyListeners.unshift(listener);\n        return this;\n    }\n    /**\n     * Removes the listener that will be fired when any event is emitted.\n     *\n     * @example\n     * const catchAllListener = (event, ...args) => {\n     *   console.log(`got event ${event}`);\n     * }\n     *\n     * socket.onAny(catchAllListener);\n     *\n     * // remove a specific listener\n     * socket.offAny(catchAllListener);\n     *\n     * // or remove all listeners\n     * socket.offAny();\n     *\n     * @param listener\n     */\n    offAny(listener) {\n        if (!this._anyListeners) {\n            return this;\n        }\n        if (listener) {\n            const listeners = this._anyListeners;\n            for (let i = 0; i < listeners.length; i++) {\n                if (listener === listeners[i]) {\n                    listeners.splice(i, 1);\n                    return this;\n                }\n            }\n        }\n        else {\n            this._anyListeners = [];\n        }\n        return this;\n    }\n    /**\n     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,\n     * e.g. to remove listeners.\n     */\n    listenersAny() {\n        return this._anyListeners || [];\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback.\n     *\n     * Note: acknowledgements sent to the server are not included.\n     *\n     * @example\n     * socket.onAnyOutgoing((event, ...args) => {\n     *   console.log(`sent event ${event}`);\n     * });\n     *\n     * @param listener\n     */\n    onAnyOutgoing(listener) {\n        this._anyOutgoingListeners = this._anyOutgoingListeners || [];\n        this._anyOutgoingListeners.push(listener);\n        return this;\n    }\n    /**\n     * Adds a listener that will be fired when any event is emitted. The event name is passed as the first argument to the\n     * callback. The listener is added to the beginning of the listeners array.\n     *\n     * Note: acknowledgements sent to the server are not included.\n     *\n     * @example\n     * socket.prependAnyOutgoing((event, ...args) => {\n     *   console.log(`sent event ${event}`);\n     * });\n     *\n     * @param listener\n     */\n    prependAnyOutgoing(listener) {\n        this._anyOutgoingListeners = this._anyOutgoingListeners || [];\n        this._anyOutgoingListeners.unshift(listener);\n        return this;\n    }\n    /**\n     * Removes the listener that will be fired when any event is emitted.\n     *\n     * @example\n     * const catchAllListener = (event, ...args) => {\n     *   console.log(`sent event ${event}`);\n     * }\n     *\n     * socket.onAnyOutgoing(catchAllListener);\n     *\n     * // remove a specific listener\n     * socket.offAnyOutgoing(catchAllListener);\n     *\n     * // or remove all listeners\n     * socket.offAnyOutgoing();\n     *\n     * @param [listener] - the catch-all listener (optional)\n     */\n    offAnyOutgoing(listener) {\n        if (!this._anyOutgoingListeners) {\n            return this;\n        }\n        if (listener) {\n            const listeners = this._anyOutgoingListeners;\n            for (let i = 0; i < listeners.length; i++) {\n                if (listener === listeners[i]) {\n                    listeners.splice(i, 1);\n                    return this;\n                }\n            }\n        }\n        else {\n            this._anyOutgoingListeners = [];\n        }\n        return this;\n    }\n    /**\n     * Returns an array of listeners that are listening for any event that is specified. This array can be manipulated,\n     * e.g. to remove listeners.\n     */\n    listenersAnyOutgoing() {\n        return this._anyOutgoingListeners || [];\n    }\n    /**\n     * Notify the listeners for each packet sent\n     *\n     * @param packet\n     *\n     * @private\n     */\n    notifyOutgoingListeners(packet) {\n        if (this._anyOutgoingListeners && this._anyOutgoingListeners.length) {\n            const listeners = this._anyOutgoingListeners.slice();\n            for (const listener of listeners) {\n                listener.apply(this, packet.data);\n            }\n        }\n    }\n}\n","/**\n * Initialize backoff timer with `opts`.\n *\n * - `min` initial timeout in milliseconds [100]\n * - `max` max timeout [10000]\n * - `jitter` [0]\n * - `factor` [2]\n *\n * @param {Object} opts\n * @api public\n */\nexport function Backoff(opts) {\n    opts = opts || {};\n    this.ms = opts.min || 100;\n    this.max = opts.max || 10000;\n    this.factor = opts.factor || 2;\n    this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;\n    this.attempts = 0;\n}\n/**\n * Return the backoff duration.\n *\n * @return {Number}\n * @api public\n */\nBackoff.prototype.duration = function () {\n    var ms = this.ms * Math.pow(this.factor, this.attempts++);\n    if (this.jitter) {\n        var rand = Math.random();\n        var deviation = Math.floor(rand * this.jitter * ms);\n        ms = (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;\n    }\n    return Math.min(ms, this.max) | 0;\n};\n/**\n * Reset the number of attempts.\n *\n * @api public\n */\nBackoff.prototype.reset = function () {\n    this.attempts = 0;\n};\n/**\n * Set the minimum duration\n *\n * @api public\n */\nBackoff.prototype.setMin = function (min) {\n    this.ms = min;\n};\n/**\n * Set the maximum duration\n *\n * @api public\n */\nBackoff.prototype.setMax = function (max) {\n    this.max = max;\n};\n/**\n * Set the jitter\n *\n * @api public\n */\nBackoff.prototype.setJitter = function (jitter) {\n    this.jitter = jitter;\n};\n","import { Socket as Engine, installTimerFunctions, nextTick, } from \"engine.io-client\";\nimport { Socket } from \"./socket.js\";\nimport * as parser from \"socket.io-parser\";\nimport { on } from \"./on.js\";\nimport { Backoff } from \"./contrib/backo2.js\";\nimport { Emitter, } from \"@socket.io/component-emitter\";\nexport class Manager extends Emitter {\n    constructor(uri, opts) {\n        var _a;\n        super();\n        this.nsps = {};\n        this.subs = [];\n        if (uri && \"object\" === typeof uri) {\n            opts = uri;\n            uri = undefined;\n        }\n        opts = opts || {};\n        opts.path = opts.path || \"/socket.io\";\n        this.opts = opts;\n        installTimerFunctions(this, opts);\n        this.reconnection(opts.reconnection !== false);\n        this.reconnectionAttempts(opts.reconnectionAttempts || Infinity);\n        this.reconnectionDelay(opts.reconnectionDelay || 1000);\n        this.reconnectionDelayMax(opts.reconnectionDelayMax || 5000);\n        this.randomizationFactor((_a = opts.randomizationFactor) !== null && _a !== void 0 ? _a : 0.5);\n        this.backoff = new Backoff({\n            min: this.reconnectionDelay(),\n            max: this.reconnectionDelayMax(),\n            jitter: this.randomizationFactor(),\n        });\n        this.timeout(null == opts.timeout ? 20000 : opts.timeout);\n        this._readyState = \"closed\";\n        this.uri = uri;\n        const _parser = opts.parser || parser;\n        this.encoder = new _parser.Encoder();\n        this.decoder = new _parser.Decoder();\n        this._autoConnect = opts.autoConnect !== false;\n        if (this._autoConnect)\n            this.open();\n    }\n    reconnection(v) {\n        if (!arguments.length)\n            return this._reconnection;\n        this._reconnection = !!v;\n        if (!v) {\n            this.skipReconnect = true;\n        }\n        return this;\n    }\n    reconnectionAttempts(v) {\n        if (v === undefined)\n            return this._reconnectionAttempts;\n        this._reconnectionAttempts = v;\n        return this;\n    }\n    reconnectionDelay(v) {\n        var _a;\n        if (v === undefined)\n            return this._reconnectionDelay;\n        this._reconnectionDelay = v;\n        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMin(v);\n        return this;\n    }\n    randomizationFactor(v) {\n        var _a;\n        if (v === undefined)\n            return this._randomizationFactor;\n        this._randomizationFactor = v;\n        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setJitter(v);\n        return this;\n    }\n    reconnectionDelayMax(v) {\n        var _a;\n        if (v === undefined)\n            return this._reconnectionDelayMax;\n        this._reconnectionDelayMax = v;\n        (_a = this.backoff) === null || _a === void 0 ? void 0 : _a.setMax(v);\n        return this;\n    }\n    timeout(v) {\n        if (!arguments.length)\n            return this._timeout;\n        this._timeout = v;\n        return this;\n    }\n    /**\n     * Starts trying to reconnect if reconnection is enabled and we have not\n     * started reconnecting yet\n     *\n     * @private\n     */\n    maybeReconnectOnOpen() {\n        // Only try to reconnect if it's the first time we're connecting\n        if (!this._reconnecting &&\n            this._reconnection &&\n            this.backoff.attempts === 0) {\n            // keeps reconnection from firing twice for the same reconnection loop\n            this.reconnect();\n        }\n    }\n    /**\n     * Sets the current transport `socket`.\n     *\n     * @param {Function} fn - optional, callback\n     * @return self\n     * @public\n     */\n    open(fn) {\n        if (~this._readyState.indexOf(\"open\"))\n            return this;\n        this.engine = new Engine(this.uri, this.opts);\n        const socket = this.engine;\n        const self = this;\n        this._readyState = \"opening\";\n        this.skipReconnect = false;\n        // emit `open`\n        const openSubDestroy = on(socket, \"open\", function () {\n            self.onopen();\n            fn && fn();\n        });\n        const onError = (err) => {\n            this.cleanup();\n            this._readyState = \"closed\";\n            this.emitReserved(\"error\", err);\n            if (fn) {\n                fn(err);\n            }\n            else {\n                // Only do this if there is no fn to handle the error\n                this.maybeReconnectOnOpen();\n            }\n        };\n        // emit `error`\n        const errorSub = on(socket, \"error\", onError);\n        if (false !== this._timeout) {\n            const timeout = this._timeout;\n            // set timer\n            const timer = this.setTimeoutFn(() => {\n                openSubDestroy();\n                onError(new Error(\"timeout\"));\n                socket.close();\n            }, timeout);\n            if (this.opts.autoUnref) {\n                timer.unref();\n            }\n            this.subs.push(() => {\n                this.clearTimeoutFn(timer);\n            });\n        }\n        this.subs.push(openSubDestroy);\n        this.subs.push(errorSub);\n        return this;\n    }\n    /**\n     * Alias for open()\n     *\n     * @return self\n     * @public\n     */\n    connect(fn) {\n        return this.open(fn);\n    }\n    /**\n     * Called upon transport open.\n     *\n     * @private\n     */\n    onopen() {\n        // clear old subs\n        this.cleanup();\n        // mark as open\n        this._readyState = \"open\";\n        this.emitReserved(\"open\");\n        // add new subs\n        const socket = this.engine;\n        this.subs.push(on(socket, \"ping\", this.onping.bind(this)), on(socket, \"data\", this.ondata.bind(this)), on(socket, \"error\", this.onerror.bind(this)), on(socket, \"close\", this.onclose.bind(this)), \n        // @ts-ignore\n        on(this.decoder, \"decoded\", this.ondecoded.bind(this)));\n    }\n    /**\n     * Called upon a ping.\n     *\n     * @private\n     */\n    onping() {\n        this.emitReserved(\"ping\");\n    }\n    /**\n     * Called with data.\n     *\n     * @private\n     */\n    ondata(data) {\n        try {\n            this.decoder.add(data);\n        }\n        catch (e) {\n            this.onclose(\"parse error\", e);\n        }\n    }\n    /**\n     * Called when parser fully decodes a packet.\n     *\n     * @private\n     */\n    ondecoded(packet) {\n        // the nextTick call prevents an exception in a user-provided event listener from triggering a disconnection due to a \"parse error\"\n        nextTick(() => {\n            this.emitReserved(\"packet\", packet);\n        }, this.setTimeoutFn);\n    }\n    /**\n     * Called upon socket error.\n     *\n     * @private\n     */\n    onerror(err) {\n        this.emitReserved(\"error\", err);\n    }\n    /**\n     * Creates a new socket for the given `nsp`.\n     *\n     * @return {Socket}\n     * @public\n     */\n    socket(nsp, opts) {\n        let socket = this.nsps[nsp];\n        if (!socket) {\n            socket = new Socket(this, nsp, opts);\n            this.nsps[nsp] = socket;\n        }\n        else if (this._autoConnect && !socket.active) {\n            socket.connect();\n        }\n        return socket;\n    }\n    /**\n     * Called upon a socket close.\n     *\n     * @param socket\n     * @private\n     */\n    _destroy(socket) {\n        const nsps = Object.keys(this.nsps);\n        for (const nsp of nsps) {\n            const socket = this.nsps[nsp];\n            if (socket.active) {\n                return;\n            }\n        }\n        this._close();\n    }\n    /**\n     * Writes a packet.\n     *\n     * @param packet\n     * @private\n     */\n    _packet(packet) {\n        const encodedPackets = this.encoder.encode(packet);\n        for (let i = 0; i < encodedPackets.length; i++) {\n            this.engine.write(encodedPackets[i], packet.options);\n        }\n    }\n    /**\n     * Clean up transport subscriptions and packet buffer.\n     *\n     * @private\n     */\n    cleanup() {\n        this.subs.forEach((subDestroy) => subDestroy());\n        this.subs.length = 0;\n        this.decoder.destroy();\n    }\n    /**\n     * Close the current socket.\n     *\n     * @private\n     */\n    _close() {\n        this.skipReconnect = true;\n        this._reconnecting = false;\n        this.onclose(\"forced close\");\n    }\n    /**\n     * Alias for close()\n     *\n     * @private\n     */\n    disconnect() {\n        return this._close();\n    }\n    /**\n     * Called when:\n     *\n     * - the low-level engine is closed\n     * - the parser encountered a badly formatted packet\n     * - all sockets are disconnected\n     *\n     * @private\n     */\n    onclose(reason, description) {\n        var _a;\n        this.cleanup();\n        (_a = this.engine) === null || _a === void 0 ? void 0 : _a.close();\n        this.backoff.reset();\n        this._readyState = \"closed\";\n        this.emitReserved(\"close\", reason, description);\n        if (this._reconnection && !this.skipReconnect) {\n            this.reconnect();\n        }\n    }\n    /**\n     * Attempt a reconnection.\n     *\n     * @private\n     */\n    reconnect() {\n        if (this._reconnecting || this.skipReconnect)\n            return this;\n        const self = this;\n        if (this.backoff.attempts >= this._reconnectionAttempts) {\n            this.backoff.reset();\n            this.emitReserved(\"reconnect_failed\");\n            this._reconnecting = false;\n        }\n        else {\n            const delay = this.backoff.duration();\n            this._reconnecting = true;\n            const timer = this.setTimeoutFn(() => {\n                if (self.skipReconnect)\n                    return;\n                this.emitReserved(\"reconnect_attempt\", self.backoff.attempts);\n                // check again for the case socket closed in above events\n                if (self.skipReconnect)\n                    return;\n                self.open((err) => {\n                    if (err) {\n                        self._reconnecting = false;\n                        self.reconnect();\n                        this.emitReserved(\"reconnect_error\", err);\n                    }\n                    else {\n                        self.onreconnect();\n                    }\n                });\n            }, delay);\n            if (this.opts.autoUnref) {\n                timer.unref();\n            }\n            this.subs.push(() => {\n                this.clearTimeoutFn(timer);\n            });\n        }\n    }\n    /**\n     * Called upon successful reconnect.\n     *\n     * @private\n     */\n    onreconnect() {\n        const attempt = this.backoff.attempts;\n        this._reconnecting = false;\n        this.backoff.reset();\n        this.emitReserved(\"reconnect\", attempt);\n    }\n}\n","import { url } from \"./url.js\";\nimport { Manager } from \"./manager.js\";\nimport { Socket } from \"./socket.js\";\n/**\n * Managers cache.\n */\nconst cache = {};\nfunction lookup(uri, opts) {\n    if (typeof uri === \"object\") {\n        opts = uri;\n        uri = undefined;\n    }\n    opts = opts || {};\n    const parsed = url(uri, opts.path || \"/socket.io\");\n    const source = parsed.source;\n    const id = parsed.id;\n    const path = parsed.path;\n    const sameNamespace = cache[id] && path in cache[id][\"nsps\"];\n    const newConnection = opts.forceNew ||\n        opts[\"force new connection\"] ||\n        false === opts.multiplex ||\n        sameNamespace;\n    let io;\n    if (newConnection) {\n        io = new Manager(source, opts);\n    }\n    else {\n        if (!cache[id]) {\n            cache[id] = new Manager(source, opts);\n        }\n        io = cache[id];\n    }\n    if (parsed.query && !opts.query) {\n        opts.query = parsed.queryKey;\n    }\n    return io.socket(parsed.path, opts);\n}\n// so that \"lookup\" can be used both as a function (e.g. `io(...)`) and as a\n// namespace (e.g. `io.connect(...)`), for backward compatibility\nObject.assign(lookup, {\n    Manager,\n    Socket,\n    io: lookup,\n    connect: lookup,\n});\n/**\n * Protocol version.\n *\n * @public\n */\nexport { protocol } from \"socket.io-parser\";\n/**\n * Expose constructors for standalone build.\n *\n * @public\n */\nexport { Manager, Socket, lookup as io, lookup as connect, lookup as default, };\nexport { Fetch, NodeXHR, XHR, NodeWebSocket, WebSocket, WebTransport, } from \"engine.io-client\";\n","import { parse } from \"engine.io-client\";\n/**\n * URL parser.\n *\n * @param uri - url\n * @param path - the request path of the connection\n * @param loc - An object meant to mimic window.location.\n *        Defaults to window.location.\n * @public\n */\nexport function url(uri, path = \"\", loc) {\n    let obj = uri;\n    // default to window.location\n    loc = loc || (typeof location !== \"undefined\" && location);\n    if (null == uri)\n        uri = loc.protocol + \"//\" + loc.host;\n    // relative path support\n    if (typeof uri === \"string\") {\n        if (\"/\" === uri.charAt(0)) {\n            if (\"/\" === uri.charAt(1)) {\n                uri = loc.protocol + uri;\n            }\n            else {\n                uri = loc.host + uri;\n            }\n        }\n        if (!/^(https?|wss?):\\/\\//.test(uri)) {\n            if (\"undefined\" !== typeof loc) {\n                uri = loc.protocol + \"//\" + uri;\n            }\n            else {\n                uri = \"https://\" + uri;\n            }\n        }\n        // parse\n        obj = parse(uri);\n    }\n    // make sure we treat `localhost:80` and `localhost` equally\n    if (!obj.port) {\n        if (/^(http|ws)$/.test(obj.protocol)) {\n            obj.port = \"80\";\n        }\n        else if (/^(http|ws)s$/.test(obj.protocol)) {\n            obj.port = \"443\";\n        }\n    }\n    obj.path = obj.path || \"/\";\n    const ipv6 = obj.host.indexOf(\":\") !== -1;\n    const host = ipv6 ? \"[\" + obj.host + \"]\" : obj.host;\n    // define unique id\n    obj.id = obj.protocol + \"://\" + host + \":\" + obj.port + path;\n    // define href\n    obj.href =\n        obj.protocol +\n            \"://\" +\n            host +\n            (loc && loc.port === obj.port ? \"\" : \":\" + obj.port);\n    return obj;\n}\n"],"names":["_typeof","obj","Symbol","iterator","constructor","prototype","mulTable","shgTable","getImageDataFromCanvas","canvas","topX","topY","width","height","document","getElementById","TypeError","context","getContext","getImageData","e","Error","processCanvasRGBA","radius","isNaN","imageData","stackEnd","pixels","data","div","widthMinus1","heightMinus1","radiusPlus1","sumFactor","stackStart","BlurStack","stack","i","next","stackIn","stackOut","yw","yi","mulSum","shgSum","y","pr","pg","pb","pa","_i","r","g","b","a","rInSum","gInSum","bInSum","aInSum","rOutSum","gOutSum","bOutSum","aOutSum","rSum","gSum","bSum","aSum","_i2","p","rbs","x","paInitial","_a2","_p","_stackOut","_r","_g","_b","_a","_x","_pr","_pg","_pb","_pa","_rOutSum","_gOutSum","_bOutSum","_aOutSum","_rSum","_gSum","_bSum","_aSum","_i3","yp","_gInSum","_bInSum","_aInSum","_rInSum","_i4","_rbs","_y","_p2","processImageDataRGBA","putImageData","instance","Constructor","_classCallCheck","this","Emitter","key","mixin","on","addEventListener","event","fn","_callbacks","push","once","off","apply","arguments","removeListener","removeAllListeners","removeEventListener","length","cb","callbacks","splice","emit","args","Array","len","slice","emitReserved","listeners","hasListeners","withNativeArrayBuffer","ArrayBuffer","toString","Object","withNativeBlob","Blob","call","withNativeFile","File","isBinary","isView","buffer","hasBinary","toJSON","isArray","l","hasOwnProperty","deconstructPacket","packet","buffers","packetData","pack","_deconstructPacket","attachments","placeholder","_placeholder","num","newData","Date","reconstructPacket","_reconstructPacket","RESERVED_EVENTS","protocol","PacketType","Encoder","replacer","encode","type","EVENT","ACK","encodeAsString","encodeAsBinary","BINARY_EVENT","BINARY_ACK","nsp","id","str","JSON","stringify","deconstruction","unshift","isObject","value","Decoder","reviver","super","add","reconstructor","decodeString","isBinaryEvent","BinaryReconstructor","base64","takeBinaryData","Number","charAt","undefined","start","buf","substring","c","payload","tryParse","substr","isPayloadValid","parse","CONNECT","DISCONNECT","CONNECT_ERROR","indexOf","destroy","finishedReconstruction","reconPack","binData","ev","freeze","connect","connect_error","disconnect","disconnecting","newListener","Socket","io","opts","connected","recovered","receiveBuffer","sendBuffer","_queue","_queueSeq","ids","acks","flags","auth","_opts","assign","_autoConnect","open","disconnected","subEvents","subs","onopen","bind","onpacket","onerror","onclose","active","_readyState","send","_len","_key","_c","_len2","_key2","retries","fromQueue","volatile","_addToQueue","options","compress","ack","pop","_registerAckCallback","isTransportWritable","engine","transport","writable","isConnected","_hasPingExpired","notifyOutgoingListeners","_this","timeout","ackTimeout","timer","setTimeoutFn","clearTimeoutFn","_len3","_key3","withError","emitWithAck","_len4","_key4","Promise","resolve","reject","arg1","arg2","_this2","tryCount","pending","err","shift","_len5","responseArgs","_key5","_drainQueue","force","_packet","_sendConnectPacket","_pid","pid","offset","_lastOffset","reason","description","_clearAcks","keys","forEach","some","String","sid","onconnect","onevent","onack","ondisconnect","message","emitEvent","_anyListeners","listener","self","sent","_len6","_key6","emitBuffered","subDestroy","close","onAny","prependAny","offAny","listenersAny","onAnyOutgoing","_anyOutgoingListeners","prependAnyOutgoing","offAnyOutgoing","listenersAnyOutgoing","Backoff","ms","min","max","factor","jitter","attempts","duration","Math","pow","rand","random","deviation","floor","reset","setMin","setMax","setJitter","Manager","uri","nsps","path","installTimerFunctions","reconnection","reconnectionAttempts","Infinity","reconnectionDelay","reconnectionDelayMax","randomizationFactor","backoff","_parser","parser","encoder","decoder","autoConnect","v","_reconnection","skipReconnect","_reconnectionAttempts","_reconnectionDelay","_randomizationFactor","_reconnectionDelayMax","_timeout","maybeReconnectOnOpen","_reconnecting","reconnect","Engine","socket","openSubDestroy","onError","cleanup","errorSub","autoUnref","unref","onping","ondata","ondecoded","nextTick","_destroy","_close","encodedPackets","write","delay","onreconnect","attempt","cache","lookup","parsed","loc","location","host","test","port","href","url","source","sameNamespace","forceNew","multiplex","query","queryKey"],"sourceRoot":""}