{"version":3,"file":"npm.datadog.9e0be60b.js","mappings":"yIAQO,IAAIA,EAAU,CACjBC,IAAKC,QAAQD,IAAIE,KAAKD,SACtBE,KAAMF,QAAQE,KAAKD,KAAKD,SACxBG,MAAOH,QAAQG,MAAMF,KAAKD,UCX1BI,EAAmB,IAIhB,SAASC,EAAkBC,GAC9B,IAAIC,EAAQ,GACRC,EAAgBC,EAAeH,EAAI,SAYvC,OAXIE,GACAA,EAAcE,MAAM,MAAMC,SAAQ,SAAUC,GACxC,IAAIC,EAmBhB,SAAyBD,GACrB,IAAIE,EAAQC,EAAeC,KAAKJ,GAChC,GAAKE,EAAL,CAGA,IAAIG,EAAWH,EAAM,IAAqC,IAA/BA,EAAM,GAAGI,QAAQ,UACxCC,EAASL,EAAM,IAAmC,IAA7BA,EAAM,GAAGI,QAAQ,QACtCE,EAAWC,EAAeL,KAAKF,EAAM,IAOzC,OANIK,GAAUC,IAEVN,EAAM,GAAKM,EAAS,GACpBN,EAAM,GAAKM,EAAS,GACpBN,EAAM,GAAKM,EAAS,IAEjB,CACHE,KAAML,EAAW,CAACH,EAAM,IAAM,GAC9BS,OAAQT,EAAM,IAAMA,EAAM,QAAKU,EAC/BC,KAAMX,EAAM,IAAMV,EAClBQ,KAAME,EAAM,IAAMA,EAAM,QAAKU,EAC7BE,IAAMT,OAAsBO,EAAXV,EAAM,KAtCFa,CAAgBf,IA0C7C,SAAsBA,GAClB,IAAIE,EAAQc,EAAcZ,KAAKJ,GAC/B,GAAKE,EAGL,MAAO,CACHQ,KAAM,GACNC,OAAQT,EAAM,IAAMA,EAAM,QAAKU,EAC/BC,KAAMX,EAAM,IAAMV,EAClBQ,MAAOE,EAAM,GACbY,IAAKZ,EAAM,IApDmCe,CAAajB,IA2DnE,SAAwBA,GACpB,IAAIE,EAAQgB,EAAcd,KAAKJ,GAC/B,GAAKE,EAAL,CAGA,IAAIK,EAASL,EAAM,IAAMA,EAAM,GAAGI,QAAQ,YAAc,EACpDE,EAAWW,EAAcf,KAAKF,EAAM,IAOxC,OANIK,GAAUC,IAEVN,EAAM,GAAKM,EAAS,GACpBN,EAAM,GAAKM,EAAS,GACpBN,EAAM,QAAKU,GAER,CACHF,KAAMR,EAAM,GAAKA,EAAM,GAAGJ,MAAM,KAAO,GACvCa,OAAQT,EAAM,IAAMA,EAAM,QAAKU,EAC/BC,KAAMX,EAAM,IAAMV,EAClBQ,KAAME,EAAM,IAAMA,EAAM,QAAKU,EAC7BE,IAAKZ,EAAM,KA7EyDkB,CAAepB,GAC3EC,KACKA,EAAWY,MAAQZ,EAAWD,OAC/BC,EAAWY,KAAOrB,GAEtBG,EAAM0B,KAAKpB,OAIhB,CACHqB,QAASzB,EAAeH,EAAI,WAC5B6B,KAAM1B,EAAeH,EAAI,QACzBC,MAAOA,GAGf,IAAIQ,EAEJ,8HACIM,EAAiB,gCAuBjBO,EAAgB,gHAchBE,EAEJ,4IACIC,EAAgB,gDAsBpB,SAAStB,EAAe2B,EAAWC,GAC/B,GAAyB,iBAAdD,GAA2BA,GAAeC,KAAYD,EAAjE,CAGA,IAAIE,EAAQF,EAAUC,GACtB,MAAwB,iBAAVC,EAAqBA,OAAQd,GC7FxC,IAAIe,EAAa,IAOjB,SAASC,EAASC,EAAIC,EAAMC,GAC/B,IAGIC,EACAC,EAJAC,GAAuBH,QAA+BnB,IAApBmB,EAAQI,SAAwBJ,EAAQI,QAC1EC,GAAwBL,QAAgCnB,IAArBmB,EAAQM,UAAyBN,EAAQM,SAC5EC,GAAe,EAGnB,MAAO,CACHC,UAAW,WAEP,IADA,IAAIC,EAAa,GACRC,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCD,EAAWC,GAAMC,UAAUD,GAE3BH,EACAN,EAAiCQ,GAGjCN,EACAL,EAAGe,WAAM,EAAQJ,GAGjBR,EAAiCQ,EAErCF,GAAe,EACfL,EAAmBY,YAAW,WACtBT,GAAyBJ,GACzBH,EAAGe,WAAM,EAAQZ,GAErBM,GAAe,EACfN,OAAiCpB,IAClCkB,KAEPgB,OAAQ,WACJC,aAAad,GACbK,GAAe,EACfN,OAAiCpB,IAItC,SAAS,EAAOoC,GAEnB,IADA,IAAIC,EAAW,GACNR,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCQ,EAASR,EAAK,GAAKC,UAAUD,GASjC,OAPAQ,EAASlD,SAAQ,SAAUmD,GACvB,IAAK,IAAIC,KAAOD,EACRE,OAAOC,UAAUC,eAAeC,KAAKL,EAAQC,KAC7CH,EAAOG,GAAOD,EAAOC,OAI1BH,EAEJ,SAASQ,EAAaC,GACzB,OAAO,EAAO,GAAIA,GAMf,SAASC,EAAaC,GACzB,OAAOA,GAEEC,SAASD,EAAa,IAAwB,GAAhBE,KAAKC,UAAmBF,SAASD,EAAa,IAAM,GAAKI,SAAS,IACnG,GAAGC,OAAO,IAAK,KAAKA,OAAO,IAAK,KAAKA,OAAO,IAAK,KAAKA,OAAO,IAAK,KAAKA,OAAO,MAAMC,QAAQ,SAAUP,GAMzG,SAASQ,EAAYC,GACxB,OAAqB,IAAdA,GAAmC,IAAhBN,KAAKC,UAAkBK,EAE9C,SAASC,EAAMC,EAAKC,GACvB,OAAQD,EAAIE,QAAQD,GAGjB,SAASE,KAMT,SAASC,EAAc/C,EAAOgD,EAAUC,GAC3C,GAAIjD,MAAAA,EACA,OAAOkD,KAAKC,UAAUnD,GAE1B,IAAIoD,EAAiB,EAAC,OAAOlE,GACzBmE,EAAUrD,KAGVoD,EAAiB,EAAC,EAAMpD,EAAMsD,eACvBtD,EAAMsD,QAEjB,IACI3B,EAQA4B,EATAC,EAAsB,EAAC,OAAOtE,GAEb,iBAAVc,GAEHqD,EADJ1B,EAAYD,OAAO+B,eAAezD,MAE9BwD,EAAsB,EAAC,EAAM7B,EAAU2B,eAChC3B,EAAU2B,QAIzB,IACIC,EAASL,KAAKC,UAAUnD,EAAOgD,EAAUC,GAE7C,MAAOS,GACHH,EAAS,sCAEb,QACQH,EAAe,KAEfpD,EAAMsD,OAASF,EAAe,IAE9BI,EAAoB,KAEpB7B,EAAU2B,OAASE,EAAoB,IAG/C,OAAOD,EAEX,SAASF,EAAUrD,GACf,MAAwB,iBAAVA,GAAgC,OAAVA,GAAkB0B,OAAOC,UAAUC,eAAeC,KAAK7B,EAAO,UAE/F,SAAS2D,EAAS7D,EAAW8D,GAChC,OAAsC,IAA/B9D,EAAUlB,QAAQgF,GAEtB,SAASC,EAAKC,EAAOC,GACxB,IAAK,IAAIC,EAAI,EAAGA,EAAIF,EAAM7C,OAAQ+C,GAAK,EAAG,CACtC,IAAIC,EAAOH,EAAME,GACjB,GAAID,EAAUE,EAAMD,EAAGF,GACnB,OAAOG,GAcZ,SAASC,EAAalE,GACzB,OAAOmE,EAASnE,IAAUA,GAAS,GAAKA,GAAS,IAE9C,SAASmE,EAASnE,GACrB,MAAwB,iBAAVA,EAEX,SAASoE,EAAarC,GACzB,OAAOL,OAAO2C,KAAKtC,GAAQuC,KAAI,SAAU7C,GAAO,OAAOM,EAAON,MAK3D,SAAS8C,EAAcxC,GAC1B,OAAOL,OAAO2C,KAAKtC,GAAQuC,KAAI,SAAU7C,GAAO,MAAO,CAACA,EAAKM,EAAON,OAEjE,SAAS+C,EAAczC,GAC1B,OAAsC,IAA/BL,OAAO2C,KAAKtC,GAAQd,OAaxB,SAASwD,IACZ,GAA0B,iBAAfC,WACP,OAAOA,WAEXhD,OAAOiD,eAAejD,OAAOC,UAAW,YAAa,CACjDiD,IAAK,WACD,OAAOC,MAEXC,cAAc,IAGlB,IAAIC,EAAeC,UAgBnB,cAdOtD,OAAOC,UAAUqD,UACI,iBAAjBD,IAIHA,EADgB,iBAATE,KACQA,KAEQ,iBAAXC,OACGA,OAGA,IAGhBH,EASJ,SAASI,EAAqBC,GACjC,GAAIA,EAAQC,OACR,OAAOD,EAAQC,OAEnB,IAAIC,EAAgBF,EAAQG,KAAKhD,QAAQ,cAAe,IACxD,MAAO,GAAGD,OAAO8C,EAAQI,SAAU,MAAMlD,OAAOgD,GAE7C,SAASG,EAAwBC,EAAW7F,GAC/C,IACI8F,EADQ,IAAIC,OAAO,cAActD,OAAOzC,EAAM,qBAC9BnB,KAAKgH,GACzB,OAAOC,EAAUA,EAAQ,QAAKzG,EAE3B,SAAS2G,EAAa/F,EAAWmB,EAAQ6E,QAC7B,IAAXA,IAAqBA,EAAS,IAClC,IAAIC,EAAWjG,EAAUkG,WAAW/E,EAAS,GAEzCgF,EAD0BF,GAAY,OAAUA,GAAY,MAChB9E,EAAS,EAAIA,EAC7D,OAAInB,EAAUmB,QAAUgF,EACbnG,EACJ,GAAGwC,OAAOxC,EAAUoG,MAAM,EAAGD,IAAkB3D,OAAOwD,GAY1D,SAASK,EAAiBC,EAASC,EAAOC,EAAUjG,GACvD,OAAOkG,EAAkBH,EAAS,CAACC,GAAQC,EAAUjG,GAclD,SAASkG,EAAkBH,EAASI,EAAQF,EAAU5C,GACzD,IAAI+C,OAAY,IAAP/C,EAAgB,GAAKA,EAAIgD,EAAOD,EAAGC,KAAMC,EAAUF,EAAGE,QAASC,EAAUH,EAAGG,QACjFC,EAAkBC,GAAQJ,EACxB,SAAUL,GACRU,IACAT,EAASD,IAEXC,GACFjG,EAAUuG,EAAU,CAAED,QAASA,EAASC,QAASA,GAAYD,EACjEH,EAAOnI,SAAQ,SAAUgI,GAAS,OAAOD,EAAQD,iBAAiBE,EAAOQ,EAAiBxG,MAC1F,IAAI0G,EAAO,WAAc,OAAOP,EAAOnI,SAAQ,SAAUgI,GAAS,OAAOD,EAAQY,oBAAoBX,EAAOQ,EAAiBxG,OAC7H,MAAO,CACH0G,KAAMA,GAGP,SAASE,EAAgBC,EAAoBC,GAC5CC,SAASC,aAAeH,GAA8C,aAAxBE,SAASC,WACvDF,IAIAhB,EAAiBjB,OADsB,aAAvBgC,EAAoC,OAAoB,mBACpCC,EAAU,CAAET,MAAM,IAMvD,SAASY,EAAQtH,GACpB,OAAc,OAAVA,EACO,OAEPuH,MAAMC,QAAQxH,GACP,eAEGA,EA8BX,SAASyH,EAAUC,EAAalG,EAAQmG,GAG3C,QAFiC,IAA7BA,IAAuCA,EA7B/C,WACI,GAAuB,oBAAZC,QAAyB,CAChC,IAAIC,EAAQ,IAAID,QAChB,MAAO,CACHE,mBAAoB,SAAU9H,GAC1B,IAAI+H,EAAMF,EAAME,IAAI/H,GAIpB,OAHK+H,GACDF,EAAMG,IAAIhI,GAEP+H,IAInB,IAAIjE,EAAQ,GACZ,MAAO,CACHgE,mBAAoB,SAAU9H,GAC1B,IAAI+H,EAAMjE,EAAMlF,QAAQoB,IAAU,EAIlC,OAHK+H,GACDjE,EAAMnE,KAAKK,GAER+H,IASuDE,SAEvD/I,IAAXsC,EACA,OAAOkG,EAEX,GAAsB,iBAAXlG,GAAkC,OAAXA,EAE9B,OAAOA,EAEN,GAAIA,aAAkB0G,KACvB,OAAO,IAAIA,KAAK1G,EAAO2G,WAEtB,GAAI3G,aAAkBoE,OAAQ,CAC/B,IAAIwC,EAAQ5G,EAAO4G,OAEf,CACI5G,EAAO6G,OAAS,IAAM,GACtB7G,EAAO8G,WAAa,IAAM,GAC1B9G,EAAO+G,UAAY,IAAM,GACzB/G,EAAOgH,OAAS,IAAM,GACtBhH,EAAOiH,QAAU,IAAM,IACzBC,KAAK,IACX,OAAO,IAAI9C,OAAOpE,EAAOA,OAAQ4G,GAErC,IAAIT,EAAyBG,mBAAmBtG,GAAhD,CAIK,GAAI+F,MAAMC,QAAQhG,GAAS,CAE5B,IADA,IAAImH,EAAWpB,MAAMC,QAAQE,GAAeA,EAAc,GACjD1D,EAAI,EAAGA,EAAIxC,EAAOP,SAAU+C,EACjC2E,EAAS3E,GAAKyD,EAAUkB,EAAS3E,GAAIxC,EAAOwC,GAAI2D,GAEpD,OAAOgB,EAEX,IAAIC,EAAkC,WAAzBtB,EAAQI,GAA4BA,EAAc,GAC/D,IAAK,IAAIjG,KAAOD,EACRE,OAAOC,UAAUC,eAAeC,KAAKL,EAAQC,KAC7CmH,EAAOnH,GAAOgG,EAAUmB,EAAOnH,GAAMD,EAAOC,GAAMkG,IAG1D,OAAOiB,GAQJ,SAASC,EAAU7I,GACtB,OAAOyH,OAAUvI,EAAWc,GAEzB,SAAS8I,IAEZ,IADA,IAIIpB,EAJAqB,EAAU,GACLhI,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCgI,EAAQhI,GAAMC,UAAUD,GAG5B,IAAK,IAAI2C,EAAK,EAAGsF,EAAYD,EAASrF,EAAKsF,EAAU/H,OAAQyC,IAAM,CAC/D,IAAIlC,EAASwH,EAAUtF,GAEnBlC,MAAAA,IAGJkG,EAAcD,EAAUC,EAAalG,IAEzC,OAAOkG,EC/XJ,SAASuB,EAAmBC,EAAYC,EAAaC,EAAgBC,GACxE,OAAKH,SAAsChK,IAAvBgK,EAAWtJ,SAA2BuJ,aAAuBG,OAQ1E,CACH1J,QAASsJ,EAAWtJ,SAAW,gBAC/B3B,MAAOsL,EAAmBL,GAC1BG,cAAeA,EACfG,KAAMN,EAAWrJ,MAXV,CACHD,QAAS,GAAG0C,OAAO8G,EAAgB,KAAK9G,OAAOS,EAAcoG,IAC7DlL,MAAO,gDACPoL,cAAeA,EACfG,KAAMN,GAAcA,EAAWrJ,MAUpC,SAAS0J,EAAmBtL,GAC/B,IAAIsF,EAASkG,EAAmBxL,GAQhC,OAPAA,EAAMA,MAAMI,SAAQ,SAAUqL,GAC1B,IAAIvK,EAAsB,MAAfuK,EAAMvK,KAAe,cAAgBuK,EAAMvK,KAClDH,EAAO0K,EAAM1K,MAAQ0K,EAAM1K,KAAKiC,OAAS,EAAI,IAAIqB,OAAOoH,EAAM1K,KAAK0J,KAAK,MAAO,KAAO,GACtFpK,EAAOoL,EAAMpL,KAAO,IAAIgE,OAAOoH,EAAMpL,MAAQ,GAC7CW,EAASyK,EAAMpL,MAAQoL,EAAMzK,OAAS,IAAIqD,OAAOoH,EAAMzK,QAAU,GACrEsE,GAAU,UAAUjB,OAAOnD,GAAMmD,OAAOtD,EAAM,OAAOsD,OAAOoH,EAAMtK,KAAKkD,OAAOhE,GAAMgE,OAAOrD,MAExFsE,EAMJ,SAASkG,EAAmBxL,GAC/B,MAAO,GAAGqE,OAAOrE,EAAM4B,MAAQ,QAAS,MAAMyC,OAAOrE,EAAM2B,SASxD,SAAS+J,IAOZ,IAEIC,EADA/L,EAAQ,IAAIyL,MAGhB,IAAKzL,EAAMI,MACP,IACI,MAAMJ,EAEV,MAAOgM,IASX,OALAC,IAAc,WACV,IAAIZ,EAAanL,EAAkBF,GACnCqL,EAAWjL,MAAQiL,EAAWjL,MAAMiI,MAdb,GAevB0D,EAAiBL,EAAmBL,MAEjCU,EC7EX,IC0DIG,ECpDAC,EFNAC,EAA4B,WAC5B,SAASA,EAAWC,GAChBrF,KAAKqF,iBAAmBA,EACxBrF,KAAKsF,UAAY,GAoBrB,OAlBAF,EAAWtI,UAAUyI,UAAY,SAAUC,GACvC,IAAIC,EAAQzF,KAKZ,OAJKA,KAAKsF,UAAUlJ,QAAU4D,KAAKqF,mBAC/BrF,KAAK0F,kBAAoB1F,KAAKqF,yBAAsBhL,GAExD2F,KAAKsF,UAAUxK,KAAK0K,GACb,CACHG,YAAa,WACTF,EAAMH,UAAYG,EAAMH,UAAUM,QAAO,SAAUC,GAAS,OAAOL,IAAMK,MACpEJ,EAAMH,UAAUlJ,QAAUqJ,EAAMC,mBACjCD,EAAMC,uBAKtBN,EAAWtI,UAAUgJ,OAAS,SAAUC,GACpC/F,KAAKsF,UAAU9L,SAAQ,SAAUwM,GAAY,OAAOA,EAASD,OAE1DX,EAvBoB,GA0BxB,SAASa,IAEZ,IADA,IAAIC,EAAc,GACThK,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCgK,EAAYhK,GAAMC,UAAUD,GAEhC,IAAIiK,EAAmB,IAAIf,GAAW,WAClC,IAAIgB,EAAgBF,EAAYzG,KAAI,SAAU4G,GAC1C,OAAOA,EAAWd,WAAU,SAAUQ,GAAQ,OAAOI,EAAiBL,OAAOC,SAEjF,OAAO,WAAc,OAAOK,EAAc5M,SAAQ,SAAU8M,GAAgB,OAAOA,EAAaX,qBAEpG,OAAOQ,ECpCJ,SAASI,EAAiBC,GAC7B,MAAO,CAAEA,SAAUA,EAAUC,WAEFC,EAFmCF,EAG1DG,EAAkBtD,KAAKuD,MAAQC,YAAYD,MAE3CD,EAAkBG,KAEXxJ,KAAKO,MAAM8I,EAAkBD,GAuCrC,SAAsBA,GAEzB,OAAOpJ,KAAKO,MAAMiJ,KAAuBJ,GAvClCK,CAAaL,KAPxB,IAA+BA,EACvBC,EAYD,SAASK,EAAiBC,GAC7B,OAAK3H,EAAS2H,GAGPpJ,EAAiB,IAAXoJ,EAAgB,GAFlBA,EAIR,SAASC,IACZ,OAAO7D,KAAKuD,MAET,SAASO,IACZ,OAAON,YAAYD,MAEhB,SAASQ,IACZ,MAAO,CAAEZ,SAAUW,IAAeV,UAAWS,KAE1C,SAASG,IACZ,MAAO,CAAEb,SAAU,EAAGC,UAAWK,MAE9B,SAASQ,GAAQC,EAAOC,GAC3B,OAAQA,EAAMD,EASX,SAASE,GAAgBC,GAC5B,OAAQA,EAAYZ,KAaxB,SAASA,KAIL,YAHwBzM,IAApB6K,IACAA,EAAkB2B,YAAYc,OAAOzC,iBAElCA,EC1CJ,SAAS0C,GAA6BC,GACzC,QAAS1C,GAA+BA,EAA4BjC,IAAI2E,GCf5E,IACIC,GADAC,GAA0B,CAAEC,mBAAoB,EAAGC,iBAAkB,EAAGC,kBAAkB,GAuEvF,SAASjG,GAAQ3G,GACpB,OAAO,WAEH,OAAO2J,GAAc3J,EAAI0E,KAAM7D,YAGhC,SAAS8I,GAAc3J,EAAI6M,EAAShO,GACvC,IAEI,OAAOmB,EAAGe,MAAM8L,EAAShO,GAE7B,MAAO6K,GACHoD,GAAgBpD,GAChB,IACIqD,GAAmBrD,GAEvB,MAAOA,GACHoD,GAAgBpD,KAIrB,SAASsD,GAAqBvN,EAASoN,IA6C9C,SAA2BpN,EAASoN,GAC5BJ,GAAwBQ,WACxB5P,EAAQC,IAAI,uBAAwBmC,EAASoN,GA9CjDK,CAAkBzN,EAASoN,GAC3BM,GAAgB,EAAO,CACnB1N,QAASA,EACT2N,OAAQ,SACTP,IAEA,SAASE,GAAmBrD,GAC/ByD,GAAgB,EAAO,CACnBC,OAAQ,SAUhB,SAAqB1D,GACjB,GAAIA,aAAaP,MAAO,CACpB,IAAIJ,EAAanL,EAAkB8L,GACnC,MAAO,CACHhM,MAAO,CACH2P,KAAMtE,EAAWrJ,KACjB5B,MAAOsL,EAAmBL,IAE9BtJ,QAASsJ,EAAWtJ,SAG5B,MAAO,CACH/B,MAAO,CACHI,MAAO,4BAEX2B,QAAS,YAAY0C,OAAOS,EAAc8G,KAxB3C4D,CAAY5D,KAEnB,SAASyD,GAAgB1N,GACjB+M,IACAC,GAAwBE,iBAAmBF,GAAwBC,qBACnED,GAAwBE,kBAAoB,EAC5CH,GAAqC/M,IAqBtC,SAAS8N,GAAaN,GACzBR,GAAwBQ,UAAYA,EAExC,SAASH,GAAgBpD,GACjB+C,GAAwBQ,WACxB5P,EAAQK,MAAM,mBAAoBgM,GC5InC,SAAS8D,GAAgBxN,EAAIyN,GAChC,OAAO,WAEH,IADA,IAAI5O,EAAO,GACF+B,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpC/B,EAAK+B,GAAMC,UAAUD,GAEzB,IACI,OAAOZ,EAAGe,WAAM,EAAQlC,GAE5B,MAAO6O,GACHrQ,EAAQK,MAAM+P,EAAUC,KCXpC,IC0CIC,GCKAC,GF9CAC,GAA+B,WAC/B,SAASA,IACLnJ,KAAKoJ,OAAS,GAYlB,OAVAD,EAAcrM,UAAUqG,IAAM,SAAUb,GACvBtC,KAAKoJ,OAAOtO,KAAKwH,GANnB,KAQPtC,KAAKoJ,OAAOC,OAAO,EAAG,IAG9BF,EAAcrM,UAAUwM,MAAQ,WAC5BtJ,KAAKoJ,OAAO5P,SAAQ,SAAU8I,GAAY,OAAOA,OACjDtC,KAAKoJ,OAAOhN,OAAS,GAElB+M,EAduB,GGA3B,SAASI,KACZ,IAAIC,EAyBG5J,IAAkB6J,mBAxBzB,GAAKD,EAGL,MAAO,CACHE,uBAAwB,WACpB,OAAOrL,KAAKsL,MAAMH,EAAkBE,2BAExCE,KAAM,SAAUC,EAAWrI,GACvBgI,EAAkBI,KAAKvL,KAAKC,UAAU,CAAEuL,UAAWA,EAAWrI,MAAOA,OAI1E,SAASsI,GAAkBC,GAC9B,IAAIlL,OACa,IAAbkL,IAAuBA,EAAiD,QAArClL,EAAKe,IAAkBoK,gBAA6B,IAAPnL,OAAgB,EAASA,EAAGkL,UAChH,IAAIE,EAASV,KACb,QAAUU,GACNA,EAAOP,yBAAyBQ,MAAK,SAAUxJ,GAC3C,IAAIyJ,EAAczJ,EAAKhD,QAAQ,MAAO,OAEtC,OAD0B,IAAIqD,OAAO,YAAYtD,OAAO0M,EAAa,MAC1CC,KAAKL,MFpBrC,SAASM,GAAUrP,EAAMG,EAAOmP,EAAa9O,GAChD,IAAI+O,EAAO,IAAIlH,KACfkH,EAAKC,QAAQD,EAAKjH,UAAYgH,GAC9B,IAAIG,EAAU,WAAWhN,OAAO8M,EAAKG,eACjCC,EAAWnP,GAAWA,EAAQoP,UAAY,OAAS,SACnDC,EAASrP,GAAWA,EAAQqP,OAAS,WAAWpN,OAAOjC,EAAQqP,QAAU,GACzEC,EAAStP,GAAWA,EAAQsP,OAAS,UAAY,GACrDvI,SAASwI,OAAS,GAAGtN,OAAOzC,EAAM,KAAKyC,OAAOtC,EAAO,KAAKsC,OAAOgN,EAAS,qBAAqBhN,OAAOkN,GAAUlN,OAAOoN,GAAQpN,OAAOqN,GAEnI,SAASE,GAAUhQ,GACtB,OAAO4F,EAAwB2B,SAASwI,OAAQ/P,GAE7C,SAASiQ,GAAajQ,EAAMQ,GAC/B6O,GAAUrP,EAAM,GAAI,EAAGQ,GCfpB,SAAS0P,GAAa3Q,GACzB,OAAO4Q,GAAS5Q,ETkNT+F,EAAqBD,OAAO2J,WSlNOoB,KA0BvC,SAASD,GAAS5Q,EAAK8Q,GAC1B,GAmBJ,WACI,QAAuBhR,IAAnB6O,GACA,OAAOA,GAEX,IACI,IAAI3O,EAAM,IAAI+Q,IAAI,oBAElB,OADApC,GAA8B,qBAAb3O,EAAI6Q,KAGzB,MAAOvM,GACHqK,IAAiB,EAErB,OAAOA,GA/BHqC,GACA,YAAgBlR,IAATgR,EAAqB,IAAIC,IAAI/Q,EAAK8Q,GAAQ,IAAIC,IAAI/Q,GAE7D,QAAaF,IAATgR,IAAuB,IAAIjB,KAAK7P,GAChC,MAAM,IAAIkK,MAAM,iBAAiBhH,OAAOlD,EAAK,MAEjD,IAAIiR,EAAMjJ,SACNkJ,EAAgBD,EAAIE,cAAc,KACtC,QAAarR,IAATgR,EAAoB,CAEpB,IAAIM,GADJH,EAAMjJ,SAASqJ,eAAeC,mBAAmB,KAC3BH,cAAc,QACpCC,EAAYP,KAAOC,EACnBG,EAAIM,KAAKC,YAAYJ,GACrBH,EAAIQ,KAAKD,YAAYN,GAGzB,OADAA,EAAcL,KAAO7Q,EACdkR,EE1CJ,IAAIQ,GAAY,CACnBC,KAAM,OACNC,IAAK,MACLC,cAAe,kBAEfC,GAAgB,CAChBH,KAAM,OACNC,IAAK,MACLC,cAAe,UAERE,GAAiB,gBACrB,SAASC,GAAsBC,EAAmBC,EAAcC,EAAM/P,GACzE,IAAIkC,EAAK2N,EAAkBG,KAAMA,OAAc,IAAP9N,EAAgByN,GAAiBzN,EAAI+N,EAAcJ,EAAkBI,YACzGC,EAAcF,EAAKpT,MAAM,KACzBuT,EAAYD,EAAYE,MACxBrM,EAAO,GAAGjD,OAAOwO,GAAUQ,GAAe,oBAAoBhP,OAAOoP,EAAYhJ,KAAK,KAAM,KAAKpG,OAAOqP,GACxGE,EAAU,WAAWvP,OAAOiD,EAAM,YAAYjD,OAAO4O,GAAcI,IACnEQ,EAAWT,EAAkBS,UAAY/B,GAAasB,EAAkBS,UAC5E,MAAO,CACHC,MAAO,WACH,IAAIjR,EAAa,YAAYwB,OAAOd,GAAU,WAC1C,WAAWc,OAAO0P,mBAAmB,CAAC,eAAe1P,OAAO,UAAUA,OAAOiP,GAAM7I,KAAK,OACxF,eAAepG,OAAOmP,GACtB,0BAA0BnP,OAAO0P,mBAAmB,UACpD,yBACA,kBAAkB1P,OAAON,KACR,QAAjBsP,IACAxQ,GAAc,eAAewB,OAAOyJ,MAExC,IAAIkG,EAAc,GAAG3P,OAAOuP,EAAS,KAAKvP,OAAOxB,GACjD,OAAOgR,EAAW,GAAGxP,OAAOwP,EAAU,eAAexP,OAAO0P,mBAAmBC,IAAgBA,GAEnGC,eAAgB,WACZ,OAAOJ,EAAW,GAAGxP,OAAOwP,EAAU,cAAgBD,ICjBlE,IAAIM,GAAuB,iBACpB,SAASC,GAAS3Q,EAAK4Q,GAI1B,IAAIC,EAvBoB,IAuBc7Q,EAAIR,OAAS,GAC/CoR,EAASpR,OAASqR,GAAkBH,GAAqBlD,KAAKoD,KAC9D7U,EAAQI,KAAK,GAAG0E,OAAOb,EAAK,+DAIhC,IAAI8Q,EAAiBF,EAAS9P,QAAQ,KAAM,KAC5C,MAAO,GAAGD,OAAOb,EAAK,KAAKa,OAAOiQ,GCzB/B,IAAIC,GAAsB,CAC7BC,MAAO,QACPC,KAAM,OACNC,gBAAiB,mBAEd,SAASC,GAA8BvB,GAC1C,IAAI3N,EAAI+C,EACR,GAAK4K,GAAsBA,EAAkBI,YAI7C,QAAqCvS,IAAjCmS,EAAkBwB,YAA6B3O,EAAamN,EAAkBwB,YAAlF,CTVG,IAAoCC,EScvC,QAA8C5T,IAA1CmS,EAAkB0B,qBAAsC7O,EAAamN,EAAkB0B,qBAM3F,OTpBuCD,ESmBZzB,EAAkB2B,2BTjBxCzL,MAAMC,QAAQsL,KAGd9I,IACDA,EAA8B,IAAIiJ,IAAIH,IAE1CA,EACKrI,QAAO,SAAUyI,GAAQ,MAAuB,iBAATA,KACvC7U,SAAQ,SAAU6U,GACnBlJ,EAA4BhC,IAAIkL,OSS7B,EAAO,CACVC,WAAY9B,EAAkB8B,YAAcxF,GAAgB0D,EAAkB8B,WAAY,8BAC1FC,cAAeC,GAAmBhC,GAClCwB,WAAoD,QAAvCnP,EAAK2N,EAAkBwB,kBAA+B,IAAPnP,EAAgBA,EAAK,IACjFqP,oBAAsE,QAAhDtM,EAAK4K,EAAkB0B,2BAAwC,IAAPtM,EAAgBA,EAAK,GACnG6M,QAASjC,EAAkBiC,QAC3BC,qBAAsBlC,EAAkBkC,mBAKxCC,gBAAiB,MACjBC,0BAA2B,IAC3BC,qCAAsC,GAKtCC,aAAc,IAIdC,aAAc,GACdC,eAAgB,QC/CjB,SAAuCxC,GAC1C,IAAIE,EFFD,SAAmBuC,GACtB,IAAIC,EAAMD,EAAcC,IAAKT,EAAUQ,EAAcR,QAASU,EAAUF,EAAcE,QAASC,EAAaH,EAAcG,WACtH1C,EAAO,GAaX,OAZIwC,GACAxC,EAAK5R,KAAKyS,GAAS,MAAO2B,IAE1BT,GACA/B,EAAK5R,KAAKyS,GAAS,UAAWkB,IAE9BU,GACAzC,EAAK5R,KAAKyS,GAAS,UAAW4B,IAE9BC,GACA1C,EAAK5R,KAAKyS,GAAS,aAAc6B,IAE9B1C,EEbI2C,CAAU7C,GACjB8C,EAQR,SAAiC9C,EAAmBE,GAChD,IAAI4C,EAAmB,CACnBC,oBAAqBhD,GAAsBC,EAAmB,OAAQE,GACtE8C,mBAAoBjD,GAAsBC,EAAmB,MAAOE,GACpE+C,6BAA8BlD,GAAsBC,EAAmB,gBAAiBE,IAE5F,OAAIF,EAAkBkD,yBACX,EAAOJ,EAAkB,CAC5BK,kCAAmCpD,GAAsB,EAAO,GAAIC,EAAmB,CAAEI,YAAaJ,EAAkBkD,2BAA6B,OAAQhD,EAAM,uCAGpK4C,EAnBgBM,CAAwBpD,EAAmBE,GAC9DmD,EAAkBtQ,EAAa+P,GAAkB7P,KAAI,SAAUqQ,GAAW,OAAOA,EAAQzC,oBACzF0C,EAmBR,SAAqCvD,EAAmBqD,EAAiBnD,GACrE,GAAKF,EAAkBwD,QAAvB,CAGA,IAAID,EAAuB,EAAO,GAAIvD,EAAmB,CACrDG,KAAML,GACNM,YAAaJ,EAAkBwD,QAAQpD,cAEvCqD,EAA0B,CAC1BV,oBAAqBhD,GAAsBwD,EAAsB,OAAQrD,GACzE8C,mBAAoBjD,GAAsBwD,EAAsB,MAAOrD,GACvEiD,kCAAmCpD,GAAsBwD,EAAsB,OAAQrD,EAAM,sCAGjG,OADAmD,EAAgB/U,KAAKuB,MAAMwT,EAAiBtQ,EAAa0Q,GAAyBxQ,KAAI,SAAUqQ,GAAW,OAAOA,EAAQzC,qBACnH,EAAO,CAAE6C,cAAe1D,EAAkBwD,QAAQE,eAAiBD,IAjC/CE,CAA4B3D,EAAmBqD,EAAiBnD,GAC3F,OAAO,EAAO,CACV0D,YAAa,SAAU7V,GAAO,OAAOsV,EAAgB3F,MAAK,SAAUmG,GAAkB,OAAuC,IAAhC9V,EAAIR,QAAQsW,OACzGL,QAASD,GACVT,GDwCAgB,CAA8B9D,IA7B7B7T,EAAQK,MAAM,mEAJdL,EAAQK,MAAM,yDAJdL,EAAQK,MAAM,8DAuCf,SAASwV,GAAmBhC,GAC/B,IAAI+B,EAAgB,GAMpB,OALAA,EAAczD,OAOlB,SAA6B0B,GACzB,QAASA,EAAkB+D,0BAA4B/D,EAAkBgE,0BARlDC,CAAoBjE,GAC3C+B,EAAc3D,YAAc4B,EAAkBgE,0BAC1ChE,EAAkBkE,+BAClBnC,EAAc1D,OLff,WACH,QAA4BxQ,IAAxB4O,GAAmC,CAOnC,IAJA,IAAI0H,EAAiB,gBAAgBlT,OAAON,KAExCyT,EAAevQ,OAAO2J,SAASD,SAASxQ,MAAM,KAC9CsX,EAAkBD,EAAa7D,MAC5B6D,EAAaxU,SAAW4O,GAAU2F,IACrCE,EAAkB,GAAGpT,OAAOmT,EAAa7D,MAAO,KAAKtP,OAAOoT,GAC5DxG,GAAUsG,EALQ,OAKyBvV,EAAY,CAAEyP,OAAQgG,IAErE5F,GAAa0F,EAAgB,CAAE9F,OAAQgG,IACvC5H,GAAsB4H,EAE1B,OAAO5H,GKAoB6H,IAEpBvC,EE7CJ,SAASwC,KACZ,OAAOC,QAAQ3Q,OAAO4Q,iCAAmCjG,GAbb,mCCEhD,IAAIkG,GAA6B,mBAC7BC,GAAuB,WACvB,SAASA,EAAMC,EAASC,EAASC,EAAYtC,EAAgBF,EAAcyC,QAC1C,IAAzBA,IAAmCA,EAAuBtT,GAC9D+B,KAAKoR,QAAUA,EACfpR,KAAKqR,QAAUA,EACfrR,KAAKsR,WAAaA,EAClBtR,KAAKgP,eAAiBA,EACtBhP,KAAK8O,aAAeA,EACpB9O,KAAKuR,qBAAuBA,EAC5BvR,KAAKwR,eAAiB,GACtBxR,KAAKyR,aAAe,GACpBzR,KAAK0R,gBAAkB,EACvB1R,KAAK2R,mBAAqB,EAC1B3R,KAAK4R,0BACL5R,KAAK6R,oBAyHT,OAvHAV,EAAMrU,UAAUqG,IAAM,SAAUpI,GAC5BiF,KAAK8R,YAAY/W,IAErBoW,EAAMrU,UAAUiV,OAAS,SAAUhX,EAAS6B,GACxCoD,KAAK8R,YAAY/W,EAAS6B,IAE9BuU,EAAMrU,UAAUkV,MAAQ,SAAUC,GAC9B,GAAgC,IAA5BjS,KAAK2R,mBAA0B,CAC/B,IAAIO,EAAWlS,KAAKwR,eAAe/T,OAAO8B,EAAaS,KAAKyR,eAC5DzR,KAAKoR,QAAQxH,KAAKsI,EAASrO,KAAK,MAAO7D,KAAK0R,gBAAiBO,GAC7DjS,KAAKwR,eAAiB,GACtBxR,KAAKyR,aAAe,GACpBzR,KAAK0R,gBAAkB,EACvB1R,KAAK2R,mBAAqB,IAGlCR,EAAMrU,UAAUqV,YAAc,SAAUlX,GAEpC,OAAKiW,GAA2B9G,KAAKnP,QAGVZ,IAAvBgG,OAAO+R,aACA,IAAIA,aAAcC,OAAOpX,GAAWmB,OAExC,IAAIkW,KAAK,CAACrX,IAAYsX,KALlBtX,EAAUmB,QAOzB+U,EAAMrU,UAAUgV,YAAc,SAAU/W,EAAS6B,GAC7C,IAAIiC,EAAKmB,KAAKwS,QAAQzX,GAAU0X,EAAmB5T,EAAG4T,iBAAkBC,EAAmB7T,EAAG6T,iBAC1FA,GAAoB1S,KAAKgP,eACzBrW,EAAQI,KAAK,2EAA2E0E,OAAOuC,KAAKgP,eAAgB,SAGpHhP,KAAK2S,cAAc/V,IACnBoD,KAAK4S,OAAOhW,GAEZoD,KAAK6S,0BAA0BH,IAC/B1S,KAAKgS,MAAM,6BAEfhS,KAAKlF,KAAK2X,EAAkBC,EAAkB9V,GAC1CoD,KAAK8S,UACL9S,KAAKgS,MAAM,YAGnBb,EAAMrU,UAAU0V,QAAU,SAAUzX,GAChC,IAAI0X,EAAmBvU,EAAcnD,GAErC,MAAO,CAAE0X,iBAAkBA,EAAkBC,iBADtB1S,KAAKmS,YAAYM,KAG5CtB,EAAMrU,UAAUhC,KAAO,SAAU2X,EAAkBC,EAAkB9V,GAC7DoD,KAAK2R,mBAAqB,IAE1B3R,KAAK0R,iBAAmB,QAEhBrX,IAARuC,EACAoD,KAAKyR,aAAa7U,GAAO6V,EAGzBzS,KAAKwR,eAAe1W,KAAK2X,GAE7BzS,KAAK0R,iBAAmBgB,EACxB1S,KAAK2R,oBAAsB,GAE/BR,EAAMrU,UAAU8V,OAAS,SAAUhW,GAC/B,IAAImW,EAAiB/S,KAAKyR,aAAa7U,UAChCoD,KAAKyR,aAAa7U,GACzB,IAAI8V,EAAmB1S,KAAKmS,YAAYY,GACxC/S,KAAK0R,iBAAmBgB,EACxB1S,KAAK2R,oBAAsB,EACvB3R,KAAK2R,mBAAqB,IAC1B3R,KAAK0R,iBAAmB,IAGhCP,EAAMrU,UAAU6V,cAAgB,SAAU/V,GACtC,YAAevC,IAARuC,QAAgDvC,IAA3B2F,KAAKyR,aAAa7U,IAElDuU,EAAMrU,UAAU+V,0BAA4B,SAAUH,GAElD,OAAO1S,KAAK0R,gBAAkBgB,EAAmB,GAAK1S,KAAKsR,YAE/DH,EAAMrU,UAAUgW,OAAS,WACrB,OAAO9S,KAAK2R,qBAAuB3R,KAAKqR,SAAWrR,KAAK0R,iBAAmB1R,KAAKsR,YAEpFH,EAAMrU,UAAU+U,kBAAoB,WAChC,IAAIpM,EAAQzF,KACZ1D,WAAW2F,IAAQ,WACfwD,EAAMuM,MAAM,qBACZvM,EAAMoM,uBACN7R,KAAK8O,eAEbqC,EAAMrU,UAAU8U,wBAA0B,WACtC,IAAInM,EAAQzF,KAKRgT,UAAUC,aAMV3R,EAAiBjB,OAAQ,eAAoCL,KAAKuR,sBAKlEjQ,EAAiBiB,SAAU,oBAA4C,WAClC,WAA7BA,SAAS2Q,iBACTzN,EAAMuM,MAAM,uBAQpB1Q,EAAiBjB,OAAQ,gBAAoC,WAAc,OAAOoF,EAAMuM,MAAM,qBAG/Fb,EAvIe,GCLtBgC,IAAsB,EAStBC,GAA6B,WAC7B,SAASA,EAAYC,EAAiB/B,GAClCtR,KAAKqT,gBAAkBA,EACvBrT,KAAKsR,WAAaA,EA+CtB,OA7CA8B,EAAYtW,UAAU8M,KAAO,SAAU7D,EAAMwM,EAAMe,GAC/C,IAAI/Y,EAAMyF,KAAKqT,gBAAgBnG,QAC3BqG,IAAcP,UAAUC,YAAcV,EAAOvS,KAAKsR,WACtD,GAAIiC,EACA,IAEI,GADeP,UAAUC,WAAW1Y,EAAKwL,GAErC,OAGR,MAAOf,IAuCnB,SAA2BA,GAClBwO,KACDA,IAAyB,EACzBnL,GAAmBrD,IAzCXyO,CAAkBzO,GAG1B,IA0BIoM,EAAU,IAAIsC,eAClBtC,EAAQ9P,iBAAiB,UAAWW,IAAQ,SAAUT,GAAS,OA3BlC,SAAUA,GACnC,IAAImS,EAAMnS,MAAAA,OAAqC,EAASA,EAAMoS,cAC1DD,EAAIjL,QAAU,KAAOiL,EAAIjL,OAAS,KAGjCyK,KACDA,IAAsB,EACtB7K,GAAqB,sBAAuB,CACxCuL,QAASb,UAAUc,OACnBvB,KAAMA,EACNhY,IAAKA,EACLwZ,WAAYR,EACZS,aAAcV,EACd9R,MAAO,CACHyS,WAAYzS,EAAM0S,UAClBC,MAAO3S,EAAM2S,MACbC,OAAQ5S,EAAM4S,QAElBhD,QAAS,CACL1I,OAAQiL,EAAIjL,OACZ2L,YAAaV,EAAInR,WACjB8R,cAAeX,EAAIY,aAAalT,MAAM,EAAG,SAMamT,CAAuBhT,OAC7F4P,EAAQqD,KAAK,OAAQla,GAAK,GAC1B6W,EAAQxH,KAAK7D,IAEVqN,EAlDqB,GAqD5BI,IAAyB,EC7CtB,SAASkB,KACZ,IAAIC,EACAC,EAAgBvU,OAYpB,GAAIuU,EAAcC,KAAM,CACpB,IAAIC,EAASF,EAAcC,KAAKE,WAAW,oBAC3CJ,EAAcC,EAAcE,GAKhC,OAHKH,IACDA,EAAcC,EAAcI,kBAEzBL,ECtCJ,IAAIM,GAAwB,mBAC/BC,GAAiB,CACjB,CAAC,WAA2B,SAAUC,GAAiB,OAAOF,KAA0BE,IACxF,CAAC,MAAiB,SAAUA,GAAiB,MAAO,mBAAqBA,IACzE,CAAC,QAAqB,SAAUA,GAAiB,MAAO,UAAYA,IACpE,CAAC,SAAuB,SAAUA,GAAiB,MAAO,WAAaA,IACvE,CAAC,MAAiB,SAAUC,EAAGC,GAAQ,MAAO,UAAUjL,KAAKiL,KAC7D,CAAC,KAAe,SAAUD,EAAGC,GAAQ,MAAO,SAASjL,KAAKiL,KAC1D,CACI,QACA,SAAUF,EAAeE,GACrB,OAAOvW,EAAS,CAAC,QAAS,MAAO,QAASqW,IAAuE,OAArD,sCAAsCtb,KAAKwb,KAG/G,CAAC,OAAmB,SAAUD,EAAGC,GAAQ,OAAiD,OAA1C,2BAA2Bxb,KAAKwb,KAChF,CACI,QACA,SAAUF,EAAeE,GACrB,OAAOvW,EAAS,CAAC,QAAS,SAAUqW,IAAiD,OAA/B,gBAAgBtb,KAAKwb,MAmBvF,SAASC,KAEL,IADA,IAAIC,EAAU,GACLrZ,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpCqZ,EAAQrZ,GAAMC,UAAUD,GAE5B,IAAK,IAAIiD,EAAI,EAAGA,EAAIoW,EAAQnZ,OAAQ+C,GAAK,EACrC,GAAIoW,EAAQpW,EAAI,GAAKoW,EAAQpW,GACzB,OAAO,EAGf,OAAO,EAaJ,SAASqW,GAAkCC,GAC9C,IAAIC,EAAaC,GAAaF,GAC9B,GAAKC,EAAL,CAGA,IAAIE,EAAYF,EAAWE,UAAWC,EAAaH,EAAWG,WAAYC,EAAgBJ,EAAWI,cAAeC,EAAcL,EAAWK,YAAaC,EAAoBN,EAAWM,kBAAmBC,EAAkBP,EAAWO,gBAAiBC,EAAeR,EAAWQ,aAAcC,EAAwBT,EAAWS,sBAAuBC,EAAaV,EAAWU,WAAYC,EAAeX,EAAWW,aAAcC,EAAgBZ,EAAWY,cAC/bC,EAAU,CACVC,SAAUC,GAAab,EAAWU,EAF0bZ,EAAWgB,aAGveC,WAAYF,GAAab,EAAWS,EAAcC,IAiBtD,OAdIF,IAAeP,IACfU,EAAQK,QAAUH,GAAab,EAAWM,EAAcE,GAEpDd,GAAWY,EAAcC,EAAuBC,KAChDG,EAAQM,IAAMJ,GAAab,EAAWO,EAAuBC,KAIjEH,IAAoBJ,IACpBU,EAAQO,IAAML,GAAab,EAAWI,EAAmBC,IAEzDc,GAAetB,KACfc,EAAQS,SAAWP,GAAab,EAAWE,EAAeC,IAEvDQ,GAEJ,SAASZ,GAAaF,GAKzB,GAAKH,GAAWG,EAAMG,UAAWH,EAAMI,WAAYJ,EAAMO,kBAAmBP,EAAMQ,gBAAiBR,EAAMS,aAAcT,EAAMW,WAAYX,EAAMY,aAAcZ,EAAMa,cAAeb,EAAMiB,aAAxL,CAGA,IAAKK,GAAetB,GAChB,OAAOA,EAEX,IAAIK,EAAgBL,EAAMK,cAAeC,EAAcN,EAAMM,YAU7D,GAPID,EAAgBL,EAAMG,YACtBE,EAAgBL,EAAMG,WAEtBG,EAAcN,EAAMG,YACpBG,EAAcN,EAAMI,YAGnBP,GAAWG,EAAMG,UAAWE,EAAeC,EAAaN,EAAMI,YAGnE,OAAO,EAAO,GAAIJ,EAAO,CACrBM,YAAaA,EACbD,cAAeA,KAGvB,SAASiB,GAAetB,GAEpB,OAAOA,EAAMI,aAAeJ,EAAMG,UAEtC,SAASa,GAAajW,EAAQ+G,EAAOC,GACjC,MAAO,CACHP,SAAUD,EAAiBM,GAAQC,EAAOC,IAC1CD,MAAOP,EAAiBM,GAAQ9G,EAAQ+G,KAGzC,SAAS0P,GAAYxB,GAExB,GAAIA,EAAMG,UAAYH,EAAMa,cACxB,OAAOb,EAAMyB,gBAId,SAASC,GAAoBlI,EAAe1U,GAC/C,OAAOA,IAAQ0U,EAAcmB,YAAY7V,GCrItC,SAAS6c,GAAmB7U,GAC/B,IAAIwD,EAMD,SAAsCxD,GACzC,IAAI8U,EAAc9U,EAAS+U,cAAc,0BACrCC,EAAgBhV,EAAS+U,cAAc,4BAC3C,OAAOE,GAAwBH,GAAeA,EAAYI,QAASF,GAAiBA,EAAcE,SATvFC,CAA6BnV,IAWrC,SAAyCA,GAC5C,IAAIoV,EAgBD,SAA0BpV,GAK7B,IAAK,IAAIpD,EAAI,EAAGA,EAAIoD,EAASqV,WAAWxb,OAAQ+C,GAAK,EAEjD,GADIwY,EAAUE,GAAwBtV,EAASqV,WAAWzY,IAEtD,OAAOwY,EAOf,GAAIpV,EAASyJ,KACT,IAAS7M,EAAIoD,EAASyJ,KAAK4L,WAAWxb,OAAS,EAAG+C,GAAK,EAAGA,GAAK,EAAG,CAC9D,IACIwY,EADAG,EAAOvV,EAASyJ,KAAK4L,WAAWzY,GAEpC,GADIwY,EAAUE,GAAwBC,GAElC,OAAOH,EAEX,IAAKI,GAAWD,GACZ,OAvCEE,CAAiBzV,GAC/B,GAAKoV,EAGL,OAAOH,GAAwB5W,EAAwB+W,EAAS,YAAa/W,EAAwB+W,EAAS,eAhBzDM,CAAgC1V,GACrF,GAAKwD,KAAQA,EAAKmS,WAAa7U,KAAKuD,MAHkB,MAMtD,OAAOb,EAAKoS,QAcT,SAASX,GAAwBW,EAASC,GAC7C,IAAIF,EAAYE,GAAgBC,OAAOD,GACvC,GAAKD,GAAYD,EAGjB,MAAO,CACHC,QAASA,EACTD,UAAWA,GA+BnB,SAASL,GAAwBC,GAC7B,GAAIA,GAOR,SAAuBA,GACnB,MAAyB,aAAlBA,EAAKQ,SARAC,CAAcT,GAAO,CAC7B,IAAIU,EAAQ,wBAAwB3e,KAAKie,EAAK/R,MAC9C,GAAIyS,EACA,OAAOA,EAAM,IAOzB,SAAST,GAAWD,GAChB,MAAyB,UAAlBA,EAAKQ,SCpEhB,SAASG,KACL,YAA8Bpe,IAAvBgG,OAAOwG,aAA6B,eAAgBA,YAExD,SAAS6R,GAA8BC,GAC1C,OAAQtY,OAAOuY,0BACiCve,IAA5Cue,oBAAoBC,qBACpBD,oBAAoBC,oBAAoB/Z,SAAS6Z,GAMlD,SAASG,GAA2BC,EAAW9J,GAkD/C,IAA+C3M,EA9ClD,GA8CkDA,EAjDZ,SAAUqF,GAC5CqR,GAA4BD,EAAW9J,EAAe,CAACtH,KAiD3DvF,EAAgB,eAAe,WAC3B,IAAIuF,EACAsR,EAAmB,CACnBN,UAAW,WACXxD,cAAeF,GACfkD,QAASf,GAAmB7U,WAEhC,GAAImW,GAA8B,eAAiB7R,YAAYqS,iBAAiB,cAAc9c,OAAS,EAEnGuL,EAAS,EADad,YAAYqS,iBAAiB,cAAc,GACjCza,SAAUwa,OAEzC,CACD,IAAIE,EAA4BC,KAChCzR,EAAS,EAAOwR,EAA2B,CACvCjC,gBAAiB,EACjBjQ,SAAUkS,EAA0BzC,YACpC1b,KAAMqF,OAAO2J,SAASoB,KACtBwK,UAAW,GACZqD,GAEP3W,EAASqF,MAnET8Q,KAA4B,CAC5B,IAAIY,EAAuBxS,YAAYyS,aAGvChd,WAAW2F,IAAQ,WAAc,OAAO+W,GAA4BD,EAAW9J,EAAeoK,OAElG,GAAIhZ,OAAOuY,oBAAqB,CAC5B,IAAIW,EAA+BtX,IAAQ,SAAUuX,GACjD,OAAOR,GAA4BD,EAAW9J,EAAeuK,EAAQF,iBAErEG,EAAc,CAAC,WAAY,aAAc,WAAY,SACrDC,EAAsB,CAAC,2BAA4B,cAAe,gBACtE,IAIIA,EAAoBlgB,SAAQ,SAAUmL,GACnB,IAAIiU,oBAAoBW,GAC9BI,QAAQ,CAAEhV,KAAMA,EAAMiV,UAAU,OAGjD,MAAO5U,GAGHyU,EAAY3e,KAAKuB,MAAMod,EAAaC,GAErB,IAAId,oBAAoBW,GAC9BI,QAAQ,CAAEE,WAAYJ,IAC/BhB,MAA8B,qBAAsB5R,aAEpDA,YAAYvF,iBAAiB,4BAA4B,WACrDuF,YAAYiT,0BAInBpB,GAA8B,eAmCvC,SAAkCpW,GAC9B,SAASyX,IAnCoB,IAAUpS,EAAAA,EAoC1B,EAAOyR,KAAoC,CAChDT,UAAW,eApCXK,GAA4BD,EAAW9J,EAAe,CAACtH,IAuC/DvF,EAAgB,YAAY,WAExB9F,WAAW2F,GAAQ8X,OA1CnBC,GAICtB,GAA8B,gBA6CvC,SAAkCpW,GAC9B,IAAI2X,EAAiB5W,KAAKuD,MACtBsT,GAAa,EACbC,EAAuBzY,EAAkBrB,OAAQ,CAAC,QAAqB,YAA8B,UAA0B,aAAgC,gBAAmC,SAAU+Z,GAE5M,GAAKA,EAAIC,WAAT,CAMA,IAAI1S,EAAS,CACTgR,UAAW,cACX2B,gBAAiBnT,IACjByO,UAAWwE,EAAI3T,WAEF,gBAAb2T,EAAIzV,KAaZ,SAA2CgD,GACvCjG,EAAkBrB,OAAQ,CAAC,YAA8B,kBAAuC,SAAUmB,GACnF,cAAfA,EAAMmD,MACN4V,EAAW5S,KAEhB,CAAE9F,MAAM,IAjBP2Y,CAAkC7S,GAGlC4S,EAAW5S,MAEhB,CAAE5F,SAAS,EAAMD,SAAS,IAAQI,KAcrC,SAASqY,EAAW5S,GAChB,IAAKuS,EAAY,CACbA,GAAa,EACbC,IAMA,IAAIM,EAAQ9S,EAAO2S,gBAAkB3S,EAAOiO,UACxC6E,GAAS,GAAKA,EAAQpX,KAAKuD,MAAQqT,GA1FlB,SAAUtS,GAC/BqR,GAA4BD,EAAW9J,EAAe,CAACtH,IA0FnDrF,CAASqF,KA3FjB+S,GAgGR,SAAStB,KACL,IAAI1a,EAAS,GACTiJ,EAASd,YAAYc,OACzB,IAAK,IAAI/K,KAAO+K,EACZ,GAAIrI,EAASqI,EAAO/K,IAAO,CACvB,IAAI+d,EAAY/d,EAEZge,EAAgBjT,EAAOgT,GAC3Bjc,EAAOic,GAA+B,IAAlBC,EAAsB,EAAInT,GAAgBmT,GAGtE,OAAOlc,EAEX,SAASsa,GAA4BD,EAAW9J,EAAeuK,GAC3D,IASIqB,EATwBrB,EAAQ5T,QAAO,SAAU6P,GACjD,MAA2B,aAApBA,EAAMkD,WACW,eAApBlD,EAAMkD,WACc,UAApBlD,EAAMkD,WACc,aAApBlD,EAAMkD,WACc,6BAApBlD,EAAMkD,WACc,gBAApBlD,EAAMkD,WACc,iBAApBlD,EAAMkD,aAE2C/S,QAAO,SAAU6P,GAAS,OAKvF,SAAgCA,GAC5B,MAA2B,eAApBA,EAAMkD,WAA8BlD,EAAMqF,cAAgB,EAN0BC,CAAuBtF,KAQtH,SAA6BxG,EAAewG,GACxC,MAA2B,aAApBA,EAAMkD,YAA6BxB,GAAoBlI,EAAewG,EAAMza,MAT0CggB,CAAoB/L,EAAewG,MAC5JoF,EAA6Bze,QAC7B2c,EAAUjT,OAAO,EAAuC+U,GCpLzD,SAASI,GAAuBpR,EAAWqR,EAAOC,GACrD,IAAIC,EAAa,EACbC,GAAiB,EACrB,MAAO,CACHC,eAAgB,WAOZ,GANmB,IAAfF,GACA9e,YAAW,WACP8e,EAAa,ItBNT,MsBSZA,GAAc,IACIF,GAASG,EAEvB,OADAA,GAAiB,GACV,EAEX,GAAID,IAAeF,EAAQ,EAAG,CAC1BG,GAAiB,EACjB,IACIF,EAAe,CACXpgB,QAAS,yBAAyB0C,OAAOoM,EAAW,iBAAiBpM,OAAOyd,GAC5Eve,OrBjBb,QqBkBa4e,YAAanU,MAGrB,QACIiU,GAAiB,GAGzB,OAAO,ICPnB,SAAStb,GAAI7C,EAAQmY,GAEjB,IADA,IAAImG,EAAUte,EACLhB,EAAK,EAAG2C,EAAKwW,EAAK9b,MAAM,KAAM2C,EAAK2C,EAAGzC,OAAQF,IAAM,CACzD,IAAIuf,EAAQ5c,EAAG3C,GACf,IAAKwf,GAAwBF,EAASC,GAClC,OAEJD,EAAUA,EAAQC,GAEtB,OAAOD,EAEX,SAASG,GAAIze,EAAQmY,EAAMla,GAGvB,IAFA,IAAIqgB,EAAUte,EACV0e,EAASvG,EAAK9b,MAAM,KACf4F,EAAI,EAAGA,EAAIyc,EAAOxf,OAAQ+C,GAAK,EAAG,CACvC,IAAIsc,EAAQG,EAAOzc,GACnB,IAAKuc,GAAwBF,EAASC,GAClC,OAEAtc,IAAMyc,EAAOxf,OAAS,EACtBof,EAAUA,EAAQC,GAGlBD,EAAQC,GAAStgB,GAI7B,SAASugB,GAAwBxe,EAAQue,GACrC,MAAyB,iBAAXve,GAAkC,OAAXA,GAAmBue,KAASve,EC/CrE,IAAI2e,GAAqC,CAErC,WACA,gBACA,qBACA,gBACA,cACA,qBACA,gBAEAC,GAAsCD,GAAmCpe,OAAO,CAEhF,YAEG,SAASse,GAAiB9M,EAAe8J,EAAWiD,EAAgBC,EAAcC,EAAaC,EAAgBC,GAClH,IAAIvd,EACAwd,EAAc,SAAUrjB,GACxB+f,EAAUjT,OAAO,GAA8B,CAAE9M,MAAOA,KAExDsjB,IAAqBzd,EAAK,IACJ,MAAIoc,GAAuB,QAAqBhM,EAAcL,0BAA2ByN,GAC/Gxd,EAAwB,OAAIoc,GAAuB,SAAuBhM,EAAcL,0BAA2ByN,GACnHxd,GACA0d,ETtBD,WACH,IAAIC,EAASnc,OAAOoc,+BAAiCzR,GAJb,gCAKpC0R,EAAWrc,OAAOsc,+BAAiC3R,GAJb,gCAK1C,GAAsB,iBAAXwR,GAA2C,iBAAbE,EACrC,MAAO,CACHE,QAASJ,EACTK,UAAWH,EACXI,SAAU/L,MSeMgM,GACpBC,EC3BD,WACH,IAAIne,EACAoe,EAA4C,QAAzBpe,EAAKwB,OAAO6c,eAA4B,IAAPre,OAAgB,EAASA,EAAGqQ,IAAI,WACxF,GAA+B,iBAApB+N,EACP,MAAO,CACHE,kBAAmBF,GDsBPG,GACpBrE,EAAUxT,UAAU,IAAkC,SAAU1G,GAC5D,IAAI+W,EAAY/W,EAAG+W,UAAWyH,EAAcxe,EAAGwe,YAAaC,EAAgBze,EAAGye,cAAeC,EAAqB1e,EAAG0e,mBAAoBC,EAAkB3e,EAAG2e,gBAC3JC,EAAcxB,EAAayB,SAAS9H,GACpC+H,EAAazB,EAAY0B,QAAQhI,GAIjCiI,EAAU7B,EAAe8B,mBAAwC,SAArBT,EAAY1Y,KAA6BiR,OAAYvb,GACrG,GAAIwjB,GAAWJ,GAAeE,EAAY,CACtC,IAAII,EAAgBR,GAAsBnB,IACtC4B,EAAa,CACbC,IAAK,CACDC,eAAgB,EAChBC,MrB1BT7gB,KAAKO,MAAMwF,KAAKuD,OAASE,KAAuBD,YAAYD,QqB2BnDiX,QAAS,CACLO,KAAMP,EAAQQ,cAAgB,EAAiB,GAEnDC,oBAAqBxU,KAAsB,aAAUzP,GAEzDkkB,YAAa,CACTC,GAAIvP,EAAciB,eAEtB3F,KAAMrD,IACNuH,QAASQ,EAAcR,QACvB9R,OAAQ,UACRkhB,QAAS,CACLW,GAAIX,EAAQW,GACZ7Z,KAAM4X,EAAoB,aAAgCS,EAAgB,UAA0B,QAExGyB,WAAYlC,EACZmC,QAAS1B,GAET2B,EAAWxC,EAAeyC,aAAahJ,GACtChO,GAA6B,YAK9BoW,EAAW7O,QAAUF,EAAcE,gBAJ5BsO,EAAYhP,eACZgP,EAAYtO,SAKvB,IAAI0P,GAoCkG,IAAvG,CAAC,QAAqB,WAA2B,aAA6B9kB,QApC9BsjB,EAoC4C1Y,OApC5Bga,EACzD1a,EAAQ+Z,EAAYL,EAAYF,EAAa,CAAEqB,OAAQ,CAAEN,GAAIG,IAActB,GAC3EpZ,EAAQ+Z,EAAYL,EAAYF,EAAaJ,GACnDwB,EAAe1W,QAAUlE,EAAQ8Z,EAAc5V,QAASqV,GAClD,eAAgBqB,EAAehB,UAEjCgB,EAAehB,QAAQkB,WAAahB,EAAciB,WAEjDrf,EAAcoe,EAAckB,QAE7BJ,EAAeK,IAAMnB,EAAckB,MAWnD,SAAoBzd,EAAO8M,EAAYgP,EAAehB,GAClD,IAAIzd,EACJ,GAAIyP,EAAY,CACZ,IAAI5P,EDvFL,SAA2BxB,EAAQiiB,EAAsBC,GAC5D,IAAIC,EAAQrb,EAAU9G,GAClBwB,ECqFmJ,SAAU8C,GAAS,OAAO8M,EAAW9M,EAAO8b,GDrFtL8B,CAASC,GAatB,OAZAF,EAAqB3lB,SAAQ,SAAU6b,GACnC,IAAIiK,EAAgBvf,GAAI7C,EAAQmY,GAC5BkK,EAAWxf,GAAIsf,EAAOhK,GACtBmK,EAAe/c,EAAQ6c,GACvBG,EAAUhd,EAAQ8c,GAClBE,IAAYD,EACZ7D,GAAIze,EAAQmY,EAAMkK,GAEI,WAAjBC,GAA0C,cAAZC,GAAuC,SAAZA,GAC9D9D,GAAIze,EAAQmY,EAAM,OAGnB3W,ECwEUghB,CAAkBle,EAAsB,SAAfA,EAAMmD,KAA6BkX,GAAqCC,IAC9G,IAAe,IAAXpd,GAAmC,SAAf8C,EAAMmD,KAC1B,OAAO,GAEI,IAAXjG,GACA/F,EAAQI,KAAK,+CAIrB,QADgE,QAAxC8F,EAAKyd,EAAkB9a,EAAMmD,aAA0B,IAAP9F,OAAgB,EAASA,EAAGyc,kBApBxFqE,CAAWd,EAAgB5P,EAAcX,WAAYgP,EAAehB,KAChE3c,EAAckf,EAAe1W,iBACtB0W,EAAe1W,QAE1B4Q,EAAUjT,OAAO,GAA8B+Y,QElFxD,IAGHe,GAAoB,GAiBjB,SAASC,KACZ,KAAID,GAAkBxjB,OAnB2B,MAmBjD,CAGA,IAAI0jB,EAA0BF,GAAkBA,GAAkBxjB,OAAS,GACvEwK,EAAMO,SACsB9M,IAA5BylB,QAAyEzlB,IAAhCylB,EAAwBtY,KAGrEoY,GAAkB9kB,KAAK,CACnByM,MAAOX,KAGR,SAASmZ,KACZ,GAAiC,IAA7BH,GAAkBxjB,OAAtB,CAGA,IAAI0jB,EAA0BF,GAAkBA,GAAkBxjB,OAAS,GACvEwK,EAAMO,SAC0B9M,IAAhCylB,EAAwBtY,MAG5BsY,EAAwBtY,IAAMZ,IAkBlC,SAASoZ,GAAiBpK,GACtB,IAAK,IAAIzW,EAAIygB,GAAkBxjB,OAAS,EAAG+C,GAAK,EAAGA,IAAK,CACpD,IAAI8gB,EAAmBL,GAAkBzgB,GACzC,QAA6B9E,IAAzB4lB,EAAiBzY,KAAqBoO,EAAYqK,EAAiBzY,IACnE,MAEJ,GAAIoO,EAAYqK,EAAiB1Y,aACHlN,IAAzB4lB,EAAiBzY,KAAqBoO,EAAYqK,EAAiBzY,KACpE,OAAO,EAGf,OAAO,EAEX,SAAS0Y,GAA6BC,EAAgBlZ,GAKlD,IAHA,IAAImZ,EAAgBD,EAAiBlZ,EACjCoZ,EAA4B,GAC5BC,EAAgBhjB,KAAKijB,IAAI,EAAGX,GAAkBxjB,OA7EG,KA8E5C+C,EAAIygB,GAAkBxjB,OAAS,EAAG+C,GAAKmhB,EAAenhB,IAAK,CAChE,IAAI8gB,EAAmBL,GAAkBzgB,GACzC,QAA6B9E,IAAzB4lB,EAAiBzY,KAAqB2Y,EAAiBF,EAAiBzY,IAGxE,MAEJ,KAAI4Y,EAAeH,EAAiB1Y,OAApC,CAKA,IAAIqO,EAAYuK,EAAiBF,EAAiB1Y,MAAQ4Y,EAAiBF,EAAiB1Y,MACxFiZ,EAAgBlZ,GAAQ6Y,EAAgBvK,GAExC6K,EAAcnZ,GAAQsO,OADavb,IAAzB4lB,EAAiBzY,KAAqB4Y,EAAeH,EAAiBzY,IAAM4Y,EAAeH,EAAiBzY,KAE1H6Y,EAA0BK,QAAQ,CAC9BnZ,MAAOP,EAAiBwZ,GACxBvZ,SAAUD,EAAiByZ,MAGnC,OAAOJ,ECrGX,ICYIM,GDZAC,GAA2B,WAC3B,SAASA,IACL5gB,KAAK6gB,UAAY,GAoBrB,OAlBAD,EAAU9jB,UAAUgJ,OAAS,SAAU+D,EAAW9D,GAC9C,IAAI+a,EAAiB9gB,KAAK6gB,UAAUhX,GAChCiX,GACAA,EAAetnB,SAAQ,SAAU8I,GAAY,OAAOA,EAASyD,OAGrE6a,EAAU9jB,UAAUyI,UAAY,SAAUsE,EAAWvH,GACjD,IAAImD,EAAQzF,KAKZ,OAJKA,KAAK6gB,UAAUhX,KAChB7J,KAAK6gB,UAAUhX,GAAa,IAEhC7J,KAAK6gB,UAAUhX,GAAW/O,KAAKwH,GACxB,CACHqD,YAAa,WACTF,EAAMob,UAAUhX,GAAapE,EAAMob,UAAUhX,GAAWjE,QAAO,SAAUC,GAAS,OAAOvD,IAAauD,QAI3G+a,EAtBmB,GCK1BG,GAAuB,0BAEhBC,GAAsB,QAI7BC,GAAqB,GAElB,SAASC,GAAqBC,EAAYC,GAC7C,IAAIviB,EAKJ,QAJwB,IAApBuiB,IAA8BA,EAAkB,GAC/CT,KACDA,GAAoBQ,GAEpBA,IAAeR,GAInB,GAAIS,GAbgC,IAchCC,SADJ,CAIA,IAAIC,EACAC,EAAiBC,KACrB,GAAIC,KAAuB,CAEvB,GAAIF,EAAeG,KAEf,YADAC,GAAWR,EAAYC,GAS3B,GALAE,EAAc,IACdC,EAAeG,KAAOJ,EACtBM,GAAWL,EAAgBJ,EAAW3lB,UAEtC+lB,EAAiBC,MACEE,OAASJ,EAExB,YADAK,GAAWR,EAAYC,GAI/B,IAAIS,EAAmBV,EAAW3O,QAAQ+O,GAC1C,GAAIE,OAEAF,EAAiBC,MACEE,OAASJ,EACxBK,GAAWR,EAAYC,OAJ/B,CAWA,GAHIS,GACAC,GAAeD,EAAkBV,EAAW3lB,SAE5CimB,QAGMI,IAAoBE,GAAeF,IAAoB,CAGzD,IADAN,EAAiBC,MACEE,OAASJ,EAExB,YADAK,GAAWR,EAAYC,UAGpBG,EAAeG,KACtBE,GAAWL,EAAgBJ,EAAW3lB,SACtCqmB,EAAmBN,EAKC,QAA3B1iB,EAAKsiB,EAAWa,aAA0B,IAAPnjB,GAAyBA,EAAG7B,KAAKmkB,EAAYU,GAAoBN,GACrGF,WAxDIJ,GAAmBnmB,KAAKqmB,GA8DhC,SAASM,KACL,QC/ESphB,OAAO4hB,QAAU,iBAAiB7X,KAAK/J,OAAO2S,UAAUkP,WDiFrE,SAASP,GAAWR,EAAYgB,GAC5B7lB,WAAW2F,IAAQ,WACfif,GAAqBC,EAAYgB,EAAyB,MA9EpC,IAiF9B,SAASd,KACLV,QAAoBtmB,EACpB,IAAI+nB,EAAiBnB,GAAmBoB,QACpCD,GACAlB,GAAqBkB,GAGtB,SAASN,GAAejE,EAASriB,GAChCumB,GAAelE,GAwCvB,SAAsBriB,GAClB6O,GAAU2W,GAAqB,GAAI,EAAGxlB,GAxClC8mB,CAAa9mB,IAGjBqiB,EAAQ0E,OAASC,OAAOnf,KAAKuD,MAAQ6b,IACrCb,GAAW/D,EAASriB,IAExB,SAASomB,GAAW/D,EAASriB,GACzB6O,GAAU2W,GAEP,SAAyBnD,GAC5B,OAAO,EACYA,GACdpe,KAAI,SAAUZ,GACf,IAAIjC,EAAMiC,EAAG,GAAI1D,EAAQ0D,EAAG,GAC5B,MAAO,GAAGpB,OAAOb,EAAK,KAAKa,OAAOtC,MAEjC0I,KA7GqB,KAoGK6e,CAAgB7E,GAAU4E,GAA0BjnB,GAWhF,SAASgmB,KACZ,IAAImB,EAAgB3X,GAAUgW,IAC1BnD,EAAU,GAUd,OAEJ,SAA8B8E,GAC1B,YAA0BtoB,IAAlBsoB,KACiD,IAApDA,EAAc5oB,QA/HO,MA+HoCgnB,GAAqB3W,KAAKuY,IAbpFC,CAAqBD,IACrBA,EAAcppB,MAnHQ,KAmHuBC,SAAQ,SAAUic,GAC3D,IAAI3U,EAAUigB,GAAqBlnB,KAAK4b,GACxC,GAAgB,OAAZ3U,EAAkB,CAClB,IAAIlE,EAAMkE,EAAQ,GAAI3F,EAAQ2F,EAAQ,GACtC+c,EAAQjhB,GAAOzB,MAIpB0iB,EAMX,SAASkE,GAAelE,GACpB,OAAO,EAAoBA,GEnIxB,IAAI4E,GAA2B,ICHtC,ICIII,GDJAC,GAAeC,EAAAA,EAMfC,GAAgC,WAChC,SAASA,EAAe1Y,GACpB,IAAI7E,EAAQzF,KACZA,KAAKsK,YAAcA,EACnBtK,KAAKwZ,QAAU,GACfxZ,KAAKijB,yBAA2BC,aAAY,WAAc,OAAOzd,EAAM0d,qBAVtCC,KAyFrC,OAzEAJ,EAAelmB,UAAUqG,IAAM,SAAUgF,EAASyN,GAC9C,IAAInQ,EAAQzF,KACRyV,EAAQ,CACRtN,QAASA,EACTyN,UAAWA,EACXyN,QAASP,GACTlQ,OAAQ,WACJ,IAAI0Q,EAAQ7d,EAAM+T,QAAQzf,QAAQ0b,GAC9B6N,GAAS,GACT7d,EAAM+T,QAAQnQ,OAAOia,EAAO,IAGpCC,MAAO,SAAUF,GACb5N,EAAM4N,QAAUA,IAIxB,OADArjB,KAAKwZ,QAAQkH,QAAQjL,GACdA,GAMXuN,EAAelmB,UAAUkC,KAAO,SAAU4W,QACpB,IAAdA,IAAwBA,EAAYkN,IACxC,IAAK,IAAI5mB,EAAK,EAAG2C,EAAKmB,KAAKwZ,QAAStd,EAAK2C,EAAGzC,OAAQF,IAAM,CACtD,IAAIuZ,EAAQ5W,EAAG3C,GACf,GAAIuZ,EAAMG,WAAaA,EAAW,CAC9B,GAAIA,GAAaH,EAAM4N,QACnB,OAAO5N,EAAMtN,QAEjB,SAQZ6a,EAAelmB,UAAU0mB,YAAc,SAAUH,GAC7C,IAAII,EAAczjB,KAAKwZ,QAAQ,GAC3BiK,GAAeA,EAAYJ,UAAYP,IACvCW,EAAYF,MAAMF,IAO1BL,EAAelmB,UAAU4mB,QAAU,SAAU9N,GAEzC,YADkB,IAAdA,IAAwBA,EAAYkN,IACjC9iB,KAAKwZ,QACP5T,QAAO,SAAU6P,GAAS,OAAOA,EAAMG,WAAaA,GAAaA,GAAaH,EAAM4N,WACpF5jB,KAAI,SAAUgW,GAAS,OAAOA,EAAMtN,YAK7C6a,EAAelmB,UAAU6mB,MAAQ,WAC7B3jB,KAAKwZ,QAAU,IAKnBwJ,EAAelmB,UAAUoF,KAAO,WAC5B0hB,cAAc5jB,KAAKijB,2BAEvBD,EAAelmB,UAAUqmB,iBAAmB,WAExC,IADA,IAAIU,EAAmB1c,IAAgBnH,KAAKsK,YACrCtK,KAAKwZ,QAAQpd,OAAS,GAAK4D,KAAKwZ,QAAQxZ,KAAKwZ,QAAQpd,OAAS,GAAGinB,QAAUQ,GAC9E7jB,KAAKwZ,QAAQzM,OAGdiW,EApFwB,GEN5B,SAASc,GAAiB5mB,EAAQ6mB,EAAQC,GAC7C,IAAIC,EAAW/mB,EAAO6mB,GAClBG,EAAkBF,EAAuBC,GACzCE,EAAyB,WAEzB,OAAOD,EAAgB7nB,MAAM2D,KAAM7D,YAGvC,OADAe,EAAO6mB,GAAUI,EACV,CACHjiB,KAAM,WACEhF,EAAO6mB,KAAYI,EACnBjnB,EAAO6mB,GAAUE,EAGjBC,EAAkBD,IAK3B,SAASG,GAAgClnB,EAAQ6mB,EAAQllB,GAC5D,IAAIwlB,EAASxlB,EAAGwlB,OAAQrC,EAAQnjB,EAAGmjB,MACnC,OAAO8B,GAAiB5mB,EAAQ6mB,GAAQ,SAAUE,GAC9C,OAAO,WACH,IACIvlB,EADAvE,EAAOgC,UAaX,OAXIkoB,GACApf,GAAcof,EAAQrkB,KAAM7F,GAER,mBAAb8pB,IAEPvlB,EAASulB,EAAS5nB,MAAM2D,KAAM7F,IAE9B6nB,GACA/c,GAAc+c,EAAOhiB,KAAM7F,GAGxBuE,MAIZ,SAAS4lB,GAAiBpnB,EAAQhC,EAAU8mB,GAC/C,IAAIuC,EAAqB1nB,OAAO2nB,yBAAyBtnB,EAAQhC,GACjE,IAAKqpB,IAAuBA,EAAmB5I,MAAQ4I,EAAmBtkB,aACtE,MAAO,CAAEiC,KAAMjE,GAEnB,IAAIimB,EAAkB,SAAUO,EAAYtpB,GAExCmB,WAAW2F,IAAQ,WACf+f,EAAMyC,EAAYtpB,MAClB,IAEJgpB,EAAyB,SAAUhpB,GACnCopB,EAAmB5I,IAAI3e,KAAKgD,KAAM7E,GAClC+oB,EAAgBlkB,KAAM7E,IAK1B,OAHA0B,OAAOiD,eAAe5C,EAAQhC,EAAU,CACpCygB,IAAKwI,IAEF,CACHjiB,KAAM,WACF,IAAIrD,GAC8D,QAA5DA,EAAKhC,OAAO2nB,yBAAyBtnB,EAAQhC,UAA8B,IAAP2D,OAAgB,EAASA,EAAG8c,OAASwI,EAC3GtnB,OAAOiD,eAAe5C,EAAQhC,EAAUqpB,GAGxCL,EAAkBjmB,ID5DlC,IEFIymB,GFEAC,GAAc,IAAIC,QACf,SAASC,KAMhB,IACQxe,EAHJ,OAHKwc,KAMDxc,EAAa,IAAIjB,GAAW,WAC5B,IAAI0f,EAAyBV,GAAgC1Q,eAAe5W,UAAW,OAAQ,CAC3FunB,OAAQU,KACT7iB,KACC8iB,EAAwBZ,GAAgC1Q,eAAe5W,UAAW,OAAQ,CAC1FunB,OAAQ,WACJY,GAAQjoB,KAAKgD,KAAMqG,MAExBnE,KACCgjB,EAAyBd,GAAgC1Q,eAAe5W,UAAW,QAAS,CAC5FunB,OAAQc,KACTjjB,KACH,OAAO,WACH4iB,IACAE,IACAE,QApBJrC,GAuBGxc,GArBAwc,GAuBX,SAASkC,GAAQhB,EAAQxpB,GACrBoqB,GAAYhJ,IAAI3b,KAAM,CAClBolB,MAAO,OACPrB,OAAQA,EACRxpB,IAAK2Q,GAAa3Q,EAAIiD,cAG9B,SAASynB,GAAQ5e,GACb,IAAIZ,EAAQzF,KACRmI,EAAUwc,GAAY5kB,IAAIC,MAC9B,GAAKmI,EAAL,CAGA,IAAIkd,EAAeld,EACnBkd,EAAaD,MAAQ,QACrBC,EAAazP,UAAYzO,IACzBke,EAAa9J,YAAcnU,IAC3Bie,EAAaC,WAAY,EACzBD,EAAaE,IAAMvlB,KACnB,IAAIwlB,GAAkB,EAClBC,EAAsCrB,GAAgCpkB,KAAM,qBAAsB,CAClGqkB,OAAQ,WACArkB,KAAKwC,aAAekR,eAAegS,MAKnCC,OAGTzjB,KACCyjB,EAAQ1jB,IAAQ,WAGhB,GAFAwD,EAAMtD,oBAAoB,UAAWwjB,GACrCF,KACID,EAAJ,CAGAA,GAAkB,EAClB,IAAII,EAAkBzd,EACtByd,EAAgBR,MAAQ,WACxBQ,EAAgB3e,SAAWK,GAAQ+d,EAAa9J,YAAY9U,UAAWS,KACvE0e,EAAgBld,OAASjD,EAAMiD,OAC/BrC,EAAWP,OAAO7I,EAAa2oB,QAEnC5lB,KAAKsB,iBAAiB,UAAWqkB,GACjCtf,EAAWP,OAAOuf,IAEtB,SAASF,KACL,IAAIhd,EAAUwc,GAAY5kB,IAAIC,MAC1BmI,IACAA,EAAQmd,WAAY,GElD5B,SAAShX,GAAWjI,EAAYwf,EAAOC,GACnC,IAAI/B,EAAU+B,GAAQA,EAAK/B,QAA6B,iBAAV8B,GAAsBA,EAAM9B,QAAW,MACjFxpB,EAAM2Q,GAA+B,iBAAV2a,GAAsBA,EAAMtrB,KAAQsrB,GAE/D1d,EAAU,CACVid,MAAO,QACPU,KAAMA,EACND,MAAOA,EACP9B,OAAQA,EACRxI,YANcnU,IAOd7M,IAAKA,GAGT,OADA8L,EAAWP,OAAOqC,GACXA,EAEX,SAAS4d,GAAU1f,EAAY2f,EAAiBX,GAC5C,IAAIY,EAAc,SAAUC,GACxB,IAAI/d,EAAUkd,EACdld,EAAQid,MAAQ,WAChBjd,EAAQlB,SAAWK,GAAQa,EAAQoT,YAAY9U,UAAWS,KACtD,UAAWgf,GAAYA,aAAoBzhB,OAC3C0D,EAAQO,OAAS,EACjBP,EAAQmd,UAAYY,aAAoBC,cAAgBD,EAASE,OAASD,aAAaE,UACvFle,EAAQnP,MAAQktB,EAChB7f,EAAWP,OAAOqC,IAEb,WAAY+d,IACjB/d,EAAQ+d,SAAWA,EACnB/d,EAAQme,aAAeJ,EAASvhB,KAChCwD,EAAQO,OAASwd,EAASxd,OAC1BP,EAAQmd,WAAY,EACpBjf,EAAWP,OAAOqC,KAG1B6d,EAAgBO,KAAKtkB,GAAQgkB,GAAchkB,GAAQgkB,ICnDhD,SAASO,GAAqBre,GACV,IAAnBA,EAAQO,QAAiBP,EAAQmd,YACjCnd,EAAQgQ,aAAU9d,EAClB8N,EAAQse,YAASpsB,GA+CzB,SAASqsB,GAA8BzX,EAAe9G,EAAS6T,EAAgB2K,GAwB/E,IAA4BxO,OALD9d,IAAhBusB,MAXX,SAAsB3X,EAAe4X,GAEjC,IADA,IAAIC,E1B7DGxmB,EAAqB6K,G0B6DE0b,IACrB3qB,EAAK,EAAG2C,EAAKoQ,EAAc8X,sBAAuB7qB,EAAK2C,EAAGzC,OAAQF,IAAM,CAC7E,IAAI8qB,EAAgBnoB,EAAG3C,GACvB,GAAI4qB,IAAkBE,GAAkBA,aAAyBjmB,QAAUimB,EAAc5c,KAAK0c,GAC1F,OAAO,EAGf,OAAO,EAfuBG,CAAahY,EAAe9G,EAAQ5N,MAASyhB,EAAe8B,uBAG1F3V,EAAQgQ,QAAU,IAAI+O,GACtB/e,EAAQse,OAAS,IAAIS,GACrBP,GAkBwBxO,EAlBEhQ,EAAQgQ,QAmB3B,CACH,mBAAoB,MACpB,sBArBuChQ,EAAQse,OAqBjBU,kBAC9B,oBAAqB,IACrB,8BAA+B,IAC/B,qBAAsBhP,EAAQgP,sBATtC,SAASP,KACL,OAAOvmB,OAAO+mB,QAAU/mB,OAAOgnB,SAYnC,IAAIH,GAAiC,WACjC,SAASA,IACLlnB,KAAKoJ,OAAS,IAAIke,WAAW,GAC7BV,KAAYW,gBAAgBvnB,KAAKoJ,QACjCpJ,KAAKoJ,OAAO,GAAsB,IAAjBpJ,KAAKoJ,OAAO,GA0BjC,OAxBA8d,EAAgBpqB,UAAUU,SAAW,SAAUgqB,GAC3C,IAAIC,EAAOznB,KAAK0nB,UAAU,GACtBC,EAAM3nB,KAAK0nB,UAAU,GACrBE,EAAM,GACV,EAAG,CACC,IAAIC,EAAOJ,EAAOD,EAAS,WAAaG,EACxCF,EAAOnqB,KAAKwqB,MAAML,EAAOD,GACzBG,EAAMrqB,KAAKwqB,MAAMD,EAAML,GACvBI,GAAOC,EAAML,GAAOhqB,SAASgqB,GAASI,QACjCH,GAAQE,GACjB,OAAOC,GAKXV,EAAgBpqB,UAAUqqB,gBAAkB,WACxC,OAAOnnB,KAAKxC,SAAS,KAEzB0pB,EAAgBpqB,UAAU4qB,UAAY,SAAUK,GAC5C,OAA8B,SAAtB/nB,KAAKoJ,OAAO2e,IACf/nB,KAAKoJ,OAAO2e,EAAS,IAAM,KAC3B/nB,KAAKoJ,OAAO2e,EAAS,IAAM,GAC5B/nB,KAAKoJ,OAAO2e,EAAS,IAEtBb,EA9ByB,GCnGhCc,GAAmB,EAChB,SAASC,GAAuBlP,EAAW9J,EAAe+M,GAC7D,IAAIkM,EDmBD,SAAqBjZ,EAAe+M,GACvC,MAAO,CACHwK,qBAAsBA,GACtB2B,WAAY,SAAUhgB,GAClB,OAAOue,GAA8BzX,EAAe9G,EAAS6T,GAAgB,SAAUoM,GACnF,IAAIvpB,EACJ,GAAIsJ,EAAQ0d,iBAAiBwC,WAAqC,QAAvBxpB,EAAKsJ,EAAQ2d,YAAyB,IAAPjnB,OAAgB,EAASA,EAAGypB,SAClGngB,EAAQ0d,MAAQ,IAAIwC,QAAQlgB,EAAQ0d,OACpChpB,OAAO2C,KAAK4oB,GAAgB5uB,SAAQ,SAAUoD,GAE1CuL,EAAQ0d,MAAMyC,QAAQC,OAAO3rB,EAAKwrB,EAAexrB,WAGpD,CACDuL,EAAQ2d,KAAO7oB,EAAakL,EAAQ2d,MACpC,IAAI0C,EAAY,GACZrgB,EAAQ2d,KAAKwC,mBAAmBG,QAChCtgB,EAAQ2d,KAAKwC,QAAQ9uB,SAAQ,SAAU2B,EAAOyB,GAC1C4rB,EAAU1tB,KAAK,CAAC8B,EAAKzB,OAGpBuH,MAAMC,QAAQwF,EAAQ2d,KAAKwC,SAChCngB,EAAQ2d,KAAKwC,QAAQ9uB,SAAQ,SAAUkvB,GACnCF,EAAU1tB,KAAK4tB,MAGdvgB,EAAQ2d,KAAKwC,SAClBzrB,OAAO2C,KAAK2I,EAAQ2d,KAAKwC,SAAS9uB,SAAQ,SAAUoD,GAChD4rB,EAAU1tB,KAAK,CAAC8B,EAAKuL,EAAQ2d,KAAKwC,QAAQ1rB,QAGlDuL,EAAQ2d,KAAKwC,QAAUE,EAAU/qB,OAAOiC,EAAc0oB,SAIlEO,SAAU,SAAUxgB,EAASod,GACzB,OAAOmB,GAA8BzX,EAAe9G,EAAS6T,GAAgB,SAAUoM,GACnFvrB,OAAO2C,KAAK4oB,GAAgB5uB,SAAQ,SAAUwB,GAC1CuqB,EAAIqD,iBAAiB5tB,EAAMotB,EAAeptB,YCzD7C6tB,CAAY5Z,EAAe+M,IAIrC,SAAkBjD,EAAW9J,EAAeiZ,GAC5BrD,KAAoBtf,WAAU,SAAUujB,GACvD,IAAI3gB,EAAU2gB,EACd,GAAK3R,GAAoBlI,EAAe9G,EAAQ5N,KAGhD,OAAQ4N,EAAQid,OACZ,IAAK,QACD8C,EAAOS,SAASxgB,EAASA,EAAQod,KACjCpd,EAAQ4gB,aAAeC,KACvBjQ,EAAUjT,OAAO,EAAyB,CACtCijB,aAAc5gB,EAAQ4gB,eAE1B,MACJ,IAAK,WACDb,EAAO1B,qBAAqBre,GAC5B4Q,EAAUjT,OAAO,EAA2B,CACxCmB,SAAUkB,EAAQlB,SAClB8c,OAAQ5b,EAAQ4b,OAChBgF,aAAc5gB,EAAQ4gB,aACtBtC,OAAQte,EAAQse,OAChBlL,YAAapT,EAAQoT,YACrB7S,OAAQP,EAAQO,OAChByP,QAAShQ,EAAQgQ,QACjBxT,KAAM,MACNpK,IAAK4N,EAAQ5N,IACbgrB,IAAKpd,EAAQod,UA7B7B0D,CAASlQ,EAAW9J,EAAeiZ,GAoChC,SAAoBnP,EAAW9J,EAAeiZ,GACjD,IF9BI7hB,GANCqe,KAMDre,EAAa,IAAIjB,GAAW,WAC5B,GAAK/E,OAAO6oB,MAiBZ,OAdWpF,GAAiBzjB,OAAQ,SAAS,SAAU8oB,GACnD,OAAO,SAAUtD,EAAOC,GACpB,IAAIE,EACA7d,EAAUlD,GAAcqJ,GAAY,KAAM,CAACjI,EAAYwf,EAAOC,IAQlE,OAPI3d,GACA6d,EAAkBmD,EAAcnsB,KAAKgD,KAAMmI,EAAQ0d,MAAO1d,EAAQ2d,MAClE7gB,GAAc8gB,GAAW,KAAM,CAAC1f,EAAY2f,EAAiB7d,KAG7D6d,EAAkBmD,EAAcnsB,KAAKgD,KAAM6lB,EAAOC,GAE/CE,MAEZ9jB,QAtBHwiB,GAyBGre,GAvBAqe,IEiCkCnf,WAAU,SAAUujB,GACzD,IAAI3gB,EAAU2gB,EACd,GAAK3R,GAAoBlI,EAAe9G,EAAQ5N,KAGhD,OAAQ4N,EAAQid,OACZ,IAAK,QACD8C,EAAOC,WAAWhgB,GAClBA,EAAQ4gB,aAAeC,KACvBjQ,EAAUjT,OAAO,EAAyB,CACtCijB,aAAc5gB,EAAQ4gB,eAE1B,MACJ,IAAK,WACDb,EAAO1B,qBAAqBre,GAC5B4Q,EAAUjT,OAAO,EAA2B,CACxCmB,SAAUkB,EAAQlB,SAClB8c,OAAQ5b,EAAQ4b,OAChBgF,aAAc5gB,EAAQ4gB,aACtBzC,aAAcne,EAAQme,aACtBG,OAAQte,EAAQse,OAChBlL,YAAapT,EAAQoT,YACrB7S,OAAQP,EAAQO,OAChByP,QAAShQ,EAAQgQ,QACjBxT,KAAM,QACNpK,IAAK4N,EAAQ5N,IACb2rB,SAAU/d,EAAQ+d,SAClBJ,KAAM3d,EAAQ2d,KACdD,MAAO1d,EAAQ0d,YAhE/BuD,CAAWrQ,EAAW9J,EAAeiZ,GAuEzC,SAASc,KACL,IAAItqB,EAASspB,GAEb,OADAA,IAAoB,EACbtpB,EChFJ,SAAS2qB,GAAiBtQ,EAAWzW,QACvB,IAAbA,IAAuBA,EAAWrE,GACtC,IAAIqrB,EAAc,CACdC,WAAY,EACZC,cAAe,EACfC,cAAe,EACfC,gBAAiB,GAEjBpjB,EAAeyS,EAAUxT,UAAU,IAA8B,SAAU1G,GAE3E,OADWA,EAAG8F,MAEV,IAAK,QACD2kB,EAAYC,YAAc,EAC1BjnB,EAASgnB,GACT,MACJ,IAAK,SACDA,EAAYI,iBAAmB,EAC/BpnB,EAASgnB,GACT,MACJ,IAAK,YACDA,EAAYE,eAAiB,EAC7BlnB,EAASgnB,GACT,MACJ,IAAK,WACDA,EAAYG,eAAiB,EAC7BnnB,EAASgnB,OAIrB,MAAO,CACHpnB,KAAM,WACFoE,EAAaX,eAEjB2jB,YAAaA,GCCd,SAASK,GAAa5Q,EAAW6Q,EAAuBC,EAAkBC,GAC7E,IAAIC,EAkCD,SAAsChR,EAAW6Q,GACpD,IAAIvjB,EAAa,IAAIjB,GAAW,WAC5B,IACI4kB,EADA5jB,EAAgB,GAEhB6jB,EAAuB,EAoB3B,OAnBA7jB,EAActL,KAAK8uB,EAAsBrkB,WAAU,WAAc,OAAO2kB,EAAmBD,MAA2BlR,EAAUxT,UAAU,GAAuC,SAAUiU,GACnLA,EAAQtP,MAAK,SAAUrL,GAEvB,MAAqB,aADLA,EAAG8Z,cAGnBuR,EAAmBD,MAEvBlR,EAAUxT,UAAU,GAAyB,SAAU4kB,QAC7B9vB,IAAtB2vB,IACAA,EAAoBG,EAAWpB,cAEnCmB,IAAqBD,MACrBlR,EAAUxT,UAAU,GAA2B,SAAU6L,QAE/B/W,IAAtB2vB,GAAmC5Y,EAAQ2X,aAAeiB,GAG9DE,IAAqBD,OAElB,WAAc,OAAO7jB,EAAc5M,SAAQ,SAAU4wB,GAAK,OAAOA,EAAEzkB,qBAE9E,SAASukB,EAAmBD,GACxB5jB,EAAWP,OAAO,CAAEukB,OAAQJ,EAAuB,IAEvD,OAAO5jB,EA/DsBikB,CAA6BvR,EAAW6Q,GACrE,OAEG,SAAwBG,EAAwBF,EAAkBC,GACrE,IAAIS,EACAC,GAAe,EACfC,EAAsBnuB,WAAW2F,IAAQ,WAAc,OAAOyoB,EAAS,CAAEC,aAAa,OAxClD,KAyCpCC,EAAuBd,GACvBxtB,WAAW2F,IAAQ,WAAc,OAAOyoB,EAAS,CAAEC,aAAa,EAAMnjB,IAAKN,SAAuB4iB,GAClGe,EAA2Bd,EAAuBxkB,WAAU,SAAU1G,GACtE,IAAIwrB,EAASxrB,EAAGwrB,OAChB7tB,aAAaiuB,GACbjuB,aAAa+tB,GACb,IAAIO,EAAiB5jB,IAChBmjB,IACDE,EAAgBjuB,WAAW2F,IAAQ,WAAc,OAAOyoB,EAAS,CAAEC,aAAa,EAAMnjB,IAAKsjB,OA/ClE,SAkD7B5oB,EAAO,WACPsoB,GAAe,EACfhuB,aAAaiuB,GACbjuB,aAAa+tB,GACb/tB,aAAaouB,GACbC,EAAyBllB,eAE7B,SAAS+kB,EAASlpB,GACVgpB,IAGJtoB,IACA2nB,EAAiBroB,IAErB,MAAO,CAAEU,KAAMA,GA/BR6oB,CAAehB,EAAwBF,EAAkBC,GChCpE,IAAIkB,GAAiC,sBAcrC,SAASC,GAAyCC,EAAeC,GAC7D,IAAIC,EAKJ,QAiMqC/wB,IAAjCgxB,KACAA,GAA+B,YAAaC,YAAYxuB,WAErDuuB,GAnMHD,EAAuBF,EAAcK,QAAQ,IAAI9tB,OAAO0tB,EAAuB,WAI/E,IADA,IAAI5qB,EAAU2qB,EACP3qB,GAAS,CACZ,GAAIA,EAAQirB,aAAaL,GAAwB,CAC7CC,EAAuB7qB,EACvB,MAEJA,EAAUA,EAAQkrB,cAG1B,GAAKL,EAIL,OAAOM,GAASC,GADLP,EAAqBQ,aAAaT,GACJU,SAE7C,IA+JIC,GAaAT,GA5KAU,GAAqB,CAErB,SAAUxrB,EAASyrB,GAGf,QA4JgC3xB,IAAhCyxB,KACAA,GAA8B,WAAYG,iBAAiBnvB,WAExDgvB,IA9JC,GAAI,WAAYvrB,GAAWA,EAAQ2rB,QAAU3rB,EAAQ2rB,OAAO9vB,OAAS,EACjE,OAAO+vB,GAAkB5rB,EAAQ2rB,OAAO,GAAIF,QAG/C,GAAIzrB,EAAQie,GAAI,CACjB,IAAI4N,EAAQ7rB,EAAQ8rB,eAAiB9rB,EAAQ8rB,cAAc/U,cAAc,cAAe7Z,OAAO8C,EAAQie,GAAG9gB,QAAQ,IAAK,OAAQ,OAC/H,OAAO0uB,GAASD,GAAkBC,EAAOJ,KAIjD,SAAUzrB,GACN,GAAyB,UAArBA,EAAQ+X,SAAsB,CAC9B,IAAIuN,EAAQtlB,EACRoE,EAAOkhB,EAAM+F,aAAa,QAC9B,GAAa,WAATjnB,GAA8B,WAATA,GAA8B,UAATA,EAC1C,OAAOkhB,EAAM1qB,QAKzB,SAAUoF,EAASyrB,GACf,GAAyB,WAArBzrB,EAAQ+X,UAA8C,UAArB/X,EAAQ+X,UAAyD,WAAjC/X,EAAQqrB,aAAa,QACtF,OAAOO,GAAkB5rB,EAASyrB,IAG1C,SAAUzrB,GAAW,OAAOA,EAAQqrB,aAAa,eAEjD,SAAUrrB,EAASyrB,GACf,IAAIM,EAAsB/rB,EAAQqrB,aAAa,mBAC/C,GAAIU,EACA,OAAOA,EACF/yB,MAAM,OACNkG,KAAI,SAAU+e,GAAM,OA0DrC,SAAwB+N,EAAY/N,GAGhC,OAAO+N,EAAWF,cAAgBE,EAAWF,cAAcG,eAAehO,GAAM,KA7DxCgO,CAAejsB,EAASie,MACnD5Y,QAAO,SAAUwmB,GAAS,OAAOpb,QAAQob,MACzC3sB,KAAI,SAAUc,GAAW,OAAO4rB,GAAkB5rB,EAASyrB,MAC3DnoB,KAAK,MAGlB,SAAUtD,GAAW,OAAOA,EAAQqrB,aAAa,QACjD,SAAUrrB,GAAW,OAAOA,EAAQqrB,aAAa,SACjD,SAAUrrB,GAAW,OAAOA,EAAQqrB,aAAa,UACjD,SAAUrrB,GAAW,OAAOA,EAAQqrB,aAAa,gBAEjD,SAAUrrB,EAASyrB,GACf,GAAI,YAAazrB,GAAWA,EAAQ/E,QAAQY,OAAS,EACjD,OAAO+vB,GAAkB5rB,EAAQ/E,QAAQ,GAAIwwB,KAIrDS,GAAqB,CACrB,SAAUlsB,EAASyrB,GAA6B,OAAOG,GAAkB5rB,EAASyrB,KAOtF,SAASU,GAAsCxB,EAAec,EAA2BW,GAGrF,IAFA,IAAIpsB,EAAU2qB,EACV0B,EAAmB,EAChBA,GAJmB,IAKtBrsB,GACqB,SAArBA,EAAQ+X,UACa,SAArB/X,EAAQ+X,UACa,SAArB/X,EAAQ+X,UAAqB,CAC7B,IAAK,IAAIpc,EAAK,EAAG2wB,EAAeF,EAAYzwB,EAAK2wB,EAAazwB,OAAQF,IAAM,CACxE,IACI4wB,GAASC,EADEF,EAAa3wB,IACNqE,EAASyrB,GAC/B,GAAsB,iBAAXc,EAAqB,CAC5B,IAAIE,EAAcF,EAAOjB,OACzB,GAAImB,EACA,OAAOtB,GAASC,GAAoBqB,KAMhD,GAAyB,SAArBzsB,EAAQ+X,SACR,MAEJ/X,EAAUA,EAAQkrB,cAClBmB,GAAoB,GAG5B,SAASjB,GAAoBvB,GACzB,OAAOA,EAAE1sB,QAAQ,OAAQ,KAE7B,SAASguB,GAAStB,GACd,OAAOA,EAAEhuB,OAAS,IAAM,GAAGqB,OAAOuD,EAAaopB,EAAG,KAAM,UAAYA,EAOxE,SAAS+B,GAAkB5rB,EAASyrB,GAChC,IAAIzrB,EAAQ0sB,kBAAZ,CAGA,GAAI,cAAe1sB,EAAS,CACxB,IAAI2sB,EAAS3sB,EAAQ4sB,UACjBC,EAAyB,SAAUC,GAEnC,IADA,IAAIC,EAAO/sB,EAAQgtB,iBAAiBF,GAC3B/J,EAAQ,EAAGA,EAAQgK,EAAKlxB,OAAQknB,GAAS,EAAG,CACjD,IAAIkK,EAAYF,EAAKhK,GACrB,GAAI,cAAekK,EAAW,CAC1B,IAAIC,EAAgBD,EAAUL,UAC1BM,GAAiBA,EAAc5B,OAAOzvB,OAAS,IAC/C8wB,EAASA,EAAOxvB,QAAQ+vB,EAAe,QAevD,OV5KGzc,QAAQzO,SAASmrB,eUqKhBN,EAAuB,iBAG3BA,EAAuB,IAAI3vB,OAAOutB,GAAgC,MAC9DgB,GACAoB,EAAuB,IAAI3vB,OAAOuuB,EAA2B,MAE1DkB,EAEX,OAAO3sB,EAAQotB,aCxKZ,SAASC,GAAa7U,EAAW6Q,EAAuB/qB,GAC3D,IAAIgvB,EAAsBhvB,EAAGgvB,oBACzBC,EAAU,IAAI9K,GAHqB,KAIvCjK,EAAUxT,UAAU,GAAyB,WACzCuoB,EAAQnK,WAEZ,IAgCkBrhB,EAhCdyrB,GAgCczrB,EAhCc,SAAUd,GACtC,GAAKoG,GAA6B,yBAA0BkmB,EAAQ9uB,OAApE,CAIA,IDZiCuB,EAASyrB,ECYtChxB,GDZ6BuF,ECYGiB,EAAM/E,ODZAuvB,ECYQ6B,EDL9C5C,GAAyC1qB,EAASyqB,KACrDgB,GAA6Bf,GAAyC1qB,EAASyrB,IAChFU,GAAsCnsB,EAASyrB,EAA2BD,KAC1EW,GAAsCnsB,EAASyrB,EAA2BS,KAC1E,ICEA,GAAKzxB,EAGL,IAAIgzB,EA8BZ,SAAmBjV,EAAW6Q,EAAuBjlB,EAAM3J,EAAMwG,EAAOysB,EAAoBC,GACxF,IAWIC,EAXA3P,EAAKrhB,IACLoe,EAAcnU,IACdgnB,EAA0B/E,GAAiBtQ,GAC3CsV,EAAsB1E,GAAa5Q,EAAW6Q,GAAuB,SAAU0E,GAC3EA,EAAU3D,aAAepP,EAAY9U,WAAa6nB,EAAU9mB,IAYpE,SAAkB6b,GACdkL,IACA,IAAIjF,EAAc8E,EAAwB9E,YAC1CvQ,EAAUjT,OAAO,EAA+B,CAC5C0oB,OAAQ,CACJjF,WAAYD,EAAYC,WACxBC,cAAeF,EAAYE,cAC3BC,cAAeH,EAAYG,eAE/BxiB,SAAUK,GAAQiU,EAAY9U,UAAW4c,GACzC7E,GAAIA,EACJxjB,KAAMA,EACNugB,YAAaA,EACb5W,KAAMA,EACNnD,MAAOA,IA7D0F,SAAU6hB,GAC3GoL,EAAalL,MAAM9b,GAAgB4b,IA8DvC4K,CAAmB5K,GA3BfqH,CAAS4D,EAAU9mB,KAGnBknB,MAxD0B,KA0DLxsB,KAwB7B,SAASwsB,IACLH,IA/DIE,EAAa7b,SAkErB,SAAS2b,IACLF,IACAD,EAAwBlsB,OACpBisB,GACAA,EAAwBxoB,cAGhC,OAjCKiC,GAA6B,yBAE9BumB,EAA0BpV,EAAUxT,UAAU,EAAsBmpB,IA+BjE,CACHA,QAASA,EACTlQ,GAAIA,EACJjD,YAAaA,GA/EUoT,CAAU5V,EAAW6Q,EAAuB,QAAqB5uB,EAAMwG,GAK1FitB,EAAeX,EAAQ3qB,IAAI6qB,EAAkBA,EAAiBzS,YAAY/U,YAmB3ElF,EAAiBjB,OAAQ,SAAqB,SAAUmB,GACvDA,EAAM/E,kBAAkBmyB,SACxBtsB,EAASd,KAEd,CAAEM,SAAS,KAtBXI,KACCia,EAAiB,CACjByC,aAAc,SAAUhJ,GACpB,IAAI/W,EACJ,OAAO+I,GAA6B,uBAC9BkmB,EAAQpK,QAAQ9N,GAAWnW,KAAI,SAAUovB,GAAc,OAAOA,EAAWrQ,MACtC,QAAlC3f,EAAKivB,EAAQ9uB,KAAK4W,UAA+B,IAAP/W,OAAgB,EAASA,EAAG2f,KAGrF,MAAO,CACHtc,KAAM,WACF4rB,EAAQpK,UAAUlqB,SAAQ,SAAUw0B,GAAoB,OAAOA,EAAiBU,aAChFX,KAEJ5R,eAAgBA,GCvBxB,SAAS2S,GAAchQ,EAAQiQ,GAC3B,IAAIC,EAAuBC,GAAanQ,GAClC,CACEA,OAAQ,CACJ9lB,MAAO,CACHk2B,MAAOpQ,EAAO0P,OAAOjF,YAEzB/K,GAAIM,EAAON,GACX2Q,aAAcnoB,EAAiB8X,EAAO7X,UACtCmoB,UAAW,CACPF,MAAOpQ,EAAO0P,OAAOhF,eAEzB6F,SAAU,CACNH,MAAOpQ,EAAO0P,OAAO/E,sBAI/BpvB,EACFmjB,EAAmByR,GAAanQ,QAA2BzkB,EAAjBykB,EAAO3W,QACjDmnB,EAAcrrB,EAAQ,CACtB6a,OAAQ,CACJN,GAAIrhB,IACJV,OAAQ,CACJzB,KAAM8jB,EAAO9jB,MAEjB2J,KAAMma,EAAOna,MAEjB4F,KAAMuU,EAAOvD,YAAY9U,UACzB9B,KAAM,UACPqqB,GACCO,EAAeR,EAAmB/O,iBAAiBlB,EAAOvD,YAAY/U,UAI1E,YAHqBnM,IAAjBk1B,IACAD,EAAYE,KAAO,CAAEC,cAAeF,IAEjC,CACH/R,gBAAiBA,EACjBH,YAAaiS,EACb1Z,UAAWkJ,EAAOvD,YAAY/U,SAC9B8W,cAAe2R,GAAanQ,GAAU,CAAEtd,MAAOsd,EAAOtd,OAAU,IAGxE,SAASytB,GAAanQ,GAClB,MAAuB,WAAhBA,EAAOna,KC1DlB,IAAI+qB,GAAiB,0GCEd,IAAIC,GAKA,QAEPC,GAA0B,GA+B9B,SAASC,GAAgBC,EAAQC,EAAKvrB,GAElC,IACIpL,EADA2B,EAAU+0B,EAAOrwB,KAAI,SAAUuwB,GAAS,OAchD,SAAiCA,GAC7B,MAAqB,iBAAVA,EACAA,EAEPA,aAAiBvrB,MACVG,EAAmB1L,EAAkB82B,IAEzC9xB,EAAc8xB,OAAO31B,EAAW,GArBY41B,CAAwBD,MAAWnsB,KAAK,KAE3F,GAAIksB,IAAQJ,GAAsB,CAC9B,IAAIO,EAAkBlxB,EAAK8wB,GAAQ,SAAUE,GAAS,OAAOA,aAAiBvrB,SAC9ErL,EAAQ82B,EAAkBxrB,EAAmBxL,EAAkBg3B,SAAoB71B,EACnFU,EAAU,kBAAkB0C,OAAO1C,GAEvC,MAAO,CACHg1B,IAAKA,EACLh1B,QAASA,EACT3B,MAAOA,EACPoL,cAAeA,GCpDhB,ICHH2rB,GACAC,GDEOC,GAGO,gBA+DlB,SAASC,GAAWt1B,EAAMD,EAASw1B,EAAYC,EAAYC,GACvD,OAAQF,GACJ7rB,EAAmB,CACf1J,KAAMA,EACND,QAASA,EACT3B,MAAO,CACH,CACIkB,KAAM,IACNC,IAAKg2B,EACL92B,KAAM+2B,EACNp2B,OAAQq2B,ME7ErB,SAASC,GAAqB3X,EAAWgW,GAC5C,IAAI4B,EAAkB,IAAIvrB,EAK1B,OCRG,SAA2BurB,GAC9B,IJWkCC,EAC9BC,GAD8BD,EIXO,CAACjB,IJYtCkB,EAAqBD,EAAKnxB,KAAI,SAAUswB,GAIxC,OAHKH,GAAwBG,KACzBH,GAAwBG,GAOpC,SAAiCA,GAC7B,IAAI1pB,EAAa,IAAIjB,GAAW,WAC5B,IAAI0rB,EAAqBj4B,QAAQk3B,GAYjC,OAXAl3B,QAAQk3B,GAAO,WAEX,IADA,IAAID,EAAS,GACJ5zB,EAAK,EAAGA,EAAKC,UAAUC,OAAQF,IACpC4zB,EAAO5zB,GAAMC,UAAUD,GAE3B40B,EAAmBz0B,MAAMxD,QAASi3B,GAClC,IAAItrB,EAAgBM,IACpBG,IAAc,WACVoB,EAAWP,OAAO+pB,GAAgBC,EAAQC,EAAKvrB,QAGhD,WACH3L,QAAQk3B,GAAOe,MAGvB,OAAOzqB,EAzBgC0qB,CAAwBhB,IAEpDH,GAAwBG,MAE5B9pB,EAAiB5J,WAAM,EAAQw0B,IIlB2BtrB,WAAU,SAAUyrB,GACjF,OAAOL,EAAgB7qB,OAAO,CAC1ByV,YAAanU,IACbrM,QAASi2B,EAAaj2B,QACtB3B,MAAO43B,EAAa53B,MACpBuD,O9CFC,U8CGDs0B,SAAU,UACVzsB,cAAewsB,EAAaxsB,mBDJpC0sB,CAAkBP,GEFf,SAA2BA,GNgC3B,IAAuCruB,EAAAA,EM/BL,SAAU+B,EAAYC,GACvD,IAAIzF,EAAKuF,EAAmBC,EAAYC,EAAa,YAAalL,EAAQyF,EAAGzF,MAAO2B,EAAU8D,EAAG9D,QAAS4J,EAAO9F,EAAG8F,KACpHgsB,EAAgB7qB,OAAO,CACnB/K,QAASA,EACT3B,MAAOA,EACPuL,KAAMA,EACNhI,O/CDA,S+CEA4e,YAAanU,IACb+pB,cAAe7sB,EACf2sB,SAAU,eNmCtB,SAA2B3uB,GACvB,OAAO8hB,GAAgC/jB,OAAQ,UAAW,CACtDgkB,OAAQ,SAAUtpB,EAASR,EAAK62B,EAAQC,EAAUC,GAC9C,IAAIl4B,EACJ,GAAIk4B,EACAl4B,EAAQF,EAAkBo4B,GAC1BhvB,EAASlJ,EAAOk4B,OAEf,CACD,IAKIxE,EALAyE,EAAa,CACbh3B,IAAKA,EACLH,OAAQi3B,EACR53B,KAAM23B,GAGNI,EAAMz2B,EACV,GAAkC,oBAA9B,GAAGyC,SAASR,KAAKjC,GAAgC,CACjD,IAAI02B,EAAS/B,GAAe71B,KAAK23B,GAC7BC,IACA3E,EAAS2E,EAAO,GAChBD,EAAMC,EAAO,IAQrBnvB,EALAlJ,EAAQ,CACJ4B,KAAM8xB,EACN/xB,QAAwB,iBAARy2B,EAAmBA,OAAMn3B,EACzCjB,MAAO,CAACm4B,IAEIx2B,OAxCG22B,CAAkBpvB,GAAUJ,KAgD/D,SAAsCI,GAClC,OAAO8hB,GAAgC/jB,OAAQ,uBAAwB,CACnEgkB,OAAQ,SAAUrf,GACd,IAAIiN,EAASjN,EAAEiN,QAAU,eACrB7Y,EAAQF,EAAkB+Y,GAC9B3P,EAASlJ,EAAO6Y,MApDoB0f,CAA6BrvB,GAAUJ,KI/BnF0vB,CAAkBjB,GGLf,SAA0BA,ILQ1B,SAA8BC,GACjC,IAgCIvqB,EAhCAH,EAAc,GACdpH,EAAS8xB,EAAMP,KACfnqB,EAAYpL,KA8BZuL,EAAa,IAAIjB,GAAW,WAC5B,IAAIysB,EAAqB5vB,IAAQ,SAAUT,GACvC6E,EAAWP,OAgBvB,SAAwCtE,GACpC,IACIzG,EAAU,IAAI0C,OAAO+D,EAAMswB,WAAY,kBAAkBr0B,OAAO+D,EAAMuwB,mBAAoB,eAC9F,MAAO,CACHptB,KAAM0rB,GACN2B,QAASxwB,EAAMuwB,mBACfh3B,QAAS,GAAG0C,OALL4yB,gBAKkB,MAAM5yB,OAAO1C,GACtC3B,MAAOk3B,GAAW9uB,EAAMuwB,mBAAoB,GAAGt0B,OAAO1C,EAAS,oBAAqB0C,OAAOuD,EAAaQ,EAAMywB,eAAgB,IAAK,OAAQ,KAAOzwB,EAAM+uB,WAAY/uB,EAAMgvB,WAAYhvB,EAAMivB,eAvBtKyB,CAA+B1wB,OAGrD,OADWF,EAAiBiB,SAAU,0BAA2DsvB,GAAoB3vB,SAhCzH,IAAIiwB,EAAcvB,EAAKhrB,QAAO,SAAUmqB,GAAO,OAAOA,IAAQM,MAI9D,OAHI8B,EAAY/1B,QACZ8J,EAAYpL,KAIpB,SAAgCq3B,GAC5B,IAAI9rB,EAAa,IAAIjB,GAAW,WAC5B,GAAK/E,OAAO+xB,kBAAZ,CAGA,IAAIC,EAAgBpwB,IAAQ,SAAUqwB,GAClC,OAAOA,EAAQ94B,SAAQ,SAAU+4B,GAC7BlsB,EAAWP,OAwB3B,SAAkCjH,GAC9B,IAAI8F,EAAO9F,EAAG8F,KAAMqH,EAAOnN,EAAGmN,KAC9B,MAAO,CACHrH,KAAMA,EACNqtB,QAAShmB,EAAKwS,GACdzjB,QAAS,GAAG0C,OAAOkH,EAAM,MAAMlH,OAAOuO,EAAKjR,SAC3C3B,MAAOk3B,GAAWtkB,EAAKwS,GAAIxS,EAAKjR,QAASiR,EAAKukB,WAAYvkB,EAAKwkB,WAAYxkB,EAAKykB,eA9BtD+B,CAAyBD,UAG/CvsB,EAAW,IAAI3F,OAAO+xB,kBAAkBC,EAAe,CACvDI,MAAON,EACPvY,UAAU,IAGd,OADA5T,EAAS2T,UACF,WACH3T,EAAS0sB,kBAGjB,OAAOrsB,EAvBcssB,CAAuBR,IAErClsB,EAAiB5J,WAAM,EAAQ6J,IKhBnB0sB,CAAqB,CAACvC,GLG3B,iBKHoF9qB,WAAU,SAAU8W,GAClH,OAAOsU,EAAgB7qB,OAAO,CAC1ByV,YAAanU,IACbrM,QAASshB,EAAYthB,QACrB3B,MAAOijB,EAAYjjB,MACnBuL,KAAM0X,EAAY2V,QAClBr1B,OhDEA,SgDDAs0B,SAAU,iBHFlB4B,CAAiBlC,GACjBA,EAAgBprB,WAAU,SAAUvM,GAAS,OAAO+f,EAAUjT,OAAO,GAA8B,CAAE9M,MAAOA,OAGzG,SAAgC+f,EAAWgW,GAQ9C,OAPAhW,EAAUxT,UAAU,IAA8B,SAAU1G,GACxD,IAAI7F,EAAQ6F,EAAG7F,MAAOwkB,EAAkB3e,EAAG2e,gBAAiBD,EAAqB1e,EAAG0e,mBACpFxE,EAAUjT,OAAO,GAAkC,EAAO,CACtD0X,gBAAiBA,EACjBD,mBAAoBA,GAwBhC,SAAsBvkB,EAAO+1B,GACzB,IAAI1R,EAAc,CACd9S,KAAMvR,EAAMuiB,YAAY9U,UACxBzN,MAAO,CACHwlB,GAAIrhB,IACJpC,QAAS/B,EAAM+B,QACf4B,OAAQ3D,EAAM2D,OACdvD,MAAOJ,EAAMI,MACb05B,eAAgB95B,EAAMwL,cACtBG,KAAM3L,EAAM2L,KACZssB,SAAUj4B,EAAMi4B,SAChB8B,YAAa,WAEjBpuB,KAAM,SAEN4qB,EAAeR,EAAmB/O,iBAAiBhnB,EAAMuiB,YAAY/U,UAIzE,YAHqBnM,IAAjBk1B,IACAlS,EAAYmS,KAAO,CAAEC,cAAeF,IAEjC,CACHlS,YAAaA,EACbzH,UAAW5c,EAAMuiB,YAAY/U,SAC7B8W,cAAe,CACXtkB,MAAOA,EAAMm4B,gBA9Cd6B,CAAah6B,EAAO+1B,QAEpB,CACHkE,SAAU,SAAUp0B,EAAI0e,GACpB,IAAIvkB,EAAQ6F,EAAG7F,MAAOwL,EAAgB3F,EAAG2F,cAAe+W,EAAc1c,EAAG0c,YAAaiC,EAAkB3e,EAAGsJ,QACvG+qB,EAShB,SAAyBl6B,EAAOwL,EAAe+W,GAE3C,OAAO,EAAO,CACVA,YAAaA,EACb5e,O7C7BI,S6C8BJw0B,cAAen4B,EACfi4B,SAAU,WACX7sB,EANcpL,aAAiByL,MAAQvL,EAAkBF,QAASqB,EAMnCrB,EAAO,WAAYwL,IAhB9B2uB,CAAgBn6B,EAAOwL,EAAe+W,GACrDxC,EAAUjT,OAAO,GAA8B,CAC3C0X,gBAAiBA,EACjBD,mBAAoBA,EACpBvkB,MAAOk6B,MAjBZE,CAAuBra,EAAWgW,GI+B7C,SAAS1L,GAAQ1b,GAEb,OAAQA,EAAOiO,UAAYjO,EAAOV,SCtC/B,SAASosB,GAAwBta,GACpCA,EAAUxT,UAAU,GAA2B,SAAU6L,GACrD2H,EAAUjT,OAAO,GAWzB,SAAwBsL,GACpB,IAAIzM,EAAwB,QAAjByM,EAAQzM,KAA2B,MAAkB,QAC5D2uB,EDJD,SAA4BliB,GAC/B,GAAKvK,aAAiB,qBAAsBA,YAA5C,CAGA,IAAI0sB,EAAkB1sB,YAAY2sB,iBAAiBpiB,EAAQ7W,IAAK,YAChE,GAAKg5B,EAAgBn3B,QAAY,WAAYm3B,EAAgB,GAA7D,CAGA,IAc6BE,EAdzBC,EAAaH,EACZ9zB,KAAI,SAAUgW,GAAS,OAAOA,EAAMhX,YACpCmH,OAAO+P,IACP/P,QAAO,SAAU6P,GAClB,OAiBW9N,EAjBM8N,EAiBElO,EAjBK6J,EAAQmK,YAAY/U,SAiBlBgB,EAjB4B6b,GAAQ,CAAEzN,UAAWxE,EAAQmK,YAAY/U,SAAUS,SAAUmK,EAAQnK,WAoBxHU,EAAOiO,WAAarO,EAFT,GAEgC8b,GAAQ1b,IAAWH,EAFnD,EADtB,IAAmBG,EAAQJ,EAAOC,KAf9B,OAA0B,IAAtBksB,EAAWt3B,OACJs3B,EAAW,GAEI,IAAtBA,EAAWt3B,QAMRinB,IADsBoQ,EAL0BC,GAMnB,KAAOD,EAAqB,GAAG7d,UALxD8d,EAAW,QADtB,ICbqBC,CAAmBviB,GACpCmK,EAAc+X,EAAiB/sB,EAAiB+sB,EAAe1d,WAAaxE,EAAQmK,YACpFqY,EAA+BN,EAAiBO,GAA+BP,QAAkBj5B,EACjGy5B,EAwDR,SAAmC1iB,GAE/B,GADoBA,EAAQ+G,SAAW/G,EAAQqV,OAI/C,MAAO,CACHxI,IAAK,CACD8V,QAAS3iB,EAAQqV,OAAOU,kBACxB6M,SAAU5iB,EAAQ+G,QAAQgP,oBAhEhB8M,CAA0B7iB,GACxC8iB,EAAgBjwB,EAAQ,CACxBsG,KAAMgR,EAAY9U,UAClB4oB,SAAU,CACN7Q,GAAIrhB,IACJwH,KAAMA,EACNsC,SAAUD,EAAiBoK,EAAQnK,UACnC8c,OAAQ3S,EAAQ2S,OAChBoQ,YAAa/iB,EAAQ1I,OACrBnO,IAAK6W,EAAQ7W,KAEjBoK,KAAM,YACPmvB,EAAaF,GAChB,MAAO,CACHhe,UAAW2F,EAAY/U,SACvB6W,YAAa6W,EACb5W,cAAe,CACX8W,iBAAkBd,GAAkBe,GAAiCf,GACrE/N,IAAKnU,EAAQmU,IACbW,SAAU9U,EAAQ8U,SAClBoO,aAAcljB,EAAQyU,MACtB0O,YAAanjB,EAAQ0U,KACrB9sB,MAAOoY,EAAQpY,QAtCgCw7B,CAAepjB,OAEtE2H,EAAUxT,UAAU,GAAuC,SAAUiU,GACjE,IAAK,IAAItd,EAAK,EAAGu4B,EAAYjb,EAAStd,EAAKu4B,EAAUr4B,OAAQF,IAAM,CAC/D,IAAIuZ,EAAQgf,EAAUv4B,GACE,aAApBuZ,EAAMkD,WhCwCc,oBADNhR,EgCvCmC8N,GhCwC/CN,eAA+D,UAAzBxN,EAAOwN,egCvC/C4D,EAAUjT,OAAO,GAAkC4uB,GAAqBjf,IhCsCjF,IAAuB9N,KgCF9B,SAAS+sB,GAAqBjf,GAC1B,IAAI9Q,EhC1BD,SAA6BgD,GAChC,IAAIpN,EAAMoN,EAAO3M,KACjB,IVrBG,SAAoBT,GACvB,IACI,QAAS4Q,GAAS5Q,GAEtB,MAAOsE,GACH,OAAO,GUgBN81B,CAAWp6B,GAEZ,OADA+N,GAAqB,gCAAiC7K,OAAOkK,EAAO3M,KAAM,MACnE,QAGX,IADA,IAAIqa,EVXD,SAAqB9a,GACxB,IAAIq6B,EAAWzpB,GAAS5Q,GAAKq6B,SAC7B,MAAuB,MAAhBA,EAAS,GAAaA,EAAW,IAAIn3B,OAAOm3B,GUSxCC,CAAYt6B,GACd2B,EAAK,EAAG44B,EAAmB5f,GAAgBhZ,EAAK44B,EAAiB14B,OAAQF,IAAM,CACpF,IAAI2C,EAAKi2B,EAAiB54B,GAAKyI,EAAO9F,EAAG,GACzC,IAAIk2B,EADkDl2B,EAAG,IAC9C8I,EAAOwN,cAAeE,GAC7B,OAAO1Q,EAGf,MAAO,QgCaIqwB,CAAoBvf,GAC3Bwf,EAAepB,GAA+Bpe,GAC9Cqe,EAuCR,SAAiCre,GAC7B,OAAOA,EAAM0C,QAAU,CAAE8F,IAAK,CAAE+V,SAAUve,EAAM0C,eAAc9d,EAxC5C66B,CAAwBzf,GACtC8F,EAAchV,EAAiBkP,EAAMG,WACrCse,EAAgBjwB,EAAQ,CACxBsG,KAAMgR,EAAY9U,UAClB4oB,SAAU,CACN7Q,GAAIrhB,IACJwH,KAAMA,EACNpK,IAAKkb,EAAMza,MAEf2J,KAAM,YACPmvB,EAAamB,GAChB,MAAO,CACHrf,UAAW2F,EAAY/U,SACvB6W,YAAa6W,EACb5W,cAAe,CACX8W,iBAAkBC,GAAiC5e,KAI/D,SAASoe,GAA+BlsB,GACpC,MAAO,CACH0nB,SAAU,EAAO,CACbpoB,UhCpBuCwO,EgCoBM9N,EhCnBjDV,EAAWwO,EAAMxO,SAAU2O,EAAYH,EAAMG,UAAWc,EAAcjB,EAAMiB,YAGrE1P,EADM,IAAbC,GAAkB2O,EAAYc,EACNpP,GAAQsO,EAAWc,GAEvBzP,IgCehBsL,KAAM0E,GAAYtP,IACnB6N,GAAkC7N,KhCtBtC,IAA4C8N,EAC3CxO,EAA2B2O,EAA6Bc,EgCuChE,SAAS2d,GAAiC5e,GAItC,M9BpFmC,mBAArB0f,kB8BiFmB1f,aAAiB0f,kBAC9C1f,EAAMhX,SAEHgX,EN9FJ,SAAS2f,GAAiB7zB,GAoB7B,YAnBgB,IAAZA,IAAsBA,EAAUlB,QAC/B8vB,KACgC,WAA7B5tB,SAAS2Q,gBACTid,GAA4B,CACxB1pB,UAAW,IAIf0pB,GAA4B,CACxB1pB,UAAWsc,EAAAA,GAEdqN,GAAgB1uB,EAAkBH,EAAS,CAAC,WAA4B,qBAA6C,SAAUC,GACzG,aAAfA,EAAMmD,MAAoD,WAA7BpC,SAAS2Q,kBACtCid,GAA0B1pB,UAAYjF,EAAMiF,UAC5C2pB,QAEL,CAAEtuB,SAAS,IAAQI,OAGvBiuB,GOnBJ,IAAIkF,GAAuB,IAC3B,SAASC,GAAwBvc,EAAWzW,GAC/C,IAAIizB,EAAU,GACd,SAASC,EAAWC,GAChB,EAAOF,EAASE,GAChBnzB,EAASizB,GAEb,IAAIG,EAyBD,SAAgC3c,EAAWzW,GAc9C,MAAO,CAAEJ,KAbE6W,EAAUxT,UAAU,GAAuC,SAAUiU,GAC5E,IAAK,IAAItd,EAAK,EAAGu4B,EAAYjb,EAAStd,EAAKu4B,EAAUr4B,OAAQF,IAAM,CAC/D,IAAIuZ,EAAQgf,EAAUv4B,GACE,eAApBuZ,EAAMkD,WACNrW,EAAS,CACLqzB,YAAalgB,EAAMkgB,YACnBC,iBAAkBngB,EAAMogB,yBACxBC,eAAgBrgB,EAAMqgB,eACtBC,UAAWtgB,EAAMqF,mBAI9BnV,aAtC0BqwB,CAAuBjd,EAAWyc,GAAYtzB,KACvE+zB,EAwCD,SAAyCld,EAAWzW,GACvD,IAAI4zB,EAAcd,KAYlB,MAAO,CAAElzB,KAXE6W,EAAUxT,UAAU,GAAuC,SAAUiU,GAC5E,IAAI2c,EAAWn3B,EAAKwa,GAAS,SAAU/D,GACnC,MAA2B,UAApBA,EAAMkD,WACM,2BAAflD,EAAMza,MACNya,EAAMG,UAAYsgB,EAAYzvB,WAC9BgP,EAAMG,UAAYyf,MAEtBc,GAhDGX,EAAW,CAAEY,qBAiDPD,EAASvgB,eAEvBjQ,aApDmB0wB,CAAgCtd,GAEnD7W,KACCo0B,EA0DD,SAA2Cvd,EAAWxX,EAASe,GAClE,IAAI4zB,EAAcd,KAIdmB,EAA4BxT,EAAAA,EAC5ByT,EAAoB90B,EAAkBH,EAAS,CAAC,cAAkC,YAA2B,SAAUC,GACvH+0B,EAA4B/0B,EAAMiF,YACnC,CAAE3E,SAAS,EAAMD,MAAM,IAAQK,KAC9Bu0B,EAAuB1d,EAAUxT,UAAU,GAAuC,SAAUiU,GAC5F,IAAIkd,EpD6DL,SAAkBz3B,EAAOC,GAC5B,IAAK,IAAIC,EAAIF,EAAM7C,OAAS,EAAG+C,GAAK,EAAGA,GAAK,EAAG,CAC3C,IAAIC,EAAOH,EAAME,GACjB,GoD/D+B,8BADYsW,EpDgE7BrW,GoD/DGuZ,WACTlD,EAAMG,UAAY2gB,GAClB9gB,EAAMG,UAAYsgB,EAAYzvB,WAC9BgP,EAAMG,UAAYyf,GpD6DtB,OAAOj2B,EoDjEsB,IAAUqW,EAA5BkhB,CAASnd,GAMpBkd,GAzEJlB,EAAW,CACPoB,uBAyESF,EAAS9gB,eAEvBjQ,YACH,MAAO,CACHzD,KAAM,WACFs0B,IACAC,MAjFcI,CAAkC9d,EAAW1Y,QAIhE6B,KACC40B,EAwFD,SAAgC/d,EAAWzW,GAC9C,IAAI4zB,EAAcd,KAelB,MAAO,CACHlzB,KAfO6W,EAAUxT,UAAU,GAAuC,SAAUiU,GAC5E,IAAIud,EAAkB/3B,EAAKwa,GAAS,SAAU/D,GAC1C,MAA2B,gBAApBA,EAAMkD,WAA+BlD,EAAMG,UAAYsgB,EAAYzvB,aAE9E,GAAIswB,EAAiB,CACjB,IAAIC,EAAkB1vB,GAAQyvB,EAAgBnhB,UAAWmhB,EAAgBzc,kBA/FzB,SAAUzb,GAE9D22B,EAAW,CACPwB,gBAFkBn4B,EAAGm4B,gBAGrBC,eAHuDp4B,EAAGo4B,iBA+F1D30B,CAAS,CAGL00B,gBAAiBA,GAAmB,EAAIA,EAAkB,EAC1DC,eAAgBF,EAAgBnhB,gBAGzCjQ,aAvGmBuxB,CAAuBne,GAM1C7W,KACH,MAAO,CACHA,KAAM,WACFwzB,IACAO,IACAK,IACAQ,MC5BL,SAASK,GAAiBpe,EAAW6Q,EAAuBwN,EAAoBC,EAAaC,GAChG,IAgBIC,EAhBAC,EAAc,CACdlO,YAAa,CACTC,WAAY,EACZC,cAAe,EACfC,cAAe,EACfC,gBAAiB,IAGrB+N,EAA0BpO,GAAiBtQ,GAAW,SAAU2e,GAChEF,EAAYlO,YAAcoO,EAC1BN,OACDl1B,KACCrD,EAyBR,SAA0Bka,EAAW6Q,EAAuB+N,EAAUL,EAAWh1B,GAC7E,IAAIs1B,EAAqC,iBAAbD,EACxBE,GAAkC,EAClCC,EAAwB,GAC5B,SAASC,IA7B2E,IAAUC,GA8BrFH,IAAoCD,GAAyBE,EAAsB17B,OAAS,IA9BP47B,EA+B7E16B,KAAKijB,IAAIlkB,MAAMiB,KAAMw6B,GA9BlCN,EAAYS,YAAcD,EAC1BZ,KAyCJ,MAAO,CACHl1B,KAVOynB,GAAa5Q,EAAW6Q,GAAuB,SAAUpoB,GAC5Dq2B,IACAA,GAAkC,EAC9Br2B,EAAMmpB,aACNmN,EAAsBh9B,KAAKwM,GAAQgwB,EAAU7wB,UAAWjF,EAAMgG,MAElEuwB,QAEL71B,KAGCg2B,aAAc,SAAUnC,GAChB6B,IACAA,GAAwB,EACxBE,EAAsBh9B,KAAKi7B,GAC3BgC,OAjDHI,CAAiBpf,EAAW6Q,EAAuByN,EAAaC,GAGrEc,EAA0Bv5B,EAAGqD,KAAMg2B,EAAer5B,EAAGq5B,aAYzD,OAoGOxf,GAA8B,iBA7GjC8e,EAAYa,sBAAwB,EACnCd,EAgET,SAAoCxe,EAAWzW,GAC3C,IAAIg2B,EAAc,EACdj4B,EAiBR,WACI,IACIuV,EACAyN,EAFAloB,EAAQ,EAGZ,MAAO,CACHo9B,OAAQ,SAAU9iB,QAC4Bpb,IAAdub,GACxBH,EAAMG,UAAYyN,GAAWjoB,GAC7Bqa,EAAMG,UAAYA,GAAa,KAE/BA,EAAYyN,EAAU5N,EAAMG,UAC5Bza,EAAQsa,EAAMta,QAGdA,GAASsa,EAAMta,MACfkoB,EAAU5N,EAAMG,YAGxBza,MAAO,WAAc,OAAOA,IAnCnBq9B,GAab,MAAO,CACHt2B,KAbO6W,EAAUxT,UAAU,GAAuC,SAAUiU,GAC5E,IAAK,IAAItd,EAAK,EAAGu4B,EAAYjb,EAAStd,EAAKu4B,EAAUr4B,OAAQF,IAAM,CAC/D,IAAIuZ,EAAQgf,EAAUv4B,GACE,iBAApBuZ,EAAMkD,WAAiClD,EAAMgjB,iBAC7Cp4B,EAAOk4B,OAAO9iB,GACVpV,EAAOlF,QAAUm9B,IACjBA,EAAcj4B,EAAOlF,QAzEkCk9B,EA0E9Cx6B,EAAMy6B,EAAa,GAzEpCd,EAAYa,sBAAwBA,EACpCjB,MAFqD,IAAUiB,KA8EpE1yB,aA9EoB+yB,CAA2B3f,GAG3C7W,MAGHq1B,EAAkBt5B,EAEf,CACHiE,KAAM,WACFu1B,IACAW,IACAb,KAEJW,aAAcA,EACdV,YAAaA,GCyCrB,SAASmB,GAAQ5f,EAAW6Q,EAAuBgP,EAAiBvB,EAAa9b,EAAasd,QACtE,IAAhBtd,IAA0BA,EAAcnU,KAE5C,IAII0xB,EAEA99B,EACAyT,EACAU,EARAqP,EAAKrhB,IACLo4B,EAAU,GACVwD,EAAgB,GAChBC,EAAkB,EAElBhvB,EAAW/M,EAAa27B,GAIxBC,IACA79B,EAAO69B,EAAY79B,KACnByT,EAAUoqB,EAAYpqB,QACtBU,EAAU0pB,EAAY1pB,SAE1B4J,EAAUjT,OAAO,EAAsB,CAAE0Y,GAAIA,EAAIxjB,KAAMA,EAAMugB,YAAaA,EAAa9M,QAASA,EAASU,QAASA,IAElH,IAAItQ,EAAKxD,EAAS4G,GAAQg3B,GAhGW,IAgGsC,CACvEr9B,SAAS,IACTw7B,EAAqBv4B,EAAG7C,UAAWk9B,EAA2Br6B,EAAGtC,OACjEqF,EAAKu1B,GAAiBpe,EAAW6Q,EAAuBwN,EAAoBC,EAAa9b,GAAc2c,EAAet2B,EAAGs2B,aAAciB,EAA0Bv3B,EAAGM,KAAMs1B,EAAc51B,EAAG41B,YAG/L,SAASyB,IACLD,GAAmB,EACnB,IAAII,OAA2B/+B,IAAdy+B,EAA0B5xB,IAAiB4xB,EAAUryB,UACtEsS,EAAUjT,OAAO,EAAsB,EAAO,CAC1CizB,cAAeA,EACfC,gBAAiBA,EACjBxa,GAAIA,EACJxjB,KAAMA,EACNyT,QAASA,EACTU,QAASA,EACTkoB,YAAaA,EACbrtB,SAAUA,EACVuR,YAAaA,EACbga,QAASA,EACTtuB,SAAUK,GAAQiU,EAAY9U,UAAW2yB,GACzCC,cAAwBh/B,IAAdy+B,GACXtB,IAEP,OAnBAyB,IAmBO,CACHj+B,KAAMA,EACNyT,QAASA,EACTU,QAASA,EACTmqB,eAAgBlC,EAChB5vB,IAAK,SAAU+xB,QACI,IAAXA,IAAqBA,EAASnyB,KAClC0xB,EAAYS,EACZJ,IACApgB,EAAUjT,OAAO,EAAoB,CAAEgzB,UAAWA,KAEtDU,cAAe,WAEXN,IACAD,KAEJQ,cAAe,SAAUhE,GACrBF,EAAUE,OACmBp7B,IAAzBo7B,EAAWM,WACXmC,EAAazC,EAAWM,YAGhC2D,UAAW,SAAU1+B,EAAM2+B,GACvB,IAAIjzB,EnD9FT,SAA+BizB,GAClC,OAAOA,EHhDW,QsD6ISC,CAAsBD,GAAQA,EAAOryB,GAAQiU,EAAY9U,UAAWkzB,GACvFZ,EAOZ,SAAwB/9B,GACpB,IAAI6+B,EAAY7+B,EAAK0C,QAAQ,qBAAsB,KAInD,OAHIm8B,IAAc7+B,GACdrC,EAAQI,KAAK,wBAAwB0E,OAAOzC,EAAM,oBAAoByC,OAAOo8B,IAE1EA,EAZeC,CAAe9+B,IAAS0L,IAuBlD,SAASqzB,GAAgBC,GACrB,IAAI1W,EAAQ0W,EAAKjgC,QAAQ,KACzB,OAAOupB,EAAQ,EAAI0W,EAAOA,EAAK34B,MAAM,EAAGiiB,GC1KrC,SAAS2W,GAAoBlhB,EAAW9J,EAAejF,EAAU4f,EAAuBsQ,EAA0BnL,EAAoBoL,EAAaC,GAItJ,OAHArhB,EAAUxT,UAAU,GAAsB,SAAUiqB,GAChD,OAAOzW,EAAUjT,OAAO,GAIhC,SAA2B0pB,EAAMT,EAAoBoL,GACjD,IAoD6BlzB,EApDzBozB,EAAcF,EAAYG,eAAe9K,EAAKhR,IAC9C+b,EAAY,CACZtc,IAAK,CACDuc,iBAAkBhL,EAAKwJ,gBACvByB,aAAcJ,GAElB9vB,KAAMilB,EAAKjU,YAAY9U,UACvB9B,KAAM,OACN6qB,KAAM,CACF1Q,OAAQ,CACJoQ,MAAOM,EAAKlG,YAAYI,iBAE5BgR,wBAAyBlL,EAAK6I,sBAC9BsC,aAAc3zB,EAAiBwoB,EAAK+F,QAAQI,aAC5CiF,mBAAoB5zB,EAAiBwoB,EAAK+F,QAAQK,kBAClDiF,gBAAiB7zB,EAAiBwoB,EAAK+F,QAAQO,gBAC/C98B,MAAO,CACHk2B,MAAOM,EAAKlG,YAAYC,YAE5BuR,uBAAwB9zB,EAAiBwoB,EAAK+F,QAAQa,sBACtD2E,kBAAmB/zB,EAAiBwoB,EAAK+F,QAAQyB,iBACjDgE,iBAAkBh0B,EAAiBwoB,EAAK+F,QAAQ0B,gBAChDgE,UAAWzL,EAAK6J,SAChBr+B,KAAMw0B,EAAKx0B,KACXkgC,yBAA0Bl0B,EAAiBwoB,EAAK+F,QAAQqB,wBACxDuE,WAAYn0B,EAAiBwoB,EAAK+F,QAAQQ,WAC1C5G,cA0BqBloB,EA1BiBD,EAAiBwoB,EAAKyI,aA2B7D34B,EAAS2H,IAAaA,EAAW,OAAI5M,EAAY4M,GA1BhDm0B,aAAc5L,EAAK6H,YACnBjI,UAAW,CACPF,MAAOM,EAAKlG,YAAYE,eAE5B6F,SAAU,CACNH,MAAOM,EAAKlG,YAAYG,eAE5B4R,WAAYr0B,EAAiBwoB,EAAKvoB,UAClCq0B,sBAAuBvM,EAAmB7O,6BAA6BsP,EAAKjU,YAAY/U,SAAUgpB,EAAKvoB,WAE3G4W,QAAS,CACLkB,aAAYsb,QAAqBhgC,IAMzC,OAHKsF,EAAc6vB,EAAKuJ,iBACpBwB,EAAU/K,KAAK+L,evDwHhB,SAAmBr+B,EAAQ5B,GAE9B,IADA,IAAIkgC,EAAY,GACPt/B,EAAK,EAAG2C,EAAKhC,OAAO2C,KAAKtC,GAAShB,EAAK2C,EAAGzC,OAAQF,IAAM,CAC7D,IAAIU,EAAMiC,EAAG3C,GACbs/B,EAAU5+B,GAAOtB,EAAG4B,EAAON,IAE/B,OAAO4+B,EuD9H6BC,CAAUjM,EAAKuJ,cAAe/xB,IAE3D,CACHqW,YAAakd,EACb3kB,UAAW4Z,EAAKjU,YAAY/U,SAC5B8W,cAAe,CACXtT,SAAUwlB,EAAKxlB,WArDuC0xB,CAAkBlM,EAAMT,EAAoBoL,ODCvG,SAAoBnwB,EAAU+O,EAAW6Q,EAAuBsQ,EAA0ByB,EAA8BvB,GAC3H,IAGIwB,EAIsBpgC,EAClBqgC,EACA35B,EATJrD,GAOsBrD,EAPA4+B,EAQlByB,EAAclD,GAAQ5f,EAAW6Q,EAAuB5f,EAAU,eAAmC3C,IAAgB7L,GACrH0G,EAAOozB,GAAwBvc,GAAW,SAAUwc,GACpDsG,EAAYpC,cAAclE,GAC1BsG,EAAYvC,oBACbp3B,KACI,CAAE25B,YAAaA,EAAa35B,KAAMA,IAbE45B,EAA0Bj9B,EAAGqD,KACxE65B,EAD4Fl9B,EAAGg9B,YAE/FG,EAgBJ,WACIjjB,EAAUxT,UAAU,GAAyB,WAEzCw2B,EAAYv0B,MAEZu0B,EAAcE,OAAgB5hC,EAAW,CACrCW,KAAM+gC,EAAY/gC,KAClByT,QAASstB,EAAYttB,QACrBU,QAAS4sB,EAAY5sB,aAI7B4J,EAAUxT,UAAU,GAAuB,WACvCw2B,EAAYv0B,MACZu0B,EAAYvC,mBAGhB,IAAI0C,EAAoB77B,OAAO6iB,YAAYjhB,IAAQ,WAC/C85B,EAAYvC,mBAtCiB,KAwCjC,MAAO,CACHt3B,KAAM,WACF0hB,cAAcsY,KAtCFC,GAAqBj6B,KAa7C,SAAS+5B,EAAgB1gB,EAAasd,GAClC,OAAOF,GAAQ5f,EAAW6Q,EAAuB5f,EAAU,eAAmCuR,EAAasd,GAuC/G,OAnDI8C,IACAC,EAuCJ,SAAmC1B,GAC/B,OAAOA,EAAyB30B,WAAU,SAAU1G,GAChD,IA6GkBu9B,EAAiBC,EAMvCC,EAnHQC,EAAc19B,EAAG09B,YACrB,GA4GmCF,EA7Gax9B,EAAG29B,aA6GjCJ,EA5GOG,GA6GT3H,WAAayH,EAAczH,WAK/C0H,EAJiBD,EAAcrC,KAIRyC,OAAO,IACzBl6B,SAASiqB,eAAe8P,IAJzBvC,GAAgBsC,EAAcrC,QAAUD,GAAgBqC,EAAgBpC,OA3GpE,OAHA+B,EAAYv0B,MACZu0B,EAAYvC,qBACZuC,EAAcE,QA7COS,CAA0BxC,IAkDpD,CACHR,UAAW,SAAU1+B,EAAM2+B,QACV,IAATA,IAAmBA,EAAOzyB,KAC9B60B,EAAYrC,UAAU1+B,EAAM2+B,GAC5BoC,EAAYzC,kBAEhBqD,UAAW,SAAUnhC,EAAS+f,GAC1BwgB,EAAYv0B,IAAI+T,GAChBwgB,EAAYvC,gBACZuC,EAAcE,EAAgB1gB,EAAa/f,IAE/C0G,KAAM,WACF05B,MAAAA,GAAwFA,EAA2Bj2B,cACnHm2B,IACAE,IACAD,EAAYv0B,QCtEbo1B,CAAW5yB,EAAU+O,EAAW6Q,EAAuBsQ,GAA2BjrB,EAAc4tB,mBAAoBzC,GCAxH,IAEH0C,GAAgB,GACb,SAASC,GAAoBvhC,EAASwhC,EAAYC,ICGlD,SAAgCzhC,GACnC,IAAImnB,EAAgB3X,GAAUgW,IAC1Bkc,EAAelyB,GAZc,OAa7BmyB,EAAanyB,GAZY,SAazBoyB,EAAcpyB,GAZY,SAa9B,IAAK2X,EAAe,CAChB,IAAI9E,EAAU,GACVqf,IACArf,EAAQW,GAAK0e,GAEbE,GAAe,SAAShzB,KAAKgzB,KAC7Bvf,EAAwB,KAAIuf,GAE5BD,GAAc,UAAU/yB,KAAK+yB,KAC7Btf,EAAuB,IAAIsf,GAE/Brb,GAAejE,EAASriB,IDlB5B6hC,CAAuB7hC,GACvB,IAAI8hC,E1BED,SAA2B9hC,EAASwhC,EAAYC,GACnD,IA6EQpf,EA7EJ0f,EAAkB,IAAIn4B,EACtBo4B,EAAmB,IAAIp4B,EACvBq4B,EAAwBva,YAAYjhB,IA8BxC,WACIif,GAAqB,CACjB1lB,QAASA,EACTgX,QAAS,SAAUkrB,GAAiB,OAASC,EAAgBD,QAAsBrjC,EAAL,IAC9E2nB,MAAO4b,OtBhDcxiC,KsBezByiC,EA2EIF,EADA9f,EAAU2D,MAEH3D,EAEJ,GA1CX,SAAS+f,EAAmBF,GAYxB,OAXKC,EAAgBD,KACjBA,EAAgB,IAEhBI,MAsBR,SAAkCJ,GAC9B,OAAOG,EAAarf,KAAOkf,EAAclf,IAAMqf,EAAab,KAAgBU,EAAcV,GAtBlFe,CAAyBL,IAyBjCG,EAAe,GACfL,EAAiB13B,UAtBT+3B,EAAeH,GAGhBA,EAWX,SAASI,IACL,YAAoCzjC,IAA7BwjC,EAAab,GAoBxB,SAASW,EAAgB9f,GAGrB,YAA6BxjB,IAApBwjB,EAAQmgB,SAAyB36B,KAAKuD,MAAQyR,OAAOwF,EAAQmgB,SA9F1C,cA+FJ3jC,IAAnBwjB,EAAQ0E,QAAwBlf,KAAKuD,MAAQyR,OAAOwF,EAAQ0E,SAErE,MAAO,CACH0b,qBAAsB,EAAeh8B,IAtFzC,WACI,IAAIi8B,EACJhd,GAAqB,CACjB1lB,QAASA,EACTgX,QAAS,SAAUkrB,GACf,IAAIS,EAAsBP,EAAmBF,GAE7C,OADAQ,EA2CZ,SAA6BR,GACzB,IAAI7+B,EAAKo+B,EAAoBS,EAAcV,IAAcoB,EAAev/B,EAAGu/B,aAAcF,EAAYr/B,EAAGq/B,UAMxG,OALAR,EAAcV,GAAcoB,EACxBF,IAAcR,EAAclf,KAC5Bkf,EAAclf,GAAK,IACnBkf,EAAcM,QAAUxb,OAAOnf,KAAKuD,QAEjCs3B,EAlDaG,CAAoBF,GACzBA,GAEXnc,MAAO,SAAU0b,GACTQ,IAAcJ,KA0D9B,SAAsBJ,GAClBG,EAAeH,EACfH,EAAgBz3B,SA3DJw4B,CAAaZ,GAEjBG,EAAeH,QtB7BEtiC,KsBsGgEY,UACzFuiC,cAtEJ,WACIrd,GAAqB,CACjB1lB,QAASA,EACTgX,QAAS,SAAUkrB,GAAiB,OAAQI,IAAsBF,EAAmBF,QAAiBrjC,MAoE1GmkC,WAAY,WAAc,OAAOX,GACjCN,gBAAiBA,EACjBC,iBAAkBA,EAClBt7B,KAAM,WACF0hB,cAAc6Z,K0BnGHgB,CAAkBjjC,EAASwhC,EAAYC,GAC1DH,GAAchiC,MAAK,WAAc,OAAOwiC,EAAap7B,UACrD,IA6BIA,EA7BAw8B,EAAwB,IAAI1b,GANA2b,OAkBhC,SAASC,IACL,MAAO,CACHpgB,GAAI8e,EAAakB,aAAahgB,GAC9B4f,aAAcd,EAAakB,aAAaxB,IAGhD,OAjBAF,GAAchiC,MAAK,WAAc,OAAO4jC,EAAsBx8B,UAC9Do7B,EAAaC,gBAAgBh4B,WAAU,WACnCm5B,EAAsBv7B,IAAIy7B,IAAuBz3B,QAErDm2B,EAAaE,iBAAiBj4B,WAAU,WACpCm5B,EAAsBlb,YAAYrc,QAEtCm2B,EAAaW,uBACbS,EAAsBv7B,IAAIy7B,IAAuBv3B,IAAeb,UAoB5DtE,EAAO,EAAwB7B,OAAQ,CAAC,QAAqB,aAAgC,UAA0B,WAnB7G,WAAc,OAAOi9B,EAAaW,yBAmByH,CAAEn8B,SAAS,EAAMC,SAAS,IAAQG,KAC3M46B,GAAchiC,KAAKoH,GAEvB,SAAyBq8B,GACrB,IAAIM,EAA2B58B,IAAQ,WACF,YAA7BM,SAAS2Q,iBAvBoBoqB,EAAaiB,mBA2B9Cr8B,EAAO,EAAuBK,SAAU,mBAA4Cs8B,GAA0B38B,KAClH46B,GAAchiC,KAAKoH,GACnB,IAAI48B,EAA0B5b,YAAY2b,EA/CV,KAgDhC/B,GAAchiC,MAAK,WACf8oB,cAAckb,MA/BlBC,GAOO,CACHC,kBAAmB,SAAUppB,GAAa,OAAO8oB,EAAsB1/B,KAAK4W,IAC5E2nB,gBAAiBD,EAAaC,gBAC9BC,iBAAkBF,EAAaE,kBE8BvC,SAASyB,GAAcC,GACnB,MAA0B,MAAnBA,GAAgE,MAAnBA,EChEjD,ICAIC,GAAmB,CAC1BC,OAAQ,SACRC,OAAQ,SACRzxB,MAAOD,GAAoBC,MAC3BC,KAAMF,GAAoBE,KAC1BC,gBAAiBH,GAAoBG,iBAE9BwxB,GAAoB,kBAKpBC,GAA4B,SAO5BC,GAAuB,MAEvBC,GAAyB,CAChCC,OAAO,EACPC,QAAQ,EACRC,UAAU,EACVC,QAAQ,EACRC,QAAQ,EACRC,UAAU,EACVC,UAAU,GCnBP,SAASC,GAAoBnoB,EAAMooB,GACtC,IAAIC,EAAyBroB,EAAKsoB,WAC5BH,GAAoBnoB,EAAKsoB,WAAYF,GACrCA,EAEN,OAAOG,GADoBC,GAAwBxoB,GACHqoB,GAK7C,SAASE,GAAmBE,EAAmBJ,GAClD,OAAQA,GAEJ,KAAKhB,GAAiBE,OACtB,KAAKF,GAAiBC,OAClB,OAAOe,EAEf,OAAQI,GACJ,KAAKpB,GAAiBvxB,MACtB,KAAKuxB,GAAiBtxB,KACtB,KAAKsxB,GAAiBrxB,gBACtB,KAAKqxB,GAAiBE,OACtB,KAAKF,GAAiBC,OAClB,OAAOmB,EACX,QACI,OAAOJ,GAMZ,SAASG,GAAwBxoB,GAEpC,GA+DJ,SAAmBA,GACf,OAAOA,EAAK0oB,WAAa1oB,EAAK2oB,aAhEzBC,CAAU5oB,GAAf,CAGA,IAAI6oB,EAAW7oB,EAAK8T,aAAa0T,IAEjC,GAAqB,SAAjBxnB,EAAK8oB,QACL,OAAOzB,GAAiBvxB,MAG5B,GAAqB,UAAjBkK,EAAK8oB,QAAqB,CAC1B,IAAIC,EAAe/oB,EACnB,GAA0B,aAAtB+oB,EAAal8B,MAA6C,UAAtBk8B,EAAal8B,MAA0C,QAAtBk8B,EAAal8B,KAClF,OAAOw6B,GAAiBtxB,KAE5B,GAA0B,WAAtBgzB,EAAal8B,KACb,OAAOw6B,GAAiBtxB,KAE5B,IAAIizB,EAAeD,EAAajV,aAAa,gBAE7C,GAAIkV,GAAgD,IAAhCA,EAAa/mC,QAAQ,OACrC,OAAOolC,GAAiBtxB,KAIhC,OAAI8yB,IAAapB,IAA6BznB,EAAKipB,UAAUC,SDjD/B,qBCkDnB7B,GAAiBE,ODzDK,SC2D7BsB,GAAwC7oB,EAAKipB,UAAUC,SDtD/B,mBCuDjB7B,GAAiBtxB,KD3DgB,oBC6DxC8yB,GAAmD7oB,EAAKipB,UAAUC,SDxD/B,8BCyD5B7B,GAAiBrxB,gBDhEM,UCkE9B6yB,GAAyC7oB,EAAKipB,UAAUC,SD7D/B,oBC8DlB7B,GAAiBvxB,MCqDzB,SAA6BrN,GAChC,GAAyB,WAArBA,EAAQ+X,SACR,OAAO,EAEX,GAAyB,SAArB/X,EAAQ+X,SAER,MAEkB,aAHd2oB,EAAeC,EAAsB,SAGsB,WAAhCA,EAAsB,OAEhC,kBAAjBD,GACiB,SAAjBA,EAER,GAAyB,SAArB1gC,EAAQ+X,SAAqB,CAC7B,IAAI6oB,EAAgBD,EAAsB,QACtCD,EAAeC,EAAsB,OACrCE,EAAoBF,EAAsB,YAC9C,MAEA,oCAAoC92B,KAAK+2B,IACnB,qBAAlBA,GACiB,SAAjBF,GACiB,qBAAjBA,GACiB,kBAAjBA,GAEkB,aAAlBE,GACkB,gBAAlBA,GAEA,oBAAoB/2B,KAAKg3B,IACzB,iBAAiBh3B,KAAK+2B,IACJ,cAAlBA,GAEkB,WAAlBA,GACkB,cAAlBA,GACkB,YAAlBA,GAGA5gC,EAAQirB,aAAa,eAEH,WAAlB2V,GACkB,cAAlBA,GACkB,cAAlBA,GACkB,cAAlBA,GACkB,WAAlBA,GACA,YAAY/2B,KAAKg3B,IACjB,YAAYh3B,KAAKg3B,IAEC,6BAAlBD,GACkB,wBAAlBA,GACkB,eAAlBA,GACkB,oBAAlBA,GACkB,cAAlBA,GACkB,iBAAlBA,GACkB,+BAAlBA,EAER,SAASD,EAAsBlmC,GAC3B,OAAQuF,EAAQqrB,aAAa5wB,IAAS,IAAIqmC,cAE9C,OAAO,ED7GHC,CAAoBxpB,GACbqnB,GAAiBC,YAD5B,GAeG,SAASmC,GAAezpB,EAAM0pB,GACjC,OAAQA,GACJ,KAAKrC,GAAiBtxB,KACtB,KAAKsxB,GAAiBE,OACtB,KAAKF,GAAiBC,OAClB,OAAO,EACX,KAAKD,GAAiBrxB,gBAClB,OAQZ,SAAoBgK,GAChB,OAAOA,EAAK0oB,WAAa1oB,EAAK2pB,UATf,CAAW3pB,GAAQ4pB,GAAc5pB,EAAKsoB,YAAcsB,GAAc5pB,GAC7E,QACI,OAAO,GASnB,SAAS4pB,GAAc5pB,GACnB,IAAKA,GAAQA,EAAK0oB,WAAa1oB,EAAK2oB,aAChC,OAAO,EAEX,IAAIlgC,EAAUuX,EACd,GAAwB,UAApBvX,EAAQqgC,QACR,OAAQrgC,EAAQoE,MACZ,IAAK,SACL,IAAK,QACL,IAAK,QACL,IAAK,SACD,OAAO,EAGnB,QAAS86B,GAAuBl/B,EAAQqgC,SAOrC,SAASe,GAAeC,EAAUC,EAAkB1B,GACvD,IAAIthC,EAGAijC,EAAkD,QAAjCjjC,EAAK+iC,EAASnW,qBAAkC,IAAP5sB,OAAgB,EAASA,EAAG+hC,QACtFjT,EAAciU,EAASjU,aAAe,GAC1C,IAAIkU,GAAqBlU,EAAY9B,OAArC,CAGA,IACIkW,EAA4B,UAAlBD,QAAmCznC,EAEjD,GADiC,WAAlBynC,EAGXnU,EAAc6R,QAEb,GAPkBW,IAOOhB,GAAiBE,OAE3C1R,EAAc6R,QAEb,GAAI+B,GAAeK,EAXDzB,KAalB4B,EACD,GAEkB,aAAlBD,GACsB,WAAlBA,GACkB,aAAlBA,GACA,IAAKnU,EAAY9B,OACb,YAKJ8B,EAFuB,WAAlBmU,EAEStC,GAGW7R,EAtCiBjwB,QAAQ,MAjItC,KA0KpB,OAAOiwB,GE3KX,IAAIqU,GAAoB,IAAIpd,QACrB,SAASqd,GAAkBnqB,GAC9B,OAAOkqB,GAAkB9+B,IAAI4U,GAY1B,SAASoqB,GAAoBpqB,GAChC,OAAOkqB,GAAkBjiC,IAAI+X,GAU1B,SAASqqB,GAAqB5hC,EAAS6hC,GAO1C,IAAIxB,EAAUrgC,EAAQqgC,QAClBzlC,EAAQoF,EAAQpF,MACpB,GAAIomC,GAAehhC,EAAS6hC,GAAmB,CAC3C,IAAIz9B,EAAOpE,EAAQoE,KACnB,GAAgB,UAAZi8B,IAAiC,WAATj8B,GAA8B,WAATA,GAA8B,UAATA,GAGlE,OAAOxJ,EAEN,IAAKA,GAAqB,WAAZylC,EAEf,OAEJ,OAAOpB,GAEX,MAAgB,WAAZoB,GAAoC,WAAZA,EACjBrgC,EAAQpF,MAEH,UAAZylC,GAAmC,aAAZA,EAGpBzlC,OAHP,ECpDG,SAASknC,GAAa7gC,GACzB,OAAOwP,QAAQxP,EAAM8gC,gBAElB,SAAS9oC,GAAQ8zB,EAAMhrB,GAC1BI,MAAM5F,UAAUtD,QAAQwD,KAAKswB,EAAMhrB,GFChC,SAASigC,GAAkBhgC,EAAU29B,GAExC,OAAOsC,GAAoBjgC,EAAU,CACjCA,SAAUA,EACV49B,uBAAwBD,IAGzB,SAASsC,GAAoB1qB,EAAMtc,GACtC,IAAIinC,EAcR,SAAuB3qB,EAAMtc,GACzB,OAAQsc,EAAK0oB,UACT,KAAK1oB,EAAK4qB,cACN,OAWL,SAA+BngC,EAAU/G,GAC5C,MAAO,CACHmJ,KAAM,EACNiT,WAAY+qB,GAAoBpgC,EAAU/G,IAd/BonC,CAAsB9qB,EAAMtc,GACvC,KAAKsc,EAAK+qB,mBACN,MAgBD,CACHl+B,KAAM,EACN3J,MAH2B8nC,EAfUhrB,GAkBlB9c,KACnB+nC,SAAUD,EAAaC,SACvBC,SAAUF,EAAaE,UAnBvB,KAAKlrB,EAAK2oB,aACN,OAsCL,SAA8BlgC,EAAS/E,GAC1C,IAAIqD,EA8NcokC,EA7NdrC,EAAUsC,GAAgB3iC,EAAQqgC,SAClCuC,EA6NkB,SADJF,EA5NO1iC,GA6NfqgC,SAAqBqC,aAAcG,iBA7NR/oC,EAGjC+nC,EAAmB/B,GAAmBC,GAAwB//B,GAAU/E,EAAQ2kC,wBACpF,GAAIiC,IAAqBjD,GAAiBE,OAAQ,CAC9C,IAAIz9B,EAAKrB,EAAQ8iC,wBAAyBC,EAAQ1hC,EAAG0hC,MAAOC,EAAS3hC,EAAG2hC,OACxE,MAAO,CACH5+B,KAAM,EACNi8B,QAASA,EACT4C,YAAa3kC,EAAK,CACV4kC,SAAU,GAAGhmC,OAAO6lC,EAAO,MAC3BI,UAAW,GAAGjmC,OAAO8lC,EAAQ,OAEjC1kC,EAAGygC,IAAqBC,GACxB1gC,GACJ+Y,WAAY,GACZurB,MAAOA,GAIf,GAAIf,IAAqBjD,GAAiBC,OAA1C,CAGA,IAAIoE,EAwMR,SAAsCjjC,EAAS6hC,GAC3C,GAAIA,IAAqBjD,GAAiBE,OACtC,MAAO,GAKX,IAHA,IAAIsE,EAAY,GACZ/C,EAAUsC,GAAgB3iC,EAAQqgC,SAClCp1B,EAAMjL,EAAQ8rB,cACTltB,EAAI,EAAGA,EAAIoB,EAAQijC,WAAWpnC,OAAQ+C,GAAK,EAAG,CACnD,IACIykC,EADYrjC,EAAQijC,WAAWpkC,KAAKD,GACVnE,KAC1B6oC,EAAiBC,GAAmBvjC,EAAS6hC,EAAkBwB,GAC5C,OAAnBC,IACAF,EAAUC,GAAiBC,GAGnC,GAAItjC,EAAQpF,QACK,aAAZylC,GAAsC,WAAZA,GAAoC,WAAZA,GAAoC,UAAZA,GAAsB,CACjG,IAAImD,EAAY5B,GAAqB5hC,EAAS6hC,QAC5B/nC,IAAd0pC,IACAJ,EAAUxoC,MAAQ4oC,GAM1B,GAAgB,WAAZnD,GAAwBwB,IAAqBjD,GAAiBvxB,MAAO,CAErE,IAAIo2B,EAAgBzjC,EAChByjC,EAAcC,WACdN,EAAUM,SAAWD,EAAcC,UAI3C,GAAgB,SAAZrD,EAAoB,CACpB,IAAIsD,EAAaxhC,MAAMyhC,KAAK34B,EAAI44B,aAAaplC,MAAK,SAAUorB,GAAK,OAAOA,EAAEhf,OAAS7K,EAAQ6K,SACvFi5B,EAAUC,GAAkBJ,KACjBA,WACJP,EAAUY,WACVZ,EAAUv4B,KACjBu4B,EAAUa,SAAWH,GAQzB,IAAIA,EAJQ,UAAZzD,GACArgC,EAAQkkC,SAENlkC,EAAQ4sB,WAAa5sB,EAAQotB,aAAe,IAAI9B,OAAOzvB,UACrDioC,EAAUC,GAAkB/jC,EAAQkkC,UAEpCd,EAAUa,SAAWH,IAW7B,IAAIxD,EAAetgC,EAYnB,GAXgB,UAAZqgC,GAA8C,UAAtBC,EAAal8B,MAA0C,aAAtBk8B,EAAal8B,OAClEy9B,IAAqBjD,GAAiBvxB,MACtC+1B,EAAUe,UAAY7D,EAAa6D,QAE9BnD,GAAeV,EAAcuB,KAClCuB,EAAUe,QAAUlF,KAMZ,UAAZoB,GAAmC,UAAZA,EAAqB,CAC5C,IAAI+D,EAAepkC,EACnBojC,EAAUiB,cAAgBD,EAAaE,OAAS,SAAW,SAW/D,OANItkC,EAAQukC,aACRnB,EAAUoB,cAAgBznC,KAAKO,MAAM0C,EAAQukC,aAE7CvkC,EAAQykC,YACRrB,EAAUsB,aAAe3nC,KAAKO,MAAM0C,EAAQykC,YAEzCrB,EA7RUuB,CAA6B3kC,EAAS6hC,GACnDxqB,EAAa,GAiBjB,OAhBIrX,EAAQqX,WAAWxb,SAcnBwb,EAAa+qB,GAAoBpiC,EAT7B/E,EAAQ2kC,yBAA2BiC,GAAoB5mC,EAAQqmC,oBAAkC,SAAZjB,GACpDplC,EAGA,EAAO,GAAIA,EAAS,CACjD2kC,uBAAwBiC,EACxBP,iBAA8B,SAAZjB,MAKvB,CACHj8B,KAAM,EACNi8B,QAASA,EACT4C,WAAYA,EACZ5rB,WAAYA,EACZurB,MAAOA,IAvFIgC,CAAqBrtB,EAAMtc,GACtC,KAAKsc,EAAK2pB,UACN,OA+JZ,SAA2BG,EAAUpmC,GACjC,IAAIqD,EAGAijC,EAAkD,QAAjCjjC,EAAK+iC,EAASnW,qBAAkC,IAAP5sB,OAAgB,EAASA,EAAG+hC,QACtFjT,EAAcgU,GAAeC,EAAUpmC,EAAQqmC,mBAAoB,EAAOrmC,EAAQ2kC,wBACtF,GAAKxS,EAGL,MAAO,CACHhpB,KAAM,EACNgpB,YAAaA,EACboU,QAA2B,UAAlBD,QAAmCznC,GA3KjC+qC,CAAkBttB,EAAMtc,GACnC,KAAKsc,EAAKutB,mBACN,MA6KD,CACH1gC,KAAM,EACNgpB,YAAa,IAtKrB,IAAmCmV,EAlCVwC,CAAcxtB,EAAMtc,GACzC,IAAKinC,EACD,OAAO,KAGX,IAAIjkB,EAAK0jB,GAAoBpqB,IAyPtBytB,KAxPHC,EAAuB/C,EAM3B,OALA+C,EAAqBhnB,GAAKA,ECDvB,SAA6B1G,EAAM2tB,GACtCzD,GAAkBrmB,IAAI7D,EAAM2tB,GDC5BC,CAAoB5tB,EAAM0G,GACtBhjB,EAAQwmC,mBACRxmC,EAAQwmC,kBAAkB7+B,IAAIqb,GAE3BgnB,EA+LJ,SAAS7C,GAAoB7qB,EAAMtc,GACtC,IAAIkD,EAAS,GAOb,OANAlF,GAAQse,EAAKF,YAAY,SAAU+tB,GAC/B,IAAIC,EAAsBpD,GAAoBmD,EAAWnqC,GACrDoqC,GACAlnC,EAAO5D,KAAK8qC,MAGblnC,EAEJ,SAASolC,GAAmBvjC,EAAS6hC,EAAkBwB,GAC1D,GAAIxB,IAAqBjD,GAAiBE,OAEtC,OAAO,KAEX,IAAIwE,EAAiBtjC,EAAQqrB,aAAagY,GAC1C,GAAIxB,IAAqBjD,GAAiBtxB,KAAM,CAC5C,IAAI+yB,EAAUrgC,EAAQqgC,QACtB,OAAQgD,GAEJ,IAAK,QACL,IAAK,MACD,OAAOpE,GAGf,KAAgB,QAAZoB,GAAiC,WAAZA,GACC,QAAlBgD,GAA6C,WAAlBA,GAC3B,MF9Ne,qFEkOvB,GAAgB,MAAZhD,GAAqC,SAAlBgD,EACnB,OAAOpE,GAGX,GAAIqE,GAAqD,IAAnCD,EAAc7pC,QAAQ,UAAkB6pC,IAAkBtE,GAE5E,OAAOE,GAGf,OAAKqE,GAA4C,iBAAnBA,GAI1BA,EAAeznC,ODnQsB,KCmQqD,UAA/BynC,EAAexiC,MAAM,EAAG,GAC5E,iBAJAwiC,EAQf,IAAI0B,GAAU,EAIVM,GAAiB,cACrB,SAAS3C,GAAgBtC,GACrB,IAAIkF,EAAmBlF,EAAQS,cAAcxV,OAC7C,OAAIga,GAAez7B,KAAK07B,GAIb,MAEJA,EAEX,SAASxB,GAAkBla,GACvB,IACI,IAAI2b,EAAQ3b,EAAE2b,OAAS3b,EAAE4b,SACzB,OAAOD,EAAQrjC,MAAMyhC,KAAK4B,GAAOtmC,IAAIwmC,IAAkBpiC,KAAK,IAAM,KAEtE,MAAO7K,GACH,OAAO,MAGf,SAASitC,GAAiBC,GACtB,OAEJ,SAAyBA,GACrB,MAAO,eAAgBA,EAHhBC,CAAgBD,GAAQ5B,GAAkB4B,EAAKE,aAAe,GAAKF,EAAK7B,QGvR5E,SAASgC,GAAsBxX,EAAYyX,EAAkBpG,GAChE,IAAIlrB,EAAmBN,KACvB,IAAKM,EACD,MAAO,CAAE9S,KAAMjE,GAEnB,IAAIsoC,ECRD,SAA6BC,GAChC,IAAIC,EAAuBxoC,EACvByoC,EAAmB,GACvB,SAAS10B,IACLy0B,IACAD,EAAqBE,GACrBA,EAAmB,GAEvB,MAAO,CACHC,aAAc,SAAUC,GACY,IAA5BF,EAAiBtqC,SACjBqqC,ElE0XT,SAA6BnkC,EAAUukC,GAM1C,GAAIxmC,OAAOymC,oBAAqB,CAC5B,IAAIC,EAAO1mC,OAAOymC,oBAAoB7kC,GAAQK,GkEjYY,CAAE0kC,QAZnC,MlE8YzB,OAAO,WAAc,OAAO3mC,OAAO4mC,mBAAmBF,IAE1D,IAAIvoB,EAAKne,OAAO6mC,sBAAsBjlC,GAAQK,IAC9C,OAAO,WAAc,OAAOjC,OAAO8mC,qBAAqB3oB,IkErYrBsoB,CAAoB90B,IAE/C00B,EAAiB5rC,KAAKuB,MAAMqqC,EAAkBE,IAElD50B,MAAOA,EACP9P,KAAM,WACFukC,MDTYW,EAAoB,SAAUR,IAoCtD,SAA0BA,EAAWN,EAAkBpG,GAKnD,IAAImH,EAAoBT,EAAUhhC,QAAO,SAAU0hC,GAC/C,OAAO/kC,SAASy+B,SAASsG,EAAS7qC,SFpDnC,SAA4Cqb,GAE/C,IADA,IAAI0D,EAAU1D,EACP0D,GAAS,CACZ,IAAKymB,GAAkBzmB,GACnB,OAAO,EAEXA,EAAUA,EAAQ4kB,WAEtB,OAAO,EE6CCmH,CAAmCD,EAAS7qC,SAC5CwjC,GAAoBqH,EAAS7qC,OAAQyjC,KAAyBf,GAAiBE,UAEnFxgC,EAiBR,SAAmC+nC,EAAW1G,GAyB1C,IAbA,IAAIsH,EAAqB,IAAIp5B,IACzBq5B,EAAe,IAAIC,IACnBC,EAAU,SAAUL,GACpB9tC,GAAQ8tC,EAASM,YAAY,SAAU9vB,GACnC0vB,EAAmBrkC,IAAI2U,MAE3Bte,GAAQ8tC,EAASG,cAAc,SAAU3vB,GAChC0vB,EAAmBtkC,IAAI4U,IACxB2vB,EAAa9rB,IAAI7D,EAAMwvB,EAAS7qC,QAEpC+qC,EAAmBK,OAAO/vB,OAGzB5b,EAAK,EAAG4rC,EAAclB,EAAW1qC,EAAK4rC,EAAY1rC,OAAQF,IAE/DyrC,EADeG,EAAY5rC,IAa/B,IAAI6rC,EAA2BrlC,MAAMyhC,KAAKqD,GACnBO,EA2IjBC,MAAK,SAAUC,EAAGC,GACpB,IAAIC,EAAWF,EAAEG,wBAAwBF,GAEzC,OAAIC,EAAWE,KAAKC,gCACR,EAEHH,EAAWE,KAAKE,4BAGhBJ,EAAWE,KAAKG,4BAFd,EAKFL,EAAWE,KAAKI,6BACb,EAGL,KAtJX,IAFA,IAAIzG,EAAoB,IAAI5zB,IACxBs6B,EAAqB,GAChB7pC,EAAK,EAAG8pC,EAA6BZ,EAA0BlpC,EAAK8pC,EAA2BvsC,OAAQyC,IAAM,CAClH,IAAIiZ,EAAO6wB,EAA2B9pC,GACtC,IAAI+pC,EAAkB9wB,GAAtB,CAGA,IAAIqoB,EAAyBF,GAAoBnoB,EAAKsoB,WAAYF,GAClE,GAAIC,IAA2BhB,GAAiBE,QAAUc,IAA2BhB,GAAiBC,OAAtG,CAGA,IAAIqD,EAAiBD,GAAoB1qB,EAAM,CAC3CvV,SACAy/B,kBAAmBA,EACnB7B,uBAAwBA,IAEvBsC,GAGLiG,EAAmB5tC,KAAK,CACpB+tC,OAAQC,EAAehxB,GACvBixB,SAAU7G,GAAoBpqB,EAAKsoB,YACnCtoB,KAAM2qB,MAId,IAAIuG,EAAuB,GAS3B,OARAvB,EAAajuC,SAAQ,SAAUyvC,EAAQnxB,GAC/BmqB,GAAkBnqB,IAClBkxB,EAAqBluC,KAAK,CACtBiuC,SAAU7G,GAAoB+G,GAC9BzqB,GAAI0jB,GAAoBpqB,QAI7B,CAAEoxB,KAAMR,EAAoBS,QAASH,EAAsBJ,kBAAmBA,GACrF,SAASA,EAAkB9wB,GACvB,OAAOmqB,GAAkBnqB,IAASkqB,EAAkB9+B,IAAIg/B,GAAoBpqB,IAEhF,SAASgxB,EAAehxB,GAEpB,IADA,IAAIsxB,EAActxB,EAAKsxB,YAChBA,GAAa,CAChB,GAAInH,GAAkBmH,GAClB,OAAOlH,GAAoBkH,GAE/BA,EAAcA,EAAYA,YAE9B,OAAO,MA3GFC,CAA0BhC,EAAkBzhC,QAAO,SAAU0hC,GAAY,MAAyB,cAAlBA,EAAS3iC,QAA0Bu7B,GAAsBgJ,EAAOrqC,EAAGqqC,KAAMC,EAAUtqC,EAAGsqC,QAASP,EAAoB/pC,EAAG+pC,kBAC3MU,EA6GR,SAAuC1C,EAAW1G,GAa9C,IAZA,IAAIrhC,EACA0qC,EAAgB,GAEhBC,EAAe,IAAIp7B,IACnBi5B,EAAoBT,EAAUhhC,QAAO,SAAU0hC,GAC/C,OAAIkC,EAAatmC,IAAIokC,EAAS7qC,UAG9B+sC,EAAarmC,IAAImkC,EAAS7qC,SACnB,MAGFP,EAAK,EAAGutC,EAAsBpC,EAAmBnrC,EAAKutC,EAAoBrtC,OAAQF,IAAM,CAC7F,IAAIorC,EAAWmC,EAAoBvtC,GAEnC,GADYorC,EAAS7qC,OAAOkxB,cACd2Z,EAASoC,SAAvB,CAGA,IAAIvJ,EAAyBF,GAAoBqH,EAAS7qC,OAAO2jC,WAAYF,GACzEC,IAA2BhB,GAAiBE,QAAUc,IAA2BhB,GAAiBC,QAGtGmK,EAAczuC,KAAK,CACf0jB,GAAI0jB,GAAoBoF,EAAS7qC,QAEjCtB,MAAiF,QAAzE0D,EAAK8iC,GAAe2F,EAAS7qC,QAAQ,EAAO0jC,UAA4C,IAAPthC,EAAgBA,EAAK,QAGtH,OAAO0qC,EA1IKI,CAA8BtC,EAAkBzhC,QAAO,SAAU0hC,GACzE,MAAyB,kBAAlBA,EAAS3iC,OAA6BikC,EAAkBtB,EAAS7qC,WACxEyjC,GACAsD,EAyIR,SAAoCoD,EAAW1G,GAmB3C,IAlBA,IAAI0J,EAAqB,GAErBC,EAAkB,IAAInC,IACtBL,EAAoBT,EAAUhhC,QAAO,SAAU0hC,GAC/C,IAAIwC,EAAoBD,EAAgB9pC,IAAIunC,EAAS7qC,QACrD,QAAIqtC,MAAAA,OAA6D,EAASA,EAAkB5mC,IAAIokC,EAAS1D,kBAGpGkG,EAIDA,EAAkB3mC,IAAImkC,EAAS1D,eAH/BiG,EAAgBluB,IAAI2rB,EAAS7qC,OAAQ,IAAI2R,IAAI,CAACk5B,EAAS1D,kBAKpD,MAGPmG,EAAmB,IAAIrC,IAClBxrC,EAAK,EAAG8tC,EAAsB3C,EAAmBnrC,EAAK8tC,EAAoB5tC,OAAQF,IAAM,CAC7F,IAAIorC,EAAW0C,EAAoB9tC,GAEnC,GADsBorC,EAAS7qC,OAAOmvB,aAAa0b,EAAS1D,iBACpC0D,EAASoC,SAAjC,CAGA,IAAIlI,EAAevB,GAAoBqH,EAAS7qC,OAAQyjC,GACpD2D,EAAiBC,GAAmBwD,EAAS7qC,OAAQ+kC,EAAc8F,EAAS1D,eAC5EqG,OAAmB,EACvB,GAA+B,UAA3B3C,EAAS1D,cAA2B,CACpC,IAAIsG,EAAa/H,GAAqBmF,EAAS7qC,OAAQ+kC,GACvD,QAAmBnnC,IAAf6vC,EACA,SAEJD,EAAmBC,OAGnBD,EAD+B,iBAAnBpG,EACOA,EAGA,KAEvB,IAAIsG,EAAkBJ,EAAiBhqC,IAAIunC,EAAS7qC,QAC/C0tC,IACDA,EAAkB,CACd3rB,GAAI0jB,GAAoBoF,EAAS7qC,QACjC+mC,WAAY,IAEhBoG,EAAmB9uC,KAAKqvC,GACxBJ,EAAiBpuB,IAAI2rB,EAAS7qC,OAAQ0tC,IAE1CA,EAAgB3G,WAAW8D,EAAS1D,eAAiBqG,GAEzD,OAAOL,EA7LUQ,CAA2B/C,EAAkBzhC,QAAO,SAAU0hC,GAC3E,MAAyB,eAAlBA,EAAS3iC,OAA0BikC,EAAkBtB,EAAS7qC,WACrEyjC,IACCoJ,EAAMltC,QAAWonC,EAAWpnC,QAAW+sC,EAAQ/sC,QAAW8sC,EAAK9sC,SAGpEkqC,EAAiB,CACb4C,KAAMA,EACNC,QAASA,EACTG,MAAOA,EACP9F,WAAYA,IA3DZ6G,CAAiBzD,EAAUnpC,OAAOuI,EAASskC,eAAgBhE,EAAkBpG,MAE7El6B,EAAW,IAAIgP,EAAiB/S,GAAQskC,EAAcI,eAU1D,OATA3gC,EAAS2T,QAAQpX,SAAU,CACvBgoC,mBAAmB,EACnB/G,YAAY,EACZgH,eAAe,EACfC,uBAAuB,EACvBC,WAAW,EACXC,SAAS,IAEb9b,EAAW+b,QAAQrE,EAAcv0B,OAC1B,CACH9P,KAAM,WACF8D,EAAS0sB,aACT6T,EAAcrkC,SAO1B,IEvCIrD,GFuCAgsC,GAAoC,WACpC,SAASA,KAST,OAPAA,EAAmB/tC,UAAUkV,MAAQ,WACjC,IAAInT,EAC0B,QAA7BA,EAAKmB,KAAK8qC,qBAAkC,IAAPjsC,GAAyBA,EAAG7B,KAAKgD,OAE3E6qC,EAAmB/tC,UAAU8tC,QAAU,SAAUnpC,GAC7CzB,KAAK8qC,cAAgBrpC,GAElBopC,EAV4B,GGjB5BE,GAAuC,SAAUC,EAASC,GACjE,IAAIC,EAAS7qC,OAAO8qC,eAChBC,EAAa,CACbC,gBAAiBL,EACjBM,gBAAiBL,EACjBM,gBAAiBP,EACjBQ,gBAAiBP,GAErB,OAAKC,GAbT,WACI,IAAIA,EAAS7qC,OAAO8qC,eACpB,OAAQ7tC,KAAKmuC,IAAIP,EAAOQ,QAAUR,EAAOS,UAAYtrC,OAAOurC,SARhD,IASRtuC,KAAKmuC,IAAIP,EAAOW,SAAWX,EAAOY,WAAazrC,OAAO0rC,SAT9C,GAuBHC,IAELZ,EAAWC,gBAAkB/tC,KAAKO,MAAMmtC,EAAUE,EAAOY,YACzDV,EAAWE,gBAAkBhuC,KAAKO,MAAMotC,EAAUC,EAAOS,aAIzDP,EAAWG,gBAAkBjuC,KAAKO,MAAMmtC,EAAUE,EAAOY,YACzDV,EAAWI,gBAAkBluC,KAAKO,MAAMotC,EAAUC,EAAOS,YAEtDP,GAZIA,GAcJa,GAAoB,WAC3B,IAAIf,EAAS7qC,OAAO8qC,eACpB,MAAO,CACHe,MAAOhB,EAAOgB,MACdJ,WAAYZ,EAAOY,WACnBH,UAAWT,EAAOS,UAClBE,SAAUX,EAAOW,SACjBH,QAASR,EAAOQ,QAChBnI,OAAQ2H,EAAO3H,OACfD,MAAO4H,EAAO5H,QAIf,SAAS6I,KACZ,IAAIjB,EAAS7qC,OAAO8qC,eACpB,OAAID,EACOA,EAAO5H,MAAQ4H,EAAOgB,MAE1B7rC,OAAO+rC,YAAc,EAGzB,SAASC,KACZ,IAAInB,EAAS7qC,OAAO8qC,eACpB,OAAID,EACOA,EAAO3H,OAAS2H,EAAOgB,MAE3B7rC,OAAOisC,aAAe,EAE1B,SAASC,KACZ,IAAIrB,EAAS7qC,OAAO8qC,eACpB,OAAID,EACOA,EAAOW,SAAWX,EAAOY,gBAEbzxC,IAAnBgG,OAAO0rC,QACA1rC,OAAO0rC,QAEX1rC,OAAOmsC,aAAe,EAE1B,SAASC,KACZ,IAAIvB,EAAS7qC,OAAO8qC,eACpB,OAAID,EACOA,EAAOQ,QAAUR,EAAOS,eAEZtxC,IAAnBgG,OAAOurC,QACAvrC,OAAOurC,QAEXvrC,OAAOqsC,aAAe,EDhF1B,SAASC,GAAcC,GAC1B,IAgPuBC,EAhPnBC,EAwBGzG,GAxBoCuG,EAAEG,mBAAoBH,EAAEI,WAAYJ,EAAE1M,qBAwBPh+B,KAvBtE+qC,EAyBR,SAA0BC,GACtB,IAAIC,EAAiB9xC,EAAS4G,IAAQ,SAAUT,GAC5C,IAAI/E,EAAS+E,EAAM/E,OACnB,GAAIwlC,GAAkBxlC,GAAS,CAC3B,IAAIoC,EAAKwjC,GAAa7gC,GAASA,EAAM8gC,eAAe,GAAK9gC,EAAOwpC,EAAUnsC,EAAGmsC,QAASC,EAAUpsC,EAAGosC,QAC/F9C,EAAW,CACX3pB,GAAI0jB,GAAoBzlC,GACxB2wC,WAAY,EACZC,EAAGrC,EACHsC,EAAGrC,GAEP,GAAI5qC,OAAO8qC,eAAgB,CACvB,IAAIvpC,EAAKmpC,GAAqCC,EAASC,GAAUM,EAAkB3pC,EAAG2pC,gBAAiBC,EAAkB5pC,EAAG4pC,gBAC5HrD,EAASkF,EAAI9B,EACbpD,EAASmF,EAAI9B,EAEjB0B,EAAG,CAAC/E,GAAW9F,GAAa7gC,GEhDzB,EALA,OFOqB,GAgDG,CAC/B1F,UAAU,IACXE,UACH,OAAO0F,EAAkBa,SAAU,CAAC,YAA8B,aAA+B4qC,EAAgB,CAC7GrrC,SAAS,EACTC,SAAS,IACVG,KAjDoBqrC,CAAiBX,EAAEY,aACtCC,EA6DR,SAAsCP,EAAIhN,GAoBtC,OAAOx+B,EAAkBa,SAAU1F,OAAO2C,KAAKkuC,KAnBjC,SAAUlsC,GACpB,IAAI/E,EAAS+E,EAAM/E,OACnB,GAAIwjC,GAAoBxjC,EAAQyjC,KAAyBf,GAAiBE,QAAW4C,GAAkBxlC,GAAvG,CAGA,IAAIoC,EAAKwjC,GAAa7gC,GAASA,EAAM8gC,eAAe,GAAK9gC,EAAOwpC,EAAUnsC,EAAGmsC,QAASC,EAAUpsC,EAAGosC,QAC/F9C,EAAW,CACX3pB,GAAI0jB,GAAoBzlC,GACxBkI,KAAM+oC,GAA4BlsC,EAAMmD,MACxC0oC,EAAGrC,EACHsC,EAAGrC,GAEP,GAAI5qC,OAAO8qC,eAAgB,CACvB,IAAIvpC,EAAKmpC,GAAqCC,EAASC,GAAUM,EAAkB3pC,EAAG2pC,gBAAiBC,EAAkB5pC,EAAG4pC,gBAC5HrD,EAASkF,EAAI9B,EACbpD,EAASmF,EAAI9B,EAEjB0B,EAAG/E,MAE+E,CAClFrmC,SAAS,EACTC,SAAS,IACVG,KApF2ByrC,CAA6Bf,EAAEgB,mBAAoBhB,EAAE1M,qBAC/E2N,EAqFR,SAA4BX,EAAIhN,GAC5B,IAAIiN,EAAiB9xC,EAAS4G,IAAQ,SAAUT,GAC5C,IAAI/E,EAAS+E,EAAM/E,OACnB,GAAKA,GACDwjC,GAAoBxjC,EAAQyjC,KAAyBf,GAAiBE,QACrE4C,GAAkBxlC,GAFvB,CAKA,IAAI+hB,EAAK0jB,GAAoBzlC,GACzBA,IAAW8F,SACX2qC,EAAG,CACC1uB,GAAIA,EACJ6uB,EAAGd,KACHe,EAAGb,OAIPS,EAAG,CACC1uB,GAAIA,EACJ6uB,EAAG5wC,EAAOqoC,WACVwI,EAAG7wC,EAAOuoC,gBA/GM,KAkHGhpC,UAC/B,OAAOsF,EAAiBiB,SAAU,SAAuB4qC,EAAgB,CAAErrC,SAAS,EAAMC,SAAS,IAAQG,KA7GvF4rC,CAAmBlB,EAAEmB,SAAUnB,EAAE1M,qBACjD8N,EA8GR,SAAoCd,GAChC,IAAIe,EAAkB5yC,EAAS4G,IAAQ,WACnC,IAAIshC,EAAS8I,KACT/I,EAAQ6I,KACZe,EAAG,CACC3J,OAAQlrB,OAAOkrB,GACfD,MAAOjrB,OAAOirB,QAElB,KAAKtnC,UACT,OAAOsF,EAAiBjB,OAAQ,SAAuB4tC,EAAiB,CAAEnsC,SAAS,EAAMC,SAAS,IAAQG,KAvH9EgsC,CAA2BtB,EAAEuB,kBACrDC,EAwHD,SAA2BlB,EAAIhN,GAClC,IAAImO,EAAoB,IAAIzpB,QAC5B,SAAS0pB,EAAgB7xC,GACrB,IAAI2lC,EAAmBnC,GAAoBxjC,EAAQyjC,GACnD,GAAIkC,IAAqBjD,GAAiBE,OAA1C,CAGA,IACIkP,EADA5pC,EAAOlI,EAAOkI,KAElB,GAAa,UAATA,GAA6B,aAATA,EAAqB,CACzC,GAAI48B,GAAe9kC,EAAQ2lC,GACvB,OAEJmM,EAAa,CAAEC,UAAW/xC,EAAOioC,aAEhC,CACD,IAAIvpC,EAAQgnC,GAAqB1lC,EAAQ2lC,GACzC,QAAc/nC,IAAVc,EACA,OAEJozC,EAAa,CAAEE,KAAMtzC,GAGzBuzC,EAAYjyC,EAAQ8xC,GAEpB,IAAIvzC,EAAOyB,EAAOzB,KACL,UAAT2J,GAAoB3J,GAAQyB,EAAOioC,SACnClrC,GAAQ+I,SAASgrB,iBAAiB,6BAAgC9vB,OAAOzC,EAAM,QAAS,SAAUioC,GAC1FA,IAAOxmC,GAEPiyC,EAAYzL,EAAI,CAAEuL,WAAW,QAQ7C,SAASE,EAAYjyC,EAAQ8xC,GACzB,GAAKtM,GAAkBxlC,GAAvB,CAGA,IAAIkyC,EAAiBN,EAAkBtuC,IAAItD,GACtCkyC,GACDA,EAAeF,OAASF,EAAWE,MACnCE,EAAeH,YAAcD,EAAWC,YACxCH,EAAkB1yB,IAAIlf,EAAQ8xC,GAC9BrB,EAAG,EAAO,CACN1uB,GAAI0jB,GAAoBzlC,IACzB8xC,MAGX,IAAIK,EAAqBltC,EAAkBa,SAAU,CAAC,QAAqB,WAAwB,SAAUf,IACrGA,EAAM/E,kBAAkBwvB,kBACxBzqB,EAAM/E,kBAAkBoyC,qBACxBrtC,EAAM/E,kBAAkBqyC,oBACxBR,EAAgB9sC,EAAM/E,UAE3B,CACCqF,SAAS,EACTC,SAAS,IACVG,KACC6sC,EAA0B,CAC1BzqB,GAAiB2H,iBAAiBnvB,UAAW,QAASwxC,GACtDhqB,GAAiB2H,iBAAiBnvB,UAAW,UAAWwxC,GACxDhqB,GAAiBwqB,kBAAkBhyC,UAAW,QAASwxC,GACvDhqB,GAAiBuqB,oBAAoB/xC,UAAW,QAASwxC,GACzDhqB,GAAiBwqB,kBAAkBhyC,UAAW,gBAAiBwxC,IAEnE,OAAO,WACHS,EAAwBv1C,SAAQ,SAAUw1C,GAAW,OAAOA,EAAQ9sC,UACpE0sC,KA/LeK,CAAkBrC,EAAEsC,QAAStC,EAAE1M,qBAC9CiP,EA2NR,SAAsCC,EAAoBlP,GAatD,OAAOx+B,EAAkBa,SAAU,CAAC,OAAmB,UAZzC,SAAUf,GACpB,IAAI/E,EAAS+E,EAAM/E,OACdA,GACDwjC,GAAoBxjC,EAAQyjC,KAAyBf,GAAiBE,QACrE4C,GAAkBxlC,IAGvB2yC,EAAmB,CACf5wB,GAAI0jB,GAAoBzlC,GACxBkI,KAAqB,SAAfnD,EAAMmD,KE/Nd,EACC,MFiO+E,CAAE7C,SAAS,EAAMC,SAAS,IAAQG,KAxO1FmtC,CAA6BzC,EAAEwC,mBAAoBxC,EAAE1M,qBAC/EoP,EAgMR,SAAgCpC,GAC5B,IAAIqC,EAAoBnrB,GAAgCorB,cAAc1yC,UAAW,aAAc,CAC3FunB,OAAQ,SAAU6hB,EAAM5iB,GAChB2e,GAAkBjiC,KAAKyvC,YACvBvC,EAAG,CACC1uB,GAAI0jB,GAAoBliC,KAAKyvC,WAC7BvG,KAAM,CAAC,CAAEhD,KAAMA,EAAM5iB,MAAOA,SAIzCphB,KACCwtC,EAAoBtrB,GAAgCorB,cAAc1yC,UAAW,aAAc,CAC3FunB,OAAQ,SAAUf,GACV2e,GAAkBjiC,KAAKyvC,YACvBvC,EAAG,CACC1uB,GAAI0jB,GAAoBliC,KAAKyvC,WAC7BtG,QAAS,CAAC,CAAE7lB,MAAOA,SAIhCphB,KACH,OAAO,WACHqtC,IACAG,KAvNqBC,CAAuB/C,EAAEgD,kBAC9CC,GAwOmBhD,EAxOcD,EAAEC,QAyOhCnrC,EAAkBrB,OAAQ,CAAC,QAAqB,SAAoB,WACvEwsC,EAAQ,CAAEiD,UAAWvtC,SAASwtC,gBAC/B7tC,MA1OC8tC,EA4OR,SAA0C9C,GACtC,IAAK7sC,OAAO8qC,eACR,OAAOltC,EAEX,IAAIY,EAAKxD,EAAS4G,IAAQ,WACtBirC,EAAGjB,SA5P8B,IA6PG,CACpCnwC,UAAU,IACVmyC,EAAkBpvC,EAAG7C,UAAWi0C,EAAiBpxC,EAAGtC,OACpD2zC,EAAiBxuC,EAAkBrB,OAAO8qC,eAAgB,CAAC,SAAuB,UAAwB8C,EAAiB,CAC3HnsC,SAAS,EACTC,SAAS,IACVG,KACH,OAAO,WACHguC,IACAD,KA3P8BE,CAAiCvD,EAAEwD,wBACrE,OAAO,WACHtD,IACAG,IACAQ,IACAI,IACAG,IACAI,IACAe,IACAG,IACAO,IACAG,KAgCR,IGhEIK,GHgEA3C,KAA+B7uC,GAAK,IACT,QEpDlB,EFqDTA,GAA+B,UEpDpB,EFqDXA,GAAsB,MEpDf,EFqDPA,GAAmC,YEpDtB,EFqDbA,GAA6B,SEpDnB,EFqDVA,GAAsB,MEpDf,EFqDPA,GAAoB,KEpDd,EFqDNA,GAAiC,WEpDrB,EFqDZA,GAA6B,SEpDnB,EFqDVA,IIcJ,SAASyxC,GAA4B3zC,EAAQoJ,GACzC,MAAO,CACHA,KAAM,EAAO,CACTpJ,OAAQA,GACToJ,GACHpB,KZ3FiB,EY4FjB+C,UAAWR,KC7FZ,SAAS0C,GAAKyJ,EAAiBtN,EAAMwqC,EAAUC,EAAgBl9B,GAClE,IAAIm9B,EAAW,IAAIC,SACnBD,EAASloB,OAAO,UAAW,IAAIjW,KAAK,CAACvM,GAAO,CACxCpB,KAAM,6BACN,GAAGlH,OAAO8yC,EAAS1yB,QAAQW,GAAI,KAAK/gB,OAAO8yC,EAAShpC,QACxDopC,GAAcJ,GAAU,SAAU3zC,EAAKzB,GAAS,OAAOs1C,EAASloB,OAAO3rB,EAAKzB,MAC5Es1C,EAASloB,OAAO,mBAAoBioB,EAAehzC,YACrC,IAAI4V,GAAYC,EARS,KAS/BzJ,KAAK6mC,EAAU1qC,EAAK6qC,WAAYt9B,GAErC,SAASq9B,GAAc9qB,EAAOgrB,EAASC,QAC3B,IAAXA,IAAqBA,EAAS,IAClCpxC,EAAcmmB,GAAOrsB,SAAQ,SAAUqF,GACnC,IAAIjC,EAAMiC,EAAG,GAAI1D,EAAQ0D,EAAG,GACP,iBAAV1D,GAAgC,OAAVA,EAC7Bw1C,GAAcx1C,EAAO01C,EAAS,GAAGpzC,OAAOqzC,GAAQrzC,OAAOb,EAAK,MAG5Di0C,EAAQ,GAAGpzC,OAAOqzC,GAAQrzC,OAAOb,GAAM4lB,OAAOrnB,OFlBnD,SAAS41C,GAAiBC,GAC7B,OAAOC,GAAuBD,GAAQE,eAKnC,SAASC,GAAUH,GACtBC,GAAuBD,GAAQI,eAAiB,EAK7C,SAAS9W,GAAe0W,GAC3B,OAAOX,MAAAA,QAAmD,EAASA,GAAatwC,IAAIixC,GAKxF,SAASC,GAAuBD,GAI5B,IAAI3W,EAeJ,OAlBKgW,KACDA,GAAe,IAAI3I,KAGnB2I,GAAantC,IAAI8tC,GACjB3W,EAAcgW,GAAatwC,IAAIixC,IAG/B3W,EAAc,CACV+W,cAAe,EACfF,eAAgB,EAChBG,wBAAyB,GAE7BhB,GAAa10B,IAAIq1B,EAAQ3W,GACrBgW,GAAa99B,KAnCM,IAyC/B,WACI,GAAK89B,GAGL,GAAIA,GAAa7wC,KACb6wC,GAAaxI,OAAOwI,GAAa7wC,OAAO6hB,OAAOlmB,WAE9C,CAED,IAAIm2C,GAAY,EAChBjB,GAAa72C,SAAQ,SAAU+3C,EAAQ30C,GAC/B00C,IACAjB,GAAaxI,OAAOjrC,GACpB00C,GAAY,OAlBhBE,IAGDnX,EGpCX,ICHIoX,GDGA5I,GAAS,EACT6I,GAAyB,WACzB,SAASA,EAAQC,EAAQxpC,EAASypC,EAAgBC,EAAeC,EAASC,GACtE,IAAItsC,EAAQzF,KACZA,KAAK2xC,OAASA,EACd3xC,KAAKgyC,WAAY,EACjBhyC,KAAKwe,GAAKqqB,KACV,IAAImI,EAAS7oC,EAAQqnB,KAAKhR,GAC1Bxe,KAAKuwC,SAAW,EAAO,CACnBhpC,MAAOsqC,EAAcnqC,UACrBF,IAAKqqC,EAAcnqC,UACnBuqC,gBAAiBL,EACjBR,cAAe,EACfc,kBddM,IccaL,EAAcltC,KACjCwtC,cAAe,GAA6BnB,IAC7C7oC,GHbJ,SAAoB6oC,GACvBC,GAAuBD,GAAQE,gBAAkB,EGa7C,CAAuBF,GACvB,GAAsBA,GACtB,IAAIvvC,EAAWQ,IAAQ,SAAUpD,GAC7B,IAAIkH,EAAOlH,EAAGkH,KACI,YAAdA,EAAKpB,MAAoC,gBAAdoB,EAAKpB,OAGhCoB,EAAKyY,KAAO/Y,EAAM+Y,IHf3B,SAAsBwyB,EAAQoB,GACjCnB,GAAuBD,GAAQK,yBAA2Be,EGe9C,CAAyBpB,EAAQjrC,EAAKqsC,mBACpB,YAAdrsC,EAAKpB,MACLotC,EAAUhsC,EAAKrH,OAAQqH,EAAKssC,SAC5BV,EAAOxvC,oBAAoB,UAAWV,IAGtCqwC,EAAQ/rC,EAAKusC,iBAGZvsC,EAAKyY,GAAK/Y,EAAM+Y,KASrBmzB,EAAOxvC,oBAAoB,UAAWV,GACtC6G,GAAqB,0EAG7BqpC,EAAOrwC,iBAAiB,UAAWG,GACnCzB,KAAK2xC,OAAOY,YAAY,CAAExsC,KAAM,eAAiBtI,OAAOY,KAAKC,UAAUuzC,IAAiBrzB,GAAIxe,KAAKwe,GAAIM,OAAQ,UAmBjH,OAjBA4yB,EAAQ50C,UAAUq0C,UAAY,SAAUqB,GACpC,IAAI3zC,EACJmB,KAAKuwC,SAAS/oC,IAAMgrC,EAAO9qC,UAC3B1H,KAAKuwC,SAASa,eAAiB,EAC/B,GAAsBpxC,KAAKuwC,SAAS/gB,KAAKhR,KACxC3f,EAAKmB,KAAKuwC,UAAU2B,oBAAsBrzC,EAAGqzC,kBdvDpC,IcuDwDM,EAAO7tC,MACzE3E,KAAK2xC,OAAOY,YAAY,CAAExsC,KAAM,IAAItI,OAAOY,KAAKC,UAAUk0C,IAAUh0B,GAAIxe,KAAKwe,GAAIM,OAAQ,WAE7F4yB,EAAQ50C,UAAUkV,MAAQ,SAAUC,GAChCjS,KAAK2xC,OAAOY,YAAY,CACpBxsC,KAAM,KAAKtI,OAAOY,KAAKC,UAAU0B,KAAKuwC,UAAUlvC,MAAM,GAAI,MAC1Dmd,GAAIxe,KAAKwe,GACTM,OAAQ,UAEZ9e,KAAKgyC,WAAY,EACjBhyC,KAAKsT,YAAcrB,GAEhBy/B,EAjEiB,GEyBrB,SAASe,GAAuB15B,EAAW7I,EAAe8L,EAAgBC,EAAcrS,EAAM+nC,GACjG,OAEG,SAAkC54B,EAAW25B,EAAmB9oC,EAAM+nC,EAAQpwC,QACjE,IAAZA,IAAsBA,EAAUlB,QACpC,IAAI+kB,EAAQ,CACR1c,OAAQ,EACRiqC,0BAA2B,QAE3BC,EAAyB75B,EAAUxT,UAAU,GAAsB,WACnEstC,EAAa,kBACdltC,YACCmtC,EAA0B/5B,EAAUxT,UAAU,GAAuB,WACrEstC,EAAa,oBACdltC,YACCotC,EAA8BzxC,EAAiBC,EAAS,oBAA4C,WACnE,WAA7BgB,SAAS2Q,iBACT2/B,EAAa,uBAElB,CAAE/wC,SAAS,IAAQI,KACtB,SAAS2wC,EAAaF,GACG,IAAjBvtB,EAAM1c,SACN0c,EAAM4tB,QAAQhhC,MAAM2gC,GAA6B,eACjDn2C,aAAa4oB,EAAM6tB,sBAGnB7tB,EADAutB,EACQ,CACJjqC,OAAQ,EACRiqC,0BAA2BA,GAIvB,CACJjqC,OAAQ,GAIpB,SAASwqC,EAAiBtB,EAAgBC,GACtC,IAAI1pC,EAsCL,SAA+B+H,EAAe8L,EAAgBC,GACjE,IAAI4B,EAAU7B,EAAe8B,qBACzBL,EAAcxB,EAAayB,WAC/B,GAAKG,GAAYJ,EAGjB,MAAO,CACHc,YAAa,CACTC,GAAItO,GAER2N,QAAS,CACLW,GAAIX,EAAQW,IAEhBgR,KAAM,CACFhR,GAAIf,EAAY+R,KAAKhR,KAzFmC20B,CAAsBjjC,EAAe8L,EAAgBC,GAsCjH,GAAK9T,EAAL,CAGA,IAAI6qC,EAAU,IAAItB,GAAQC,EAAQxpC,EAASypC,EAAgBC,GAAe,SAAUuB,IAC3EJ,EAAQhB,WAAaoB,EHvEK,KGwE3BP,EAAa,eAElB,SAAU9sC,EAAMyqC,GACf5mC,EAAK7D,EAAMitC,EAAQzC,SAAUC,EAAgBwC,EAAQ1/B,gBAEzD8R,EAAQ,CACJ1c,OAAQ,EACRsqC,QAASA,EACTC,oBAAqB32C,WAAW2F,IAAQ,WACpC4wC,EAAa,mBA/EK,OAmF9B,MAAO,CACH1B,UAAW,SAAUqB,GACjB,OAAQptB,EAAM1c,QACV,KAAK,EACDwqC,EAAiB9tB,EAAMutB,0BAA2BH,GAClD,MACJ,KAAK,EACDptB,EAAM4tB,QAAQ7B,UAAUqB,KAIpCtwC,KAAM,WACF2wC,IACAD,IACAE,IACAC,MAvEDM,CAAyBt6B,EAAW,EAA4FnP,EAAM+nC,GD7B1I,SAAS2B,KAKZ,OAHK7B,KACDA,GAAYnmC,IAAIioC,gBAAgB,IAAIjhC,KAAK,CAAC,IAAI7U,OAAO+1C,GAAc,eAEhE,IAAIC,OAAOhC,IAEtB,SAAS+B,KA+CL,SAASvxC,EAAQ3G,GACb,OAAO,WACH,IACI,OAAOA,EAAGe,MAAM2D,KAAM7D,WAE1B,MAAO6I,GACH,IACI5E,KAAKmyC,YAAY,CACb5tC,KAAM,UACN3L,MAAOgM,IAGf,MAAOoQ,GAEHhV,KAAKmyC,YAAY,CACb5tC,KAAM,UACN3L,MAAO,GAAGyE,OAAOuH,QA9DrC/C,GAAQ,WACJ,IAAIpD,EAoER,WA8BI,SAAS60C,EAAKC,GAEV,IADA,IAAIC,EAAMD,EAAIv3C,SACLw3C,GAAO,GACZD,EAAIC,GAAO,EAGnB,IAaIC,EAAW,IAEXC,EAAUD,IAEVE,EAAU,GAMVC,EAAW,GAiBXC,EAEJ,IAAI3sB,WAAW,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,IAChG4sB,EAEJ,IAAI5sB,WAAW,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,GAAI,KAC1G6sB,EAEJ,IAAI7sB,WAAW,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,EAAG,IAClE8sB,EAAW,IAAI9sB,WAAW,CAAC,GAAI,GAAI,GAAI,EAAG,EAAG,EAAG,EAAG,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,GAAI,EAAG,KAYzF+sB,EAAe,IAAI3xC,MAAM,KAC7BgxC,EAAKW,GAML,IAAIC,EAAe,IAAI5xC,MAAMqxC,IAC7BL,EAAKY,GAIL,IAAIC,EAAa,IAAI7xC,MAfD,KAgBpBgxC,EAAKa,GAKL,IAAIC,EAAe,IAAI9xC,MAAM+xC,KAC7Bf,EAAKc,GAEL,IAAIE,EAAc,IAAIhyC,MAvEH,IAwEnBgxC,EAAKgB,GAEL,IAiBIC,EACAC,EACAC,EAnBAC,EAAY,IAAIpyC,MAAMqxC,GAG1B,SAASgB,EAAeC,EAAaC,EAAYC,EAAYC,EAAOC,GAChEp1C,KAAKg1C,YAAcA,EAEnBh1C,KAAKi1C,WAAaA,EAElBj1C,KAAKk1C,WAAaA,EAElBl1C,KAAKm1C,MAAQA,EAEbn1C,KAAKo1C,WAAaA,EAGlBp1C,KAAKq1C,UAAYL,GAAeA,EAAY54C,OAKhD,SAASk5C,EAASC,EAAUC,GACxBx1C,KAAKu1C,SAAWA,EAEhBv1C,KAAKy1C,SAAW,EAEhBz1C,KAAKw1C,UAAYA,EAxBrB9B,EAAKoB,GA2BL,IAAIY,EAAS,SAAgBC,GACzB,OAAOA,EAAO,IAAMpB,EAAWoB,GAAQpB,EAAW,KAAOoB,IAAS,KAMlEC,EAAY,SAAmBxrB,EAAGyrB,GAGlCzrB,EAAE0rB,YAAY1rB,EAAE2rB,WAAiB,IAAJF,EAC7BzrB,EAAE0rB,YAAY1rB,EAAE2rB,WAAcF,IAAM,EAAK,KAMzCG,EAAY,SAAmB5rB,EAAGjvB,EAAOiB,GACrCguB,EAAE6rB,SA1GK,GA0GiB75C,GACxBguB,EAAE8rB,QAAW/6C,GAASivB,EAAE6rB,SAAY,MACpCL,EAAUxrB,EAAGA,EAAE8rB,QACf9rB,EAAE8rB,OAAS/6C,GA7GJ,GA6GyBivB,EAAE6rB,SAClC7rB,EAAE6rB,UAAY75C,EA9GP,KAiHPguB,EAAE8rB,QAAW/6C,GAASivB,EAAE6rB,SAAY,MACpC7rB,EAAE6rB,UAAY75C,IAGlB+5C,EAAY,SAAmB/rB,EAAGgsB,EAAGC,GACrCL,EAAU5rB,EAAGisB,EAAS,EAAJD,GAElBC,EAAS,EAAJD,EAAQ,KASbE,EAAa,SAAoBlwB,EAAMwtB,GACvC,IAAI2C,EAAM,EACV,GACIA,GAAc,EAAPnwB,EACPA,KAAU,EACVmwB,IAAQ,UACD3C,EAAM,GACjB,OAAO2C,IAAQ,GAyJfC,EAAY,SAAmBH,EAAMZ,EAAUgB,GAK/C,IAIIC,EAEAC,EANAC,EAAY,IAAIl0C,MAAMsxC,IAEtB5tB,EAAO,EASX,IAAKswB,EAAO,EAAGA,GAAQ1C,EAAU0C,IAC7BE,EAAUF,GAAQtwB,EAAQA,EAAOqwB,EAASC,EAAO,IAAO,EAQ5D,IAAKC,EAAI,EAAGA,GAAKlB,EAAUkB,IAAK,CAC5B,IAAI/C,EAAMyC,EAAS,EAAJM,EAAQ,GAEX,IAAR/C,IAIJyC,EAAS,EAAJM,GAEDL,EAAWM,EAAUhD,KAAQA,MAkHrCiD,EAAa,SAAoBzsB,GACjC,IAAIusB,EAGJ,IAAKA,EAAI,EAAGA,EAAI7C,EAAS6C,IACrBvsB,EAAE0sB,UAAc,EAAJH,GAER,EAER,IAAKA,EAAI,EAAGA,EAAI5C,EAAS4C,IACrBvsB,EAAE2sB,UAAc,EAAJJ,GAER,EAER,IAAKA,EAAI,EAAGA,EAzcD,GAyceA,IACtBvsB,EAAE4sB,QAAY,EAAJL,GAEN,EAERvsB,EAAE0sB,UAAUG,KAER,EACJ7sB,EAAE8sB,QAAU9sB,EAAE+sB,WAAa,EAC3B/sB,EAAEgtB,SAAWhtB,EAAEtpB,QAAU,GAKzBu2C,EAAY,SAAmBjtB,GAC3BA,EAAE6rB,SAAW,EACbL,EAAUxrB,EAAGA,EAAE8rB,QAEV9rB,EAAE6rB,SAAW,IAElB7rB,EAAE0rB,YAAY1rB,EAAE2rB,WAAa3rB,EAAE8rB,QAEnC9rB,EAAE8rB,OAAS,EACX9rB,EAAE6rB,SAAW,GA4BbqB,EAAU,SAAiBjB,EAAMM,EAAGY,EAAGC,GACvC,IAAIC,EAAU,EAAJd,EACNe,EAAU,EAAJH,EACV,OAAQlB,EAAKoB,GAETpB,EAAKqB,IAEJrB,EAAKoB,KAEFpB,EAAKqB,IAELF,EAAMb,IAAMa,EAAMD,IAQ1BI,EAAa,SAAoBvtB,EAAGisB,EAAMuB,GAQ1C,IAHA,IAAIC,EAAIztB,EAAE0tB,KAAKF,GACXG,EAAIH,GAAK,EAENG,GAAK3tB,EAAE4tB,WAEND,EAAI3tB,EAAE4tB,UAAYV,EAAQjB,EAAMjsB,EAAE0tB,KAAKC,EAAI,GAAI3tB,EAAE0tB,KAAKC,GAAI3tB,EAAEotB,QAC5DO,KAGAT,EAAQjB,EAAMwB,EAAGztB,EAAE0tB,KAAKC,GAAI3tB,EAAEotB,SAIlCptB,EAAE0tB,KAAKF,GAAKxtB,EAAE0tB,KAAKC,GACnBH,EAAIG,EAEJA,IAAM,EAEV3tB,EAAE0tB,KAAKF,GAAKC,GAMZI,EAAiB,SAAwB7tB,EAAG8tB,EAAOC,GAKnD,IAAIxC,EAEAyC,EAIAhyB,EAEAiyB,EAJAC,EAAK,EAMT,GAAmB,IAAfluB,EAAEgtB,SACF,GACIzB,EAAQvrB,EAAE0rB,YAAY1rB,EAAEmuB,MAAa,EAALD,IAAW,EAAKluB,EAAE0rB,YAAY1rB,EAAEmuB,MAAa,EAALD,EAAS,GACjFF,EAAKhuB,EAAE0rB,YAAY1rB,EAAEouB,MAAQF,GAC7BA,IACa,IAAT3C,EACAQ,EAAU/rB,EAAGguB,EAAIF,IAMjB9xB,EAAOouB,EAAa4D,GACpBjC,EAAU/rB,EAAGhE,EAAOytB,EAAW,EAAGqE,GAGpB,KADdG,EAAQpE,EAAY7tB,MAEhBgyB,GAAM1D,EAAYtuB,GAClB4vB,EAAU5rB,EAAGguB,EAAIC,IAGrB1C,IAEAvvB,EAAOsvB,EAAOC,GACdQ,EAAU/rB,EAAGhE,EAAM+xB,GAGL,KADdE,EAAQnE,EAAY9tB,MAEhBuvB,GAAQb,EAAU1uB,GAClB4vB,EAAU5rB,EAAGurB,EAAM0C,WAQtBC,EAAKluB,EAAEgtB,UAEpBjB,EAAU/rB,EArlBE,IAqlBY8tB,IAUxBO,EAAa,SAAoBruB,EAAGsuB,GAEpC,IAII/B,EACAY,EAIAz/B,EATAu+B,EAAOqC,EAAKnD,SACZoD,EAAQD,EAAKlD,UAAUR,YACvBK,EAAYqD,EAAKlD,UAAUH,UAC3BF,EAAQuD,EAAKlD,UAAUL,MAIvBM,GAAY,EAUhB,IAFArrB,EAAE4tB,SAAW,EACb5tB,EAAEwuB,SA5nBU,IA6nBPjC,EAAI,EAAGA,EAAIxB,EAAOwB,IAGf,IAFAN,EAAS,EAAJM,IAGLvsB,EAAE0tB,OAAO1tB,EAAE4tB,UAAYvC,EAAWkB,EAClCvsB,EAAEotB,MAAMb,GAAK,GAGbN,EAAS,EAAJM,EAAQ,GAET,EAQZ,KAAOvsB,EAAE4tB,SAAW,GAEhB3B,EAAY,GADZv+B,EAAOsS,EAAE0tB,OAAO1tB,EAAE4tB,UAAYvC,EAAW,IAAMA,EAAW,IAGtD,EACJrrB,EAAEotB,MAAM1/B,GAAQ,EAChBsS,EAAE8sB,UACE7B,IACAjrB,EAAE+sB,YAAcwB,EAAa,EAAP7gC,EAAW,IASzC,IAJA4gC,EAAKjD,SAAWA,EAIXkB,EAAIvsB,EAAE4tB,UAAY,EAEvBrB,GAAK,EAAGA,IACJgB,EAAWvtB,EAAGisB,EAAMM,GAKxB7+B,EAAOq9B,EAEP,GAGIwB,EAAIvsB,EAAE0tB,KAAK,GAEX1tB,EAAE0tB,KAAK,GAAK1tB,EAAE0tB,KAAK1tB,EAAE4tB,YAErBL,EAAWvtB,EAAGisB,EAAM,GAIpBkB,EAAIntB,EAAE0tB,KAAK,GAGX1tB,EAAE0tB,OAAO1tB,EAAEwuB,UAAYjC,EAEvBvsB,EAAE0tB,OAAO1tB,EAAEwuB,UAAYrB,EAEvBlB,EAAY,EAAPv+B,GAEDu+B,EAAS,EAAJM,GAEDN,EAAS,EAAJkB,GAEbntB,EAAEotB,MAAM1/B,IAASsS,EAAEotB,MAAMb,IAAMvsB,EAAEotB,MAAMD,GAAKntB,EAAEotB,MAAMb,GAAKvsB,EAAEotB,MAAMD,IAAM,EACvElB,EAAS,EAAJM,EAAQ,GAETN,EAAS,EAAJkB,EAAQ,GAETz/B,EAERsS,EAAE0tB,KAAK,GAAKhgC,IAEZ6/B,EAAWvtB,EAAGisB,EAAM,SAGfjsB,EAAE4tB,UAAY,GACvB5tB,EAAE0tB,OAAO1tB,EAAEwuB,UAAYxuB,EAAE0tB,KAAK,GAxiBjB,SAAoB1tB,EAAGsuB,GAEpC,IAOIG,EAEAlC,EACAY,EAEAb,EAEAoC,EAEAtzC,EAhBA6wC,EAAOqC,EAAKnD,SACZE,EAAWiD,EAAKjD,SAChBkD,EAAQD,EAAKlD,UAAUR,YACvBK,EAAYqD,EAAKlD,UAAUH,UAC3BgD,EAAQK,EAAKlD,UAAUP,WACvB5pC,EAAOqtC,EAAKlD,UAAUN,WACtBE,EAAasD,EAAKlD,UAAUJ,WAY5B2D,EAAW,EAEf,IAAKrC,EAAO,EAAGA,GAAQ1C,EAAU0C,IAC7BtsB,EAAEqsB,SAASC,GAAQ,EASvB,IAJAL,EAA0B,EAArBjsB,EAAE0tB,KAAK1tB,EAAEwuB,UAAgB,GAE1B,EAECC,EAAIzuB,EAAEwuB,SAAW,EAAGC,EAvMb,IAuM4BA,KAEpCnC,EACIL,EAEI,EAFCA,EAAS,GAFlBM,EAAIvsB,EAAE0tB,KAAKe,IAEW,GAGd,GAEA,GACGzD,IACPsB,EAAOtB,EACP2D,KAEJ1C,EAAS,EAAJM,EAAQ,GAETD,EAEAC,EAAIlB,IAIRrrB,EAAEqsB,SAASC,KACXoC,EAAQ,EACJnC,GAAKtrC,IACLytC,EAAQT,EAAM1B,EAAItrC,IAEtB7F,EAAI6wC,EAAS,EAAJM,GAETvsB,EAAE8sB,SAAW1xC,GAAKkxC,EAAOoC,GACrBzD,IACAjrB,EAAE+sB,YACE3xC,GACKmzC,EAAU,EAAJhC,EAAQ,GAEXmC,KAGpB,GAAiB,IAAbC,EAAJ,CAKA,EAAG,CAEC,IADArC,EAAOtB,EAAa,EACQ,IAArBhrB,EAAEqsB,SAASC,IACdA,IAEJtsB,EAAEqsB,SAASC,KAEXtsB,EAAEqsB,SAASC,EAAO,IAAM,EAExBtsB,EAAEqsB,SAASrB,KAIX2D,GAAY,QACPA,EAAW,GAMpB,IAAKrC,EAAOtB,EAAqB,IAATsB,EAAYA,IAEhC,IADAC,EAAIvsB,EAAEqsB,SAASC,GACF,IAANC,IACHY,EAAIntB,EAAE0tB,OAAOe,IACLpD,IAGJY,EAAS,EAAJkB,EAAQ,KAEbb,IAEAtsB,EAAE8sB,UACGR,EAAOL,EAAS,EAAJkB,EAAQ,IAEjBlB,EAAS,EAAJkB,GAEblB,EAAS,EAAJkB,EAAQ,GAETb,GAERC,MA2bRqC,CAAW5uB,EAAGsuB,GAEdlC,EAAUH,EAAMZ,EAAUrrB,EAAEqsB,WAM5BwC,EAAY,SAAmB7uB,EAAGisB,EAAMZ,GAKxC,IAAIkB,EAIAuC,EAFAC,GAAW,EAIXC,EAAU/C,EAAK,GAGfnnB,EAAQ,EAERmqB,EAAY,EAEZC,EAAY,EAUhB,IARgB,IAAZF,IACAC,EAAY,IACZC,EAAY,GAEhBjD,EAAsB,GAAhBZ,EAAW,GAAS,GAEtB,MAECkB,EAAI,EAAGA,GAAKlB,EAAUkB,IACvBuC,EAASE,EACTA,EAAU/C,EAAe,GAATM,EAAI,GAAS,KAEvBznB,EAAQmqB,GAAaH,IAAWE,IAG7BlqB,EAAQoqB,EACblvB,EAAE4sB,QAAiB,EAATkC,IAENhqB,EAEY,IAAXgqB,GACDA,IAAWC,GACX/uB,EAAE4sB,QAAiB,EAATkC,KAEd9uB,EAAE4sB,QAAQuC,OAELrqB,GAAS,GACd9E,EAAE4sB,QAAQwC,MAGVpvB,EAAE4sB,QAAQyC,MAEdvqB,EAAQ,EACRiqB,EAAUD,EACM,IAAZE,GACAC,EAAY,IACZC,EAAY,GAEPJ,IAAWE,GAChBC,EAAY,EACZC,EAAY,IAGZD,EAAY,EACZC,EAAY,KAQpBI,EAAY,SAAmBtvB,EAAGisB,EAAMZ,GAKxC,IAAIkB,EAIAuC,EAFAC,GAAW,EAIXC,EAAU/C,EAAK,GAGfnnB,EAAQ,EAERmqB,EAAY,EAEZC,EAAY,EAQhB,IAJgB,IAAZF,IACAC,EAAY,IACZC,EAAY,GAEX3C,EAAI,EAAGA,GAAKlB,EAAUkB,IAIvB,GAHAuC,EAASE,EACTA,EAAU/C,EAAe,GAATM,EAAI,GAAS,OAEvBznB,EAAQmqB,GAAaH,IAAWE,GAAtC,CAGK,GAAIlqB,EAAQoqB,EACb,GACInD,EAAU/rB,EAAG8uB,EAAQ9uB,EAAE4sB,eACN,KAAV9nB,QAEK,IAAXgqB,GACDA,IAAWC,IACXhD,EAAU/rB,EAAG8uB,EAAQ9uB,EAAE4sB,SACvB9nB,KAEJinB,EAAU/rB,EAl0BR,GAk0BoBA,EAAE4sB,SACxBhB,EAAU5rB,EAAG8E,EAAQ,EAAG,IAEnBA,GAAS,IACdinB,EAAU/rB,EAp0BN,GAo0BoBA,EAAE4sB,SAC1BhB,EAAU5rB,EAAG8E,EAAQ,EAAG,KAGxBinB,EAAU/rB,EAt0BJ,GAs0BoBA,EAAE4sB,SAC5BhB,EAAU5rB,EAAG8E,EAAQ,GAAI,IAE7BA,EAAQ,EACRiqB,EAAUD,EACM,IAAZE,GACAC,EAAY,IACZC,EAAY,GAEPJ,IAAWE,GAChBC,EAAY,EACZC,EAAY,IAGZD,EAAY,EACZC,EAAY,KAuHpBK,GAAmB,EAoBnBC,EAAmB,SAA0BxvB,EAAGupB,EAAKkG,EAAYC,GAMjE9D,EAAU5rB,EAAG,GAAuB0vB,EAAO,EAAI,GAAI,GAnhBtC,SAAoB1vB,EAAGupB,EAAKC,EAAKlrB,GAM9C2uB,EAAUjtB,GAEN1B,IACAktB,EAAUxrB,EAAGwpB,GACbgC,EAAUxrB,GAAIwpB,IAKlBxpB,EAAE0rB,YAAYn6B,IAAIyO,EAAE/pB,OAAO05C,SAASpG,EAAKA,EAAMC,GAAMxpB,EAAE2rB,SACvD3rB,EAAE2rB,SAAWnC,EAqgBboG,CAAW5vB,EAAGupB,EAAKkG,GAAY,IAmJ/BI,EA3KW,SAAkB7vB,GACxBuvB,IAppBY,WACjB,IAAIhD,EAEAD,EAEAt6C,EAEAgqB,EAEAuvB,EAEAc,EAAW,IAAI/zC,MAAMsxC,IAczB,IADA53C,EAAS,EACJgqB,EAAO,EAAGA,EAAO8zB,GAAkB9zB,IAEpC,IADAsuB,EAAYtuB,GAAQhqB,EACfu6C,EAAI,EAAGA,EAAI,GAAK1C,EAAY7tB,GAAOuwB,IACpCnC,EAAap4C,KAAYgqB,EAUjC,IAHAouB,EAAap4C,EAAS,GAAKgqB,EAE3BuvB,EAAO,EACFvvB,EAAO,EAAGA,EAAO,GAAIA,IAEtB,IADA0uB,EAAU1uB,GAAQuvB,EACbgB,EAAI,EAAGA,EAAI,GAAKzC,EAAY9tB,GAAOuwB,IACpCpC,EAAWoB,KAAUvvB,EAK7B,IAFAuvB,IAAS,EAEFvvB,EAAO2tB,EAAS3tB,IAEnB,IADA0uB,EAAU1uB,GAAQuvB,GAAQ,EACrBgB,EAAI,EAAGA,EAAI,GAAMzC,EAAY9tB,GAAQ,EAAIuwB,IAC1CpC,EAAW,IAAMoB,KAAUvvB,EAInC,IAAKswB,EAAO,EAAGA,GAAQ1C,EAAU0C,IAC7BD,EAASC,GAAQ,EAGrB,IADAC,EAAI,EACGA,GAAK,KACRtC,EAAiB,EAAJsC,EAAQ,GAEjB,EACJA,IACAF,EAAS,KAEb,KAAOE,GAAK,KACRtC,EAAiB,EAAJsC,EAAQ,GAEjB,EACJA,IACAF,EAAS,KAEb,KAAOE,GAAK,KACRtC,EAAiB,EAAJsC,EAAQ,GAEjB,EACJA,IACAF,EAAS,KAEb,KAAOE,GAAK,KACRtC,EAAiB,EAAJsC,EAAQ,GAEjB,EACJA,IACAF,EAAS,KAQb,IAFAD,EAAUnC,EAAcP,IAAa2C,GAEhCE,EAAI,EAAGA,EAAI5C,EAAS4C,IACrBrC,EAAiB,EAAJqC,EAAQ,GAEjB,EACJrC,EAAiB,EAAJqC,GAETL,EAAWK,EAAG,GAEtBhC,EAAgB,IAAII,EAAeV,EAAcJ,EAAaJ,IAAcC,EAASE,GACrFY,EAAgB,IAAIG,EAAeT,EAAcJ,EAAa,EAAGH,EAASC,GAC1Ea,EAAiB,IAAIE,EAAe,IAAIryC,MAAM,GAAIyxC,EAAc,EArbrD,GAWG,GA09BVgG,GACAR,GAAmB,GAEvBvvB,EAAEgwB,OAAS,IAAI9E,EAASlrB,EAAE0sB,UAAWnC,GACrCvqB,EAAEiwB,OAAS,IAAI/E,EAASlrB,EAAE2sB,UAAWnC,GACrCxqB,EAAEkwB,QAAU,IAAIhF,EAASlrB,EAAE4sB,QAASnC,GACpCzqB,EAAE8rB,OAAS,EACX9rB,EAAE6rB,SAAW,EAEbY,EAAWzsB,IAgKX6vB,EAJqBL,EAIrBK,EAnIkB,SAAyB7vB,EAAGupB,EAAKkG,EAAYC,GAM/D,IAAIS,EACAC,EAEAC,EAAc,EAGdrwB,EAAEswB,MAAQ,GAljCF,IAojCJtwB,EAAEuwB,KAAKC,YACPxwB,EAAEuwB,KAAKC,UAnGI,SAA0BxwB,GAK7C,IACIusB,EADAkE,EAAa,WAGjB,IAAKlE,EAAI,EAAGA,GAAK,GAAIA,IAAKkE,KAAgB,EACtC,GAAiB,EAAbA,GAGI,IAFJzwB,EAAE0sB,UAAc,EAAJH,GAGZ,OAj+BG,EAq+BX,GAEI,IAFAvsB,EAAE0sB,UAAU,KAKR,IAFJ1sB,EAAE0sB,UAAU,KAKR,IAFJ1sB,EAAE0sB,UAAU,IAGZ,OA7+BK,EA++BT,IAAKH,EAAI,GAAIA,EAAI9C,EAAU8C,IACvB,GAEI,IAFAvsB,EAAE0sB,UAAc,EAAJH,GAGZ,OAn/BC,EAy/BT,OA1/BW,EAujCgBmE,CAAiB1wB,IAGxCquB,EAAWruB,EAAGA,EAAEgwB,QAEhB3B,EAAWruB,EAAGA,EAAEiwB,QAQhBI,EAvLY,SAAuBrwB,GACvC,IAAIqwB,EAcJ,IAXAxB,EAAU7uB,EAAGA,EAAE0sB,UAAW1sB,EAAEgwB,OAAO3E,UACnCwD,EAAU7uB,EAAGA,EAAE2sB,UAAW3sB,EAAEiwB,OAAO5E,UAEnCgD,EAAWruB,EAAGA,EAAEkwB,SAQXG,EAAcM,GAAcN,GAAe,GAGxC,IAFArwB,EAAE4sB,QAAgC,EAAxB5C,EAASqG,GAAmB,GADKA,KAUnD,OAFArwB,EAAE8sB,SAAW,GAAKuD,EAAc,GAAK,EAAI,EAAI,EAEtCA,EA8JWO,CAAc5wB,GAE5BmwB,EAAYnwB,EAAE8sB,QAAU,EAAI,IAAO,GACnCsD,EAAepwB,EAAE+sB,WAAa,EAAI,IAAO,IAGtBoD,IACfA,EAAWC,IAKfD,EAAWC,EAAcX,EAAa,EAGtCA,EAAa,GAAKU,IAAqB,IAAT5G,EAQ9BiG,EAAiBxvB,EAAGupB,EAAKkG,EAAYC,GA7lC/B,IA+lCD1vB,EAAE2C,UAAwBytB,IAAgBD,GAC/CvE,EAAU5rB,EAAG,GAAuB0vB,EAAO,EAAI,GAAI,GACnD7B,EAAe7tB,EAAGiqB,EAAcC,KAGhC0B,EAAU5rB,EAAG,GAAoB0vB,EAAO,EAAI,GAAI,GArLnC,SAAwB1vB,EAAG6wB,EAAQC,EAAQC,GAE5D,IAAIC,EAWJ,IALApF,EAAU5rB,EAAG6wB,EAAS,IAAK,GAE3BjF,EAAU5rB,EAAG8wB,EAAS,EAAG,GACzBlF,EAAU5rB,EAAG+wB,EAAU,EAAG,GAErBC,EAAO,EAAGA,EAAOD,EAASC,IAE3BpF,EAAU5rB,EAAGA,EAAE4sB,QAAyB,EAAjB5C,EAASgH,GAAY,GAE5C,GAEJ1B,EAAUtvB,EAAGA,EAAE0sB,UAAWmE,EAAS,GAGnCvB,EAAUtvB,EAAGA,EAAE2sB,UAAWmE,EAAS,GAgK/BG,CAAejxB,EAAGA,EAAEgwB,OAAO3E,SAAW,EAAGrrB,EAAEiwB,OAAO5E,SAAW,EAAGgF,EAAc,GAC9ExC,EAAe7tB,EAAGA,EAAE0sB,UAAW1sB,EAAE2sB,YAKrCF,EAAWzsB,GACP0vB,GACAzC,EAAUjtB,IAgEd6vB,EAxDY,SAAmB7vB,EAAGurB,EAAMyC,GA6CxC,OAvCAhuB,EAAE0rB,YAAY1rB,EAAEmuB,MAAqB,EAAbnuB,EAAEgtB,UAAiBzB,IAAS,EAAK,IACzDvrB,EAAE0rB,YAAY1rB,EAAEmuB,MAAqB,EAAbnuB,EAAEgtB,SAAe,GAAY,IAAPzB,EAC9CvrB,EAAE0rB,YAAY1rB,EAAEouB,MAAQpuB,EAAEgtB,UAAiB,IAALgB,EACtChuB,EAAEgtB,WACW,IAATzB,EAEAvrB,EAAE0sB,UAAe,EAALsB,MAGZhuB,EAAEtpB,UAEF60C,IAKAvrB,EAAE0sB,UAA8C,GAAnCtC,EAAa4D,GAAMvE,EAAW,MAC3CzpB,EAAE2sB,UAAyB,EAAfrB,EAAOC,OAsBhBvrB,EAAEgtB,WAAahtB,EAAEkxB,YAAc,GAWtCrB,EA5IY,SAAmB7vB,GAC/B4rB,EAAU5rB,EAAGmxB,EAAmB,GAChCpF,EAAU/rB,EAv/BE,IAu/BYiqB,GAj3Bb,SAAkBjqB,GACV,KAAfA,EAAE6rB,UACFL,EAAUxrB,EAAGA,EAAE8rB,QACf9rB,EAAE8rB,OAAS,EACX9rB,EAAE6rB,SAAW,GAER7rB,EAAE6rB,UAAY,IACnB7rB,EAAE0rB,YAAY1rB,EAAE2rB,WAAwB,IAAX3rB,EAAE8rB,OAC/B9rB,EAAE8rB,SAAW,EACb9rB,EAAE6rB,UAAY,GAy2BlBuF,CAASpxB,IAuLTqxB,EAnBU,SAAiBC,EAAO/H,EAAKC,EAAK+H,GAI5C,IAHA,IAAIC,EAAc,MAARF,EAAkB,EACxBG,EAAOH,IAAU,GAAM,MAAU,EACjC/E,EAAI,EACO,IAAR/C,GAAW,CAKdA,GADA+C,EAAI/C,EAAM,IAAO,IAAOA,EAExB,GAEIiI,EAAMA,GADND,EAAMA,EAAKjI,EAAIgI,KAAU,GACR,UACVhF,GACXiF,GAAM,MACNC,GAAM,MAEV,OAAOD,EAAMC,GAAM,GAAM,GAoCzBC,EAAW,IAAIC,YAZH,WAGZ,IAFA,IAAI3F,EACA4F,EAAQ,GACHrF,EAAI,EAAGA,EAAI,IAAKA,IAAK,CAC1BP,EAAIO,EACJ,IAAK,IAAIiB,EAAI,EAAGA,EAAI,EAAGA,IACnBxB,EAAQ,EAAJA,EAAQ,WAAcA,IAAM,EAAKA,IAAM,EAE/C4F,EAAMrF,GAAKP,EAEf,OAAO4F,EAEoBC,IAU3BC,EATQ,SAAeC,EAAKxI,EAAKC,EAAK+H,GACtC,IAAIS,EAAIN,EACJt0C,EAAMm0C,EAAM/H,EAChBuI,IAAQ,EACR,IAAK,IAAIh9C,EAAIw8C,EAAKx8C,EAAIqI,EAAKrI,IACvBg9C,EAAOA,IAAQ,EAAKC,EAAmB,KAAhBD,EAAMxI,EAAIx0C,KAErC,OAAc,EAAPg9C,GAoBPjqC,EAAW,CACX,EAAG,kBAEH,EAAG,aAEH,EAAG,GAEH,KAAM,aAEN,KAAM,eAEN,KAAM,aAEN,KAAM,sBAEN,KAAM,eAEN,KAAM,wBAoBNmqC,EAAY,CAEZC,WAAY,EACZC,gBAAiB,EACjBC,aAAc,EACdC,aAAc,EACdC,SAAU,EACVC,QAAS,EACTC,QAAS,EAITC,KAAM,EACNC,aAAc,EACdC,YAAa,EACbC,SAAU,EACVC,gBAAiB,EACjBC,cAAe,EACfC,aAAc,EACdC,aAAc,EAGdC,iBAAkB,EAClBC,aAAc,EACdC,mBAAoB,EACpBC,uBAAwB,EACxBC,WAAY,EACZC,eAAgB,EAChBC,MAAO,EACPC,QAAS,EACTC,mBAAoB,EAEpBC,SAAU,EACVC,OAAQ,EAERC,UAAW,EAEXC,WAAY,GAmBZC,EAAajE,EACbkE,EAAqBlE,EACrBmE,EAAoBnE,EACpBoE,EAAcpE,EACdqE,EAAcrE,EAGdqC,EAAaD,EAAUC,WACvBC,EAAkBF,EAAUE,gBAC5BE,EAAeJ,EAAUI,aACzBC,GAAWL,EAAUK,SACrBC,GAAUN,EAAUM,QACpBE,GAAOR,EAAUQ,KACjBC,GAAeT,EAAUS,aACzBG,GAAiBZ,EAAUY,eAC3BC,GAAeb,EAAUa,aACzBE,GAAcf,EAAUe,YACxBI,GAAwBnB,EAAUmB,sBAClCC,GAAapB,EAAUoB,WACvBC,GAAiBrB,EAAUqB,eAC3BC,GAAQtB,EAAUsB,MAClBY,GAAYlC,EAAUuB,QAEtBY,GAAcnC,EAAU2B,UACxBC,GAAa5B,EAAU4B,WAsBvBQ,GAAc,IACdC,GAAgBD,IAMhBE,GAAa,IACbC,GAAa,IACbC,GAAe,IAUf71C,GAAM,SAAa2xC,EAAMmE,GAEzB,OADAnE,EAAKnpB,IAAMtf,EAAS4sC,GACbA,GAEP1D,GAAO,SAAc51C,GACrB,OAAQA,GAAK,IAAMA,EAAI,EAAI,EAAI,IAE/Bu5C,GAAS,SAAcpL,GAEvB,IADA,IAAIC,EAAMD,EAAIv3C,SACLw3C,GAAO,GACZD,EAAIC,GAAO,GAQfoL,GALY,SAAmB50B,EAAG60B,EAAMl5C,GACxC,OAASk5C,GAAQ70B,EAAE80B,WAAcn5C,GAAQqkB,EAAE+0B,WAW3CC,GAAgB,SAAuBzE,GACvC,IAAIvwB,EAAIuwB,EAAKv1B,MACTwuB,EAAMxpB,EAAE2rB,QACRnC,EAAM+G,EAAK0E,YACXzL,EAAM+G,EAAK0E,WAEH,IAARzL,IAGJ+G,EAAK2E,OAAO3jC,IAAIyO,EAAE0rB,YAAYiE,SAAS3vB,EAAEm1B,YAAan1B,EAAEm1B,YAAc3L,GAAM+G,EAAK6E,UACjF7E,EAAK6E,UAAY5L,EACjBxpB,EAAEm1B,aAAe3L,EACjB+G,EAAK8E,WAAa7L,EAClB+G,EAAK0E,WAAazL,EAClBxpB,EAAE2rB,SAAWnC,EACK,IAAdxpB,EAAE2rB,UACF3rB,EAAEm1B,YAAc,KAGpBG,GAAmB,SAA0Bt1B,EAAG0vB,GAChDsE,EAAkBh0B,EAAGA,EAAEu1B,aAAe,EAAIv1B,EAAEu1B,aAAe,EAAGv1B,EAAEw1B,SAAWx1B,EAAEu1B,YAAa7F,GAC1F1vB,EAAEu1B,YAAcv1B,EAAEw1B,SAClBR,GAAch1B,EAAEuwB,OAEhBkF,GAAW,SAAkBz1B,EAAG8d,GAChC9d,EAAE0rB,YAAY1rB,EAAE2rB,WAAa7N,GAO7B4X,GAAc,SAAqB11B,EAAG8d,GAGtC9d,EAAE0rB,YAAY1rB,EAAE2rB,WAAc7N,IAAM,EAAK,IACzC9d,EAAE0rB,YAAY1rB,EAAE2rB,WAAiB,IAAJ7N,GAsC7B6X,GAAgB,SAAuB31B,EAAG41B,GAC1C,IAIIxnC,EAEAo7B,EANAqM,EAAe71B,EAAE81B,iBAEjBC,EAAO/1B,EAAEw1B,SAMTQ,EAAWh2B,EAAEi2B,YAEbC,EAAal2B,EAAEk2B,WAEfplC,EAAQkP,EAAEw1B,SAAWx1B,EAAEm2B,OAAS7B,GAAgBt0B,EAAEw1B,UAAYx1B,EAAEm2B,OAAS7B,IAAiB,EAE1F8B,EAAOp2B,EAAE/pB,OACTogD,EAAQr2B,EAAEs2B,OACVzB,EAAO70B,EAAE60B,KAIT0B,EAASv2B,EAAEw1B,SAAWnB,GACtBmC,EAAYJ,EAAKL,EAAOC,EAAW,GACnCS,EAAWL,EAAKL,EAAOC,GAMvBh2B,EAAEi2B,aAAej2B,EAAE02B,aACnBb,IAAiB,GAKjBK,EAAal2B,EAAE22B,YACfT,EAAal2B,EAAE22B,WAEnB,GAWI,GAAIP,GATJhoC,EAAQwnC,GASSI,KAAcS,GAC3BL,EAAKhoC,EAAQ4nC,EAAW,KAAOQ,GAC/BJ,EAAKhoC,KAAWgoC,EAAKL,IACrBK,IAAOhoC,KAAWgoC,EAAKL,EAAO,GAHlC,CAYAA,GAAQ,EACR3nC,IAIA,UAESgoC,IAAOL,KAAUK,IAAOhoC,IAC7BgoC,IAAOL,KAAUK,IAAOhoC,IACxBgoC,IAAOL,KAAUK,IAAOhoC,IACxBgoC,IAAOL,KAAUK,IAAOhoC,IACxBgoC,IAAOL,KAAUK,IAAOhoC,IACxBgoC,IAAOL,KAAUK,IAAOhoC,IACxBgoC,IAAOL,KAAUK,IAAOhoC,IACxBgoC,IAAOL,KAAUK,IAAOhoC,IACxB2nC,EAAOQ,GAGX,GAFA/M,EAAM6K,IAAekC,EAASR,GAC9BA,EAAOQ,EAASlC,GACZ7K,EAAMwM,EAAU,CAGhB,GAFAh2B,EAAE42B,YAAchB,EAChBI,EAAWxM,EACPA,GAAO0M,EACP,MAEJM,EAAYJ,EAAKL,EAAOC,EAAW,GACnCS,EAAWL,EAAKL,EAAOC,YAErBJ,EAAYf,EAAKe,EAAYS,IAAUvlC,GAA4B,KAAjB+kC,GAC5D,OAAIG,GAAYh2B,EAAE22B,UACPX,EAEJh2B,EAAE22B,WAYTE,GAAc,SAAqB72B,GACnC,IACI82B,EACAvK,EACAY,EACA4J,EACAv5B,EA3IyB+yB,EAAMhH,EAAKpsC,EAAOgL,EAC3CqhC,EAqIAwN,EAAUh3B,EAAEm2B,OAMhB,EAAG,CAiBC,GAhBAY,EAAO/2B,EAAEi3B,YAAcj3B,EAAE22B,UAAY32B,EAAEw1B,SAgBnCx1B,EAAEw1B,UAAYwB,GAAWA,EAAU1C,IAAgB,CACnDt0B,EAAE/pB,OAAOsb,IAAIyO,EAAE/pB,OAAO05C,SAASqH,EAASA,EAAUA,GAAU,GAC5Dh3B,EAAE42B,aAAeI,EACjBh3B,EAAEw1B,UAAYwB,EAEdh3B,EAAEu1B,aAAeyB,EAQjBF,EADAvK,EAAIvsB,EAAEk3B,UAEN,GACI/J,EAAIntB,EAAEte,OAAOo1C,GACb92B,EAAEte,KAAKo1C,GAAK3J,GAAK6J,EAAU7J,EAAI6J,EAAU,UAClCzK,GAEXuK,EADAvK,EAAIyK,EAEJ,GACI7J,EAAIntB,EAAE60B,OAAOiC,GACb92B,EAAE60B,KAAKiC,GAAK3J,GAAK6J,EAAU7J,EAAI6J,EAAU,UAIlCzK,GACXwK,GAAQC,EAEZ,GAAwB,IAApBh3B,EAAEuwB,KAAK4G,SACP,MAiBJ,GA5MyB5G,EAyMZvwB,EAAEuwB,KAzMgBhH,EAyMVvpB,EAAE/pB,OAzMakH,EAyML6iB,EAAEw1B,SAAWx1B,EAAE22B,UAzMHxuC,EAyMc4uC,EAxMzDvN,OAAAA,GAAAA,EAAM+G,EAAK4G,UACLhvC,IACNqhC,EAAMrhC,GAsMNokC,EApMQ,IAAR/C,EACO,GAEX+G,EAAK4G,UAAY3N,EACjBD,EAAIh4B,IAAIg/B,EAAK90B,MAAMk0B,SAASY,EAAK6G,QAAS7G,EAAK6G,QAAU5N,GAAMrsC,GACvC,IAApBozC,EAAKv1B,MAAMq8B,KACX9G,EAAKe,MAAQD,EAAUd,EAAKe,MAAO/H,EAAKC,EAAKrsC,GAEpB,IAApBozC,EAAKv1B,MAAMq8B,OAChB9G,EAAKe,MAAQQ,EAAQvB,EAAKe,MAAO/H,EAAKC,EAAKrsC,IAE/CozC,EAAK6G,SAAW5N,EAChB+G,EAAK+G,UAAY9N,EACVA,GAwLHxpB,EAAE22B,WAAapK,EAEXvsB,EAAE22B,UAAY32B,EAAEu3B,QAtSV,EA6SN,IANA/5B,EAAMwC,EAAEw1B,SAAWx1B,EAAEu3B,OACrBv3B,EAAEw3B,MAAQx3B,EAAE/pB,OAAOunB,GAEnBwC,EAAEw3B,MAAQ5C,GAAK50B,EAAGA,EAAEw3B,MAAOx3B,EAAE/pB,OAAOunB,EAAM,IAGnCwC,EAAEu3B,SAELv3B,EAAEw3B,MAAQ5C,GAAK50B,EAAGA,EAAEw3B,MAAOx3B,EAAE/pB,OAAOunB,EA/SlC,EA+SsD,IACxDwC,EAAE60B,KAAKr3B,EAAMwC,EAAEs2B,QAAUt2B,EAAEte,KAAKse,EAAEw3B,OAClCx3B,EAAEte,KAAKse,EAAEw3B,OAASh6B,EAClBA,IACAwC,EAAEu3B,WACEv3B,EAAE22B,UAAY32B,EAAEu3B,OApTlB,aA4TLv3B,EAAE22B,UAAYrC,IAAqC,IAApBt0B,EAAEuwB,KAAK4G,WAiI/CM,GAAe,SAAsBz3B,EAAGpY,GAKxC,IAJA,IAAI8vC,EAEAC,IAEK,CAML,GAAI33B,EAAE22B,UAAYrC,GAAe,CAE7B,GADAuC,GAAY72B,GACRA,EAAE22B,UAAYrC,IAAiB1sC,IAAUsqC,EACzC,OAhcG,EAkcP,GAAoB,IAAhBlyB,EAAE22B,UACF,MA6BR,GAtBAe,EAAY,EAER13B,EAAE22B,WAvdI,IAydN32B,EAAEw3B,MAAQ5C,GAAK50B,EAAGA,EAAEw3B,MAAOx3B,EAAE/pB,OAAO+pB,EAAEw1B,SAzdhC,EAydyD,IAC/DkC,EAAY13B,EAAE60B,KAAK70B,EAAEw1B,SAAWx1B,EAAEs2B,QAAUt2B,EAAEte,KAAKse,EAAEw3B,OACrDx3B,EAAEte,KAAKse,EAAEw3B,OAASx3B,EAAEw1B,UAMN,IAAdkC,GAEA13B,EAAEw1B,SAAWkC,GAAa13B,EAAEm2B,OAAS7B,KAKrCt0B,EAAE43B,aAAejC,GAAc31B,EAAG03B,IAGlC13B,EAAE43B,cA3eI,EAofN,GALAD,EAAS1D,EAAYj0B,EAAGA,EAAEw1B,SAAWx1B,EAAE42B,YAAa52B,EAAE43B,aA/ehD,GAgfN53B,EAAE22B,WAAa32B,EAAE43B,aAIb53B,EAAE43B,cAAgB53B,EAAE63B,gBAEpB73B,EAAE22B,WAtfA,EAsf0B,CAC5B32B,EAAE43B,eAEF,GACI53B,EAAEw1B,WAEFx1B,EAAEw3B,MAAQ5C,GAAK50B,EAAGA,EAAEw3B,MAAOx3B,EAAE/pB,OAAO+pB,EAAEw1B,SA5fxC,EA4fiE,IAC/DkC,EAAY13B,EAAE60B,KAAK70B,EAAEw1B,SAAWx1B,EAAEs2B,QAAUt2B,EAAEte,KAAKse,EAAEw3B,OACrDx3B,EAAEte,KAAKse,EAAEw3B,OAASx3B,EAAEw1B,eAKM,KAAnBx1B,EAAE43B,cACb53B,EAAEw1B,gBAGFx1B,EAAEw1B,UAAYx1B,EAAE43B,aAChB53B,EAAE43B,aAAe,EACjB53B,EAAEw3B,MAAQx3B,EAAE/pB,OAAO+pB,EAAEw1B,UAErBx1B,EAAEw3B,MAAQ5C,GAAK50B,EAAGA,EAAEw3B,MAAOx3B,EAAE/pB,OAAO+pB,EAAEw1B,SAAW,SAYrDmC,EAAS1D,EAAYj0B,EAAG,EAAGA,EAAE/pB,OAAO+pB,EAAEw1B,WACtCx1B,EAAE22B,YACF32B,EAAEw1B,WAEN,GAAImC,IAEArC,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WACP,OAphBG,EA0hBf,OADAj1B,EAAEu3B,OAASv3B,EAAEw1B,SAAWsC,EAAkB93B,EAAEw1B,SAAWsC,EACnDlwC,IAAU0qC,IAEVgD,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,UAzhBK,EAEH,GA6hBbj1B,EAAEgtB,WAEFsI,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WAtiBA,EAEC,GAgjBhB8C,GAAe,SAAsB/3B,EAAGpY,GAOxC,IANA,IAAI8vC,EAEAC,EAEAK,IAEK,CAML,GAAIh4B,EAAE22B,UAAYrC,GAAe,CAE7B,GADAuC,GAAY72B,GACRA,EAAE22B,UAAYrC,IAAiB1sC,IAAUsqC,EACzC,OAlkBG,EAokBP,GAAoB,IAAhBlyB,EAAE22B,UACF,MA8CR,GAvCAe,EAAY,EAER13B,EAAE22B,WAzlBI,IA2lBN32B,EAAEw3B,MAAQ5C,GAAK50B,EAAGA,EAAEw3B,MAAOx3B,EAAE/pB,OAAO+pB,EAAEw1B,SA3lBhC,EA2lByD,IAC/DkC,EAAY13B,EAAE60B,KAAK70B,EAAEw1B,SAAWx1B,EAAEs2B,QAAUt2B,EAAEte,KAAKse,EAAEw3B,OACrDx3B,EAAEte,KAAKse,EAAEw3B,OAASx3B,EAAEw1B,UAKxBx1B,EAAEi2B,YAAcj2B,EAAE43B,aAClB53B,EAAEi4B,WAAaj4B,EAAE42B,YACjB52B,EAAE43B,aAAeE,EACC,IAAdJ,GAEA13B,EAAEi2B,YAAcj2B,EAAE63B,gBAClB73B,EAAEw1B,SAAWkC,GAAa13B,EAAEm2B,OAAS7B,KAOrCt0B,EAAE43B,aAAejC,GAAc31B,EAAG03B,GAE9B13B,EAAE43B,cAAgB,IACjB53B,EAAE2C,WAAa0wB,IAlnBd,IAknB6BrzB,EAAE43B,cAAgC53B,EAAEw1B,SAAWx1B,EAAE42B,YAAc,QAM9F52B,EAAE43B,aAAeE,IAMrB93B,EAAEi2B,aA9nBI,GA8nB0Bj2B,EAAE43B,cAAgB53B,EAAEi2B,YAAa,CACjE+B,EAAah4B,EAAEw1B,SAAWx1B,EAAE22B,UA/nBtB,EAooBNgB,EAAS1D,EAAYj0B,EAAGA,EAAEw1B,SAAW,EAAIx1B,EAAEi4B,WAAYj4B,EAAEi2B,YApoBnD,GA0oBNj2B,EAAE22B,WAAa32B,EAAEi2B,YAAc,EAC/Bj2B,EAAEi2B,aAAe,EACjB,KACUj2B,EAAEw1B,UAAYwC,IAEhBh4B,EAAEw3B,MAAQ5C,GAAK50B,EAAGA,EAAEw3B,MAAOx3B,EAAE/pB,OAAO+pB,EAAEw1B,SA/oBxC,EA+oBiE,IAC/DkC,EAAY13B,EAAE60B,KAAK70B,EAAEw1B,SAAWx1B,EAAEs2B,QAAUt2B,EAAEte,KAAKse,EAAEw3B,OACrDx3B,EAAEte,KAAKse,EAAEw3B,OAASx3B,EAAEw1B,gBAGC,KAAlBx1B,EAAEi2B,aAIb,GAHAj2B,EAAEk4B,gBAAkB,EACpBl4B,EAAE43B,aAAeE,EACjB93B,EAAEw1B,WACEmC,IAEArC,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WACP,OAjpBD,OAspBN,GAAIj1B,EAAEk4B,iBAeP,IARAP,EAAS1D,EAAYj0B,EAAG,EAAGA,EAAE/pB,OAAO+pB,EAAEw1B,SAAW,MAG7CF,GAAiBt1B,GAAG,GAGxBA,EAAEw1B,WACFx1B,EAAE22B,YACuB,IAArB32B,EAAEuwB,KAAK0E,UACP,OAtqBG,OA6qBPj1B,EAAEk4B,gBAAkB,EACpBl4B,EAAEw1B,WACFx1B,EAAE22B,YAUV,OAPI32B,EAAEk4B,kBAGFP,EAAS1D,EAAYj0B,EAAG,EAAGA,EAAE/pB,OAAO+pB,EAAEw1B,SAAW,IACjDx1B,EAAEk4B,gBAAkB,GAExBl4B,EAAEu3B,OAASv3B,EAAEw1B,SAAWsC,EAAkB93B,EAAEw1B,SAAWsC,EACnDlwC,IAAU0qC,IAEVgD,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,UAxrBK,EAEH,GA4rBbj1B,EAAEgtB,WAEFsI,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WArsBA,EAEC,GAw2BpB,SAASkD,GAAOC,EAAaC,EAAUC,EAAaC,EAAWroD,GAC3D0F,KAAKwiD,YAAcA,EACnBxiD,KAAKyiD,SAAWA,EAChBziD,KAAK0iD,YAAcA,EACnB1iD,KAAK2iD,UAAYA,EACjB3iD,KAAK1F,KAAOA,EAEhB,IAAIsoD,GAAsB,CAEtB,IAAIL,GAAO,EAAG,EAAG,EAAG,GAnhBH,SAAwBn4B,EAAGpY,GAI5C,IAAI6wC,EAAiB,MAKrB,IAJIA,EAAiBz4B,EAAE04B,iBAAmB,IACtCD,EAAiBz4B,EAAE04B,iBAAmB,KAGjC,CAEL,GAAI14B,EAAE22B,WAAa,EAAG,CAQlB,GADAE,GAAY72B,GACQ,IAAhBA,EAAE22B,WAAmB/uC,IAAUsqC,EAC/B,OApXG,EAsXP,GAAoB,IAAhBlyB,EAAE22B,UACF,MAKR32B,EAAEw1B,UAAYx1B,EAAE22B,UAChB32B,EAAE22B,UAAY,EAEd,IAAIgC,EAAY34B,EAAEu1B,YAAckD,EAChC,IAAmB,IAAfz4B,EAAEw1B,UAAkBx1B,EAAEw1B,UAAYmD,KAElC34B,EAAE22B,UAAY32B,EAAEw1B,SAAWmD,EAC3B34B,EAAEw1B,SAAWmD,EAEbrD,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WACP,OAvYG,EA8YX,GAAIj1B,EAAEw1B,SAAWx1B,EAAEu1B,aAAev1B,EAAEm2B,OAAS7B,KAEzCgB,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WACP,OAlZG,EAwZf,OADAj1B,EAAEu3B,OAAS,EACP3vC,IAAU0qC,IAEVgD,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,UAvZK,EAEH,IA2Zbj1B,EAAEw1B,SAAWx1B,EAAEu1B,cAEfD,GAAiBt1B,GAAG,GAChBA,EAAEuwB,KAAK0E,WApaA,MAq3Bf,IAAIkD,GAAO,EAAG,EAAG,EAAG,EAAGV,IAEvB,IAAIU,GAAO,EAAG,EAAG,GAAI,EAAGV,IAExB,IAAIU,GAAO,EAAG,EAAG,GAAI,GAAIV,IAEzB,IAAIU,GAAO,EAAG,EAAG,GAAI,GAAIJ,IAEzB,IAAII,GAAO,EAAG,GAAI,GAAI,GAAIJ,IAE1B,IAAII,GAAO,EAAG,GAAI,IAAK,IAAKJ,IAE5B,IAAII,GAAO,EAAG,GAAI,IAAK,IAAKJ,IAE5B,IAAII,GAAO,GAAI,IAAK,IAAK,KAAMJ,IAE/B,IAAII,GAAO,GAAI,IAAK,IAAK,KAAMJ,KAwBnC,SAASa,KACLhjD,KAAK26C,KAAO,KAEZ36C,KAAK0I,OAAS,EAEd1I,KAAK81C,YAAc,KAEnB91C,KAAK8iD,iBAAmB,EAExB9iD,KAAKu/C,YAAc,EAEnBv/C,KAAK+1C,QAAU,EAEf/1C,KAAKyhD,KAAO,EAEZzhD,KAAKijD,OAAS,KAEdjjD,KAAKkjD,QAAU,EAEfljD,KAAK+jB,OAASk6B,GAEdj+C,KAAKmjD,YAAc,EAEnBnjD,KAAKugD,OAAS,EAEdvgD,KAAKojD,OAAS,EAEdpjD,KAAK0gD,OAAS,EAEd1gD,KAAKK,OAAS,KAOdL,KAAKqhD,YAAc,EAInBrhD,KAAKi/C,KAAO,KAKZj/C,KAAK8L,KAAO,KAEZ9L,KAAK4hD,MAAQ,EAEb5hD,KAAKshD,UAAY,EAEjBthD,KAAKqjD,UAAY,EAEjBrjD,KAAKm/C,UAAY,EAEjBn/C,KAAKk/C,WAAa,EAMlBl/C,KAAK2/C,YAAc,EAInB3/C,KAAKgiD,aAAe,EAEpBhiD,KAAKqiD,WAAa,EAElBriD,KAAKsiD,gBAAkB,EAEvBtiD,KAAK4/C,SAAW,EAEhB5/C,KAAKghD,YAAc,EAEnBhhD,KAAK+gD,UAAY,EAEjB/gD,KAAKqgD,YAAc,EAInBrgD,KAAKkgD,iBAAmB,EAKxBlgD,KAAKiiD,eAAiB,EAWtBjiD,KAAK06C,MAAQ,EAEb16C,KAAK+sB,SAAW,EAEhB/sB,KAAK8gD,WAAa,EAElB9gD,KAAKsgD,WAAa,EASlBtgD,KAAK82C,UAAY,IAAIwM,YAAYC,MACjCvjD,KAAK+2C,UAAY,IAAIuM,YAAY,KACjCtjD,KAAKg3C,QAAU,IAAIsM,YAAY,IAC/BvE,GAAO/+C,KAAK82C,WACZiI,GAAO/+C,KAAK+2C,WACZgI,GAAO/+C,KAAKg3C,SACZh3C,KAAKo6C,OAAS,KAEdp6C,KAAKq6C,OAAS,KAEdr6C,KAAKs6C,QAAU,KAGft6C,KAAKy2C,SAAW,IAAI6M,YAAYE,IAGhCxjD,KAAK83C,KAAO,IAAIwL,YAAY,KAE5BvE,GAAO/+C,KAAK83C,MACZ93C,KAAKg4C,SAAW,EAEhBh4C,KAAK44C,SAAW,EAKhB54C,KAAKw3C,MAAQ,IAAI8L,YAAY,KAC7BvE,GAAO/+C,KAAKw3C,OAGZx3C,KAAKw4C,MAAQ,EAEbx4C,KAAKs7C,YAAc,EAmBnBt7C,KAAKo3C,SAAW,EAEhBp3C,KAAKu4C,MAAQ,EAKbv4C,KAAKk3C,QAAU,EAEfl3C,KAAKm3C,WAAa,EAElBn3C,KAAKc,QAAU,EAEfd,KAAK2hD,OAAS,EAEd3hD,KAAKk2C,OAAS,EAIdl2C,KAAKi2C,SAAW,EAapB,IAAIwN,GAAmB,SAA0B9I,GAC7C,IAAKA,IAASA,EAAKv1B,MACf,OAAOpc,GAAI2xC,EAAMsC,IAErBtC,EAAK+G,SAAW/G,EAAK8E,UAAY,EACjC9E,EAAKC,UAAY4D,GACjB,IAAIp0B,EAAIuwB,EAAKv1B,MAcb,OAbAgF,EAAE2rB,QAAU,EACZ3rB,EAAEm1B,YAAc,EACZn1B,EAAEq3B,KAAO,IACTr3B,EAAEq3B,MAAQr3B,EAAEq3B,MAGhBr3B,EAAE1hB,OAAS0hB,EAAEq3B,KApnCA,GAonCoB7C,GACjCjE,EAAKe,MACU,IAAXtxB,EAAEq3B,KACI,EACA,EACVr3B,EAAE+4B,WAAa7G,EACf4B,EAAW9zB,GACJyyB,IAEP6G,GAAe,SAAsB/I,GACrC,IA5O2BvwB,EA4OvBu5B,EAAMF,GAAiB9I,GAI3B,OAHIgJ,IAAQ9G,MA7OezyB,EA8OfuwB,EAAKv1B,OA7Ofi8B,YAAc,EAAIj3B,EAAEm2B,OAEtBxB,GAAO30B,EAAEte,MAGTse,EAAE63B,eAAiBW,GAAoBx4B,EAAEswB,OAAO+H,SAChDr4B,EAAE02B,WAAa8B,GAAoBx4B,EAAEswB,OAAO8H,YAC5Cp4B,EAAEk2B,WAAasC,GAAoBx4B,EAAEswB,OAAOgI,YAC5Ct4B,EAAE81B,iBAAmB0C,GAAoBx4B,EAAEswB,OAAOiI,UAClDv4B,EAAEw1B,SAAW,EACbx1B,EAAEu1B,YAAc,EAChBv1B,EAAE22B,UAAY,EACd32B,EAAEu3B,OAAS,EACXv3B,EAAE43B,aAAe53B,EAAEi2B,YAAc6B,EACjC93B,EAAEk4B,gBAAkB,EACpBl4B,EAAEw3B,MAAQ,GAgOH+B,GAYPC,GAAe,SAAsBjJ,EAAMD,EAAO32B,EAAQ8/B,EAAYC,EAAU/2B,GAChF,IAAK4tB,EAED,OAAOsC,GAEX,IAAIwE,EAAO,EAcX,GAbI/G,IAAU8C,KACV9C,EAAQ,GAERmJ,EAAa,GAEbpC,EAAO,EACPoC,GAAcA,GAETA,EAAa,KAClBpC,EAAO,EAEPoC,GAAc,IAEdC,EAAW,GACXA,EAzrCY,GA0rCZ//B,IAAWk6B,IACX4F,EAAa,GACbA,EAAa,IACbnJ,EAAQ,GACRA,EAAQ,GACR3tB,EAAW,GACXA,EAAWwxB,GACX,OAAOv1C,GAAI2xC,EAAMsC,IAEF,IAAf4G,IACAA,EAAa,GAGjB,IAAIz5B,EAAI,IAAI44B,GA6BZ,OA5BArI,EAAKv1B,MAAQgF,EACbA,EAAEuwB,KAAOA,EACTvwB,EAAEq3B,KAAOA,EACTr3B,EAAE64B,OAAS,KACX74B,EAAEg5B,OAASS,EACXz5B,EAAEm2B,OAAS,GAAKn2B,EAAEg5B,OAClBh5B,EAAEs2B,OAASt2B,EAAEm2B,OAAS,EACtBn2B,EAAEi5B,UAAYS,EAAW,EACzB15B,EAAEk3B,UAAY,GAAKl3B,EAAEi5B,UACrBj5B,EAAE+0B,UAAY/0B,EAAEk3B,UAAY,EAC5Bl3B,EAAE80B,eAAiB90B,EAAEi5B,UA/rCP,EA+rCiC,GA/rCjC,GAgsCdj5B,EAAE/pB,OAAS,IAAIinB,WAAsB,EAAX8C,EAAEm2B,QAC5Bn2B,EAAEte,KAAO,IAAIw3C,YAAYl5B,EAAEk3B,WAC3Bl3B,EAAE60B,KAAO,IAAIqE,YAAYl5B,EAAEm2B,QAE3Bn2B,EAAEkxB,YAAc,GAAMwI,EAAW,EAEjC15B,EAAE04B,iBAAmC,EAAhB14B,EAAEkxB,YAIvBlxB,EAAE0rB,YAAc,IAAIxuB,WAAW8C,EAAE04B,kBAEjC14B,EAAEmuB,MAAQ,EAAInuB,EAAEkxB,YAChBlxB,EAAEouB,MAAQ,EAAUpuB,EAAEkxB,YACtBlxB,EAAEswB,MAAQA,EACVtwB,EAAE2C,SAAWA,EACb3C,EAAErG,OAASA,EACJ2/B,GAAa/I,IAybpBoJ,GAhBiBH,GAgBjBG,GAlgBmB,SAA0BpJ,EAAM7uC,GACnD,OAAK6uC,GAASA,EAAKv1B,MAGK,IAApBu1B,EAAKv1B,MAAMq8B,KACJxE,IAEXtC,EAAKv1B,MAAM69B,OAASn3C,EACb+wC,IANII,IAggBX8G,GApbU,SAAiBpJ,EAAM3oC,GACjC,IAAIgyC,EACAC,EACJ,IAAKtJ,IAASA,EAAKv1B,OAASpT,EAAQ2qC,IAAW3qC,EAAQ,EACnD,OAAO2oC,EAAO3xC,GAAI2xC,EAAMsC,IAAkBA,GAE9C,IAAI7yB,EAAIuwB,EAAKv1B,MACb,IAAKu1B,EAAK2E,SAAY3E,EAAK90B,OAA2B,IAAlB80B,EAAK4G,UAAoBn3B,EAAE1hB,SAAWm2C,IAAgB7sC,IAAU0qC,GAChG,OAAO1zC,GAAI2xC,EAAyB,IAAnBA,EAAK0E,UAAkBjC,GAAcH,IAE1D7yB,EAAEuwB,KAAOA,EAET,IAAIuJ,EAAY95B,EAAE+4B,WAGlB,GAFA/4B,EAAE+4B,WAAanxC,EA/tCF,KAiuCToY,EAAE1hB,OACF,GAAe,IAAX0hB,EAAEq3B,KAEF9G,EAAKe,MAAQ,EACbmE,GAASz1B,EAAG,IACZy1B,GAASz1B,EAAG,KACZy1B,GAASz1B,EAAG,GACPA,EAAE64B,QAYHpD,GAASz1B,GAAIA,EAAE64B,OAAOxU,KAAO,EAAI,IAC5BrkB,EAAE64B,OAAOkB,KAAO,EAAI,IACnB/5B,EAAE64B,OAAO5K,MAAY,EAAJ,IACjBjuB,EAAE64B,OAAOjoD,KAAW,EAAJ,IAChBovB,EAAE64B,OAAOtrC,QAAc,GAAJ,IACzBkoC,GAASz1B,EAAmB,IAAhBA,EAAE64B,OAAOtpB,MACrBkmB,GAASz1B,EAAIA,EAAE64B,OAAOtpB,MAAQ,EAAK,KACnCkmB,GAASz1B,EAAIA,EAAE64B,OAAOtpB,MAAQ,GAAM,KACpCkmB,GAASz1B,EAAIA,EAAE64B,OAAOtpB,MAAQ,GAAM,KACpCkmB,GAASz1B,EAAe,IAAZA,EAAEswB,MAAc,EAAItwB,EAAE2C,UAAY2wB,IAAkBtzB,EAAEswB,MAAQ,EAAI,EAAI,GAClFmF,GAASz1B,EAAiB,IAAdA,EAAE64B,OAAOmB,IACjBh6B,EAAE64B,OAAO5K,OAASjuB,EAAE64B,OAAO5K,MAAMj8C,SACjCyjD,GAASz1B,EAA2B,IAAxBA,EAAE64B,OAAO5K,MAAMj8C,QAC3ByjD,GAASz1B,EAAIA,EAAE64B,OAAO5K,MAAMj8C,QAAU,EAAK,MAE3CguB,EAAE64B,OAAOkB,OACTxJ,EAAKe,MAAQQ,EAAQvB,EAAKe,MAAOtxB,EAAE0rB,YAAa1rB,EAAE2rB,QAAS,IAE/D3rB,EAAE84B,QAAU,EACZ94B,EAAE1hB,OAtwCA,KAyuCFm3C,GAASz1B,EAAG,GACZy1B,GAASz1B,EAAG,GACZy1B,GAASz1B,EAAG,GACZy1B,GAASz1B,EAAG,GACZy1B,GAASz1B,EAAG,GACZy1B,GAASz1B,EAAe,IAAZA,EAAEswB,MAAc,EAAItwB,EAAE2C,UAAY2wB,IAAkBtzB,EAAEswB,MAAQ,EAAI,EAAI,GAClFmF,GAASz1B,EAjuCX,GAkuCEA,EAAE1hB,OAASk2C,QAyBd,CACD,IAAIl2B,EAAUu1B,IAAe7zB,EAAEg5B,OAAS,GAAM,IAAO,EAcrD16B,IAZI0B,EAAE2C,UAAY2wB,IAAkBtzB,EAAEswB,MAAQ,EAC5B,EAETtwB,EAAEswB,MAAQ,EACD,EAEG,IAAZtwB,EAAEswB,MACO,EAGA,IAEO,EACN,IAAftwB,EAAEw1B,WACFl3B,GA5xCE,IA8xCNA,GAAU,GAAMA,EAAS,GACzB0B,EAAE1hB,OAASk2C,GACXkB,GAAY11B,EAAG1B,GAEI,IAAf0B,EAAEw1B,WACFE,GAAY11B,EAAGuwB,EAAKe,QAAU,IAC9BoE,GAAY11B,EAAgB,MAAbuwB,EAAKe,QAExBf,EAAKe,MAAQ,EAGrB,GAvyCc,KAuyCVtxB,EAAE1hB,OACF,GAAI0hB,EAAE64B,OAAO5K,MAEX,CAGE,IAFA2L,EAAM55B,EAAE2rB,QAED3rB,EAAE84B,SAAmC,MAAxB94B,EAAE64B,OAAO5K,MAAMj8C,UAC3BguB,EAAE2rB,UAAY3rB,EAAE04B,mBACZ14B,EAAE64B,OAAOkB,MAAQ/5B,EAAE2rB,QAAUiO,IAC7BrJ,EAAKe,MAAQQ,EAAQvB,EAAKe,MAAOtxB,EAAE0rB,YAAa1rB,EAAE2rB,QAAUiO,EAAKA,IAErE5E,GAAczE,GACdqJ,EAAM55B,EAAE2rB,QACJ3rB,EAAE2rB,UAAY3rB,EAAE04B,oBAIxBjD,GAASz1B,EAA+B,IAA5BA,EAAE64B,OAAO5K,MAAMjuB,EAAE84B,UAC7B94B,EAAE84B,UAEF94B,EAAE64B,OAAOkB,MAAQ/5B,EAAE2rB,QAAUiO,IAC7BrJ,EAAKe,MAAQQ,EAAQvB,EAAKe,MAAOtxB,EAAE0rB,YAAa1rB,EAAE2rB,QAAUiO,EAAKA,IAEjE55B,EAAE84B,UAAY94B,EAAE64B,OAAO5K,MAAMj8C,SAC7BguB,EAAE84B,QAAU,EACZ94B,EAAE1hB,OA/zCD,SAm0CL0hB,EAAE1hB,OAn0CG,GAs0Cb,GAt0Ca,KAs0CT0hB,EAAE1hB,OACF,GAAI0hB,EAAE64B,OAAOjoD,KAEX,CACEgpD,EAAM55B,EAAE2rB,QAGR,EAAG,CACC,GAAI3rB,EAAE2rB,UAAY3rB,EAAE04B,mBACZ14B,EAAE64B,OAAOkB,MAAQ/5B,EAAE2rB,QAAUiO,IAC7BrJ,EAAKe,MAAQQ,EAAQvB,EAAKe,MAAOtxB,EAAE0rB,YAAa1rB,EAAE2rB,QAAUiO,EAAKA,IAErE5E,GAAczE,GACdqJ,EAAM55B,EAAE2rB,QACJ3rB,EAAE2rB,UAAY3rB,EAAE04B,kBAAkB,CAClCmB,EAAM,EACN,MAIJA,EADA75B,EAAE84B,QAAU94B,EAAE64B,OAAOjoD,KAAKoB,OACoB,IAAxCguB,EAAE64B,OAAOjoD,KAAKmG,WAAWipB,EAAE84B,WAG3B,EAEVrD,GAASz1B,EAAG65B,SACC,IAARA,GACL75B,EAAE64B,OAAOkB,MAAQ/5B,EAAE2rB,QAAUiO,IAC7BrJ,EAAKe,MAAQQ,EAAQvB,EAAKe,MAAOtxB,EAAE0rB,YAAa1rB,EAAE2rB,QAAUiO,EAAKA,IAEzD,IAARC,IACA75B,EAAE84B,QAAU,EACZ94B,EAAE1hB,OAr2CE,SAy2CR0hB,EAAE1hB,OAz2CM,GA42ChB,GA52CgB,KA42CZ0hB,EAAE1hB,OACF,GAAI0hB,EAAE64B,OAAOtrC,QAEX,CACEqsC,EAAM55B,EAAE2rB,QAGR,EAAG,CACC,GAAI3rB,EAAE2rB,UAAY3rB,EAAE04B,mBACZ14B,EAAE64B,OAAOkB,MAAQ/5B,EAAE2rB,QAAUiO,IAC7BrJ,EAAKe,MAAQQ,EAAQvB,EAAKe,MAAOtxB,EAAE0rB,YAAa1rB,EAAE2rB,QAAUiO,EAAKA,IAErE5E,GAAczE,GACdqJ,EAAM55B,EAAE2rB,QACJ3rB,EAAE2rB,UAAY3rB,EAAE04B,kBAAkB,CAClCmB,EAAM,EACN,MAIJA,EADA75B,EAAE84B,QAAU94B,EAAE64B,OAAOtrC,QAAQvb,OACoB,IAA3CguB,EAAE64B,OAAOtrC,QAAQxW,WAAWipB,EAAE84B,WAG9B,EAEVrD,GAASz1B,EAAG65B,SACC,IAARA,GACL75B,EAAE64B,OAAOkB,MAAQ/5B,EAAE2rB,QAAUiO,IAC7BrJ,EAAKe,MAAQQ,EAAQvB,EAAKe,MAAOtxB,EAAE0rB,YAAa1rB,EAAE2rB,QAAUiO,EAAKA,IAEzD,IAARC,IACA75B,EAAE1hB,OAASi2C,SAIfv0B,EAAE1hB,OAASi2C,GAoBnB,GAjBIv0B,EAAE1hB,SAAWi2C,KACTv0B,EAAE64B,OAAOkB,MACL/5B,EAAE2rB,QAAU,EAAI3rB,EAAE04B,kBAClB1D,GAAczE,GAEdvwB,EAAE2rB,QAAU,GAAK3rB,EAAE04B,mBACnBjD,GAASz1B,EAAgB,IAAbuwB,EAAKe,OACjBmE,GAASz1B,EAAIuwB,EAAKe,OAAS,EAAK,KAChCf,EAAKe,MAAQ,EACbtxB,EAAE1hB,OAASk2C,KAIfx0B,EAAE1hB,OAASk2C,IAID,IAAdx0B,EAAE2rB,SAEF,GADAqJ,GAAczE,GACS,IAAnBA,EAAK0E,UAQL,OADAj1B,EAAE+4B,YAAc,EACTtG,QAOV,GAAsB,IAAlBlC,EAAK4G,UAAkBnG,GAAKppC,IAAUopC,GAAK8I,IAAclyC,IAAU0qC,GACxE,OAAO1zC,GAAI2xC,EAAMyC,IAGrB,GAAIhzB,EAAE1hB,SAAWm2C,IAAkC,IAAlBlE,EAAK4G,SAClC,OAAOv4C,GAAI2xC,EAAMyC,IAIrB,GAAsB,IAAlBzC,EAAK4G,UAAkC,IAAhBn3B,EAAE22B,WAAoB/uC,IAAUsqC,GAAclyB,EAAE1hB,SAAWm2C,GAAe,CACjG,IAAIwF,EAASj6B,EAAE2C,WAAa2wB,GAvoBjB,SAAsBtzB,EAAGpY,GAGxC,IAFA,IAAI+vC,IAEK,CAEL,GAAoB,IAAhB33B,EAAE22B,YACFE,GAAY72B,GACQ,IAAhBA,EAAE22B,WAAiB,CACnB,GAAI/uC,IAAUsqC,EACV,OA5zBD,EA8zBH,MAUR,GALAlyB,EAAE43B,aAAe,EAEjBD,EAAS1D,EAAYj0B,EAAG,EAAGA,EAAE/pB,OAAO+pB,EAAEw1B,WACtCx1B,EAAE22B,YACF32B,EAAEw1B,WACEmC,IAEArC,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WACP,OA50BG,EAk1Bf,OADAj1B,EAAEu3B,OAAS,EACP3vC,IAAU0qC,IAEVgD,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,UAj1BK,EAEH,GAq1Bbj1B,EAAEgtB,WAEFsI,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WA91BA,EAEC,EAy7CNiF,CAAal6B,EAAGpY,GAChBoY,EAAE2C,WAAa4wB,GA3uBX,SAAqBvzB,EAAGpY,GAStC,IARA,IAAI+vC,EAEA9C,EAEAkB,EACAQ,EAEAH,EAAOp2B,EAAE/pB,SACJ,CAKL,GAAI+pB,EAAE22B,WAAatC,GAAa,CAE5B,GADAwC,GAAY72B,GACRA,EAAE22B,WAAatC,IAAezsC,IAAUsqC,EACxC,OAluBG,EAouBP,GAAoB,IAAhBlyB,EAAE22B,UACF,MAMR,GADA32B,EAAE43B,aAAe,EACb53B,EAAE22B,WAtvBI,GAsvBwB32B,EAAEw1B,SAAW,IAE3CX,EAAOuB,EADPL,EAAO/1B,EAAEw1B,SAAW,MAEPY,IAAOL,IAASlB,IAASuB,IAAOL,IAASlB,IAASuB,IAAOL,GAAO,CACzEQ,EAASv2B,EAAEw1B,SAAWnB,GACtB,UAESQ,IAASuB,IAAOL,IACrBlB,IAASuB,IAAOL,IAChBlB,IAASuB,IAAOL,IAChBlB,IAASuB,IAAOL,IAChBlB,IAASuB,IAAOL,IAChBlB,IAASuB,IAAOL,IAChBlB,IAASuB,IAAOL,IAChBlB,IAASuB,IAAOL,IAChBA,EAAOQ,GACXv2B,EAAE43B,aAAevD,IAAekC,EAASR,GACrC/1B,EAAE43B,aAAe53B,EAAE22B,YACnB32B,EAAE43B,aAAe53B,EAAE22B,WAqB/B,GAhBI32B,EAAE43B,cA7wBI,GAgxBND,EAAS1D,EAAYj0B,EAAG,EAAGA,EAAE43B,aAhxBvB,GAixBN53B,EAAE22B,WAAa32B,EAAE43B,aACjB53B,EAAEw1B,UAAYx1B,EAAE43B,aAChB53B,EAAE43B,aAAe,IAMjBD,EAAS1D,EAAYj0B,EAAG,EAAGA,EAAE/pB,OAAO+pB,EAAEw1B,WACtCx1B,EAAE22B,YACF32B,EAAEw1B,YAEFmC,IAEArC,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WACP,OAtxBG,EA4xBf,OADAj1B,EAAEu3B,OAAS,EACP3vC,IAAU0qC,IAEVgD,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,UA3xBK,EAEH,GA+xBbj1B,EAAEgtB,WAEFsI,GAAiBt1B,GAAG,GACK,IAArBA,EAAEuwB,KAAK0E,WAxyBA,EAEC,EA27CFkF,CAAYn6B,EAAGpY,GACf4wC,GAAoBx4B,EAAEswB,OAAOpgD,KAAK8vB,EAAGpY,GAI/C,GA97CgB,IA27CZqyC,GAz7CS,IAy7CuBA,IAChCj6B,EAAE1hB,OAASm2C,IAh8CJ,IAk8CPwF,GA97CY,IA87CeA,EAK3B,OAJuB,IAAnB1J,EAAK0E,YACLj1B,EAAE+4B,YAAc,GAGbtG,GASX,GA98CY,IA88CRwH,IACIryC,IAAUuqC,EACV+B,EAAYl0B,GAEPpY,IAAU2qC,KAEfwB,EAAmB/zB,EAAG,EAAG,GAAG,GAIxBpY,IAAUyqC,IAGVsC,GAAO30B,EAAEte,MACW,IAAhBse,EAAE22B,YACF32B,EAAEw1B,SAAW,EACbx1B,EAAEu1B,YAAc,EAChBv1B,EAAEu3B,OAAS,KAIvBvC,GAAczE,GACS,IAAnBA,EAAK0E,WAGL,OAFAj1B,EAAE+4B,YAAc,EAETtG,GAKnB,OAAI7qC,IAAU0qC,GACHG,GAEPzyB,EAAEq3B,MAAQ,EACH3E,IAGI,IAAX1yB,EAAEq3B,MACF5B,GAASz1B,EAAgB,IAAbuwB,EAAKe,OACjBmE,GAASz1B,EAAIuwB,EAAKe,OAAS,EAAK,KAChCmE,GAASz1B,EAAIuwB,EAAKe,OAAS,GAAM,KACjCmE,GAASz1B,EAAIuwB,EAAKe,OAAS,GAAM,KACjCmE,GAASz1B,EAAmB,IAAhBuwB,EAAK+G,UACjB7B,GAASz1B,EAAIuwB,EAAK+G,UAAY,EAAK,KACnC7B,GAASz1B,EAAIuwB,EAAK+G,UAAY,GAAM,KACpC7B,GAASz1B,EAAIuwB,EAAK+G,UAAY,GAAM,OAGpC5B,GAAY11B,EAAGuwB,EAAKe,QAAU,IAC9BoE,GAAY11B,EAAgB,MAAbuwB,EAAKe,QAExB0D,GAAczE,GAIVvwB,EAAEq3B,KAAO,IACTr3B,EAAEq3B,MAAQr3B,EAAEq3B,MAGK,IAAdr3B,EAAE2rB,QAAgB8G,GAAOC,KAoHhCiH,GAlHa,SAAoBpJ,GACjC,IAAKA,IAEAA,EAAKv1B,MAGN,OAAO63B,GAEX,IAAIv0C,EAASiyC,EAAKv1B,MAAM1c,OACxB,OA7hDa,KA6hDTA,GA5hDU,KA6hDVA,GA5hDS,KA6hDTA,GA5hDY,KA6hDZA,GACAA,IAAWi2C,IACXj2C,IAAWk2C,IACXl2C,IAAWm2C,GACJ71C,GAAI2xC,EAAMsC,KAErBtC,EAAKv1B,MAAQ,KACN1c,IAAWk2C,GAAa51C,GAAI2xC,EAAMuC,IAAgBL,KA+FzDkH,GAzFuB,SAA8BpJ,EAAM6J,GAC3D,IAAIC,EAAaD,EAAWpoD,OAC5B,IAAKu+C,IAEAA,EAAKv1B,MAGN,OAAO63B,GAEX,IAAI7yB,EAAIuwB,EAAKv1B,MACTq8B,EAAOr3B,EAAEq3B,KACb,GAAa,IAATA,GAAwB,IAATA,GAxjDN,KAwjDoBr3B,EAAE1hB,QAA0B0hB,EAAE22B,UAC3D,OAAO9D,GAUX,GAPa,IAATwE,IAEA9G,EAAKe,MAAQD,EAAUd,EAAKe,MAAO8I,EAAYC,EAAY,IAE/Dr6B,EAAEq3B,KAAO,EAGLgD,GAAcr6B,EAAEm2B,OAAQ,CACX,IAATkB,IAGA1C,GAAO30B,EAAEte,MACTse,EAAEw1B,SAAW,EACbx1B,EAAEu1B,YAAc,EAChBv1B,EAAEu3B,OAAS,GAIf,IAAI+C,EAAU,IAAIp9B,WAAW8C,EAAEm2B,QAC/BmE,EAAQ/oC,IAAI6oC,EAAWzK,SAAS0K,EAAar6B,EAAEm2B,OAAQkE,GAAa,GACpED,EAAaE,EACbD,EAAar6B,EAAEm2B,OAGnB,IAAIoE,EAAQhK,EAAK4G,SACblgC,EAAOs5B,EAAK6G,QACZ37B,EAAQ80B,EAAK90B,MAKjB,IAJA80B,EAAK4G,SAAWkD,EAChB9J,EAAK6G,QAAU,EACf7G,EAAK90B,MAAQ2+B,EACbvD,GAAY72B,GACLA,EAAE22B,WA/lDK,GA+lDqB,CAC/B,IAAIn5B,EAAMwC,EAAEw1B,SACRjJ,EAAIvsB,EAAE22B,UAAY,EACtB,GAEI32B,EAAEw3B,MAAQ5C,GAAK50B,EAAGA,EAAEw3B,MAAOx3B,EAAE/pB,OAAOunB,EApmD9B,EAomDkD,IACxDwC,EAAE60B,KAAKr3B,EAAMwC,EAAEs2B,QAAUt2B,EAAEte,KAAKse,EAAEw3B,OAClCx3B,EAAEte,KAAKse,EAAEw3B,OAASh6B,EAClBA,YACO+uB,GACXvsB,EAAEw1B,SAAWh4B,EACbwC,EAAE22B,UAAYmB,EACdjB,GAAY72B,GAYhB,OAVAA,EAAEw1B,UAAYx1B,EAAE22B,UAChB32B,EAAEu1B,YAAcv1B,EAAEw1B,SAClBx1B,EAAEu3B,OAASv3B,EAAE22B,UACb32B,EAAE22B,UAAY,EACd32B,EAAE43B,aAAe53B,EAAEi2B,YAAc6B,EACjC93B,EAAEk4B,gBAAkB,EACpB3H,EAAK6G,QAAUngC,EACfs5B,EAAK90B,MAAQA,EACb80B,EAAK4G,SAAWoD,EAChBv6B,EAAEq3B,KAAOA,EACF5E,IAsDX,IADA,IAAI+H,GAAW,IAAIt9B,WAAW,KACrBu9B,GAAI,EAAGA,GAAI,IAAKA,KACrBD,GAASC,IAAKA,IAAK,IAAM,EAAIA,IAAK,IAAM,EAAIA,IAAK,IAAM,EAAIA,IAAK,IAAM,EAAIA,IAAK,IAAM,EAAI,EAE7FD,GAAS,KAAOA,GAAS,KAAO,EA6ChC,IAAIE,GA1BJ,WAEI9kD,KAAK6lB,MAAQ,KACb7lB,KAAKwhD,QAAU,EAEfxhD,KAAKuhD,SAAW,EAEhBvhD,KAAK0hD,SAAW,EAEhB1hD,KAAKs/C,OAAS,KACdt/C,KAAKw/C,SAAW,EAEhBx/C,KAAKq/C,UAAY,EAEjBr/C,KAAKy/C,UAAY,EAEjBz/C,KAAKwxB,IAAM,GAGXxxB,KAAKolB,MAAQ,KAEbplB,KAAK46C,UAAY,EAGjB56C,KAAK07C,MAAQ,GAIbl+C,GAAWX,OAAOC,UAAUU,SAG5BunD,GAAe1I,EAAUC,WACzBE,GAAeH,EAAUG,aACzBwI,GAAiB3I,EAAUI,aAC3BwI,GAAa5I,EAAUK,SACvBwI,GAAS7I,EAAUQ,KACnBsI,GAAiB9I,EAAUS,aAC3BsI,GAA0B/I,EAAUmB,sBACpC6H,GAAuBhJ,EAAUwB,mBACjCyH,GAAejJ,EAAU4B,WAiF7B,SAASsH,KACLvlD,KAAKxE,QAAU,CACXk/C,MAAO0K,GACPrhC,OAAQuhC,GACRE,UAAW,MACX3B,WAAY,GACZC,SAAU,EACV/2B,SAAUs4B,IAEd,IAAII,EAAMzlD,KAAKxE,QACXiqD,EAAIC,KAAOD,EAAI5B,WAAa,EAC5B4B,EAAI5B,YAAc4B,EAAI5B,WAEjB4B,EAAIE,MAAQF,EAAI5B,WAAa,GAAK4B,EAAI5B,WAAa,KACxD4B,EAAI5B,YAAc,IAEtB7jD,KAAKgJ,IAAM,EACXhJ,KAAKwxB,IAAM,GACXxxB,KAAK4lD,OAAQ,EACb5lD,KAAK6lD,OAAS,GACd7lD,KAAK26C,KAAO,IAAImK,GAChB9kD,KAAK26C,KAAK0E,UAAY,EACtB,IAAI32C,EAASq7C,GAAuB/jD,KAAK26C,KAAM8K,EAAI/K,MAAO+K,EAAI1hC,OAAQ0hC,EAAI5B,WAAY4B,EAAI3B,SAAU2B,EAAI14B,UACxG,GAAIrkB,IAAWw8C,GACX,MAAM,IAAIzgD,MAAMyN,EAASxJ,IAK7B,GAHI+8C,EAAI/8B,QACJq7B,GAA2B/jD,KAAK26C,KAAM8K,EAAI/8B,QAE1C+8B,EAAIjB,WAAY,CAChB,IAAIsB,EAQJ,GANIA,EADkC,yBAAlCtoD,GAASR,KAAKyoD,EAAIjB,YACX,IAAIl9B,WAAWm+B,EAAIjB,YAGnBiB,EAAIjB,YAEf97C,EAASq7C,GAA+B/jD,KAAK26C,KAAMmL,MACpCZ,GACX,MAAM,IAAIzgD,MAAMyN,EAASxJ,IAE7B1I,KAAK+lD,WAAY,GA4KzB,OAnJAR,GAAQzoD,UAAUhC,KAAO,SAAUiL,EAAMigD,GACrC,IAEIt9C,EACAu9C,EAHAtL,EAAO36C,KAAK26C,KACZ6K,EAAYxlD,KAAKxE,QAAQgqD,UAG7B,GAAIxlD,KAAK4lD,MACL,OAAO,EAgBX,IAbIK,EADAD,MAAiBA,EACHA,GAGe,IAAfA,EAAsBf,GAAaF,GAEzB,yBAAxBvnD,GAASR,KAAK+I,GACd40C,EAAK90B,MAAQ,IAAIyB,WAAWvhB,GAG5B40C,EAAK90B,MAAQ9f,EAEjB40C,EAAK6G,QAAU,EACf7G,EAAK4G,SAAW5G,EAAK90B,MAAMzpB,SAOvB,GALuB,IAAnBu+C,EAAK0E,YACL1E,EAAK2E,OAAS,IAAIh4B,WAAWk+B,GAC7B7K,EAAK6E,SAAW,EAChB7E,EAAK0E,UAAYmG,IAEhBS,IAAgBzJ,IAAgByJ,IAAgBjB,KAAmBrK,EAAK0E,WAAa,EACtFr/C,KAAKkmD,OAAOvL,EAAK2E,OAAOvF,SAAS,EAAGY,EAAK6E,WACzC7E,EAAK0E,UAAY,MAFrB,CAMA,IADA32C,EAASq7C,GAAkBpJ,EAAMsL,MAClBd,GAOX,OANIxK,EAAK6E,SAAW,GAChBx/C,KAAKkmD,OAAOvL,EAAK2E,OAAOvF,SAAS,EAAGY,EAAK6E,WAE7C92C,EAASq7C,GAAqB/jD,KAAK26C,MACnC36C,KAAK2lB,MAAMjd,GACX1I,KAAK4lD,OAAQ,EACNl9C,IAAWw8C,GAEtB,GAAuB,IAAnBvK,EAAK0E,WAIT,GAAI4G,EAAc,GAAKtL,EAAK6E,SAAW,EACnCx/C,KAAKkmD,OAAOvL,EAAK2E,OAAOvF,SAAS,EAAGY,EAAK6E,WACzC7E,EAAK0E,UAAY,OAGrB,GAAsB,IAAlB1E,EAAK4G,SACL,WATAvhD,KAAKkmD,OAAOvL,EAAK2E,QAYzB,OAAO,GASXiG,GAAQzoD,UAAUopD,OAAS,SAAUC,GACjCnmD,KAAK6lD,OAAO/qD,KAAKqrD,IAWrBZ,GAAQzoD,UAAU6oB,MAAQ,SAAUjd,GAE5BA,IAAWw8C,KACXllD,KAAKtB,OAvTb,SAAuBmnD,GAGnB,IADA,IAAIjS,EAAM,EACDz0C,EAAI,EAAGinD,EAAIP,EAAOzpD,OAAQ+C,EAAIinD,EAAGjnD,IACtCy0C,GAAOiS,EAAO1mD,GAAG/C,OAGrB,IADA,IAAIsC,EAAS,IAAI4oB,WAAWssB,GACnB13C,EAAK,EAAGy/C,EAAM,EAAG0K,EAAKR,EAAOzpD,OAAQF,EAAKmqD,EAAInqD,IAAM,CACzD,IAAIiqD,EAAQN,EAAO3pD,GACnBwC,EAAOid,IAAIwqC,EAAOxK,GAClBA,GAAOwK,EAAM/pD,OAEjB,OAAOsC,EA2SW4nD,CAActmD,KAAK6lD,SAErC7lD,KAAK6lD,OAAS,GACd7lD,KAAKgJ,IAAMN,EACX1I,KAAKwxB,IAAMxxB,KAAK26C,KAAKnpB,KA+DlB,CAAE+zB,QAASA,GAASlJ,UAAWA,EAAWkK,WA5DjD,SAAoB3+B,GAChB,GAA2B,mBAAhBxV,aAA8BA,YAAYtV,UAAUuV,OAC3D,OAAO,IAAID,aAAcC,OAAOuV,GAEpC,IAAI+rB,EACAyC,EACAoQ,EACAC,EACAtnD,EACAunD,EAAU9+B,EAAIxrB,OACduqD,EAAU,EAEd,IAAKF,EAAQ,EAAGA,EAAQC,EAASD,IAER,QAAZ,OADTrQ,EAAIxuB,EAAIzmB,WAAWslD,MACYA,EAAQ,EAAIC,GAEjB,QAAZ,OADVF,EAAK5+B,EAAIzmB,WAAWslD,EAAQ,OAExBrQ,EAAI,OAAYA,EAAI,OAAW,KAAOoQ,EAAK,OAC3CC,KAGRE,GAAWvQ,EAAI,IAAO,EAAIA,EAAI,KAAQ,EAAIA,EAAI,MAAU,EAAI,EAKhE,IAFAzC,EAAM,IAAIrsB,WAAWq/B,GAEhBxnD,EAAI,EAAGsnD,EAAQ,EAAGtnD,EAAIwnD,EAASF,IAEX,QAAZ,OADTrQ,EAAIxuB,EAAIzmB,WAAWslD,MACYA,EAAQ,EAAIC,GAEjB,QAAZ,OADVF,EAAK5+B,EAAIzmB,WAAWslD,EAAQ,OAExBrQ,EAAI,OAAYA,EAAI,OAAW,KAAOoQ,EAAK,OAC3CC,KAGJrQ,EAAI,IAEJzC,EAAIx0C,KAAOi3C,EAENA,EAAI,MAETzC,EAAIx0C,KAAO,IAAQi3C,IAAM,EACzBzC,EAAIx0C,KAAO,IAAY,GAAJi3C,GAEdA,EAAI,OAETzC,EAAIx0C,KAAO,IAAQi3C,IAAM,GACzBzC,EAAIx0C,KAAO,IAASi3C,IAAM,EAAK,GAC/BzC,EAAIx0C,KAAO,IAAY,GAAJi3C,IAInBzC,EAAIx0C,KAAO,IAAQi3C,IAAM,GACzBzC,EAAIx0C,KAAO,IAASi3C,IAAM,GAAM,GAChCzC,EAAIx0C,KAAO,IAASi3C,IAAM,EAAK,GAC/BzC,EAAIx0C,KAAO,IAAY,GAAJi3C,GAG3B,OAAOzC,IA7gHFiT,GAAmBrB,EAAU1mD,EAAG0mD,QAASlJ,EAAYx9C,EAAGw9C,UAAWkK,EAAa1nD,EAAG0nD,WACxFM,EAAU,IAAItB,EACdlT,EAAU,EAmCd,SAASyU,EAAS/gD,GAEd,IAAIghD,EAAaR,EAAWxgD,GAG5B,OAFA8gD,EAAQ/rD,KAAKisD,EAAY1K,EAAUG,cACnCnK,GAAW0U,EAAW3qD,OACf2qD,EAAW3qD,OAvCtBgE,KAAKkB,iBAAiB,UAAWW,GAAQ,SAAUT,GAC/C,IAAIuE,EAAOvE,EAAMuE,KACjB,OAAQA,EAAK+Y,QACT,IAAK,OACD1e,KAAKmyC,YAAY,CACb5tC,KAAM,gBAEV,MACJ,IAAK,QACD,IAAIytC,EAAoB0U,EAAS/gD,EAAKA,MACtC3F,KAAKmyC,YAAY,CACb5tC,KAAM,QACN6Z,GAAIzY,EAAKyY,GACT8zB,eAAgBuU,EAAQhB,OAAOmB,QAAO,SAAU7yC,EAAOgyC,GAAS,OAAOhyC,EAAQgyC,EAAM/pD,SAAW,GAChGg2C,kBAAmBA,IAEvB,MAEJ,IAAK,QACGA,EAAoBrsC,EAAKA,KAAO+gD,EAAS/gD,EAAKA,MAAQ,EAC1D8gD,EAAQ/rD,KAAK,GAAIuhD,EAAUK,UAC3Bt8C,KAAKmyC,YAAY,CACb5tC,KAAM,UACN6Z,GAAIzY,EAAKyY,GACT9f,OAAQmoD,EAAQnoD,OAChB0zC,kBAAmBA,EACnBC,QAASA,IAEbwU,EAAU,IAAItB,EACdlT,EAAU,SAjC1BpwC,GEPJ,IAAImjB,GAAQ,CAAE1c,OAAQ,GACf,SAASu+C,GAAmB3kD,EAAU4kD,GAEzC,YADgC,IAA5BA,IAAsCA,EAA0B5T,IAC5DluB,GAAM1c,QACV,KAAK,EACD0c,GAAQ,CAAE1c,OAAQ,EAAiBmY,UAAW,CAACve,IA0BpD,SAA8B4kD,QACD,IAA5BA,IAAsCA,EAA0B5T,IACpE,IACI,IAAI6T,EAAWD,IACfC,EAAS7lD,iBAAiB,QAASW,GAAQmlD,KAC3CD,EAAS7lD,iBAAiB,UAAWW,IAAQ,SAAUpD,GACnD,IAeW8yC,EAfP5rC,EAAOlH,EAAGkH,KACI,YAAdA,EAAKpB,KACLyiD,GAAQrhD,EAAK/M,OAEM,gBAAd+M,EAAKpB,OAWHgtC,EAVOwV,EAWL,IAAjB/hC,GAAM1c,SACN0c,GAAMvE,UAAUrnB,SAAQ,SAAU8I,GAAY,OAAOA,EAASqvC,MAC9DvsB,GAAQ,CAAE1c,OAAQ,EAAqBipC,OAAQA,SAV/CwV,EAAS5U,YAAY,CAAEzzB,OAAQ,SAGnC,MAAO9lB,GACHouD,GAAQpuD,IA3CJquD,CAAqBH,GACrB,MACJ,KAAK,EACD9hC,GAAMvE,UAAU/lB,KAAKwH,GACrB,MACJ,KAAK,EACDA,IACA,MACJ,KAAK,EACDA,EAAS8iB,GAAMusB,SA2C3B,SAASyV,GAAQpuD,GACQ,IAAjBosB,GAAM1c,QACN/P,EAAQK,MAAM,yFAA0FA,GACpGA,aAAiBsuD,OAAUtuD,aAAiByL,OAAS3F,EAAS9F,EAAM+B,QAAS,2BAC7EpC,EAAQK,MAAM,4HAIdqP,GAAmBrP,GAEvBosB,GAAMvE,UAAUrnB,SAAQ,SAAU8I,GAAY,OAAOA,OACrD8iB,GAAQ,CAAE1c,OAAQ,IAGlBL,GAAmBrP,GCpE3B,ICiB6BwK,GAAcusB,GACnCw3B,GDlBJptB,GEHG,SAAyBqtB,EAAoBC,GAEhD,QAD+B,IAA3BA,IAAqCA,EAAyBR,IAC9Dn9C,KACA,MAAO,CACHvC,MAAOtJ,EACPiE,KAAMjE,EACNq8B,eAAgB,aAChBotB,WAAYzpD,EACZ0pD,YAAa,WAAc,OAAO,IAG1C,IAAIviC,EAAQ,CACR1c,OAAQ,GAERk/C,EAAgB,WAChBxiC,EAAQ,CAAE1c,OAAQ,IAElBm/C,EAAe,WACfziC,EAAQ,CAAE1c,OAAQ,IAEtB,MAAO,CACHnB,MAAO,WAAc,OAAOqgD,KAC5B1lD,KAAM,WAAc,OAAO2lD,KAC3BvtB,eAAgBA,GAChBotB,WAAY,SAAU3uC,EAAW9J,EAAe+M,EAAgBC,GAC5DlD,EAAUxT,UAAU,GAAyB,WACpB,IAAjB6f,EAAM1c,QAAgD,IAAjB0c,EAAM1c,SAC3Cm/C,IACAziC,EAAQ,CAAE1c,OAAQ,OAG1BqQ,EAAUxT,UAAU,GAAyB,WACpB,IAAjB6f,EAAM1c,QACNk/C,OAGRA,EAAgB,WACZ,IAAI/pC,EAAU7B,EAAe8B,qBACxBD,GAAYA,EAAQQ,cAIJ,IAAjB+G,EAAM1c,QAAgD,IAAjB0c,EAAM1c,SAG/C0c,EAAQ,CAAE1c,OAAQ,GAClBtG,EAAgB,eAAe,WACN,IAAjBgjB,EAAM1c,QAGV++C,GAAuB,SAAU9V,GAC7B,GAAqB,IAAjBvsB,EAAM1c,OAGV,GAAKipC,EAAL,CAMA,IAAImW,EC1DrB,SAAwB/uC,EAAW9J,EAAe+M,EAAgBC,EAAc01B,GACnF,IAAI9yC,EAAK4zC,GAAuB15B,EAAW9J,EAAciB,cAAe8L,EAAgBC,GAAc,SAAUlW,EAAMwqC,EAAUC,EAAgBl9B,GAC5I,OAAO1J,GAAKqF,EAAcQ,6BAA8B1J,EAAMwqC,EAAUC,EAAgBl9B,KACzFq+B,GAASR,EAAYtyC,EAAGsyC,UAAW4W,EAAwBlpD,EAAGqD,KAC7DN,ETFD,SAAgBpG,GACnB,IAAIwsD,EAAOxsD,EAAQwsD,KAEnB,IAAKA,EACD,MAAM,IAAIvjD,MAAM,6BAEpB,IAAIsoC,EAAqB,IAAIlC,GACzBod,EAAmB,SAAUvgD,QACX,IAAdA,IAAwBA,EAAYR,KACxC6lC,EAAmB/6B,QACnBg2C,EAAK,CACDjiD,KAAM,CACFw9B,OAAQ8I,KACRjhC,KAAM/K,OAAO2J,SAASoB,KACtBk4B,MAAO6I,MAEXxnC,KZnBF,EYoBE+C,UAAWA,IAEfsgD,EAAK,CACDjiD,KAAM,CACF+pC,UAAWvtC,SAASwtC,YAExBprC,KZzBD,EY0BC+C,UAAWA,IAEfsgD,EAAK,CACDjiD,KAAM,CACF+R,KAAMyqB,GAAkBhgC,SAAU/G,EAAQ0kC,qBAC1CgoB,cAAe,CACXC,KAAM5b,KACN6b,IAAK3b,OAGb9nC,KZvCM,EYwCN+C,UAAWA,IAEXrH,OAAO8qC,gBACP6c,EAAK,CACDjiD,KAAMkmC,KACNtnC,KZxCI,EYyCJ+C,UAAWA,KAmCvB,OA/BAugD,IA+BO,CACH/lD,KA/BgByqC,GAAc,CAC9BI,mBAAoBA,EACpB7M,oBAAqB1kC,EAAQ0kC,oBAC7BgP,QAAS,SAAU2I,GAAK,OAAOmQ,EAAK1X,GFlDjC,EEkDsFuH,KACzFzI,mBAAoB,SAAU8R,GAC1B,OAAO8G,EAAK1X,GFlDF,EEkDkE4Q,KAEhFtT,mBAAoB,SAAUya,GAC1B,OAAOL,EAAK1X,GF1DF,EE0DkE+X,KAEhF7a,YAAa,SAAU8a,EAAW3rD,GAAU,OAAOqrD,EAAK1X,GAA4B3zC,EAAQ,CAAE2rD,UAAWA,MACzGtb,WAAY,SAAUuK,GAAK,OAAOyQ,EAAK1X,GF/DjC,EE+DyFiH,KAC/FxJ,SAAU,SAAUmT,GAAK,OAAO8G,EAAK1X,GF7DjC,EE6DuF4Q,KAC3FtR,iBAAkB,SAAU2Y,GAAK,OAAOP,EAAK1X,GFzDjC,EEyD+FiY,KAC3Gpa,iBAAkB,SAAUka,GAAK,OAAOL,EAAK1X,GF9DjC,EE8D+F+X,KAC3Gxb,QAAS,SAAU9mC,GACf,OAAOiiD,EAAK,CACRjiD,KAAMA,EACNpB,KZlEL,EYmEK+C,UAAWR,OAGnBkpC,uBAAwB,SAAUrqC,GAC9BiiD,EAAK,CACDjiD,KAAMA,EACNpB,KZvEI,EYwEJ+C,UAAWR,SAMnB+gD,iBAAkBA,EAClBO,eAAgB,WAAc,OAAOzb,EAAmB/6B,US7EnDwgC,CAAO,CACZwV,KAAM7W,EACNjR,oBAAqBjxB,EAAcixB,sBACnC4nB,EAAgBlmD,EAAGM,KAAM+lD,EAAmBrmD,EAAGqmD,iBAAkBO,EAAiB5mD,EAAG4mD,eACrFC,EAAuB1vC,EAAUxT,UAAU,GAAoB,WAC/DijD,IACArX,EAAU,CACNzpC,UAAWR,IACXvC,KrBXC,OqBaNgB,YACCitC,EAAyB75B,EAAUxT,UAAU,GAAsB,SAAUiqB,GAC7Ey4B,EAAiBz4B,EAAKjU,YAAY9U,cACnCd,YACH,MAAO,CACHzD,KAAM,WACFumD,IACA7V,IACAkV,IACAC,MDmCgCP,CAAmBzuC,EAAW9J,EAAe+M,EAAgBC,EAAc01B,GAAQzvC,KACvGkjB,EAAQ,CACJ1c,OAAQ,EACRo/C,cAAeA,QARf1iC,EAAQ,CACJ1c,OAAQ,UAjBpB0c,EAAQ,CAAE1c,OAAQ,IA6B1Bm/C,EAAe,WACU,IAAjBziC,EAAM1c,SAGW,IAAjB0c,EAAM1c,QACN0c,EAAM0iC,gBAEV1iC,EAAQ,CACJ1c,OAAQ,KAGK,IAAjB0c,EAAM1c,QACNk/C,KAGRD,YAAa,WAAc,OAAwB,IAAjBviC,EAAM1c,SFhF9BggD,GACPC,GIJJ,SAA0BC,EAAczuB,EAAat7B,GACxD,ICHIsJ,EDG8B0gD,EAAT,GAAiBC,oCAAqCA,OAA6C,IAAPD,GAAuBA,EACxIE,GAAuB,EACvBC,GCLA7gD,EAAU,GACP,CACHpI,IAAK,WAAc,OAAOoI,GAC1BhF,IAAK,SAAUvG,EAAKzB,GAChBgN,EAAQvL,GAAOzB,GAEnByX,OAAQ,SAAUhW,UACPuL,EAAQvL,IAEnB+e,IAAK,SAAUstC,GACX9gD,EAAU8gD,KDJdhqC,EAAO,GACPiqC,EAA6B,aAC7BC,EAA+B,aAC/BC,EAAiB,IAAIjgD,GACrBkgD,EAAoB,SAAUruD,EAAM2+B,QACvB,IAATA,IAAmBA,EAAOzyB,KAC9BkiD,EAAejmD,KAAI,WAAc,OAAOkmD,EAAkBruD,EAAM2+B,OAEhE2vB,EAAoB,SAAU9tD,EAAS+f,QACnB,IAAhBA,IAA0BA,EAAcnU,KAC5CgiD,EAAejmD,KAAI,WAAc,OAAOmmD,EAAkB9tD,EAAS+f,OAEnEguC,EAAoB,SAAUzqC,EAAQf,QAChB,IAAlBA,IAA4BA,EAAgByrC,KAChDJ,EAAejmD,KAAI,WAAc,OAAOomD,EAAkBzqC,EAAQf,OAElE0rC,EAAmB,SAAUC,EAAe3rC,QACtB,IAAlBA,IAA4BA,EAAgByrC,KAChDJ,EAAejmD,KAAI,WAAc,OAAOsmD,EAAiBC,EAAe3rC,OAE5E,SAASyrC,IACL,OAAOxlD,EAAU,CACbmE,QAAS6gD,EAAqBjpD,MAC9Bkf,KAAMA,IAyCd,SAAS0qC,EAAW16C,EAAemrB,GAC/B,IAAIwvB,EErDL,SAAkB36C,EAAemN,EAAkB+d,EAAaC,GACnE,IAAIrhB,EAAY,IAAI6H,GAChBipC,EAuDR,SAAoC56C,GAChC,IAAIpQ,EACAgrD,E9ErED,SAAiC56C,GACpC,IAAI66C,EACAC,EACAC,EAA8B,IAAI5kD,EAClC6kD,EAA2B,IAAI7kD,EA4BnC,OA3BA2C,GAAwBG,iBAAmBvK,EAAYsR,EAAcf,qBACrEpG,GAAuC,SAAU/M,GAC7CivD,EAA4BlkD,OAShC,SAAqB/K,GACjB,OAAOkJ,EAAQ,CAAEsG,KAAMrD,UAA8C7M,IAA5ByvD,EAAwCA,IAA4B,GAAI/uD,GAV9EmvD,CAAYnvD,IAC3C6M,GAA6B,cAAgBG,GAAwBG,kBACrE+hD,EAAyBnkD,OAUjC,SAA0B/K,GACtB,OAAOkJ,EAAQ,CACXU,KAAM,YACN4F,KAAMrD,IACNuH,QAAS,cACTU,QAAS,QACTxS,OAAQ,UACRshB,IAAK,CACDC,eAAgB,GAEpBisC,UAAWpvD,QACiBV,IAA7B0vD,EAAyCA,IAA6B,IArBrCK,CAAiBrvD,KAGzD,EAAOgN,GAAyB,CAC5BC,mBAAoBiH,EAAcJ,qCAClC5G,iBAAkB,IAkBf,CACHoiD,2BAA4B,SAAUC,GAClCR,EAA0BQ,GAE9BN,4BAA6BA,EAC7BO,4BAA6B,SAAUD,GACnCP,EAA2BO,GAE/BL,yBAA0BA,G8E6BLO,CAAwBv7C,GACjD,GAAInF,KAAqB,CACrB,IAAI2gD,EAAWlhD,KACfsgD,EAAmBG,4BAA4BzkD,WAAU,SAAUxK,GAAW,OAAO0vD,EAAS7gD,KAAK,eAAgB7O,MACnH8uD,EAAmBI,yBAAyB1kD,WAAU,SAAUxK,GAAW,OAAO0vD,EAAS7gD,KAAK,qBAAsB7O,WAErH,GAAIkU,EAAcU,kCAAmC,CACtD,IAAI+6C,ECpFL,SAA+Bz7C,EAAe07C,EAAUC,GAC3D,IACIC,EADAC,EAAeC,EAAYJ,GAK/B,SAASI,EAAY13C,GACjB,OAAO,IAAIlC,GAAM,IAAIiC,GAAYC,EAAiBpE,EAAcN,iBAAkBM,EAAcF,aAAcE,EAAcN,gBAAiBM,EAAcD,eAAgBC,EAAcH,cAE7L,OANI87C,IACAC,EAAeE,EAAYH,IAKxB,CACHznD,IAAK,SAAUpI,GACX+vD,EAAa3nD,IAAIpI,GACb8vD,GACAA,EAAa1nD,IAAIpI,KDuEXiwD,CAAsB/7C,EAAeA,EAAcU,kCAAoE,QAAhC9Q,EAAKoQ,EAAce,eAA4B,IAAPnR,OAAgB,EAASA,EAAG8Q,mCACzKk6C,EAAmBG,4BAA4BzkD,WAAU,SAAUxK,GAAW,OAAO2vD,EAAQvnD,IAAIpI,MAErG,OAAO8uD,EAnEkBoB,CAA2Bh8C,GACpD46C,EAAmBQ,4BAA2B,WAC1C,IAAIxrD,EACJ,OAAOoF,EAAQ,CACXinD,eAAgBj8C,EAAciB,cAC9B2N,QAAS,CACLW,GAA4C,QAAvC3f,EAAKgf,EAAQC,4BAAyC,IAAPjf,OAAgB,EAASA,EAAG2f,KAErFvC,EAAayB,WAAY,CAAE8R,KAAM,CAAEx0B,KAAM,WAEhD6uD,EAAmBU,6BAA4B,WAC3C,IAAI1rD,EAAI+C,EACR,MAAO,CACH2c,YAAa,CACTC,GAAIvP,EAAciB,eAEtB2N,QAAS,CACLW,GAA4C,QAAvC3f,EAAKgf,EAAQC,4BAAyC,IAAPjf,OAAgB,EAASA,EAAG2f,IAEpFgR,KAAM,CACFhR,GAAuC,QAAlC5c,EAAKqa,EAAayB,kBAA+B,IAAP9b,OAAgB,EAASA,EAAG4tB,KAAKhR,IAEpFM,OAAQ,CACJN,GAAIrC,EAAeyC,oBAI1B9U,KE/CF,SAA6BiP,GAChC,IAAI9O,EAASV,KACbwP,EAAUxT,UAAU,IAA8B,SAAUsZ,GACxD5U,EAAOL,KAAK,MAAOiV,MFgDnBssC,CAAoBpyC,GGnDrB,SAAuB9J,EAAe8J,EAAWkxC,GACpD,IAAImB,EAWR,SAAsBn8C,EAAe8J,GACjC,IAGI8xC,EAHAC,EAAeO,EAAep8C,EAAcO,oBAAoB,WAChE,OAAOuJ,EAAUjT,OAAO,MAGxBkK,EAAUf,EAAce,QAI5B,SAASq7C,EAAeh4C,EAAiBi4C,GACrC,OAAO,IAAIn6C,GAAM,IAAIiC,GAAYC,EAAiBpE,EAAcN,iBAAkBM,EAAcF,aAAcE,EAAcN,gBAAiBM,EAAcD,eAAgBC,EAAcH,aAAcw8C,GAE3M,SAASC,EAAyBxwD,GAC9B,OAAOkJ,EAAQlJ,EAAS,CAAEwjB,YAAa,CAAEC,GAAIxO,EAAQE,iBAEzD,YATgB7V,IAAZ2V,IACA66C,EAAeQ,EAAer7C,EAAQR,qBAQnC,CACHrM,IAAK,SAAUpI,GACX+vD,EAAa3nD,IAAIpI,GACb8vD,GACAA,EAAa1nD,IAAIooD,EAAyBxwD,KAGlDgX,OAAQ,SAAUhX,EAAS6B,GACvBkuD,EAAa/4C,OAAOhX,EAAS6B,GACzBiuD,GACAA,EAAa94C,OAAOw5C,EAAyBxwD,GAAU6B,KApCvD4uD,CAAav8C,EAAe8J,GACxCA,EAAUxT,UAAU,IAA8B,SAAUsZ,GAC5B,SAAxBA,EAAela,KACfymD,EAAMr5C,OAAO8M,EAAgBA,EAAe2Q,KAAKhR,IAGjD4sC,EAAMjoD,IAAI0b,MAGlBorC,EAAyB1kD,WAAU,SAAU/D,GAAS,OAAO4pD,EAAMjoD,IAAI3B,MHsCnEiqD,CAAcx8C,EAAe8J,EAAW8wC,EAAmBI,0BAK/D,IjEpDIj1C,EACA3O,EiEmDAwX,EAAW/T,KzBxBZ,WACH,IAAI+T,EAAU,CACVW,GAAI,uCACJH,eAAe,EACfqtC,aAAa,GAEjB,MAAO,CACH5tC,mBAAoB,WAAc,OAAOD,IyBiB2C8tC,GzBpDrF,SAAgC18C,EAAe8J,GAClD,IAAIiD,EAAiB+gB,GAAoB9tB,EAAcV,cAF9B,OAE8D,SAAUq9C,GAC7F,OAoCR,SAA6B38C,EAAe28C,GACxC,IAAIxtB,EAaJ,MAAO,CACHA,aAHAA,EAOR,SAA4BA,GACxB,MAAyB,MAAjBA,GACa,MAAjBA,GACiB,MAAjBA,EApBAytB,CAAmBD,GACJA,EAETjuD,EAAYsR,EAAcjB,YAG1BrQ,EAAYsR,EAAc68C,kBAIjB,IAHA,IAHA,IAUf5tB,UAAWe,GAAcb,IApDlBnB,CAAoBhuB,EAAe28C,MAQ9C,OANA5vC,EAAewhB,iBAAiBj4B,WAAU,WACtCwT,EAAUjT,OAAO,MAErBkW,EAAeuhB,gBAAgBh4B,WAAU,WACrCwT,EAAUjT,OAAO,MAEd,CACHgY,mBAAoB,SAAUlI,GAC1B,IAAIiI,EAAU7B,EAAegjB,kBAAkBppB,GAC/C,GAAKiI,GAAYohB,GAAcphB,EAAQugB,cAGvC,MAAO,CACH5f,GAAIX,EAAQW,GACZH,cAAwC,MAAzBR,EAAQugB,aACvBstB,YAAsC,MAAzB7tC,EAAQugB,gByBiCI2tB,CAAuB98C,EAAe8J,GACvE6Q,GjErDA5U,EAAmBN,KACnBrO,EAAa,IAAIjB,GAAW,WAC5B,GAAK4P,EAAL,CAGA,IAAIhP,EAAW,IAAIgP,EAAiB/S,IAAQ,WAAc,OAAOoE,EAAWP,aAO5E,OANAE,EAAS2T,QAAQpX,SAAU,CACvBihC,YAAY,EACZgH,eAAe,EACfE,WAAW,EACXC,SAAS,IAEN,WAAc,OAAO3kC,EAAS0sB,mBiE0CrCwH,EIvDD,SAAwClwB,GAC3C,IAAIoyB,EAAkBn/B,EAAa+M,GAC/B3D,EAAa,IAAIjB,GAAW,WAC5B,IAoBc4mD,EACdC,EAGAC,EAGAhc,EASWic,EApCPC,GAoBUJ,EApByBK,EAqBvCJ,EAA6B7nC,GAAgC0J,QAAS,YAAa,CACnF9L,MAAOgqC,IACR9pD,KACCgqD,EAAgC9nC,GAAgC0J,QAAS,eAAgB,CACzF9L,MAAOgqC,IACR9pD,KACCguC,EAAiB5uC,EAAiBjB,OAAQ,WAA4B2rD,GAAiB9pD,KACpF,CACHA,KAAM,WACF+pD,IACAC,IACAhc,OAhCqDhuC,KACrDoqD,GAmCOH,EAnCsBE,EAoC9B/qD,EAAiBjB,OAAQ,aAAgC8rD,IApCTjqD,KACnD,OAAO,WACHkqD,IACAE,QAGR,SAASD,IACL,GAAIjwB,EAAgBhxB,OAASpB,EAASoB,KAAtC,CAGA,IAAIoxB,EAAcv/B,EAAa+M,GAC/B3D,EAAWP,OAAO,CACd02B,YAAaA,EACbD,YAAaH,IAEjBA,EAAkBI,GAEtB,OAAOn2B,EJkCwBkmD,CAA+BviD,UAC1DnL,EAiCD,SAAiCka,EAAW9J,EAAejF,EAAUgS,EAAgBke,EAA0BtQ,EAAuBxN,GACzI,IAAIH,EKzFD,SAA2BlD,GAC9B,IAAIyzC,EAAqB,IAAIxpC,GAFQ2b,OAuBrC,OApBA5lB,EAAUxT,UAAU,GAAsB,SAAUiqB,GAChDg9B,EAAmBrpD,IASvB,SAA0BqsB,GACtB,MAAO,CACH/gB,QAAS+gB,EAAK/gB,QACdU,QAASqgB,EAAKrgB,QACdqgB,KAAM,CACFhR,GAAIgR,EAAKhR,GACTxjB,KAAMw0B,EAAKx0B,OAfIyxD,CAAiBj9B,GAAOA,EAAKjU,YAAY/U,aAEpEuS,EAAUxT,UAAU,GAAoB,SAAU1G,GAC9C,IAAIi6B,EAAYj6B,EAAGi6B,UACnB0zB,EAAmBhpC,YAAYsV,EAAUtyB,aAE7CuS,EAAUxT,UAAU,GAAyB,WACzCinD,EAAmB7oC,WAYhB,CACHjG,SAAU,SAAU9H,GAAa,OAAO42C,EAAmBxtD,KAAK4W,IAChE1T,KAAM,WACFsqD,EAAmBtqD,SLgERwqD,CAAkB3zC,GACjCmD,EMrFD,SAA0BnD,EAAWmhB,EAA0BlwB,GAClE,IACI2iD,EADAC,EAAoB,IAAI5pC,GAFQ2b,OAIpC5lB,EAAUxT,UAAU,GAAoB,SAAU1G,GAC9C,IAAIi6B,EAAYj6B,EAAGi6B,UACnB8zB,EAAkBppC,YAAYsV,EAAUtyB,aAE5CuS,EAAUxT,UAAU,GAAsB,SAAU1G,GAChD,IAAI0c,EAAc1c,EAAG0c,YACjBsxC,EAAU7iD,EAASoB,KACvBwhD,EAAkBzpD,IAAI2pD,EAAgB,CAClCvyD,IAAKsyD,EACLE,SAAWJ,GAAkBpqD,SAASwqD,WACtCxxC,EAAY/U,UAChBmmD,EAAkBE,KAEtB,IAAIjxB,EAA6B1B,EAAyB30B,WAAU,SAAU1G,GAC1E,IAAI29B,EAAc39B,EAAG29B,YACjBhhB,EAAUoxC,EAAkB5tD,OAChC,GAAIwc,EAAS,CACT,IAAIwxC,EAAa7lD,IACjBylD,EAAkBppC,YAAYwpC,GAC9BJ,EAAkBzpD,IAAI2pD,EAAgB,CAClCvyD,IAAKiiC,EAAYpxB,KACjB2hD,SAAUvxC,EAAQgU,KAAKu9B,WACvBC,OAGZ,SAASF,EAAgBjuD,GAErB,MAAO,CACH2wB,KAAM,CACFj1B,IAHEsE,EAAGtE,IAILwyD,SAJqBluD,EAAGkuD,WAQpC,MAAO,CACHnvC,QAAS,SAAUhI,GAAa,OAAOg3C,EAAkB5tD,KAAK4W,IAC9D1T,KAAM,WACF05B,EAA2Bj2B,cAC3BinD,EAAkB1qD,SN4CR+qD,CAAiBl0C,EAAWmhB,EAA0BlwB,GACpE+kB,EzDvFD,WACCxsB,SAASwtC,YACTlwB,KAEJ,IAoCgBqtC,EAQDC,EA5CXC,GAoCYF,EApCwBrtC,GAqCjCve,EAAiBjB,OAAQ,SAAqB,SAAUmB,GACtDA,EAAM0S,WAGXg5C,QAzC4DhrD,KAC5DmrD,GA2CWF,EA3CkBptC,GA4C1Bze,EAAiBjB,OAAQ,QAAmB,SAAUmB,GACpDA,EAAM0S,WAGXi5C,QAhDoDjrD,KACxD,MAAO,CACH8d,iBAAkBA,GAClBE,6BAA8BA,GAC9Bhe,KAAM,WACF0d,GAAoB,GACpBwtC,IACAC,MyD2EiBC,GACrBzuD,E1C5FD,SAA+Bka,EAAW6Q,EAAuB3a,EAAe8f,GACnFhW,EAAUxT,UAAU,GAA+B,SAAUuZ,GACzD,OAAO/F,EAAUjT,OAAO,GAAkCgpB,GAAchQ,EAAQiQ,OAEpF,IAAI5S,EAAiB,CAAEyC,aAAc3gB,GAIrC,OAHIgR,EAAcs+C,oBACdpxC,EAAiByR,GAAa7U,EAAW6Q,EAAuB3a,GAAekN,gBAE5E,CACHqxC,UAAW,SAAU1uC,EAAQvB,GACzBxE,EAAUjT,OAAO,GAAkC,EAAO,CACtDyX,mBAAoBA,GACrBuR,GAAchQ,EAAQiQ,MAE7B5S,eAAgBA,G0C8EXsxC,CAAsB10C,EAAW6Q,EAAuB3a,EAAe8f,GAAqBy+B,EAAY3uD,EAAG2uD,UAAWrxC,EAAiBtd,EAAGsd,eAEnJ,OADAJ,GAAiB9M,EAAe8J,EAAWiD,EAAgBC,EAAcC,EAAaC,EAAgBC,GAC/F,CACHH,aAAcA,EACd8S,mBAAoBA,EACpB7S,YAAaA,EACbsxC,UAAWA,EACXrxC,eAAgBA,EAChBja,KAAM,WACF+Z,EAAa/Z,OACb6sB,EAAmB7sB,SA/ClBwrD,CAAwB30C,EAAW9J,EAAejF,SAAU6T,EAASqc,EAA0BtQ,EAAuBxN,GAAmBH,EAAepd,EAAGod,aAAc8S,EAAqBlwB,EAAGkwB,mBAAoB7S,EAAcrd,EAAGqd,YAAaC,EAAiBtd,EAAGsd,eAAgBqxC,EAAY3uD,EAAG2uD,WOxD5S,SAAiCz0C,EAAWiD,GAC/CjD,EAAUxT,UAAU,GAAuC,SAAUiU,GACjE,IAAK,IAAItd,EAAK,EAAGu4B,EAAYjb,EAAStd,EAAKu4B,EAAUr4B,OAAQF,IAAM,CAC/D,IAAIuZ,EAAQgf,EAAUv4B,GACtB,GAAwB,aAApBuZ,EAAMkD,UACN,MAEJ,IAAIkF,EAAU7B,EAAe8B,mBAAmBrI,EAAMG,WACtD,IAAKiI,GAAWA,EAAQ6tC,YACpB,MAEJ,IAAInwC,EAAchV,EAAiBkP,EAAMG,WACrCyH,EAAc,CACd9S,KAAMgR,EAAY9U,UAClB2oB,UAAW,CACP5Q,GAAIrhB,IACJ8J,SAAUD,EAAiByO,EAAMxO,WAErCtC,KAAM,aAEVoU,EAAUjT,OAAO,GAAkC,CAC/CuX,YAAaA,EACbzH,UAAW2F,EAAY/U,SACvB8W,cAAe,CAAE8W,iBAAkB3e,EAAMhX,gBPkCrDkvD,CAAwB50C,EAAW8E,GACnCwV,GAAwBta,GACxB,IAAInX,EAAKq4B,GAAoBlhB,EAAW9J,EAAejF,SAAU4f,EAAuBsQ,EAA0BnL,EAAoBoL,EAAaC,GAAqBV,EAAY93B,EAAG83B,UAAWiD,EAAY/6B,EAAG+6B,UAC7M1J,EAAWvC,GAAqB3X,EAAWgW,GAAoBkE,SACnEhL,GAAuBlP,EAAW9J,EAAe4O,GACjD/E,GAA2BC,EAAW9J,GACtC,IAAI2+C,EQ3DD,SAA8B19C,EAAe8L,EAAgBC,EAAcE,EAAgBD,GAC9F,MAAO,CACHnc,IAAK,SAAU6V,GACX,IAAI6H,EAAcxB,EAAayB,SAAS9H,GACpC+H,EAAazB,EAAY0B,QAAQhI,GACjCiI,EAAU7B,EAAe8B,mBAAmBlI,GAChD,GAAIiI,GAAWJ,GAAeE,EAAY,CACtC,IAAIgB,EAAWxC,EAAeyC,aAAahJ,GAC3C,MAAO,CACHs1C,eAAgBh7C,EAChB29C,WAAYhwC,EAAQW,GACpBsvC,YAAanvC,EAAW,CAAEH,GAAIG,QAAatkB,EAC3Cm1B,KAAM,EAAO,GAAI/R,EAAY+R,KAAM7R,EAAW6R,UR+CxCu+B,CAAqB9+C,EAAciB,cAAe2N,EAAS5B,EAAcE,EAAgBD,GAC/G,MAAO,CACHsxC,UAAWA,EACXv6B,SAAUA,EACVyG,UAAWA,EACXiD,UAAWA,EACX5jB,UAAWA,EACXkD,aAAcA,EACd4B,QAASA,EACTmwC,mBAAoBJ,EAAgB7tD,KFDd6oD,CAAa35C,GAAe,WAAc,MAAO,CACnEgQ,KAAMA,EACN9W,QAAS6gD,EAAqBjpD,MAC9Bif,YAAWmb,EAAYwtB,oBAAuBttD,KAC3C8/B,EAAaC,GACnBkvB,EAAoBM,EAAgBjtB,UAAW4sB,EAAoBK,EAAgB4D,UAAW/D,EAAmBG,EAAgB32B,SAAUo2B,EAAoBO,EAAgBlwB,UAAWwvB,EAA6BU,EAAgBoE,mBACxO5E,EAAe9/C,QACf6wB,EAAYutB,WAAWkC,EAAgB7wC,UAAW9J,EAAe26C,EAAgB/rC,QAAS+rC,EAAgB3tC,cAE9G,IH9E0BgyC,EACtBC,EG6EAvxB,EAAY16B,IAAQ,SAAUzG,GAE9B8tD,EAD0C,iBAAZ9tD,EAAuBA,EAAU,CAAER,KAAMQ,OAGvE2yD,GHlFsBF,EGkFO,CAC7BnoC,KAAM7jB,IArDV,SAAiBuK,GAKb,IAAIs8C,IAAuC/3C,KAA3C,CAGA,GAAIjH,KACA0C,EA8HR,SAA4CA,GACxC,OAAO,EAAO,GAAIA,EAAmB,CACjC0D,cAAe,uCACftD,YAAa,QACboB,WAAY,MAlIQogD,CAAmC5hD,QAEtD,IAwGT,SAA0BA,GACtB,OzEnID,SAA8BhR,GACjC,QAAwBnB,IAApBkI,SAASwI,QAA4C,OAApBxI,SAASwI,OAC1C,OAAO,EAEX,IAGI,IAAI4F,EAAiB,kBAAkBlT,OAAON,KAC1CkxD,EAAkB,OACtBhkD,GAAUsG,EAAgB09C,EAAiBjzD,EAAYI,GACvD,IAAI8yD,EAAuBtjD,GAAU2F,KAAoB09C,EAEzD,OADApjD,GAAa0F,EAAgBnV,GACtB8yD,EAEX,MAAOt1D,GAEH,OADAL,EAAQK,MAAMA,IACP,GyEmHFu1D,CAAqB//C,GAAmBhC,IA2BT,UAA7BnM,OAAO2J,SAASrJ,WAtBnBhI,EAAQK,MAAM,qDACP,IALPL,EAAQI,KAAK,2DACN,GA3GDy1D,CAAiBhiD,GACvB,OAEJ,GAgHJ,SAAoBA,GAChB,OAAIu8C,IACKv8C,EAAkBkC,oBACnB/V,EAAQK,MAAM,mCAEX,GArHNy1D,CAAWjiD,GAAhB,CAGA,IAAIyC,EWjDL,SAA0CzC,GAC7C,IAAI3N,EAAI+C,EACR,GAAK4K,EAAkB0D,cAIvB,QAA2C7V,IAAvCmS,EAAkBs/C,kBAAmCzsD,EAAamN,EAAkBs/C,kBAAxF,CAIA,QAAgDzxD,IAA5CmS,EAAkBua,sBAAqC,CACvD,IAAKrkB,MAAMC,QAAQ6J,EAAkBua,uBAEjC,YADApuB,EAAQK,MAAM,8CAGlB,GAAuD,IAAnDwT,EAAkBua,sBAAsB3qB,aAA8C/B,IAA9BmS,EAAkBiC,QAE1E,YADA9V,EAAQK,MAAM,yDAItB,I5F6I2BkE,EAAQ/B,E4F7I/BuzD,EAAoB3gD,GAA8BvB,GACtD,GAAKkiD,EAGL,OAAO,EAAO,CACVx+C,cAAe1D,EAAkB0D,cACjCf,QAAS3C,EAAkB2C,QAC3B0e,oBAAqBrhB,EAAkBqhB,oBACvCi+B,iBAAgE,QAA7CjtD,EAAK2N,EAAkBs/C,wBAAqC,IAAPjtD,EAAgBA,EAAK,IAC7FkoB,sBAA0E,QAAlDnlB,EAAK4K,EAAkBua,6BAA0C,IAAPnlB,EAAgBA,EAAK,GACvG2rD,oBAAqB/gD,EAAkB+gD,kBACvC1wB,qBAAsBrwB,EAAkBqwB,mBACxCqD,qB5FiIuBhjC,E4FjIayQ,G5FiILxS,E4FjI0BqR,EAAkB0zB,oB5FkIxErjC,OAAO2C,KAAKtC,GAAQgN,MAAK,SAAUtN,GAAO,OAAOM,EAAON,KAASzB,K4FjI9DqR,EAAkB0zB,oBAClBvyB,GAAoBG,kBAC3B4gD,QA5BC/1D,EAAQK,MAAM,gEAJdL,EAAQK,MAAM,oEX8CM21D,CAAiCniD,GACrD,GAAKyC,EAAL,CAGA,GAAKA,EAAc4tB,mBAGd,CAID,IAAI+xB,EAAkBxF,EACtBA,EAAiB,IAAIjgD,GACrBmgD,EAAoB,SAAU9tD,GAC1BmuD,EAAW16C,EAAezT,IAE9BozD,EAAgBtlD,aAXhBqgD,EAAW16C,GAafk6C,EAA+B,WAAc,OAAOnlD,EAAUwI,IAC9Du8C,GAAuB,QAkBvB8F,oBAAqB5sD,GAAQ+mD,EAAqB7lD,KAClD2rD,uBAAwB7sD,GAAQ+mD,EAAqBp2C,QACrDm8C,oBAAqB9sD,GAAQ+mD,EAAqBjpD,KAClDivD,oBAAqB/sD,GAAQ+mD,EAAqBrtC,KAClDqyC,mBAAoB/rD,IAAQ,SAAU2T,GAAa,OAAOszC,EAA2BtzC,MACrFq5C,qBAAsBhtD,IAAQ,WAAc,OAAOknD,OACnDqE,UAAWvrD,IAAQ,SAAUjH,EAAMmN,GAC/BohD,EAAkB,CACdvuD,KAAMA,EACNmN,QAASnE,EAAUmE,GACnBoT,YAAanU,IACbzC,KAAM,cAGdsuB,SAAU,SAAUj6B,EAAOmP,GACvB,IAAI3D,EAAgBM,IACpBG,IAAc,WACVwkD,EAAiB,CACbzwD,MAAOA,EACPwL,cAAeA,EACf2D,QAASnE,EAAUmE,GACnBoT,YAAanU,UAIzBsyB,UAAWz3B,IAAQ,SAAUjH,EAAM2+B,GAC/B0vB,EAAkBruD,EAAM2+B,MAE5Bu1B,QAASjtD,IAAQ,SAAUktD,GACvB,IAAIC,EAgBZ,SAAsBD,GAClB,GAAuB,iBAAZA,GAAyBA,EAApC,CAGA,IAAIzwD,EAASsF,EAAUmrD,GAUvB,MATI,OAAQzwD,IACRA,EAAO8f,GAAKgE,OAAO9jB,EAAO8f,KAE1B,SAAU9f,IACVA,EAAO1D,KAAOwnB,OAAO9jB,EAAO1D,OAE5B,UAAW0D,IACXA,EAAO2wD,MAAQ7sC,OAAO9jB,EAAO2wD,QAE1B3wD,GA9BiB4wD,CAAaH,GAC7BC,EACAnwC,EAAOmwC,EAGPz2D,EAAQK,MAAM,oBAAqBm2D,MAG3CI,WAAYttD,IAAQ,WAChBgd,EAAO,MAEX0d,UAAWA,EACX6yB,4BAA6BvtD,GAAQk4B,EAAY5yB,OACjDkoD,2BAA4BxtD,GAAQk4B,EAAYj4B,OH7HhDgsD,EAAY,EAAO,CACnB/+C,QAAS,QAITugD,QAAS,SAAUptD,GACfA,MAEL2rD,GAGHpxD,OAAOiD,eAAeouD,EAAW,YAAa,CAC1CnuD,IAAK,WACD,OAAO8I,IAEX8mD,YAAY,IAETzB,GG8GP,OAAOC,EJ5HayB,CMYjB,ENZ4Cz1B,ICgBtB32B,GDfhB5D,ICe8BmwB,GDfD44B,GCgBlCpB,GAAyB/jD,GDhBD,UCiB5BA,GAAW,OAAIusB,GACXw3B,IAA0BA,GAAuB1C,GACjD0C,GAAuB1C,EAAErrD,SAAQ,SAAU8B,GAAM,OAAOwN,GAAgBxN,EAAI,mCAApBwN","sources":["webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/display.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/tracekit/computeStackTrace.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/utils.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/error.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/observable.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/timeUtils.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/configuration/experimentalFeatures.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/internalMonitoring/internalMonitoring.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/catchUserErrors.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/boundedBuffer.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/browser/cookie.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/urlPolyfill.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/transport/eventBridge.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/configuration/endpointBuilder.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/configuration/tags.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/configuration/configuration.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/configuration/transportConfiguration.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/syntheticsContext.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/transport/batch.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/transport/httpRequest.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/browser/domMutationObservable.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceUtils.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/getDocumentTraceId.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/browser/performanceCollection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/createEventRateLimiter.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/limitModification.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/assembly.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/ciTestContext.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/foregroundContexts.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/lifeCycle.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/session/sessionCookieStore.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/browserDetection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/session/sessionStore.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/contextHistory.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/browser/xhrObservable.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/instrumentMethod.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/browser/fetchObservable.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/tracing/tracer.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/requestCollection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/trackEventCounts.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/waitIdlePage.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/getActionNameFromElement.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/trackActions.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/action/actionCollection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/tracekit/tracekit.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/console/consoleObservable.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/report/reportObservable.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackFirstHidden.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/errorCollection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackConsoleError.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/error/trackRuntimeError.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/error/trackReportError.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/matchRequestTiming.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/resource/resourceCollection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackInitialViewTimings.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViewMetrics.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/trackViews.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/view/viewCollection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/session/sessionManager.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/domain/session/oldCookiesMigration.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumSessionManager.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/types.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/constants.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/privacy.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/serialize.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/serializationUtils.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/utils.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/mutationObserver.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/mutationBatch.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/observer.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/viewports.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/types.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/replayStats.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/record/record.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/transport/send.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segment.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/deflateWorker.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/segmentCollection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/domain/segmentCollection/startDeflateWorker.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/entries/main.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/boot/init.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/boot/recorderApi.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum/esm/boot/startRecording.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/boot/rumPublicApi.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/tools/contextManager.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/boot/startRum.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-core/esm/transport/startBatchWithReplica.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/transport/startRumEventBridge.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/transport/startRumBatch.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/browser/locationChangeObservable.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/viewContexts.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/urlContexts.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/rumEventsCollection/longTask/longTaskCollection.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/internalContext.js","webpack://goodkind-frontend/./node_modules/@datadog/browser-rum-core/esm/domain/configuration.js"],"sourcesContent":["/* eslint-disable no-console, local-rules/disallow-side-effects */\n/**\n * Keep references on console methods to avoid triggering patched behaviors\n *\n * NB: in some setup, console could already be patched by another SDK.\n * In this case, some display messages can be sent by the other SDK\n * but we should be safe from infinite loop nonetheless.\n */\nexport var display = {\n    log: console.log.bind(console),\n    warn: console.warn.bind(console),\n    error: console.error.bind(console),\n};\n//# sourceMappingURL=display.js.map","var UNKNOWN_FUNCTION = '?';\n/**\n * Computes a stack trace for an exception.\n */\nexport function computeStackTrace(ex) {\n    var stack = [];\n    var stackProperty = tryToGetString(ex, 'stack');\n    if (stackProperty) {\n        stackProperty.split('\\n').forEach(function (line) {\n            var stackFrame = parseChromeLine(line) || parseWinLine(line) || parseGeckoLine(line);\n            if (stackFrame) {\n                if (!stackFrame.func && stackFrame.line) {\n                    stackFrame.func = UNKNOWN_FUNCTION;\n                }\n                stack.push(stackFrame);\n            }\n        });\n    }\n    return {\n        message: tryToGetString(ex, 'message'),\n        name: tryToGetString(ex, 'name'),\n        stack: stack,\n    };\n}\nvar CHROME_LINE_RE = \n// eslint-disable-next-line max-len\n/^\\s*at (.*?) ?\\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\\/).*?)(?::(\\d+))?(?::(\\d+))?\\)?\\s*$/i;\nvar CHROME_EVAL_RE = /\\((\\S*)(?::(\\d+))(?::(\\d+))\\)/;\nfunction parseChromeLine(line) {\n    var parts = CHROME_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line\n    var isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line\n    var submatch = CHROME_EVAL_RE.exec(parts[2]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line/column number\n        parts[2] = submatch[1]; // url\n        parts[3] = submatch[2]; // line\n        parts[4] = submatch[3]; // column\n    }\n    return {\n        args: isNative ? [parts[2]] : [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[3] ? +parts[3] : undefined,\n        url: !isNative ? parts[2] : undefined,\n    };\n}\nvar WINJS_LINE_RE = /^\\s*at (?:((?:\\[object object\\])?.+) )?\\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\\d+)(?::(\\d+))?\\)?\\s*$/i;\nfunction parseWinLine(line) {\n    var parts = WINJS_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    return {\n        args: [],\n        column: parts[4] ? +parts[4] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: +parts[3],\n        url: parts[2],\n    };\n}\nvar GECKO_LINE_RE = \n// eslint-disable-next-line max-len\n/^\\s*(.*?)(?:\\((.*?)\\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|capacitor|\\[native).*?|[^@]*bundle)(?::(\\d+))?(?::(\\d+))?\\s*$/i;\nvar GECKO_EVAL_RE = /(\\S+) line (\\d+)(?: > eval line \\d+)* > eval/i;\nfunction parseGeckoLine(line) {\n    var parts = GECKO_LINE_RE.exec(line);\n    if (!parts) {\n        return;\n    }\n    var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;\n    var submatch = GECKO_EVAL_RE.exec(parts[3]);\n    if (isEval && submatch) {\n        // throw out eval line/column and use top-most line number\n        parts[3] = submatch[1];\n        parts[4] = submatch[2];\n        parts[5] = undefined; // no column when eval\n    }\n    return {\n        args: parts[2] ? parts[2].split(',') : [],\n        column: parts[5] ? +parts[5] : undefined,\n        func: parts[1] || UNKNOWN_FUNCTION,\n        line: parts[4] ? +parts[4] : undefined,\n        url: parts[3],\n    };\n}\nfunction tryToGetString(candidate, property) {\n    if (typeof candidate !== 'object' || !candidate || !(property in candidate)) {\n        return undefined;\n    }\n    var value = candidate[property];\n    return typeof value === 'string' ? value : undefined;\n}\n//# sourceMappingURL=computeStackTrace.js.map","import { monitor } from '../domain/internalMonitoring';\nexport var ONE_SECOND = 1000;\nexport var ONE_MINUTE = 60 * ONE_SECOND;\nexport var ONE_HOUR = 60 * ONE_MINUTE;\nexport var ONE_DAY = 24 * ONE_HOUR;\nexport var ONE_YEAR = 365 * ONE_DAY;\nexport var ONE_KILO_BYTE = 1024;\n// use lodash API\nexport function throttle(fn, wait, options) {\n    var needLeadingExecution = options && options.leading !== undefined ? options.leading : true;\n    var needTrailingExecution = options && options.trailing !== undefined ? options.trailing : true;\n    var inWaitPeriod = false;\n    var pendingExecutionWithParameters;\n    var pendingTimeoutId;\n    return {\n        throttled: function () {\n            var parameters = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                parameters[_i] = arguments[_i];\n            }\n            if (inWaitPeriod) {\n                pendingExecutionWithParameters = parameters;\n                return;\n            }\n            if (needLeadingExecution) {\n                fn.apply(void 0, parameters);\n            }\n            else {\n                pendingExecutionWithParameters = parameters;\n            }\n            inWaitPeriod = true;\n            pendingTimeoutId = setTimeout(function () {\n                if (needTrailingExecution && pendingExecutionWithParameters) {\n                    fn.apply(void 0, pendingExecutionWithParameters);\n                }\n                inWaitPeriod = false;\n                pendingExecutionWithParameters = undefined;\n            }, wait);\n        },\n        cancel: function () {\n            clearTimeout(pendingTimeoutId);\n            inWaitPeriod = false;\n            pendingExecutionWithParameters = undefined;\n        },\n    };\n}\nexport function assign(target) {\n    var toAssign = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        toAssign[_i - 1] = arguments[_i];\n    }\n    toAssign.forEach(function (source) {\n        for (var key in source) {\n            if (Object.prototype.hasOwnProperty.call(source, key)) {\n                target[key] = source[key];\n            }\n        }\n    });\n    return target;\n}\nexport function shallowClone(object) {\n    return assign({}, object);\n}\n/**\n * UUID v4\n * from https://gist.github.com/jed/982883\n */\nexport function generateUUID(placeholder) {\n    return placeholder\n        ? // eslint-disable-next-line  no-bitwise\n            (parseInt(placeholder, 10) ^ ((Math.random() * 16) >> (parseInt(placeholder, 10) / 4))).toString(16)\n        : \"\".concat(1e7, \"-\").concat(1e3, \"-\").concat(4e3, \"-\").concat(8e3, \"-\").concat(1e11).replace(/[018]/g, generateUUID);\n}\n/**\n * Return true if the draw is successful\n * @param threshold between 0 and 100\n */\nexport function performDraw(threshold) {\n    return threshold !== 0 && Math.random() * 100 <= threshold;\n}\nexport function round(num, decimals) {\n    return +num.toFixed(decimals);\n}\n// eslint-disable-next-line @typescript-eslint/no-empty-function\nexport function noop() { }\n/**\n * Custom implementation of JSON.stringify that ignores value.toJSON.\n * We need to do that because some sites badly override toJSON on certain objects.\n * Note this still supposes that JSON.stringify is correct...\n */\nexport function jsonStringify(value, replacer, space) {\n    if (value === null || value === undefined) {\n        return JSON.stringify(value);\n    }\n    var originalToJSON = [false, undefined];\n    if (hasToJSON(value)) {\n        // We need to add a flag and not rely on the truthiness of value.toJSON\n        // because it can be set but undefined and that's actually significant.\n        originalToJSON = [true, value.toJSON];\n        delete value.toJSON;\n    }\n    var originalProtoToJSON = [false, undefined];\n    var prototype;\n    if (typeof value === 'object') {\n        prototype = Object.getPrototypeOf(value);\n        if (hasToJSON(prototype)) {\n            originalProtoToJSON = [true, prototype.toJSON];\n            delete prototype.toJSON;\n        }\n    }\n    var result;\n    try {\n        result = JSON.stringify(value, replacer, space);\n    }\n    catch (_a) {\n        result = '<error: unable to serialize object>';\n    }\n    finally {\n        if (originalToJSON[0]) {\n            ;\n            value.toJSON = originalToJSON[1];\n        }\n        if (originalProtoToJSON[0]) {\n            ;\n            prototype.toJSON = originalProtoToJSON[1];\n        }\n    }\n    return result;\n}\nfunction hasToJSON(value) {\n    return typeof value === 'object' && value !== null && Object.prototype.hasOwnProperty.call(value, 'toJSON');\n}\nexport function includes(candidate, search) {\n    return candidate.indexOf(search) !== -1;\n}\nexport function find(array, predicate) {\n    for (var i = 0; i < array.length; i += 1) {\n        var item = array[i];\n        if (predicate(item, i, array)) {\n            return item;\n        }\n    }\n    return undefined;\n}\nexport function findLast(array, predicate) {\n    for (var i = array.length - 1; i >= 0; i -= 1) {\n        var item = array[i];\n        if (predicate(item, i, array)) {\n            return item;\n        }\n    }\n    return undefined;\n}\nexport function isPercentage(value) {\n    return isNumber(value) && value >= 0 && value <= 100;\n}\nexport function isNumber(value) {\n    return typeof value === 'number';\n}\nexport function objectValues(object) {\n    return Object.keys(object).map(function (key) { return object[key]; });\n}\nexport function objectHasValue(object, value) {\n    return Object.keys(object).some(function (key) { return object[key] === value; });\n}\nexport function objectEntries(object) {\n    return Object.keys(object).map(function (key) { return [key, object[key]]; });\n}\nexport function isEmptyObject(object) {\n    return Object.keys(object).length === 0;\n}\nexport function mapValues(object, fn) {\n    var newObject = {};\n    for (var _i = 0, _a = Object.keys(object); _i < _a.length; _i++) {\n        var key = _a[_i];\n        newObject[key] = fn(object[key]);\n    }\n    return newObject;\n}\n/**\n * inspired by https://mathiasbynens.be/notes/globalthis\n */\nexport function getGlobalObject() {\n    if (typeof globalThis === 'object') {\n        return globalThis;\n    }\n    Object.defineProperty(Object.prototype, '_dd_temp_', {\n        get: function () {\n            return this;\n        },\n        configurable: true,\n    });\n    // @ts-ignore _dd_temp is defined using defineProperty\n    var globalObject = _dd_temp_;\n    // @ts-ignore _dd_temp is defined using defineProperty\n    delete Object.prototype._dd_temp_;\n    if (typeof globalObject !== 'object') {\n        // on safari _dd_temp_ is available on window but not globally\n        // fallback on other browser globals check\n        if (typeof self === 'object') {\n            globalObject = self;\n        }\n        else if (typeof window === 'object') {\n            globalObject = window;\n        }\n        else {\n            globalObject = {};\n        }\n    }\n    return globalObject;\n}\nexport function getLocationOrigin() {\n    return getLinkElementOrigin(window.location);\n}\n/**\n * IE fallback\n * https://developer.mozilla.org/en-US/docs/Web/API/HTMLHyperlinkElementUtils/origin\n */\nexport function getLinkElementOrigin(element) {\n    if (element.origin) {\n        return element.origin;\n    }\n    var sanitizedHost = element.host.replace(/(:80|:443)$/, '');\n    return \"\".concat(element.protocol, \"//\").concat(sanitizedHost);\n}\nexport function findCommaSeparatedValue(rawString, name) {\n    var regex = new RegExp(\"(?:^|;)\\\\s*\".concat(name, \"\\\\s*=\\\\s*([^;]+)\"));\n    var matches = regex.exec(rawString);\n    return matches ? matches[1] : undefined;\n}\nexport function safeTruncate(candidate, length, suffix) {\n    if (suffix === void 0) { suffix = ''; }\n    var lastChar = candidate.charCodeAt(length - 1);\n    var isLastCharSurrogatePair = lastChar >= 0xd800 && lastChar <= 0xdbff;\n    var correctedLength = isLastCharSurrogatePair ? length + 1 : length;\n    if (candidate.length <= correctedLength)\n        return candidate;\n    return \"\".concat(candidate.slice(0, correctedLength)).concat(suffix);\n}\n/**\n * Add an event listener to an event emitter object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n */\nexport function addEventListener(emitter, event, listener, options) {\n    return addEventListeners(emitter, [event], listener, options);\n}\n/**\n * Add event listeners to an event emitter object (Window, Element, mock object...).  This provides\n * a few conveniences compared to using `element.addEventListener` directly:\n *\n * * supports IE11 by: using an option object only if needed and emulating the `once` option\n *\n * * wraps the listener with a `monitor` function\n *\n * * returns a `stop` function to remove the listener\n *\n * * with `once: true`, the listener will be called at most once, even if different events are listened\n */\nexport function addEventListeners(emitter, events, listener, _a) {\n    var _b = _a === void 0 ? {} : _a, once = _b.once, capture = _b.capture, passive = _b.passive;\n    var wrappedListener = monitor(once\n        ? function (event) {\n            stop();\n            listener(event);\n        }\n        : listener);\n    var options = passive ? { capture: capture, passive: passive } : capture;\n    events.forEach(function (event) { return emitter.addEventListener(event, wrappedListener, options); });\n    var stop = function () { return events.forEach(function (event) { return emitter.removeEventListener(event, wrappedListener, options); }); };\n    return {\n        stop: stop,\n    };\n}\nexport function runOnReadyState(expectedReadyState, callback) {\n    if (document.readyState === expectedReadyState || document.readyState === 'complete') {\n        callback();\n    }\n    else {\n        var eventName = expectedReadyState === 'complete' ? \"load\" /* LOAD */ : \"DOMContentLoaded\" /* DOM_CONTENT_LOADED */;\n        addEventListener(window, eventName, callback, { once: true });\n    }\n}\n/**\n * Similar to `typeof`, but distinguish plain objects from `null` and arrays\n */\nexport function getType(value) {\n    if (value === null) {\n        return 'null';\n    }\n    if (Array.isArray(value)) {\n        return 'array';\n    }\n    return typeof value;\n}\nfunction createCircularReferenceChecker() {\n    if (typeof WeakSet !== 'undefined') {\n        var set_1 = new WeakSet();\n        return {\n            hasAlreadyBeenSeen: function (value) {\n                var has = set_1.has(value);\n                if (!has) {\n                    set_1.add(value);\n                }\n                return has;\n            },\n        };\n    }\n    var array = [];\n    return {\n        hasAlreadyBeenSeen: function (value) {\n            var has = array.indexOf(value) >= 0;\n            if (!has) {\n                array.push(value);\n            }\n            return has;\n        },\n    };\n}\n/**\n * Iterate over source and affect its sub values into destination, recursively.\n * If the source and destination can't be merged, return source.\n */\nexport function mergeInto(destination, source, circularReferenceChecker) {\n    if (circularReferenceChecker === void 0) { circularReferenceChecker = createCircularReferenceChecker(); }\n    // ignore the source if it is undefined\n    if (source === undefined) {\n        return destination;\n    }\n    if (typeof source !== 'object' || source === null) {\n        // primitive values - just return source\n        return source;\n    }\n    else if (source instanceof Date) {\n        return new Date(source.getTime());\n    }\n    else if (source instanceof RegExp) {\n        var flags = source.flags ||\n            // old browsers compatibility\n            [\n                source.global ? 'g' : '',\n                source.ignoreCase ? 'i' : '',\n                source.multiline ? 'm' : '',\n                source.sticky ? 'y' : '',\n                source.unicode ? 'u' : '',\n            ].join('');\n        return new RegExp(source.source, flags);\n    }\n    if (circularReferenceChecker.hasAlreadyBeenSeen(source)) {\n        // remove circular references\n        return undefined;\n    }\n    else if (Array.isArray(source)) {\n        var merged_1 = Array.isArray(destination) ? destination : [];\n        for (var i = 0; i < source.length; ++i) {\n            merged_1[i] = mergeInto(merged_1[i], source[i], circularReferenceChecker);\n        }\n        return merged_1;\n    }\n    var merged = getType(destination) === 'object' ? destination : {};\n    for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n            merged[key] = mergeInto(merged[key], source[key], circularReferenceChecker);\n        }\n    }\n    return merged;\n}\n/**\n * A simplistic implementation of a deep clone algorithm.\n * Caveats:\n * - It doesn't maintain prototype chains - don't use with instances of custom classes.\n * - It doesn't handle Map and Set\n */\nexport function deepClone(value) {\n    return mergeInto(undefined, value);\n}\nexport function combine() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    var destination;\n    for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) {\n        var source = sources_1[_a];\n        // Ignore any undefined or null sources.\n        if (source === undefined || source === null) {\n            continue;\n        }\n        destination = mergeInto(destination, source);\n    }\n    return destination;\n}\nexport function requestIdleCallback(callback, opts) {\n    // Use 'requestIdleCallback' when available: it will throttle the mutation processing if the\n    // browser is busy rendering frames (ex: when frames are below 60fps). When not available, the\n    // fallback on 'requestAnimationFrame' will still ensure the mutations are processed after any\n    // browser rendering process (Layout, Recalculate Style, etc.), so we can serialize DOM nodes\n    // efficiently.\n    if (window.requestIdleCallback) {\n        var id_1 = window.requestIdleCallback(monitor(callback), opts);\n        return function () { return window.cancelIdleCallback(id_1); };\n    }\n    var id = window.requestAnimationFrame(monitor(callback));\n    return function () { return window.cancelAnimationFrame(id); };\n}\nexport function removeDuplicates(array) {\n    var deduplicated = [];\n    var set = new Set();\n    array.forEach(function (item) { return set.add(item); });\n    set.forEach(function (item) { return deduplicated.push(item); });\n    return deduplicated;\n}\n//# sourceMappingURL=utils.js.map","import { callMonitored } from '../domain/internalMonitoring';\nimport { computeStackTrace } from '../domain/tracekit';\nimport { jsonStringify, noop } from './utils';\nexport var ErrorSource = {\n    AGENT: 'agent',\n    CONSOLE: 'console',\n    CUSTOM: 'custom',\n    LOGGER: 'logger',\n    NETWORK: 'network',\n    SOURCE: 'source',\n    REPORT: 'report',\n};\nexport function formatUnknownError(stackTrace, errorObject, nonErrorPrefix, handlingStack) {\n    if (!stackTrace || (stackTrace.message === undefined && !(errorObject instanceof Error))) {\n        return {\n            message: \"\".concat(nonErrorPrefix, \" \").concat(jsonStringify(errorObject)),\n            stack: 'No stack, consider using an instance of Error',\n            handlingStack: handlingStack,\n            type: stackTrace && stackTrace.name,\n        };\n    }\n    return {\n        message: stackTrace.message || 'Empty message',\n        stack: toStackTraceString(stackTrace),\n        handlingStack: handlingStack,\n        type: stackTrace.name,\n    };\n}\nexport function toStackTraceString(stack) {\n    var result = formatErrorMessage(stack);\n    stack.stack.forEach(function (frame) {\n        var func = frame.func === '?' ? '<anonymous>' : frame.func;\n        var args = frame.args && frame.args.length > 0 ? \"(\".concat(frame.args.join(', '), \")\") : '';\n        var line = frame.line ? \":\".concat(frame.line) : '';\n        var column = frame.line && frame.column ? \":\".concat(frame.column) : '';\n        result += \"\\n  at \".concat(func).concat(args, \" @ \").concat(frame.url).concat(line).concat(column);\n    });\n    return result;\n}\nexport function getFileFromStackTraceString(stack) {\n    var _a;\n    return (_a = /@ (.+)/.exec(stack)) === null || _a === void 0 ? void 0 : _a[1];\n}\nexport function formatErrorMessage(stack) {\n    return \"\".concat(stack.name || 'Error', \": \").concat(stack.message);\n}\n/**\n Creates a stacktrace without SDK internal frames.\n \n Constraints:\n - Has to be called at the utmost position of the call stack.\n - No internal monitoring should encapsulate the function, that is why we need to use callMonitored inside of it.\n */\nexport function createHandlingStack() {\n    /**\n     * Skip the two internal frames:\n     * - SDK API (console.error, ...)\n     * - this function\n     * in order to keep only the user calls\n     */\n    var internalFramesToSkip = 2;\n    var error = new Error();\n    var formattedStack;\n    // IE needs to throw the error to fill in the stack trace\n    if (!error.stack) {\n        try {\n            throw error;\n        }\n        catch (e) {\n            noop();\n        }\n    }\n    callMonitored(function () {\n        var stackTrace = computeStackTrace(error);\n        stackTrace.stack = stackTrace.stack.slice(internalFramesToSkip);\n        formattedStack = toStackTraceString(stackTrace);\n    });\n    return formattedStack;\n}\n//# sourceMappingURL=error.js.map","var Observable = /** @class */ (function () {\n    function Observable(onFirstSubscribe) {\n        this.onFirstSubscribe = onFirstSubscribe;\n        this.observers = [];\n    }\n    Observable.prototype.subscribe = function (f) {\n        var _this = this;\n        if (!this.observers.length && this.onFirstSubscribe) {\n            this.onLastUnsubscribe = this.onFirstSubscribe() || undefined;\n        }\n        this.observers.push(f);\n        return {\n            unsubscribe: function () {\n                _this.observers = _this.observers.filter(function (other) { return f !== other; });\n                if (!_this.observers.length && _this.onLastUnsubscribe) {\n                    _this.onLastUnsubscribe();\n                }\n            },\n        };\n    };\n    Observable.prototype.notify = function (data) {\n        this.observers.forEach(function (observer) { return observer(data); });\n    };\n    return Observable;\n}());\nexport { Observable };\nexport function mergeObservables() {\n    var observables = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        observables[_i] = arguments[_i];\n    }\n    var globalObservable = new Observable(function () {\n        var subscriptions = observables.map(function (observable) {\n            return observable.subscribe(function (data) { return globalObservable.notify(data); });\n        });\n        return function () { return subscriptions.forEach(function (subscription) { return subscription.unsubscribe(); }); };\n    });\n    return globalObservable;\n}\n//# sourceMappingURL=observable.js.map","import { isNumber, ONE_YEAR, round } from './utils';\nexport function relativeToClocks(relative) {\n    return { relative: relative, timeStamp: getCorrectedTimeStamp(relative) };\n}\nfunction getCorrectedTimeStamp(relativeTime) {\n    var correctedOrigin = Date.now() - performance.now();\n    // apply correction only for positive drift\n    if (correctedOrigin > getNavigationStart()) {\n        // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n        return Math.round(correctedOrigin + relativeTime);\n    }\n    return getTimeStamp(relativeTime);\n}\nexport function currentDrift() {\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return Math.round(Date.now() - (getNavigationStart() + performance.now()));\n}\nexport function toServerDuration(duration) {\n    if (!isNumber(duration)) {\n        return duration;\n    }\n    return round(duration * 1e6, 0);\n}\nexport function timeStampNow() {\n    return Date.now();\n}\nexport function relativeNow() {\n    return performance.now();\n}\nexport function clocksNow() {\n    return { relative: relativeNow(), timeStamp: timeStampNow() };\n}\nexport function clocksOrigin() {\n    return { relative: 0, timeStamp: getNavigationStart() };\n}\nexport function elapsed(start, end) {\n    return (end - start);\n}\n/**\n * Get the time since the navigation was started.\n *\n * Note: this does not use `performance.timeOrigin` because it doesn't seem to reflect the actual\n * time on which the navigation has started: it may be much farther in the past, at least in Firefox 71.\n * Related issue in Firefox: https://bugzilla.mozilla.org/show_bug.cgi?id=1429926\n */\nexport function getRelativeTime(timestamp) {\n    return (timestamp - getNavigationStart());\n}\nexport function getTimeStamp(relativeTime) {\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return Math.round(getNavigationStart() + relativeTime);\n}\nexport function looksLikeRelativeTime(time) {\n    return time < ONE_YEAR;\n}\n/**\n * Navigation start slightly change on some rare cases\n */\nvar navigationStart;\nfunction getNavigationStart() {\n    if (navigationStart === undefined) {\n        navigationStart = performance.timing.navigationStart;\n    }\n    return navigationStart;\n}\nexport function resetNavigationStart() {\n    navigationStart = undefined;\n}\n//# sourceMappingURL=timeUtils.js.map","/**\n * LIMITATION:\n * For NPM setup, this feature flag singleton is shared between RUM and Logs product.\n * This means that an experimental flag set on the RUM product will be set on the Logs product.\n * So keep in mind that in certain configurations, your experimental feature flag may affect other products.\n */\nvar enabledExperimentalFeatures;\nexport function updateExperimentalFeatures(enabledFeatures) {\n    // Safely handle external data\n    if (!Array.isArray(enabledFeatures)) {\n        return;\n    }\n    if (!enabledExperimentalFeatures) {\n        enabledExperimentalFeatures = new Set(enabledFeatures);\n    }\n    enabledFeatures\n        .filter(function (flag) { return typeof flag === 'string'; })\n        .forEach(function (flag) {\n        enabledExperimentalFeatures.add(flag);\n    });\n}\nexport function isExperimentalFeatureEnabled(featureName) {\n    return !!enabledExperimentalFeatures && enabledExperimentalFeatures.has(featureName);\n}\nexport function resetExperimentalFeatures() {\n    enabledExperimentalFeatures = new Set();\n}\n//# sourceMappingURL=experimentalFeatures.js.map","import { display } from '../../tools/display';\nimport { toStackTraceString } from '../../tools/error';\nimport { assign, combine, jsonStringify, performDraw } from '../../tools/utils';\nimport { computeStackTrace } from '../tracekit';\nimport { Observable } from '../../tools/observable';\nimport { timeStampNow } from '../../tools/timeUtils';\nimport { isExperimentalFeatureEnabled } from '../configuration';\nvar monitoringConfiguration = { maxMessagesPerPage: 0, sentMessageCount: 0, telemetryEnabled: false };\nvar onInternalMonitoringMessageCollected;\nexport function startInternalMonitoring(configuration) {\n    var externalContextProvider;\n    var telemetryContextProvider;\n    var monitoringMessageObservable = new Observable();\n    var telemetryEventObservable = new Observable();\n    monitoringConfiguration.telemetryEnabled = performDraw(configuration.telemetrySampleRate);\n    onInternalMonitoringMessageCollected = function (message) {\n        monitoringMessageObservable.notify(withContext(message));\n        if (isExperimentalFeatureEnabled('telemetry') && monitoringConfiguration.telemetryEnabled) {\n            telemetryEventObservable.notify(toTelemetryEvent(message));\n        }\n    };\n    assign(monitoringConfiguration, {\n        maxMessagesPerPage: configuration.maxInternalMonitoringMessagesPerPage,\n        sentMessageCount: 0,\n    });\n    function withContext(message) {\n        return combine({ date: timeStampNow() }, externalContextProvider !== undefined ? externalContextProvider() : {}, message);\n    }\n    function toTelemetryEvent(message) {\n        return combine({\n            type: 'telemetry',\n            date: timeStampNow(),\n            service: 'browser-sdk',\n            version: \"4.8.1\",\n            source: 'browser',\n            _dd: {\n                format_version: 2,\n            },\n            telemetry: message, // https://github.com/microsoft/TypeScript/issues/48457\n        }, telemetryContextProvider !== undefined ? telemetryContextProvider() : {});\n    }\n    return {\n        setExternalContextProvider: function (provider) {\n            externalContextProvider = provider;\n        },\n        monitoringMessageObservable: monitoringMessageObservable,\n        setTelemetryContextProvider: function (provider) {\n            telemetryContextProvider = provider;\n        },\n        telemetryEventObservable: telemetryEventObservable,\n    };\n}\nexport function startFakeInternalMonitoring() {\n    var messages = [];\n    assign(monitoringConfiguration, {\n        maxMessagesPerPage: Infinity,\n        sentMessageCount: 0,\n    });\n    onInternalMonitoringMessageCollected = function (message) {\n        messages.push(message);\n    };\n    return messages;\n}\nexport function resetInternalMonitoring() {\n    onInternalMonitoringMessageCollected = undefined;\n    monitoringConfiguration.debugMode = undefined;\n}\nexport function monitored(_, __, descriptor) {\n    var originalMethod = descriptor.value;\n    descriptor.value = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var decorated = onInternalMonitoringMessageCollected ? monitor(originalMethod) : originalMethod;\n        return decorated.apply(this, args);\n    };\n}\nexport function monitor(fn) {\n    return function () {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return callMonitored(fn, this, arguments);\n    }; // consider output type has input type\n}\nexport function callMonitored(fn, context, args) {\n    try {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return fn.apply(context, args);\n    }\n    catch (e) {\n        logErrorIfDebug(e);\n        try {\n            addMonitoringError(e);\n        }\n        catch (e) {\n            logErrorIfDebug(e);\n        }\n    }\n}\nexport function addMonitoringMessage(message, context) {\n    logMessageIfDebug(message, context);\n    addToMonitoring(assign({\n        message: message,\n        status: \"debug\" /* debug */,\n    }, context));\n}\nexport function addMonitoringError(e) {\n    addToMonitoring(assign({\n        status: \"error\" /* error */,\n    }, formatError(e)));\n}\nfunction addToMonitoring(message) {\n    if (onInternalMonitoringMessageCollected &&\n        monitoringConfiguration.sentMessageCount < monitoringConfiguration.maxMessagesPerPage) {\n        monitoringConfiguration.sentMessageCount += 1;\n        onInternalMonitoringMessageCollected(message);\n    }\n}\nfunction formatError(e) {\n    if (e instanceof Error) {\n        var stackTrace = computeStackTrace(e);\n        return {\n            error: {\n                kind: stackTrace.name,\n                stack: toStackTraceString(stackTrace),\n            },\n            message: stackTrace.message,\n        };\n    }\n    return {\n        error: {\n            stack: 'Not an instance of error',\n        },\n        message: \"Uncaught \".concat(jsonStringify(e)),\n    };\n}\nexport function setDebugMode(debugMode) {\n    monitoringConfiguration.debugMode = debugMode;\n}\nfunction logErrorIfDebug(e) {\n    if (monitoringConfiguration.debugMode) {\n        display.error('[INTERNAL ERROR]', e);\n    }\n}\nfunction logMessageIfDebug(message, context) {\n    if (monitoringConfiguration.debugMode) {\n        display.log('[MONITORING MESSAGE]', message, context);\n    }\n}\n//# sourceMappingURL=internalMonitoring.js.map","import { display } from './display';\nexport function catchUserErrors(fn, errorMsg) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        try {\n            return fn.apply(void 0, args);\n        }\n        catch (err) {\n            display.error(errorMsg, err);\n        }\n    };\n}\n//# sourceMappingURL=catchUserErrors.js.map","var BUFFER_LIMIT = 500;\nvar BoundedBuffer = /** @class */ (function () {\n    function BoundedBuffer() {\n        this.buffer = [];\n    }\n    BoundedBuffer.prototype.add = function (callback) {\n        var length = this.buffer.push(callback);\n        if (length > BUFFER_LIMIT) {\n            this.buffer.splice(0, 1);\n        }\n    };\n    BoundedBuffer.prototype.drain = function () {\n        this.buffer.forEach(function (callback) { return callback(); });\n        this.buffer.length = 0;\n    };\n    return BoundedBuffer;\n}());\nexport { BoundedBuffer };\n//# sourceMappingURL=boundedBuffer.js.map","import { display } from '../tools/display';\nimport { findCommaSeparatedValue, generateUUID, ONE_SECOND } from '../tools/utils';\nexport var COOKIE_ACCESS_DELAY = ONE_SECOND;\nexport function setCookie(name, value, expireDelay, options) {\n    var date = new Date();\n    date.setTime(date.getTime() + expireDelay);\n    var expires = \"expires=\".concat(date.toUTCString());\n    var sameSite = options && options.crossSite ? 'none' : 'strict';\n    var domain = options && options.domain ? \";domain=\".concat(options.domain) : '';\n    var secure = options && options.secure ? ';secure' : '';\n    document.cookie = \"\".concat(name, \"=\").concat(value, \";\").concat(expires, \";path=/;samesite=\").concat(sameSite).concat(domain).concat(secure);\n}\nexport function getCookie(name) {\n    return findCommaSeparatedValue(document.cookie, name);\n}\nexport function deleteCookie(name, options) {\n    setCookie(name, '', 0, options);\n}\nexport function areCookiesAuthorized(options) {\n    if (document.cookie === undefined || document.cookie === null) {\n        return false;\n    }\n    try {\n        // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n        // the test cookie lifetime\n        var testCookieName = \"dd_cookie_test_\".concat(generateUUID());\n        var testCookieValue = 'test';\n        setCookie(testCookieName, testCookieValue, ONE_SECOND, options);\n        var isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue;\n        deleteCookie(testCookieName, options);\n        return isCookieCorrectlySet;\n    }\n    catch (error) {\n        display.error(error);\n        return false;\n    }\n}\n/**\n * No API to retrieve it, number of levels for subdomain and suffix are unknown\n * strategy: find the minimal domain on which cookies are allowed to be set\n * https://web.dev/same-site-same-origin/#site\n */\nvar getCurrentSiteCache;\nexport function getCurrentSite() {\n    if (getCurrentSiteCache === undefined) {\n        // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during\n        // the test cookie lifetime\n        var testCookieName = \"dd_site_test_\".concat(generateUUID());\n        var testCookieValue = 'test';\n        var domainLevels = window.location.hostname.split('.');\n        var candidateDomain = domainLevels.pop();\n        while (domainLevels.length && !getCookie(testCookieName)) {\n            candidateDomain = \"\".concat(domainLevels.pop(), \".\").concat(candidateDomain);\n            setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain });\n        }\n        deleteCookie(testCookieName, { domain: candidateDomain });\n        getCurrentSiteCache = candidateDomain;\n    }\n    return getCurrentSiteCache;\n}\n//# sourceMappingURL=cookie.js.map","import { getLinkElementOrigin, getLocationOrigin } from './utils';\nexport function normalizeUrl(url) {\n    return buildUrl(url, getLocationOrigin()).href;\n}\nexport function isValidUrl(url) {\n    try {\n        return !!buildUrl(url);\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function haveSameOrigin(url1, url2) {\n    return getOrigin(url1) === getOrigin(url2);\n}\nexport function getOrigin(url) {\n    return getLinkElementOrigin(buildUrl(url));\n}\nexport function getPathName(url) {\n    var pathname = buildUrl(url).pathname;\n    return pathname[0] === '/' ? pathname : \"/\".concat(pathname);\n}\nexport function getSearch(url) {\n    return buildUrl(url).search;\n}\nexport function getHash(url) {\n    return buildUrl(url).hash;\n}\nexport function buildUrl(url, base) {\n    if (checkURLSupported()) {\n        return base !== undefined ? new URL(url, base) : new URL(url);\n    }\n    if (base === undefined && !/:/.test(url)) {\n        throw new Error(\"Invalid URL: '\".concat(url, \"'\"));\n    }\n    var doc = document;\n    var anchorElement = doc.createElement('a');\n    if (base !== undefined) {\n        doc = document.implementation.createHTMLDocument('');\n        var baseElement = doc.createElement('base');\n        baseElement.href = base;\n        doc.head.appendChild(baseElement);\n        doc.body.appendChild(anchorElement);\n    }\n    anchorElement.href = url;\n    return anchorElement;\n}\nvar isURLSupported;\nfunction checkURLSupported() {\n    if (isURLSupported !== undefined) {\n        return isURLSupported;\n    }\n    try {\n        var url = new URL('http://test/path');\n        isURLSupported = url.href === 'http://test/path';\n        return isURLSupported;\n    }\n    catch (_a) {\n        isURLSupported = false;\n    }\n    return isURLSupported;\n}\n//# sourceMappingURL=urlPolyfill.js.map","import { getGlobalObject } from '..';\nexport function getEventBridge() {\n    var eventBridgeGlobal = getEventBridgeGlobal();\n    if (!eventBridgeGlobal) {\n        return;\n    }\n    return {\n        getAllowedWebViewHosts: function () {\n            return JSON.parse(eventBridgeGlobal.getAllowedWebViewHosts());\n        },\n        send: function (eventType, event) {\n            eventBridgeGlobal.send(JSON.stringify({ eventType: eventType, event: event }));\n        },\n    };\n}\nexport function canUseEventBridge(hostname) {\n    var _a;\n    if (hostname === void 0) { hostname = (_a = getGlobalObject().location) === null || _a === void 0 ? void 0 : _a.hostname; }\n    var bridge = getEventBridge();\n    return (!!bridge &&\n        bridge.getAllowedWebViewHosts().some(function (host) {\n            var escapedHost = host.replace(/\\./g, '\\\\.');\n            var isDomainOrSubDomain = new RegExp(\"^(.+\\\\.)*\".concat(escapedHost, \"$\"));\n            return isDomainOrSubDomain.test(hostname);\n        }));\n}\nfunction getEventBridgeGlobal() {\n    return getGlobalObject().DatadogEventBridge;\n}\n//# sourceMappingURL=eventBridge.js.map","import { timeStampNow } from '../../tools/timeUtils';\nimport { normalizeUrl } from '../../tools/urlPolyfill';\nimport { generateUUID } from '../../tools/utils';\nexport var ENDPOINTS = {\n    logs: 'logs',\n    rum: 'rum',\n    sessionReplay: 'session-replay',\n};\nvar INTAKE_TRACKS = {\n    logs: 'logs',\n    rum: 'rum',\n    sessionReplay: 'replay',\n};\nexport var INTAKE_SITE_US = 'datadoghq.com';\nexport function createEndpointBuilder(initConfiguration, endpointType, tags, source) {\n    var _a = initConfiguration.site, site = _a === void 0 ? INTAKE_SITE_US : _a, clientToken = initConfiguration.clientToken;\n    var domainParts = site.split('.');\n    var extension = domainParts.pop();\n    var host = \"\".concat(ENDPOINTS[endpointType], \".browser-intake-\").concat(domainParts.join('-'), \".\").concat(extension);\n    var baseUrl = \"https://\".concat(host, \"/api/v2/\").concat(INTAKE_TRACKS[endpointType]);\n    var proxyUrl = initConfiguration.proxyUrl && normalizeUrl(initConfiguration.proxyUrl);\n    return {\n        build: function () {\n            var parameters = \"ddsource=\".concat(source || 'browser') +\n                \"&ddtags=\".concat(encodeURIComponent([\"sdk_version:\".concat(\"4.8.1\")].concat(tags).join(','))) +\n                \"&dd-api-key=\".concat(clientToken) +\n                \"&dd-evp-origin-version=\".concat(encodeURIComponent(\"4.8.1\")) +\n                '&dd-evp-origin=browser' +\n                \"&dd-request-id=\".concat(generateUUID());\n            if (endpointType === 'rum') {\n                parameters += \"&batch_time=\".concat(timeStampNow());\n            }\n            var endpointUrl = \"\".concat(baseUrl, \"?\").concat(parameters);\n            return proxyUrl ? \"\".concat(proxyUrl, \"?ddforward=\").concat(encodeURIComponent(endpointUrl)) : endpointUrl;\n        },\n        buildIntakeUrl: function () {\n            return proxyUrl ? \"\".concat(proxyUrl, \"?ddforward\") : baseUrl;\n        },\n    };\n}\n//# sourceMappingURL=endpointBuilder.js.map","import { display } from '../../tools/display';\nexport var TAG_SIZE_LIMIT = 200;\nexport function buildTags(configuration) {\n    var env = configuration.env, service = configuration.service, version = configuration.version, datacenter = configuration.datacenter;\n    var tags = [];\n    if (env) {\n        tags.push(buildTag('env', env));\n    }\n    if (service) {\n        tags.push(buildTag('service', service));\n    }\n    if (version) {\n        tags.push(buildTag('version', version));\n    }\n    if (datacenter) {\n        tags.push(buildTag('datacenter', datacenter));\n    }\n    return tags;\n}\nvar FORBIDDEN_CHARACTERS = /[^a-z0-9_:./-]/;\nexport function buildTag(key, rawValue) {\n    // See https://docs.datadoghq.com/getting_started/tagging/#defining-tags for tags syntax. Note\n    // that the backend may not follow the exact same rules, so we only want to display an informal\n    // warning.\n    var valueSizeLimit = TAG_SIZE_LIMIT - key.length - 1;\n    if (rawValue.length > valueSizeLimit || FORBIDDEN_CHARACTERS.test(rawValue)) {\n        display.warn(\"\".concat(key, \" value doesn't meet tag requirements and will be sanitized\"));\n    }\n    // Let the backend do most of the sanitization, but still make sure multiple tags can't be crafted\n    // by forging a value containing commas.\n    var sanitizedValue = rawValue.replace(/,/g, '_');\n    return \"\".concat(key, \":\").concat(sanitizedValue);\n}\n//# sourceMappingURL=tags.js.map","import { getCurrentSite } from '../../browser/cookie';\nimport { catchUserErrors } from '../../tools/catchUserErrors';\nimport { display } from '../../tools/display';\nimport { assign, isPercentage, ONE_KILO_BYTE, ONE_SECOND } from '../../tools/utils';\nimport { updateExperimentalFeatures } from './experimentalFeatures';\nimport { computeTransportConfiguration } from './transportConfiguration';\nexport var DefaultPrivacyLevel = {\n    ALLOW: 'allow',\n    MASK: 'mask',\n    MASK_USER_INPUT: 'mask-user-input',\n};\nexport function validateAndBuildConfiguration(initConfiguration) {\n    var _a, _b;\n    if (!initConfiguration || !initConfiguration.clientToken) {\n        display.error('Client Token is not configured, we will not send any data.');\n        return;\n    }\n    if (initConfiguration.sampleRate !== undefined && !isPercentage(initConfiguration.sampleRate)) {\n        display.error('Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.telemetrySampleRate !== undefined && !isPercentage(initConfiguration.telemetrySampleRate)) {\n        display.error('Telemetry Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    // Set the experimental feature flags as early as possible, so we can use them in most places\n    updateExperimentalFeatures(initConfiguration.enableExperimentalFeatures);\n    return assign({\n        beforeSend: initConfiguration.beforeSend && catchUserErrors(initConfiguration.beforeSend, 'beforeSend threw an error:'),\n        cookieOptions: buildCookieOptions(initConfiguration),\n        sampleRate: (_a = initConfiguration.sampleRate) !== null && _a !== void 0 ? _a : 100,\n        telemetrySampleRate: (_b = initConfiguration.telemetrySampleRate) !== null && _b !== void 0 ? _b : 20,\n        service: initConfiguration.service,\n        silentMultipleInit: !!initConfiguration.silentMultipleInit,\n        /**\n         * beacon payload max queue size implementation is 64kb\n         * ensure that we leave room for logs, rum and potential other users\n         */\n        batchBytesLimit: 16 * ONE_KILO_BYTE,\n        eventRateLimiterThreshold: 3000,\n        maxInternalMonitoringMessagesPerPage: 15,\n        /**\n         * flush automatically, aim to be lower than ALB connection timeout\n         * to maximize connection reuse.\n         */\n        flushTimeout: 30 * ONE_SECOND,\n        /**\n         * Logs intake limit\n         */\n        maxBatchSize: 50,\n        maxMessageSize: 256 * ONE_KILO_BYTE,\n    }, computeTransportConfiguration(initConfiguration));\n}\nexport function buildCookieOptions(initConfiguration) {\n    var cookieOptions = {};\n    cookieOptions.secure = mustUseSecureCookie(initConfiguration);\n    cookieOptions.crossSite = !!initConfiguration.useCrossSiteSessionCookie;\n    if (initConfiguration.trackSessionAcrossSubdomains) {\n        cookieOptions.domain = getCurrentSite();\n    }\n    return cookieOptions;\n}\nfunction mustUseSecureCookie(initConfiguration) {\n    return !!initConfiguration.useSecureSessionCookie || !!initConfiguration.useCrossSiteSessionCookie;\n}\n//# sourceMappingURL=configuration.js.map","import { assign, objectValues } from '../../tools/utils';\nimport { createEndpointBuilder, INTAKE_SITE_US } from './endpointBuilder';\nimport { buildTags } from './tags';\nexport function computeTransportConfiguration(initConfiguration) {\n    var tags = buildTags(initConfiguration);\n    var endpointBuilders = computeEndpointBuilders(initConfiguration, tags);\n    var intakeEndpoints = objectValues(endpointBuilders).map(function (builder) { return builder.buildIntakeUrl(); });\n    var replicaConfiguration = computeReplicaConfiguration(initConfiguration, intakeEndpoints, tags);\n    return assign({\n        isIntakeUrl: function (url) { return intakeEndpoints.some(function (intakeEndpoint) { return url.indexOf(intakeEndpoint) === 0; }); },\n        replica: replicaConfiguration,\n    }, endpointBuilders);\n}\nfunction computeEndpointBuilders(initConfiguration, tags) {\n    var endpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(initConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(initConfiguration, 'rum', tags),\n        sessionReplayEndpointBuilder: createEndpointBuilder(initConfiguration, 'sessionReplay', tags),\n    };\n    if (initConfiguration.internalMonitoringApiKey) {\n        return assign(endpointBuilders, {\n            internalMonitoringEndpointBuilder: createEndpointBuilder(assign({}, initConfiguration, { clientToken: initConfiguration.internalMonitoringApiKey }), 'logs', tags, 'browser-agent-internal-monitoring'),\n        });\n    }\n    return endpointBuilders;\n}\nfunction computeReplicaConfiguration(initConfiguration, intakeEndpoints, tags) {\n    if (!initConfiguration.replica) {\n        return;\n    }\n    var replicaConfiguration = assign({}, initConfiguration, {\n        site: INTAKE_SITE_US,\n        clientToken: initConfiguration.replica.clientToken,\n    });\n    var replicaEndpointBuilders = {\n        logsEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags),\n        rumEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'rum', tags),\n        internalMonitoringEndpointBuilder: createEndpointBuilder(replicaConfiguration, 'logs', tags, 'browser-agent-internal-monitoring'),\n    };\n    intakeEndpoints.push.apply(intakeEndpoints, objectValues(replicaEndpointBuilders).map(function (builder) { return builder.buildIntakeUrl(); }));\n    return assign({ applicationId: initConfiguration.replica.applicationId }, replicaEndpointBuilders);\n}\n//# sourceMappingURL=transportConfiguration.js.map","import { getCookie } from '@datadog/browser-core';\nexport var SYNTHETICS_TEST_ID_COOKIE_NAME = 'datadog-synthetics-public-id';\nexport var SYNTHETICS_RESULT_ID_COOKIE_NAME = 'datadog-synthetics-result-id';\nexport var SYNTHETICS_INJECTS_RUM_COOKIE_NAME = 'datadog-synthetics-injects-rum';\nexport function getSyntheticsContext() {\n    var testId = window._DATADOG_SYNTHETICS_PUBLIC_ID || getCookie(SYNTHETICS_TEST_ID_COOKIE_NAME);\n    var resultId = window._DATADOG_SYNTHETICS_RESULT_ID || getCookie(SYNTHETICS_RESULT_ID_COOKIE_NAME);\n    if (typeof testId === 'string' && typeof resultId === 'string') {\n        return {\n            test_id: testId,\n            result_id: resultId,\n            injected: willSyntheticsInjectRum(),\n        };\n    }\n}\nexport function willSyntheticsInjectRum() {\n    return Boolean(window._DATADOG_SYNTHETICS_INJECTS_RUM || getCookie(SYNTHETICS_INJECTS_RUM_COOKIE_NAME));\n}\n//# sourceMappingURL=syntheticsContext.js.map","import { display } from '../tools/display';\nimport { addEventListener, jsonStringify, noop, objectValues } from '../tools/utils';\nimport { monitor } from '../domain/internalMonitoring';\n// https://en.wikipedia.org/wiki/UTF-8\n// eslint-disable-next-line no-control-regex\nvar HAS_MULTI_BYTES_CHARACTERS = /[^\\u0000-\\u007F]/;\nvar Batch = /** @class */ (function () {\n    function Batch(request, maxSize, bytesLimit, maxMessageSize, flushTimeout, beforeUnloadCallback) {\n        if (beforeUnloadCallback === void 0) { beforeUnloadCallback = noop; }\n        this.request = request;\n        this.maxSize = maxSize;\n        this.bytesLimit = bytesLimit;\n        this.maxMessageSize = maxMessageSize;\n        this.flushTimeout = flushTimeout;\n        this.beforeUnloadCallback = beforeUnloadCallback;\n        this.pushOnlyBuffer = [];\n        this.upsertBuffer = {};\n        this.bufferBytesSize = 0;\n        this.bufferMessageCount = 0;\n        this.flushOnVisibilityHidden();\n        this.flushPeriodically();\n    }\n    Batch.prototype.add = function (message) {\n        this.addOrUpdate(message);\n    };\n    Batch.prototype.upsert = function (message, key) {\n        this.addOrUpdate(message, key);\n    };\n    Batch.prototype.flush = function (reason) {\n        if (this.bufferMessageCount !== 0) {\n            var messages = this.pushOnlyBuffer.concat(objectValues(this.upsertBuffer));\n            this.request.send(messages.join('\\n'), this.bufferBytesSize, reason);\n            this.pushOnlyBuffer = [];\n            this.upsertBuffer = {};\n            this.bufferBytesSize = 0;\n            this.bufferMessageCount = 0;\n        }\n    };\n    Batch.prototype.sizeInBytes = function (candidate) {\n        // Accurate byte size computations can degrade performances when there is a lot of events to process\n        if (!HAS_MULTI_BYTES_CHARACTERS.test(candidate)) {\n            return candidate.length;\n        }\n        if (window.TextEncoder !== undefined) {\n            return new TextEncoder().encode(candidate).length;\n        }\n        return new Blob([candidate]).size;\n    };\n    Batch.prototype.addOrUpdate = function (message, key) {\n        var _a = this.process(message), processedMessage = _a.processedMessage, messageBytesSize = _a.messageBytesSize;\n        if (messageBytesSize >= this.maxMessageSize) {\n            display.warn(\"Discarded a message whose size was bigger than the maximum allowed size \".concat(this.maxMessageSize, \"KB.\"));\n            return;\n        }\n        if (this.hasMessageFor(key)) {\n            this.remove(key);\n        }\n        if (this.willReachedBytesLimitWith(messageBytesSize)) {\n            this.flush('willReachedBytesLimitWith');\n        }\n        this.push(processedMessage, messageBytesSize, key);\n        if (this.isFull()) {\n            this.flush('isFull');\n        }\n    };\n    Batch.prototype.process = function (message) {\n        var processedMessage = jsonStringify(message);\n        var messageBytesSize = this.sizeInBytes(processedMessage);\n        return { processedMessage: processedMessage, messageBytesSize: messageBytesSize };\n    };\n    Batch.prototype.push = function (processedMessage, messageBytesSize, key) {\n        if (this.bufferMessageCount > 0) {\n            // \\n separator at serialization\n            this.bufferBytesSize += 1;\n        }\n        if (key !== undefined) {\n            this.upsertBuffer[key] = processedMessage;\n        }\n        else {\n            this.pushOnlyBuffer.push(processedMessage);\n        }\n        this.bufferBytesSize += messageBytesSize;\n        this.bufferMessageCount += 1;\n    };\n    Batch.prototype.remove = function (key) {\n        var removedMessage = this.upsertBuffer[key];\n        delete this.upsertBuffer[key];\n        var messageBytesSize = this.sizeInBytes(removedMessage);\n        this.bufferBytesSize -= messageBytesSize;\n        this.bufferMessageCount -= 1;\n        if (this.bufferMessageCount > 0) {\n            this.bufferBytesSize -= 1;\n        }\n    };\n    Batch.prototype.hasMessageFor = function (key) {\n        return key !== undefined && this.upsertBuffer[key] !== undefined;\n    };\n    Batch.prototype.willReachedBytesLimitWith = function (messageBytesSize) {\n        // byte of the separator at the end of the message\n        return this.bufferBytesSize + messageBytesSize + 1 >= this.bytesLimit;\n    };\n    Batch.prototype.isFull = function () {\n        return this.bufferMessageCount === this.maxSize || this.bufferBytesSize >= this.bytesLimit;\n    };\n    Batch.prototype.flushPeriodically = function () {\n        var _this = this;\n        setTimeout(monitor(function () {\n            _this.flush('flushPeriodically');\n            _this.flushPeriodically();\n        }), this.flushTimeout);\n    };\n    Batch.prototype.flushOnVisibilityHidden = function () {\n        var _this = this;\n        /**\n         * With sendBeacon, requests are guaranteed to be successfully sent during document unload\n         */\n        // @ts-ignore this function is not always defined\n        if (navigator.sendBeacon) {\n            /**\n             * beforeunload is called before visibilitychange\n             * register first to be sure to be called before flush on beforeunload\n             * caveat: unload can still be canceled by another listener\n             */\n            addEventListener(window, \"beforeunload\" /* BEFORE_UNLOAD */, this.beforeUnloadCallback);\n            /**\n             * Only event that guarantee to fire on mobile devices when the page transitions to background state\n             * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.\n             */\n            addEventListener(document, \"visibilitychange\" /* VISIBILITY_CHANGE */, function () {\n                if (document.visibilityState === 'hidden') {\n                    _this.flush(\"visibilitychange\" /* VISIBILITY_CHANGE */);\n                }\n            });\n            /**\n             * Safari does not support yet to send a request during:\n             * - a visibility change during doc unload (cf: https://bugs.webkit.org/show_bug.cgi?id=194897)\n             * - a page hide transition (cf: https://bugs.webkit.org/show_bug.cgi?id=188329)\n             */\n            addEventListener(window, \"beforeunload\" /* BEFORE_UNLOAD */, function () { return _this.flush(\"beforeunload\" /* BEFORE_UNLOAD */); });\n        }\n    };\n    return Batch;\n}());\nexport { Batch };\n//# sourceMappingURL=batch.js.map","import { monitor, addMonitoringError, addMonitoringMessage } from '../domain/internalMonitoring';\nvar hasReportedXhrError = false;\n/**\n * Use POST request without content type to:\n * - avoid CORS preflight requests\n * - allow usage of sendBeacon\n *\n * multiple elements are sent separated by \\n in order\n * to be parsed correctly without content type header\n */\nvar HttpRequest = /** @class */ (function () {\n    function HttpRequest(endpointBuilder, bytesLimit) {\n        this.endpointBuilder = endpointBuilder;\n        this.bytesLimit = bytesLimit;\n    }\n    HttpRequest.prototype.send = function (data, size, flushReason) {\n        var url = this.endpointBuilder.build();\n        var tryBeacon = !!navigator.sendBeacon && size < this.bytesLimit;\n        if (tryBeacon) {\n            try {\n                var isQueued = navigator.sendBeacon(url, data);\n                if (isQueued) {\n                    return;\n                }\n            }\n            catch (e) {\n                reportBeaconError(e);\n            }\n        }\n        var transportIntrospection = function (event) {\n            var req = event === null || event === void 0 ? void 0 : event.currentTarget;\n            if (req.status >= 200 && req.status < 300) {\n                return;\n            }\n            if (!hasReportedXhrError) {\n                hasReportedXhrError = true;\n                addMonitoringMessage('XHR fallback failed', {\n                    on_line: navigator.onLine,\n                    size: size,\n                    url: url,\n                    try_beacon: tryBeacon,\n                    flush_reason: flushReason,\n                    event: {\n                        is_trusted: event.isTrusted,\n                        total: event.total,\n                        loaded: event.loaded,\n                    },\n                    request: {\n                        status: req.status,\n                        ready_state: req.readyState,\n                        response_text: req.responseText.slice(0, 512),\n                    },\n                });\n            }\n        };\n        var request = new XMLHttpRequest();\n        request.addEventListener('loadend', monitor(function (event) { return transportIntrospection(event); }));\n        request.open('POST', url, true);\n        request.send(data);\n    };\n    return HttpRequest;\n}());\nexport { HttpRequest };\nvar hasReportedBeaconError = false;\nfunction reportBeaconError(e) {\n    if (!hasReportedBeaconError) {\n        hasReportedBeaconError = true;\n        addMonitoringError(e);\n    }\n}\n//# sourceMappingURL=httpRequest.js.map","import { monitor, Observable } from '@datadog/browser-core';\nexport function createDOMMutationObservable() {\n    var MutationObserver = getMutationObserverConstructor();\n    var observable = new Observable(function () {\n        if (!MutationObserver) {\n            return;\n        }\n        var observer = new MutationObserver(monitor(function () { return observable.notify(); }));\n        observer.observe(document, {\n            attributes: true,\n            characterData: true,\n            childList: true,\n            subtree: true,\n        });\n        return function () { return observer.disconnect(); };\n    });\n    return observable;\n}\nexport function getMutationObserverConstructor() {\n    var constructor;\n    var browserWindow = window;\n    // Angular uses Zone.js to provide a context persisting across async tasks.  Zone.js replaces the\n    // global MutationObserver constructor with a patched version to support the context propagation.\n    // There is an ongoing issue[1][2] with this setup when using a MutationObserver within a Angular\n    // component: on some occasions, the callback is being called in an infinite loop, causing the\n    // page to freeze (even if the callback is completely empty).\n    //\n    // To work around this issue, we are using the Zone __symbol__ API to get the original, unpatched\n    // MutationObserver constructor.\n    //\n    // [1] https://github.com/angular/angular/issues/26948\n    // [2] https://github.com/angular/angular/issues/31712\n    if (browserWindow.Zone) {\n        var symbol = browserWindow.Zone.__symbol__('MutationObserver');\n        constructor = browserWindow[symbol];\n    }\n    if (!constructor) {\n        constructor = browserWindow.MutationObserver;\n    }\n    return constructor;\n}\n//# sourceMappingURL=domMutationObservable.js.map","import { assign, addMonitoringMessage, elapsed, getPathName, includes, isValidUrl, toServerDuration, } from '@datadog/browser-core';\nexport var FAKE_INITIAL_DOCUMENT = 'initial_document';\nvar RESOURCE_TYPES = [\n    [\"document\" /* DOCUMENT */, function (initiatorType) { return FAKE_INITIAL_DOCUMENT === initiatorType; }],\n    [\"xhr\" /* XHR */, function (initiatorType) { return 'xmlhttprequest' === initiatorType; }],\n    [\"fetch\" /* FETCH */, function (initiatorType) { return 'fetch' === initiatorType; }],\n    [\"beacon\" /* BEACON */, function (initiatorType) { return 'beacon' === initiatorType; }],\n    [\"css\" /* CSS */, function (_, path) { return /\\.css$/i.test(path); }],\n    [\"js\" /* JS */, function (_, path) { return /\\.js$/i.test(path); }],\n    [\n        \"image\" /* IMAGE */,\n        function (initiatorType, path) {\n            return includes(['image', 'img', 'icon'], initiatorType) || /\\.(gif|jpg|jpeg|tiff|png|svg|ico)$/i.exec(path) !== null;\n        },\n    ],\n    [\"font\" /* FONT */, function (_, path) { return /\\.(woff|eot|woff2|ttf)$/i.exec(path) !== null; }],\n    [\n        \"media\" /* MEDIA */,\n        function (initiatorType, path) {\n            return includes(['audio', 'video'], initiatorType) || /\\.(mp3|mp4)$/i.exec(path) !== null;\n        },\n    ],\n];\nexport function computeResourceKind(timing) {\n    var url = timing.name;\n    if (!isValidUrl(url)) {\n        addMonitoringMessage(\"Failed to construct URL for \\\"\".concat(timing.name, \"\\\"\"));\n        return \"other\" /* OTHER */;\n    }\n    var path = getPathName(url);\n    for (var _i = 0, RESOURCE_TYPES_1 = RESOURCE_TYPES; _i < RESOURCE_TYPES_1.length; _i++) {\n        var _a = RESOURCE_TYPES_1[_i], type = _a[0], isType = _a[1];\n        if (isType(timing.initiatorType, path)) {\n            return type;\n        }\n    }\n    return \"other\" /* OTHER */;\n}\nfunction areInOrder() {\n    var numbers = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        numbers[_i] = arguments[_i];\n    }\n    for (var i = 1; i < numbers.length; i += 1) {\n        if (numbers[i - 1] > numbers[i]) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function isRequestKind(timing) {\n    return timing.initiatorType === 'xmlhttprequest' || timing.initiatorType === 'fetch';\n}\nexport function computePerformanceResourceDuration(entry) {\n    var duration = entry.duration, startTime = entry.startTime, responseEnd = entry.responseEnd;\n    // Safari duration is always 0 on timings blocked by cross origin policies.\n    if (duration === 0 && startTime < responseEnd) {\n        return toServerDuration(elapsed(startTime, responseEnd));\n    }\n    return toServerDuration(duration);\n}\nexport function computePerformanceResourceDetails(entry) {\n    var validEntry = toValidEntry(entry);\n    if (!validEntry) {\n        return undefined;\n    }\n    var startTime = validEntry.startTime, fetchStart = validEntry.fetchStart, redirectStart = validEntry.redirectStart, redirectEnd = validEntry.redirectEnd, domainLookupStart = validEntry.domainLookupStart, domainLookupEnd = validEntry.domainLookupEnd, connectStart = validEntry.connectStart, secureConnectionStart = validEntry.secureConnectionStart, connectEnd = validEntry.connectEnd, requestStart = validEntry.requestStart, responseStart = validEntry.responseStart, responseEnd = validEntry.responseEnd;\n    var details = {\n        download: formatTiming(startTime, responseStart, responseEnd),\n        first_byte: formatTiming(startTime, requestStart, responseStart),\n    };\n    // Make sure a connection occurred\n    if (connectEnd !== fetchStart) {\n        details.connect = formatTiming(startTime, connectStart, connectEnd);\n        // Make sure a secure connection occurred\n        if (areInOrder(connectStart, secureConnectionStart, connectEnd)) {\n            details.ssl = formatTiming(startTime, secureConnectionStart, connectEnd);\n        }\n    }\n    // Make sure a domain lookup occurred\n    if (domainLookupEnd !== fetchStart) {\n        details.dns = formatTiming(startTime, domainLookupStart, domainLookupEnd);\n    }\n    if (hasRedirection(entry)) {\n        details.redirect = formatTiming(startTime, redirectStart, redirectEnd);\n    }\n    return details;\n}\nexport function toValidEntry(entry) {\n    // Ensure timings are in the right order. On top of filtering out potential invalid\n    // RumPerformanceResourceTiming, it will ignore entries from requests where timings cannot be\n    // collected, for example cross origin requests without a \"Timing-Allow-Origin\" header allowing\n    // it.\n    if (!areInOrder(entry.startTime, entry.fetchStart, entry.domainLookupStart, entry.domainLookupEnd, entry.connectStart, entry.connectEnd, entry.requestStart, entry.responseStart, entry.responseEnd)) {\n        return undefined;\n    }\n    if (!hasRedirection(entry)) {\n        return entry;\n    }\n    var redirectStart = entry.redirectStart, redirectEnd = entry.redirectEnd;\n    // Firefox doesn't provide redirect timings on cross origin requests.\n    // Provide a default for those.\n    if (redirectStart < entry.startTime) {\n        redirectStart = entry.startTime;\n    }\n    if (redirectEnd < entry.startTime) {\n        redirectEnd = entry.fetchStart;\n    }\n    // Make sure redirect timings are in order\n    if (!areInOrder(entry.startTime, redirectStart, redirectEnd, entry.fetchStart)) {\n        return undefined;\n    }\n    return assign({}, entry, {\n        redirectEnd: redirectEnd,\n        redirectStart: redirectStart,\n    });\n}\nfunction hasRedirection(entry) {\n    // The only time fetchStart is different than startTime is if a redirection occurred.\n    return entry.fetchStart !== entry.startTime;\n}\nfunction formatTiming(origin, start, end) {\n    return {\n        duration: toServerDuration(elapsed(start, end)),\n        start: toServerDuration(elapsed(origin, start)),\n    };\n}\nexport function computeSize(entry) {\n    // Make sure a request actually occurred\n    if (entry.startTime < entry.responseStart) {\n        return entry.decodedBodySize;\n    }\n    return undefined;\n}\nexport function isAllowedRequestUrl(configuration, url) {\n    return url && !configuration.isIntakeUrl(url);\n}\n//# sourceMappingURL=resourceUtils.js.map","import { findCommaSeparatedValue, ONE_MINUTE } from '@datadog/browser-core';\nexport var INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD = 2 * ONE_MINUTE;\nexport function getDocumentTraceId(document) {\n    var data = getDocumentTraceDataFromMeta(document) || getDocumentTraceDataFromComment(document);\n    if (!data || data.traceTime <= Date.now() - INITIAL_DOCUMENT_OUTDATED_TRACE_ID_THRESHOLD) {\n        return undefined;\n    }\n    return data.traceId;\n}\nexport function getDocumentTraceDataFromMeta(document) {\n    var traceIdMeta = document.querySelector('meta[name=dd-trace-id]');\n    var traceTimeMeta = document.querySelector('meta[name=dd-trace-time]');\n    return createDocumentTraceData(traceIdMeta && traceIdMeta.content, traceTimeMeta && traceTimeMeta.content);\n}\nexport function getDocumentTraceDataFromComment(document) {\n    var comment = findTraceComment(document);\n    if (!comment) {\n        return undefined;\n    }\n    return createDocumentTraceData(findCommaSeparatedValue(comment, 'trace-id'), findCommaSeparatedValue(comment, 'trace-time'));\n}\nexport function createDocumentTraceData(traceId, rawTraceTime) {\n    var traceTime = rawTraceTime && Number(rawTraceTime);\n    if (!traceId || !traceTime) {\n        return undefined;\n    }\n    return {\n        traceId: traceId,\n        traceTime: traceTime,\n    };\n}\nexport function findTraceComment(document) {\n    // 1. Try to find the comment as a direct child of the document\n    // Note: TSLint advises to use a 'for of', but TS doesn't allow to use 'for of' if the iterated\n    // value is not an array or string (here, a NodeList).\n    // eslint-disable-next-line @typescript-eslint/prefer-for-of\n    for (var i = 0; i < document.childNodes.length; i += 1) {\n        var comment = getTraceCommentFromNode(document.childNodes[i]);\n        if (comment) {\n            return comment;\n        }\n    }\n    // 2. If the comment is placed after the </html> tag, but have some space or new lines before or\n    // after, the DOM parser will lift it (and the surrounding text) at the end of the <body> tag.\n    // Try to look for the comment at the end of the <body> by by iterating over its child nodes in\n    // reverse order, stopping if we come across a non-text node.\n    if (document.body) {\n        for (var i = document.body.childNodes.length - 1; i >= 0; i -= 1) {\n            var node = document.body.childNodes[i];\n            var comment = getTraceCommentFromNode(node);\n            if (comment) {\n                return comment;\n            }\n            if (!isTextNode(node)) {\n                break;\n            }\n        }\n    }\n}\nfunction getTraceCommentFromNode(node) {\n    if (node && isCommentNode(node)) {\n        var match = /^\\s*DATADOG;(.*?)\\s*$/.exec(node.data);\n        if (match) {\n            return match[1];\n        }\n    }\n}\nfunction isCommentNode(node) {\n    return node.nodeName === '#comment';\n}\nfunction isTextNode(node) {\n    return node.nodeName === '#text';\n}\n//# sourceMappingURL=getDocumentTraceId.js.map","import { assign, addEventListeners, getRelativeTime, isNumber, monitor, relativeNow, runOnReadyState, } from '@datadog/browser-core';\nimport { FAKE_INITIAL_DOCUMENT, isAllowedRequestUrl } from '../domain/rumEventsCollection/resource/resourceUtils';\nimport { getDocumentTraceId } from '../domain/tracing/getDocumentTraceId';\nfunction supportPerformanceObject() {\n    return window.performance !== undefined && 'getEntries' in performance;\n}\nexport function supportPerformanceTimingEvent(entryType) {\n    return (window.PerformanceObserver &&\n        PerformanceObserver.supportedEntryTypes !== undefined &&\n        PerformanceObserver.supportedEntryTypes.includes(entryType));\n}\nexport function supportPerformanceEntry() {\n    // Safari 10 doesn't support PerformanceEntry\n    return typeof PerformanceEntry === 'function';\n}\nexport function startPerformanceCollection(lifeCycle, configuration) {\n    retrieveInitialDocumentResourceTiming(function (timing) {\n        handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n    });\n    if (supportPerformanceObject()) {\n        var performanceEntries_1 = performance.getEntries();\n        // Because the performance entry list can be quite large\n        // delay the computation to prevent the SDK from blocking the main thread on init\n        setTimeout(monitor(function () { return handleRumPerformanceEntries(lifeCycle, configuration, performanceEntries_1); }));\n    }\n    if (window.PerformanceObserver) {\n        var handlePerformanceEntryList_1 = monitor(function (entries) {\n            return handleRumPerformanceEntries(lifeCycle, configuration, entries.getEntries());\n        });\n        var mainEntries = ['resource', 'navigation', 'longtask', 'paint'];\n        var experimentalEntries = ['largest-contentful-paint', 'first-input', 'layout-shift'];\n        try {\n            // Experimental entries are not retrieved by performance.getEntries()\n            // use a single PerformanceObserver with buffered flag by type\n            // to get values that could happen before SDK init\n            experimentalEntries.forEach(function (type) {\n                var observer = new PerformanceObserver(handlePerformanceEntryList_1);\n                observer.observe({ type: type, buffered: true });\n            });\n        }\n        catch (e) {\n            // Some old browser versions (ex: chrome 67) don't support the PerformanceObserver type and buffered options\n            // In these cases, fallback to PerformanceObserver with entryTypes\n            mainEntries.push.apply(mainEntries, experimentalEntries);\n        }\n        var mainObserver = new PerformanceObserver(handlePerformanceEntryList_1);\n        mainObserver.observe({ entryTypes: mainEntries });\n        if (supportPerformanceObject() && 'addEventListener' in performance) {\n            // https://bugzilla.mozilla.org/show_bug.cgi?id=1559377\n            performance.addEventListener('resourcetimingbufferfull', function () {\n                performance.clearResourceTimings();\n            });\n        }\n    }\n    if (!supportPerformanceTimingEvent('navigation')) {\n        retrieveNavigationTiming(function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n    if (!supportPerformanceTimingEvent('first-input')) {\n        retrieveFirstInputTiming(function (timing) {\n            handleRumPerformanceEntries(lifeCycle, configuration, [timing]);\n        });\n    }\n}\nexport function retrieveInitialDocumentResourceTiming(callback) {\n    runOnReadyState('interactive', function () {\n        var timing;\n        var forcedAttributes = {\n            entryType: 'resource',\n            initiatorType: FAKE_INITIAL_DOCUMENT,\n            traceId: getDocumentTraceId(document),\n        };\n        if (supportPerformanceTimingEvent('navigation') && performance.getEntriesByType('navigation').length > 0) {\n            var navigationEntry = performance.getEntriesByType('navigation')[0];\n            timing = assign(navigationEntry.toJSON(), forcedAttributes);\n        }\n        else {\n            var relativePerformanceTiming = computeRelativePerformanceTiming();\n            timing = assign(relativePerformanceTiming, {\n                decodedBodySize: 0,\n                duration: relativePerformanceTiming.responseEnd,\n                name: window.location.href,\n                startTime: 0,\n            }, forcedAttributes);\n        }\n        callback(timing);\n    });\n}\nfunction retrieveNavigationTiming(callback) {\n    function sendFakeTiming() {\n        callback(assign(computeRelativePerformanceTiming(), {\n            entryType: 'navigation',\n        }));\n    }\n    runOnReadyState('complete', function () {\n        // Send it a bit after the actual load event, so the \"loadEventEnd\" timing is accurate\n        setTimeout(monitor(sendFakeTiming));\n    });\n}\n/**\n * first-input timing entry polyfill based on\n * https://github.com/GoogleChrome/web-vitals/blob/master/src/lib/polyfills/firstInputPolyfill.ts\n */\nfunction retrieveFirstInputTiming(callback) {\n    var startTimeStamp = Date.now();\n    var timingSent = false;\n    var removeEventListeners = addEventListeners(window, [\"click\" /* CLICK */, \"mousedown\" /* MOUSE_DOWN */, \"keydown\" /* KEY_DOWN */, \"touchstart\" /* TOUCH_START */, \"pointerdown\" /* POINTER_DOWN */], function (evt) {\n        // Only count cancelable events, which should trigger behavior important to the user.\n        if (!evt.cancelable) {\n            return;\n        }\n        // This timing will be used to compute the \"first Input delay\", which is the delta between\n        // when the system received the event (e.g. evt.timeStamp) and when it could run the callback\n        // (e.g. performance.now()).\n        var timing = {\n            entryType: 'first-input',\n            processingStart: relativeNow(),\n            startTime: evt.timeStamp,\n        };\n        if (evt.type === \"pointerdown\" /* POINTER_DOWN */) {\n            sendTimingIfPointerIsNotCancelled(timing);\n        }\n        else {\n            sendTiming(timing);\n        }\n    }, { passive: true, capture: true }).stop;\n    /**\n     * Pointer events are a special case, because they can trigger main or compositor thread behavior.\n     * We differentiate these cases based on whether or not we see a pointercancel event, which are\n     * fired when we scroll. If we're scrolling we don't need to report input delay since FID excludes\n     * scrolling and pinch/zooming.\n     */\n    function sendTimingIfPointerIsNotCancelled(timing) {\n        addEventListeners(window, [\"pointerup\" /* POINTER_UP */, \"pointercancel\" /* POINTER_CANCEL */], function (event) {\n            if (event.type === \"pointerup\" /* POINTER_UP */) {\n                sendTiming(timing);\n            }\n        }, { once: true });\n    }\n    function sendTiming(timing) {\n        if (!timingSent) {\n            timingSent = true;\n            removeEventListeners();\n            // In some cases the recorded delay is clearly wrong, e.g. it's negative or it's larger than\n            // the time between now and when the page was loaded.\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/4\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/6\n            // - https://github.com/GoogleChromeLabs/first-input-delay/issues/7\n            var delay = timing.processingStart - timing.startTime;\n            if (delay >= 0 && delay < Date.now() - startTimeStamp) {\n                callback(timing);\n            }\n        }\n    }\n}\nfunction computeRelativePerformanceTiming() {\n    var result = {};\n    var timing = performance.timing;\n    for (var key in timing) {\n        if (isNumber(timing[key])) {\n            var numberKey = key;\n            // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion\n            var timingElement = timing[numberKey];\n            result[numberKey] = timingElement === 0 ? 0 : getRelativeTime(timingElement);\n        }\n    }\n    return result;\n}\nfunction handleRumPerformanceEntries(lifeCycle, configuration, entries) {\n    var rumPerformanceEntries = entries.filter(function (entry) {\n        return entry.entryType === 'resource' ||\n            entry.entryType === 'navigation' ||\n            entry.entryType === 'paint' ||\n            entry.entryType === 'longtask' ||\n            entry.entryType === 'largest-contentful-paint' ||\n            entry.entryType === 'first-input' ||\n            entry.entryType === 'layout-shift';\n    });\n    var rumAllowedPerformanceEntries = rumPerformanceEntries.filter(function (entry) { return !isIncompleteNavigation(entry) && !isForbiddenResource(configuration, entry); });\n    if (rumAllowedPerformanceEntries.length) {\n        lifeCycle.notify(0 /* PERFORMANCE_ENTRIES_COLLECTED */, rumAllowedPerformanceEntries);\n    }\n}\nfunction isIncompleteNavigation(entry) {\n    return entry.entryType === 'navigation' && entry.loadEventEnd <= 0;\n}\nfunction isForbiddenResource(configuration, entry) {\n    return entry.entryType === 'resource' && !isAllowedRequestUrl(configuration, entry.name);\n}\n//# sourceMappingURL=performanceCollection.js.map","import { clocksNow, ErrorSource, ONE_MINUTE } from '..';\nexport function createEventRateLimiter(eventType, limit, onLimitReached) {\n    var eventCount = 0;\n    var allowNextEvent = false;\n    return {\n        isLimitReached: function () {\n            if (eventCount === 0) {\n                setTimeout(function () {\n                    eventCount = 0;\n                }, ONE_MINUTE);\n            }\n            eventCount += 1;\n            if (eventCount <= limit || allowNextEvent) {\n                allowNextEvent = false;\n                return false;\n            }\n            if (eventCount === limit + 1) {\n                allowNextEvent = true;\n                try {\n                    onLimitReached({\n                        message: \"Reached max number of \".concat(eventType, \"s by minute: \").concat(limit),\n                        source: ErrorSource.AGENT,\n                        startClocks: clocksNow(),\n                    });\n                }\n                finally {\n                    allowNextEvent = false;\n                }\n            }\n            return true;\n        },\n    };\n}\n//# sourceMappingURL=createEventRateLimiter.js.map","import { deepClone, getType } from './utils';\n/**\n * Current limitation:\n * - field path do not support array, 'a.b.c' only\n */\nexport function limitModification(object, modifiableFieldPaths, modifier) {\n    var clone = deepClone(object);\n    var result = modifier(clone);\n    modifiableFieldPaths.forEach(function (path) {\n        var originalValue = get(object, path);\n        var newValue = get(clone, path);\n        var originalType = getType(originalValue);\n        var newType = getType(newValue);\n        if (newType === originalType) {\n            set(object, path, newValue);\n        }\n        else if (originalType === 'object' && (newType === 'undefined' || newType === 'null')) {\n            set(object, path, {});\n        }\n    });\n    return result;\n}\nfunction get(object, path) {\n    var current = object;\n    for (var _i = 0, _a = path.split('.'); _i < _a.length; _i++) {\n        var field = _a[_i];\n        if (!isValidObjectContaining(current, field)) {\n            return;\n        }\n        current = current[field];\n    }\n    return current;\n}\nfunction set(object, path, value) {\n    var current = object;\n    var fields = path.split('.');\n    for (var i = 0; i < fields.length; i += 1) {\n        var field = fields[i];\n        if (!isValidObjectContaining(current, field)) {\n            return;\n        }\n        if (i !== fields.length - 1) {\n            current = current[field];\n        }\n        else {\n            current[field] = value;\n        }\n    }\n}\nfunction isValidObjectContaining(object, field) {\n    return typeof object === 'object' && object !== null && field in object;\n}\n//# sourceMappingURL=limitModification.js.map","import { combine, isEmptyObject, limitModification, timeStampNow, currentDrift, display, createEventRateLimiter, canUseEventBridge, isExperimentalFeatureEnabled, } from '@datadog/browser-core';\nimport { getSyntheticsContext } from './syntheticsContext';\nimport { getCiTestContext } from './ciTestContext';\nvar VIEW_EVENTS_MODIFIABLE_FIELD_PATHS = [\n    // Fields with sensitive data\n    'view.url',\n    'view.referrer',\n    'action.target.name',\n    'error.message',\n    'error.stack',\n    'error.resource.url',\n    'resource.url',\n];\nvar OTHER_EVENTS_MODIFIABLE_FIELD_PATHS = VIEW_EVENTS_MODIFIABLE_FIELD_PATHS.concat([\n    // User-customizable field\n    'context',\n]);\nexport function startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, getCommonContext) {\n    var _a;\n    var reportError = function (error) {\n        lifeCycle.notify(12 /* RAW_ERROR_COLLECTED */, { error: error });\n    };\n    var eventRateLimiters = (_a = {},\n        _a[\"error\" /* ERROR */] = createEventRateLimiter(\"error\" /* ERROR */, configuration.eventRateLimiterThreshold, reportError),\n        _a[\"action\" /* ACTION */] = createEventRateLimiter(\"action\" /* ACTION */, configuration.eventRateLimiterThreshold, reportError),\n        _a);\n    var syntheticsContext = getSyntheticsContext();\n    var ciTestContext = getCiTestContext();\n    lifeCycle.subscribe(10 /* RAW_RUM_EVENT_COLLECTED */, function (_a) {\n        var startTime = _a.startTime, rawRumEvent = _a.rawRumEvent, domainContext = _a.domainContext, savedCommonContext = _a.savedCommonContext, customerContext = _a.customerContext;\n        var viewContext = viewContexts.findView(startTime);\n        var urlContext = urlContexts.findUrl(startTime);\n        // allow to send events if the session was tracked when they start\n        // except for views which are continuously updated\n        // TODO: stop sending view updates when session is expired\n        var session = sessionManager.findTrackedSession(rawRumEvent.type !== \"view\" /* VIEW */ ? startTime : undefined);\n        if (session && viewContext && urlContext) {\n            var commonContext = savedCommonContext || getCommonContext();\n            var rumContext = {\n                _dd: {\n                    format_version: 2,\n                    drift: currentDrift(),\n                    session: {\n                        plan: session.hasReplayPlan ? 2 /* REPLAY */ : 1 /* LITE */,\n                    },\n                    browser_sdk_version: canUseEventBridge() ? \"4.8.1\" : undefined,\n                },\n                application: {\n                    id: configuration.applicationId,\n                },\n                date: timeStampNow(),\n                service: configuration.service,\n                source: 'browser',\n                session: {\n                    id: session.id,\n                    type: syntheticsContext ? \"synthetics\" /* SYNTHETICS */ : ciTestContext ? \"ci_test\" /* CI_TEST */ : \"user\" /* USER */,\n                },\n                synthetics: syntheticsContext,\n                ci_test: ciTestContext,\n            };\n            var actionId = actionContexts.findActionId(startTime);\n            if (!isExperimentalFeatureEnabled('sub-apps')) {\n                delete viewContext.service;\n                delete viewContext.version;\n            }\n            else {\n                rumContext.version = configuration.version;\n            }\n            var serverRumEvent = (needToAssembleWithAction(rawRumEvent) && actionId\n                ? combine(rumContext, urlContext, viewContext, { action: { id: actionId } }, rawRumEvent)\n                : combine(rumContext, urlContext, viewContext, rawRumEvent));\n            serverRumEvent.context = combine(commonContext.context, customerContext);\n            if (!('has_replay' in serverRumEvent.session)) {\n                ;\n                serverRumEvent.session.has_replay = commonContext.hasReplay;\n            }\n            if (!isEmptyObject(commonContext.user)) {\n                ;\n                serverRumEvent.usr = commonContext.user;\n            }\n            if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {\n                if (isEmptyObject(serverRumEvent.context)) {\n                    delete serverRumEvent.context;\n                }\n                lifeCycle.notify(11 /* RUM_EVENT_COLLECTED */, serverRumEvent);\n            }\n        }\n    });\n}\nfunction shouldSend(event, beforeSend, domainContext, eventRateLimiters) {\n    var _a;\n    if (beforeSend) {\n        var result = limitModification(event, event.type === \"view\" /* VIEW */ ? VIEW_EVENTS_MODIFIABLE_FIELD_PATHS : OTHER_EVENTS_MODIFIABLE_FIELD_PATHS, function (event) { return beforeSend(event, domainContext); });\n        if (result === false && event.type !== \"view\" /* VIEW */) {\n            return false;\n        }\n        if (result === false) {\n            display.warn(\"Can't dismiss view events using beforeSend!\");\n        }\n    }\n    var rateLimitReached = (_a = eventRateLimiters[event.type]) === null || _a === void 0 ? void 0 : _a.isLimitReached();\n    return !rateLimitReached;\n}\nfunction needToAssembleWithAction(event) {\n    return [\"error\" /* ERROR */, \"resource\" /* RESOURCE */, \"long_task\" /* LONG_TASK */].indexOf(event.type) !== -1;\n}\n//# sourceMappingURL=assembly.js.map","export function getCiTestContext() {\n    var _a;\n    var testExecutionId = (_a = window.Cypress) === null || _a === void 0 ? void 0 : _a.env('traceId');\n    if (typeof testExecutionId === 'string') {\n        return {\n            test_execution_id: testExecutionId,\n        };\n    }\n}\n//# sourceMappingURL=ciTestContext.js.map","import { addEventListener, elapsed, relativeNow, toServerDuration } from '@datadog/browser-core';\n// Arbitrary value to cap number of element mostly for backend & to save bandwidth\nexport var MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS = 500;\n// Arbitrary value to cap number of element mostly for memory consumption in the browser\nexport var MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS = 2500;\nvar foregroundPeriods = [];\nexport function startForegroundContexts() {\n    if (document.hasFocus()) {\n        addNewForegroundPeriod();\n    }\n    var stopForegroundTracking = trackFocus(addNewForegroundPeriod).stop;\n    var stopBlurTracking = trackBlur(closeForegroundPeriod).stop;\n    return {\n        isInForegroundAt: isInForegroundAt,\n        selectInForegroundPeriodsFor: selectInForegroundPeriodsFor,\n        stop: function () {\n            foregroundPeriods = [];\n            stopForegroundTracking();\n            stopBlurTracking();\n        },\n    };\n}\nexport function addNewForegroundPeriod() {\n    if (foregroundPeriods.length > MAX_NUMBER_OF_STORED_FOREGROUND_PERIODS) {\n        return;\n    }\n    var currentForegroundPeriod = foregroundPeriods[foregroundPeriods.length - 1];\n    var now = relativeNow();\n    if (currentForegroundPeriod !== undefined && currentForegroundPeriod.end === undefined) {\n        return;\n    }\n    foregroundPeriods.push({\n        start: now,\n    });\n}\nexport function closeForegroundPeriod() {\n    if (foregroundPeriods.length === 0) {\n        return;\n    }\n    var currentForegroundPeriod = foregroundPeriods[foregroundPeriods.length - 1];\n    var now = relativeNow();\n    if (currentForegroundPeriod.end !== undefined) {\n        return;\n    }\n    currentForegroundPeriod.end = now;\n}\nfunction trackFocus(onFocusChange) {\n    return addEventListener(window, \"focus\" /* FOCUS */, function (event) {\n        if (!event.isTrusted) {\n            return;\n        }\n        onFocusChange();\n    });\n}\nfunction trackBlur(onBlurChange) {\n    return addEventListener(window, \"blur\" /* BLUR */, function (event) {\n        if (!event.isTrusted) {\n            return;\n        }\n        onBlurChange();\n    });\n}\nfunction isInForegroundAt(startTime) {\n    for (var i = foregroundPeriods.length - 1; i >= 0; i--) {\n        var foregroundPeriod = foregroundPeriods[i];\n        if (foregroundPeriod.end !== undefined && startTime > foregroundPeriod.end) {\n            break;\n        }\n        if (startTime > foregroundPeriod.start &&\n            (foregroundPeriod.end === undefined || startTime < foregroundPeriod.end)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction selectInForegroundPeriodsFor(eventStartTime, duration) {\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    var eventEndTime = (eventStartTime + duration);\n    var filteredForegroundPeriods = [];\n    var earliestIndex = Math.max(0, foregroundPeriods.length - MAX_NUMBER_OF_SELECTABLE_FOREGROUND_PERIODS);\n    for (var i = foregroundPeriods.length - 1; i >= earliestIndex; i--) {\n        var foregroundPeriod = foregroundPeriods[i];\n        if (foregroundPeriod.end !== undefined && eventStartTime > foregroundPeriod.end) {\n            // event starts after the end of the current focus period\n            // since the array is sorted, we can stop looking for foreground periods\n            break;\n        }\n        if (eventEndTime < foregroundPeriod.start) {\n            // event ends before the start of the current focus period\n            // continue to previous one\n            continue;\n        }\n        var startTime = eventStartTime > foregroundPeriod.start ? eventStartTime : foregroundPeriod.start;\n        var startDuration = elapsed(eventStartTime, startTime);\n        var endTime = foregroundPeriod.end === undefined || eventEndTime < foregroundPeriod.end ? eventEndTime : foregroundPeriod.end;\n        var endDuration = elapsed(startTime, endTime);\n        filteredForegroundPeriods.unshift({\n            start: toServerDuration(startDuration),\n            duration: toServerDuration(endDuration),\n        });\n    }\n    return filteredForegroundPeriods;\n}\n//# sourceMappingURL=foregroundContexts.js.map","var LifeCycle = /** @class */ (function () {\n    function LifeCycle() {\n        this.callbacks = {};\n    }\n    LifeCycle.prototype.notify = function (eventType, data) {\n        var eventCallbacks = this.callbacks[eventType];\n        if (eventCallbacks) {\n            eventCallbacks.forEach(function (callback) { return callback(data); });\n        }\n    };\n    LifeCycle.prototype.subscribe = function (eventType, callback) {\n        var _this = this;\n        if (!this.callbacks[eventType]) {\n            this.callbacks[eventType] = [];\n        }\n        this.callbacks[eventType].push(callback);\n        return {\n            unsubscribe: function () {\n                _this.callbacks[eventType] = _this.callbacks[eventType].filter(function (other) { return callback !== other; });\n            },\n        };\n    };\n    return LifeCycle;\n}());\nexport { LifeCycle };\n//# sourceMappingURL=lifeCycle.js.map","import { getCookie, setCookie } from '../../browser/cookie';\nimport { isChromium } from '../../tools/browserDetection';\nimport * as utils from '../../tools/utils';\nimport { monitor } from '../internalMonitoring';\nimport { SESSION_EXPIRATION_DELAY } from './sessionStore';\nvar SESSION_ENTRY_REGEXP = /^([a-z]+)=([a-z0-9-]+)$/;\nvar SESSION_ENTRY_SEPARATOR = '&';\nexport var SESSION_COOKIE_NAME = '_dd_s';\n// arbitrary values\nexport var LOCK_RETRY_DELAY = 10;\nexport var MAX_NUMBER_OF_LOCK_RETRIES = 100;\nvar bufferedOperations = [];\nvar ongoingOperations;\nexport function withCookieLockAccess(operations, numberOfRetries) {\n    var _a;\n    if (numberOfRetries === void 0) { numberOfRetries = 0; }\n    if (!ongoingOperations) {\n        ongoingOperations = operations;\n    }\n    if (operations !== ongoingOperations) {\n        bufferedOperations.push(operations);\n        return;\n    }\n    if (numberOfRetries >= MAX_NUMBER_OF_LOCK_RETRIES) {\n        next();\n        return;\n    }\n    var currentLock;\n    var currentSession = retrieveSession();\n    if (isCookieLockEnabled()) {\n        // if someone has lock, retry later\n        if (currentSession.lock) {\n            retryLater(operations, numberOfRetries);\n            return;\n        }\n        // acquire lock\n        currentLock = utils.generateUUID();\n        currentSession.lock = currentLock;\n        setSession(currentSession, operations.options);\n        // if lock is not acquired, retry later\n        currentSession = retrieveSession();\n        if (currentSession.lock !== currentLock) {\n            retryLater(operations, numberOfRetries);\n            return;\n        }\n    }\n    var processedSession = operations.process(currentSession);\n    if (isCookieLockEnabled()) {\n        // if lock corrupted after process, retry later\n        currentSession = retrieveSession();\n        if (currentSession.lock !== currentLock) {\n            retryLater(operations, numberOfRetries);\n            return;\n        }\n    }\n    if (processedSession) {\n        persistSession(processedSession, operations.options);\n    }\n    if (isCookieLockEnabled()) {\n        // correctly handle lock around expiration would require to handle this case properly at several levels\n        // since we don't have evidence of lock issues around expiration, let's just not do the corruption check for it\n        if (!(processedSession && isExpiredState(processedSession))) {\n            // if lock corrupted after persist, retry later\n            currentSession = retrieveSession();\n            if (currentSession.lock !== currentLock) {\n                retryLater(operations, numberOfRetries);\n                return;\n            }\n            delete currentSession.lock;\n            setSession(currentSession, operations.options);\n            processedSession = currentSession;\n        }\n    }\n    // call after even if session is not persisted in order to perform operations on\n    // up-to-date cookie value, the value could have been modified by another tab\n    (_a = operations.after) === null || _a === void 0 ? void 0 : _a.call(operations, processedSession || currentSession);\n    next();\n}\n/**\n * Cookie lock strategy allows mitigating issues due to concurrent access to cookie.\n * This issue concerns only chromium browsers and enabling this on firefox increase cookie write failures.\n */\nfunction isCookieLockEnabled() {\n    return isChromium();\n}\nfunction retryLater(operations, currentNumberOfRetries) {\n    setTimeout(monitor(function () {\n        withCookieLockAccess(operations, currentNumberOfRetries + 1);\n    }), LOCK_RETRY_DELAY);\n}\nfunction next() {\n    ongoingOperations = undefined;\n    var nextOperations = bufferedOperations.shift();\n    if (nextOperations) {\n        withCookieLockAccess(nextOperations);\n    }\n}\nexport function persistSession(session, options) {\n    if (isExpiredState(session)) {\n        clearSession(options);\n        return;\n    }\n    session.expire = String(Date.now() + SESSION_EXPIRATION_DELAY);\n    setSession(session, options);\n}\nfunction setSession(session, options) {\n    setCookie(SESSION_COOKIE_NAME, toSessionString(session), SESSION_EXPIRATION_DELAY, options);\n}\nexport function toSessionString(session) {\n    return utils\n        .objectEntries(session)\n        .map(function (_a) {\n        var key = _a[0], value = _a[1];\n        return \"\".concat(key, \"=\").concat(value);\n    })\n        .join(SESSION_ENTRY_SEPARATOR);\n}\nexport function retrieveSession() {\n    var sessionString = getCookie(SESSION_COOKIE_NAME);\n    var session = {};\n    if (isValidSessionString(sessionString)) {\n        sessionString.split(SESSION_ENTRY_SEPARATOR).forEach(function (entry) {\n            var matches = SESSION_ENTRY_REGEXP.exec(entry);\n            if (matches !== null) {\n                var key = matches[1], value = matches[2];\n                session[key] = value;\n            }\n        });\n    }\n    return session;\n}\nfunction isValidSessionString(sessionString) {\n    return (sessionString !== undefined &&\n        (sessionString.indexOf(SESSION_ENTRY_SEPARATOR) !== -1 || SESSION_ENTRY_REGEXP.test(sessionString)));\n}\nfunction isExpiredState(session) {\n    return utils.isEmptyObject(session);\n}\nfunction clearSession(options) {\n    setCookie(SESSION_COOKIE_NAME, '', 0, options);\n}\n//# sourceMappingURL=sessionCookieStore.js.map","export function isIE() {\n    return Boolean(document.documentMode);\n}\nexport function isChromium() {\n    return !!window.chrome || /HeadlessChrome/.test(window.navigator.userAgent);\n}\n//# sourceMappingURL=browserDetection.js.map","import { COOKIE_ACCESS_DELAY } from '../../browser/cookie';\nimport { Observable } from '../../tools/observable';\nimport * as utils from '../../tools/utils';\nimport { monitor } from '../internalMonitoring';\nimport { retrieveSession, withCookieLockAccess } from './sessionCookieStore';\nexport var SESSION_EXPIRATION_DELAY = 15 * utils.ONE_MINUTE;\nexport var SESSION_TIME_OUT_DELAY = 4 * utils.ONE_HOUR;\n/**\n * Different session concepts:\n * - tracked, the session has an id and is updated along the user navigation\n * - not tracked, the session does not have an id but it is updated along the user navigation\n * - inactive, no session in store or session expired, waiting for a renew session\n */\nexport function startSessionStore(options, productKey, computeSessionState) {\n    var renewObservable = new Observable();\n    var expireObservable = new Observable();\n    var watchSessionTimeoutId = setInterval(monitor(watchSession), COOKIE_ACCESS_DELAY);\n    var sessionCache = retrieveActiveSession();\n    function expandOrRenewSession() {\n        var isTracked;\n        withCookieLockAccess({\n            options: options,\n            process: function (cookieSession) {\n                var synchronizedSession = synchronizeSession(cookieSession);\n                isTracked = expandOrRenewCookie(synchronizedSession);\n                return synchronizedSession;\n            },\n            after: function (cookieSession) {\n                if (isTracked && !hasSessionInCache()) {\n                    renewSession(cookieSession);\n                }\n                sessionCache = cookieSession;\n            },\n        });\n    }\n    function expandSession() {\n        withCookieLockAccess({\n            options: options,\n            process: function (cookieSession) { return (hasSessionInCache() ? synchronizeSession(cookieSession) : undefined); },\n        });\n    }\n    /**\n     * allows two behaviors:\n     * - if the session is active, synchronize the session cache without updating the session cookie\n     * - if the session is not active, clear the session cookie and expire the session cache\n     */\n    function watchSession() {\n        withCookieLockAccess({\n            options: options,\n            process: function (cookieSession) { return (!isActiveSession(cookieSession) ? {} : undefined); },\n            after: synchronizeSession,\n        });\n    }\n    function synchronizeSession(cookieSession) {\n        if (!isActiveSession(cookieSession)) {\n            cookieSession = {};\n        }\n        if (hasSessionInCache()) {\n            if (isSessionInCacheOutdated(cookieSession)) {\n                expireSession();\n            }\n            else {\n                sessionCache = cookieSession;\n            }\n        }\n        return cookieSession;\n    }\n    function expandOrRenewCookie(cookieSession) {\n        var _a = computeSessionState(cookieSession[productKey]), trackingType = _a.trackingType, isTracked = _a.isTracked;\n        cookieSession[productKey] = trackingType;\n        if (isTracked && !cookieSession.id) {\n            cookieSession.id = utils.generateUUID();\n            cookieSession.created = String(Date.now());\n        }\n        return isTracked;\n    }\n    function hasSessionInCache() {\n        return sessionCache[productKey] !== undefined;\n    }\n    function isSessionInCacheOutdated(cookieSession) {\n        return sessionCache.id !== cookieSession.id || sessionCache[productKey] !== cookieSession[productKey];\n    }\n    function expireSession() {\n        sessionCache = {};\n        expireObservable.notify();\n    }\n    function renewSession(cookieSession) {\n        sessionCache = cookieSession;\n        renewObservable.notify();\n    }\n    function retrieveActiveSession() {\n        var session = retrieveSession();\n        if (isActiveSession(session)) {\n            return session;\n        }\n        return {};\n    }\n    function isActiveSession(session) {\n        // created and expire can be undefined for versions which was not storing them\n        // these checks could be removed when older versions will not be available/live anymore\n        return ((session.created === undefined || Date.now() - Number(session.created) < SESSION_TIME_OUT_DELAY) &&\n            (session.expire === undefined || Date.now() < Number(session.expire)));\n    }\n    return {\n        expandOrRenewSession: utils.throttle(monitor(expandOrRenewSession), COOKIE_ACCESS_DELAY).throttled,\n        expandSession: expandSession,\n        getSession: function () { return sessionCache; },\n        renewObservable: renewObservable,\n        expireObservable: expireObservable,\n        stop: function () {\n            clearInterval(watchSessionTimeoutId);\n        },\n    };\n}\n//# sourceMappingURL=sessionStore.js.map","import { relativeNow } from './timeUtils';\nimport { ONE_MINUTE } from './utils';\nvar END_OF_TIMES = Infinity;\nexport var CLEAR_OLD_CONTEXTS_INTERVAL = ONE_MINUTE;\n/**\n * Store and keep track of contexts spans. This whole class assumes that contexts are added in\n * chronological order (i.e. all entries have an increasing start time).\n */\nvar ContextHistory = /** @class */ (function () {\n    function ContextHistory(expireDelay) {\n        var _this = this;\n        this.expireDelay = expireDelay;\n        this.entries = [];\n        this.clearOldContextsInterval = setInterval(function () { return _this.clearOldContexts(); }, CLEAR_OLD_CONTEXTS_INTERVAL);\n    }\n    /**\n     * Add a context to the history associated with a start time. Returns a reference to this newly\n     * added entry that can be removed or closed.\n     */\n    ContextHistory.prototype.add = function (context, startTime) {\n        var _this = this;\n        var entry = {\n            context: context,\n            startTime: startTime,\n            endTime: END_OF_TIMES,\n            remove: function () {\n                var index = _this.entries.indexOf(entry);\n                if (index >= 0) {\n                    _this.entries.splice(index, 1);\n                }\n            },\n            close: function (endTime) {\n                entry.endTime = endTime;\n            },\n        };\n        this.entries.unshift(entry);\n        return entry;\n    };\n    /**\n     * Return the latest context that was active during `startTime`, or the currently active context\n     * if no `startTime` is provided. This method assumes that entries are not overlapping.\n     */\n    ContextHistory.prototype.find = function (startTime) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        for (var _i = 0, _a = this.entries; _i < _a.length; _i++) {\n            var entry = _a[_i];\n            if (entry.startTime <= startTime) {\n                if (startTime <= entry.endTime) {\n                    return entry.context;\n                }\n                break;\n            }\n        }\n    };\n    /**\n     * Helper function to close the currently active context, if any. This method assumes that entries\n     * are not overlapping.\n     */\n    ContextHistory.prototype.closeActive = function (endTime) {\n        var latestEntry = this.entries[0];\n        if (latestEntry && latestEntry.endTime === END_OF_TIMES) {\n            latestEntry.close(endTime);\n        }\n    };\n    /**\n     * Return all contexts that were active during `startTime`, or all currently active contexts if no\n     * `startTime` is provided.\n     */\n    ContextHistory.prototype.findAll = function (startTime) {\n        if (startTime === void 0) { startTime = END_OF_TIMES; }\n        return this.entries\n            .filter(function (entry) { return entry.startTime <= startTime && startTime <= entry.endTime; })\n            .map(function (entry) { return entry.context; });\n    };\n    /**\n     * Remove all entries from this collection.\n     */\n    ContextHistory.prototype.reset = function () {\n        this.entries = [];\n    };\n    /**\n     * Stop internal garbage collection of past entries.\n     */\n    ContextHistory.prototype.stop = function () {\n        clearInterval(this.clearOldContextsInterval);\n    };\n    ContextHistory.prototype.clearOldContexts = function () {\n        var oldTimeThreshold = relativeNow() - this.expireDelay;\n        while (this.entries.length > 0 && this.entries[this.entries.length - 1].endTime < oldTimeThreshold) {\n            this.entries.pop();\n        }\n    };\n    return ContextHistory;\n}());\nexport { ContextHistory };\n//# sourceMappingURL=contextHistory.js.map","import { monitor } from '../domain/internalMonitoring';\nimport { instrumentMethodAndCallOriginal } from '../tools/instrumentMethod';\nimport { Observable } from '../tools/observable';\nimport { elapsed, relativeNow, clocksNow, timeStampNow } from '../tools/timeUtils';\nimport { normalizeUrl } from '../tools/urlPolyfill';\nimport { shallowClone } from '../tools/utils';\nvar xhrObservable;\nvar xhrContexts = new WeakMap();\nexport function initXhrObservable() {\n    if (!xhrObservable) {\n        xhrObservable = createXhrObservable();\n    }\n    return xhrObservable;\n}\nfunction createXhrObservable() {\n    var observable = new Observable(function () {\n        var stopInstrumentingStart = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'open', {\n            before: openXhr,\n        }).stop;\n        var stopInstrumentingSend = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'send', {\n            before: function () {\n                sendXhr.call(this, observable);\n            },\n        }).stop;\n        var stopInstrumentingAbort = instrumentMethodAndCallOriginal(XMLHttpRequest.prototype, 'abort', {\n            before: abortXhr,\n        }).stop;\n        return function () {\n            stopInstrumentingStart();\n            stopInstrumentingSend();\n            stopInstrumentingAbort();\n        };\n    });\n    return observable;\n}\nfunction openXhr(method, url) {\n    xhrContexts.set(this, {\n        state: 'open',\n        method: method,\n        url: normalizeUrl(url.toString()),\n    });\n}\nfunction sendXhr(observable) {\n    var _this = this;\n    var context = xhrContexts.get(this);\n    if (!context) {\n        return;\n    }\n    var startContext = context;\n    startContext.state = 'start';\n    startContext.startTime = relativeNow();\n    startContext.startClocks = clocksNow();\n    startContext.isAborted = false;\n    startContext.xhr = this;\n    var hasBeenReported = false;\n    var stopInstrumentingOnReadyStateChange = instrumentMethodAndCallOriginal(this, 'onreadystatechange', {\n        before: function () {\n            if (this.readyState === XMLHttpRequest.DONE) {\n                // Try to report the XHR as soon as possible, because the XHR may be mutated by the\n                // application during a future event. For example, Angular is calling .abort() on\n                // completed requests during a onreadystatechange event, so the status becomes '0'\n                // before the request is collected.\n                onEnd();\n            }\n        },\n    }).stop;\n    var onEnd = monitor(function () {\n        _this.removeEventListener('loadend', onEnd);\n        stopInstrumentingOnReadyStateChange();\n        if (hasBeenReported) {\n            return;\n        }\n        hasBeenReported = true;\n        var completeContext = context;\n        completeContext.state = 'complete';\n        completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow());\n        completeContext.status = _this.status;\n        observable.notify(shallowClone(completeContext));\n    });\n    this.addEventListener('loadend', onEnd);\n    observable.notify(startContext);\n}\nfunction abortXhr() {\n    var context = xhrContexts.get(this);\n    if (context) {\n        context.isAborted = true;\n    }\n}\n//# sourceMappingURL=xhrObservable.js.map","import { callMonitored, monitor } from '../domain/internalMonitoring';\nimport { noop } from './utils';\nexport function instrumentMethod(object, method, instrumentationFactory) {\n    var original = object[method];\n    var instrumentation = instrumentationFactory(original);\n    var instrumentationWrapper = function () {\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n        return instrumentation.apply(this, arguments);\n    };\n    object[method] = instrumentationWrapper;\n    return {\n        stop: function () {\n            if (object[method] === instrumentationWrapper) {\n                object[method] = original;\n            }\n            else {\n                instrumentation = original;\n            }\n        },\n    };\n}\nexport function instrumentMethodAndCallOriginal(object, method, _a) {\n    var before = _a.before, after = _a.after;\n    return instrumentMethod(object, method, function (original) {\n        return function () {\n            var args = arguments;\n            var result;\n            if (before) {\n                callMonitored(before, this, args);\n            }\n            if (typeof original === 'function') {\n                // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n                result = original.apply(this, args);\n            }\n            if (after) {\n                callMonitored(after, this, args);\n            }\n            // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n            return result;\n        };\n    });\n}\nexport function instrumentSetter(object, property, after) {\n    var originalDescriptor = Object.getOwnPropertyDescriptor(object, property);\n    if (!originalDescriptor || !originalDescriptor.set || !originalDescriptor.configurable) {\n        return { stop: noop };\n    }\n    var instrumentation = function (thisObject, value) {\n        // put hooked setter into event loop to avoid of set latency\n        setTimeout(monitor(function () {\n            after(thisObject, value);\n        }), 0);\n    };\n    var instrumentationWrapper = function (value) {\n        originalDescriptor.set.call(this, value);\n        instrumentation(this, value);\n    };\n    Object.defineProperty(object, property, {\n        set: instrumentationWrapper,\n    });\n    return {\n        stop: function () {\n            var _a;\n            if (((_a = Object.getOwnPropertyDescriptor(object, property)) === null || _a === void 0 ? void 0 : _a.set) === instrumentationWrapper) {\n                Object.defineProperty(object, property, originalDescriptor);\n            }\n            else {\n                instrumentation = noop;\n            }\n        },\n    };\n}\n//# sourceMappingURL=instrumentMethod.js.map","import { monitor, callMonitored } from '../domain/internalMonitoring';\nimport { instrumentMethod } from '../tools/instrumentMethod';\nimport { Observable } from '../tools/observable';\nimport { elapsed, clocksNow, timeStampNow } from '../tools/timeUtils';\nimport { normalizeUrl } from '../tools/urlPolyfill';\nvar fetchObservable;\nexport function initFetchObservable() {\n    if (!fetchObservable) {\n        fetchObservable = createFetchObservable();\n    }\n    return fetchObservable;\n}\nfunction createFetchObservable() {\n    var observable = new Observable(function () {\n        if (!window.fetch) {\n            return;\n        }\n        var stop = instrumentMethod(window, 'fetch', function (originalFetch) {\n            return function (input, init) {\n                var responsePromise;\n                var context = callMonitored(beforeSend, null, [observable, input, init]);\n                if (context) {\n                    responsePromise = originalFetch.call(this, context.input, context.init);\n                    callMonitored(afterSend, null, [observable, responsePromise, context]);\n                }\n                else {\n                    responsePromise = originalFetch.call(this, input, init);\n                }\n                return responsePromise;\n            };\n        }).stop;\n        return stop;\n    });\n    return observable;\n}\nfunction beforeSend(observable, input, init) {\n    var method = (init && init.method) || (typeof input === 'object' && input.method) || 'GET';\n    var url = normalizeUrl((typeof input === 'object' && input.url) || input);\n    var startClocks = clocksNow();\n    var context = {\n        state: 'start',\n        init: init,\n        input: input,\n        method: method,\n        startClocks: startClocks,\n        url: url,\n    };\n    observable.notify(context);\n    return context;\n}\nfunction afterSend(observable, responsePromise, startContext) {\n    var reportFetch = function (response) {\n        var context = startContext;\n        context.state = 'complete';\n        context.duration = elapsed(context.startClocks.timeStamp, timeStampNow());\n        if ('stack' in response || response instanceof Error) {\n            context.status = 0;\n            context.isAborted = response instanceof DOMException && response.code === DOMException.ABORT_ERR;\n            context.error = response;\n            observable.notify(context);\n        }\n        else if ('status' in response) {\n            context.response = response;\n            context.responseType = response.type;\n            context.status = response.status;\n            context.isAborted = false;\n            observable.notify(context);\n        }\n    };\n    responsePromise.then(monitor(reportFetch), monitor(reportFetch));\n}\n//# sourceMappingURL=fetchObservable.js.map","import { getOrigin, objectEntries, shallowClone } from '@datadog/browser-core';\n/**\n * Clear tracing information to avoid incomplete traces. Ideally, we should do it when the the\n * request did not reach the server, but we the browser does not expose this. So, we clear tracing\n * information if the request ended with status 0 without being aborted by the application.\n *\n * Reasoning:\n *\n * * Applications are usually aborting requests after a bit of time, for example when the user is\n * typing (autocompletion) or navigating away (in a SPA). With a performant device and good\n * network conditions, the request is likely to reach the server before being canceled.\n *\n * * Requests aborted otherwise (ex: lack of internet, CORS issue, blocked by a privacy extension)\n * are likely to finish quickly and without reaching the server.\n *\n * Of course it might not be the case every time, but it should limit having incomplete traces a\n * bit..\n * */\nexport function clearTracingIfNeeded(context) {\n    if (context.status === 0 && !context.isAborted) {\n        context.traceId = undefined;\n        context.spanId = undefined;\n    }\n}\nexport function startTracer(configuration, sessionManager) {\n    return {\n        clearTracingIfNeeded: clearTracingIfNeeded,\n        traceFetch: function (context) {\n            return injectHeadersIfTracingAllowed(configuration, context, sessionManager, function (tracingHeaders) {\n                var _a;\n                if (context.input instanceof Request && !((_a = context.init) === null || _a === void 0 ? void 0 : _a.headers)) {\n                    context.input = new Request(context.input);\n                    Object.keys(tracingHeaders).forEach(function (key) {\n                        ;\n                        context.input.headers.append(key, tracingHeaders[key]);\n                    });\n                }\n                else {\n                    context.init = shallowClone(context.init);\n                    var headers_1 = [];\n                    if (context.init.headers instanceof Headers) {\n                        context.init.headers.forEach(function (value, key) {\n                            headers_1.push([key, value]);\n                        });\n                    }\n                    else if (Array.isArray(context.init.headers)) {\n                        context.init.headers.forEach(function (header) {\n                            headers_1.push(header);\n                        });\n                    }\n                    else if (context.init.headers) {\n                        Object.keys(context.init.headers).forEach(function (key) {\n                            headers_1.push([key, context.init.headers[key]]);\n                        });\n                    }\n                    context.init.headers = headers_1.concat(objectEntries(tracingHeaders));\n                }\n            });\n        },\n        traceXhr: function (context, xhr) {\n            return injectHeadersIfTracingAllowed(configuration, context, sessionManager, function (tracingHeaders) {\n                Object.keys(tracingHeaders).forEach(function (name) {\n                    xhr.setRequestHeader(name, tracingHeaders[name]);\n                });\n            });\n        },\n    };\n}\nfunction injectHeadersIfTracingAllowed(configuration, context, sessionManager, inject) {\n    if (!isTracingSupported() || !isAllowedUrl(configuration, context.url) || !sessionManager.findTrackedSession()) {\n        return;\n    }\n    context.traceId = new TraceIdentifier();\n    context.spanId = new TraceIdentifier();\n    inject(makeTracingHeaders(context.traceId, context.spanId));\n}\nfunction isAllowedUrl(configuration, requestUrl) {\n    var requestOrigin = getOrigin(requestUrl);\n    for (var _i = 0, _a = configuration.allowedTracingOrigins; _i < _a.length; _i++) {\n        var allowedOrigin = _a[_i];\n        if (requestOrigin === allowedOrigin || (allowedOrigin instanceof RegExp && allowedOrigin.test(requestOrigin))) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function isTracingSupported() {\n    return getCrypto() !== undefined;\n}\nfunction getCrypto() {\n    return window.crypto || window.msCrypto;\n}\nfunction makeTracingHeaders(traceId, spanId) {\n    return {\n        'x-datadog-origin': 'rum',\n        'x-datadog-parent-id': spanId.toDecimalString(),\n        'x-datadog-sampled': '1',\n        'x-datadog-sampling-priority': '1',\n        'x-datadog-trace-id': traceId.toDecimalString(),\n    };\n}\n/* eslint-disable no-bitwise */\nvar TraceIdentifier = /** @class */ (function () {\n    function TraceIdentifier() {\n        this.buffer = new Uint8Array(8);\n        getCrypto().getRandomValues(this.buffer);\n        this.buffer[0] = this.buffer[0] & 0x7f; // force 63-bit\n    }\n    TraceIdentifier.prototype.toString = function (radix) {\n        var high = this.readInt32(0);\n        var low = this.readInt32(4);\n        var str = '';\n        do {\n            var mod = (high % radix) * 4294967296 + low;\n            high = Math.floor(high / radix);\n            low = Math.floor(mod / radix);\n            str = (mod % radix).toString(radix) + str;\n        } while (high || low);\n        return str;\n    };\n    /**\n     * Format used everywhere except the trace intake\n     */\n    TraceIdentifier.prototype.toDecimalString = function () {\n        return this.toString(10);\n    };\n    TraceIdentifier.prototype.readInt32 = function (offset) {\n        return (this.buffer[offset] * 16777216 +\n            (this.buffer[offset + 1] << 16) +\n            (this.buffer[offset + 2] << 8) +\n            this.buffer[offset + 3]);\n    };\n    return TraceIdentifier;\n}());\nexport { TraceIdentifier };\n/* eslint-enable no-bitwise */\n//# sourceMappingURL=tracer.js.map","import { initFetchObservable, initXhrObservable } from '@datadog/browser-core';\nimport { isAllowedRequestUrl } from './rumEventsCollection/resource/resourceUtils';\nimport { startTracer } from './tracing/tracer';\nvar nextRequestIndex = 1;\nexport function startRequestCollection(lifeCycle, configuration, sessionManager) {\n    var tracer = startTracer(configuration, sessionManager);\n    trackXhr(lifeCycle, configuration, tracer);\n    trackFetch(lifeCycle, configuration, tracer);\n}\nexport function trackXhr(lifeCycle, configuration, tracer) {\n    var subscription = initXhrObservable().subscribe(function (rawContext) {\n        var context = rawContext;\n        if (!isAllowedRequestUrl(configuration, context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceXhr(context, context.xhr);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(5 /* REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(6 /* REQUEST_COMPLETED */, {\n                    duration: context.duration,\n                    method: context.method,\n                    requestIndex: context.requestIndex,\n                    spanId: context.spanId,\n                    startClocks: context.startClocks,\n                    status: context.status,\n                    traceId: context.traceId,\n                    type: \"xhr\" /* XHR */,\n                    url: context.url,\n                    xhr: context.xhr,\n                });\n                break;\n        }\n    });\n    return { stop: function () { return subscription.unsubscribe(); } };\n}\nexport function trackFetch(lifeCycle, configuration, tracer) {\n    var subscription = initFetchObservable().subscribe(function (rawContext) {\n        var context = rawContext;\n        if (!isAllowedRequestUrl(configuration, context.url)) {\n            return;\n        }\n        switch (context.state) {\n            case 'start':\n                tracer.traceFetch(context);\n                context.requestIndex = getNextRequestIndex();\n                lifeCycle.notify(5 /* REQUEST_STARTED */, {\n                    requestIndex: context.requestIndex,\n                });\n                break;\n            case 'complete':\n                tracer.clearTracingIfNeeded(context);\n                lifeCycle.notify(6 /* REQUEST_COMPLETED */, {\n                    duration: context.duration,\n                    method: context.method,\n                    requestIndex: context.requestIndex,\n                    responseType: context.responseType,\n                    spanId: context.spanId,\n                    startClocks: context.startClocks,\n                    status: context.status,\n                    traceId: context.traceId,\n                    type: \"fetch\" /* FETCH */,\n                    url: context.url,\n                    response: context.response,\n                    init: context.init,\n                    input: context.input,\n                });\n                break;\n        }\n    });\n    return { stop: function () { return subscription.unsubscribe(); } };\n}\nfunction getNextRequestIndex() {\n    var result = nextRequestIndex;\n    nextRequestIndex += 1;\n    return result;\n}\n//# sourceMappingURL=requestCollection.js.map","import { noop } from '@datadog/browser-core';\nexport function trackEventCounts(lifeCycle, callback) {\n    if (callback === void 0) { callback = noop; }\n    var eventCounts = {\n        errorCount: 0,\n        longTaskCount: 0,\n        resourceCount: 0,\n        userActionCount: 0,\n    };\n    var subscription = lifeCycle.subscribe(11 /* RUM_EVENT_COLLECTED */, function (_a) {\n        var type = _a.type;\n        switch (type) {\n            case \"error\" /* ERROR */:\n                eventCounts.errorCount += 1;\n                callback(eventCounts);\n                break;\n            case \"action\" /* ACTION */:\n                eventCounts.userActionCount += 1;\n                callback(eventCounts);\n                break;\n            case \"long_task\" /* LONG_TASK */:\n                eventCounts.longTaskCount += 1;\n                callback(eventCounts);\n                break;\n            case \"resource\" /* RESOURCE */:\n                eventCounts.resourceCount += 1;\n                callback(eventCounts);\n                break;\n        }\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n        eventCounts: eventCounts,\n    };\n}\n//# sourceMappingURL=trackEventCounts.js.map","import { monitor, Observable, timeStampNow } from '@datadog/browser-core';\n// Delay to wait for a page activity to validate the tracking process\nexport var PAGE_ACTIVITY_VALIDATION_DELAY = 100;\n// Delay to wait after a page activity to end the tracking process\nexport var PAGE_ACTIVITY_END_DELAY = 100;\n/**\n * Wait for the next idle page time\n *\n * Detection lifecycle:\n * ```\n *                           Wait idle page\n *              .-------------------'--------------------.\n *              v                                        v\n *     [Wait for a page activity ]          [Wait for a maximum duration]\n *     [timeout: VALIDATION_DELAY]          [  timeout: maxDuration     ]\n *          /                  \\                           |\n *         v                    v                          |\n *  [No page activity]   [Page activity]                   |\n *         |                   |,----------------------.   |\n *         v                   v                       |   |\n *     (Discard)     [Wait for a page activity]        |   |\n *                   [   timeout: END_DELAY   ]        |   |\n *                       /                \\            |   |\n *                      v                  v           |   |\n *             [No page activity]    [Page activity]   |   |\n *                      |                 |            |   |\n *                      |                 '------------'   |\n *                      '-----------. ,--------------------'\n *                                   v\n *                                 (End)\n * ```\n *\n * Note: by assuming that maxDuration is greater than VALIDATION_DELAY, we are sure that if the\n * process is still alive after maxDuration, it has been validated.\n */\nexport function waitIdlePage(lifeCycle, domMutationObservable, idlePageCallback, maxDuration) {\n    var pageActivityObservable = createPageActivityObservable(lifeCycle, domMutationObservable);\n    return doWaitIdlePage(pageActivityObservable, idlePageCallback, maxDuration);\n}\nexport function doWaitIdlePage(pageActivityObservable, idlePageCallback, maxDuration) {\n    var idleTimeoutId;\n    var hasCompleted = false;\n    var validationTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: false }); }), PAGE_ACTIVITY_VALIDATION_DELAY);\n    var maxDurationTimeoutId = maxDuration &&\n        setTimeout(monitor(function () { return complete({ hadActivity: true, end: timeStampNow() }); }), maxDuration);\n    var pageActivitySubscription = pageActivityObservable.subscribe(function (_a) {\n        var isBusy = _a.isBusy;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(idleTimeoutId);\n        var lastChangeTime = timeStampNow();\n        if (!isBusy) {\n            idleTimeoutId = setTimeout(monitor(function () { return complete({ hadActivity: true, end: lastChangeTime }); }), PAGE_ACTIVITY_END_DELAY);\n        }\n    });\n    var stop = function () {\n        hasCompleted = true;\n        clearTimeout(validationTimeoutId);\n        clearTimeout(idleTimeoutId);\n        clearTimeout(maxDurationTimeoutId);\n        pageActivitySubscription.unsubscribe();\n    };\n    function complete(event) {\n        if (hasCompleted) {\n            return;\n        }\n        stop();\n        idlePageCallback(event);\n    }\n    return { stop: stop };\n}\nexport function createPageActivityObservable(lifeCycle, domMutationObservable) {\n    var observable = new Observable(function () {\n        var subscriptions = [];\n        var firstRequestIndex;\n        var pendingRequestsCount = 0;\n        subscriptions.push(domMutationObservable.subscribe(function () { return notifyPageActivity(pendingRequestsCount); }), lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n            if (entries.some(function (_a) {\n                var entryType = _a.entryType;\n                return entryType === 'resource';\n            })) {\n                notifyPageActivity(pendingRequestsCount);\n            }\n        }), lifeCycle.subscribe(5 /* REQUEST_STARTED */, function (startEvent) {\n            if (firstRequestIndex === undefined) {\n                firstRequestIndex = startEvent.requestIndex;\n            }\n            notifyPageActivity(++pendingRequestsCount);\n        }), lifeCycle.subscribe(6 /* REQUEST_COMPLETED */, function (request) {\n            // If the request started before the tracking start, ignore it\n            if (firstRequestIndex === undefined || request.requestIndex < firstRequestIndex) {\n                return;\n            }\n            notifyPageActivity(--pendingRequestsCount);\n        }));\n        return function () { return subscriptions.forEach(function (s) { return s.unsubscribe(); }); };\n    });\n    function notifyPageActivity(pendingRequestsCount) {\n        observable.notify({ isBusy: pendingRequestsCount > 0 });\n    }\n    return observable;\n}\n//# sourceMappingURL=waitIdlePage.js.map","import { safeTruncate, isIE } from '@datadog/browser-core';\n/**\n * Get the action name from the attribute 'data-dd-action-name' on the element or any of its parent.\n * It can also be retrieved from a user defined attribute.\n */\nvar DEFAULT_PROGRAMMATIC_ATTRIBUTE = 'data-dd-action-name';\nexport function getActionNameFromElement(element, userProgrammaticAttribute) {\n    // Proceed to get the action name in two steps:\n    // * first, get the name programmatically, explicitly defined by the user.\n    // * then, use strategies that are known to return good results. Those strategies will be used on\n    //   the element and a few parents, but it's likely that they won't succeed at all.\n    // * if no name is found this way, use strategies returning less accurate names as a fallback.\n    //   Those are much likely to succeed.\n    return (getActionNameFromElementProgrammatically(element, DEFAULT_PROGRAMMATIC_ATTRIBUTE) ||\n        (userProgrammaticAttribute && getActionNameFromElementProgrammatically(element, userProgrammaticAttribute)) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, priorityStrategies) ||\n        getActionNameFromElementForStrategies(element, userProgrammaticAttribute, fallbackStrategies) ||\n        '');\n}\nfunction getActionNameFromElementProgrammatically(targetElement, programmaticAttribute) {\n    var elementWithAttribute;\n    // We don't use getActionNameFromElementForStrategies here, because we want to consider all parents,\n    // without limit. It is up to the user to declare a relevant naming strategy.\n    // If available, use element.closest() to match get the attribute from the element or any of its\n    // parent.  Else fallback to a more traditional implementation.\n    if (supportsElementClosest()) {\n        elementWithAttribute = targetElement.closest(\"[\".concat(programmaticAttribute, \"]\"));\n    }\n    else {\n        var element = targetElement;\n        while (element) {\n            if (element.hasAttribute(programmaticAttribute)) {\n                elementWithAttribute = element;\n                break;\n            }\n            element = element.parentElement;\n        }\n    }\n    if (!elementWithAttribute) {\n        return;\n    }\n    var name = elementWithAttribute.getAttribute(programmaticAttribute);\n    return truncate(normalizeWhitespace(name.trim()));\n}\nvar priorityStrategies = [\n    // associated LABEL text\n    function (element, userProgrammaticAttribute) {\n        // IE does not support element.labels, so we fallback to a CSS selector based on the element id\n        // instead\n        if (supportsLabelProperty()) {\n            if ('labels' in element && element.labels && element.labels.length > 0) {\n                return getTextualContent(element.labels[0], userProgrammaticAttribute);\n            }\n        }\n        else if (element.id) {\n            var label = element.ownerDocument && element.ownerDocument.querySelector(\"label[for=\\\"\".concat(element.id.replace('\"', '\\\\\"'), \"\\\"]\"));\n            return label && getTextualContent(label, userProgrammaticAttribute);\n        }\n    },\n    // INPUT button (and associated) value\n    function (element) {\n        if (element.nodeName === 'INPUT') {\n            var input = element;\n            var type = input.getAttribute('type');\n            if (type === 'button' || type === 'submit' || type === 'reset') {\n                return input.value;\n            }\n        }\n    },\n    // BUTTON, LABEL or button-like element text\n    function (element, userProgrammaticAttribute) {\n        if (element.nodeName === 'BUTTON' || element.nodeName === 'LABEL' || element.getAttribute('role') === 'button') {\n            return getTextualContent(element, userProgrammaticAttribute);\n        }\n    },\n    function (element) { return element.getAttribute('aria-label'); },\n    // associated element text designated by the aria-labelledby attribute\n    function (element, userProgrammaticAttribute) {\n        var labelledByAttribute = element.getAttribute('aria-labelledby');\n        if (labelledByAttribute) {\n            return labelledByAttribute\n                .split(/\\s+/)\n                .map(function (id) { return getElementById(element, id); })\n                .filter(function (label) { return Boolean(label); })\n                .map(function (element) { return getTextualContent(element, userProgrammaticAttribute); })\n                .join(' ');\n        }\n    },\n    function (element) { return element.getAttribute('alt'); },\n    function (element) { return element.getAttribute('name'); },\n    function (element) { return element.getAttribute('title'); },\n    function (element) { return element.getAttribute('placeholder'); },\n    // SELECT first OPTION text\n    function (element, userProgrammaticAttribute) {\n        if ('options' in element && element.options.length > 0) {\n            return getTextualContent(element.options[0], userProgrammaticAttribute);\n        }\n    },\n];\nvar fallbackStrategies = [\n    function (element, userProgrammaticAttribute) { return getTextualContent(element, userProgrammaticAttribute); },\n];\n/**\n * Iterates over the target element and its parent, using the strategies list to get an action name.\n * Each strategies are applied on each element, stopping as soon as a non-empty value is returned.\n */\nvar MAX_PARENTS_TO_CONSIDER = 10;\nfunction getActionNameFromElementForStrategies(targetElement, userProgrammaticAttribute, strategies) {\n    var element = targetElement;\n    var recursionCounter = 0;\n    while (recursionCounter <= MAX_PARENTS_TO_CONSIDER &&\n        element &&\n        element.nodeName !== 'BODY' &&\n        element.nodeName !== 'HTML' &&\n        element.nodeName !== 'HEAD') {\n        for (var _i = 0, strategies_1 = strategies; _i < strategies_1.length; _i++) {\n            var strategy = strategies_1[_i];\n            var name_1 = strategy(element, userProgrammaticAttribute);\n            if (typeof name_1 === 'string') {\n                var trimmedName = name_1.trim();\n                if (trimmedName) {\n                    return truncate(normalizeWhitespace(trimmedName));\n                }\n            }\n        }\n        // Consider a FORM as a contextual limit to get the action name.  This is experimental and may\n        // be reconsidered in the future.\n        if (element.nodeName === 'FORM') {\n            break;\n        }\n        element = element.parentElement;\n        recursionCounter += 1;\n    }\n}\nfunction normalizeWhitespace(s) {\n    return s.replace(/\\s+/g, ' ');\n}\nfunction truncate(s) {\n    return s.length > 100 ? \"\".concat(safeTruncate(s, 100), \" [...]\") : s;\n}\nfunction getElementById(refElement, id) {\n    // Use the element ownerDocument here, because tests are executed in an iframe, so\n    // document.getElementById won't work.\n    return refElement.ownerDocument ? refElement.ownerDocument.getElementById(id) : null;\n}\nfunction getTextualContent(element, userProgrammaticAttribute) {\n    if (element.isContentEditable) {\n        return;\n    }\n    if ('innerText' in element) {\n        var text_1 = element.innerText;\n        var removeTextFromElements = function (query) {\n            var list = element.querySelectorAll(query);\n            for (var index = 0; index < list.length; index += 1) {\n                var element_1 = list[index];\n                if ('innerText' in element_1) {\n                    var textToReplace = element_1.innerText;\n                    if (textToReplace && textToReplace.trim().length > 0) {\n                        text_1 = text_1.replace(textToReplace, '');\n                    }\n                }\n            }\n        };\n        if (!supportsInnerTextScriptAndStyleRemoval()) {\n            // remove the inner text of SCRIPT and STYLES from the result. This is a bit dirty, but should\n            // be relatively fast and work in most cases.\n            removeTextFromElements('script, style');\n        }\n        // remove the text of elements with programmatic attribute value\n        removeTextFromElements(\"[\".concat(DEFAULT_PROGRAMMATIC_ATTRIBUTE, \"]\"));\n        if (userProgrammaticAttribute) {\n            removeTextFromElements(\"[\".concat(userProgrammaticAttribute, \"]\"));\n        }\n        return text_1;\n    }\n    return element.textContent;\n}\n/**\n * Returns true if element.innerText excludes the text from inline SCRIPT and STYLE element. This\n * should be the case everywhere except on Internet Explorer 10 and 11 (see [1])\n *\n * The innerText property relies on what is actually rendered to compute its output, so to check if\n * it actually excludes SCRIPT and STYLE content, a solution would be to create a style element, set\n * its content to '*', inject it in the document body, and check if the style element innerText\n * property returns '*'. Using a new `document` instance won't work as it is not rendered.\n *\n * This solution requires specific CSP rules (see [2]) to be set by the customer. We want to avoid\n * this, so instead we rely on browser detection. In case of false negative, the impact should be\n * low, since we rely on this result to remove the SCRIPT and STYLE innerText (which will be empty)\n * from a parent element innerText.\n *\n * [1]: https://web.archive.org/web/20210602165716/http://perfectionkills.com/the-poor-misunderstood-innerText/#diff-with-textContent\n * [2]: https://github.com/DataDog/browser-sdk/issues/1084\n */\nfunction supportsInnerTextScriptAndStyleRemoval() {\n    return !isIE();\n}\n/**\n * Returns true if the browser supports the element.labels property.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsLabelPropertyResult;\nfunction supportsLabelProperty() {\n    if (supportsLabelPropertyResult === undefined) {\n        supportsLabelPropertyResult = 'labels' in HTMLInputElement.prototype;\n    }\n    return supportsLabelPropertyResult;\n}\n/**\n * Returns true if the browser supports the element.closest method.  This should be the case\n * everywhere except on Internet Explorer.\n * Note: The result is computed lazily, because we don't want any DOM access when the SDK is\n * evaluated.\n */\nvar supportsElementClosestResult;\nfunction supportsElementClosest() {\n    if (supportsElementClosestResult === undefined) {\n        supportsElementClosestResult = 'closest' in HTMLElement.prototype;\n    }\n    return supportsElementClosestResult;\n}\n//# sourceMappingURL=getActionNameFromElement.js.map","import { isExperimentalFeatureEnabled, getRelativeTime, ONE_MINUTE, ContextHistory, addEventListener, generateUUID, clocksNow, ONE_SECOND, elapsed, } from '@datadog/browser-core';\nimport { trackEventCounts } from '../../trackEventCounts';\nimport { waitIdlePage } from '../../waitIdlePage';\nimport { getActionNameFromElement } from './getActionNameFromElement';\n// Maximum duration for automatic actions\nexport var AUTO_ACTION_MAX_DURATION = 10 * ONE_SECOND;\nexport var ACTION_CONTEXT_TIME_OUT_DELAY = 5 * ONE_MINUTE; // arbitrary\nexport function trackActions(lifeCycle, domMutationObservable, _a) {\n    var actionNameAttribute = _a.actionNameAttribute;\n    var history = new ContextHistory(ACTION_CONTEXT_TIME_OUT_DELAY);\n    lifeCycle.subscribe(8 /* SESSION_RENEWED */, function () {\n        history.reset();\n    });\n    var stopListener = listenEvents(function (event) {\n        if (!isExperimentalFeatureEnabled('frustration-signals') && history.find()) {\n            // Ignore any new action if another one is already occurring.\n            return;\n        }\n        var name = getActionNameFromElement(event.target, actionNameAttribute);\n        if (!name) {\n            return;\n        }\n        var actionController = newAction(lifeCycle, domMutationObservable, \"click\" /* CLICK */, name, event, function (endTime) {\n            historyEntry.close(getRelativeTime(endTime));\n        }, function () {\n            historyEntry.remove();\n        });\n        var historyEntry = history.add(actionController, actionController.startClocks.relative);\n    }).stop;\n    var actionContexts = {\n        findActionId: function (startTime) {\n            var _a;\n            return isExperimentalFeatureEnabled('frustration-signals')\n                ? history.findAll(startTime).map(function (controller) { return controller.id; })\n                : (_a = history.find(startTime)) === null || _a === void 0 ? void 0 : _a.id;\n        },\n    };\n    return {\n        stop: function () {\n            history.findAll().forEach(function (actionController) { return actionController.discard(); });\n            stopListener();\n        },\n        actionContexts: actionContexts,\n    };\n}\nfunction listenEvents(callback) {\n    return addEventListener(window, \"click\" /* CLICK */, function (event) {\n        if (event.target instanceof Element) {\n            callback(event);\n        }\n    }, { capture: true });\n}\nfunction newAction(lifeCycle, domMutationObservable, type, name, event, onCompleteCallback, onDiscardCallback) {\n    var id = generateUUID();\n    var startClocks = clocksNow();\n    var eventCountsSubscription = trackEventCounts(lifeCycle);\n    var stopWaitingIdlePage = waitIdlePage(lifeCycle, domMutationObservable, function (idleEvent) {\n        if (idleEvent.hadActivity && startClocks.timeStamp <= idleEvent.end) {\n            complete(idleEvent.end);\n        }\n        else {\n            discard();\n        }\n    }, AUTO_ACTION_MAX_DURATION).stop;\n    var viewCreatedSubscription;\n    if (!isExperimentalFeatureEnabled('frustration-signals')) {\n        // New views trigger the discard of the current pending Action\n        viewCreatedSubscription = lifeCycle.subscribe(2 /* VIEW_CREATED */, discard);\n    }\n    function complete(endTime) {\n        cleanup();\n        var eventCounts = eventCountsSubscription.eventCounts;\n        lifeCycle.notify(1 /* AUTO_ACTION_COMPLETED */, {\n            counts: {\n                errorCount: eventCounts.errorCount,\n                longTaskCount: eventCounts.longTaskCount,\n                resourceCount: eventCounts.resourceCount,\n            },\n            duration: elapsed(startClocks.timeStamp, endTime),\n            id: id,\n            name: name,\n            startClocks: startClocks,\n            type: type,\n            event: event,\n        });\n        onCompleteCallback(endTime);\n    }\n    function discard() {\n        cleanup();\n        onDiscardCallback();\n    }\n    function cleanup() {\n        stopWaitingIdlePage();\n        eventCountsSubscription.stop();\n        if (viewCreatedSubscription) {\n            viewCreatedSubscription.unsubscribe();\n        }\n    }\n    return {\n        discard: discard,\n        id: id,\n        startClocks: startClocks,\n    };\n}\n//# sourceMappingURL=trackActions.js.map","import { noop, assign, combine, toServerDuration, generateUUID } from '@datadog/browser-core';\nimport { trackActions } from './trackActions';\nexport function startActionCollection(lifeCycle, domMutationObservable, configuration, foregroundContexts) {\n    lifeCycle.subscribe(1 /* AUTO_ACTION_COMPLETED */, function (action) {\n        return lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, processAction(action, foregroundContexts));\n    });\n    var actionContexts = { findActionId: noop };\n    if (configuration.trackInteractions) {\n        actionContexts = trackActions(lifeCycle, domMutationObservable, configuration).actionContexts;\n    }\n    return {\n        addAction: function (action, savedCommonContext) {\n            lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, assign({\n                savedCommonContext: savedCommonContext,\n            }, processAction(action, foregroundContexts)));\n        },\n        actionContexts: actionContexts,\n    };\n}\nfunction processAction(action, foregroundContexts) {\n    var autoActionProperties = isAutoAction(action)\n        ? {\n            action: {\n                error: {\n                    count: action.counts.errorCount,\n                },\n                id: action.id,\n                loading_time: toServerDuration(action.duration),\n                long_task: {\n                    count: action.counts.longTaskCount,\n                },\n                resource: {\n                    count: action.counts.resourceCount,\n                },\n            },\n        }\n        : undefined;\n    var customerContext = !isAutoAction(action) ? action.context : undefined;\n    var actionEvent = combine({\n        action: {\n            id: generateUUID(),\n            target: {\n                name: action.name,\n            },\n            type: action.type,\n        },\n        date: action.startClocks.timeStamp,\n        type: \"action\" /* ACTION */,\n    }, autoActionProperties);\n    var inForeground = foregroundContexts.isInForegroundAt(action.startClocks.relative);\n    if (inForeground !== undefined) {\n        actionEvent.view = { in_foreground: inForeground };\n    }\n    return {\n        customerContext: customerContext,\n        rawRumEvent: actionEvent,\n        startTime: action.startClocks.relative,\n        domainContext: isAutoAction(action) ? { event: action.event } : {},\n    };\n}\nfunction isAutoAction(action) {\n    return action.type !== \"custom\" /* CUSTOM */;\n}\n//# sourceMappingURL=actionCollection.js.map","import { instrumentMethodAndCallOriginal } from '../../tools/instrumentMethod';\nimport { computeStackTrace } from './computeStackTrace';\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types\nvar ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;\n/**\n * Cross-browser collection of unhandled errors\n *\n * Supports:\n * - Firefox: full stack trace with line numbers, plus column number\n * on top frame; column number is not guaranteed\n * - Opera: full stack trace with line and column numbers\n * - Chrome: full stack trace with line and column numbers\n * - Safari: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n * - IE: line and column number for the top frame only; some frames\n * may be missing, and column number is not guaranteed\n *\n * In theory, TraceKit should work on all of the following versions:\n * - IE5.5+ (only 8.0 tested)\n * - Firefox 0.9+ (only 3.5+ tested)\n * - Opera 7+ (only 10.50 tested; versions 9 and earlier may require\n * Exceptions Have Stacktrace to be enabled in opera:config)\n * - Safari 3+ (only 4+ tested)\n * - Chrome 1+ (only 5+ tested)\n * - Konqueror 3.5+ (untested)\n *\n * Tries to catch all unhandled errors and report them to the\n * callback.\n *\n * Callbacks receive a StackTrace object as described in the\n * computeStackTrace docs.\n *\n * @memberof TraceKit\n * @namespace\n */\nexport function startUnhandledErrorCollection(callback) {\n    var stopInstrumentingOnError = instrumentOnError(callback).stop;\n    var stopInstrumentingOnUnhandledRejection = instrumentUnhandledRejection(callback).stop;\n    return {\n        stop: function () {\n            stopInstrumentingOnError();\n            stopInstrumentingOnUnhandledRejection();\n        },\n    };\n}\n/**\n * Install a global onerror handler\n */\nfunction instrumentOnError(callback) {\n    return instrumentMethodAndCallOriginal(window, 'onerror', {\n        before: function (message, url, lineNo, columnNo, errorObj) {\n            var stack;\n            if (errorObj) {\n                stack = computeStackTrace(errorObj);\n                callback(stack, errorObj);\n            }\n            else {\n                var location_1 = {\n                    url: url,\n                    column: columnNo,\n                    line: lineNo,\n                };\n                var name_1;\n                var msg = message;\n                if ({}.toString.call(message) === '[object String]') {\n                    var groups = ERROR_TYPES_RE.exec(msg);\n                    if (groups) {\n                        name_1 = groups[1];\n                        msg = groups[2];\n                    }\n                }\n                stack = {\n                    name: name_1,\n                    message: typeof msg === 'string' ? msg : undefined,\n                    stack: [location_1],\n                };\n                callback(stack, message);\n            }\n        },\n    });\n}\n/**\n * Install a global onunhandledrejection handler\n */\nfunction instrumentUnhandledRejection(callback) {\n    return instrumentMethodAndCallOriginal(window, 'onunhandledrejection', {\n        before: function (e) {\n            var reason = e.reason || 'Empty reason';\n            var stack = computeStackTrace(reason);\n            callback(stack, reason);\n        },\n    });\n}\n//# sourceMappingURL=tracekit.js.map","import { callMonitored } from '../internalMonitoring';\nimport { computeStackTrace } from '../tracekit';\nimport { createHandlingStack, formatErrorMessage, toStackTraceString } from '../../tools/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { find, jsonStringify } from '../../tools/utils';\nexport var ConsoleApiName = {\n    log: 'log',\n    debug: 'debug',\n    info: 'info',\n    warn: 'warn',\n    error: 'error',\n};\nvar consoleObservablesByApi = {};\nexport function initConsoleObservable(apis) {\n    var consoleObservables = apis.map(function (api) {\n        if (!consoleObservablesByApi[api]) {\n            consoleObservablesByApi[api] = createConsoleObservable(api);\n        }\n        return consoleObservablesByApi[api];\n    });\n    return mergeObservables.apply(void 0, consoleObservables);\n}\n/* eslint-disable no-console */\nfunction createConsoleObservable(api) {\n    var observable = new Observable(function () {\n        var originalConsoleApi = console[api];\n        console[api] = function () {\n            var params = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                params[_i] = arguments[_i];\n            }\n            originalConsoleApi.apply(console, params);\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                observable.notify(buildConsoleLog(params, api, handlingStack));\n            });\n        };\n        return function () {\n            console[api] = originalConsoleApi;\n        };\n    });\n    return observable;\n}\nfunction buildConsoleLog(params, api, handlingStack) {\n    // Todo: remove console error prefix in the next major version\n    var message = params.map(function (param) { return formatConsoleParameters(param); }).join(' ');\n    var stack;\n    if (api === ConsoleApiName.error) {\n        var firstErrorParam = find(params, function (param) { return param instanceof Error; });\n        stack = firstErrorParam ? toStackTraceString(computeStackTrace(firstErrorParam)) : undefined;\n        message = \"console error: \".concat(message);\n    }\n    return {\n        api: api,\n        message: message,\n        stack: stack,\n        handlingStack: handlingStack,\n    };\n}\nfunction formatConsoleParameters(param) {\n    if (typeof param === 'string') {\n        return param;\n    }\n    if (param instanceof Error) {\n        return formatErrorMessage(computeStackTrace(param));\n    }\n    return jsonStringify(param, undefined, 2);\n}\n//# sourceMappingURL=consoleObservable.js.map","import { toStackTraceString } from '../../tools/error';\nimport { mergeObservables, Observable } from '../../tools/observable';\nimport { includes, addEventListener, safeTruncate } from '../../tools/utils';\nimport { monitor } from '../internalMonitoring';\nexport var RawReportType = {\n    intervention: 'intervention',\n    deprecation: 'deprecation',\n    cspViolation: 'csp_violation',\n};\nexport function initReportObservable(apis) {\n    var observables = [];\n    if (includes(apis, RawReportType.cspViolation)) {\n        observables.push(createCspViolationReportObservable());\n    }\n    var reportTypes = apis.filter(function (api) { return api !== RawReportType.cspViolation; });\n    if (reportTypes.length) {\n        observables.push(createReportObservable(reportTypes));\n    }\n    return mergeObservables.apply(void 0, observables);\n}\nfunction createReportObservable(reportTypes) {\n    var observable = new Observable(function () {\n        if (!window.ReportingObserver) {\n            return;\n        }\n        var handleReports = monitor(function (reports) {\n            return reports.forEach(function (report) {\n                observable.notify(buildRawReportFromReport(report));\n            });\n        });\n        var observer = new window.ReportingObserver(handleReports, {\n            types: reportTypes,\n            buffered: true,\n        });\n        observer.observe();\n        return function () {\n            observer.disconnect();\n        };\n    });\n    return observable;\n}\nfunction createCspViolationReportObservable() {\n    var observable = new Observable(function () {\n        var handleCspViolation = monitor(function (event) {\n            observable.notify(buildRawReportFromCspViolation(event));\n        });\n        var stop = addEventListener(document, \"securitypolicyviolation\" /* SECURITY_POLICY_VIOLATION */, handleCspViolation).stop;\n        return stop;\n    });\n    return observable;\n}\nfunction buildRawReportFromReport(_a) {\n    var type = _a.type, body = _a.body;\n    return {\n        type: type,\n        subtype: body.id,\n        message: \"\".concat(type, \": \").concat(body.message),\n        stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),\n    };\n}\nfunction buildRawReportFromCspViolation(event) {\n    var type = RawReportType.cspViolation;\n    var message = \"'\".concat(event.blockedURI, \"' blocked by '\").concat(event.effectiveDirective, \"' directive\");\n    return {\n        type: RawReportType.cspViolation,\n        subtype: event.effectiveDirective,\n        message: \"\".concat(type, \": \").concat(message),\n        stack: buildStack(event.effectiveDirective, \"\".concat(message, \" of the policy \\\"\").concat(safeTruncate(event.originalPolicy, 100, '...'), \"\\\"\"), event.sourceFile, event.lineNumber, event.columnNumber),\n    };\n}\nfunction buildStack(name, message, sourceFile, lineNumber, columnNumber) {\n    return (sourceFile &&\n        toStackTraceString({\n            name: name,\n            message: message,\n            stack: [\n                {\n                    func: '?',\n                    url: sourceFile,\n                    line: lineNumber,\n                    column: columnNumber,\n                },\n            ],\n        }));\n}\n//# sourceMappingURL=reportObservable.js.map","import { addEventListeners } from '@datadog/browser-core';\nvar trackFirstHiddenSingleton;\nvar stopListeners;\nexport function trackFirstHidden(emitter) {\n    if (emitter === void 0) { emitter = window; }\n    if (!trackFirstHiddenSingleton) {\n        if (document.visibilityState === 'hidden') {\n            trackFirstHiddenSingleton = {\n                timeStamp: 0,\n            };\n        }\n        else {\n            trackFirstHiddenSingleton = {\n                timeStamp: Infinity,\n            };\n            (stopListeners = addEventListeners(emitter, [\"pagehide\" /* PAGE_HIDE */, \"visibilitychange\" /* VISIBILITY_CHANGE */], function (event) {\n                if (event.type === 'pagehide' || document.visibilityState === 'hidden') {\n                    trackFirstHiddenSingleton.timeStamp = event.timeStamp;\n                    stopListeners();\n                }\n            }, { capture: true }).stop);\n        }\n    }\n    return trackFirstHiddenSingleton;\n}\nexport function resetFirstHidden() {\n    if (stopListeners) {\n        stopListeners();\n    }\n    trackFirstHiddenSingleton = undefined;\n}\n//# sourceMappingURL=trackFirstHidden.js.map","import { assign, computeStackTrace, formatUnknownError, ErrorSource, generateUUID, Observable, trackRuntimeError, } from '@datadog/browser-core';\nimport { trackConsoleError } from './trackConsoleError';\nimport { trackReportError } from './trackReportError';\nexport function startErrorCollection(lifeCycle, foregroundContexts) {\n    var errorObservable = new Observable();\n    trackConsoleError(errorObservable);\n    trackRuntimeError(errorObservable);\n    trackReportError(errorObservable);\n    errorObservable.subscribe(function (error) { return lifeCycle.notify(12 /* RAW_ERROR_COLLECTED */, { error: error }); });\n    return doStartErrorCollection(lifeCycle, foregroundContexts);\n}\nexport function doStartErrorCollection(lifeCycle, foregroundContexts) {\n    lifeCycle.subscribe(12 /* RAW_ERROR_COLLECTED */, function (_a) {\n        var error = _a.error, customerContext = _a.customerContext, savedCommonContext = _a.savedCommonContext;\n        lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, assign({\n            customerContext: customerContext,\n            savedCommonContext: savedCommonContext,\n        }, processError(error, foregroundContexts)));\n    });\n    return {\n        addError: function (_a, savedCommonContext) {\n            var error = _a.error, handlingStack = _a.handlingStack, startClocks = _a.startClocks, customerContext = _a.context;\n            var rawError = computeRawError(error, handlingStack, startClocks);\n            lifeCycle.notify(12 /* RAW_ERROR_COLLECTED */, {\n                customerContext: customerContext,\n                savedCommonContext: savedCommonContext,\n                error: rawError,\n            });\n        },\n    };\n}\nfunction computeRawError(error, handlingStack, startClocks) {\n    var stackTrace = error instanceof Error ? computeStackTrace(error) : undefined;\n    return assign({\n        startClocks: startClocks,\n        source: ErrorSource.CUSTOM,\n        originalError: error,\n        handling: \"handled\" /* HANDLED */,\n    }, formatUnknownError(stackTrace, error, 'Provided', handlingStack));\n}\nfunction processError(error, foregroundContexts) {\n    var rawRumEvent = {\n        date: error.startClocks.timeStamp,\n        error: {\n            id: generateUUID(),\n            message: error.message,\n            source: error.source,\n            stack: error.stack,\n            handling_stack: error.handlingStack,\n            type: error.type,\n            handling: error.handling,\n            source_type: 'browser',\n        },\n        type: \"error\" /* ERROR */,\n    };\n    var inForeground = foregroundContexts.isInForegroundAt(error.startClocks.relative);\n    if (inForeground !== undefined) {\n        rawRumEvent.view = { in_foreground: inForeground };\n    }\n    return {\n        rawRumEvent: rawRumEvent,\n        startTime: error.startClocks.relative,\n        domainContext: {\n            error: error.originalError,\n        },\n    };\n}\n//# sourceMappingURL=errorCollection.js.map","import { clocksNow, initConsoleObservable, ErrorSource, ConsoleApiName } from '@datadog/browser-core';\nexport function trackConsoleError(errorObservable) {\n    var subscription = initConsoleObservable([ConsoleApiName.error]).subscribe(function (consoleError) {\n        return errorObservable.notify({\n            startClocks: clocksNow(),\n            message: consoleError.message,\n            stack: consoleError.stack,\n            source: ErrorSource.CONSOLE,\n            handling: \"handled\" /* HANDLED */,\n            handlingStack: consoleError.handlingStack,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackConsoleError.js.map","import { ErrorSource, formatUnknownError } from '../../tools/error';\nimport { clocksNow } from '../../tools/timeUtils';\nimport { startUnhandledErrorCollection } from '../tracekit';\nexport function trackRuntimeError(errorObservable) {\n    return startUnhandledErrorCollection(function (stackTrace, errorObject) {\n        var _a = formatUnknownError(stackTrace, errorObject, 'Uncaught'), stack = _a.stack, message = _a.message, type = _a.type;\n        errorObservable.notify({\n            message: message,\n            stack: stack,\n            type: type,\n            source: ErrorSource.SOURCE,\n            startClocks: clocksNow(),\n            originalError: errorObject,\n            handling: \"unhandled\" /* UNHANDLED */,\n        });\n    });\n}\n//# sourceMappingURL=trackRuntimeError.js.map","import { clocksNow, ErrorSource, initReportObservable, RawReportType } from '@datadog/browser-core';\nexport function trackReportError(errorObservable) {\n    var subscription = initReportObservable([RawReportType.cspViolation, RawReportType.intervention]).subscribe(function (reportError) {\n        return errorObservable.notify({\n            startClocks: clocksNow(),\n            message: reportError.message,\n            stack: reportError.stack,\n            type: reportError.subtype,\n            source: ErrorSource.REPORT,\n            handling: \"unhandled\" /* UNHANDLED */,\n        });\n    });\n    return {\n        stop: function () {\n            subscription.unsubscribe();\n        },\n    };\n}\n//# sourceMappingURL=trackReportError.js.map","import { toValidEntry } from './resourceUtils';\n/**\n * Look for corresponding timing in resource timing buffer\n *\n * Observations:\n * - Timing (start, end) are nested inside the request (start, end)\n * - Some timing can be not exactly nested, being off by < 1 ms\n * - Browsers generate a timing entry for OPTIONS request\n *\n * Strategy:\n * - from valid nested entries (with 1 ms error margin)\n * - if a single timing match, return the timing\n * - if two following timings match (OPTIONS request), return the timing for the actual request\n * - otherwise we can't decide, return undefined\n */\nexport function matchRequestTiming(request) {\n    if (!performance || !('getEntriesByName' in performance)) {\n        return;\n    }\n    var sameNameEntries = performance.getEntriesByName(request.url, 'resource');\n    if (!sameNameEntries.length || !('toJSON' in sameNameEntries[0])) {\n        return;\n    }\n    var candidates = sameNameEntries\n        .map(function (entry) { return entry.toJSON(); })\n        .filter(toValidEntry)\n        .filter(function (entry) {\n        return isBetween(entry, request.startClocks.relative, endTime({ startTime: request.startClocks.relative, duration: request.duration }));\n    });\n    if (candidates.length === 1) {\n        return candidates[0];\n    }\n    if (candidates.length === 2 && firstCanBeOptionRequest(candidates)) {\n        return candidates[1];\n    }\n    return;\n}\nfunction firstCanBeOptionRequest(correspondingEntries) {\n    return endTime(correspondingEntries[0]) <= correspondingEntries[1].startTime;\n}\nfunction endTime(timing) {\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return (timing.startTime + timing.duration);\n}\nfunction isBetween(timing, start, end) {\n    var errorMargin = 1;\n    // eslint-disable-next-line @typescript-eslint/restrict-plus-operands\n    return timing.startTime >= start - errorMargin && endTime(timing) <= end + errorMargin;\n}\n//# sourceMappingURL=matchRequestTiming.js.map","import { combine, generateUUID, toServerDuration, relativeToClocks, assign, } from '@datadog/browser-core';\nimport { supportPerformanceEntry } from '../../../browser/performanceCollection';\nimport { matchRequestTiming } from './matchRequestTiming';\nimport { computePerformanceResourceDetails, computePerformanceResourceDuration, computeResourceKind, computeSize, isRequestKind, } from './resourceUtils';\nexport function startResourceCollection(lifeCycle) {\n    lifeCycle.subscribe(6 /* REQUEST_COMPLETED */, function (request) {\n        lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, processRequest(request));\n    });\n    lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'resource' && !isRequestKind(entry)) {\n                lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, processResourceEntry(entry));\n            }\n        }\n    });\n}\nfunction processRequest(request) {\n    var type = request.type === \"xhr\" /* XHR */ ? \"xhr\" /* XHR */ : \"fetch\" /* FETCH */;\n    var matchingTiming = matchRequestTiming(request);\n    var startClocks = matchingTiming ? relativeToClocks(matchingTiming.startTime) : request.startClocks;\n    var correspondingTimingOverrides = matchingTiming ? computePerformanceEntryMetrics(matchingTiming) : undefined;\n    var tracingInfo = computeRequestTracingInfo(request);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            duration: toServerDuration(request.duration),\n            method: request.method,\n            status_code: request.status,\n            url: request.url,\n        },\n        type: \"resource\" /* RESOURCE */,\n    }, tracingInfo, correspondingTimingOverrides);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: matchingTiming && toPerformanceEntryRepresentation(matchingTiming),\n            xhr: request.xhr,\n            response: request.response,\n            requestInput: request.input,\n            requestInit: request.init,\n            error: request.error,\n        },\n    };\n}\nfunction processResourceEntry(entry) {\n    var type = computeResourceKind(entry);\n    var entryMetrics = computePerformanceEntryMetrics(entry);\n    var tracingInfo = computeEntryTracingInfo(entry);\n    var startClocks = relativeToClocks(entry.startTime);\n    var resourceEvent = combine({\n        date: startClocks.timeStamp,\n        resource: {\n            id: generateUUID(),\n            type: type,\n            url: entry.name,\n        },\n        type: \"resource\" /* RESOURCE */,\n    }, tracingInfo, entryMetrics);\n    return {\n        startTime: startClocks.relative,\n        rawRumEvent: resourceEvent,\n        domainContext: {\n            performanceEntry: toPerformanceEntryRepresentation(entry),\n        },\n    };\n}\nfunction computePerformanceEntryMetrics(timing) {\n    return {\n        resource: assign({\n            duration: computePerformanceResourceDuration(timing),\n            size: computeSize(timing),\n        }, computePerformanceResourceDetails(timing)),\n    };\n}\nfunction computeRequestTracingInfo(request) {\n    var hasBeenTraced = request.traceId && request.spanId;\n    if (!hasBeenTraced) {\n        return undefined;\n    }\n    return {\n        _dd: {\n            span_id: request.spanId.toDecimalString(),\n            trace_id: request.traceId.toDecimalString(),\n        },\n    };\n}\nfunction computeEntryTracingInfo(entry) {\n    return entry.traceId ? { _dd: { trace_id: entry.traceId } } : undefined;\n}\nfunction toPerformanceEntryRepresentation(entry) {\n    if (supportPerformanceEntry() && entry instanceof PerformanceEntry) {\n        entry.toJSON();\n    }\n    return entry;\n}\n//# sourceMappingURL=resourceCollection.js.map","import { assign, addEventListeners, elapsed, ONE_MINUTE, find, findLast } from '@datadog/browser-core';\nimport { trackFirstHidden } from './trackFirstHidden';\n// Discard LCP and FCP timings above a certain delay to avoid incorrect data\n// It happens in some cases like sleep mode or some browser implementations\nexport var TIMING_MAXIMUM_DELAY = 10 * ONE_MINUTE;\nexport function trackInitialViewTimings(lifeCycle, callback) {\n    var timings = {};\n    function setTimings(newTimings) {\n        assign(timings, newTimings);\n        callback(timings);\n    }\n    var stopNavigationTracking = trackNavigationTimings(lifeCycle, setTimings).stop;\n    var stopFCPTracking = trackFirstContentfulPaintTiming(lifeCycle, function (firstContentfulPaint) {\n        return setTimings({ firstContentfulPaint: firstContentfulPaint });\n    }).stop;\n    var stopLCPTracking = trackLargestContentfulPaintTiming(lifeCycle, window, function (largestContentfulPaint) {\n        setTimings({\n            largestContentfulPaint: largestContentfulPaint,\n        });\n    }).stop;\n    var stopFIDTracking = trackFirstInputTimings(lifeCycle, function (_a) {\n        var firstInputDelay = _a.firstInputDelay, firstInputTime = _a.firstInputTime;\n        setTimings({\n            firstInputDelay: firstInputDelay,\n            firstInputTime: firstInputTime,\n        });\n    }).stop;\n    return {\n        stop: function () {\n            stopNavigationTracking();\n            stopFCPTracking();\n            stopLCPTracking();\n            stopFIDTracking();\n        },\n    };\n}\nexport function trackNavigationTimings(lifeCycle, callback) {\n    var stop = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'navigation') {\n                callback({\n                    domComplete: entry.domComplete,\n                    domContentLoaded: entry.domContentLoadedEventEnd,\n                    domInteractive: entry.domInteractive,\n                    loadEvent: entry.loadEventEnd,\n                });\n            }\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\nexport function trackFirstContentfulPaintTiming(lifeCycle, callback) {\n    var firstHidden = trackFirstHidden();\n    var stop = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var fcpEntry = find(entries, function (entry) {\n            return entry.entryType === 'paint' &&\n                entry.name === 'first-contentful-paint' &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < TIMING_MAXIMUM_DELAY;\n        });\n        if (fcpEntry) {\n            callback(fcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return { stop: stop };\n}\n/**\n * Track the largest contentful paint (LCP) occurring during the initial View.  This can yield\n * multiple values, only the most recent one should be used.\n * Documentation: https://web.dev/lcp/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getLCP.ts\n */\nexport function trackLargestContentfulPaintTiming(lifeCycle, emitter, callback) {\n    var firstHidden = trackFirstHidden();\n    // Ignore entries that come after the first user interaction.  According to the documentation, the\n    // browser should not send largest-contentful-paint entries after a user interact with the page,\n    // but the web-vitals reference implementation uses this as a safeguard.\n    var firstInteractionTimestamp = Infinity;\n    var stopEventListener = addEventListeners(emitter, [\"pointerdown\" /* POINTER_DOWN */, \"keydown\" /* KEY_DOWN */], function (event) {\n        firstInteractionTimestamp = event.timeStamp;\n    }, { capture: true, once: true }).stop;\n    var unsubscribeLifeCycle = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var lcpEntry = findLast(entries, function (entry) {\n            return entry.entryType === 'largest-contentful-paint' &&\n                entry.startTime < firstInteractionTimestamp &&\n                entry.startTime < firstHidden.timeStamp &&\n                entry.startTime < TIMING_MAXIMUM_DELAY;\n        });\n        if (lcpEntry) {\n            callback(lcpEntry.startTime);\n        }\n    }).unsubscribe;\n    return {\n        stop: function () {\n            stopEventListener();\n            unsubscribeLifeCycle();\n        },\n    };\n}\n/**\n * Track the first input occurring during the initial View to return:\n * - First Input Delay\n * - First Input Time\n * Callback is called at most one time.\n * Documentation: https://web.dev/fid/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getFID.ts\n */\nexport function trackFirstInputTimings(lifeCycle, callback) {\n    var firstHidden = trackFirstHidden();\n    var stop = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        var firstInputEntry = find(entries, function (entry) {\n            return entry.entryType === 'first-input' && entry.startTime < firstHidden.timeStamp;\n        });\n        if (firstInputEntry) {\n            var firstInputDelay = elapsed(firstInputEntry.startTime, firstInputEntry.processingStart);\n            callback({\n                // Ensure firstInputDelay to be positive, see\n                // https://bugs.chromium.org/p/chromium/issues/detail?id=1185815\n                firstInputDelay: firstInputDelay >= 0 ? firstInputDelay : 0,\n                firstInputTime: firstInputEntry.startTime,\n            });\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\n//# sourceMappingURL=trackInitialViewTimings.js.map","import { noop, round, ONE_SECOND, elapsed } from '@datadog/browser-core';\nimport { supportPerformanceTimingEvent } from '../../../browser/performanceCollection';\nimport { trackEventCounts } from '../../trackEventCounts';\nimport { waitIdlePage } from '../../waitIdlePage';\nexport function trackViewMetrics(lifeCycle, domMutationObservable, scheduleViewUpdate, loadingType, viewStart) {\n    var viewMetrics = {\n        eventCounts: {\n            errorCount: 0,\n            longTaskCount: 0,\n            resourceCount: 0,\n            userActionCount: 0,\n        },\n    };\n    var stopEventCountsTracking = trackEventCounts(lifeCycle, function (newEventCounts) {\n        viewMetrics.eventCounts = newEventCounts;\n        scheduleViewUpdate();\n    }).stop;\n    var _a = trackLoadingTime(lifeCycle, domMutationObservable, loadingType, viewStart, function (newLoadingTime) {\n        viewMetrics.loadingTime = newLoadingTime;\n        scheduleViewUpdate();\n    }), stopLoadingTimeTracking = _a.stop, setLoadEvent = _a.setLoadEvent;\n    var stopCLSTracking;\n    if (isLayoutShiftSupported()) {\n        viewMetrics.cumulativeLayoutShift = 0;\n        (stopCLSTracking = trackCumulativeLayoutShift(lifeCycle, function (cumulativeLayoutShift) {\n            viewMetrics.cumulativeLayoutShift = cumulativeLayoutShift;\n            scheduleViewUpdate();\n        }).stop);\n    }\n    else {\n        stopCLSTracking = noop;\n    }\n    return {\n        stop: function () {\n            stopEventCountsTracking();\n            stopLoadingTimeTracking();\n            stopCLSTracking();\n        },\n        setLoadEvent: setLoadEvent,\n        viewMetrics: viewMetrics,\n    };\n}\nfunction trackLoadingTime(lifeCycle, domMutationObservable, loadType, viewStart, callback) {\n    var isWaitingForLoadEvent = loadType === \"initial_load\" /* INITIAL_LOAD */;\n    var isWaitingForActivityLoadingTime = true;\n    var loadingTimeCandidates = [];\n    function invokeCallbackIfAllCandidatesAreReceived() {\n        if (!isWaitingForActivityLoadingTime && !isWaitingForLoadEvent && loadingTimeCandidates.length > 0) {\n            callback(Math.max.apply(Math, loadingTimeCandidates));\n        }\n    }\n    var stop = waitIdlePage(lifeCycle, domMutationObservable, function (event) {\n        if (isWaitingForActivityLoadingTime) {\n            isWaitingForActivityLoadingTime = false;\n            if (event.hadActivity) {\n                loadingTimeCandidates.push(elapsed(viewStart.timeStamp, event.end));\n            }\n            invokeCallbackIfAllCandidatesAreReceived();\n        }\n    }).stop;\n    return {\n        stop: stop,\n        setLoadEvent: function (loadEvent) {\n            if (isWaitingForLoadEvent) {\n                isWaitingForLoadEvent = false;\n                loadingTimeCandidates.push(loadEvent);\n                invokeCallbackIfAllCandidatesAreReceived();\n            }\n        },\n    };\n}\n/**\n * Track the cumulative layout shifts (CLS).\n * Layout shifts are grouped into session windows.\n * The minimum gap between session windows is 1 second.\n * The maximum duration of a session window is 5 second.\n * The session window layout shift value is the sum of layout shifts inside it.\n * The CLS value is the max of session windows values.\n *\n * This yields a new value whenever the CLS value is updated (a higher session window value is computed).\n *\n * See isLayoutShiftSupported to check for browser support.\n *\n * Documentation:\n * https://web.dev/cls/\n * https://web.dev/evolving-cls/\n * Reference implementation: https://github.com/GoogleChrome/web-vitals/blob/master/src/getCLS.ts\n */\nfunction trackCumulativeLayoutShift(lifeCycle, callback) {\n    var maxClsValue = 0;\n    var window = slidingSessionWindow();\n    var stop = lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType === 'layout-shift' && !entry.hadRecentInput) {\n                window.update(entry);\n                if (window.value() > maxClsValue) {\n                    maxClsValue = window.value();\n                    callback(round(maxClsValue, 4));\n                }\n            }\n        }\n    }).unsubscribe;\n    return {\n        stop: stop,\n    };\n}\nfunction slidingSessionWindow() {\n    var value = 0;\n    var startTime;\n    var endTime;\n    return {\n        update: function (entry) {\n            var shouldCreateNewWindow = startTime === undefined ||\n                entry.startTime - endTime >= ONE_SECOND ||\n                entry.startTime - startTime >= 5 * ONE_SECOND;\n            if (shouldCreateNewWindow) {\n                startTime = endTime = entry.startTime;\n                value = entry.value;\n            }\n            else {\n                value += entry.value;\n                endTime = entry.startTime;\n            }\n        },\n        value: function () { return value; },\n    };\n}\n/**\n * Check whether `layout-shift` is supported by the browser.\n */\nfunction isLayoutShiftSupported() {\n    return supportPerformanceTimingEvent('layout-shift');\n}\n//# sourceMappingURL=trackViewMetrics.js.map","import { shallowClone, assign, elapsed, generateUUID, monitor, ONE_MINUTE, throttle, clocksNow, clocksOrigin, timeStampNow, display, looksLikeRelativeTime, } from '@datadog/browser-core';\nimport { trackInitialViewTimings } from './trackInitialViewTimings';\nimport { trackViewMetrics } from './trackViewMetrics';\nexport var THROTTLE_VIEW_UPDATE_PERIOD = 3000;\nexport var SESSION_KEEP_ALIVE_INTERVAL = 5 * ONE_MINUTE;\nexport function trackViews(location, lifeCycle, domMutationObservable, locationChangeObservable, areViewsTrackedAutomatically, initialViewOptions) {\n    var _a = trackInitialView(initialViewOptions), stopInitialViewTracking = _a.stop, initialView = _a.initialView;\n    var currentView = initialView;\n    var stopViewLifeCycle = startViewLifeCycle().stop;\n    var locationChangeSubscription;\n    if (areViewsTrackedAutomatically) {\n        locationChangeSubscription = renewViewOnLocationChange(locationChangeObservable);\n    }\n    function trackInitialView(options) {\n        var initialView = newView(lifeCycle, domMutationObservable, location, \"initial_load\" /* INITIAL_LOAD */, clocksOrigin(), options);\n        var stop = trackInitialViewTimings(lifeCycle, function (timings) {\n            initialView.updateTimings(timings);\n            initialView.scheduleUpdate();\n        }).stop;\n        return { initialView: initialView, stop: stop };\n    }\n    function trackViewChange(startClocks, viewOptions) {\n        return newView(lifeCycle, domMutationObservable, location, \"route_change\" /* ROUTE_CHANGE */, startClocks, viewOptions);\n    }\n    function startViewLifeCycle() {\n        lifeCycle.subscribe(8 /* SESSION_RENEWED */, function () {\n            // do not trigger view update to avoid wrong data\n            currentView.end();\n            // Renew view on session renewal\n            currentView = trackViewChange(undefined, {\n                name: currentView.name,\n                service: currentView.service,\n                version: currentView.version,\n            });\n        });\n        // End the current view on page unload\n        lifeCycle.subscribe(9 /* BEFORE_UNLOAD */, function () {\n            currentView.end();\n            currentView.triggerUpdate();\n        });\n        // Session keep alive\n        var keepAliveInterval = window.setInterval(monitor(function () {\n            currentView.triggerUpdate();\n        }), SESSION_KEEP_ALIVE_INTERVAL);\n        return {\n            stop: function () {\n                clearInterval(keepAliveInterval);\n            },\n        };\n    }\n    function renewViewOnLocationChange(locationChangeObservable) {\n        return locationChangeObservable.subscribe(function (_a) {\n            var oldLocation = _a.oldLocation, newLocation = _a.newLocation;\n            if (areDifferentLocation(oldLocation, newLocation)) {\n                currentView.end();\n                currentView.triggerUpdate();\n                currentView = trackViewChange();\n                return;\n            }\n        });\n    }\n    return {\n        addTiming: function (name, time) {\n            if (time === void 0) { time = timeStampNow(); }\n            currentView.addTiming(name, time);\n            currentView.scheduleUpdate();\n        },\n        startView: function (options, startClocks) {\n            currentView.end(startClocks);\n            currentView.triggerUpdate();\n            currentView = trackViewChange(startClocks, options);\n        },\n        stop: function () {\n            locationChangeSubscription === null || locationChangeSubscription === void 0 ? void 0 : locationChangeSubscription.unsubscribe();\n            stopInitialViewTracking();\n            stopViewLifeCycle();\n            currentView.end();\n        },\n    };\n}\nfunction newView(lifeCycle, domMutationObservable, initialLocation, loadingType, startClocks, viewOptions) {\n    if (startClocks === void 0) { startClocks = clocksNow(); }\n    // Setup initial values\n    var id = generateUUID();\n    var timings = {};\n    var customTimings = {};\n    var documentVersion = 0;\n    var endClocks;\n    var location = shallowClone(initialLocation);\n    var name;\n    var service;\n    var version;\n    if (viewOptions) {\n        name = viewOptions.name;\n        service = viewOptions.service;\n        version = viewOptions.version;\n    }\n    lifeCycle.notify(2 /* VIEW_CREATED */, { id: id, name: name, startClocks: startClocks, service: service, version: version });\n    // Update the view every time the measures are changing\n    var _a = throttle(monitor(triggerViewUpdate), THROTTLE_VIEW_UPDATE_PERIOD, {\n        leading: false,\n    }), scheduleViewUpdate = _a.throttled, cancelScheduleViewUpdate = _a.cancel;\n    var _b = trackViewMetrics(lifeCycle, domMutationObservable, scheduleViewUpdate, loadingType, startClocks), setLoadEvent = _b.setLoadEvent, stopViewMetricsTracking = _b.stop, viewMetrics = _b.viewMetrics;\n    // Initial view update\n    triggerViewUpdate();\n    function triggerViewUpdate() {\n        documentVersion += 1;\n        var currentEnd = endClocks === undefined ? timeStampNow() : endClocks.timeStamp;\n        lifeCycle.notify(3 /* VIEW_UPDATED */, assign({\n            customTimings: customTimings,\n            documentVersion: documentVersion,\n            id: id,\n            name: name,\n            service: service,\n            version: version,\n            loadingType: loadingType,\n            location: location,\n            startClocks: startClocks,\n            timings: timings,\n            duration: elapsed(startClocks.timeStamp, currentEnd),\n            isActive: endClocks === undefined,\n        }, viewMetrics));\n    }\n    return {\n        name: name,\n        service: service,\n        version: version,\n        scheduleUpdate: scheduleViewUpdate,\n        end: function (clocks) {\n            if (clocks === void 0) { clocks = clocksNow(); }\n            endClocks = clocks;\n            stopViewMetricsTracking();\n            lifeCycle.notify(4 /* VIEW_ENDED */, { endClocks: endClocks });\n        },\n        triggerUpdate: function () {\n            // cancel any pending view updates execution\n            cancelScheduleViewUpdate();\n            triggerViewUpdate();\n        },\n        updateTimings: function (newTimings) {\n            timings = newTimings;\n            if (newTimings.loadEvent !== undefined) {\n                setLoadEvent(newTimings.loadEvent);\n            }\n        },\n        addTiming: function (name, time) {\n            var relativeTime = looksLikeRelativeTime(time) ? time : elapsed(startClocks.timeStamp, time);\n            customTimings[sanitizeTiming(name)] = relativeTime;\n        },\n    };\n}\n/**\n * Timing name is used as facet path that must contain only letters, digits, or the characters - _ . @ $\n */\nfunction sanitizeTiming(name) {\n    var sanitized = name.replace(/[^a-zA-Z0-9-_.@$]/g, '_');\n    if (sanitized !== name) {\n        display.warn(\"Invalid timing name: \".concat(name, \", sanitized to: \").concat(sanitized));\n    }\n    return sanitized;\n}\nfunction areDifferentLocation(currentLocation, otherLocation) {\n    return (currentLocation.pathname !== otherLocation.pathname ||\n        (!isHashAnAnchor(otherLocation.hash) &&\n            getPathFromHash(otherLocation.hash) !== getPathFromHash(currentLocation.hash)));\n}\nfunction isHashAnAnchor(hash) {\n    var correspondingId = hash.substr(1);\n    return !!document.getElementById(correspondingId);\n}\nfunction getPathFromHash(hash) {\n    var index = hash.indexOf('?');\n    return index < 0 ? hash : hash.slice(0, index);\n}\n//# sourceMappingURL=trackViews.js.map","import { isEmptyObject, mapValues, toServerDuration, isNumber } from '@datadog/browser-core';\nimport { trackViews } from './trackViews';\nexport function startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, foregroundContexts, recorderApi, initialViewOptions) {\n    lifeCycle.subscribe(3 /* VIEW_UPDATED */, function (view) {\n        return lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, processViewUpdate(view, foregroundContexts, recorderApi));\n    });\n    return trackViews(location, lifeCycle, domMutationObservable, locationChangeObservable, !configuration.trackViewsManually, initialViewOptions);\n}\nfunction processViewUpdate(view, foregroundContexts, recorderApi) {\n    var replayStats = recorderApi.getReplayStats(view.id);\n    var viewEvent = {\n        _dd: {\n            document_version: view.documentVersion,\n            replay_stats: replayStats,\n        },\n        date: view.startClocks.timeStamp,\n        type: \"view\" /* VIEW */,\n        view: {\n            action: {\n                count: view.eventCounts.userActionCount,\n            },\n            cumulative_layout_shift: view.cumulativeLayoutShift,\n            dom_complete: toServerDuration(view.timings.domComplete),\n            dom_content_loaded: toServerDuration(view.timings.domContentLoaded),\n            dom_interactive: toServerDuration(view.timings.domInteractive),\n            error: {\n                count: view.eventCounts.errorCount,\n            },\n            first_contentful_paint: toServerDuration(view.timings.firstContentfulPaint),\n            first_input_delay: toServerDuration(view.timings.firstInputDelay),\n            first_input_time: toServerDuration(view.timings.firstInputTime),\n            is_active: view.isActive,\n            name: view.name,\n            largest_contentful_paint: toServerDuration(view.timings.largestContentfulPaint),\n            load_event: toServerDuration(view.timings.loadEvent),\n            loading_time: discardNegativeDuration(toServerDuration(view.loadingTime)),\n            loading_type: view.loadingType,\n            long_task: {\n                count: view.eventCounts.longTaskCount,\n            },\n            resource: {\n                count: view.eventCounts.resourceCount,\n            },\n            time_spent: toServerDuration(view.duration),\n            in_foreground_periods: foregroundContexts.selectInForegroundPeriodsFor(view.startClocks.relative, view.duration),\n        },\n        session: {\n            has_replay: replayStats ? true : undefined,\n        },\n    };\n    if (!isEmptyObject(view.customTimings)) {\n        viewEvent.view.custom_timings = mapValues(view.customTimings, toServerDuration);\n    }\n    return {\n        rawRumEvent: viewEvent,\n        startTime: view.startClocks.relative,\n        domainContext: {\n            location: view.location,\n        },\n    };\n}\nfunction discardNegativeDuration(duration) {\n    return isNumber(duration) && duration < 0 ? undefined : duration;\n}\n//# sourceMappingURL=viewCollection.js.map","import * as utils from '../../tools/utils';\nimport { monitor } from '../internalMonitoring';\nimport { ContextHistory } from '../../tools/contextHistory';\nimport { relativeNow, clocksOrigin } from '../../tools/timeUtils';\nimport { tryOldCookiesMigration } from './oldCookiesMigration';\nimport { startSessionStore, SESSION_TIME_OUT_DELAY } from './sessionStore';\nexport var VISIBILITY_CHECK_DELAY = utils.ONE_MINUTE;\nvar SESSION_CONTEXT_TIMEOUT_DELAY = SESSION_TIME_OUT_DELAY;\nvar stopCallbacks = [];\nexport function startSessionManager(options, productKey, computeSessionState) {\n    tryOldCookiesMigration(options);\n    var sessionStore = startSessionStore(options, productKey, computeSessionState);\n    stopCallbacks.push(function () { return sessionStore.stop(); });\n    var sessionContextHistory = new ContextHistory(SESSION_CONTEXT_TIMEOUT_DELAY);\n    stopCallbacks.push(function () { return sessionContextHistory.stop(); });\n    sessionStore.renewObservable.subscribe(function () {\n        sessionContextHistory.add(buildSessionContext(), relativeNow());\n    });\n    sessionStore.expireObservable.subscribe(function () {\n        sessionContextHistory.closeActive(relativeNow());\n    });\n    sessionStore.expandOrRenewSession();\n    sessionContextHistory.add(buildSessionContext(), clocksOrigin().relative);\n    trackActivity(function () { return sessionStore.expandOrRenewSession(); });\n    trackVisibility(function () { return sessionStore.expandSession(); });\n    function buildSessionContext() {\n        return {\n            id: sessionStore.getSession().id,\n            trackingType: sessionStore.getSession()[productKey],\n        };\n    }\n    return {\n        findActiveSession: function (startTime) { return sessionContextHistory.find(startTime); },\n        renewObservable: sessionStore.renewObservable,\n        expireObservable: sessionStore.expireObservable,\n    };\n}\nexport function stopSessionManager() {\n    stopCallbacks.forEach(function (e) { return e(); });\n    stopCallbacks = [];\n}\nfunction trackActivity(expandOrRenewSession) {\n    var stop = utils.addEventListeners(window, [\"click\" /* CLICK */, \"touchstart\" /* TOUCH_START */, \"keydown\" /* KEY_DOWN */, \"scroll\" /* SCROLL */], expandOrRenewSession, { capture: true, passive: true }).stop;\n    stopCallbacks.push(stop);\n}\nfunction trackVisibility(expandSession) {\n    var expandSessionWhenVisible = monitor(function () {\n        if (document.visibilityState === 'visible') {\n            expandSession();\n        }\n    });\n    var stop = utils.addEventListener(document, \"visibilitychange\" /* VISIBILITY_CHANGE */, expandSessionWhenVisible).stop;\n    stopCallbacks.push(stop);\n    var visibilityCheckInterval = setInterval(expandSessionWhenVisible, VISIBILITY_CHECK_DELAY);\n    stopCallbacks.push(function () {\n        clearInterval(visibilityCheckInterval);\n    });\n}\n//# sourceMappingURL=sessionManager.js.map","import { getCookie } from '../../browser/cookie';\nimport { SESSION_COOKIE_NAME, persistSession } from './sessionCookieStore';\nexport var OLD_SESSION_COOKIE_NAME = '_dd';\nexport var OLD_RUM_COOKIE_NAME = '_dd_r';\nexport var OLD_LOGS_COOKIE_NAME = '_dd_l';\n// duplicate values to avoid dependency issues\nexport var RUM_SESSION_KEY = 'rum';\nexport var LOGS_SESSION_KEY = 'logs';\n/**\n * This migration should remain in the codebase as long as older versions are available/live\n * to allow older sdk versions to be upgraded to newer versions without compatibility issues.\n */\nexport function tryOldCookiesMigration(options) {\n    var sessionString = getCookie(SESSION_COOKIE_NAME);\n    var oldSessionId = getCookie(OLD_SESSION_COOKIE_NAME);\n    var oldRumType = getCookie(OLD_RUM_COOKIE_NAME);\n    var oldLogsType = getCookie(OLD_LOGS_COOKIE_NAME);\n    if (!sessionString) {\n        var session = {};\n        if (oldSessionId) {\n            session.id = oldSessionId;\n        }\n        if (oldLogsType && /^[01]$/.test(oldLogsType)) {\n            session[LOGS_SESSION_KEY] = oldLogsType;\n        }\n        if (oldRumType && /^[012]$/.test(oldRumType)) {\n            session[RUM_SESSION_KEY] = oldRumType;\n        }\n        persistSession(session, options);\n    }\n}\n//# sourceMappingURL=oldCookiesMigration.js.map","import { performDraw, startSessionManager } from '@datadog/browser-core';\nexport var RUM_SESSION_KEY = 'rum';\nexport function startRumSessionManager(configuration, lifeCycle) {\n    var sessionManager = startSessionManager(configuration.cookieOptions, RUM_SESSION_KEY, function (rawTrackingType) {\n        return computeSessionState(configuration, rawTrackingType);\n    });\n    sessionManager.expireObservable.subscribe(function () {\n        lifeCycle.notify(7 /* SESSION_EXPIRED */);\n    });\n    sessionManager.renewObservable.subscribe(function () {\n        lifeCycle.notify(8 /* SESSION_RENEWED */);\n    });\n    return {\n        findTrackedSession: function (startTime) {\n            var session = sessionManager.findActiveSession(startTime);\n            if (!session || !isTypeTracked(session.trackingType)) {\n                return;\n            }\n            return {\n                id: session.id,\n                hasReplayPlan: session.trackingType === \"1\" /* TRACKED_REPLAY */,\n                hasLitePlan: session.trackingType === \"2\" /* TRACKED_LITE */,\n            };\n        },\n    };\n}\n/**\n * Start a tracked replay session stub\n * It needs to be a replay plan in order to get long tasks\n */\nexport function startRumSessionManagerStub() {\n    var session = {\n        id: '00000000-aaaa-0000-aaaa-000000000000',\n        hasReplayPlan: true,\n        hasLitePlan: false,\n    };\n    return {\n        findTrackedSession: function () { return session; },\n    };\n}\nfunction computeSessionState(configuration, rawTrackingType) {\n    var trackingType;\n    if (hasValidRumSession(rawTrackingType)) {\n        trackingType = rawTrackingType;\n    }\n    else if (!performDraw(configuration.sampleRate)) {\n        trackingType = \"0\" /* NOT_TRACKED */;\n    }\n    else if (!performDraw(configuration.replaySampleRate)) {\n        trackingType = \"2\" /* TRACKED_LITE */;\n    }\n    else {\n        trackingType = \"1\" /* TRACKED_REPLAY */;\n    }\n    return {\n        trackingType: trackingType,\n        isTracked: isTypeTracked(trackingType),\n    };\n}\nfunction hasValidRumSession(trackingType) {\n    return (trackingType === \"0\" /* NOT_TRACKED */ ||\n        trackingType === \"1\" /* TRACKED_REPLAY */ ||\n        trackingType === \"2\" /* TRACKED_LITE */);\n}\nfunction isTypeTracked(rumSessionType) {\n    return rumSessionType === \"2\" /* TRACKED_LITE */ || rumSessionType === \"1\" /* TRACKED_REPLAY */;\n}\n//# sourceMappingURL=rumSessionManager.js.map","export { IncrementalSource } from './domain/record';\nexport var RecordType = {\n    FullSnapshot: 2,\n    IncrementalSnapshot: 3,\n    Meta: 4,\n    Focus: 6,\n    ViewEnd: 7,\n    VisualViewport: 8,\n};\n//# sourceMappingURL=types.js.map","import { DefaultPrivacyLevel } from '@datadog/browser-core';\nexport var NodePrivacyLevel = {\n    IGNORE: 'ignore',\n    HIDDEN: 'hidden',\n    ALLOW: DefaultPrivacyLevel.ALLOW,\n    MASK: DefaultPrivacyLevel.MASK,\n    MASK_USER_INPUT: DefaultPrivacyLevel.MASK_USER_INPUT,\n};\nexport var PRIVACY_ATTR_NAME = 'data-dd-privacy';\n// Privacy Attrs\nexport var PRIVACY_ATTR_VALUE_ALLOW = 'allow';\nexport var PRIVACY_ATTR_VALUE_MASK = 'mask';\nexport var PRIVACY_ATTR_VALUE_MASK_USER_INPUT = 'mask-user-input';\nexport var PRIVACY_ATTR_VALUE_HIDDEN = 'hidden';\n// Privacy Classes - not all customers can set plain HTML attributes, so support classes too\nexport var PRIVACY_CLASS_ALLOW = 'dd-privacy-allow';\nexport var PRIVACY_CLASS_MASK = 'dd-privacy-mask';\nexport var PRIVACY_CLASS_MASK_USER_INPUT = 'dd-privacy-mask-user-input';\nexport var PRIVACY_CLASS_HIDDEN = 'dd-privacy-hidden';\n// Private Replacement Templates\nexport var CENSORED_STRING_MARK = '***';\nexport var CENSORED_IMG_MARK = 'data:image/gif;base64,R0lGODlhAQABAIAAAMLCwgAAACH5BAAAAAAALAAAAAABAAEAAAICRAEAOw==';\nexport var FORM_PRIVATE_TAG_NAMES = {\n    INPUT: true,\n    OUTPUT: true,\n    TEXTAREA: true,\n    SELECT: true,\n    OPTION: true,\n    DATALIST: true,\n    OPTGROUP: true,\n};\n//# sourceMappingURL=constants.js.map","import { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_ALLOW, PRIVACY_ATTR_VALUE_MASK, PRIVACY_ATTR_VALUE_MASK_USER_INPUT, PRIVACY_ATTR_VALUE_HIDDEN, PRIVACY_CLASS_ALLOW, PRIVACY_CLASS_MASK, PRIVACY_CLASS_MASK_USER_INPUT, PRIVACY_CLASS_HIDDEN, FORM_PRIVATE_TAG_NAMES, CENSORED_STRING_MARK, } from '../../constants';\nexport var MAX_ATTRIBUTE_VALUE_CHAR_LENGTH = 100000;\nimport { shouldIgnoreElement } from './serialize';\nvar TEXT_MASKING_CHAR = 'x';\n/**\n * Get node privacy level by iterating over its ancestors. When the direct parent privacy level is\n * know, it is best to use something like:\n *\n * derivePrivacyLevelGivenParent(getNodeSelfPrivacyLevel(node), parentNodePrivacyLevel)\n */\nexport function getNodePrivacyLevel(node, defaultPrivacyLevel) {\n    var parentNodePrivacyLevel = node.parentNode\n        ? getNodePrivacyLevel(node.parentNode, defaultPrivacyLevel)\n        : defaultPrivacyLevel;\n    var selfNodePrivacyLevel = getNodeSelfPrivacyLevel(node);\n    return reducePrivacyLevel(selfNodePrivacyLevel, parentNodePrivacyLevel);\n}\n/**\n * Reduces the next privacy level based on self + parent privacy levels\n */\nexport function reducePrivacyLevel(childPrivacyLevel, parentNodePrivacyLevel) {\n    switch (parentNodePrivacyLevel) {\n        // These values cannot be overridden\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return parentNodePrivacyLevel;\n    }\n    switch (childPrivacyLevel) {\n        case NodePrivacyLevel.ALLOW:\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.MASK_USER_INPUT:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return childPrivacyLevel;\n        default:\n            return parentNodePrivacyLevel;\n    }\n}\n/**\n * Determines the node's own privacy level without checking for ancestors.\n */\nexport function getNodeSelfPrivacyLevel(node) {\n    // Only Element types can have a privacy level set\n    if (!isElement(node)) {\n        return;\n    }\n    var privAttr = node.getAttribute(PRIVACY_ATTR_NAME);\n    // Overrules for replay purpose\n    if (node.tagName === 'BASE') {\n        return NodePrivacyLevel.ALLOW;\n    }\n    // Overrules to enforce end-user protection\n    if (node.tagName === 'INPUT') {\n        var inputElement = node;\n        if (inputElement.type === 'password' || inputElement.type === 'email' || inputElement.type === 'tel') {\n            return NodePrivacyLevel.MASK;\n        }\n        if (inputElement.type === 'hidden') {\n            return NodePrivacyLevel.MASK;\n        }\n        var autocomplete = inputElement.getAttribute('autocomplete');\n        // Handle input[autocomplete=cc-number/cc-csc/cc-exp/cc-exp-month/cc-exp-year]\n        if (autocomplete && autocomplete.indexOf('cc-') === 0) {\n            return NodePrivacyLevel.MASK;\n        }\n    }\n    // Check HTML privacy attributes and classes\n    if (privAttr === PRIVACY_ATTR_VALUE_HIDDEN || node.classList.contains(PRIVACY_CLASS_HIDDEN)) {\n        return NodePrivacyLevel.HIDDEN;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK || node.classList.contains(PRIVACY_CLASS_MASK)) {\n        return NodePrivacyLevel.MASK;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_MASK_USER_INPUT || node.classList.contains(PRIVACY_CLASS_MASK_USER_INPUT)) {\n        return NodePrivacyLevel.MASK_USER_INPUT;\n    }\n    if (privAttr === PRIVACY_ATTR_VALUE_ALLOW || node.classList.contains(PRIVACY_CLASS_ALLOW)) {\n        return NodePrivacyLevel.ALLOW;\n    }\n    if (shouldIgnoreElement(node)) {\n        return NodePrivacyLevel.IGNORE;\n    }\n}\n/**\n * Helper aiming to unify `mask` and `mask-user-input` privacy levels:\n *\n * In the `mask` case, it is trivial: we should mask the element.\n *\n * In the `mask-user-input` case, we should mask the element only if it is a \"form\" element or the\n * direct parent is a form element for text nodes).\n *\n * Other `shouldMaskNode` cases are edge cases that should not matter too much (ex: should we mask a\n * node if it is ignored or hidden? it doesn't matter since it won't be serialized).\n */\nexport function shouldMaskNode(node, privacyLevel) {\n    switch (privacyLevel) {\n        case NodePrivacyLevel.MASK:\n        case NodePrivacyLevel.HIDDEN:\n        case NodePrivacyLevel.IGNORE:\n            return true;\n        case NodePrivacyLevel.MASK_USER_INPUT:\n            return isTextNode(node) ? isFormElement(node.parentNode) : isFormElement(node);\n        default:\n            return false;\n    }\n}\nfunction isElement(node) {\n    return node.nodeType === node.ELEMENT_NODE;\n}\nfunction isTextNode(node) {\n    return node.nodeType === node.TEXT_NODE;\n}\nfunction isFormElement(node) {\n    if (!node || node.nodeType !== node.ELEMENT_NODE) {\n        return false;\n    }\n    var element = node;\n    if (element.tagName === 'INPUT') {\n        switch (element.type) {\n            case 'button':\n            case 'color':\n            case 'reset':\n            case 'submit':\n                return false;\n        }\n    }\n    return !!FORM_PRIVATE_TAG_NAMES[element.tagName];\n}\n/**\n * Text censoring non-destructively maintains whitespace characters in order to preserve text shape\n * during replay.\n */\nexport var censorText = function (text) { return text.replace(/\\S/g, TEXT_MASKING_CHAR); };\nexport function getTextContent(textNode, ignoreWhiteSpace, parentNodePrivacyLevel) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = textNode.textContent || '';\n    if (ignoreWhiteSpace && !textContent.trim()) {\n        return;\n    }\n    var nodePrivacyLevel = parentNodePrivacyLevel;\n    var isStyle = parentTagName === 'STYLE' ? true : undefined;\n    var isScript = parentTagName === 'SCRIPT';\n    if (isScript) {\n        // For perf reasons, we don't record script (heuristic)\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // Should never occur, but just in case, we set to CENSORED_MARK.\n        textContent = CENSORED_STRING_MARK;\n    }\n    else if (shouldMaskNode(textNode, nodePrivacyLevel) &&\n        // Style tags are `overruled` (Use `hide` to enforce privacy)\n        !isStyle) {\n        if (\n        // Scrambling the child list breaks text nodes for DATALIST/SELECT/OPTGROUP\n        parentTagName === 'DATALIST' ||\n            parentTagName === 'SELECT' ||\n            parentTagName === 'OPTGROUP') {\n            if (!textContent.trim()) {\n                return;\n            }\n        }\n        else if (parentTagName === 'OPTION') {\n            // <Option> has low entropy in charset + text length, so use `CENSORED_STRING_MARK` when masked\n            textContent = CENSORED_STRING_MARK;\n        }\n        else {\n            textContent = censorText(textContent);\n        }\n    }\n    return textContent;\n}\n//# sourceMappingURL=privacy.js.map","import { assign } from '@datadog/browser-core';\nimport { NodePrivacyLevel, PRIVACY_ATTR_NAME, PRIVACY_ATTR_VALUE_HIDDEN, CENSORED_STRING_MARK, CENSORED_IMG_MARK, } from '../../constants';\nimport { getTextContent, shouldMaskNode, reducePrivacyLevel, getNodeSelfPrivacyLevel, MAX_ATTRIBUTE_VALUE_CHAR_LENGTH, } from './privacy';\nimport { getSerializedNodeId, setSerializedNodeId, getElementInputValue } from './serializationUtils';\nimport { forEach } from './utils';\nexport function serializeDocument(document, defaultPrivacyLevel) {\n    // We are sure that Documents are never ignored, so this function never returns null\n    return serializeNodeWithId(document, {\n        document: document,\n        parentNodePrivacyLevel: defaultPrivacyLevel,\n    });\n}\nexport function serializeNodeWithId(node, options) {\n    var serializedNode = serializeNode(node, options);\n    if (!serializedNode) {\n        return null;\n    }\n    // Try to reuse the previous id\n    var id = getSerializedNodeId(node) || generateNextId();\n    var serializedNodeWithId = serializedNode;\n    serializedNodeWithId.id = id;\n    setSerializedNodeId(node, id);\n    if (options.serializedNodeIds) {\n        options.serializedNodeIds.add(id);\n    }\n    return serializedNodeWithId;\n}\nfunction serializeNode(node, options) {\n    switch (node.nodeType) {\n        case node.DOCUMENT_NODE:\n            return serializeDocumentNode(node, options);\n        case node.DOCUMENT_TYPE_NODE:\n            return serializeDocumentTypeNode(node);\n        case node.ELEMENT_NODE:\n            return serializeElementNode(node, options);\n        case node.TEXT_NODE:\n            return serializeTextNode(node, options);\n        case node.CDATA_SECTION_NODE:\n            return serializeCDataNode();\n    }\n}\nexport function serializeDocumentNode(document, options) {\n    return {\n        type: 0 /* Document */,\n        childNodes: serializeChildNodes(document, options),\n    };\n}\nfunction serializeDocumentTypeNode(documentType) {\n    return {\n        type: 1 /* DocumentType */,\n        name: documentType.name,\n        publicId: documentType.publicId,\n        systemId: documentType.systemId,\n    };\n}\n/**\n * Serialzing Element nodes involves capturing:\n * 1. HTML ATTRIBUTES:\n * 2. JS STATE:\n * - scroll offsets\n * - Form fields (input value, checkbox checked, otpion selection, range)\n * - Canvas state,\n * - Media (video/audio) play mode + currentTime\n * - iframe contents\n * - webcomponents\n * 3. CUSTOM PROPERTIES:\n * - height+width for when `hidden` to cover the element\n * 4. EXCLUDED INTERACTION STATE:\n * - focus (possible, but not worth perf impact)\n * - hover (tracked only via mouse activity)\n * - fullscreen mode\n */\nexport function serializeElementNode(element, options) {\n    var _a;\n    var tagName = getValidTagName(element.tagName);\n    var isSVG = isSVGElement(element) || undefined;\n    // For performance reason, we don't use getNodePrivacyLevel directly: we leverage the\n    // parentNodePrivacyLevel option to avoid iterating over all parents\n    var nodePrivacyLevel = reducePrivacyLevel(getNodeSelfPrivacyLevel(element), options.parentNodePrivacyLevel);\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        var _b = element.getBoundingClientRect(), width = _b.width, height = _b.height;\n        return {\n            type: 2 /* Element */,\n            tagName: tagName,\n            attributes: (_a = {\n                    rr_width: \"\".concat(width, \"px\"),\n                    rr_height: \"\".concat(height, \"px\")\n                },\n                _a[PRIVACY_ATTR_NAME] = PRIVACY_ATTR_VALUE_HIDDEN,\n                _a),\n            childNodes: [],\n            isSVG: isSVG,\n        };\n    }\n    // Ignore Elements like Script and some Link, Metas\n    if (nodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n        return;\n    }\n    var attributes = getAttributesForPrivacyLevel(element, nodePrivacyLevel);\n    var childNodes = [];\n    if (element.childNodes.length) {\n        // OBJECT POOLING OPTIMIZATION:\n        // We should not create a new object systematically as it could impact performances. Try to reuse\n        // the same object as much as possible, and clone it only if we need to.\n        var childNodesSerializationOptions = void 0;\n        if (options.parentNodePrivacyLevel === nodePrivacyLevel && options.ignoreWhiteSpace === (tagName === 'head')) {\n            childNodesSerializationOptions = options;\n        }\n        else {\n            childNodesSerializationOptions = assign({}, options, {\n                parentNodePrivacyLevel: nodePrivacyLevel,\n                ignoreWhiteSpace: tagName === 'head',\n            });\n        }\n        childNodes = serializeChildNodes(element, childNodesSerializationOptions);\n    }\n    return {\n        type: 2 /* Element */,\n        tagName: tagName,\n        attributes: attributes,\n        childNodes: childNodes,\n        isSVG: isSVG,\n    };\n}\n/**\n * TODO: Preserve CSS element order, and record the presence of the tag, just don't render\n * We don't need this logic on the recorder side.\n * For security related meta's, customer can mask themmanually given they\n * are easy to identify in the HEAD tag.\n */\nexport function shouldIgnoreElement(element) {\n    if (element.nodeName === 'SCRIPT') {\n        return true;\n    }\n    if (element.nodeName === 'LINK') {\n        var relAttribute = getLowerCaseAttribute('rel');\n        return (\n        // Scripts\n        (relAttribute === 'preload' && getLowerCaseAttribute('as') === 'script') ||\n            // Favicons\n            relAttribute === 'shortcut icon' ||\n            relAttribute === 'icon');\n    }\n    if (element.nodeName === 'META') {\n        var nameAttribute = getLowerCaseAttribute('name');\n        var relAttribute = getLowerCaseAttribute('rel');\n        var propertyAttribute = getLowerCaseAttribute('property');\n        return (\n        // Favicons\n        /^msapplication-tile(image|color)$/.test(nameAttribute) ||\n            nameAttribute === 'application-name' ||\n            relAttribute === 'icon' ||\n            relAttribute === 'apple-touch-icon' ||\n            relAttribute === 'shortcut icon' ||\n            // Description\n            nameAttribute === 'keywords' ||\n            nameAttribute === 'description' ||\n            // Social\n            /^(og|twitter|fb):/.test(propertyAttribute) ||\n            /^(og|twitter):/.test(nameAttribute) ||\n            nameAttribute === 'pinterest' ||\n            // Robots\n            nameAttribute === 'robots' ||\n            nameAttribute === 'googlebot' ||\n            nameAttribute === 'bingbot' ||\n            // Http headers. Ex: X-UA-Compatible, Content-Type, Content-Language, cache-control,\n            // X-Translated-By\n            element.hasAttribute('http-equiv') ||\n            // Authorship\n            nameAttribute === 'author' ||\n            nameAttribute === 'generator' ||\n            nameAttribute === 'framework' ||\n            nameAttribute === 'publisher' ||\n            nameAttribute === 'progid' ||\n            /^article:/.test(propertyAttribute) ||\n            /^product:/.test(propertyAttribute) ||\n            // Verification\n            nameAttribute === 'google-site-verification' ||\n            nameAttribute === 'yandex-verification' ||\n            nameAttribute === 'csrf-token' ||\n            nameAttribute === 'p:domain_verify' ||\n            nameAttribute === 'verify-v1' ||\n            nameAttribute === 'verification' ||\n            nameAttribute === 'shopify-checkout-api-token');\n    }\n    function getLowerCaseAttribute(name) {\n        return (element.getAttribute(name) || '').toLowerCase();\n    }\n    return false;\n}\n/**\n * Text Nodes are dependant on Element nodes\n * Privacy levels are set on elements so we check the parentElement of a text node\n * for privacy level.\n */\nfunction serializeTextNode(textNode, options) {\n    var _a;\n    // The parent node may not be a html element which has a tagName attribute.\n    // So just let it be undefined which is ok in this use case.\n    var parentTagName = (_a = textNode.parentElement) === null || _a === void 0 ? void 0 : _a.tagName;\n    var textContent = getTextContent(textNode, options.ignoreWhiteSpace || false, options.parentNodePrivacyLevel);\n    if (!textContent) {\n        return;\n    }\n    return {\n        type: 3 /* Text */,\n        textContent: textContent,\n        isStyle: parentTagName === 'STYLE' ? true : undefined,\n    };\n}\nfunction serializeCDataNode() {\n    return {\n        type: 4 /* CDATA */,\n        textContent: '',\n    };\n}\nexport function serializeChildNodes(node, options) {\n    var result = [];\n    forEach(node.childNodes, function (childNode) {\n        var serializedChildNode = serializeNodeWithId(childNode, options);\n        if (serializedChildNode) {\n            result.push(serializedChildNode);\n        }\n    });\n    return result;\n}\nexport function serializeAttribute(element, nodePrivacyLevel, attributeName) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        // dup condition for direct access case\n        return null;\n    }\n    var attributeValue = element.getAttribute(attributeName);\n    if (nodePrivacyLevel === NodePrivacyLevel.MASK) {\n        var tagName = element.tagName;\n        switch (attributeName) {\n            // Mask Attribute text content\n            case 'title':\n            case 'alt':\n                return CENSORED_STRING_MARK;\n        }\n        // mask image URLs\n        if (tagName === 'IMG' || tagName === 'SOURCE') {\n            if (attributeName === 'src' || attributeName === 'srcset') {\n                return CENSORED_IMG_MARK;\n            }\n        }\n        // mask <a> URLs\n        if (tagName === 'A' && attributeName === 'href') {\n            return CENSORED_STRING_MARK;\n        }\n        // mask data-* attributes\n        if (attributeValue && attributeName.indexOf('data-') === 0 && attributeName !== PRIVACY_ATTR_NAME) {\n            // Exception: it's safe to reveal the `${PRIVACY_ATTR_NAME}` attr\n            return CENSORED_STRING_MARK;\n        }\n    }\n    if (!attributeValue || typeof attributeValue !== 'string') {\n        return attributeValue;\n    }\n    // Minimum Fix for customer.\n    if (attributeValue.length > MAX_ATTRIBUTE_VALUE_CHAR_LENGTH && attributeValue.slice(0, 5) === 'data:') {\n        return 'data:truncated';\n    }\n    return attributeValue;\n}\nvar _nextId = 1;\nfunction generateNextId() {\n    return _nextId++;\n}\nvar TAG_NAME_REGEX = /[^a-z1-6-_]/;\nfunction getValidTagName(tagName) {\n    var processedTagName = tagName.toLowerCase().trim();\n    if (TAG_NAME_REGEX.test(processedTagName)) {\n        // if the tag name is odd and we cannot extract\n        // anything from the string, then we return a\n        // generic div\n        return 'div';\n    }\n    return processedTagName;\n}\nfunction getCssRulesString(s) {\n    try {\n        var rules = s.rules || s.cssRules;\n        return rules ? Array.from(rules).map(getCssRuleString).join('') : null;\n    }\n    catch (error) {\n        return null;\n    }\n}\nfunction getCssRuleString(rule) {\n    return isCSSImportRule(rule) ? getCssRulesString(rule.styleSheet) || '' : rule.cssText;\n}\nfunction isCSSImportRule(rule) {\n    return 'styleSheet' in rule;\n}\nfunction isSVGElement(el) {\n    return el.tagName === 'svg' || el instanceof SVGElement;\n}\nfunction getAttributesForPrivacyLevel(element, nodePrivacyLevel) {\n    if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n        return {};\n    }\n    var safeAttrs = {};\n    var tagName = getValidTagName(element.tagName);\n    var doc = element.ownerDocument;\n    for (var i = 0; i < element.attributes.length; i += 1) {\n        var attribute = element.attributes.item(i);\n        var attributeName = attribute.name;\n        var attributeValue = serializeAttribute(element, nodePrivacyLevel, attributeName);\n        if (attributeValue !== null) {\n            safeAttrs[attributeName] = attributeValue;\n        }\n    }\n    if (element.value &&\n        (tagName === 'textarea' || tagName === 'select' || tagName === 'option' || tagName === 'input')) {\n        var formValue = getElementInputValue(element, nodePrivacyLevel);\n        if (formValue !== undefined) {\n            safeAttrs.value = formValue;\n        }\n    }\n    /**\n     * <Option> can be selected, which occurs if its `value` matches ancestor `<Select>.value`\n     */\n    if (tagName === 'option' && nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n        // For privacy=`MASK`, all the values would be the same, so skip.\n        var optionElement = element;\n        if (optionElement.selected) {\n            safeAttrs.selected = optionElement.selected;\n        }\n    }\n    // remote css\n    if (tagName === 'link') {\n        var stylesheet = Array.from(doc.styleSheets).find(function (s) { return s.href === element.href; });\n        var cssText = getCssRulesString(stylesheet);\n        if (cssText && stylesheet) {\n            delete safeAttrs.rel;\n            delete safeAttrs.href;\n            safeAttrs._cssText = cssText;\n        }\n    }\n    // dynamic stylesheet\n    if (tagName === 'style' &&\n        element.sheet &&\n        // TODO: Currently we only try to get dynamic stylesheet when it is an empty style element\n        !(element.innerText || element.textContent || '').trim().length) {\n        var cssText = getCssRulesString(element.sheet);\n        if (cssText) {\n            safeAttrs._cssText = cssText;\n        }\n    }\n    /**\n     * Forms: input[type=checkbox,radio]\n     * The `checked` property for <input> is a little bit special:\n     * 1. el.checked is a setter that returns if truthy.\n     * 2. getAttribute returns the string value\n     * getAttribute('checked') does not sync with `Element.checked`, so use JS property\n     * NOTE: `checked` property exists on `HTMLInputElement`. For serializer assumptions, we check for type=radio|check.\n     */\n    var inputElement = element;\n    if (tagName === 'input' && (inputElement.type === 'radio' || inputElement.type === 'checkbox')) {\n        if (nodePrivacyLevel === NodePrivacyLevel.ALLOW) {\n            safeAttrs.checked = !!inputElement.checked;\n        }\n        else if (shouldMaskNode(inputElement, nodePrivacyLevel)) {\n            safeAttrs.checked = CENSORED_STRING_MARK;\n        }\n    }\n    /**\n     * Serialize the media playback state\n     */\n    if (tagName === 'audio' || tagName === 'video') {\n        var mediaElement = element;\n        safeAttrs.rr_mediaState = mediaElement.paused ? 'paused' : 'played';\n    }\n    /**\n     * Serialize the scroll state for each element\n     */\n    if (element.scrollLeft) {\n        safeAttrs.rr_scrollLeft = Math.round(element.scrollLeft);\n    }\n    if (element.scrollTop) {\n        safeAttrs.rr_scrollTop = Math.round(element.scrollTop);\n    }\n    return safeAttrs;\n}\n//# sourceMappingURL=serialize.js.map","import { CENSORED_STRING_MARK } from '../../constants';\nimport { shouldMaskNode } from './privacy';\nvar serializedNodeIds = new WeakMap();\nexport function hasSerializedNode(node) {\n    return serializedNodeIds.has(node);\n}\nexport function nodeAndAncestorsHaveSerializedNode(node) {\n    var current = node;\n    while (current) {\n        if (!hasSerializedNode(current)) {\n            return false;\n        }\n        current = current.parentNode;\n    }\n    return true;\n}\nexport function getSerializedNodeId(node) {\n    return serializedNodeIds.get(node);\n}\nexport function setSerializedNodeId(node, serializeNodeId) {\n    serializedNodeIds.set(node, serializeNodeId);\n}\n/**\n * Get the element \"value\" to be serialized as an attribute or an input update record. It respects\n * the input privacy mode of the element.\n * PERFROMANCE OPTIMIZATION: Assumes that privacy level `HIDDEN` is never encountered because of earlier checks.\n */\nexport function getElementInputValue(element, nodePrivacyLevel) {\n    /*\n     BROWSER SPEC NOTE: <input>, <select>\n     For some <input> elements, the `value` is an exceptional property/attribute that has the\n     value synced between el.value and el.getAttribute()\n     input[type=button,checkbox,hidden,image,radio,reset,submit]\n     */\n    var tagName = element.tagName;\n    var value = element.value;\n    if (shouldMaskNode(element, nodePrivacyLevel)) {\n        var type = element.type;\n        if (tagName === 'INPUT' && (type === 'button' || type === 'submit' || type === 'reset')) {\n            // Overrule `MASK` privacy level for button-like element values, as they are used during replay\n            // to display their label. They can still be hidden via the \"hidden\" privacy attribute or class name.\n            return value;\n        }\n        else if (!value || tagName === 'OPTION') {\n            // <Option> value provides no benefit\n            return;\n        }\n        return CENSORED_STRING_MARK;\n    }\n    if (tagName === 'OPTION' || tagName === 'SELECT') {\n        return element.value;\n    }\n    if (tagName !== 'INPUT' && tagName !== 'TEXTAREA') {\n        return;\n    }\n    return value;\n}\n//# sourceMappingURL=serializationUtils.js.map","export function isTouchEvent(event) {\n    return Boolean(event.changedTouches);\n}\nexport function forEach(list, callback) {\n    Array.prototype.forEach.call(list, callback);\n}\n//# sourceMappingURL=utils.js.map","import { monitor, noop } from '@datadog/browser-core';\nimport { getMutationObserverConstructor } from '@datadog/browser-rum-core';\nimport { NodePrivacyLevel } from '../../constants';\nimport { getNodePrivacyLevel, getTextContent } from './privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode, nodeAndAncestorsHaveSerializedNode, } from './serializationUtils';\nimport { serializeNodeWithId, serializeAttribute } from './serialize';\nimport { forEach } from './utils';\nimport { createMutationBatch } from './mutationBatch';\n/**\n * Buffers and aggregate mutations generated by a MutationObserver into MutationPayload\n */\nexport function startMutationObserver(controller, mutationCallback, defaultPrivacyLevel) {\n    var MutationObserver = getMutationObserverConstructor();\n    if (!MutationObserver) {\n        return { stop: noop };\n    }\n    var mutationBatch = createMutationBatch(function (mutations) {\n        processMutations(mutations.concat(observer.takeRecords()), mutationCallback, defaultPrivacyLevel);\n    });\n    var observer = new MutationObserver(monitor(mutationBatch.addMutations));\n    observer.observe(document, {\n        attributeOldValue: true,\n        attributes: true,\n        characterData: true,\n        characterDataOldValue: true,\n        childList: true,\n        subtree: true,\n    });\n    controller.onFlush(mutationBatch.flush);\n    return {\n        stop: function () {\n            observer.disconnect();\n            mutationBatch.stop();\n        },\n    };\n}\n/**\n * Controls how mutations are processed, allowing to flush pending mutations.\n */\nvar MutationController = /** @class */ (function () {\n    function MutationController() {\n    }\n    MutationController.prototype.flush = function () {\n        var _a;\n        (_a = this.flushListener) === null || _a === void 0 ? void 0 : _a.call(this);\n    };\n    MutationController.prototype.onFlush = function (listener) {\n        this.flushListener = listener;\n    };\n    return MutationController;\n}());\nexport { MutationController };\nfunction processMutations(mutations, mutationCallback, defaultPrivacyLevel) {\n    // Discard any mutation with a 'target' node that:\n    // * isn't injected in the current document or isn't known/serialized yet: those nodes are likely\n    // part of a mutation occurring in a parent Node\n    // * should be hidden or ignored\n    var filteredMutations = mutations.filter(function (mutation) {\n        return document.contains(mutation.target) &&\n            nodeAndAncestorsHaveSerializedNode(mutation.target) &&\n            getNodePrivacyLevel(mutation.target, defaultPrivacyLevel) !== NodePrivacyLevel.HIDDEN;\n    });\n    var _a = processChildListMutations(filteredMutations.filter(function (mutation) { return mutation.type === 'childList'; }), defaultPrivacyLevel), adds = _a.adds, removes = _a.removes, hasBeenSerialized = _a.hasBeenSerialized;\n    var texts = processCharacterDataMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'characterData' && !hasBeenSerialized(mutation.target);\n    }), defaultPrivacyLevel);\n    var attributes = processAttributesMutations(filteredMutations.filter(function (mutation) {\n        return mutation.type === 'attributes' && !hasBeenSerialized(mutation.target);\n    }), defaultPrivacyLevel);\n    if (!texts.length && !attributes.length && !removes.length && !adds.length) {\n        return;\n    }\n    mutationCallback({\n        adds: adds,\n        removes: removes,\n        texts: texts,\n        attributes: attributes,\n    });\n}\nfunction processChildListMutations(mutations, defaultPrivacyLevel) {\n    // First, we iterate over mutations to collect:\n    //\n    // * nodes that have been added in the document and not removed by a subsequent mutation\n    // * nodes that have been removed from the document but were not added in a previous mutation\n    //\n    // For this second category, we also collect their previous parent (mutation.target) because we'll\n    // need it to emit a 'remove' mutation.\n    //\n    // Those two categories may overlap: if a node moved from a position to another, it is reported as\n    // two mutation records, one with a \"removedNodes\" and the other with \"addedNodes\". In this case,\n    // the node will be in both sets.\n    var addedAndMovedNodes = new Set();\n    var removedNodes = new Map();\n    var _loop_1 = function (mutation) {\n        forEach(mutation.addedNodes, function (node) {\n            addedAndMovedNodes.add(node);\n        });\n        forEach(mutation.removedNodes, function (node) {\n            if (!addedAndMovedNodes.has(node)) {\n                removedNodes.set(node, mutation.target);\n            }\n            addedAndMovedNodes.delete(node);\n        });\n    };\n    for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n        var mutation = mutations_1[_i];\n        _loop_1(mutation);\n    }\n    // Then, we sort nodes that are still in the document by topological order, for two reasons:\n    //\n    // * We will serialize each added nodes with their descendants. We don't want to serialize a node\n    // twice, so we need to iterate over the parent nodes first and skip any node that is contained in\n    // a precedent node.\n    //\n    // * To emit \"add\" mutations, we need references to the parent and potential next sibling of each\n    // added node. So we need to iterate over the parent nodes first, and when multiple nodes are\n    // siblings, we want to iterate from last to first. This will ensure that any \"next\" node is\n    // already serialized and have an id.\n    var sortedAddedAndMovedNodes = Array.from(addedAndMovedNodes);\n    sortAddedAndMovedNodes(sortedAddedAndMovedNodes);\n    // Then, we iterate over our sorted node sets to emit mutations. We collect the newly serialized\n    // node ids in a set to be able to skip subsequent related mutations.\n    var serializedNodeIds = new Set();\n    var addedNodeMutations = [];\n    for (var _a = 0, sortedAddedAndMovedNodes_1 = sortedAddedAndMovedNodes; _a < sortedAddedAndMovedNodes_1.length; _a++) {\n        var node = sortedAddedAndMovedNodes_1[_a];\n        if (hasBeenSerialized(node)) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(node.parentNode, defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        var serializedNode = serializeNodeWithId(node, {\n            document: document,\n            serializedNodeIds: serializedNodeIds,\n            parentNodePrivacyLevel: parentNodePrivacyLevel,\n        });\n        if (!serializedNode) {\n            continue;\n        }\n        addedNodeMutations.push({\n            nextId: getNextSibling(node),\n            parentId: getSerializedNodeId(node.parentNode),\n            node: serializedNode,\n        });\n    }\n    // Finally, we emit remove mutations.\n    var removedNodeMutations = [];\n    removedNodes.forEach(function (parent, node) {\n        if (hasSerializedNode(node)) {\n            removedNodeMutations.push({\n                parentId: getSerializedNodeId(parent),\n                id: getSerializedNodeId(node),\n            });\n        }\n    });\n    return { adds: addedNodeMutations, removes: removedNodeMutations, hasBeenSerialized: hasBeenSerialized };\n    function hasBeenSerialized(node) {\n        return hasSerializedNode(node) && serializedNodeIds.has(getSerializedNodeId(node));\n    }\n    function getNextSibling(node) {\n        var nextSibling = node.nextSibling;\n        while (nextSibling) {\n            if (hasSerializedNode(nextSibling)) {\n                return getSerializedNodeId(nextSibling);\n            }\n            nextSibling = nextSibling.nextSibling;\n        }\n        return null;\n    }\n}\nfunction processCharacterDataMutations(mutations, defaultPrivacyLevel) {\n    var _a;\n    var textMutations = [];\n    // Deduplicate mutations based on their target node\n    var handledNodes = new Set();\n    var filteredMutations = mutations.filter(function (mutation) {\n        if (handledNodes.has(mutation.target)) {\n            return false;\n        }\n        handledNodes.add(mutation.target);\n        return true;\n    });\n    // Emit mutations\n    for (var _i = 0, filteredMutations_1 = filteredMutations; _i < filteredMutations_1.length; _i++) {\n        var mutation = filteredMutations_1[_i];\n        var value = mutation.target.textContent;\n        if (value === mutation.oldValue) {\n            continue;\n        }\n        var parentNodePrivacyLevel = getNodePrivacyLevel(mutation.target.parentNode, defaultPrivacyLevel);\n        if (parentNodePrivacyLevel === NodePrivacyLevel.HIDDEN || parentNodePrivacyLevel === NodePrivacyLevel.IGNORE) {\n            continue;\n        }\n        textMutations.push({\n            id: getSerializedNodeId(mutation.target),\n            // TODO: pass a valid \"ignoreWhiteSpace\" argument\n            value: (_a = getTextContent(mutation.target, false, parentNodePrivacyLevel)) !== null && _a !== void 0 ? _a : null,\n        });\n    }\n    return textMutations;\n}\nfunction processAttributesMutations(mutations, defaultPrivacyLevel) {\n    var attributeMutations = [];\n    // Deduplicate mutations based on their target node and changed attribute\n    var handledElements = new Map();\n    var filteredMutations = mutations.filter(function (mutation) {\n        var handledAttributes = handledElements.get(mutation.target);\n        if (handledAttributes === null || handledAttributes === void 0 ? void 0 : handledAttributes.has(mutation.attributeName)) {\n            return false;\n        }\n        if (!handledAttributes) {\n            handledElements.set(mutation.target, new Set([mutation.attributeName]));\n        }\n        else {\n            handledAttributes.add(mutation.attributeName);\n        }\n        return true;\n    });\n    // Emit mutations\n    var emittedMutations = new Map();\n    for (var _i = 0, filteredMutations_2 = filteredMutations; _i < filteredMutations_2.length; _i++) {\n        var mutation = filteredMutations_2[_i];\n        var uncensoredValue = mutation.target.getAttribute(mutation.attributeName);\n        if (uncensoredValue === mutation.oldValue) {\n            continue;\n        }\n        var privacyLevel = getNodePrivacyLevel(mutation.target, defaultPrivacyLevel);\n        var attributeValue = serializeAttribute(mutation.target, privacyLevel, mutation.attributeName);\n        var transformedValue = void 0;\n        if (mutation.attributeName === 'value') {\n            var inputValue = getElementInputValue(mutation.target, privacyLevel);\n            if (inputValue === undefined) {\n                continue;\n            }\n            transformedValue = inputValue;\n        }\n        else if (typeof attributeValue === 'string') {\n            transformedValue = attributeValue;\n        }\n        else {\n            transformedValue = null;\n        }\n        var emittedMutation = emittedMutations.get(mutation.target);\n        if (!emittedMutation) {\n            emittedMutation = {\n                id: getSerializedNodeId(mutation.target),\n                attributes: {},\n            };\n            attributeMutations.push(emittedMutation);\n            emittedMutations.set(mutation.target, emittedMutation);\n        }\n        emittedMutation.attributes[mutation.attributeName] = transformedValue;\n    }\n    return attributeMutations;\n}\nexport function sortAddedAndMovedNodes(nodes) {\n    nodes.sort(function (a, b) {\n        var position = a.compareDocumentPosition(b);\n        /* eslint-disable no-bitwise */\n        if (position & Node.DOCUMENT_POSITION_CONTAINED_BY) {\n            return -1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_CONTAINS) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_FOLLOWING) {\n            return 1;\n        }\n        else if (position & Node.DOCUMENT_POSITION_PRECEDING) {\n            return -1;\n        }\n        /* eslint-enable no-bitwise */\n        return 0;\n    });\n}\n//# sourceMappingURL=mutationObserver.js.map","import { noop, requestIdleCallback } from '@datadog/browser-core';\n/**\n * Maximum duration to wait before processing mutations. If the browser is idle, mutations will be\n * processed more quickly. If the browser is busy executing small tasks (ex: rendering frames), the\n * mutations will wait MUTATION_PROCESS_MAX_DELAY milliseconds before being processed. If the\n * browser is busy executing a longer task, mutations will be processed after this task.\n */\nvar MUTATION_PROCESS_MAX_DELAY = 100;\nexport function createMutationBatch(processMutationBatch) {\n    var cancelScheduledFlush = noop;\n    var pendingMutations = [];\n    function flush() {\n        cancelScheduledFlush();\n        processMutationBatch(pendingMutations);\n        pendingMutations = [];\n    }\n    return {\n        addMutations: function (mutations) {\n            if (pendingMutations.length === 0) {\n                cancelScheduledFlush = requestIdleCallback(flush, { timeout: MUTATION_PROCESS_MAX_DELAY });\n            }\n            pendingMutations.push.apply(pendingMutations, mutations);\n        },\n        flush: flush,\n        stop: function () {\n            cancelScheduledFlush();\n        },\n    };\n}\n//# sourceMappingURL=mutationBatch.js.map","var _a;\nimport { instrumentSetter, instrumentMethodAndCallOriginal, assign, monitor, throttle, addEventListeners, addEventListener, noop, } from '@datadog/browser-core';\nimport { NodePrivacyLevel } from '../../constants';\nimport { getNodePrivacyLevel, shouldMaskNode } from './privacy';\nimport { getElementInputValue, getSerializedNodeId, hasSerializedNode } from './serializationUtils';\nimport { IncrementalSource, MediaInteractions, MouseInteractions } from './types';\nimport { forEach, isTouchEvent } from './utils';\nimport { startMutationObserver } from './mutationObserver';\nimport { getVisualViewport, getWindowHeight, getWindowWidth, getScrollX, getScrollY, convertMouseEventToLayoutCoordinates, } from './viewports';\nvar MOUSE_MOVE_OBSERVER_THRESHOLD = 50;\nvar SCROLL_OBSERVER_THRESHOLD = 100;\nvar VISUAL_VIEWPORT_OBSERVER_THRESHOLD = 200;\nexport function initObservers(o) {\n    var mutationHandler = initMutationObserver(o.mutationController, o.mutationCb, o.defaultPrivacyLevel);\n    var mousemoveHandler = initMoveObserver(o.mousemoveCb);\n    var mouseInteractionHandler = initMouseInteractionObserver(o.mouseInteractionCb, o.defaultPrivacyLevel);\n    var scrollHandler = initScrollObserver(o.scrollCb, o.defaultPrivacyLevel);\n    var viewportResizeHandler = initViewportResizeObserver(o.viewportResizeCb);\n    var inputHandler = initInputObserver(o.inputCb, o.defaultPrivacyLevel);\n    var mediaInteractionHandler = initMediaInteractionObserver(o.mediaInteractionCb, o.defaultPrivacyLevel);\n    var styleSheetObserver = initStyleSheetObserver(o.styleSheetRuleCb);\n    var focusHandler = initFocusObserver(o.focusCb);\n    var visualViewportResizeHandler = initVisualViewportResizeObserver(o.visualViewportResizeCb);\n    return function () {\n        mutationHandler();\n        mousemoveHandler();\n        mouseInteractionHandler();\n        scrollHandler();\n        viewportResizeHandler();\n        inputHandler();\n        mediaInteractionHandler();\n        styleSheetObserver();\n        focusHandler();\n        visualViewportResizeHandler();\n    };\n}\nfunction initMutationObserver(mutationController, cb, defaultPrivacyLevel) {\n    return startMutationObserver(mutationController, cb, defaultPrivacyLevel).stop;\n}\nfunction initMoveObserver(cb) {\n    var updatePosition = throttle(monitor(function (event) {\n        var target = event.target;\n        if (hasSerializedNode(target)) {\n            var _a = isTouchEvent(event) ? event.changedTouches[0] : event, clientX = _a.clientX, clientY = _a.clientY;\n            var position = {\n                id: getSerializedNodeId(target),\n                timeOffset: 0,\n                x: clientX,\n                y: clientY,\n            };\n            if (window.visualViewport) {\n                var _b = convertMouseEventToLayoutCoordinates(clientX, clientY), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n                position.x = visualViewportX;\n                position.y = visualViewportY;\n            }\n            cb([position], isTouchEvent(event) ? IncrementalSource.TouchMove : IncrementalSource.MouseMove);\n        }\n    }), MOUSE_MOVE_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }).throttled;\n    return addEventListeners(document, [\"mousemove\" /* MOUSE_MOVE */, \"touchmove\" /* TOUCH_MOVE */], updatePosition, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nvar eventTypeToMouseInteraction = (_a = {},\n    _a[\"mouseup\" /* MOUSE_UP */] = MouseInteractions.MouseUp,\n    _a[\"mousedown\" /* MOUSE_DOWN */] = MouseInteractions.MouseDown,\n    _a[\"click\" /* CLICK */] = MouseInteractions.Click,\n    _a[\"contextmenu\" /* CONTEXT_MENU */] = MouseInteractions.ContextMenu,\n    _a[\"dblclick\" /* DBL_CLICK */] = MouseInteractions.DblClick,\n    _a[\"focus\" /* FOCUS */] = MouseInteractions.Focus,\n    _a[\"blur\" /* BLUR */] = MouseInteractions.Blur,\n    _a[\"touchstart\" /* TOUCH_START */] = MouseInteractions.TouchStart,\n    _a[\"touchend\" /* TOUCH_END */] = MouseInteractions.TouchEnd,\n    _a);\nfunction initMouseInteractionObserver(cb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = event.target;\n        if (getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN || !hasSerializedNode(target)) {\n            return;\n        }\n        var _a = isTouchEvent(event) ? event.changedTouches[0] : event, clientX = _a.clientX, clientY = _a.clientY;\n        var position = {\n            id: getSerializedNodeId(target),\n            type: eventTypeToMouseInteraction[event.type],\n            x: clientX,\n            y: clientY,\n        };\n        if (window.visualViewport) {\n            var _b = convertMouseEventToLayoutCoordinates(clientX, clientY), visualViewportX = _b.visualViewportX, visualViewportY = _b.visualViewportY;\n            position.x = visualViewportX;\n            position.y = visualViewportY;\n        }\n        cb(position);\n    };\n    return addEventListeners(document, Object.keys(eventTypeToMouseInteraction), handler, {\n        capture: true,\n        passive: true,\n    }).stop;\n}\nfunction initScrollObserver(cb, defaultPrivacyLevel) {\n    var updatePosition = throttle(monitor(function (event) {\n        var target = event.target;\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        var id = getSerializedNodeId(target);\n        if (target === document) {\n            cb({\n                id: id,\n                x: getScrollX(),\n                y: getScrollY(),\n            });\n        }\n        else {\n            cb({\n                id: id,\n                x: target.scrollLeft,\n                y: target.scrollTop,\n            });\n        }\n    }), SCROLL_OBSERVER_THRESHOLD).throttled;\n    return addEventListener(document, \"scroll\" /* SCROLL */, updatePosition, { capture: true, passive: true }).stop;\n}\nfunction initViewportResizeObserver(cb) {\n    var updateDimension = throttle(monitor(function () {\n        var height = getWindowHeight();\n        var width = getWindowWidth();\n        cb({\n            height: Number(height),\n            width: Number(width),\n        });\n    }), 200).throttled;\n    return addEventListener(window, \"resize\" /* RESIZE */, updateDimension, { capture: true, passive: true }).stop;\n}\nexport function initInputObserver(cb, defaultPrivacyLevel) {\n    var lastInputStateMap = new WeakMap();\n    function onElementChange(target) {\n        var nodePrivacyLevel = getNodePrivacyLevel(target, defaultPrivacyLevel);\n        if (nodePrivacyLevel === NodePrivacyLevel.HIDDEN) {\n            return;\n        }\n        var type = target.type;\n        var inputState;\n        if (type === 'radio' || type === 'checkbox') {\n            if (shouldMaskNode(target, nodePrivacyLevel)) {\n                return;\n            }\n            inputState = { isChecked: target.checked };\n        }\n        else {\n            var value = getElementInputValue(target, nodePrivacyLevel);\n            if (value === undefined) {\n                return;\n            }\n            inputState = { text: value };\n        }\n        // Can be multiple changes on the same node within the same batched mutation observation.\n        cbWithDedup(target, inputState);\n        // If a radio was checked, other radios with the same name attribute will be unchecked.\n        var name = target.name;\n        if (type === 'radio' && name && target.checked) {\n            forEach(document.querySelectorAll(\"input[type=\\\"radio\\\"][name=\\\"\".concat(name, \"\\\"]\")), function (el) {\n                if (el !== target) {\n                    // TODO: Consider the privacy implications for various differing input privacy levels\n                    cbWithDedup(el, { isChecked: false });\n                }\n            });\n        }\n    }\n    /**\n     * There can be multiple changes on the same node within the same batched mutation observation.\n     */\n    function cbWithDedup(target, inputState) {\n        if (!hasSerializedNode(target)) {\n            return;\n        }\n        var lastInputState = lastInputStateMap.get(target);\n        if (!lastInputState ||\n            lastInputState.text !== inputState.text ||\n            lastInputState.isChecked !== inputState.isChecked) {\n            lastInputStateMap.set(target, inputState);\n            cb(assign({\n                id: getSerializedNodeId(target),\n            }, inputState));\n        }\n    }\n    var stopEventListeners = addEventListeners(document, [\"input\" /* INPUT */, \"change\" /* CHANGE */], function (event) {\n        if (event.target instanceof HTMLInputElement ||\n            event.target instanceof HTMLTextAreaElement ||\n            event.target instanceof HTMLSelectElement) {\n            onElementChange(event.target);\n        }\n    }, {\n        capture: true,\n        passive: true,\n    }).stop;\n    var instrumentationStoppers = [\n        instrumentSetter(HTMLInputElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLInputElement.prototype, 'checked', onElementChange),\n        instrumentSetter(HTMLSelectElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLTextAreaElement.prototype, 'value', onElementChange),\n        instrumentSetter(HTMLSelectElement.prototype, 'selectedIndex', onElementChange),\n    ];\n    return function () {\n        instrumentationStoppers.forEach(function (stopper) { return stopper.stop(); });\n        stopEventListeners();\n    };\n}\nfunction initStyleSheetObserver(cb) {\n    var restoreInsertRule = instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'insertRule', {\n        before: function (rule, index) {\n            if (hasSerializedNode(this.ownerNode)) {\n                cb({\n                    id: getSerializedNodeId(this.ownerNode),\n                    adds: [{ rule: rule, index: index }],\n                });\n            }\n        },\n    }).stop;\n    var restoreDeleteRule = instrumentMethodAndCallOriginal(CSSStyleSheet.prototype, 'deleteRule', {\n        before: function (index) {\n            if (hasSerializedNode(this.ownerNode)) {\n                cb({\n                    id: getSerializedNodeId(this.ownerNode),\n                    removes: [{ index: index }],\n                });\n            }\n        },\n    }).stop;\n    return function () {\n        restoreInsertRule();\n        restoreDeleteRule();\n    };\n}\nfunction initMediaInteractionObserver(mediaInteractionCb, defaultPrivacyLevel) {\n    var handler = function (event) {\n        var target = event.target;\n        if (!target ||\n            getNodePrivacyLevel(target, defaultPrivacyLevel) === NodePrivacyLevel.HIDDEN ||\n            !hasSerializedNode(target)) {\n            return;\n        }\n        mediaInteractionCb({\n            id: getSerializedNodeId(target),\n            type: event.type === \"play\" /* PLAY */ ? MediaInteractions.Play : MediaInteractions.Pause,\n        });\n    };\n    return addEventListeners(document, [\"play\" /* PLAY */, \"pause\" /* PAUSE */], handler, { capture: true, passive: true }).stop;\n}\nfunction initFocusObserver(focusCb) {\n    return addEventListeners(window, [\"focus\" /* FOCUS */, \"blur\" /* BLUR */], function () {\n        focusCb({ has_focus: document.hasFocus() });\n    }).stop;\n}\nfunction initVisualViewportResizeObserver(cb) {\n    if (!window.visualViewport) {\n        return noop;\n    }\n    var _a = throttle(monitor(function () {\n        cb(getVisualViewport());\n    }), VISUAL_VIEWPORT_OBSERVER_THRESHOLD, {\n        trailing: false,\n    }), updateDimension = _a.throttled, cancelThrottle = _a.cancel;\n    var removeListener = addEventListeners(window.visualViewport, [\"resize\" /* RESIZE */, \"scroll\" /* SCROLL */], updateDimension, {\n        capture: true,\n        passive: true,\n    }).stop;\n    return function stop() {\n        removeListener();\n        cancelThrottle();\n    };\n}\n//# sourceMappingURL=observer.js.map","/**\n * Browsers have not standardized various dimension properties. Mobile devices typically report\n * dimensions in reference to the visual viewport, while desktop uses the layout viewport. For example,\n * Mobile Chrome will change innerWidth when a pinch zoom takes place, while Chrome Desktop (mac) will not.\n *\n * With the new Viewport API, we now calculate and normalize dimension properties to the layout viewport.\n * If the VisualViewport API is not supported by a browser, it isn't reasonably possible to detect or normalize\n * which viewport is being measured. Therefore these exported functions will fallback to assuming that the layout\n * viewport is being measured by the browser\n */\n// Scrollbar widths vary across properties on different devices and browsers\nvar TOLERANCE = 25;\n/**\n * Use the Visual Viewport API's properties to measure scrollX/Y in reference to the layout viewport\n * in order to determine if window.scrollX/Y is measuring the layout or visual viewport.\n * This finding corresponds to which viewport mouseEvent.clientX/Y and window.innerWidth/Height measures.\n */\nfunction isVisualViewportFactoredIn() {\n    var visual = window.visualViewport;\n    return (Math.abs(visual.pageTop - visual.offsetTop - window.scrollY) > TOLERANCE ||\n        Math.abs(visual.pageLeft - visual.offsetLeft - window.scrollX) > TOLERANCE);\n}\nexport var convertMouseEventToLayoutCoordinates = function (clientX, clientY) {\n    var visual = window.visualViewport;\n    var normalised = {\n        layoutViewportX: clientX,\n        layoutViewportY: clientY,\n        visualViewportX: clientX,\n        visualViewportY: clientY,\n    };\n    if (!visual) {\n        // On old browsers, we cannot normalise, so fallback to clientX/Y\n        return normalised;\n    }\n    else if (isVisualViewportFactoredIn()) {\n        // Typically Mobile Devices\n        normalised.layoutViewportX = Math.round(clientX + visual.offsetLeft);\n        normalised.layoutViewportY = Math.round(clientY + visual.offsetTop);\n    }\n    else {\n        // Typically Desktop Devices\n        normalised.visualViewportX = Math.round(clientX - visual.offsetLeft);\n        normalised.visualViewportY = Math.round(clientY - visual.offsetTop);\n    }\n    return normalised;\n};\nexport var getVisualViewport = function () {\n    var visual = window.visualViewport;\n    return {\n        scale: visual.scale,\n        offsetLeft: visual.offsetLeft,\n        offsetTop: visual.offsetTop,\n        pageLeft: visual.pageLeft,\n        pageTop: visual.pageTop,\n        height: visual.height,\n        width: visual.width,\n    };\n};\n// excludes the width of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getWindowWidth() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return visual.width * visual.scale;\n    }\n    return window.innerWidth || 0;\n}\n// excludes the height of any rendered classic scrollbar that is fixed to the visual viewport\nexport function getWindowHeight() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return visual.height * visual.scale;\n    }\n    return window.innerHeight || 0;\n}\nexport function getScrollX() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return visual.pageLeft - visual.offsetLeft;\n    }\n    if (window.scrollX !== undefined) {\n        return window.scrollX;\n    }\n    return window.pageXOffset || 0;\n}\nexport function getScrollY() {\n    var visual = window.visualViewport;\n    if (visual) {\n        return visual.pageTop - visual.offsetTop;\n    }\n    if (window.scrollY !== undefined) {\n        return window.scrollY;\n    }\n    return window.pageYOffset || 0;\n}\n//# sourceMappingURL=viewports.js.map","export var IncrementalSource = {\n    Mutation: 0,\n    MouseMove: 1,\n    MouseInteraction: 2,\n    Scroll: 3,\n    ViewportResize: 4,\n    Input: 5,\n    TouchMove: 6,\n    MediaInteraction: 7,\n    StyleSheetRule: 8,\n    // CanvasMutation : 9,\n    // Font : 10,\n};\nexport var MouseInteractions = {\n    MouseUp: 0,\n    MouseDown: 1,\n    Click: 2,\n    ContextMenu: 3,\n    DblClick: 4,\n    Focus: 5,\n    Blur: 6,\n    TouchStart: 7,\n    TouchEnd: 9,\n};\nexport var MediaInteractions = {\n    Play: 0,\n    Pause: 1,\n};\n//# sourceMappingURL=types.js.map","export var MAX_STATS_HISTORY = 10;\nvar statsPerView;\nexport function getSegmentsCount(viewId) {\n    return getOrCreateReplayStats(viewId).segments_count;\n}\nexport function addSegment(viewId) {\n    getOrCreateReplayStats(viewId).segments_count += 1;\n}\nexport function addRecord(viewId) {\n    getOrCreateReplayStats(viewId).records_count += 1;\n}\nexport function addWroteData(viewId, additionalRawSize) {\n    getOrCreateReplayStats(viewId).segments_total_raw_size += additionalRawSize;\n}\nexport function getReplayStats(viewId) {\n    return statsPerView === null || statsPerView === void 0 ? void 0 : statsPerView.get(viewId);\n}\nexport function resetReplayStats() {\n    statsPerView = undefined;\n}\nfunction getOrCreateReplayStats(viewId) {\n    if (!statsPerView) {\n        statsPerView = new Map();\n    }\n    var replayStats;\n    if (statsPerView.has(viewId)) {\n        replayStats = statsPerView.get(viewId);\n    }\n    else {\n        replayStats = {\n            records_count: 0,\n            segments_count: 0,\n            segments_total_raw_size: 0,\n        };\n        statsPerView.set(viewId, replayStats);\n        if (statsPerView.size > MAX_STATS_HISTORY) {\n            deleteOldestStats();\n        }\n    }\n    return replayStats;\n}\nfunction deleteOldestStats() {\n    if (!statsPerView) {\n        return;\n    }\n    if (statsPerView.keys) {\n        statsPerView.delete(statsPerView.keys().next().value);\n    }\n    else {\n        // IE11 doesn't support map.keys\n        var isFirst_1 = true;\n        statsPerView.forEach(function (_value, key) {\n            if (isFirst_1) {\n                statsPerView.delete(key);\n                isFirst_1 = false;\n            }\n        });\n    }\n}\n//# sourceMappingURL=replayStats.js.map","import { assign, timeStampNow } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport { serializeDocument } from './serialize';\nimport { initObservers } from './observer';\nimport { IncrementalSource } from './types';\nimport { MutationController } from './mutationObserver';\nimport { getVisualViewport, getScrollX, getScrollY, getWindowHeight, getWindowWidth } from './viewports';\nexport function record(options) {\n    var emit = options.emit;\n    // runtime checks for user options\n    if (!emit) {\n        throw new Error('emit function is required');\n    }\n    var mutationController = new MutationController();\n    var takeFullSnapshot = function (timestamp) {\n        if (timestamp === void 0) { timestamp = timeStampNow(); }\n        mutationController.flush(); // process any pending mutation before taking a full snapshot\n        emit({\n            data: {\n                height: getWindowHeight(),\n                href: window.location.href,\n                width: getWindowWidth(),\n            },\n            type: RecordType.Meta,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                has_focus: document.hasFocus(),\n            },\n            type: RecordType.Focus,\n            timestamp: timestamp,\n        });\n        emit({\n            data: {\n                node: serializeDocument(document, options.defaultPrivacyLevel),\n                initialOffset: {\n                    left: getScrollX(),\n                    top: getScrollY(),\n                },\n            },\n            type: RecordType.FullSnapshot,\n            timestamp: timestamp,\n        });\n        if (window.visualViewport) {\n            emit({\n                data: getVisualViewport(),\n                type: RecordType.VisualViewport,\n                timestamp: timestamp,\n            });\n        }\n    };\n    takeFullSnapshot();\n    var stopObservers = initObservers({\n        mutationController: mutationController,\n        defaultPrivacyLevel: options.defaultPrivacyLevel,\n        inputCb: function (v) { return emit(assembleIncrementalSnapshot(IncrementalSource.Input, v)); },\n        mediaInteractionCb: function (p) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MediaInteraction, p));\n        },\n        mouseInteractionCb: function (d) {\n            return emit(assembleIncrementalSnapshot(IncrementalSource.MouseInteraction, d));\n        },\n        mousemoveCb: function (positions, source) { return emit(assembleIncrementalSnapshot(source, { positions: positions })); },\n        mutationCb: function (m) { return emit(assembleIncrementalSnapshot(IncrementalSource.Mutation, m)); },\n        scrollCb: function (p) { return emit(assembleIncrementalSnapshot(IncrementalSource.Scroll, p)); },\n        styleSheetRuleCb: function (r) { return emit(assembleIncrementalSnapshot(IncrementalSource.StyleSheetRule, r)); },\n        viewportResizeCb: function (d) { return emit(assembleIncrementalSnapshot(IncrementalSource.ViewportResize, d)); },\n        focusCb: function (data) {\n            return emit({\n                data: data,\n                type: RecordType.Focus,\n                timestamp: timeStampNow(),\n            });\n        },\n        visualViewportResizeCb: function (data) {\n            emit({\n                data: data,\n                type: RecordType.VisualViewport,\n                timestamp: timeStampNow(),\n            });\n        },\n    });\n    return {\n        stop: stopObservers,\n        takeFullSnapshot: takeFullSnapshot,\n        flushMutations: function () { return mutationController.flush(); },\n    };\n}\nfunction assembleIncrementalSnapshot(source, data) {\n    return {\n        data: assign({\n            source: source,\n        }, data),\n        type: RecordType.IncrementalSnapshot,\n        timestamp: timeStampNow(),\n    };\n}\n//# sourceMappingURL=record.js.map","import { HttpRequest, objectEntries } from '@datadog/browser-core';\nexport var SEND_BEACON_BYTE_LENGTH_LIMIT = 60000;\nexport function send(endpointBuilder, data, metadata, rawSegmentSize, flushReason) {\n    var formData = new FormData();\n    formData.append('segment', new Blob([data], {\n        type: 'application/octet-stream',\n    }), \"\".concat(metadata.session.id, \"-\").concat(metadata.start));\n    toFormEntries(metadata, function (key, value) { return formData.append(key, value); });\n    formData.append('raw_segment_size', rawSegmentSize.toString());\n    var request = new HttpRequest(endpointBuilder, SEND_BEACON_BYTE_LENGTH_LIMIT);\n    request.send(formData, data.byteLength, flushReason);\n}\nexport function toFormEntries(input, onEntry, prefix) {\n    if (prefix === void 0) { prefix = ''; }\n    objectEntries(input).forEach(function (_a) {\n        var key = _a[0], value = _a[1];\n        if (typeof value === 'object' && value !== null) {\n            toFormEntries(value, onEntry, \"\".concat(prefix).concat(key, \".\"));\n        }\n        else {\n            onEntry(\"\".concat(prefix).concat(key), String(value));\n        }\n    });\n}\n//# sourceMappingURL=send.js.map","import { addMonitoringMessage, assign, monitor } from '@datadog/browser-core';\nimport { RecordType } from '../../types';\nimport * as replayStats from '../replayStats';\nvar nextId = 0;\nvar Segment = /** @class */ (function () {\n    function Segment(worker, context, creationReason, initialRecord, onWrote, onFlushed) {\n        var _this = this;\n        this.worker = worker;\n        this.isFlushed = false;\n        this.id = nextId++;\n        var viewId = context.view.id;\n        this.metadata = assign({\n            start: initialRecord.timestamp,\n            end: initialRecord.timestamp,\n            creation_reason: creationReason,\n            records_count: 1,\n            has_full_snapshot: initialRecord.type === RecordType.FullSnapshot,\n            index_in_view: replayStats.getSegmentsCount(viewId),\n        }, context);\n        replayStats.addSegment(viewId);\n        replayStats.addRecord(viewId);\n        var listener = monitor(function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored' || data.type === 'initialized') {\n                return;\n            }\n            if (data.id === _this.id) {\n                replayStats.addWroteData(viewId, data.additionalRawSize);\n                if (data.type === 'flushed') {\n                    onFlushed(data.result, data.rawSize);\n                    worker.removeEventListener('message', listener);\n                }\n                else {\n                    onWrote(data.compressedSize);\n                }\n            }\n            else if (data.id > _this.id) {\n                // Messages should be received in the same order as they are sent, so if we receive a\n                // message with an id superior to this Segment instance id, we know that another, more\n                // recent Segment instance is being used.\n                //\n                // In theory, a \"flush\" response should have been received at this point, so the listener\n                // should already have been removed. But if something goes wrong and we didn't receive a\n                // \"flush\" response, remove the listener to avoid any leak, and send a monitor message to\n                // help investigate the issue.\n                worker.removeEventListener('message', listener);\n                addMonitoringMessage(\"Segment did not receive a 'flush' response before being replaced.\");\n            }\n        });\n        worker.addEventListener('message', listener);\n        this.worker.postMessage({ data: \"{\\\"records\\\":[\".concat(JSON.stringify(initialRecord)), id: this.id, action: 'write' });\n    }\n    Segment.prototype.addRecord = function (record) {\n        var _a;\n        this.metadata.end = record.timestamp;\n        this.metadata.records_count += 1;\n        replayStats.addRecord(this.metadata.view.id);\n        (_a = this.metadata).has_full_snapshot || (_a.has_full_snapshot = record.type === RecordType.FullSnapshot);\n        this.worker.postMessage({ data: \",\".concat(JSON.stringify(record)), id: this.id, action: 'write' });\n    };\n    Segment.prototype.flush = function (reason) {\n        this.worker.postMessage({\n            data: \"],\".concat(JSON.stringify(this.metadata).slice(1), \"\\n\"),\n            id: this.id,\n            action: 'flush',\n        });\n        this.isFlushed = true;\n        this.flushReason = reason;\n    };\n    return Segment;\n}());\nexport { Segment };\n//# sourceMappingURL=segment.js.map","var workerURL;\nexport function createDeflateWorker() {\n    // Lazily compute the worker URL to allow importing the SDK in NodeJS\n    if (!workerURL) {\n        workerURL = URL.createObjectURL(new Blob([\"(\".concat(workerCodeFn, \")(self)\")]));\n    }\n    return new Worker(workerURL);\n}\nfunction workerCodeFn() {\n    monitor(function () {\n        var _a = makePakoDeflate(), Deflate = _a.Deflate, constants = _a.constants, string2buf = _a.string2buf;\n        var deflate = new Deflate();\n        var rawSize = 0;\n        self.addEventListener('message', monitor(function (event) {\n            var data = event.data;\n            switch (data.action) {\n                case 'init':\n                    self.postMessage({\n                        type: 'initialized',\n                    });\n                    break;\n                case 'write': {\n                    var additionalRawSize = pushData(data.data);\n                    self.postMessage({\n                        type: 'wrote',\n                        id: data.id,\n                        compressedSize: deflate.chunks.reduce(function (total, chunk) { return total + chunk.length; }, 0),\n                        additionalRawSize: additionalRawSize,\n                    });\n                    break;\n                }\n                case 'flush': {\n                    var additionalRawSize = data.data ? pushData(data.data) : 0;\n                    deflate.push('', constants.Z_FINISH);\n                    self.postMessage({\n                        type: 'flushed',\n                        id: data.id,\n                        result: deflate.result,\n                        additionalRawSize: additionalRawSize,\n                        rawSize: rawSize,\n                    });\n                    deflate = new Deflate();\n                    rawSize = 0;\n                    break;\n                }\n            }\n        }));\n        function pushData(data) {\n            // TextEncoder is not supported on old browser version like Edge 18, therefore we use string2buf\n            var binaryData = string2buf(data);\n            deflate.push(binaryData, constants.Z_SYNC_FLUSH);\n            rawSize += binaryData.length;\n            return binaryData.length;\n        }\n    })();\n    function monitor(fn) {\n        return function () {\n            try {\n                return fn.apply(this, arguments);\n            }\n            catch (e) {\n                try {\n                    self.postMessage({\n                        type: 'errored',\n                        error: e,\n                    });\n                }\n                catch (_) {\n                    // DATA_CLONE_ERR, cf https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm\n                    self.postMessage({\n                        type: 'errored',\n                        error: \"\".concat(e),\n                    });\n                }\n            }\n        };\n    }\n    // https://github.com/nodeca/pako/blob/034669ba0f1a4c0590e45f7c2820128200f972b3/dist/pako_deflate.es5.js\n    function makePakoDeflate() {\n        /* eslint-disable camelcase, no-bitwise */\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        // const Z_FILTERED          = 1;\n        // const Z_HUFFMAN_ONLY      = 2;\n        // const Z_RLE               = 3;\n        var Z_FIXED = 4; // const Z_DEFAULT_STRATEGY  = 0;\n        /* Possible values of the data_type field (though see inflate()) */\n        var Z_BINARY = 0;\n        var Z_TEXT = 1; // const Z_ASCII             = 1; // = Z_TEXT\n        var Z_UNKNOWN = 2;\n        /* ============================================================================ */\n        function zero(buf) {\n            var len = buf.length;\n            while (--len >= 0) {\n                buf[len] = 0;\n            }\n        } // From zutil.h\n        var STORED_BLOCK = 0;\n        var STATIC_TREES = 1;\n        var DYN_TREES = 2;\n        /* The three kinds of block type */\n        var MIN_MATCH = 3;\n        var MAX_MATCH = 258;\n        /* The minimum and maximum match lengths */\n        // From deflate.h\n        /* ===========================================================================\n         * Internal compression state.\n         */\n        var LENGTH_CODES = 29;\n        /* number of length codes, not counting the special END_BLOCK code */\n        var LITERALS = 256;\n        /* number of literal bytes 0..255 */\n        var L_CODES = LITERALS + 1 + LENGTH_CODES;\n        /* number of Literal or Length codes, including the END_BLOCK code */\n        var D_CODES = 30;\n        /* number of distance codes */\n        var BL_CODES = 19;\n        /* number of codes used to transfer the bit lengths */\n        var HEAP_SIZE = 2 * L_CODES + 1;\n        /* maximum heap size */\n        var MAX_BITS = 15;\n        /* All codes must not exceed MAX_BITS bits */\n        var Buf_size = 16;\n        /* size of bit buffer in bi_buf */\n        /* ===========================================================================\n         * Constants\n         */\n        var MAX_BL_BITS = 7;\n        /* Bit length codes must not exceed MAX_BL_BITS bits */\n        var END_BLOCK = 256;\n        /* end of block literal code */\n        var REP_3_6 = 16;\n        /* repeat previous bit length 3-6 times (2 bits of repeat count) */\n        var REPZ_3_10 = 17;\n        /* repeat a zero length 3-10 times  (3 bits of repeat count) */\n        var REPZ_11_138 = 18;\n        /* repeat a zero length 11-138 times  (7 bits of repeat count) */\n        var extra_lbits = \n        /* extra bits for each length code */\n        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0]);\n        var extra_dbits = \n        /* extra bits for each distance code */\n        new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13]);\n        var extra_blbits = \n        /* extra bits for each bit length code */\n        new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7]);\n        var bl_order = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n        /* eslint-enable comma-spacing,array-bracket-spacing */\n        /* The lengths of the bit length codes are sent in order of decreasing\n         * probability, to avoid transmitting the lengths for unused bit length codes.\n         */\n        /* ===========================================================================\n         * Local data. These are initialized only once.\n         */\n        // We pre-fill arrays with 0 to avoid uninitialized gaps\n        var DIST_CODE_LEN = 512;\n        /* see definition of array dist_code below */\n        // !!!! Use flat array instead of structure, Freq = i*2, Len = i*2+1\n        var static_ltree = new Array((L_CODES + 2) * 2);\n        zero(static_ltree);\n        /* The static literal tree. Since the bit lengths are imposed, there is no\n         * need for the L_CODES extra codes used during heap construction. However\n         * The codes 286 and 287 are needed to build a canonical tree (see _tr_init\n         * below).\n         */\n        var static_dtree = new Array(D_CODES * 2);\n        zero(static_dtree);\n        /* The static distance tree. (Actually a trivial tree since all codes use\n         * 5 bits.)\n         */\n        var _dist_code = new Array(DIST_CODE_LEN);\n        zero(_dist_code);\n        /* Distance codes. The first 256 values correspond to the distances\n         * 3 .. 258, the last 256 values correspond to the top 8 bits of\n         * the 15 bit distances.\n         */\n        var _length_code = new Array(MAX_MATCH - MIN_MATCH + 1);\n        zero(_length_code);\n        /* length code for each normalized match length (0 == MIN_MATCH) */\n        var base_length = new Array(LENGTH_CODES);\n        zero(base_length);\n        /* First normalized length for each code (0 = MIN_MATCH) */\n        var base_dist = new Array(D_CODES);\n        zero(base_dist);\n        /* First normalized distance for each code (0 = distance of 1) */\n        function StaticTreeDesc(static_tree, extra_bits, extra_base, elems, max_length) {\n            this.static_tree = static_tree;\n            /* static tree or NULL */\n            this.extra_bits = extra_bits;\n            /* extra bits for each code or NULL */\n            this.extra_base = extra_base;\n            /* base index for extra_bits */\n            this.elems = elems;\n            /* max number of elements in the tree */\n            this.max_length = max_length;\n            /* max bit length for the codes */\n            // show if `static_tree` has data or dummy - needed for monomorphic objects\n            this.has_stree = static_tree && static_tree.length;\n        }\n        var static_l_desc;\n        var static_d_desc;\n        var static_bl_desc;\n        function TreeDesc(dyn_tree, stat_desc) {\n            this.dyn_tree = dyn_tree;\n            /* the dynamic tree */\n            this.max_code = 0;\n            /* largest code with non zero frequency */\n            this.stat_desc = stat_desc;\n            /* the corresponding static tree */\n        }\n        var d_code = function d_code(dist) {\n            return dist < 256 ? _dist_code[dist] : _dist_code[256 + (dist >>> 7)];\n        };\n        /* ===========================================================================\n         * Output a short LSB first on the stream.\n         * IN assertion: there is enough room in pendingBuf.\n         */\n        var put_short = function put_short(s, w) {\n            //    put_byte(s, (uch)((w) & 0xff));\n            //    put_byte(s, (uch)((ush)(w) >> 8));\n            s.pending_buf[s.pending++] = w & 0xff;\n            s.pending_buf[s.pending++] = (w >>> 8) & 0xff;\n        };\n        /* ===========================================================================\n         * Send a value on a given number of bits.\n         * IN assertion: length <= 16 and value fits in length bits.\n         */\n        var send_bits = function send_bits(s, value, length) {\n            if (s.bi_valid > Buf_size - length) {\n                s.bi_buf |= (value << s.bi_valid) & 0xffff;\n                put_short(s, s.bi_buf);\n                s.bi_buf = value >> (Buf_size - s.bi_valid);\n                s.bi_valid += length - Buf_size;\n            }\n            else {\n                s.bi_buf |= (value << s.bi_valid) & 0xffff;\n                s.bi_valid += length;\n            }\n        };\n        var send_code = function send_code(s, c, tree) {\n            send_bits(s, tree[c * 2], \n            /* .Code */\n            tree[c * 2 + 1]\n            /* .Len */\n            );\n        };\n        /* ===========================================================================\n         * Reverse the first len bits of a code, using straightforward code (a faster\n         * method would use a table)\n         * IN assertion: 1 <= len <= 15\n         */\n        var bi_reverse = function bi_reverse(code, len) {\n            var res = 0;\n            do {\n                res |= code & 1;\n                code >>>= 1;\n                res <<= 1;\n            } while (--len > 0);\n            return res >>> 1;\n        };\n        /* ===========================================================================\n         * Flush the bit buffer, keeping at most 7 bits in it.\n         */\n        var bi_flush = function bi_flush(s) {\n            if (s.bi_valid === 16) {\n                put_short(s, s.bi_buf);\n                s.bi_buf = 0;\n                s.bi_valid = 0;\n            }\n            else if (s.bi_valid >= 8) {\n                s.pending_buf[s.pending++] = s.bi_buf & 0xff;\n                s.bi_buf >>= 8;\n                s.bi_valid -= 8;\n            }\n        };\n        /* ===========================================================================\n         * Compute the optimal bit lengths for a tree and update the total bit length\n         * for the current block.\n         * IN assertion: the fields freq and dad are set, heap[heap_max] and\n         *    above are the tree nodes sorted by increasing frequency.\n         * OUT assertions: the field len is set to the optimal bit length, the\n         *     array bl_count contains the frequencies for each bit length.\n         *     The length opt_len is updated; static_len is also updated if stree is\n         *     not null.\n         */\n        var gen_bitlen = function gen_bitlen(s, desc //    deflate_state *s; //    tree_desc *desc;    /* the tree descriptor */\n        ) {\n            var tree = desc.dyn_tree;\n            var max_code = desc.max_code;\n            var stree = desc.stat_desc.static_tree;\n            var has_stree = desc.stat_desc.has_stree;\n            var extra = desc.stat_desc.extra_bits;\n            var base = desc.stat_desc.extra_base;\n            var max_length = desc.stat_desc.max_length;\n            var h;\n            /* heap index */\n            var n;\n            var m;\n            /* iterate over the tree elements */\n            var bits;\n            /* bit length */\n            var xbits;\n            /* extra bits */\n            var f;\n            /* frequency */\n            var overflow = 0;\n            /* number of elements with bit length too large */\n            for (bits = 0; bits <= MAX_BITS; bits++) {\n                s.bl_count[bits] = 0;\n            }\n            /* In a first pass, compute the optimal bit lengths (which may\n             * overflow in the case of the bit length tree).\n             */\n            tree[s.heap[s.heap_max] * 2 + 1] =\n                /* .Len */\n                0;\n            /* root of the heap */\n            for (h = s.heap_max + 1; h < HEAP_SIZE; h++) {\n                n = s.heap[h];\n                bits =\n                    tree[tree[n * 2 + 1] *\n                        /* .Dad */\n                        2 +\n                        1] +\n                        /* .Len */\n                        1;\n                if (bits > max_length) {\n                    bits = max_length;\n                    overflow++;\n                }\n                tree[n * 2 + 1] =\n                    /* .Len */\n                    bits;\n                /* We overwrite tree[n].Dad which is no longer needed */\n                if (n > max_code) {\n                    continue;\n                }\n                /* not a leaf node */\n                s.bl_count[bits]++;\n                xbits = 0;\n                if (n >= base) {\n                    xbits = extra[n - base];\n                }\n                f = tree[n * 2];\n                /* .Freq */\n                s.opt_len += f * (bits + xbits);\n                if (has_stree) {\n                    s.static_len +=\n                        f *\n                            (stree[n * 2 + 1] +\n                                /* .Len */\n                                xbits);\n                }\n            }\n            if (overflow === 0) {\n                return;\n            } // Trace((stderr,\"\\nbit length overflow\\n\"));\n            /* This happens for example on obj2 and pic of the Calgary corpus */\n            /* Find the first bit length which could increase: */\n            do {\n                bits = max_length - 1;\n                while (s.bl_count[bits] === 0) {\n                    bits--;\n                }\n                s.bl_count[bits]--;\n                /* move one leaf down the tree */\n                s.bl_count[bits + 1] += 2;\n                /* move one overflow item as its brother */\n                s.bl_count[max_length]--;\n                /* The brother of the overflow item also moves one step up,\n                 * but this does not affect bl_count[max_length]\n                 */\n                overflow -= 2;\n            } while (overflow > 0);\n            /* Now recompute all bit lengths, scanning in increasing frequency.\n             * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all\n             * lengths instead of fixing only the wrong ones. This idea is taken\n             * from 'ar' written by Haruhiko Okumura.)\n             */\n            for (bits = max_length; bits !== 0; bits--) {\n                n = s.bl_count[bits];\n                while (n !== 0) {\n                    m = s.heap[--h];\n                    if (m > max_code) {\n                        continue;\n                    }\n                    if (tree[m * 2 + 1] !==\n                        /* .Len */\n                        bits) {\n                        // Trace((stderr,\"code %d bits %d->%d\\n\", m, tree[m].Len, bits));\n                        s.opt_len +=\n                            (bits - tree[m * 2 + 1]) *\n                                /* .Len */\n                                tree[m * 2];\n                        /* .Freq */\n                        tree[m * 2 + 1] =\n                            /* .Len */\n                            bits;\n                    }\n                    n--;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Generate the codes for a given tree and bit counts (which need not be\n         * optimal).\n         * IN assertion: the array bl_count contains the bit length statistics for\n         * the given tree and the field len is set for all tree elements.\n         * OUT assertion: the field code is set for all tree elements of non\n         *     zero code length.\n         */\n        var gen_codes = function gen_codes(tree, max_code, bl_count\n        //    ct_data *tree;             /* the tree to decorate */\n        //    int max_code;              /* largest code with non zero frequency */\n        //    ushf *bl_count;            /* number of codes at each bit length */\n        ) {\n            var next_code = new Array(MAX_BITS + 1);\n            /* next code value for each bit length */\n            var code = 0;\n            /* running code value */\n            var bits;\n            /* bit index */\n            var n;\n            /* code index */\n            /* The distribution counts are first used to generate the code values\n             * without bit reversal.\n             */\n            for (bits = 1; bits <= MAX_BITS; bits++) {\n                next_code[bits] = code = (code + bl_count[bits - 1]) << 1;\n            }\n            /* Check that the bit counts in bl_count are consistent. The last code\n             * must be all ones.\n             */\n            // Assert (code + bl_count[MAX_BITS]-1 == (1<<MAX_BITS)-1,\n            //        \"inconsistent bit counts\");\n            // Tracev((stderr,\"\\ngen_codes: max_code %d \", max_code));\n            for (n = 0; n <= max_code; n++) {\n                var len = tree[n * 2 + 1];\n                /* .Len */\n                if (len === 0) {\n                    continue;\n                }\n                /* Now reverse the bits */\n                tree[n * 2] =\n                    /* .Code */\n                    bi_reverse(next_code[len]++, len); // Tracecv(tree != static_ltree, (stderr,\"\\nn %3d %c l %2d c %4x (%x) \",\n                //     n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));\n            }\n        };\n        /* ===========================================================================\n         * Initialize the various 'constant' tables.\n         */\n        var tr_static_init = function tr_static_init() {\n            var n;\n            /* iterates over tree elements */\n            var bits;\n            /* bit counter */\n            var length;\n            /* length value */\n            var code;\n            /* code value */\n            var dist;\n            /* distance index */\n            var bl_count = new Array(MAX_BITS + 1);\n            /* number of codes at each bit length for an optimal tree */\n            // do check in _tr_init()\n            // if (static_init_done) return;\n            /* For some embedded targets, global variables are not initialized: */\n            /* #ifdef NO_INIT_GLOBAL_POINTERS\n            static_l_desc.static_tree = static_ltree;\n            static_l_desc.extra_bits = extra_lbits;\n            static_d_desc.static_tree = static_dtree;\n            static_d_desc.extra_bits = extra_dbits;\n            static_bl_desc.extra_bits = extra_blbits;\n          #endif */\n            /* Initialize the mapping length (0..255) -> length code (0..28) */\n            length = 0;\n            for (code = 0; code < LENGTH_CODES - 1; code++) {\n                base_length[code] = length;\n                for (n = 0; n < 1 << extra_lbits[code]; n++) {\n                    _length_code[length++] = code;\n                }\n            } // Assert (length == 256, \"tr_static_init: length != 256\");\n            /* Note that the length 255 (match length 258) can be represented\n             * in two different ways: code 284 + 5 bits or code 285, so we\n             * overwrite length_code[255] to use the best encoding:\n             */\n            _length_code[length - 1] = code;\n            /* Initialize the mapping dist (0..32K) -> dist code (0..29) */\n            dist = 0;\n            for (code = 0; code < 16; code++) {\n                base_dist[code] = dist;\n                for (n = 0; n < 1 << extra_dbits[code]; n++) {\n                    _dist_code[dist++] = code;\n                }\n            } // Assert (dist == 256, \"tr_static_init: dist != 256\");\n            dist >>= 7;\n            /* from now on, all distances are divided by 128 */\n            for (; code < D_CODES; code++) {\n                base_dist[code] = dist << 7;\n                for (n = 0; n < 1 << (extra_dbits[code] - 7); n++) {\n                    _dist_code[256 + dist++] = code;\n                }\n            } // Assert (dist == 256, \"tr_static_init: 256+dist != 512\");\n            /* Construct the codes of the static literal tree */\n            for (bits = 0; bits <= MAX_BITS; bits++) {\n                bl_count[bits] = 0;\n            }\n            n = 0;\n            while (n <= 143) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    8;\n                n++;\n                bl_count[8]++;\n            }\n            while (n <= 255) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    9;\n                n++;\n                bl_count[9]++;\n            }\n            while (n <= 279) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    7;\n                n++;\n                bl_count[7]++;\n            }\n            while (n <= 287) {\n                static_ltree[n * 2 + 1] =\n                    /* .Len */\n                    8;\n                n++;\n                bl_count[8]++;\n            }\n            /* Codes 286 and 287 do not exist, but we must include them in the\n             * tree construction to get a canonical Huffman tree (longest code\n             * all ones)\n             */\n            gen_codes(static_ltree, L_CODES + 1, bl_count);\n            /* The static distance tree is trivial: */\n            for (n = 0; n < D_CODES; n++) {\n                static_dtree[n * 2 + 1] =\n                    /* .Len */\n                    5;\n                static_dtree[n * 2] =\n                    /* .Code */\n                    bi_reverse(n, 5);\n            } // Now data ready and we can init static trees\n            static_l_desc = new StaticTreeDesc(static_ltree, extra_lbits, LITERALS + 1, L_CODES, MAX_BITS);\n            static_d_desc = new StaticTreeDesc(static_dtree, extra_dbits, 0, D_CODES, MAX_BITS);\n            static_bl_desc = new StaticTreeDesc(new Array(0), extra_blbits, 0, BL_CODES, MAX_BL_BITS);\n            // static_init_done = true;\n        };\n        /* ===========================================================================\n         * Initialize a new block.\n         */\n        var init_block = function init_block(s) {\n            var n;\n            /* iterates over tree elements */\n            /* Initialize the trees. */\n            for (n = 0; n < L_CODES; n++) {\n                s.dyn_ltree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            for (n = 0; n < D_CODES; n++) {\n                s.dyn_dtree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            for (n = 0; n < BL_CODES; n++) {\n                s.bl_tree[n * 2] =\n                    /* .Freq */\n                    0;\n            }\n            s.dyn_ltree[END_BLOCK * 2] =\n                /* .Freq */\n                1;\n            s.opt_len = s.static_len = 0;\n            s.last_lit = s.matches = 0;\n        };\n        /* ===========================================================================\n         * Flush the bit buffer and align the output on a byte boundary\n         */\n        var bi_windup = function bi_windup(s) {\n            if (s.bi_valid > 8) {\n                put_short(s, s.bi_buf);\n            }\n            else if (s.bi_valid > 0) {\n                // put_byte(s, (Byte)s->bi_buf);\n                s.pending_buf[s.pending++] = s.bi_buf;\n            }\n            s.bi_buf = 0;\n            s.bi_valid = 0;\n        };\n        /* ===========================================================================\n         * Copy a stored block, storing first the length and its\n         * one's complement if requested.\n         */\n        var copy_block = function copy_block(s, buf, len, header\n        // DeflateState *s;\n        // charf    *buf;    /* the input data */\n        // unsigned len;     /* its length */\n        // int      header;  /* true if block header must be written */\n        ) {\n            bi_windup(s);\n            /* align on byte boundary */\n            if (header) {\n                put_short(s, len);\n                put_short(s, ~len);\n            }\n            //  while (len--) {\n            //    put_byte(s, *buf++);\n            //  }\n            s.pending_buf.set(s.window.subarray(buf, buf + len), s.pending);\n            s.pending += len;\n        };\n        /* ===========================================================================\n         * Compares to subtrees, using the tree depth as tie breaker when\n         * the subtrees have equal frequency. This minimizes the worst case length.\n         */\n        var smaller = function smaller(tree, n, m, depth) {\n            var _n2 = n * 2;\n            var _m2 = m * 2;\n            return (tree[_n2] <\n                /* .Freq */\n                tree[_m2] ||\n                /* .Freq */\n                (tree[_n2] ===\n                    /* .Freq */\n                    tree[_m2] &&\n                    /* .Freq */\n                    depth[n] <= depth[m]));\n        };\n        /* ===========================================================================\n         * Restore the heap property by moving down the tree starting at node k,\n         * exchanging a node with the smallest of its two sons if necessary, stopping\n         * when the heap property is re-established (each father smaller than its\n         * two sons).\n         */\n        var pqdownheap = function pqdownheap(s, tree, k\n        //    deflate_state *s;\n        //    ct_data *tree;  /* the tree to restore */\n        //    int k;               /* node to move down */\n        ) {\n            var v = s.heap[k];\n            var j = k << 1;\n            /* left son of k */\n            while (j <= s.heap_len) {\n                /* Set j to the smallest of the two sons: */\n                if (j < s.heap_len && smaller(tree, s.heap[j + 1], s.heap[j], s.depth)) {\n                    j++;\n                }\n                /* Exit if v is smaller than both sons */\n                if (smaller(tree, v, s.heap[j], s.depth)) {\n                    break;\n                }\n                /* Exchange v with the smallest son */\n                s.heap[k] = s.heap[j];\n                k = j;\n                /* And continue down the tree, setting j to the left son of k */\n                j <<= 1;\n            }\n            s.heap[k] = v;\n        }; // inlined manually\n        // const SMALLEST = 1;\n        /* ===========================================================================\n         * Send the block data compressed using the given Huffman trees\n         */\n        var compress_block = function compress_block(s, ltree, dtree\n        //    deflate_state *s;\n        //    const ct_data *ltree; /* literal tree */\n        //    const ct_data *dtree; /* distance tree */\n        ) {\n            var dist;\n            /* distance of matched string */\n            var lc;\n            /* match length or unmatched char (if dist == 0) */\n            var lx = 0;\n            /* running index in l_buf */\n            var code;\n            /* the code to send */\n            var extra;\n            /* number of extra bits to send */\n            if (s.last_lit !== 0) {\n                do {\n                    dist = (s.pending_buf[s.d_buf + lx * 2] << 8) | s.pending_buf[s.d_buf + lx * 2 + 1];\n                    lc = s.pending_buf[s.l_buf + lx];\n                    lx++;\n                    if (dist === 0) {\n                        send_code(s, lc, ltree);\n                        /* send a literal byte */\n                        // Tracecv(isgraph(lc), (stderr,\" '%c' \", lc));\n                    }\n                    else {\n                        /* Here, lc is the match length - MIN_MATCH */\n                        code = _length_code[lc];\n                        send_code(s, code + LITERALS + 1, ltree);\n                        /* send the length code */\n                        extra = extra_lbits[code];\n                        if (extra !== 0) {\n                            lc -= base_length[code];\n                            send_bits(s, lc, extra);\n                            /* send the extra length bits */\n                        }\n                        dist--;\n                        /* dist is now the match distance - 1 */\n                        code = d_code(dist); // Assert (code < D_CODES, \"bad d_code\");\n                        send_code(s, code, dtree);\n                        /* send the distance code */\n                        extra = extra_dbits[code];\n                        if (extra !== 0) {\n                            dist -= base_dist[code];\n                            send_bits(s, dist, extra);\n                            /* send the extra distance bits */\n                        }\n                    }\n                    /* literal or match pair ? */\n                    /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */\n                    // Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,\n                    //       \"pendingBuf overflow\");\n                } while (lx < s.last_lit);\n            }\n            send_code(s, END_BLOCK, ltree);\n        };\n        /* ===========================================================================\n         * Construct one Huffman tree and assigns the code bit strings and lengths.\n         * Update the total bit length for the current block.\n         * IN assertion: the field freq is set for all tree elements.\n         * OUT assertions: the fields len and code are set to the optimal bit length\n         *     and corresponding code. The length opt_len is updated; static_len is\n         *     also updated if stree is not null. The field max_code is set.\n         */\n        var build_tree = function build_tree(s, desc //    deflate_state *s; //    tree_desc *desc; /* the tree descriptor */\n        ) {\n            var tree = desc.dyn_tree;\n            var stree = desc.stat_desc.static_tree;\n            var has_stree = desc.stat_desc.has_stree;\n            var elems = desc.stat_desc.elems;\n            var n;\n            var m;\n            /* iterate over heap elements */\n            var max_code = -1;\n            /* largest code with non zero frequency */\n            var node;\n            /* new node being created */\n            /* Construct the initial heap, with least frequent element in\n             * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1].\n             * heap[0] is not used.\n             */\n            s.heap_len = 0;\n            s.heap_max = HEAP_SIZE;\n            for (n = 0; n < elems; n++) {\n                if (tree[n * 2] !==\n                    /* .Freq */\n                    0) {\n                    s.heap[++s.heap_len] = max_code = n;\n                    s.depth[n] = 0;\n                }\n                else {\n                    tree[n * 2 + 1] =\n                        /* .Len */\n                        0;\n                }\n            }\n            /* The pkzip format requires that at least one distance code exists,\n             * and that at least one bit should be sent even if there is only one\n             * possible code. So to avoid special checks later on we force at least\n             * two codes of non zero frequency.\n             */\n            while (s.heap_len < 2) {\n                node = s.heap[++s.heap_len] = max_code < 2 ? ++max_code : 0;\n                tree[node * 2] =\n                    /* .Freq */\n                    1;\n                s.depth[node] = 0;\n                s.opt_len--;\n                if (has_stree) {\n                    s.static_len -= stree[node * 2 + 1];\n                    /* .Len */\n                }\n                /* node is 0 or 1 so it does not have extra bits */\n            }\n            desc.max_code = max_code;\n            /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree,\n             * establish sub-heaps of increasing lengths:\n             */\n            for (n = s.heap_len >> 1; \n            /* int /2 */\n            n >= 1; n--) {\n                pqdownheap(s, tree, n);\n            }\n            /* Construct the Huffman tree by repeatedly combining the least two\n             * frequent nodes.\n             */\n            node = elems;\n            /* next internal node of the tree */\n            do {\n                // pqremove(s, tree, n);  /* n = node of least frequency */\n                /** * pqremove ** */\n                n = s.heap[1];\n                /* SMALLEST */\n                s.heap[1] = s.heap[s.heap_len--];\n                /* SMALLEST */\n                pqdownheap(s, tree, 1\n                /* SMALLEST */\n                );\n                /***/\n                m = s.heap[1];\n                /* SMALLEST */\n                /* m = node of next least frequency */\n                s.heap[--s.heap_max] = n;\n                /* keep the nodes sorted by frequency */\n                s.heap[--s.heap_max] = m;\n                /* Create a new node father of n and m */\n                tree[node * 2] =\n                    /* .Freq */\n                    tree[n * 2] +\n                        /* .Freq */\n                        tree[m * 2];\n                /* .Freq */\n                s.depth[node] = (s.depth[n] >= s.depth[m] ? s.depth[n] : s.depth[m]) + 1;\n                tree[n * 2 + 1] =\n                    /* .Dad */\n                    tree[m * 2 + 1] =\n                        /* .Dad */\n                        node;\n                /* and insert the new node in the heap */\n                s.heap[1] = node++;\n                /* SMALLEST */\n                pqdownheap(s, tree, 1\n                /* SMALLEST */\n                );\n            } while (s.heap_len >= 2);\n            s.heap[--s.heap_max] = s.heap[1];\n            /* SMALLEST */\n            /* At this point, the fields freq and dad are set. We can now\n             * generate the bit lengths.\n             */\n            gen_bitlen(s, desc);\n            /* The field len is now set, we can generate the bit codes */\n            gen_codes(tree, max_code, s.bl_count);\n        };\n        /* ===========================================================================\n         * Scan a literal or distance tree to determine the frequencies of the codes\n         * in the bit length tree.\n         */\n        var scan_tree = function scan_tree(s, tree, max_code\n        //    deflate_state *s;\n        //    ct_data *tree;   /* the tree to be scanned */\n        //    int max_code;    /* and its largest code of non zero frequency */\n        ) {\n            var n;\n            /* iterates over all tree elements */\n            var prevlen = -1;\n            /* last emitted length */\n            var curlen;\n            /* length of current code */\n            var nextlen = tree[0 * 2 + 1];\n            /* .Len */\n            /* length of next code */\n            var count = 0;\n            /* repeat count of the current code */\n            var max_count = 7;\n            /* max repeat count */\n            var min_count = 4;\n            /* min repeat count */\n            if (nextlen === 0) {\n                max_count = 138;\n                min_count = 3;\n            }\n            tree[(max_code + 1) * 2 + 1] =\n                /* .Len */\n                0xffff;\n            /* guard */\n            for (n = 0; n <= max_code; n++) {\n                curlen = nextlen;\n                nextlen = tree[(n + 1) * 2 + 1];\n                /* .Len */\n                if (++count < max_count && curlen === nextlen) {\n                    continue;\n                }\n                else if (count < min_count) {\n                    s.bl_tree[curlen * 2] +=\n                        /* .Freq */\n                        count;\n                }\n                else if (curlen !== 0) {\n                    if (curlen !== prevlen) {\n                        s.bl_tree[curlen * 2] /* .Freq */++;\n                    }\n                    s.bl_tree[REP_3_6 * 2] /* .Freq */++;\n                }\n                else if (count <= 10) {\n                    s.bl_tree[REPZ_3_10 * 2] /* .Freq */++;\n                }\n                else {\n                    s.bl_tree[REPZ_11_138 * 2] /* .Freq */++;\n                }\n                count = 0;\n                prevlen = curlen;\n                if (nextlen === 0) {\n                    max_count = 138;\n                    min_count = 3;\n                }\n                else if (curlen === nextlen) {\n                    max_count = 6;\n                    min_count = 3;\n                }\n                else {\n                    max_count = 7;\n                    min_count = 4;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Send a literal or distance tree in compressed form, using the codes in\n         * bl_tree.\n         */\n        var send_tree = function send_tree(s, tree, max_code\n        //    deflate_state *s;\n        //    ct_data *tree; /* the tree to be scanned */\n        //    int max_code;       /* and its largest code of non zero frequency */\n        ) {\n            var n;\n            /* iterates over all tree elements */\n            var prevlen = -1;\n            /* last emitted length */\n            var curlen;\n            /* length of current code */\n            var nextlen = tree[0 * 2 + 1];\n            /* .Len */\n            /* length of next code */\n            var count = 0;\n            /* repeat count of the current code */\n            var max_count = 7;\n            /* max repeat count */\n            var min_count = 4;\n            /* min repeat count */\n            /* tree[max_code+1].Len = -1; */\n            /* guard already set */\n            if (nextlen === 0) {\n                max_count = 138;\n                min_count = 3;\n            }\n            for (n = 0; n <= max_code; n++) {\n                curlen = nextlen;\n                nextlen = tree[(n + 1) * 2 + 1];\n                /* .Len */\n                if (++count < max_count && curlen === nextlen) {\n                    continue;\n                }\n                else if (count < min_count) {\n                    do {\n                        send_code(s, curlen, s.bl_tree);\n                    } while (--count !== 0);\n                }\n                else if (curlen !== 0) {\n                    if (curlen !== prevlen) {\n                        send_code(s, curlen, s.bl_tree);\n                        count--;\n                    } // Assert(count >= 3 && count <= 6, \" 3_6?\");\n                    send_code(s, REP_3_6, s.bl_tree);\n                    send_bits(s, count - 3, 2);\n                }\n                else if (count <= 10) {\n                    send_code(s, REPZ_3_10, s.bl_tree);\n                    send_bits(s, count - 3, 3);\n                }\n                else {\n                    send_code(s, REPZ_11_138, s.bl_tree);\n                    send_bits(s, count - 11, 7);\n                }\n                count = 0;\n                prevlen = curlen;\n                if (nextlen === 0) {\n                    max_count = 138;\n                    min_count = 3;\n                }\n                else if (curlen === nextlen) {\n                    max_count = 6;\n                    min_count = 3;\n                }\n                else {\n                    max_count = 7;\n                    min_count = 4;\n                }\n            }\n        };\n        /* ===========================================================================\n         * Construct the Huffman tree for the bit lengths and return the index in\n         * bl_order of the last bit length code to send.\n         */\n        var build_bl_tree = function build_bl_tree(s) {\n            var max_blindex;\n            /* index of last bit length code of non zero freq */\n            /* Determine the bit length frequencies for literal and distance trees */\n            scan_tree(s, s.dyn_ltree, s.l_desc.max_code);\n            scan_tree(s, s.dyn_dtree, s.d_desc.max_code);\n            /* Build the bit length tree: */\n            build_tree(s, s.bl_desc);\n            /* opt_len now includes the length of the tree representations, except\n             * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.\n             */\n            /* Determine the number of bit length codes to send. The pkzip format\n             * requires that at least 4 bit length codes be sent. (appnote.txt says\n             * 3 but the actual value used is 4.)\n             */\n            for (max_blindex = BL_CODES - 1; max_blindex >= 3; max_blindex--) {\n                if (s.bl_tree[bl_order[max_blindex] * 2 + 1] !==\n                    /* .Len */\n                    0) {\n                    break;\n                }\n            }\n            /* Update opt_len to include the bit length tree and counts */\n            s.opt_len += 3 * (max_blindex + 1) + 5 + 5 + 4; // Tracev((stderr, \"\\ndyn trees: dyn %ld, stat %ld\",\n            //        s->opt_len, s->static_len));\n            return max_blindex;\n        };\n        /* ===========================================================================\n         * Send the header for a block using dynamic Huffman trees: the counts, the\n         * lengths of the bit length codes, the literal tree and the distance tree.\n         * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.\n         */\n        var send_all_trees = function send_all_trees(s, lcodes, dcodes, blcodes //    deflate_state *s; //    int lcodes, dcodes, blcodes; /* number of codes for each tree */\n        ) {\n            var rank;\n            /* index in bl_order */\n            // Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, \"not enough codes\");\n            // Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,\n            //        \"too many codes\");\n            // Tracev((stderr, \"\\nbl counts: \"));\n            send_bits(s, lcodes - 257, 5);\n            /* not +255 as stated in appnote.txt */\n            send_bits(s, dcodes - 1, 5);\n            send_bits(s, blcodes - 4, 4);\n            /* not -3 as stated in appnote.txt */\n            for (rank = 0; rank < blcodes; rank++) {\n                // Tracev((stderr, \"\\nbl code %2d \", bl_order[rank]));\n                send_bits(s, s.bl_tree[bl_order[rank] * 2 + 1], \n                /* .Len */\n                3);\n            } // Tracev((stderr, \"\\nbl tree: sent %ld\", s->bits_sent));\n            send_tree(s, s.dyn_ltree, lcodes - 1);\n            /* literal tree */\n            // Tracev((stderr, \"\\nlit tree: sent %ld\", s->bits_sent));\n            send_tree(s, s.dyn_dtree, dcodes - 1);\n            /* distance tree */\n            // Tracev((stderr, \"\\ndist tree: sent %ld\", s->bits_sent));\n        };\n        /* ===========================================================================\n         * Check if the data type is TEXT or BINARY, using the following algorithm:\n         * - TEXT if the two conditions below are satisfied:\n         *    a) There are no non-portable control characters belonging to the\n         *       \"black list\" (0..6, 14..25, 28..31).\n         *    b) There is at least one printable character belonging to the\n         *       \"white list\" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).\n         * - BINARY otherwise.\n         * - The following partially-portable control characters form a\n         *   \"gray list\" that is ignored in this detection algorithm:\n         *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).\n         * IN assertion: the fields Freq of dyn_ltree are set.\n         */\n        var detect_data_type = function detect_data_type(s) {\n            /* black_mask is the bit mask of black-listed bytes\n             * set bits 0..6, 14..25, and 28..31\n             * 0xf3ffc07f = binary 11110011111111111100000001111111\n             */\n            var black_mask = 0xf3ffc07f;\n            var n;\n            /* Check for non-textual (\"black-listed\") bytes. */\n            for (n = 0; n <= 31; n++, black_mask >>>= 1) {\n                if (black_mask & 1 &&\n                    s.dyn_ltree[n * 2] !==\n                        /* .Freq */\n                        0) {\n                    return Z_BINARY;\n                }\n            }\n            /* Check for textual (\"white-listed\") bytes. */\n            if (s.dyn_ltree[9 * 2] !==\n                /* .Freq */\n                0 ||\n                s.dyn_ltree[10 * 2] !==\n                    /* .Freq */\n                    0 ||\n                s.dyn_ltree[13 * 2] !==\n                    /* .Freq */\n                    0) {\n                return Z_TEXT;\n            }\n            for (n = 32; n < LITERALS; n++) {\n                if (s.dyn_ltree[n * 2] !==\n                    /* .Freq */\n                    0) {\n                    return Z_TEXT;\n                }\n            }\n            /* There are no \"black-listed\" or \"white-listed\" bytes:\n             * this stream either is empty or has tolerated (\"gray-listed\") bytes only.\n             */\n            return Z_BINARY;\n        };\n        var static_init_done = false;\n        /* ===========================================================================\n         * Initialize the tree data structures for a new zlib stream.\n         */\n        var _tr_init = function _tr_init(s) {\n            if (!static_init_done) {\n                tr_static_init();\n                static_init_done = true;\n            }\n            s.l_desc = new TreeDesc(s.dyn_ltree, static_l_desc);\n            s.d_desc = new TreeDesc(s.dyn_dtree, static_d_desc);\n            s.bl_desc = new TreeDesc(s.bl_tree, static_bl_desc);\n            s.bi_buf = 0;\n            s.bi_valid = 0;\n            /* Initialize the first block of the first file: */\n            init_block(s);\n        };\n        /* ===========================================================================\n         * Send a stored block\n         */\n        var _tr_stored_block = function _tr_stored_block(s, buf, stored_len, last\n        // DeflateState *s;\n        // charf *buf;       /* input block */\n        // ulg stored_len;   /* length of input block */\n        // int last;         /* one if this is the last block for a file */\n        ) {\n            send_bits(s, (STORED_BLOCK << 1) + (last ? 1 : 0), 3);\n            /* send block type */\n            copy_block(s, buf, stored_len, true);\n            /* with header */\n        };\n        /* ===========================================================================\n         * Send one empty static block to give enough lookahead for inflate.\n         * This takes 10 bits, of which 7 may remain in the bit buffer.\n         */\n        var _tr_align = function _tr_align(s) {\n            send_bits(s, STATIC_TREES << 1, 3);\n            send_code(s, END_BLOCK, static_ltree);\n            bi_flush(s);\n        };\n        /* ===========================================================================\n         * Determine the best encoding for the current block: dynamic trees, static\n         * trees or store, and output the encoded block to the zip file.\n         */\n        var _tr_flush_block = function _tr_flush_block(s, buf, stored_len, last\n        // DeflateState *s;\n        // charf *buf;       /* input block, or NULL if too old */\n        // ulg stored_len;   /* length of input block */\n        // int last;         /* one if this is the last block for a file */\n        ) {\n            var opt_lenb;\n            var static_lenb;\n            /* opt_len and static_len in bytes */\n            var max_blindex = 0;\n            /* index of last bit length code of non zero freq */\n            /* Build the Huffman trees unless a stored block is forced */\n            if (s.level > 0) {\n                /* Check if the file is binary or text */\n                if (s.strm.data_type === Z_UNKNOWN) {\n                    s.strm.data_type = detect_data_type(s);\n                }\n                /* Construct the literal and distance trees */\n                build_tree(s, s.l_desc); // Tracev((stderr, \"\\nlit data: dyn %ld, stat %ld\", s->opt_len,\n                //        s->static_len));\n                build_tree(s, s.d_desc); // Tracev((stderr, \"\\ndist data: dyn %ld, stat %ld\", s->opt_len,\n                //        s->static_len));\n                /* At this point, opt_len and static_len are the total bit lengths of\n                 * the compressed block data, excluding the tree representations.\n                 */\n                /* Build the bit length tree for the above two trees, and get the index\n                 * in bl_order of the last bit length code to send.\n                 */\n                max_blindex = build_bl_tree(s);\n                /* Determine the best encoding. Compute the block lengths in bytes. */\n                opt_lenb = (s.opt_len + 3 + 7) >>> 3;\n                static_lenb = (s.static_len + 3 + 7) >>> 3; // Tracev((stderr, \"\\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u \",\n                //        opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,\n                //        s->last_lit));\n                if (static_lenb <= opt_lenb) {\n                    opt_lenb = static_lenb;\n                }\n            }\n            else {\n                // Assert(buf != (char*)0, \"lost buf\");\n                opt_lenb = static_lenb = stored_len + 5;\n                /* force a stored block */\n            }\n            if (stored_len + 4 <= opt_lenb && buf !== -1) {\n                /* 4: two words for the lengths */\n                /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.\n                 * Otherwise we can't have processed more than WSIZE input bytes since\n                 * the last block flush, because compression would have been\n                 * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to\n                 * transform a block into a stored block.\n                 */\n                _tr_stored_block(s, buf, stored_len, last);\n            }\n            else if (s.strategy === Z_FIXED || static_lenb === opt_lenb) {\n                send_bits(s, (STATIC_TREES << 1) + (last ? 1 : 0), 3);\n                compress_block(s, static_ltree, static_dtree);\n            }\n            else {\n                send_bits(s, (DYN_TREES << 1) + (last ? 1 : 0), 3);\n                send_all_trees(s, s.l_desc.max_code + 1, s.d_desc.max_code + 1, max_blindex + 1);\n                compress_block(s, s.dyn_ltree, s.dyn_dtree);\n            } // Assert (s->compressed_len == s->bits_sent, \"bad compressed size\");\n            /* The above check is made mod 2^32, for files larger than 512 MB\n             * and uLong implemented on 32 bits.\n             */\n            init_block(s);\n            if (last) {\n                bi_windup(s);\n            } // Tracev((stderr,\"\\ncomprlen %lu(%lu) \", s->compressed_len>>3,\n            //       s->compressed_len-7*last));\n        };\n        /* ===========================================================================\n         * Save the match info and tally the frequency counts. Return true if\n         * the current block must be flushed.\n         */\n        var _tr_tally = function _tr_tally(s, dist, lc\n        //    deflate_state *s;\n        //    unsigned dist;  /* distance of matched string */\n        //    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */\n        ) {\n            // let out_length, in_length, dcode;\n            s.pending_buf[s.d_buf + s.last_lit * 2] = (dist >>> 8) & 0xff;\n            s.pending_buf[s.d_buf + s.last_lit * 2 + 1] = dist & 0xff;\n            s.pending_buf[s.l_buf + s.last_lit] = lc & 0xff;\n            s.last_lit++;\n            if (dist === 0) {\n                /* lc is the unmatched char */\n                s.dyn_ltree[lc * 2] /* .Freq */++;\n            }\n            else {\n                s.matches++;\n                /* Here, lc is the match length - MIN_MATCH */\n                dist--;\n                /* dist = match distance - 1 */\n                // Assert((ush)dist < (ush)MAX_DIST(s) &&\n                //       (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&\n                //       (ush)d_code(dist) < (ush)D_CODES,  \"_tr_tally: bad match\");\n                s.dyn_ltree[(_length_code[lc] + LITERALS + 1) * 2] /* .Freq */++;\n                s.dyn_dtree[d_code(dist) * 2] /* .Freq */++;\n            } // (!) This block is disabled in zlib defaults,\n            // don't enable it for binary compatibility\n            // #ifdef TRUNCATE_BLOCK\n            //  /* Try to guess if it is profitable to stop the current block here */\n            //  if ((s.last_lit & 0x1fff) === 0 && s.level > 2) {\n            //    /* Compute an upper bound for the compressed length */\n            //    out_length = s.last_lit*8;\n            //    in_length = s.strstart - s.block_start;\n            //\n            //    for (dcode = 0; dcode < D_CODES; dcode++) {\n            //      out_length += s.dyn_dtree[dcode*2]/*.Freq*/ * (5 + extra_dbits[dcode]);\n            //    }\n            //    out_length >>>= 3;\n            //    //Tracev((stderr,\"\\nlast_lit %u, in %ld, out ~%ld(%ld%%) \",\n            //    //       s->last_lit, in_length, out_length,\n            //    //       100L - out_length*100L/in_length));\n            //    if (s.matches < (s.last_lit>>1)/*int /2*/ && out_length < (in_length>>1)/*int /2*/) {\n            //      return true;\n            //    }\n            //  }\n            // #endif\n            return s.last_lit === s.lit_bufsize - 1;\n            /* We avoid equality with lit_bufsize because of wraparound at 64K\n             * on 16 bit machines and because stored blocks are restricted to\n             * 64K-1 bytes.\n             */\n        };\n        var _tr_init_1 = _tr_init;\n        var _tr_stored_block_1 = _tr_stored_block;\n        var _tr_flush_block_1 = _tr_flush_block;\n        var _tr_tally_1 = _tr_tally;\n        var _tr_align_1 = _tr_align;\n        var trees = {\n            _tr_init: _tr_init_1,\n            _tr_stored_block: _tr_stored_block_1,\n            _tr_flush_block: _tr_flush_block_1,\n            _tr_tally: _tr_tally_1,\n            _tr_align: _tr_align_1,\n        };\n        // It isn't worth it to make additional optimizations as in original.\n        // Small size is preferable.\n        // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var adler32 = function adler32(adler, buf, len, pos) {\n            var s1 = (adler & 0xffff) | 0;\n            var s2 = ((adler >>> 16) & 0xffff) | 0;\n            var n = 0;\n            while (len !== 0) {\n                // Set limit ~ twice less than 5552, to keep\n                // s2 in 31-bits, because we force signed ints.\n                // in other case %= will fail.\n                n = len > 2000 ? 2000 : len;\n                len -= n;\n                do {\n                    s1 = (s1 + buf[pos++]) | 0;\n                    s2 = (s2 + s1) | 0;\n                } while (--n);\n                s1 %= 65521;\n                s2 %= 65521;\n            }\n            return s1 | (s2 << 16) | 0;\n        };\n        var adler32_1 = adler32;\n        // So write code to minimize size - no pregenerated tables\n        // and array tools dependencies.\n        // (C) 1995-2013 Jean-loup Gailly and Mark Adler\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        // Use ordinary array, since untyped makes no boost here\n        var makeTable = function makeTable() {\n            var c;\n            var table = [];\n            for (var n = 0; n < 256; n++) {\n                c = n;\n                for (var k = 0; k < 8; k++) {\n                    c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;\n                }\n                table[n] = c;\n            }\n            return table;\n        }; // Create table on load. Just 255 signed longs. Not a problem.\n        var crcTable = new Uint32Array(makeTable());\n        var crc32 = function crc32(crc, buf, len, pos) {\n            var t = crcTable;\n            var end = pos + len;\n            crc ^= -1;\n            for (var i = pos; i < end; i++) {\n                crc = (crc >>> 8) ^ t[(crc ^ buf[i]) & 0xff];\n            }\n            return crc ^ -1; // >>> 0;\n        };\n        var crc32_1 = crc32;\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var messages = {\n            2: 'need dictionary',\n            /* Z_NEED_DICT       2  */\n            1: 'stream end',\n            /* Z_STREAM_END      1  */\n            0: '',\n            /* Z_OK              0  */\n            '-1': 'file error',\n            /* Z_ERRNO         (-1) */\n            '-2': 'stream error',\n            /* Z_STREAM_ERROR  (-2) */\n            '-3': 'data error',\n            /* Z_DATA_ERROR    (-3) */\n            '-4': 'insufficient memory',\n            /* Z_MEM_ERROR     (-4) */\n            '-5': 'buffer error',\n            /* Z_BUF_ERROR     (-5) */\n            '-6': 'incompatible version',\n            /* Z_VERSION_ERROR (-6) */\n        };\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var constants = {\n            /* Allowed flush values; see deflate() and inflate() below for details */\n            Z_NO_FLUSH: 0,\n            Z_PARTIAL_FLUSH: 1,\n            Z_SYNC_FLUSH: 2,\n            Z_FULL_FLUSH: 3,\n            Z_FINISH: 4,\n            Z_BLOCK: 5,\n            Z_TREES: 6,\n            /* Return codes for the compression/decompression functions. Negative values\n             * are errors, positive values are used for special but normal events.\n             */\n            Z_OK: 0,\n            Z_STREAM_END: 1,\n            Z_NEED_DICT: 2,\n            Z_ERRNO: -1,\n            Z_STREAM_ERROR: -2,\n            Z_DATA_ERROR: -3,\n            Z_MEM_ERROR: -4,\n            Z_BUF_ERROR: -5,\n            // Z_VERSION_ERROR: -6,\n            /* compression levels */\n            Z_NO_COMPRESSION: 0,\n            Z_BEST_SPEED: 1,\n            Z_BEST_COMPRESSION: 9,\n            Z_DEFAULT_COMPRESSION: -1,\n            Z_FILTERED: 1,\n            Z_HUFFMAN_ONLY: 2,\n            Z_RLE: 3,\n            Z_FIXED: 4,\n            Z_DEFAULT_STRATEGY: 0,\n            /* Possible values of the data_type field (though see inflate()) */\n            Z_BINARY: 0,\n            Z_TEXT: 1,\n            // Z_ASCII:                1, // = Z_TEXT (deprecated)\n            Z_UNKNOWN: 2,\n            /* The deflate compression method */\n            Z_DEFLATED: 8, // Z_NULL:                 null // Use -1 or null inline, depending on var type\n        };\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        var _tr_init$1 = trees._tr_init;\n        var _tr_stored_block$1 = trees._tr_stored_block;\n        var _tr_flush_block$1 = trees._tr_flush_block;\n        var _tr_tally$1 = trees._tr_tally;\n        var _tr_align$1 = trees._tr_align;\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        var Z_NO_FLUSH = constants.Z_NO_FLUSH;\n        var Z_PARTIAL_FLUSH = constants.Z_PARTIAL_FLUSH;\n        var Z_FULL_FLUSH = constants.Z_FULL_FLUSH;\n        var Z_FINISH = constants.Z_FINISH;\n        var Z_BLOCK = constants.Z_BLOCK;\n        var Z_OK = constants.Z_OK;\n        var Z_STREAM_END = constants.Z_STREAM_END;\n        var Z_STREAM_ERROR = constants.Z_STREAM_ERROR;\n        var Z_DATA_ERROR = constants.Z_DATA_ERROR;\n        var Z_BUF_ERROR = constants.Z_BUF_ERROR;\n        var Z_DEFAULT_COMPRESSION = constants.Z_DEFAULT_COMPRESSION;\n        var Z_FILTERED = constants.Z_FILTERED;\n        var Z_HUFFMAN_ONLY = constants.Z_HUFFMAN_ONLY;\n        var Z_RLE = constants.Z_RLE;\n        var Z_FIXED$1 = constants.Z_FIXED;\n        var Z_DEFAULT_STRATEGY = constants.Z_DEFAULT_STRATEGY;\n        var Z_UNKNOWN$1 = constants.Z_UNKNOWN;\n        var Z_DEFLATED = constants.Z_DEFLATED;\n        /* ============================================================================ */\n        var MAX_MEM_LEVEL = 9;\n        /* Maximum value for memLevel in deflateInit2 */\n        var MAX_WBITS = 15;\n        /* 32K LZ77 window */\n        var DEF_MEM_LEVEL = 8;\n        var LENGTH_CODES$1 = 29;\n        /* number of length codes, not counting the special END_BLOCK code */\n        var LITERALS$1 = 256;\n        /* number of literal bytes 0..255 */\n        var L_CODES$1 = LITERALS$1 + 1 + LENGTH_CODES$1;\n        /* number of Literal or Length codes, including the END_BLOCK code */\n        var D_CODES$1 = 30;\n        /* number of distance codes */\n        var BL_CODES$1 = 19;\n        /* number of codes used to transfer the bit lengths */\n        var HEAP_SIZE$1 = 2 * L_CODES$1 + 1;\n        /* maximum heap size */\n        var MAX_BITS$1 = 15;\n        /* All codes must not exceed MAX_BITS bits */\n        var MIN_MATCH$1 = 3;\n        var MAX_MATCH$1 = 258;\n        var MIN_LOOKAHEAD = MAX_MATCH$1 + MIN_MATCH$1 + 1;\n        var PRESET_DICT = 0x20;\n        var INIT_STATE = 42;\n        var EXTRA_STATE = 69;\n        var NAME_STATE = 73;\n        var COMMENT_STATE = 91;\n        var HCRC_STATE = 103;\n        var BUSY_STATE = 113;\n        var FINISH_STATE = 666;\n        var BS_NEED_MORE = 1;\n        /* block not completed, need more input or more output */\n        var BS_BLOCK_DONE = 2;\n        /* block flush performed */\n        var BS_FINISH_STARTED = 3;\n        /* finish started, need only more output at next deflate */\n        var BS_FINISH_DONE = 4;\n        /* finish done, accept no more input or output */\n        var OS_CODE = 0x03; // Unix :) . Don't detect, use this default.\n        var err = function err(strm, errorCode) {\n            strm.msg = messages[errorCode];\n            return errorCode;\n        };\n        var rank = function rank(f) {\n            return (f << 1) - (f > 4 ? 9 : 0);\n        };\n        var zero$1 = function zero(buf) {\n            var len = buf.length;\n            while (--len >= 0) {\n                buf[len] = 0;\n            }\n        };\n        var HASH_ZLIB = function HASH_ZLIB(s, prev, data) {\n            return ((prev << s.hash_shift) ^ data) & s.hash_mask;\n        }; // This hash causes less collisions, https://github.com/nodeca/pako/issues/135\n        // But breaks binary compatibility\n        // let HASH_FAST = (s, prev, data) => ((prev << 8) + (prev >> 8) + (data << 4)) & s.hash_mask;\n        var HASH = HASH_ZLIB;\n        /* =========================================================================\n         * Flush as much pending output as possible. All deflate() output goes\n         * through this function so some applications may wish to modify it\n         * to avoid allocating a large strm->output buffer and copying into it.\n         * (See also read_buf()).\n         */\n        var flush_pending = function flush_pending(strm) {\n            var s = strm.state; // _tr_flush_bits(s);\n            var len = s.pending;\n            if (len > strm.avail_out) {\n                len = strm.avail_out;\n            }\n            if (len === 0) {\n                return;\n            }\n            strm.output.set(s.pending_buf.subarray(s.pending_out, s.pending_out + len), strm.next_out);\n            strm.next_out += len;\n            s.pending_out += len;\n            strm.total_out += len;\n            strm.avail_out -= len;\n            s.pending -= len;\n            if (s.pending === 0) {\n                s.pending_out = 0;\n            }\n        };\n        var flush_block_only = function flush_block_only(s, last) {\n            _tr_flush_block$1(s, s.block_start >= 0 ? s.block_start : -1, s.strstart - s.block_start, last);\n            s.block_start = s.strstart;\n            flush_pending(s.strm);\n        };\n        var put_byte = function put_byte(s, b) {\n            s.pending_buf[s.pending++] = b;\n        };\n        /* =========================================================================\n         * Put a short in the pending buffer. The 16-bit value is put in MSB order.\n         * IN assertion: the stream state is correct and there is enough room in\n         * pending_buf.\n         */\n        var putShortMSB = function putShortMSB(s, b) {\n            //  put_byte(s, (Byte)(b >> 8));\n            //  put_byte(s, (Byte)(b & 0xff));\n            s.pending_buf[s.pending++] = (b >>> 8) & 0xff;\n            s.pending_buf[s.pending++] = b & 0xff;\n        };\n        /* ===========================================================================\n         * Read a new buffer from the current input stream, update the adler32\n         * and total number of bytes read.  All deflate() input goes through\n         * this function so some applications may wish to modify it to avoid\n         * allocating a large strm->input buffer and copying from it.\n         * (See also flush_pending()).\n         */\n        var read_buf = function read_buf(strm, buf, start, size) {\n            var len = strm.avail_in;\n            if (len > size) {\n                len = size;\n            }\n            if (len === 0) {\n                return 0;\n            }\n            strm.avail_in -= len; // zmemcpy(buf, strm->next_in, len);\n            buf.set(strm.input.subarray(strm.next_in, strm.next_in + len), start);\n            if (strm.state.wrap === 1) {\n                strm.adler = adler32_1(strm.adler, buf, len, start);\n            }\n            else if (strm.state.wrap === 2) {\n                strm.adler = crc32_1(strm.adler, buf, len, start);\n            }\n            strm.next_in += len;\n            strm.total_in += len;\n            return len;\n        };\n        /* ===========================================================================\n         * Set match_start to the longest match starting at the given string and\n         * return its length. Matches shorter or equal to prev_length are discarded,\n         * in which case the result is equal to prev_length and match_start is\n         * garbage.\n         * IN assertions: cur_match is the head of the hash chain for the current\n         *   string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1\n         * OUT assertion: the match length is not greater than s->lookahead.\n         */\n        var longest_match = function longest_match(s, cur_match) {\n            var chain_length = s.max_chain_length;\n            /* max hash chain length */\n            var scan = s.strstart;\n            /* current string */\n            var match;\n            /* matched string */\n            var len;\n            /* length of current match */\n            var best_len = s.prev_length;\n            /* best match length so far */\n            var nice_match = s.nice_match;\n            /* stop if match long enough */\n            var limit = s.strstart > s.w_size - MIN_LOOKAHEAD ? s.strstart - (s.w_size - MIN_LOOKAHEAD) : 0;\n            /* NIL */\n            var _win = s.window; // shortcut\n            var wmask = s.w_mask;\n            var prev = s.prev;\n            /* Stop when cur_match becomes <= limit. To simplify the code,\n             * we prevent matches with the string of window index 0.\n             */\n            var strend = s.strstart + MAX_MATCH$1;\n            var scan_end1 = _win[scan + best_len - 1];\n            var scan_end = _win[scan + best_len];\n            /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.\n             * It is easy to get rid of this optimization if necessary.\n             */\n            // Assert(s->hash_bits >= 8 && MAX_MATCH == 258, \"Code too clever\");\n            /* Do not waste too much time if we already have a good match: */\n            if (s.prev_length >= s.good_match) {\n                chain_length >>= 2;\n            }\n            /* Do not look for matches beyond the end of the input. This is necessary\n             * to make deflate deterministic.\n             */\n            if (nice_match > s.lookahead) {\n                nice_match = s.lookahead;\n            } // Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, \"need lookahead\");\n            do {\n                // Assert(cur_match < s->strstart, \"no future\");\n                match = cur_match;\n                /* Skip to next match if the match length cannot increase\n                 * or if the match length is less than 2.  Note that the checks below\n                 * for insufficient lookahead only occur occasionally for performance\n                 * reasons.  Therefore uninitialized memory will be accessed, and\n                 * conditional jumps will be made that depend on those values.\n                 * However the length of the match is limited to the lookahead, so\n                 * the output of deflate is not affected by the uninitialized values.\n                 */\n                if (_win[match + best_len] !== scan_end ||\n                    _win[match + best_len - 1] !== scan_end1 ||\n                    _win[match] !== _win[scan] ||\n                    _win[++match] !== _win[scan + 1]) {\n                    continue;\n                }\n                /* The check at best_len-1 can be removed because it will be made\n                 * again later. (This heuristic is not always a win.)\n                 * It is not necessary to compare scan[2] and match[2] since they\n                 * are always equal when the other bytes match, given that\n                 * the hash keys are equal and that HASH_BITS >= 8.\n                 */\n                scan += 2;\n                match++; // Assert(*scan == *match, \"match[2]?\");\n                /* We check for insufficient lookahead only every 8th comparison;\n                 * the 256th check will be made at strstart+258.\n                 */\n                do {\n                    /* jshint noempty:false */\n                } while (_win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    _win[++scan] === _win[++match] &&\n                    scan < strend); // Assert(scan <= s->window+(unsigned)(s->window_size-1), \"wild scan\");\n                len = MAX_MATCH$1 - (strend - scan);\n                scan = strend - MAX_MATCH$1;\n                if (len > best_len) {\n                    s.match_start = cur_match;\n                    best_len = len;\n                    if (len >= nice_match) {\n                        break;\n                    }\n                    scan_end1 = _win[scan + best_len - 1];\n                    scan_end = _win[scan + best_len];\n                }\n            } while ((cur_match = prev[cur_match & wmask]) > limit && --chain_length !== 0);\n            if (best_len <= s.lookahead) {\n                return best_len;\n            }\n            return s.lookahead;\n        };\n        /* ===========================================================================\n         * Fill the window when the lookahead becomes insufficient.\n         * Updates strstart and lookahead.\n         *\n         * IN assertion: lookahead < MIN_LOOKAHEAD\n         * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD\n         *    At least one byte has been read, or avail_in == 0; reads are\n         *    performed for at least two bytes (required for the zip translate_eol\n         *    option -- not supported here).\n         */\n        var fill_window = function fill_window(s) {\n            var _w_size = s.w_size;\n            var p;\n            var n;\n            var m;\n            var more;\n            var str; // Assert(s->lookahead < MIN_LOOKAHEAD, \"already enough lookahead\");\n            do {\n                more = s.window_size - s.lookahead - s.strstart; // JS ints have 32 bit, block below not needed\n                /* Deal with !@#$% 64K limit: */\n                // if (sizeof(int) <= 2) {\n                //    if (more == 0 && s->strstart == 0 && s->lookahead == 0) {\n                //        more = wsize;\n                //\n                //  } else if (more == (unsigned)(-1)) {\n                //        /* Very unlikely, but possible on 16 bit machine if\n                //         * strstart == 0 && lookahead == 1 (input done a byte at time)\n                //         */\n                //        more--;\n                //    }\n                // }\n                /* If the window is almost full and there is insufficient lookahead,\n                 * move the upper half to the lower one to make room in the upper half.\n                 */\n                if (s.strstart >= _w_size + (_w_size - MIN_LOOKAHEAD)) {\n                    s.window.set(s.window.subarray(_w_size, _w_size + _w_size), 0);\n                    s.match_start -= _w_size;\n                    s.strstart -= _w_size;\n                    /* we now have strstart >= MAX_DIST */\n                    s.block_start -= _w_size;\n                    /* Slide the hash table (could be avoided with 32 bit values\n                   at the expense of memory usage). We slide even when level == 0\n                   to keep the hash table consistent if we switch back to level > 0\n                   later. (Using level 0 permanently is not an optimal usage of\n                   zlib, so we don't care about this pathological case.)\n                   */\n                    n = s.hash_size;\n                    p = n;\n                    do {\n                        m = s.head[--p];\n                        s.head[p] = m >= _w_size ? m - _w_size : 0;\n                    } while (--n);\n                    n = _w_size;\n                    p = n;\n                    do {\n                        m = s.prev[--p];\n                        s.prev[p] = m >= _w_size ? m - _w_size : 0;\n                        /* If n is not on any hash chain, prev[n] is garbage but\n                         * its value will never be used.\n                         */\n                    } while (--n);\n                    more += _w_size;\n                }\n                if (s.strm.avail_in === 0) {\n                    break;\n                }\n                /* If there was no sliding:\n                 *    strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 &&\n                 *    more == window_size - lookahead - strstart\n                 * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1)\n                 * => more >= window_size - 2*WSIZE + 2\n                 * In the BIG_MEM or MMAP case (not yet supported),\n                 *   window_size == input_size + MIN_LOOKAHEAD  &&\n                 *   strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD.\n                 * Otherwise, window_size == 2*WSIZE so more >= 2.\n                 * If there was sliding, more >= WSIZE. So in all cases, more >= 2.\n                 */\n                // Assert(more >= 2, \"more < 2\");\n                n = read_buf(s.strm, s.window, s.strstart + s.lookahead, more);\n                s.lookahead += n;\n                /* Initialize the hash value now that we have some input: */\n                if (s.lookahead + s.insert >= MIN_MATCH$1) {\n                    str = s.strstart - s.insert;\n                    s.ins_h = s.window[str];\n                    /* UPDATE_HASH(s, s->ins_h, s->window[str + 1]); */\n                    s.ins_h = HASH(s, s.ins_h, s.window[str + 1]); // #if MIN_MATCH != 3\n                    //        Call update_hash() MIN_MATCH-3 more times\n                    // #endif\n                    while (s.insert) {\n                        /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n                        s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);\n                        s.prev[str & s.w_mask] = s.head[s.ins_h];\n                        s.head[s.ins_h] = str;\n                        str++;\n                        s.insert--;\n                        if (s.lookahead + s.insert < MIN_MATCH$1) {\n                            break;\n                        }\n                    }\n                }\n                /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage,\n                 * but this is not important since only literal bytes will be emitted.\n                 */\n            } while (s.lookahead < MIN_LOOKAHEAD && s.strm.avail_in !== 0);\n            /* If the WIN_INIT bytes after the end of the current data have never been\n             * written, then zero those bytes in order to avoid memory check reports of\n             * the use of uninitialized (or uninitialised as Julian writes) bytes by\n             * the longest match routines.  Update the high water mark for the next\n             * time through here.  WIN_INIT is set to MAX_MATCH since the longest match\n             * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead.\n             */\n            //  if (s.high_water < s.window_size) {\n            //    const curr = s.strstart + s.lookahead;\n            //    let init = 0;\n            //\n            //    if (s.high_water < curr) {\n            //      /* Previous high water mark below current data -- zero WIN_INIT\n            //       * bytes or up to end of window, whichever is less.\n            //       */\n            //      init = s.window_size - curr;\n            //      if (init > WIN_INIT)\n            //        init = WIN_INIT;\n            //      zmemzero(s->window + curr, (unsigned)init);\n            //      s->high_water = curr + init;\n            //    }\n            //    else if (s->high_water < (ulg)curr + WIN_INIT) {\n            //      /* High water mark at or above current data, but below current data\n            //       * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up\n            //       * to end of window, whichever is less.\n            //       */\n            //      init = (ulg)curr + WIN_INIT - s->high_water;\n            //      if (init > s->window_size - s->high_water)\n            //        init = s->window_size - s->high_water;\n            //      zmemzero(s->window + s->high_water, (unsigned)init);\n            //      s->high_water += init;\n            //    }\n            //  }\n            //\n            //  Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD,\n            //    \"not enough room for search\");\n        };\n        /* ===========================================================================\n         * Copy without compression as much as possible from the input stream, return\n         * the current block state.\n         * This function does not insert new strings in the dictionary since\n         * uncompressible data is probably not useful. This function is used\n         * only for the level=0 compression option.\n         * NOTE: this function should be optimized to avoid extra copying from\n         * window to pending_buf.\n         */\n        var deflate_stored = function deflate_stored(s, flush) {\n            /* Stored blocks are limited to 0xffff bytes, pending_buf is limited\n             * to pending_buf_size, and each stored block has a 5 byte header:\n             */\n            var max_block_size = 0xffff;\n            if (max_block_size > s.pending_buf_size - 5) {\n                max_block_size = s.pending_buf_size - 5;\n            }\n            /* Copy as much as possible from input to output: */\n            for (;;) {\n                /* Fill the window as much as possible: */\n                if (s.lookahead <= 1) {\n                    // Assert(s->strstart < s->w_size+MAX_DIST(s) ||\n                    //  s->block_start >= (long)s->w_size, \"slide too late\");\n                    //      if (!(s.strstart < s.w_size + (s.w_size - MIN_LOOKAHEAD) ||\n                    //        s.block_start >= s.w_size)) {\n                    //        throw  new Error(\"slide too late\");\n                    //      }\n                    fill_window(s);\n                    if (s.lookahead === 0 && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                } // Assert(s->block_start >= 0L, \"block gone\");\n                //    if (s.block_start < 0) throw new Error(\"block gone\");\n                s.strstart += s.lookahead;\n                s.lookahead = 0;\n                /* Emit a stored block if pending_buf will be full: */\n                var max_start = s.block_start + max_block_size;\n                if (s.strstart === 0 || s.strstart >= max_start) {\n                    /* strstart == 0 is possible when wraparound on 16-bit machine */\n                    s.lookahead = s.strstart - max_start;\n                    s.strstart = max_start;\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n                /* Flush if we may have to slide, otherwise block_start may become\n                 * negative and the data will be gone:\n                 */\n                if (s.strstart - s.block_start >= s.w_size - MIN_LOOKAHEAD) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.strstart > s.block_start) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_NEED_MORE;\n        };\n        /* ===========================================================================\n         * Compress as much as possible from the input stream, return the current\n         * block state.\n         * This function does not perform lazy evaluation of matches and inserts\n         * new strings in the dictionary only for unmatched strings or for short\n         * matches. It is used only for the fast compression options.\n         */\n        var deflate_fast = function deflate_fast(s, flush) {\n            var hash_head;\n            /* head of the hash chain */\n            var bflush;\n            /* set if current block must be flushed */\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the next match, plus MIN_MATCH bytes to insert the\n                 * string following the next match.\n                 */\n                if (s.lookahead < MIN_LOOKAHEAD) {\n                    fill_window(s);\n                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                        /* flush the current block */\n                    }\n                }\n                /* Insert the string window[strstart .. strstart+2] in the\n                 * dictionary, and set hash_head to the head of the hash chain:\n                 */\n                hash_head = 0;\n                /* NIL */\n                if (s.lookahead >= MIN_MATCH$1) {\n                    /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                    s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = s.strstart;\n                    /***/\n                }\n                /* Find the longest match, discarding those <= prev_length.\n                 * At this point we have always match_length < MIN_MATCH\n                 */\n                if (hash_head !== 0 &&\n                    /* NIL */\n                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD) {\n                    /* To simplify the code, we prevent matches with the string\n                     * of window index 0 (in particular we have to avoid a match\n                     * of the string with itself at the start of the input file).\n                     */\n                    s.match_length = longest_match(s, hash_head);\n                    /* longest_match() sets match_start */\n                }\n                if (s.match_length >= MIN_MATCH$1) {\n                    // check_match(s, s.strstart, s.match_start, s.match_length); // for debug only\n                    /** * _tr_tally_dist(s, s.strstart - s.match_start,\n                                 s.match_length - MIN_MATCH, bflush); ** */\n                    bflush = _tr_tally$1(s, s.strstart - s.match_start, s.match_length - MIN_MATCH$1);\n                    s.lookahead -= s.match_length;\n                    /* Insert new strings in the hash table only if the match length\n                     * is not too large. This saves time but degrades compression.\n                     */\n                    if (s.match_length <= s.max_lazy_match &&\n                        /* max_insert_length */\n                        s.lookahead >= MIN_MATCH$1) {\n                        s.match_length--;\n                        /* string at strstart already in table */\n                        do {\n                            s.strstart++;\n                            /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                            s.head[s.ins_h] = s.strstart;\n                            /***/\n                            /* strstart never exceeds WSIZE-MAX_MATCH, so there are\n                             * always MIN_MATCH bytes ahead.\n                             */\n                        } while (--s.match_length !== 0);\n                        s.strstart++;\n                    }\n                    else {\n                        s.strstart += s.match_length;\n                        s.match_length = 0;\n                        s.ins_h = s.window[s.strstart];\n                        /* UPDATE_HASH(s, s.ins_h, s.window[s.strstart+1]); */\n                        s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + 1]); // #if MIN_MATCH != 3\n                        //                Call UPDATE_HASH() MIN_MATCH-3 more times\n                        // #endif\n                        /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not\n                         * matter since it will be recomputed at next deflate call.\n                         */\n                    }\n                }\n                else {\n                    /* No match, output a literal byte */\n                    // Tracevv((stderr,\"%c\", s.window[s.strstart]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                    s.lookahead--;\n                    s.strstart++;\n                }\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * Same as above, but achieves better compression. We use a lazy\n         * evaluation for matches: a match is finally adopted only if there is\n         * no better match at the next window position.\n         */\n        var deflate_slow = function deflate_slow(s, flush) {\n            var hash_head;\n            /* head of hash chain */\n            var bflush;\n            /* set if current block must be flushed */\n            var max_insert;\n            /* Process the input block. */\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the next match, plus MIN_MATCH bytes to insert the\n                 * string following the next match.\n                 */\n                if (s.lookahead < MIN_LOOKAHEAD) {\n                    fill_window(s);\n                    if (s.lookahead < MIN_LOOKAHEAD && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                }\n                /* Insert the string window[strstart .. strstart+2] in the\n                 * dictionary, and set hash_head to the head of the hash chain:\n                 */\n                hash_head = 0;\n                /* NIL */\n                if (s.lookahead >= MIN_MATCH$1) {\n                    /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                    s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                    hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = s.strstart;\n                    /***/\n                }\n                /* Find the longest match, discarding those <= prev_length.\n                 */\n                s.prev_length = s.match_length;\n                s.prev_match = s.match_start;\n                s.match_length = MIN_MATCH$1 - 1;\n                if (hash_head !== 0 &&\n                    /* NIL */\n                    s.prev_length < s.max_lazy_match &&\n                    s.strstart - hash_head <= s.w_size - MIN_LOOKAHEAD\n                /* MAX_DIST(s) */\n                ) {\n                    /* To simplify the code, we prevent matches with the string\n                     * of window index 0 (in particular we have to avoid a match\n                     * of the string with itself at the start of the input file).\n                     */\n                    s.match_length = longest_match(s, hash_head);\n                    /* longest_match() sets match_start */\n                    if (s.match_length <= 5 &&\n                        (s.strategy === Z_FILTERED || (s.match_length === MIN_MATCH$1 && s.strstart - s.match_start > 4096))\n                    /* TOO_FAR */\n                    ) {\n                        /* If prev_match is also MIN_MATCH, match_start is garbage\n                         * but we will ignore the current match anyway.\n                         */\n                        s.match_length = MIN_MATCH$1 - 1;\n                    }\n                }\n                /* If there was a match at the previous step and the current\n                 * match is not better, output the previous match:\n                 */\n                if (s.prev_length >= MIN_MATCH$1 && s.match_length <= s.prev_length) {\n                    max_insert = s.strstart + s.lookahead - MIN_MATCH$1;\n                    /* Do not insert strings in hash table beyond this. */\n                    // check_match(s, s.strstart-1, s.prev_match, s.prev_length);\n                    /** *_tr_tally_dist(s, s.strstart - 1 - s.prev_match,\n                                 s.prev_length - MIN_MATCH, bflush);** */\n                    bflush = _tr_tally$1(s, s.strstart - 1 - s.prev_match, s.prev_length - MIN_MATCH$1);\n                    /* Insert in hash table all strings up to the end of the match.\n                     * strstart-1 and strstart are already inserted. If there is not\n                     * enough lookahead, the last two strings are not inserted in\n                     * the hash table.\n                     */\n                    s.lookahead -= s.prev_length - 1;\n                    s.prev_length -= 2;\n                    do {\n                        if (++s.strstart <= max_insert) {\n                            /** * INSERT_STRING(s, s.strstart, hash_head); ** */\n                            s.ins_h = HASH(s, s.ins_h, s.window[s.strstart + MIN_MATCH$1 - 1]);\n                            hash_head = s.prev[s.strstart & s.w_mask] = s.head[s.ins_h];\n                            s.head[s.ins_h] = s.strstart;\n                            /***/\n                        }\n                    } while (--s.prev_length !== 0);\n                    s.match_available = 0;\n                    s.match_length = MIN_MATCH$1 - 1;\n                    s.strstart++;\n                    if (bflush) {\n                        /** * FLUSH_BLOCK(s, 0); ** */\n                        flush_block_only(s, false);\n                        if (s.strm.avail_out === 0) {\n                            return BS_NEED_MORE;\n                        }\n                        /***/\n                    }\n                }\n                else if (s.match_available) {\n                    /* If there was no match at the previous position, output a\n                     * single literal. If there was a match but the current match\n                     * is longer, truncate the previous match to a single literal.\n                     */\n                    // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);\n                    if (bflush) {\n                        /** * FLUSH_BLOCK_ONLY(s, 0) ** */\n                        flush_block_only(s, false);\n                        /***/\n                    }\n                    s.strstart++;\n                    s.lookahead--;\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                }\n                else {\n                    /* There is no previous match to compare with, wait for\n                     * the next step to decide.\n                     */\n                    s.match_available = 1;\n                    s.strstart++;\n                    s.lookahead--;\n                }\n            } // Assert (flush != Z_NO_FLUSH, \"no flush?\");\n            if (s.match_available) {\n                // Tracevv((stderr,\"%c\", s->window[s->strstart-1]));\n                /** * _tr_tally_lit(s, s.window[s.strstart-1], bflush); ** */\n                bflush = _tr_tally$1(s, 0, s.window[s.strstart - 1]);\n                s.match_available = 0;\n            }\n            s.insert = s.strstart < MIN_MATCH$1 - 1 ? s.strstart : MIN_MATCH$1 - 1;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * For Z_RLE, simply look for runs of bytes, generate matches only of distance\n         * one.  Do not maintain a hash table.  (It will be regenerated if this run of\n         * deflate switches away from Z_RLE.)\n         */\n        var deflate_rle = function deflate_rle(s, flush) {\n            var bflush;\n            /* set if current block must be flushed */\n            var prev;\n            /* byte at distance one to match */\n            var scan;\n            var strend;\n            /* scan goes up to strend for length of run */\n            var _win = s.window;\n            for (;;) {\n                /* Make sure that we always have enough lookahead, except\n                 * at the end of the input file. We need MAX_MATCH bytes\n                 * for the longest run, plus one for the unrolled loop.\n                 */\n                if (s.lookahead <= MAX_MATCH$1) {\n                    fill_window(s);\n                    if (s.lookahead <= MAX_MATCH$1 && flush === Z_NO_FLUSH) {\n                        return BS_NEED_MORE;\n                    }\n                    if (s.lookahead === 0) {\n                        break;\n                    }\n                    /* flush the current block */\n                }\n                /* See how many times the previous byte repeats */\n                s.match_length = 0;\n                if (s.lookahead >= MIN_MATCH$1 && s.strstart > 0) {\n                    scan = s.strstart - 1;\n                    prev = _win[scan];\n                    if (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan]) {\n                        strend = s.strstart + MAX_MATCH$1;\n                        do {\n                            /* jshint noempty:false */\n                        } while (prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            prev === _win[++scan] &&\n                            scan < strend);\n                        s.match_length = MAX_MATCH$1 - (strend - scan);\n                        if (s.match_length > s.lookahead) {\n                            s.match_length = s.lookahead;\n                        }\n                    } // Assert(scan <= s->window+(uInt)(s->window_size-1), \"wild scan\");\n                }\n                /* Emit match if have run of MIN_MATCH or longer, else emit literal */\n                if (s.match_length >= MIN_MATCH$1) {\n                    // check_match(s, s.strstart, s.strstart - 1, s.match_length);\n                    /** * _tr_tally_dist(s, 1, s.match_length - MIN_MATCH, bflush); ** */\n                    bflush = _tr_tally$1(s, 1, s.match_length - MIN_MATCH$1);\n                    s.lookahead -= s.match_length;\n                    s.strstart += s.match_length;\n                    s.match_length = 0;\n                }\n                else {\n                    /* No match, output a literal byte */\n                    // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n                    /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                    bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                    s.lookahead--;\n                    s.strstart++;\n                }\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* ===========================================================================\n         * For Z_HUFFMAN_ONLY, do not look for matches.  Do not maintain a hash table.\n         * (It will be regenerated if this run of deflate switches away from Huffman.)\n         */\n        var deflate_huff = function deflate_huff(s, flush) {\n            var bflush;\n            /* set if current block must be flushed */\n            for (;;) {\n                /* Make sure that we have a literal to write. */\n                if (s.lookahead === 0) {\n                    fill_window(s);\n                    if (s.lookahead === 0) {\n                        if (flush === Z_NO_FLUSH) {\n                            return BS_NEED_MORE;\n                        }\n                        break;\n                        /* flush the current block */\n                    }\n                }\n                /* Output a literal byte */\n                s.match_length = 0; // Tracevv((stderr,\"%c\", s->window[s->strstart]));\n                /** * _tr_tally_lit(s, s.window[s.strstart], bflush); ** */\n                bflush = _tr_tally$1(s, 0, s.window[s.strstart]);\n                s.lookahead--;\n                s.strstart++;\n                if (bflush) {\n                    /** * FLUSH_BLOCK(s, 0); ** */\n                    flush_block_only(s, false);\n                    if (s.strm.avail_out === 0) {\n                        return BS_NEED_MORE;\n                    }\n                    /***/\n                }\n            }\n            s.insert = 0;\n            if (flush === Z_FINISH) {\n                /** * FLUSH_BLOCK(s, 1); ** */\n                flush_block_only(s, true);\n                if (s.strm.avail_out === 0) {\n                    return BS_FINISH_STARTED;\n                }\n                /***/\n                return BS_FINISH_DONE;\n            }\n            if (s.last_lit) {\n                /** * FLUSH_BLOCK(s, 0); ** */\n                flush_block_only(s, false);\n                if (s.strm.avail_out === 0) {\n                    return BS_NEED_MORE;\n                }\n                /***/\n            }\n            return BS_BLOCK_DONE;\n        };\n        /* Values for max_lazy_match, good_match and max_chain_length, depending on\n         * the desired pack level (0..9). The values given below have been tuned to\n         * exclude worst case performance for pathological files. Better values may be\n         * found for specific files.\n         */\n        function Config(good_length, max_lazy, nice_length, max_chain, func) {\n            this.good_length = good_length;\n            this.max_lazy = max_lazy;\n            this.nice_length = nice_length;\n            this.max_chain = max_chain;\n            this.func = func;\n        }\n        var configuration_table = [\n            /*      good lazy nice chain */\n            new Config(0, 0, 0, 0, deflate_stored),\n            /* 0 store only */\n            new Config(4, 4, 8, 4, deflate_fast),\n            /* 1 max speed, no lazy matches */\n            new Config(4, 5, 16, 8, deflate_fast),\n            /* 2 */\n            new Config(4, 6, 32, 32, deflate_fast),\n            /* 3 */\n            new Config(4, 4, 16, 16, deflate_slow),\n            /* 4 lazy matches */\n            new Config(8, 16, 32, 32, deflate_slow),\n            /* 5 */\n            new Config(8, 16, 128, 128, deflate_slow),\n            /* 6 */\n            new Config(8, 32, 128, 256, deflate_slow),\n            /* 7 */\n            new Config(32, 128, 258, 1024, deflate_slow),\n            /* 8 */\n            new Config(32, 258, 258, 4096, deflate_slow),\n            /* 9 max compression */\n        ];\n        /* ===========================================================================\n         * Initialize the \"longest match\" routines for a new zlib stream\n         */\n        var lm_init = function lm_init(s) {\n            s.window_size = 2 * s.w_size;\n            /** * CLEAR_HASH(s); ** */\n            zero$1(s.head); // Fill with NIL (= 0);\n            /* Set the default configuration parameters:\n             */\n            s.max_lazy_match = configuration_table[s.level].max_lazy;\n            s.good_match = configuration_table[s.level].good_length;\n            s.nice_match = configuration_table[s.level].nice_length;\n            s.max_chain_length = configuration_table[s.level].max_chain;\n            s.strstart = 0;\n            s.block_start = 0;\n            s.lookahead = 0;\n            s.insert = 0;\n            s.match_length = s.prev_length = MIN_MATCH$1 - 1;\n            s.match_available = 0;\n            s.ins_h = 0;\n        };\n        function DeflateState() {\n            this.strm = null;\n            /* pointer back to this zlib stream */\n            this.status = 0;\n            /* as the name implies */\n            this.pending_buf = null;\n            /* output still pending */\n            this.pending_buf_size = 0;\n            /* size of pending_buf */\n            this.pending_out = 0;\n            /* next pending byte to output to the stream */\n            this.pending = 0;\n            /* nb of bytes in the pending buffer */\n            this.wrap = 0;\n            /* bit 0 true for zlib, bit 1 true for gzip */\n            this.gzhead = null;\n            /* gzip header information to write */\n            this.gzindex = 0;\n            /* where in extra, name, or comment */\n            this.method = Z_DEFLATED;\n            /* can only be DEFLATED */\n            this.last_flush = -1;\n            /* value of flush param for previous deflate call */\n            this.w_size = 0;\n            /* LZ77 window size (32K by default) */\n            this.w_bits = 0;\n            /* log2(w_size)  (8..16) */\n            this.w_mask = 0;\n            /* w_size - 1 */\n            this.window = null;\n            /* Sliding window. Input bytes are read into the second half of the window,\n             * and move to the first half later to keep a dictionary of at least wSize\n             * bytes. With this organization, matches are limited to a distance of\n             * wSize-MAX_MATCH bytes, but this ensures that IO is always\n             * performed with a length multiple of the block size.\n             */\n            this.window_size = 0;\n            /* Actual size of window: 2*wSize, except when the user input buffer\n             * is directly used as sliding window.\n             */\n            this.prev = null;\n            /* Link to older string with same hash index. To limit the size of this\n             * array to 64K, this link is maintained only for the last 32K strings.\n             * An index in this array is thus a window index modulo 32K.\n             */\n            this.head = null;\n            /* Heads of the hash chains or NIL. */\n            this.ins_h = 0;\n            /* hash index of string to be inserted */\n            this.hash_size = 0;\n            /* number of elements in hash table */\n            this.hash_bits = 0;\n            /* log2(hash_size) */\n            this.hash_mask = 0;\n            /* hash_size-1 */\n            this.hash_shift = 0;\n            /* Number of bits by which ins_h must be shifted at each input\n             * step. It must be such that after MIN_MATCH steps, the oldest\n             * byte no longer takes part in the hash key, that is:\n             *   hash_shift * MIN_MATCH >= hash_bits\n             */\n            this.block_start = 0;\n            /* Window position at the beginning of the current output block. Gets\n             * negative when the window is moved backwards.\n             */\n            this.match_length = 0;\n            /* length of best match */\n            this.prev_match = 0;\n            /* previous match */\n            this.match_available = 0;\n            /* set if previous match exists */\n            this.strstart = 0;\n            /* start of string to insert */\n            this.match_start = 0;\n            /* start of matching string */\n            this.lookahead = 0;\n            /* number of valid bytes ahead in window */\n            this.prev_length = 0;\n            /* Length of the best match at previous step. Matches not greater than this\n             * are discarded. This is used in the lazy match evaluation.\n             */\n            this.max_chain_length = 0;\n            /* To speed up deflation, hash chains are never searched beyond this\n             * length.  A higher limit improves compression ratio but degrades the\n             * speed.\n             */\n            this.max_lazy_match = 0;\n            /* Attempt to find a better match only when the current match is strictly\n             * smaller than this value. This mechanism is used only for compression\n             * levels >= 4.\n             */\n            // That's alias to max_lazy_match, don't use directly\n            // this.max_insert_length = 0;\n            /* Insert new strings in the hash table only if the match length is not\n             * greater than this length. This saves time but degrades compression.\n             * max_insert_length is used only for compression levels <= 3.\n             */\n            this.level = 0;\n            /* compression level (1..9) */\n            this.strategy = 0;\n            /* favor or force Huffman coding */\n            this.good_match = 0;\n            /* Use a faster search when the previous match is longer than this */\n            this.nice_match = 0;\n            /* Stop searching when current match exceeds this */\n            /* used by trees.c: */\n            /* Didn't use ct_data typedef below to suppress compiler warning */\n            // struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */\n            // struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */\n            // struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */\n            // Use flat array of DOUBLE size, with interleaved fata,\n            // because JS does not support effective\n            this.dyn_ltree = new Uint16Array(HEAP_SIZE$1 * 2);\n            this.dyn_dtree = new Uint16Array((2 * D_CODES$1 + 1) * 2);\n            this.bl_tree = new Uint16Array((2 * BL_CODES$1 + 1) * 2);\n            zero$1(this.dyn_ltree);\n            zero$1(this.dyn_dtree);\n            zero$1(this.bl_tree);\n            this.l_desc = null;\n            /* desc. for literal tree */\n            this.d_desc = null;\n            /* desc. for distance tree */\n            this.bl_desc = null;\n            /* desc. for bit length tree */\n            // ush bl_count[MAX_BITS+1];\n            this.bl_count = new Uint16Array(MAX_BITS$1 + 1);\n            /* number of codes at each bit length for an optimal tree */\n            // int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */\n            this.heap = new Uint16Array(2 * L_CODES$1 + 1);\n            /* heap used to build the Huffman trees */\n            zero$1(this.heap);\n            this.heap_len = 0;\n            /* number of elements in the heap */\n            this.heap_max = 0;\n            /* element of largest frequency */\n            /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.\n             * The same heap array is used to build all trees.\n             */\n            this.depth = new Uint16Array(2 * L_CODES$1 + 1); // uch depth[2*L_CODES+1];\n            zero$1(this.depth);\n            /* Depth of each subtree used as tie breaker for trees of equal frequency\n             */\n            this.l_buf = 0;\n            /* buffer index for literals or lengths */\n            this.lit_bufsize = 0;\n            /* Size of match buffer for literals/lengths.  There are 4 reasons for\n             * limiting lit_bufsize to 64K:\n             *   - frequencies can be kept in 16 bit counters\n             *   - if compression is not successful for the first block, all input\n             *     data is still in the window so we can still emit a stored block even\n             *     when input comes from standard input.  (This can also be done for\n             *     all blocks if lit_bufsize is not greater than 32K.)\n             *   - if compression is not successful for a file smaller than 64K, we can\n             *     even emit a stored file instead of a stored block (saving 5 bytes).\n             *     This is applicable only for zip (not gzip or zlib).\n             *   - creating new Huffman trees less frequently may not provide fast\n             *     adaptation to changes in the input data statistics. (Take for\n             *     example a binary file with poorly compressible code followed by\n             *     a highly compressible string table.) Smaller buffer sizes give\n             *     fast adaptation but have of course the overhead of transmitting\n             *     trees more frequently.\n             *   - I can't count above 4\n             */\n            this.last_lit = 0;\n            /* running index in l_buf */\n            this.d_buf = 0;\n            /* Buffer index for distances. To simplify the code, d_buf and l_buf have\n             * the same number of elements. To use different lengths, an extra flag\n             * array would be necessary.\n             */\n            this.opt_len = 0;\n            /* bit length of current block with optimal trees */\n            this.static_len = 0;\n            /* bit length of current block with static trees */\n            this.matches = 0;\n            /* number of string matches in current block */\n            this.insert = 0;\n            /* bytes at end of window left to insert */\n            this.bi_buf = 0;\n            /* Output buffer. bits are inserted starting at the bottom (least\n             * significant bits).\n             */\n            this.bi_valid = 0;\n            /* Number of valid bits in bi_buf.  All bits above the last valid bit\n             * are always zero.\n             */\n            // Used for window memory init. We safely ignore it for JS. That makes\n            // sense only for pointers and memory check tools.\n            // this.high_water = 0;\n            /* High water mark offset in window for initialized bytes -- bytes above\n             * this are set to zero in order to avoid memory check warnings when\n             * longest match routines access bytes past the input.  This is then\n             * updated to the new high water mark.\n             */\n        }\n        var deflateResetKeep = function deflateResetKeep(strm) {\n            if (!strm || !strm.state) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            strm.total_in = strm.total_out = 0;\n            strm.data_type = Z_UNKNOWN$1;\n            var s = strm.state;\n            s.pending = 0;\n            s.pending_out = 0;\n            if (s.wrap < 0) {\n                s.wrap = -s.wrap;\n                /* was made negative by deflate(..., Z_FINISH); */\n            }\n            s.status = s.wrap ? INIT_STATE : BUSY_STATE;\n            strm.adler =\n                s.wrap === 2\n                    ? 0 // crc32(0, Z_NULL, 0)\n                    : 1; // adler32(0, Z_NULL, 0)\n            s.last_flush = Z_NO_FLUSH;\n            _tr_init$1(s);\n            return Z_OK;\n        };\n        var deflateReset = function deflateReset(strm) {\n            var ret = deflateResetKeep(strm);\n            if (ret === Z_OK) {\n                lm_init(strm.state);\n            }\n            return ret;\n        };\n        var deflateSetHeader = function deflateSetHeader(strm, head) {\n            if (!strm || !strm.state) {\n                return Z_STREAM_ERROR;\n            }\n            if (strm.state.wrap !== 2) {\n                return Z_STREAM_ERROR;\n            }\n            strm.state.gzhead = head;\n            return Z_OK;\n        };\n        var deflateInit2 = function deflateInit2(strm, level, method, windowBits, memLevel, strategy) {\n            if (!strm) {\n                // === Z_NULL\n                return Z_STREAM_ERROR;\n            }\n            var wrap = 1;\n            if (level === Z_DEFAULT_COMPRESSION) {\n                level = 6;\n            }\n            if (windowBits < 0) {\n                /* suppress zlib wrapper */\n                wrap = 0;\n                windowBits = -windowBits;\n            }\n            else if (windowBits > 15) {\n                wrap = 2;\n                /* write gzip wrapper instead */\n                windowBits -= 16;\n            }\n            if (memLevel < 1 ||\n                memLevel > MAX_MEM_LEVEL ||\n                method !== Z_DEFLATED ||\n                windowBits < 8 ||\n                windowBits > 15 ||\n                level < 0 ||\n                level > 9 ||\n                strategy < 0 ||\n                strategy > Z_FIXED$1) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            if (windowBits === 8) {\n                windowBits = 9;\n            }\n            /* until 256-byte window bug fixed */\n            var s = new DeflateState();\n            strm.state = s;\n            s.strm = strm;\n            s.wrap = wrap;\n            s.gzhead = null;\n            s.w_bits = windowBits;\n            s.w_size = 1 << s.w_bits;\n            s.w_mask = s.w_size - 1;\n            s.hash_bits = memLevel + 7;\n            s.hash_size = 1 << s.hash_bits;\n            s.hash_mask = s.hash_size - 1;\n            s.hash_shift = ~~((s.hash_bits + MIN_MATCH$1 - 1) / MIN_MATCH$1);\n            s.window = new Uint8Array(s.w_size * 2);\n            s.head = new Uint16Array(s.hash_size);\n            s.prev = new Uint16Array(s.w_size); // Don't need mem init magic for JS.\n            // s.high_water = 0;  /* nothing written to s->window yet */\n            s.lit_bufsize = 1 << (memLevel + 6);\n            /* 16K elements by default */\n            s.pending_buf_size = s.lit_bufsize * 4;\n            // overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2);\n            // s->pending_buf = (uchf *) overlay;\n            // It is offset from `s.pending_buf` (size is `s.lit_bufsize * 2`)\n            s.pending_buf = new Uint8Array(s.pending_buf_size);\n            // s->d_buf = overlay + s->lit_bufsize/sizeof(ush);\n            s.d_buf = 1 * s.lit_bufsize; // s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize;\n            s.l_buf = (1 + 2) * s.lit_bufsize;\n            s.level = level;\n            s.strategy = strategy;\n            s.method = method;\n            return deflateReset(strm);\n        };\n        var deflateInit = function deflateInit(strm, level) {\n            return deflateInit2(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY);\n        };\n        var deflate = function deflate(strm, flush) {\n            var beg;\n            var val; // for gzip header write only\n            if (!strm || !strm.state || flush > Z_BLOCK || flush < 0) {\n                return strm ? err(strm, Z_STREAM_ERROR) : Z_STREAM_ERROR;\n            }\n            var s = strm.state;\n            if (!strm.output || (!strm.input && strm.avail_in !== 0) || (s.status === FINISH_STATE && flush !== Z_FINISH)) {\n                return err(strm, strm.avail_out === 0 ? Z_BUF_ERROR : Z_STREAM_ERROR);\n            }\n            s.strm = strm;\n            /* just in case */\n            var old_flush = s.last_flush;\n            s.last_flush = flush;\n            /* Write the header */\n            if (s.status === INIT_STATE) {\n                if (s.wrap === 2) {\n                    // GZIP header\n                    strm.adler = 0; // crc32(0L, Z_NULL, 0);\n                    put_byte(s, 31);\n                    put_byte(s, 139);\n                    put_byte(s, 8);\n                    if (!s.gzhead) {\n                        // s->gzhead == Z_NULL\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, 0);\n                        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n                        put_byte(s, OS_CODE);\n                        s.status = BUSY_STATE;\n                    }\n                    else {\n                        put_byte(s, (s.gzhead.text ? 1 : 0) +\n                            (s.gzhead.hcrc ? 2 : 0) +\n                            (!s.gzhead.extra ? 0 : 4) +\n                            (!s.gzhead.name ? 0 : 8) +\n                            (!s.gzhead.comment ? 0 : 16));\n                        put_byte(s, s.gzhead.time & 0xff);\n                        put_byte(s, (s.gzhead.time >> 8) & 0xff);\n                        put_byte(s, (s.gzhead.time >> 16) & 0xff);\n                        put_byte(s, (s.gzhead.time >> 24) & 0xff);\n                        put_byte(s, s.level === 9 ? 2 : s.strategy >= Z_HUFFMAN_ONLY || s.level < 2 ? 4 : 0);\n                        put_byte(s, s.gzhead.os & 0xff);\n                        if (s.gzhead.extra && s.gzhead.extra.length) {\n                            put_byte(s, s.gzhead.extra.length & 0xff);\n                            put_byte(s, (s.gzhead.extra.length >> 8) & 0xff);\n                        }\n                        if (s.gzhead.hcrc) {\n                            strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending, 0);\n                        }\n                        s.gzindex = 0;\n                        s.status = EXTRA_STATE;\n                    }\n                } // DEFLATE header\n                else {\n                    var header = (Z_DEFLATED + ((s.w_bits - 8) << 4)) << 8;\n                    var level_flags = -1;\n                    if (s.strategy >= Z_HUFFMAN_ONLY || s.level < 2) {\n                        level_flags = 0;\n                    }\n                    else if (s.level < 6) {\n                        level_flags = 1;\n                    }\n                    else if (s.level === 6) {\n                        level_flags = 2;\n                    }\n                    else {\n                        level_flags = 3;\n                    }\n                    header |= level_flags << 6;\n                    if (s.strstart !== 0) {\n                        header |= PRESET_DICT;\n                    }\n                    header += 31 - (header % 31);\n                    s.status = BUSY_STATE;\n                    putShortMSB(s, header);\n                    /* Save the adler32 of the preset dictionary: */\n                    if (s.strstart !== 0) {\n                        putShortMSB(s, strm.adler >>> 16);\n                        putShortMSB(s, strm.adler & 0xffff);\n                    }\n                    strm.adler = 1; // adler32(0L, Z_NULL, 0);\n                }\n            } // #ifdef GZIP\n            if (s.status === EXTRA_STATE) {\n                if (s.gzhead.extra\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    while (s.gzindex < (s.gzhead.extra.length & 0xffff)) {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                break;\n                            }\n                        }\n                        put_byte(s, s.gzhead.extra[s.gzindex] & 0xff);\n                        s.gzindex++;\n                    }\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (s.gzindex === s.gzhead.extra.length) {\n                        s.gzindex = 0;\n                        s.status = NAME_STATE;\n                    }\n                }\n                else {\n                    s.status = NAME_STATE;\n                }\n            }\n            if (s.status === NAME_STATE) {\n                if (s.gzhead.name\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    // int val;\n                    do {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                val = 1;\n                                break;\n                            }\n                        } // JS specific: little magic to add zero terminator to end of string\n                        if (s.gzindex < s.gzhead.name.length) {\n                            val = s.gzhead.name.charCodeAt(s.gzindex++) & 0xff;\n                        }\n                        else {\n                            val = 0;\n                        }\n                        put_byte(s, val);\n                    } while (val !== 0);\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (val === 0) {\n                        s.gzindex = 0;\n                        s.status = COMMENT_STATE;\n                    }\n                }\n                else {\n                    s.status = COMMENT_STATE;\n                }\n            }\n            if (s.status === COMMENT_STATE) {\n                if (s.gzhead.comment\n                /* != Z_NULL */\n                ) {\n                    beg = s.pending;\n                    /* start of bytes to update crc */\n                    // int val;\n                    do {\n                        if (s.pending === s.pending_buf_size) {\n                            if (s.gzhead.hcrc && s.pending > beg) {\n                                strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                            }\n                            flush_pending(strm);\n                            beg = s.pending;\n                            if (s.pending === s.pending_buf_size) {\n                                val = 1;\n                                break;\n                            }\n                        } // JS specific: little magic to add zero terminator to end of string\n                        if (s.gzindex < s.gzhead.comment.length) {\n                            val = s.gzhead.comment.charCodeAt(s.gzindex++) & 0xff;\n                        }\n                        else {\n                            val = 0;\n                        }\n                        put_byte(s, val);\n                    } while (val !== 0);\n                    if (s.gzhead.hcrc && s.pending > beg) {\n                        strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);\n                    }\n                    if (val === 0) {\n                        s.status = HCRC_STATE;\n                    }\n                }\n                else {\n                    s.status = HCRC_STATE;\n                }\n            }\n            if (s.status === HCRC_STATE) {\n                if (s.gzhead.hcrc) {\n                    if (s.pending + 2 > s.pending_buf_size) {\n                        flush_pending(strm);\n                    }\n                    if (s.pending + 2 <= s.pending_buf_size) {\n                        put_byte(s, strm.adler & 0xff);\n                        put_byte(s, (strm.adler >> 8) & 0xff);\n                        strm.adler = 0; // crc32(0L, Z_NULL, 0);\n                        s.status = BUSY_STATE;\n                    }\n                }\n                else {\n                    s.status = BUSY_STATE;\n                }\n            } // #endif\n            /* Flush as much pending output as possible */\n            if (s.pending !== 0) {\n                flush_pending(strm);\n                if (strm.avail_out === 0) {\n                    /* Since avail_out is 0, deflate will be called again with\n                     * more output space, but possibly with both pending and\n                     * avail_in equal to zero. There won't be anything to do,\n                     * but this is not an error situation so make sure we\n                     * return OK instead of BUF_ERROR at next call of deflate:\n                     */\n                    s.last_flush = -1;\n                    return Z_OK;\n                }\n                /* Make sure there is something to do and avoid duplicate consecutive\n                 * flushes. For repeated and useless calls with Z_FINISH, we keep\n                 * returning Z_STREAM_END instead of Z_BUF_ERROR.\n                 */\n            }\n            else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) && flush !== Z_FINISH) {\n                return err(strm, Z_BUF_ERROR);\n            }\n            /* User must not provide more input after the first FINISH: */\n            if (s.status === FINISH_STATE && strm.avail_in !== 0) {\n                return err(strm, Z_BUF_ERROR);\n            }\n            /* Start a new block or continue the current one.\n             */\n            if (strm.avail_in !== 0 || s.lookahead !== 0 || (flush !== Z_NO_FLUSH && s.status !== FINISH_STATE)) {\n                var bstate = s.strategy === Z_HUFFMAN_ONLY\n                    ? deflate_huff(s, flush)\n                    : s.strategy === Z_RLE\n                        ? deflate_rle(s, flush)\n                        : configuration_table[s.level].func(s, flush);\n                if (bstate === BS_FINISH_STARTED || bstate === BS_FINISH_DONE) {\n                    s.status = FINISH_STATE;\n                }\n                if (bstate === BS_NEED_MORE || bstate === BS_FINISH_STARTED) {\n                    if (strm.avail_out === 0) {\n                        s.last_flush = -1;\n                        /* avoid BUF_ERROR next call, see above */\n                    }\n                    return Z_OK;\n                    /* If flush != Z_NO_FLUSH && avail_out == 0, the next call\n                     * of deflate should use the same flush parameter to make sure\n                     * that the flush is complete. So we don't have to output an\n                     * empty block here, this will be done at next call. This also\n                     * ensures that for a very small output buffer, we emit at most\n                     * one empty block.\n                     */\n                }\n                if (bstate === BS_BLOCK_DONE) {\n                    if (flush === Z_PARTIAL_FLUSH) {\n                        _tr_align$1(s);\n                    }\n                    else if (flush !== Z_BLOCK) {\n                        /* FULL_FLUSH or SYNC_FLUSH */\n                        _tr_stored_block$1(s, 0, 0, false);\n                        /* For a full flush, this empty block will be recognized\n                         * as a special marker by inflate_sync().\n                         */\n                        if (flush === Z_FULL_FLUSH) {\n                            /** * CLEAR_HASH(s); ** */\n                            /* forget history */\n                            zero$1(s.head); // Fill with NIL (= 0);\n                            if (s.lookahead === 0) {\n                                s.strstart = 0;\n                                s.block_start = 0;\n                                s.insert = 0;\n                            }\n                        }\n                    }\n                    flush_pending(strm);\n                    if (strm.avail_out === 0) {\n                        s.last_flush = -1;\n                        /* avoid BUF_ERROR at next call, see above */\n                        return Z_OK;\n                    }\n                }\n            } // Assert(strm->avail_out > 0, \"bug2\");\n            // if (strm.avail_out <= 0) { throw new Error(\"bug2\");}\n            if (flush !== Z_FINISH) {\n                return Z_OK;\n            }\n            if (s.wrap <= 0) {\n                return Z_STREAM_END;\n            }\n            /* Write the trailer */\n            if (s.wrap === 2) {\n                put_byte(s, strm.adler & 0xff);\n                put_byte(s, (strm.adler >> 8) & 0xff);\n                put_byte(s, (strm.adler >> 16) & 0xff);\n                put_byte(s, (strm.adler >> 24) & 0xff);\n                put_byte(s, strm.total_in & 0xff);\n                put_byte(s, (strm.total_in >> 8) & 0xff);\n                put_byte(s, (strm.total_in >> 16) & 0xff);\n                put_byte(s, (strm.total_in >> 24) & 0xff);\n            }\n            else {\n                putShortMSB(s, strm.adler >>> 16);\n                putShortMSB(s, strm.adler & 0xffff);\n            }\n            flush_pending(strm);\n            /* If avail_out is zero, the application will call deflate again\n             * to flush the rest.\n             */\n            if (s.wrap > 0) {\n                s.wrap = -s.wrap;\n            }\n            /* write the trailer only once! */\n            return s.pending !== 0 ? Z_OK : Z_STREAM_END;\n        };\n        var deflateEnd = function deflateEnd(strm) {\n            if (!strm ||\n                /* == Z_NULL */\n                !strm.state\n            /* == Z_NULL */\n            ) {\n                return Z_STREAM_ERROR;\n            }\n            var status = strm.state.status;\n            if (status !== INIT_STATE &&\n                status !== EXTRA_STATE &&\n                status !== NAME_STATE &&\n                status !== COMMENT_STATE &&\n                status !== HCRC_STATE &&\n                status !== BUSY_STATE &&\n                status !== FINISH_STATE) {\n                return err(strm, Z_STREAM_ERROR);\n            }\n            strm.state = null;\n            return status === BUSY_STATE ? err(strm, Z_DATA_ERROR) : Z_OK;\n        };\n        /* =========================================================================\n         * Initializes the compression dictionary from the given byte\n         * sequence without producing any compressed output.\n         */\n        var deflateSetDictionary = function deflateSetDictionary(strm, dictionary) {\n            var dictLength = dictionary.length;\n            if (!strm ||\n                /* == Z_NULL */\n                !strm.state\n            /* == Z_NULL */\n            ) {\n                return Z_STREAM_ERROR;\n            }\n            var s = strm.state;\n            var wrap = s.wrap;\n            if (wrap === 2 || (wrap === 1 && s.status !== INIT_STATE) || s.lookahead) {\n                return Z_STREAM_ERROR;\n            }\n            /* when using zlib wrappers, compute Adler-32 for provided dictionary */\n            if (wrap === 1) {\n                /* adler32(strm->adler, dictionary, dictLength); */\n                strm.adler = adler32_1(strm.adler, dictionary, dictLength, 0);\n            }\n            s.wrap = 0;\n            /* avoid computing Adler-32 in read_buf */\n            /* if dictionary would fill window, just replace the history */\n            if (dictLength >= s.w_size) {\n                if (wrap === 0) {\n                    /* already empty otherwise */\n                    /** * CLEAR_HASH(s); ** */\n                    zero$1(s.head); // Fill with NIL (= 0);\n                    s.strstart = 0;\n                    s.block_start = 0;\n                    s.insert = 0;\n                }\n                /* use the tail */\n                // dictionary = dictionary.slice(dictLength - s.w_size);\n                var tmpDict = new Uint8Array(s.w_size);\n                tmpDict.set(dictionary.subarray(dictLength - s.w_size, dictLength), 0);\n                dictionary = tmpDict;\n                dictLength = s.w_size;\n            }\n            /* insert dictionary into window and hash */\n            var avail = strm.avail_in;\n            var next = strm.next_in;\n            var input = strm.input;\n            strm.avail_in = dictLength;\n            strm.next_in = 0;\n            strm.input = dictionary;\n            fill_window(s);\n            while (s.lookahead >= MIN_MATCH$1) {\n                var str = s.strstart;\n                var n = s.lookahead - (MIN_MATCH$1 - 1);\n                do {\n                    /* UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); */\n                    s.ins_h = HASH(s, s.ins_h, s.window[str + MIN_MATCH$1 - 1]);\n                    s.prev[str & s.w_mask] = s.head[s.ins_h];\n                    s.head[s.ins_h] = str;\n                    str++;\n                } while (--n);\n                s.strstart = str;\n                s.lookahead = MIN_MATCH$1 - 1;\n                fill_window(s);\n            }\n            s.strstart += s.lookahead;\n            s.block_start = s.strstart;\n            s.insert = s.lookahead;\n            s.lookahead = 0;\n            s.match_length = s.prev_length = MIN_MATCH$1 - 1;\n            s.match_available = 0;\n            strm.next_in = next;\n            strm.input = input;\n            strm.avail_in = avail;\n            s.wrap = wrap;\n            return Z_OK;\n        };\n        var deflateInit_1 = deflateInit;\n        var deflateInit2_1 = deflateInit2;\n        var deflateReset_1 = deflateReset;\n        var deflateResetKeep_1 = deflateResetKeep;\n        var deflateSetHeader_1 = deflateSetHeader;\n        var deflate_2 = deflate;\n        var deflateEnd_1 = deflateEnd;\n        var deflateSetDictionary_1 = deflateSetDictionary;\n        var deflateInfo = 'pako deflate (from Nodeca project)';\n        /* Not implemented\n      module.exports.deflateBound = deflateBound;\n      module.exports.deflateCopy = deflateCopy;\n      module.exports.deflateParams = deflateParams;\n      module.exports.deflatePending = deflatePending;\n      module.exports.deflatePrime = deflatePrime;\n      module.exports.deflateTune = deflateTune;\n      */\n        var deflate_1 = {\n            deflateInit: deflateInit_1,\n            deflateInit2: deflateInit2_1,\n            deflateReset: deflateReset_1,\n            deflateResetKeep: deflateResetKeep_1,\n            deflateSetHeader: deflateSetHeader_1,\n            deflate: deflate_2,\n            deflateEnd: deflateEnd_1,\n            deflateSetDictionary: deflateSetDictionary_1,\n            deflateInfo: deflateInfo,\n        };\n        // Join array of chunks to single array.\n        function flattenChunks(chunks) {\n            // calculate data length\n            var len = 0;\n            for (var i = 0, l = chunks.length; i < l; i++) {\n                len += chunks[i].length;\n            } // join chunks\n            var result = new Uint8Array(len);\n            for (var _i = 0, pos = 0, _l = chunks.length; _i < _l; _i++) {\n                var chunk = chunks[_i];\n                result.set(chunk, pos);\n                pos += chunk.length;\n            }\n            return result;\n        }\n        // String encode/decode helpers\n        //\n        // - apply(Array) can fail on Android 2.2\n        // - apply(Uint8Array) can fail on iOS 5.1 Safari\n        //\n        // Table with utf8 lengths (calculated by first byte of sequence)\n        // Note, that 5 & 6-byte values and some 4-byte values can not be represented in JS,\n        // because max possible codepoint is 0x10ffff\n        var _utf8len = new Uint8Array(256);\n        for (var q = 0; q < 256; q++) {\n            _utf8len[q] = q >= 252 ? 6 : q >= 248 ? 5 : q >= 240 ? 4 : q >= 224 ? 3 : q >= 192 ? 2 : 1;\n        }\n        _utf8len[254] = _utf8len[254] = 1; // Invalid sequence start\n        // convert string to array (typed, when possible)\n        // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin\n        //\n        // This software is provided 'as-is', without any express or implied\n        // warranty. In no event will the authors be held liable for any damages\n        // arising from the use of this software.\n        //\n        // Permission is granted to anyone to use this software for any purpose,\n        // including commercial applications, and to alter it and redistribute it\n        // freely, subject to the following restrictions:\n        //\n        // 1. The origin of this software must not be misrepresented; you must not\n        //   claim that you wrote the original software. If you use this software\n        //   in a product, an acknowledgment in the product documentation would be\n        //   appreciated but is not required.\n        // 2. Altered source versions must be plainly marked as such, and must not be\n        //   misrepresented as being the original software.\n        // 3. This notice may not be removed or altered from any source distribution.\n        function ZStream() {\n            /* next input byte */\n            this.input = null; // JS specific, because we have no pointers\n            this.next_in = 0;\n            /* number of bytes available at input */\n            this.avail_in = 0;\n            /* total number of input bytes read so far */\n            this.total_in = 0;\n            /* next output byte should be put there */\n            this.output = null; // JS specific, because we have no pointers\n            this.next_out = 0;\n            /* remaining free space at output */\n            this.avail_out = 0;\n            /* total number of bytes output so far */\n            this.total_out = 0;\n            /* last error message, NULL if no error */\n            this.msg = '';\n            /* Z_NULL */\n            /* not visible by applications */\n            this.state = null;\n            /* best guess about the data type: binary or text */\n            this.data_type = 2;\n            /* Z_UNKNOWN */\n            /* adler32 value of the uncompressed data */\n            this.adler = 0;\n        }\n        var zstream = ZStream;\n        // eslint-disable-next-line @typescript-eslint/unbound-method\n        var toString = Object.prototype.toString;\n        /* Public constants ========================================================== */\n        /* =========================================================================== */\n        var Z_NO_FLUSH$1 = constants.Z_NO_FLUSH;\n        var Z_SYNC_FLUSH = constants.Z_SYNC_FLUSH;\n        var Z_FULL_FLUSH$1 = constants.Z_FULL_FLUSH;\n        var Z_FINISH$1 = constants.Z_FINISH;\n        var Z_OK$1 = constants.Z_OK;\n        var Z_STREAM_END$1 = constants.Z_STREAM_END;\n        var Z_DEFAULT_COMPRESSION$1 = constants.Z_DEFAULT_COMPRESSION;\n        var Z_DEFAULT_STRATEGY$1 = constants.Z_DEFAULT_STRATEGY;\n        var Z_DEFLATED$1 = constants.Z_DEFLATED;\n        /* =========================================================================== */\n        /**\n         * class Deflate\n         *\n         * Generic JS-style wrapper for zlib calls. If you don't need\n         * streaming behaviour - use more simple functions: [[deflate]],\n         * [[deflateRaw]] and [[gzip]].\n         * */\n        /* internal\n         * Deflate.chunks -> Array\n         *\n         * Chunks of output data, if [[Deflate#onData]] not overridden.\n         * */\n        /**\n         * Deflate.result -> Uint8Array\n         *\n         * Compressed result, generated by default [[Deflate#onData]]\n         * and [[Deflate#onEnd]] handlers. Filled after you push last chunk\n         * (call [[Deflate#push]] with `Z_FINISH` / `true` param).\n         * */\n        /**\n         * Deflate.err -> Number\n         *\n         * Error code after deflate finished. 0 (Z_OK) on success.\n         * You will not need it in real life, because deflate errors\n         * are possible only on wrong options or bad `onData` / `onEnd`\n         * custom handlers.\n         * */\n        /**\n         * Deflate.msg -> String\n         *\n         * Error message, if [[Deflate.err]] != 0\n         * */\n        /**\n         * new Deflate(options)\n         * - options (Object): zlib deflate options.\n         *\n         * Creates new deflator instance with specified params. Throws exception\n         * on bad params. Supported options:\n         *\n         * - `level`\n         * - `windowBits`\n         * - `memLevel`\n         * - `strategy`\n         * - `dictionary`\n         *\n         * [http://zlib.net/manual.html#Advanced](http://zlib.net/manual.html#Advanced)\n         * for more information on these.\n         *\n         * Additional options, for internal needs:\n         *\n         * * `chunkSize` - size of generated data chunks (16K by default)\n         * * `raw` (Boolean) - do raw deflate\n         * * `gzip` (Boolean) - create gzip wrapper\n         * * `header` (Object) - custom header for gzip\n         * ** `text` (Boolean) - true if compressed data believed to be text\n         * ** `time` (Number) - modification time, unix timestamp\n         * ** `os` (Number) - operation system code\n         * ** `extra` (Array) - array of bytes with extra data (max 65536)\n         * ** `name` (String) - file name (binary string)\n         * ** `comment` (String) - comment (binary string)\n         * ** `hcrc` (Boolean) - true if header crc should be added\n         *\n         * ##### Example:\n         *\n         * ```javascript\n         * const pako = require('pako')\n         *   , chunk1 = new Uint8Array([1,2,3,4,5,6,7,8,9])\n         *   , chunk2 = new Uint8Array([10,11,12,13,14,15,16,17,18,19]);\n         *\n         * const deflate = new pako.Deflate({ level: 3});\n         *\n         * deflate.push(chunk1, false);\n         * deflate.push(chunk2, true);  // true -> last chunk\n         *\n         * if (deflate.err) { throw new Error(deflate.err); }\n         *\n         * console.log(deflate.result);\n         * ```\n         * */\n        function Deflate() {\n            this.options = {\n                level: Z_DEFAULT_COMPRESSION$1,\n                method: Z_DEFLATED$1,\n                chunkSize: 16384,\n                windowBits: 15,\n                memLevel: 8,\n                strategy: Z_DEFAULT_STRATEGY$1,\n            };\n            var opt = this.options;\n            if (opt.raw && opt.windowBits > 0) {\n                opt.windowBits = -opt.windowBits;\n            }\n            else if (opt.gzip && opt.windowBits > 0 && opt.windowBits < 16) {\n                opt.windowBits += 16;\n            }\n            this.err = 0; // error code, if happens (0 = Z_OK)\n            this.msg = ''; // error message\n            this.ended = false; // used to avoid multiple onEnd() calls\n            this.chunks = []; // chunks of compressed data\n            this.strm = new zstream();\n            this.strm.avail_out = 0;\n            var status = deflate_1.deflateInit2(this.strm, opt.level, opt.method, opt.windowBits, opt.memLevel, opt.strategy);\n            if (status !== Z_OK$1) {\n                throw new Error(messages[status]);\n            }\n            if (opt.header) {\n                deflate_1.deflateSetHeader(this.strm, opt.header);\n            }\n            if (opt.dictionary) {\n                var dict; // Convert data if needed\n                if (toString.call(opt.dictionary) === '[object ArrayBuffer]') {\n                    dict = new Uint8Array(opt.dictionary);\n                }\n                else {\n                    dict = opt.dictionary;\n                }\n                status = deflate_1.deflateSetDictionary(this.strm, dict);\n                if (status !== Z_OK$1) {\n                    throw new Error(messages[status]);\n                }\n                this._dict_set = true;\n            }\n        }\n        /**\n         * Deflate#push(data[, flush_mode]) -> Boolean\n         * - data (Uint8Array|ArrayBuffer|String): input data. Strings will be\n         * converted to utf8 byte sequence.\n         * - flush_mode (Number|Boolean): 0..6 for corresponding Z_NO_FLUSH..Z_TREE modes.\n         * See constants. Skipped or `false` means Z_NO_FLUSH, `true` means Z_FINISH.\n         *\n         * Sends input data to deflate pipe, generating [[Deflate#onData]] calls with\n         * new compressed chunks. Returns `true` on success. The last data block must\n         * have `flush_mode` Z_FINISH (or `true`). That will flush internal pending\n         * buffers and call [[Deflate#onEnd]].\n         *\n         * On fail call [[Deflate#onEnd]] with error code and return false.\n         *\n         * ##### Example\n         *\n         * ```javascript\n         * push(chunk, false); // push one of data chunks\n         * ...\n         * push(chunk, true);  // push last chunk\n         * ```\n         * */\n        Deflate.prototype.push = function (data, flush_mode) {\n            var strm = this.strm;\n            var chunkSize = this.options.chunkSize;\n            var status;\n            var _flush_mode;\n            if (this.ended) {\n                return false;\n            }\n            if (flush_mode === ~~flush_mode) {\n                _flush_mode = flush_mode;\n            }\n            else {\n                _flush_mode = flush_mode === true ? Z_FINISH$1 : Z_NO_FLUSH$1;\n            } // Convert data if needed\n            if (toString.call(data) === '[object ArrayBuffer]') {\n                strm.input = new Uint8Array(data);\n            }\n            else {\n                strm.input = data;\n            }\n            strm.next_in = 0;\n            strm.avail_in = strm.input.length;\n            for (;;) {\n                if (strm.avail_out === 0) {\n                    strm.output = new Uint8Array(chunkSize);\n                    strm.next_out = 0;\n                    strm.avail_out = chunkSize;\n                } // Make sure avail_out > 6 to avoid repeating markers\n                if ((_flush_mode === Z_SYNC_FLUSH || _flush_mode === Z_FULL_FLUSH$1) && strm.avail_out <= 6) {\n                    this.onData(strm.output.subarray(0, strm.next_out));\n                    strm.avail_out = 0;\n                    continue;\n                }\n                status = deflate_1.deflate(strm, _flush_mode); // Ended => flush and finish\n                if (status === Z_STREAM_END$1) {\n                    if (strm.next_out > 0) {\n                        this.onData(strm.output.subarray(0, strm.next_out));\n                    }\n                    status = deflate_1.deflateEnd(this.strm);\n                    this.onEnd(status);\n                    this.ended = true;\n                    return status === Z_OK$1;\n                } // Flush if out buffer full\n                if (strm.avail_out === 0) {\n                    this.onData(strm.output);\n                    continue;\n                } // Flush if requested and has data\n                if (_flush_mode > 0 && strm.next_out > 0) {\n                    this.onData(strm.output.subarray(0, strm.next_out));\n                    strm.avail_out = 0;\n                    continue;\n                }\n                if (strm.avail_in === 0) {\n                    break;\n                }\n            }\n            return true;\n        };\n        /**\n         * Deflate#onData(chunk) -> Void\n         * - chunk (Uint8Array): output data.\n         *\n         * By default, stores data blocks in `chunks[]` property and glue\n         * those in `onEnd`. Override this handler, if you need another behaviour.\n         * */\n        Deflate.prototype.onData = function (chunk) {\n            this.chunks.push(chunk);\n        };\n        /**\n         * Deflate#onEnd(status) -> Void\n         * - status (Number): deflate status. 0 (Z_OK) on success,\n         * other if not.\n         *\n         * Called once after you tell deflate that the input stream is\n         * complete (Z_FINISH). By default - join collected chunks,\n         * free memory and fill `results` / `err` properties.\n         * */\n        Deflate.prototype.onEnd = function (status) {\n            // On success - join\n            if (status === Z_OK$1) {\n                this.result = flattenChunks(this.chunks);\n            }\n            this.chunks = [];\n            this.err = status;\n            this.msg = this.strm.msg;\n        };\n        // https://github.com/nodeca/pako/blob/26dff4fb3472c5532b3bd8856421146d35ab7592/lib/utils/strings.js#L26\n        function string2buf(str) {\n            if (typeof TextEncoder === 'function' && TextEncoder.prototype.encode) {\n                return new TextEncoder().encode(str);\n            }\n            var buf;\n            var c;\n            var c2;\n            var m_pos;\n            var i;\n            var str_len = str.length;\n            var buf_len = 0;\n            // count binary size\n            for (m_pos = 0; m_pos < str_len; m_pos++) {\n                c = str.charCodeAt(m_pos);\n                if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n                    c2 = str.charCodeAt(m_pos + 1);\n                    if ((c2 & 0xfc00) === 0xdc00) {\n                        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n                        m_pos++;\n                    }\n                }\n                buf_len += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;\n            }\n            // allocate buffer\n            buf = new Uint8Array(buf_len);\n            // convert\n            for (i = 0, m_pos = 0; i < buf_len; m_pos++) {\n                c = str.charCodeAt(m_pos);\n                if ((c & 0xfc00) === 0xd800 && m_pos + 1 < str_len) {\n                    c2 = str.charCodeAt(m_pos + 1);\n                    if ((c2 & 0xfc00) === 0xdc00) {\n                        c = 0x10000 + ((c - 0xd800) << 10) + (c2 - 0xdc00);\n                        m_pos++;\n                    }\n                }\n                if (c < 0x80) {\n                    /* one byte */\n                    buf[i++] = c;\n                }\n                else if (c < 0x800) {\n                    /* two bytes */\n                    buf[i++] = 0xc0 | (c >>> 6);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n                else if (c < 0x10000) {\n                    /* three bytes */\n                    buf[i++] = 0xe0 | (c >>> 12);\n                    buf[i++] = 0x80 | ((c >>> 6) & 0x3f);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n                else {\n                    /* four bytes */\n                    buf[i++] = 0xf0 | (c >>> 18);\n                    buf[i++] = 0x80 | ((c >>> 12) & 0x3f);\n                    buf[i++] = 0x80 | ((c >>> 6) & 0x3f);\n                    buf[i++] = 0x80 | (c & 0x3f);\n                }\n            }\n            return buf;\n        }\n        return { Deflate: Deflate, constants: constants, string2buf: string2buf };\n    }\n}\n//# sourceMappingURL=deflateWorker.js.map","import { addEventListener, monitor } from '@datadog/browser-core';\nimport { SEND_BEACON_BYTE_LENGTH_LIMIT } from '../../transport/send';\nimport { Segment } from './segment';\nexport var MAX_SEGMENT_DURATION = 30000;\nvar MAX_SEGMENT_SIZE = SEND_BEACON_BYTE_LENGTH_LIMIT;\n// Segments are the main data structure for session replays. They contain context information used\n// for indexing or UI needs, and a list of records (RRWeb 'events', renamed to avoid confusing\n// namings). They are stored without any processing from the intake, and fetched one after the\n// other while a session is being replayed. Their encoding (deflate) are carefully crafted to allow\n// concatenating multiple segments together. Segments have a size overhead (metadata), so our goal is to\n// build segments containing as much records as possible while complying with the various flush\n// strategies to guarantee a good replay quality.\n//\n// When the recording starts, a segment is initially created.  The segment is flushed (finalized and\n// sent) based on various events (non-exhaustive list):\n//\n// * the page visibility change or becomes to unload\n// * the segment duration reaches a limit\n// * the encoded segment size reaches a limit\n// * ...\n//\n// A segment cannot be created without its context.  If the RUM session ends and no session id is\n// available when creating a new segment, records will be ignored, until the session is renewed and\n// a new session id is available.\n//\n// Empty segments (segments with no record) aren't useful and should be ignored.\n//\n// To help investigate session replays issues, each segment is created with a \"creation reason\",\n// indicating why the session has been created.\nexport function startSegmentCollection(lifeCycle, applicationId, sessionManager, viewContexts, send, worker) {\n    return doStartSegmentCollection(lifeCycle, function () { return computeSegmentContext(applicationId, sessionManager, viewContexts); }, send, worker);\n}\nexport function doStartSegmentCollection(lifeCycle, getSegmentContext, send, worker, emitter) {\n    if (emitter === void 0) { emitter = window; }\n    var state = {\n        status: 0 /* WaitingForInitialRecord */,\n        nextSegmentCreationReason: 'init',\n    };\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* VIEW_CREATED */, function () {\n        flushSegment('view_change');\n    }).unsubscribe;\n    var unsubscribeBeforeUnload = lifeCycle.subscribe(9 /* BEFORE_UNLOAD */, function () {\n        flushSegment('before_unload');\n    }).unsubscribe;\n    var unsubscribeVisibilityChange = addEventListener(emitter, \"visibilitychange\" /* VISIBILITY_CHANGE */, function () {\n        if (document.visibilityState === 'hidden') {\n            flushSegment('visibility_hidden');\n        }\n    }, { capture: true }).stop;\n    function flushSegment(nextSegmentCreationReason) {\n        if (state.status === 1 /* SegmentPending */) {\n            state.segment.flush(nextSegmentCreationReason || 'sdk_stopped');\n            clearTimeout(state.expirationTimeoutId);\n        }\n        if (nextSegmentCreationReason) {\n            state = {\n                status: 0 /* WaitingForInitialRecord */,\n                nextSegmentCreationReason: nextSegmentCreationReason,\n            };\n        }\n        else {\n            state = {\n                status: 2 /* Stopped */,\n            };\n        }\n    }\n    function createNewSegment(creationReason, initialRecord) {\n        var context = getSegmentContext();\n        if (!context) {\n            return;\n        }\n        var segment = new Segment(worker, context, creationReason, initialRecord, function (compressedSegmentSize) {\n            if (!segment.isFlushed && compressedSegmentSize > MAX_SEGMENT_SIZE) {\n                flushSegment('max_size');\n            }\n        }, function (data, rawSegmentSize) {\n            send(data, segment.metadata, rawSegmentSize, segment.flushReason);\n        });\n        state = {\n            status: 1 /* SegmentPending */,\n            segment: segment,\n            expirationTimeoutId: setTimeout(monitor(function () {\n                flushSegment('max_duration');\n            }), MAX_SEGMENT_DURATION),\n        };\n    }\n    return {\n        addRecord: function (record) {\n            switch (state.status) {\n                case 0 /* WaitingForInitialRecord */:\n                    createNewSegment(state.nextSegmentCreationReason, record);\n                    break;\n                case 1 /* SegmentPending */:\n                    state.segment.addRecord(record);\n                    break;\n            }\n        },\n        stop: function () {\n            flushSegment();\n            unsubscribeViewCreated();\n            unsubscribeBeforeUnload();\n            unsubscribeVisibilityChange();\n        },\n    };\n}\nexport function computeSegmentContext(applicationId, sessionManager, viewContexts) {\n    var session = sessionManager.findTrackedSession();\n    var viewContext = viewContexts.findView();\n    if (!session || !viewContext) {\n        return undefined;\n    }\n    return {\n        application: {\n            id: applicationId,\n        },\n        session: {\n            id: session.id,\n        },\n        view: {\n            id: viewContext.view.id,\n        },\n    };\n}\nexport function setMaxSegmentSize(newSize) {\n    if (newSize === void 0) { newSize = SEND_BEACON_BYTE_LENGTH_LIMIT; }\n    MAX_SEGMENT_SIZE = newSize;\n}\n//# sourceMappingURL=segmentCollection.js.map","import { addMonitoringError, display, includes, monitor } from '@datadog/browser-core';\nimport { createDeflateWorker } from './deflateWorker';\nvar state = { status: 0 /* Nil */ };\nexport function startDeflateWorker(callback, createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    switch (state.status) {\n        case 0 /* Nil */:\n            state = { status: 1 /* Loading */, callbacks: [callback] };\n            doStartDeflateWorker(createDeflateWorkerImpl);\n            break;\n        case 1 /* Loading */:\n            state.callbacks.push(callback);\n            break;\n        case 2 /* Error */:\n            callback();\n            break;\n        case 3 /* Initialized */:\n            callback(state.worker);\n            break;\n    }\n}\nexport function resetDeflateWorkerState() {\n    state = { status: 0 /* Nil */ };\n}\n/**\n * Starts the deflate worker and handle messages and errors\n *\n * The spec allow browsers to handle worker errors differently:\n * - Chromium throws an exception\n * - Firefox fires an error event\n *\n * more details: https://bugzilla.mozilla.org/show_bug.cgi?id=1736865#c2\n */\nexport function doStartDeflateWorker(createDeflateWorkerImpl) {\n    if (createDeflateWorkerImpl === void 0) { createDeflateWorkerImpl = createDeflateWorker; }\n    try {\n        var worker_1 = createDeflateWorkerImpl();\n        worker_1.addEventListener('error', monitor(onError));\n        worker_1.addEventListener('message', monitor(function (_a) {\n            var data = _a.data;\n            if (data.type === 'errored') {\n                onError(data.error);\n            }\n            else if (data.type === 'initialized') {\n                onInitialized(worker_1);\n            }\n        }));\n        worker_1.postMessage({ action: 'init' });\n        return worker_1;\n    }\n    catch (error) {\n        onError(error);\n    }\n}\nfunction onInitialized(worker) {\n    if (state.status === 1 /* Loading */) {\n        state.callbacks.forEach(function (callback) { return callback(worker); });\n        state = { status: 3 /* Initialized */, worker: worker };\n    }\n}\nfunction onError(error) {\n    if (state.status === 1 /* Loading */) {\n        display.error('Session Replay recording failed to start: an error occurred while creating the Worker:', error);\n        if (error instanceof Event || (error instanceof Error && includes(error.message, 'Content Security Policy'))) {\n            display.error('Please make sure CSP is correctly configured ' +\n                'https://docs.datadoghq.com/real_user_monitoring/faq/content_security_policy');\n        }\n        else {\n            addMonitoringError(error);\n        }\n        state.callbacks.forEach(function (callback) { return callback(); });\n        state = { status: 2 /* Error */ };\n    }\n    else {\n        addMonitoringError(error);\n    }\n}\n//# sourceMappingURL=startDeflateWorker.js.map","// Keep the following in sync with packages/rum-slim/src/entries/main.ts\nimport { defineGlobal, getGlobalObject } from '@datadog/browser-core';\nimport { makeRumPublicApi, startRum } from '@datadog/browser-rum-core';\nimport { startRecording } from '../boot/startRecording';\nimport { makeRecorderApi } from '../boot/recorderApi';\nexport { DefaultPrivacyLevel } from '@datadog/browser-core';\nvar recorderApi = makeRecorderApi(startRecording);\nexport var datadogRum = makeRumPublicApi(startRum, recorderApi);\ndefineGlobal(getGlobalObject(), 'DD_RUM', datadogRum);\n//# sourceMappingURL=main.js.map","import { setDebugMode } from '../domain/internalMonitoring';\nimport { catchUserErrors } from '../tools/catchUserErrors';\nimport { assign } from '../tools/utils';\nexport function makePublicApi(stub) {\n    var publicApi = assign({\n        version: \"4.8.1\",\n        // This API method is intentionally not monitored, since the only thing executed is the\n        // user-provided 'callback'.  All SDK usages executed in the callback should be monitored, and\n        // we don't want to interfere with the user uncaught exceptions.\n        onReady: function (callback) {\n            callback();\n        },\n    }, stub);\n    // Add a \"hidden\" property to set debug mode. We define it that way to hide it\n    // as much as possible but of course it's not a real protection.\n    Object.defineProperty(publicApi, '_setDebug', {\n        get: function () {\n            return setDebugMode;\n        },\n        enumerable: false,\n    });\n    return publicApi;\n}\nexport function defineGlobal(global, name, api) {\n    var existingGlobalVariable = global[name];\n    global[name] = api;\n    if (existingGlobalVariable && existingGlobalVariable.q) {\n        existingGlobalVariable.q.forEach(function (fn) { return catchUserErrors(fn, 'onReady callback threw an error:')(); });\n    }\n}\n//# sourceMappingURL=init.js.map","import { canUseEventBridge, noop, runOnReadyState } from '@datadog/browser-core';\nimport { getReplayStats } from '../domain/replayStats';\nimport { startDeflateWorker } from '../domain/segmentCollection';\nexport function makeRecorderApi(startRecordingImpl, startDeflateWorkerImpl) {\n    if (startDeflateWorkerImpl === void 0) { startDeflateWorkerImpl = startDeflateWorker; }\n    if (canUseEventBridge()) {\n        return {\n            start: noop,\n            stop: noop,\n            getReplayStats: function () { return undefined; },\n            onRumStart: noop,\n            isRecording: function () { return false; },\n        };\n    }\n    var state = {\n        status: 0 /* Stopped */,\n    };\n    var startStrategy = function () {\n        state = { status: 1 /* IntentToStart */ };\n    };\n    var stopStrategy = function () {\n        state = { status: 0 /* Stopped */ };\n    };\n    return {\n        start: function () { return startStrategy(); },\n        stop: function () { return stopStrategy(); },\n        getReplayStats: getReplayStats,\n        onRumStart: function (lifeCycle, configuration, sessionManager, viewContexts) {\n            lifeCycle.subscribe(7 /* SESSION_EXPIRED */, function () {\n                if (state.status === 2 /* Starting */ || state.status === 3 /* Started */) {\n                    stopStrategy();\n                    state = { status: 1 /* IntentToStart */ };\n                }\n            });\n            lifeCycle.subscribe(8 /* SESSION_RENEWED */, function () {\n                if (state.status === 1 /* IntentToStart */) {\n                    startStrategy();\n                }\n            });\n            startStrategy = function () {\n                var session = sessionManager.findTrackedSession();\n                if (!session || !session.hasReplayPlan) {\n                    state = { status: 1 /* IntentToStart */ };\n                    return;\n                }\n                if (state.status === 2 /* Starting */ || state.status === 3 /* Started */) {\n                    return;\n                }\n                state = { status: 2 /* Starting */ };\n                runOnReadyState('interactive', function () {\n                    if (state.status !== 2 /* Starting */) {\n                        return;\n                    }\n                    startDeflateWorkerImpl(function (worker) {\n                        if (state.status !== 2 /* Starting */) {\n                            return;\n                        }\n                        if (!worker) {\n                            state = {\n                                status: 0 /* Stopped */,\n                            };\n                            return;\n                        }\n                        var stopRecording = startRecordingImpl(lifeCycle, configuration, sessionManager, viewContexts, worker).stop;\n                        state = {\n                            status: 3 /* Started */,\n                            stopRecording: stopRecording,\n                        };\n                    });\n                });\n            };\n            stopStrategy = function () {\n                if (state.status === 0 /* Stopped */) {\n                    return;\n                }\n                if (state.status === 3 /* Started */) {\n                    state.stopRecording();\n                }\n                state = {\n                    status: 0 /* Stopped */,\n                };\n            };\n            if (state.status === 1 /* IntentToStart */) {\n                startStrategy();\n            }\n        },\n        isRecording: function () { return state.status === 3 /* Started */; },\n    };\n}\n//# sourceMappingURL=recorderApi.js.map","import { timeStampNow } from '@datadog/browser-core';\nimport { record } from '../domain/record';\nimport { startSegmentCollection } from '../domain/segmentCollection';\nimport { send } from '../transport/send';\nimport { RecordType } from '../types';\nexport function startRecording(lifeCycle, configuration, sessionManager, viewContexts, worker) {\n    var _a = startSegmentCollection(lifeCycle, configuration.applicationId, sessionManager, viewContexts, function (data, metadata, rawSegmentSize, flushReason) {\n        return send(configuration.sessionReplayEndpointBuilder, data, metadata, rawSegmentSize, flushReason);\n    }, worker), addRecord = _a.addRecord, stopSegmentCollection = _a.stop;\n    var _b = record({\n        emit: addRecord,\n        defaultPrivacyLevel: configuration.defaultPrivacyLevel,\n    }), stopRecording = _b.stop, takeFullSnapshot = _b.takeFullSnapshot, flushMutations = _b.flushMutations;\n    var unsubscribeViewEnded = lifeCycle.subscribe(4 /* VIEW_ENDED */, function () {\n        flushMutations();\n        addRecord({\n            timestamp: timeStampNow(),\n            type: RecordType.ViewEnd,\n        });\n    }).unsubscribe;\n    var unsubscribeViewCreated = lifeCycle.subscribe(2 /* VIEW_CREATED */, function (view) {\n        takeFullSnapshot(view.startClocks.timeStamp);\n    }).unsubscribe;\n    return {\n        stop: function () {\n            unsubscribeViewEnded();\n            unsubscribeViewCreated();\n            stopRecording();\n            stopSegmentCollection();\n        },\n    };\n}\n//# sourceMappingURL=startRecording.js.map","import { assign, BoundedBuffer, buildCookieOptions, createContextManager, deepClone, makePublicApi, monitor, clocksNow, timeStampNow, display, callMonitored, createHandlingStack, canUseEventBridge, areCookiesAuthorized, } from '@datadog/browser-core';\nimport { willSyntheticsInjectRum } from '../domain/syntheticsContext';\nimport { validateAndBuildRumConfiguration } from '../domain/configuration';\nexport function makeRumPublicApi(startRumImpl, recorderApi, _a) {\n    var _b = _a === void 0 ? {} : _a, _c = _b.ignoreInitIfSyntheticsWillInjectRum, ignoreInitIfSyntheticsWillInjectRum = _c === void 0 ? true : _c;\n    var isAlreadyInitialized = false;\n    var globalContextManager = createContextManager();\n    var user = {};\n    var getInternalContextStrategy = function () { return undefined; };\n    var getInitConfigurationStrategy = function () { return undefined; };\n    var bufferApiCalls = new BoundedBuffer();\n    var addTimingStrategy = function (name, time) {\n        if (time === void 0) { time = timeStampNow(); }\n        bufferApiCalls.add(function () { return addTimingStrategy(name, time); });\n    };\n    var startViewStrategy = function (options, startClocks) {\n        if (startClocks === void 0) { startClocks = clocksNow(); }\n        bufferApiCalls.add(function () { return startViewStrategy(options, startClocks); });\n    };\n    var addActionStrategy = function (action, commonContext) {\n        if (commonContext === void 0) { commonContext = clonedCommonContext(); }\n        bufferApiCalls.add(function () { return addActionStrategy(action, commonContext); });\n    };\n    var addErrorStrategy = function (providedError, commonContext) {\n        if (commonContext === void 0) { commonContext = clonedCommonContext(); }\n        bufferApiCalls.add(function () { return addErrorStrategy(providedError, commonContext); });\n    };\n    function clonedCommonContext() {\n        return deepClone({\n            context: globalContextManager.get(),\n            user: user,\n        });\n    }\n    function initRum(initConfiguration) {\n        // If we are in a Synthetics test configured to automatically inject a RUM instance, we want to\n        // completely discard the customer application RUM instance by ignoring their init() call.  But,\n        // we should not ignore the init() call from the Synthetics-injected RUM instance, so the\n        // internal `ignoreInitIfSyntheticsWillInjectRum` option is here to bypass this condition.\n        if (ignoreInitIfSyntheticsWillInjectRum && willSyntheticsInjectRum()) {\n            return;\n        }\n        if (canUseEventBridge()) {\n            initConfiguration = overrideInitConfigurationForBridge(initConfiguration);\n        }\n        else if (!canHandleSession(initConfiguration)) {\n            return;\n        }\n        if (!canInitRum(initConfiguration)) {\n            return;\n        }\n        var configuration = validateAndBuildRumConfiguration(initConfiguration);\n        if (!configuration) {\n            return;\n        }\n        if (!configuration.trackViewsManually) {\n            doStartRum(configuration);\n        }\n        else {\n            // drain beforeInitCalls by buffering them until we start RUM\n            // if we get a startView, drain re-buffered calls before continuing to drain beforeInitCalls\n            // in order to ensure that calls are processed in order\n            var beforeInitCalls = bufferApiCalls;\n            bufferApiCalls = new BoundedBuffer();\n            startViewStrategy = function (options) {\n                doStartRum(configuration, options);\n            };\n            beforeInitCalls.drain();\n        }\n        getInitConfigurationStrategy = function () { return deepClone(initConfiguration); };\n        isAlreadyInitialized = true;\n    }\n    function doStartRum(configuration, initialViewOptions) {\n        var startRumResults = startRumImpl(configuration, function () { return ({\n            user: user,\n            context: globalContextManager.get(),\n            hasReplay: recorderApi.isRecording() ? true : undefined,\n        }); }, recorderApi, initialViewOptions);\n        (startViewStrategy = startRumResults.startView, addActionStrategy = startRumResults.addAction, addErrorStrategy = startRumResults.addError, addTimingStrategy = startRumResults.addTiming, getInternalContextStrategy = startRumResults.getInternalContext);\n        bufferApiCalls.drain();\n        recorderApi.onRumStart(startRumResults.lifeCycle, configuration, startRumResults.session, startRumResults.viewContexts);\n    }\n    var startView = monitor(function (options) {\n        var sanitizedOptions = typeof options === 'object' ? options : { name: options };\n        startViewStrategy(sanitizedOptions);\n    });\n    var rumPublicApi = makePublicApi({\n        init: monitor(initRum),\n        addRumGlobalContext: monitor(globalContextManager.add),\n        removeRumGlobalContext: monitor(globalContextManager.remove),\n        getRumGlobalContext: monitor(globalContextManager.get),\n        setRumGlobalContext: monitor(globalContextManager.set),\n        getInternalContext: monitor(function (startTime) { return getInternalContextStrategy(startTime); }),\n        getInitConfiguration: monitor(function () { return getInitConfigurationStrategy(); }),\n        addAction: monitor(function (name, context) {\n            addActionStrategy({\n                name: name,\n                context: deepClone(context),\n                startClocks: clocksNow(),\n                type: \"custom\" /* CUSTOM */,\n            });\n        }),\n        addError: function (error, context) {\n            var handlingStack = createHandlingStack();\n            callMonitored(function () {\n                addErrorStrategy({\n                    error: error,\n                    handlingStack: handlingStack,\n                    context: deepClone(context),\n                    startClocks: clocksNow(),\n                });\n            });\n        },\n        addTiming: monitor(function (name, time) {\n            addTimingStrategy(name, time);\n        }),\n        setUser: monitor(function (newUser) {\n            var sanitizedUser = sanitizeUser(newUser);\n            if (sanitizedUser) {\n                user = sanitizedUser;\n            }\n            else {\n                display.error('Unsupported user:', newUser);\n            }\n        }),\n        removeUser: monitor(function () {\n            user = {};\n        }),\n        startView: startView,\n        startSessionReplayRecording: monitor(recorderApi.start),\n        stopSessionReplayRecording: monitor(recorderApi.stop),\n    });\n    return rumPublicApi;\n    function sanitizeUser(newUser) {\n        if (typeof newUser !== 'object' || !newUser) {\n            return;\n        }\n        var result = deepClone(newUser);\n        if ('id' in result) {\n            result.id = String(result.id);\n        }\n        if ('name' in result) {\n            result.name = String(result.name);\n        }\n        if ('email' in result) {\n            result.email = String(result.email);\n        }\n        return result;\n    }\n    function canHandleSession(initConfiguration) {\n        if (!areCookiesAuthorized(buildCookieOptions(initConfiguration))) {\n            display.warn('Cookies are not authorized, we will not send any data.');\n            return false;\n        }\n        if (isLocalFile()) {\n            display.error('Execution is not allowed in the current context.');\n            return false;\n        }\n        return true;\n    }\n    function canInitRum(initConfiguration) {\n        if (isAlreadyInitialized) {\n            if (!initConfiguration.silentMultipleInit) {\n                display.error('DD_RUM is already initialized.');\n            }\n            return false;\n        }\n        return true;\n    }\n    function overrideInitConfigurationForBridge(initConfiguration) {\n        return assign({}, initConfiguration, {\n            applicationId: '00000000-aaaa-0000-aaaa-000000000000',\n            clientToken: 'empty',\n            sampleRate: 100,\n        });\n    }\n    function isLocalFile() {\n        return window.location.protocol === 'file:';\n    }\n}\n//# sourceMappingURL=rumPublicApi.js.map","export function createContextManager() {\n    var context = {};\n    return {\n        get: function () { return context; },\n        add: function (key, value) {\n            context[key] = value;\n        },\n        remove: function (key) {\n            delete context[key];\n        },\n        set: function (newContext) {\n            context = newContext;\n        },\n    };\n}\n//# sourceMappingURL=contextManager.js.map","import { startInternalMonitoring, combine, canUseEventBridge, startBatchWithReplica, getEventBridge, } from '@datadog/browser-core';\nimport { createDOMMutationObservable } from '../browser/domMutationObservable';\nimport { startPerformanceCollection } from '../browser/performanceCollection';\nimport { startRumAssembly } from '../domain/assembly';\nimport { startForegroundContexts } from '../domain/foregroundContexts';\nimport { startInternalContext } from '../domain/internalContext';\nimport { LifeCycle } from '../domain/lifeCycle';\nimport { startViewContexts } from '../domain/viewContexts';\nimport { startRequestCollection } from '../domain/requestCollection';\nimport { startActionCollection } from '../domain/rumEventsCollection/action/actionCollection';\nimport { startErrorCollection } from '../domain/rumEventsCollection/error/errorCollection';\nimport { startLongTaskCollection } from '../domain/rumEventsCollection/longTask/longTaskCollection';\nimport { startResourceCollection } from '../domain/rumEventsCollection/resource/resourceCollection';\nimport { startViewCollection } from '../domain/rumEventsCollection/view/viewCollection';\nimport { startRumSessionManager, startRumSessionManagerStub } from '../domain/rumSessionManager';\nimport { startRumBatch } from '../transport/startRumBatch';\nimport { startRumEventBridge } from '../transport/startRumEventBridge';\nimport { startUrlContexts } from '../domain/urlContexts';\nimport { createLocationChangeObservable } from '../browser/locationChangeObservable';\nexport function startRum(configuration, getCommonContext, recorderApi, initialViewOptions) {\n    var lifeCycle = new LifeCycle();\n    var internalMonitoring = startRumInternalMonitoring(configuration);\n    internalMonitoring.setExternalContextProvider(function () {\n        var _a;\n        return combine({\n            application_id: configuration.applicationId,\n            session: {\n                id: (_a = session.findTrackedSession()) === null || _a === void 0 ? void 0 : _a.id,\n            },\n        }, viewContexts.findView(), { view: { name: null } });\n    });\n    internalMonitoring.setTelemetryContextProvider(function () {\n        var _a, _b;\n        return ({\n            application: {\n                id: configuration.applicationId,\n            },\n            session: {\n                id: (_a = session.findTrackedSession()) === null || _a === void 0 ? void 0 : _a.id,\n            },\n            view: {\n                id: (_b = viewContexts.findView()) === null || _b === void 0 ? void 0 : _b.view.id,\n            },\n            action: {\n                id: actionContexts.findActionId(),\n            },\n        });\n    });\n    if (!canUseEventBridge()) {\n        startRumBatch(configuration, lifeCycle, internalMonitoring.telemetryEventObservable);\n    }\n    else {\n        startRumEventBridge(lifeCycle);\n    }\n    var session = !canUseEventBridge() ? startRumSessionManager(configuration, lifeCycle) : startRumSessionManagerStub();\n    var domMutationObservable = createDOMMutationObservable();\n    var locationChangeObservable = createLocationChangeObservable(location);\n    var _a = startRumEventCollection(lifeCycle, configuration, location, session, locationChangeObservable, domMutationObservable, getCommonContext), viewContexts = _a.viewContexts, foregroundContexts = _a.foregroundContexts, urlContexts = _a.urlContexts, actionContexts = _a.actionContexts, addAction = _a.addAction;\n    startLongTaskCollection(lifeCycle, session);\n    startResourceCollection(lifeCycle);\n    var _b = startViewCollection(lifeCycle, configuration, location, domMutationObservable, locationChangeObservable, foregroundContexts, recorderApi, initialViewOptions), addTiming = _b.addTiming, startView = _b.startView;\n    var addError = startErrorCollection(lifeCycle, foregroundContexts).addError;\n    startRequestCollection(lifeCycle, configuration, session);\n    startPerformanceCollection(lifeCycle, configuration);\n    var internalContext = startInternalContext(configuration.applicationId, session, viewContexts, actionContexts, urlContexts);\n    return {\n        addAction: addAction,\n        addError: addError,\n        addTiming: addTiming,\n        startView: startView,\n        lifeCycle: lifeCycle,\n        viewContexts: viewContexts,\n        session: session,\n        getInternalContext: internalContext.get,\n    };\n}\nfunction startRumInternalMonitoring(configuration) {\n    var _a;\n    var internalMonitoring = startInternalMonitoring(configuration);\n    if (canUseEventBridge()) {\n        var bridge_1 = getEventBridge();\n        internalMonitoring.monitoringMessageObservable.subscribe(function (message) { return bridge_1.send('internal_log', message); });\n        internalMonitoring.telemetryEventObservable.subscribe(function (message) { return bridge_1.send('internal_telemetry', message); });\n    }\n    else if (configuration.internalMonitoringEndpointBuilder) {\n        var batch_1 = startBatchWithReplica(configuration, configuration.internalMonitoringEndpointBuilder, (_a = configuration.replica) === null || _a === void 0 ? void 0 : _a.internalMonitoringEndpointBuilder);\n        internalMonitoring.monitoringMessageObservable.subscribe(function (message) { return batch_1.add(message); });\n    }\n    return internalMonitoring;\n}\nexport function startRumEventCollection(lifeCycle, configuration, location, sessionManager, locationChangeObservable, domMutationObservable, getCommonContext) {\n    var viewContexts = startViewContexts(lifeCycle);\n    var urlContexts = startUrlContexts(lifeCycle, locationChangeObservable, location);\n    var foregroundContexts = startForegroundContexts();\n    var _a = startActionCollection(lifeCycle, domMutationObservable, configuration, foregroundContexts), addAction = _a.addAction, actionContexts = _a.actionContexts;\n    startRumAssembly(configuration, lifeCycle, sessionManager, viewContexts, urlContexts, actionContexts, getCommonContext);\n    return {\n        viewContexts: viewContexts,\n        foregroundContexts: foregroundContexts,\n        urlContexts: urlContexts,\n        addAction: addAction,\n        actionContexts: actionContexts,\n        stop: function () {\n            viewContexts.stop();\n            foregroundContexts.stop();\n        },\n    };\n}\n//# sourceMappingURL=startRum.js.map","import { Batch, HttpRequest } from './index';\nexport function startBatchWithReplica(configuration, endpoint, replicaEndpoint) {\n    var primaryBatch = createBatch(endpoint);\n    var replicaBatch;\n    if (replicaEndpoint) {\n        replicaBatch = createBatch(replicaEndpoint);\n    }\n    function createBatch(endpointBuilder) {\n        return new Batch(new HttpRequest(endpointBuilder, configuration.batchBytesLimit), configuration.maxBatchSize, configuration.batchBytesLimit, configuration.maxMessageSize, configuration.flushTimeout);\n    }\n    return {\n        add: function (message) {\n            primaryBatch.add(message);\n            if (replicaBatch) {\n                replicaBatch.add(message);\n            }\n        },\n    };\n}\n//# sourceMappingURL=startBatchWithReplica.js.map","import { getEventBridge } from '@datadog/browser-core';\nexport function startRumEventBridge(lifeCycle) {\n    var bridge = getEventBridge();\n    lifeCycle.subscribe(11 /* RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        bridge.send('rum', serverRumEvent);\n    });\n}\n//# sourceMappingURL=startRumEventBridge.js.map","import { Batch, combine, HttpRequest } from '@datadog/browser-core';\nexport function startRumBatch(configuration, lifeCycle, telemetryEventObservable) {\n    var batch = makeRumBatch(configuration, lifeCycle);\n    lifeCycle.subscribe(11 /* RUM_EVENT_COLLECTED */, function (serverRumEvent) {\n        if (serverRumEvent.type === \"view\" /* VIEW */) {\n            batch.upsert(serverRumEvent, serverRumEvent.view.id);\n        }\n        else {\n            batch.add(serverRumEvent);\n        }\n    });\n    telemetryEventObservable.subscribe(function (event) { return batch.add(event); });\n}\nfunction makeRumBatch(configuration, lifeCycle) {\n    var primaryBatch = createRumBatch(configuration.rumEndpointBuilder, function () {\n        return lifeCycle.notify(9 /* BEFORE_UNLOAD */);\n    });\n    var replicaBatch;\n    var replica = configuration.replica;\n    if (replica !== undefined) {\n        replicaBatch = createRumBatch(replica.rumEndpointBuilder);\n    }\n    function createRumBatch(endpointBuilder, unloadCallback) {\n        return new Batch(new HttpRequest(endpointBuilder, configuration.batchBytesLimit), configuration.maxBatchSize, configuration.batchBytesLimit, configuration.maxMessageSize, configuration.flushTimeout, unloadCallback);\n    }\n    function withReplicaApplicationId(message) {\n        return combine(message, { application: { id: replica.applicationId } });\n    }\n    return {\n        add: function (message) {\n            primaryBatch.add(message);\n            if (replicaBatch) {\n                replicaBatch.add(withReplicaApplicationId(message));\n            }\n        },\n        upsert: function (message, key) {\n            primaryBatch.upsert(message, key);\n            if (replicaBatch) {\n                replicaBatch.upsert(withReplicaApplicationId(message), key);\n            }\n        },\n    };\n}\n//# sourceMappingURL=startRumBatch.js.map","import { addEventListener, instrumentMethodAndCallOriginal, Observable, shallowClone, } from '@datadog/browser-core';\nexport function createLocationChangeObservable(location) {\n    var currentLocation = shallowClone(location);\n    var observable = new Observable(function () {\n        var stopHistoryTracking = trackHistory(onLocationChange).stop;\n        var stopHashTracking = trackHash(onLocationChange).stop;\n        return function () {\n            stopHistoryTracking();\n            stopHashTracking();\n        };\n    });\n    function onLocationChange() {\n        if (currentLocation.href === location.href) {\n            return;\n        }\n        var newLocation = shallowClone(location);\n        observable.notify({\n            newLocation: newLocation,\n            oldLocation: currentLocation,\n        });\n        currentLocation = newLocation;\n    }\n    return observable;\n}\nfunction trackHistory(onHistoryChange) {\n    var stopInstrumentingPushState = instrumentMethodAndCallOriginal(history, 'pushState', {\n        after: onHistoryChange,\n    }).stop;\n    var stopInstrumentingReplaceState = instrumentMethodAndCallOriginal(history, 'replaceState', {\n        after: onHistoryChange,\n    }).stop;\n    var removeListener = addEventListener(window, \"popstate\" /* POP_STATE */, onHistoryChange).stop;\n    return {\n        stop: function () {\n            stopInstrumentingPushState();\n            stopInstrumentingReplaceState();\n            removeListener();\n        },\n    };\n}\nfunction trackHash(onHashChange) {\n    return addEventListener(window, \"hashchange\" /* HASH_CHANGE */, onHashChange);\n}\n//# sourceMappingURL=locationChangeObservable.js.map","import { SESSION_TIME_OUT_DELAY, ContextHistory } from '@datadog/browser-core';\nexport var VIEW_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startViewContexts(lifeCycle) {\n    var viewContextHistory = new ContextHistory(VIEW_CONTEXT_TIME_OUT_DELAY);\n    lifeCycle.subscribe(2 /* VIEW_CREATED */, function (view) {\n        viewContextHistory.add(buildViewContext(view), view.startClocks.relative);\n    });\n    lifeCycle.subscribe(4 /* VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        viewContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(8 /* SESSION_RENEWED */, function () {\n        viewContextHistory.reset();\n    });\n    function buildViewContext(view) {\n        return {\n            service: view.service,\n            version: view.version,\n            view: {\n                id: view.id,\n                name: view.name,\n            },\n        };\n    }\n    return {\n        findView: function (startTime) { return viewContextHistory.find(startTime); },\n        stop: function () {\n            viewContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=viewContexts.js.map","import { SESSION_TIME_OUT_DELAY, relativeNow, ContextHistory } from '@datadog/browser-core';\n/**\n * We want to attach to an event:\n * - the url corresponding to its start\n * - the referrer corresponding to the previous view url (or document referrer for initial view)\n */\nexport var URL_CONTEXT_TIME_OUT_DELAY = SESSION_TIME_OUT_DELAY;\nexport function startUrlContexts(lifeCycle, locationChangeObservable, location) {\n    var urlContextHistory = new ContextHistory(URL_CONTEXT_TIME_OUT_DELAY);\n    var previousViewUrl;\n    lifeCycle.subscribe(4 /* VIEW_ENDED */, function (_a) {\n        var endClocks = _a.endClocks;\n        urlContextHistory.closeActive(endClocks.relative);\n    });\n    lifeCycle.subscribe(2 /* VIEW_CREATED */, function (_a) {\n        var startClocks = _a.startClocks;\n        var viewUrl = location.href;\n        urlContextHistory.add(buildUrlContext({\n            url: viewUrl,\n            referrer: !previousViewUrl ? document.referrer : previousViewUrl,\n        }), startClocks.relative);\n        previousViewUrl = viewUrl;\n    });\n    var locationChangeSubscription = locationChangeObservable.subscribe(function (_a) {\n        var newLocation = _a.newLocation;\n        var current = urlContextHistory.find();\n        if (current) {\n            var changeTime = relativeNow();\n            urlContextHistory.closeActive(changeTime);\n            urlContextHistory.add(buildUrlContext({\n                url: newLocation.href,\n                referrer: current.view.referrer,\n            }), changeTime);\n        }\n    });\n    function buildUrlContext(_a) {\n        var url = _a.url, referrer = _a.referrer;\n        return {\n            view: {\n                url: url,\n                referrer: referrer,\n            },\n        };\n    }\n    return {\n        findUrl: function (startTime) { return urlContextHistory.find(startTime); },\n        stop: function () {\n            locationChangeSubscription.unsubscribe();\n            urlContextHistory.stop();\n        },\n    };\n}\n//# sourceMappingURL=urlContexts.js.map","import { toServerDuration, relativeToClocks, generateUUID } from '@datadog/browser-core';\nexport function startLongTaskCollection(lifeCycle, sessionManager) {\n    lifeCycle.subscribe(0 /* PERFORMANCE_ENTRIES_COLLECTED */, function (entries) {\n        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n            var entry = entries_1[_i];\n            if (entry.entryType !== 'longtask') {\n                break;\n            }\n            var session = sessionManager.findTrackedSession(entry.startTime);\n            if (!session || session.hasLitePlan) {\n                break;\n            }\n            var startClocks = relativeToClocks(entry.startTime);\n            var rawRumEvent = {\n                date: startClocks.timeStamp,\n                long_task: {\n                    id: generateUUID(),\n                    duration: toServerDuration(entry.duration),\n                },\n                type: \"long_task\" /* LONG_TASK */,\n            };\n            lifeCycle.notify(10 /* RAW_RUM_EVENT_COLLECTED */, {\n                rawRumEvent: rawRumEvent,\n                startTime: startClocks.relative,\n                domainContext: { performanceEntry: entry.toJSON() },\n            });\n        }\n    });\n}\n//# sourceMappingURL=longTaskCollection.js.map","import { assign } from '@datadog/browser-core';\n/**\n * Internal context keep returning v1 format\n * to not break compatibility with logs data format\n */\nexport function startInternalContext(applicationId, sessionManager, viewContexts, actionContexts, urlContexts) {\n    return {\n        get: function (startTime) {\n            var viewContext = viewContexts.findView(startTime);\n            var urlContext = urlContexts.findUrl(startTime);\n            var session = sessionManager.findTrackedSession(startTime);\n            if (session && viewContext && urlContext) {\n                var actionId = actionContexts.findActionId(startTime);\n                return {\n                    application_id: applicationId,\n                    session_id: session.id,\n                    user_action: actionId ? { id: actionId } : undefined,\n                    view: assign({}, viewContext.view, urlContext.view),\n                };\n            }\n        },\n    };\n}\n//# sourceMappingURL=internalContext.js.map","import { assign, DefaultPrivacyLevel, display, isPercentage, objectHasValue, validateAndBuildConfiguration, } from '@datadog/browser-core';\nexport function validateAndBuildRumConfiguration(initConfiguration) {\n    var _a, _b;\n    if (!initConfiguration.applicationId) {\n        display.error('Application ID is not configured, no RUM data will be collected.');\n        return;\n    }\n    if (initConfiguration.replaySampleRate !== undefined && !isPercentage(initConfiguration.replaySampleRate)) {\n        display.error('Replay Sample Rate should be a number between 0 and 100');\n        return;\n    }\n    if (initConfiguration.allowedTracingOrigins !== undefined) {\n        if (!Array.isArray(initConfiguration.allowedTracingOrigins)) {\n            display.error('Allowed Tracing Origins should be an array');\n            return;\n        }\n        if (initConfiguration.allowedTracingOrigins.length !== 0 && initConfiguration.service === undefined) {\n            display.error('Service need to be configured when tracing is enabled');\n            return;\n        }\n    }\n    var baseConfiguration = validateAndBuildConfiguration(initConfiguration);\n    if (!baseConfiguration) {\n        return;\n    }\n    return assign({\n        applicationId: initConfiguration.applicationId,\n        version: initConfiguration.version,\n        actionNameAttribute: initConfiguration.actionNameAttribute,\n        replaySampleRate: (_a = initConfiguration.replaySampleRate) !== null && _a !== void 0 ? _a : 100,\n        allowedTracingOrigins: (_b = initConfiguration.allowedTracingOrigins) !== null && _b !== void 0 ? _b : [],\n        trackInteractions: !!initConfiguration.trackInteractions,\n        trackViewsManually: !!initConfiguration.trackViewsManually,\n        defaultPrivacyLevel: objectHasValue(DefaultPrivacyLevel, initConfiguration.defaultPrivacyLevel)\n            ? initConfiguration.defaultPrivacyLevel\n            : DefaultPrivacyLevel.MASK_USER_INPUT,\n    }, baseConfiguration);\n}\n//# sourceMappingURL=configuration.js.map"],"names":["display","log","console","bind","warn","error","UNKNOWN_FUNCTION","computeStackTrace","ex","stack","stackProperty","tryToGetString","split","forEach","line","stackFrame","parts","CHROME_LINE_RE","exec","isNative","indexOf","isEval","submatch","CHROME_EVAL_RE","args","column","undefined","func","url","parseChromeLine","WINJS_LINE_RE","parseWinLine","GECKO_LINE_RE","GECKO_EVAL_RE","parseGeckoLine","push","message","name","candidate","property","value","ONE_SECOND","throttle","fn","wait","options","pendingExecutionWithParameters","pendingTimeoutId","needLeadingExecution","leading","needTrailingExecution","trailing","inWaitPeriod","throttled","parameters","_i","arguments","length","apply","setTimeout","cancel","clearTimeout","target","toAssign","source","key","Object","prototype","hasOwnProperty","call","shallowClone","object","generateUUID","placeholder","parseInt","Math","random","toString","concat","replace","performDraw","threshold","round","num","decimals","toFixed","noop","jsonStringify","replacer","space","JSON","stringify","originalToJSON","hasToJSON","toJSON","result","originalProtoToJSON","getPrototypeOf","_a","includes","search","find","array","predicate","i","item","isPercentage","isNumber","objectValues","keys","map","objectEntries","isEmptyObject","getGlobalObject","globalThis","defineProperty","get","this","configurable","globalObject","_dd_temp_","self","window","getLinkElementOrigin","element","origin","sanitizedHost","host","protocol","findCommaSeparatedValue","rawString","matches","RegExp","safeTruncate","suffix","lastChar","charCodeAt","correctedLength","slice","addEventListener","emitter","event","listener","addEventListeners","events","_b","once","capture","passive","wrappedListener","monitor","stop","removeEventListener","runOnReadyState","expectedReadyState","callback","document","readyState","getType","Array","isArray","mergeInto","destination","circularReferenceChecker","WeakSet","set_1","hasAlreadyBeenSeen","has","add","createCircularReferenceChecker","Date","getTime","flags","global","ignoreCase","multiline","sticky","unicode","join","merged_1","merged","deepClone","combine","sources","sources_1","formatUnknownError","stackTrace","errorObject","nonErrorPrefix","handlingStack","Error","toStackTraceString","type","formatErrorMessage","frame","createHandlingStack","formattedStack","e","callMonitored","navigationStart","enabledExperimentalFeatures","Observable","onFirstSubscribe","observers","subscribe","f","_this","onLastUnsubscribe","unsubscribe","filter","other","notify","data","observer","mergeObservables","observables","globalObservable","subscriptions","observable","subscription","relativeToClocks","relative","timeStamp","relativeTime","correctedOrigin","now","performance","getNavigationStart","getTimeStamp","toServerDuration","duration","timeStampNow","relativeNow","clocksNow","clocksOrigin","elapsed","start","end","getRelativeTime","timestamp","timing","isExperimentalFeatureEnabled","featureName","onInternalMonitoringMessageCollected","monitoringConfiguration","maxMessagesPerPage","sentMessageCount","telemetryEnabled","context","logErrorIfDebug","addMonitoringError","addMonitoringMessage","debugMode","logMessageIfDebug","addToMonitoring","status","kind","formatError","setDebugMode","catchUserErrors","errorMsg","err","getCurrentSiteCache","isURLSupported","BoundedBuffer","buffer","splice","drain","getEventBridge","eventBridgeGlobal","DatadogEventBridge","getAllowedWebViewHosts","parse","send","eventType","canUseEventBridge","hostname","location","bridge","some","escapedHost","test","setCookie","expireDelay","date","setTime","expires","toUTCString","sameSite","crossSite","domain","secure","cookie","getCookie","deleteCookie","normalizeUrl","buildUrl","href","base","URL","checkURLSupported","doc","anchorElement","createElement","baseElement","implementation","createHTMLDocument","head","appendChild","body","ENDPOINTS","logs","rum","sessionReplay","INTAKE_TRACKS","INTAKE_SITE_US","createEndpointBuilder","initConfiguration","endpointType","tags","site","clientToken","domainParts","extension","pop","baseUrl","proxyUrl","build","encodeURIComponent","endpointUrl","buildIntakeUrl","FORBIDDEN_CHARACTERS","buildTag","rawValue","valueSizeLimit","sanitizedValue","DefaultPrivacyLevel","ALLOW","MASK","MASK_USER_INPUT","validateAndBuildConfiguration","sampleRate","enabledFeatures","telemetrySampleRate","enableExperimentalFeatures","Set","flag","beforeSend","cookieOptions","buildCookieOptions","service","silentMultipleInit","batchBytesLimit","eventRateLimiterThreshold","maxInternalMonitoringMessagesPerPage","flushTimeout","maxBatchSize","maxMessageSize","configuration","env","version","datacenter","buildTags","endpointBuilders","logsEndpointBuilder","rumEndpointBuilder","sessionReplayEndpointBuilder","internalMonitoringApiKey","internalMonitoringEndpointBuilder","computeEndpointBuilders","intakeEndpoints","builder","replicaConfiguration","replica","replicaEndpointBuilders","applicationId","computeReplicaConfiguration","isIntakeUrl","intakeEndpoint","computeTransportConfiguration","useSecureSessionCookie","useCrossSiteSessionCookie","mustUseSecureCookie","trackSessionAcrossSubdomains","testCookieName","domainLevels","candidateDomain","getCurrentSite","willSyntheticsInjectRum","Boolean","_DATADOG_SYNTHETICS_INJECTS_RUM","HAS_MULTI_BYTES_CHARACTERS","Batch","request","maxSize","bytesLimit","beforeUnloadCallback","pushOnlyBuffer","upsertBuffer","bufferBytesSize","bufferMessageCount","flushOnVisibilityHidden","flushPeriodically","addOrUpdate","upsert","flush","reason","messages","sizeInBytes","TextEncoder","encode","Blob","size","process","processedMessage","messageBytesSize","hasMessageFor","remove","willReachedBytesLimitWith","isFull","removedMessage","navigator","sendBeacon","visibilityState","hasReportedXhrError","HttpRequest","endpointBuilder","flushReason","tryBeacon","hasReportedBeaconError","reportBeaconError","XMLHttpRequest","req","currentTarget","on_line","onLine","try_beacon","flush_reason","is_trusted","isTrusted","total","loaded","ready_state","response_text","responseText","transportIntrospection","open","getMutationObserverConstructor","constructor","browserWindow","Zone","symbol","__symbol__","MutationObserver","FAKE_INITIAL_DOCUMENT","RESOURCE_TYPES","initiatorType","_","path","areInOrder","numbers","computePerformanceResourceDetails","entry","validEntry","toValidEntry","startTime","fetchStart","redirectStart","redirectEnd","domainLookupStart","domainLookupEnd","connectStart","secureConnectionStart","connectEnd","requestStart","responseStart","details","download","formatTiming","responseEnd","first_byte","connect","ssl","dns","hasRedirection","redirect","computeSize","decodedBodySize","isAllowedRequestUrl","getDocumentTraceId","traceIdMeta","querySelector","traceTimeMeta","createDocumentTraceData","content","getDocumentTraceDataFromMeta","comment","childNodes","getTraceCommentFromNode","node","isTextNode","findTraceComment","getDocumentTraceDataFromComment","traceTime","traceId","rawTraceTime","Number","nodeName","isCommentNode","match","supportPerformanceObject","supportPerformanceTimingEvent","entryType","PerformanceObserver","supportedEntryTypes","startPerformanceCollection","lifeCycle","handleRumPerformanceEntries","forcedAttributes","getEntriesByType","relativePerformanceTiming","computeRelativePerformanceTiming","performanceEntries_1","getEntries","handlePerformanceEntryList_1","entries","mainEntries","experimentalEntries","observe","buffered","entryTypes","clearResourceTimings","sendFakeTiming","retrieveNavigationTiming","startTimeStamp","timingSent","removeEventListeners","evt","cancelable","processingStart","sendTiming","sendTimingIfPointerIsNotCancelled","delay","retrieveFirstInputTiming","numberKey","timingElement","rumAllowedPerformanceEntries","loadEventEnd","isIncompleteNavigation","isForbiddenResource","createEventRateLimiter","limit","onLimitReached","eventCount","allowNextEvent","isLimitReached","startClocks","current","field","isValidObjectContaining","set","fields","VIEW_EVENTS_MODIFIABLE_FIELD_PATHS","OTHER_EVENTS_MODIFIABLE_FIELD_PATHS","startRumAssembly","sessionManager","viewContexts","urlContexts","actionContexts","getCommonContext","reportError","eventRateLimiters","syntheticsContext","testId","_DATADOG_SYNTHETICS_PUBLIC_ID","resultId","_DATADOG_SYNTHETICS_RESULT_ID","test_id","result_id","injected","getSyntheticsContext","ciTestContext","testExecutionId","Cypress","test_execution_id","getCiTestContext","rawRumEvent","domainContext","savedCommonContext","customerContext","viewContext","findView","urlContext","findUrl","session","findTrackedSession","commonContext","rumContext","_dd","format_version","drift","plan","hasReplayPlan","browser_sdk_version","application","id","synthetics","ci_test","actionId","findActionId","serverRumEvent","action","has_replay","hasReplay","user","usr","modifiableFieldPaths","modifier","clone","originalValue","newValue","originalType","newType","limitModification","shouldSend","foregroundPeriods","addNewForegroundPeriod","currentForegroundPeriod","closeForegroundPeriod","isInForegroundAt","foregroundPeriod","selectInForegroundPeriodsFor","eventStartTime","eventEndTime","filteredForegroundPeriods","earliestIndex","max","startDuration","endDuration","unshift","ongoingOperations","LifeCycle","callbacks","eventCallbacks","SESSION_ENTRY_REGEXP","SESSION_COOKIE_NAME","bufferedOperations","withCookieLockAccess","operations","numberOfRetries","next","currentLock","currentSession","retrieveSession","isCookieLockEnabled","lock","retryLater","setSession","processedSession","persistSession","isExpiredState","after","chrome","userAgent","currentNumberOfRetries","nextOperations","shift","clearSession","expire","String","SESSION_EXPIRATION_DELAY","toSessionString","sessionString","isValidSessionString","xhrObservable","END_OF_TIMES","Infinity","ContextHistory","clearOldContextsInterval","setInterval","clearOldContexts","ONE_MINUTE","endTime","index","close","closeActive","latestEntry","findAll","reset","clearInterval","oldTimeThreshold","instrumentMethod","method","instrumentationFactory","original","instrumentation","instrumentationWrapper","instrumentMethodAndCallOriginal","before","instrumentSetter","originalDescriptor","getOwnPropertyDescriptor","thisObject","fetchObservable","xhrContexts","WeakMap","initXhrObservable","stopInstrumentingStart","openXhr","stopInstrumentingSend","sendXhr","stopInstrumentingAbort","abortXhr","state","startContext","isAborted","xhr","hasBeenReported","stopInstrumentingOnReadyStateChange","DONE","onEnd","completeContext","input","init","afterSend","responsePromise","reportFetch","response","DOMException","code","ABORT_ERR","responseType","then","clearTracingIfNeeded","spanId","injectHeadersIfTracingAllowed","inject","getCrypto","requestUrl","requestOrigin","allowedTracingOrigins","allowedOrigin","isAllowedUrl","TraceIdentifier","toDecimalString","crypto","msCrypto","Uint8Array","getRandomValues","radix","high","readInt32","low","str","mod","floor","offset","nextRequestIndex","startRequestCollection","tracer","traceFetch","tracingHeaders","Request","headers","append","headers_1","Headers","header","traceXhr","setRequestHeader","startTracer","rawContext","requestIndex","getNextRequestIndex","trackXhr","fetch","originalFetch","trackFetch","trackEventCounts","eventCounts","errorCount","longTaskCount","resourceCount","userActionCount","waitIdlePage","domMutationObservable","idlePageCallback","maxDuration","pageActivityObservable","firstRequestIndex","pendingRequestsCount","notifyPageActivity","startEvent","s","isBusy","createPageActivityObservable","idleTimeoutId","hasCompleted","validationTimeoutId","complete","hadActivity","maxDurationTimeoutId","pageActivitySubscription","lastChangeTime","doWaitIdlePage","DEFAULT_PROGRAMMATIC_ATTRIBUTE","getActionNameFromElementProgrammatically","targetElement","programmaticAttribute","elementWithAttribute","supportsElementClosestResult","HTMLElement","closest","hasAttribute","parentElement","truncate","normalizeWhitespace","getAttribute","trim","supportsLabelPropertyResult","priorityStrategies","userProgrammaticAttribute","HTMLInputElement","labels","getTextualContent","label","ownerDocument","labelledByAttribute","refElement","getElementById","fallbackStrategies","getActionNameFromElementForStrategies","strategies","recursionCounter","strategies_1","name_1","strategy","trimmedName","isContentEditable","text_1","innerText","removeTextFromElements","query","list","querySelectorAll","element_1","textToReplace","documentMode","textContent","trackActions","actionNameAttribute","history","stopListener","actionController","onCompleteCallback","onDiscardCallback","viewCreatedSubscription","eventCountsSubscription","stopWaitingIdlePage","idleEvent","cleanup","counts","historyEntry","discard","newAction","Element","controller","processAction","foregroundContexts","autoActionProperties","isAutoAction","count","loading_time","long_task","resource","actionEvent","inForeground","view","in_foreground","ERROR_TYPES_RE","ConsoleApiName","consoleObservablesByApi","buildConsoleLog","params","api","param","formatConsoleParameters","firstErrorParam","trackFirstHiddenSingleton","stopListeners","RawReportType","buildStack","sourceFile","lineNumber","columnNumber","startErrorCollection","errorObservable","apis","consoleObservables","originalConsoleApi","createConsoleObservable","consoleError","handling","trackConsoleError","originalError","lineNo","columnNo","errorObj","location_1","msg","groups","instrumentOnError","instrumentUnhandledRejection","trackRuntimeError","handleCspViolation","blockedURI","effectiveDirective","subtype","originalPolicy","buildRawReportFromCspViolation","reportTypes","ReportingObserver","handleReports","reports","report","buildRawReportFromReport","types","disconnect","createReportObservable","initReportObservable","trackReportError","handling_stack","source_type","processError","addError","rawError","computeRawError","doStartErrorCollection","startResourceCollection","matchingTiming","sameNameEntries","getEntriesByName","correspondingEntries","candidates","matchRequestTiming","correspondingTimingOverrides","computePerformanceEntryMetrics","tracingInfo","span_id","trace_id","computeRequestTracingInfo","resourceEvent","status_code","performanceEntry","toPerformanceEntryRepresentation","requestInput","requestInit","processRequest","entries_1","processResourceEntry","isValidUrl","pathname","getPathName","RESOURCE_TYPES_1","isType","computeResourceKind","entryMetrics","computeEntryTracingInfo","PerformanceEntry","trackFirstHidden","TIMING_MAXIMUM_DELAY","trackInitialViewTimings","timings","setTimings","newTimings","stopNavigationTracking","domComplete","domContentLoaded","domContentLoadedEventEnd","domInteractive","loadEvent","trackNavigationTimings","stopFCPTracking","firstHidden","fcpEntry","firstContentfulPaint","trackFirstContentfulPaintTiming","stopLCPTracking","firstInteractionTimestamp","stopEventListener","unsubscribeLifeCycle","lcpEntry","findLast","largestContentfulPaint","trackLargestContentfulPaintTiming","stopFIDTracking","firstInputEntry","firstInputDelay","firstInputTime","trackFirstInputTimings","trackViewMetrics","scheduleViewUpdate","loadingType","viewStart","stopCLSTracking","viewMetrics","stopEventCountsTracking","newEventCounts","loadType","isWaitingForLoadEvent","isWaitingForActivityLoadingTime","loadingTimeCandidates","invokeCallbackIfAllCandidatesAreReceived","newLoadingTime","loadingTime","setLoadEvent","trackLoadingTime","stopLoadingTimeTracking","cumulativeLayoutShift","maxClsValue","update","slidingSessionWindow","hadRecentInput","trackCumulativeLayoutShift","newView","initialLocation","viewOptions","endClocks","customTimings","documentVersion","triggerViewUpdate","cancelScheduleViewUpdate","stopViewMetricsTracking","currentEnd","isActive","scheduleUpdate","clocks","triggerUpdate","updateTimings","addTiming","time","looksLikeRelativeTime","sanitized","sanitizeTiming","getPathFromHash","hash","startViewCollection","locationChangeObservable","recorderApi","initialViewOptions","replayStats","getReplayStats","viewEvent","document_version","replay_stats","cumulative_layout_shift","dom_complete","dom_content_loaded","dom_interactive","first_contentful_paint","first_input_delay","first_input_time","is_active","largest_contentful_paint","load_event","loading_type","time_spent","in_foreground_periods","custom_timings","newObject","mapValues","processViewUpdate","areViewsTrackedAutomatically","locationChangeSubscription","initialView","stopInitialViewTracking","currentView","stopViewLifeCycle","trackViewChange","keepAliveInterval","startViewLifeCycle","currentLocation","otherLocation","correspondingId","oldLocation","newLocation","substr","renewViewOnLocationChange","startView","trackViews","trackViewsManually","stopCallbacks","startSessionManager","productKey","computeSessionState","oldSessionId","oldRumType","oldLogsType","tryOldCookiesMigration","sessionStore","renewObservable","expireObservable","watchSessionTimeoutId","cookieSession","isActiveSession","synchronizeSession","sessionCache","hasSessionInCache","isSessionInCacheOutdated","created","expandOrRenewSession","isTracked","synchronizedSession","trackingType","expandOrRenewCookie","renewSession","expandSession","getSession","startSessionStore","sessionContextHistory","SESSION_TIME_OUT_DELAY","buildSessionContext","expandSessionWhenVisible","visibilityCheckInterval","trackVisibility","findActiveSession","isTypeTracked","rumSessionType","NodePrivacyLevel","IGNORE","HIDDEN","PRIVACY_ATTR_NAME","PRIVACY_ATTR_VALUE_HIDDEN","CENSORED_STRING_MARK","FORM_PRIVATE_TAG_NAMES","INPUT","OUTPUT","TEXTAREA","SELECT","OPTION","DATALIST","OPTGROUP","getNodePrivacyLevel","defaultPrivacyLevel","parentNodePrivacyLevel","parentNode","reducePrivacyLevel","getNodeSelfPrivacyLevel","childPrivacyLevel","nodeType","ELEMENT_NODE","isElement","privAttr","tagName","inputElement","autocomplete","classList","contains","relAttribute","getLowerCaseAttribute","nameAttribute","propertyAttribute","toLowerCase","shouldIgnoreElement","shouldMaskNode","privacyLevel","TEXT_NODE","isFormElement","getTextContent","textNode","ignoreWhiteSpace","parentTagName","isStyle","serializedNodeIds","hasSerializedNode","getSerializedNodeId","getElementInputValue","nodePrivacyLevel","isTouchEvent","changedTouches","serializeDocument","serializeNodeWithId","serializedNode","DOCUMENT_NODE","serializeChildNodes","serializeDocumentNode","DOCUMENT_TYPE_NODE","documentType","publicId","systemId","el","getValidTagName","isSVG","SVGElement","getBoundingClientRect","width","height","attributes","rr_width","rr_height","safeAttrs","attributeName","attributeValue","serializeAttribute","formValue","optionElement","selected","stylesheet","from","styleSheets","cssText","getCssRulesString","rel","_cssText","sheet","checked","mediaElement","rr_mediaState","paused","scrollLeft","rr_scrollLeft","scrollTop","rr_scrollTop","getAttributesForPrivacyLevel","serializeElementNode","serializeTextNode","CDATA_SECTION_NODE","serializeNode","_nextId","serializedNodeWithId","serializeNodeId","setSerializedNodeId","childNode","serializedChildNode","TAG_NAME_REGEX","processedTagName","rules","cssRules","getCssRuleString","rule","isCSSImportRule","styleSheet","startMutationObserver","mutationCallback","mutationBatch","processMutationBatch","cancelScheduledFlush","pendingMutations","addMutations","mutations","opts","requestIdleCallback","id_1","timeout","cancelIdleCallback","requestAnimationFrame","cancelAnimationFrame","createMutationBatch","filteredMutations","mutation","nodeAndAncestorsHaveSerializedNode","addedAndMovedNodes","removedNodes","Map","_loop_1","addedNodes","delete","mutations_1","sortedAddedAndMovedNodes","sort","a","b","position","compareDocumentPosition","Node","DOCUMENT_POSITION_CONTAINED_BY","DOCUMENT_POSITION_CONTAINS","DOCUMENT_POSITION_FOLLOWING","DOCUMENT_POSITION_PRECEDING","addedNodeMutations","sortedAddedAndMovedNodes_1","hasBeenSerialized","nextId","getNextSibling","parentId","removedNodeMutations","parent","adds","removes","nextSibling","processChildListMutations","texts","textMutations","handledNodes","filteredMutations_1","oldValue","processCharacterDataMutations","attributeMutations","handledElements","handledAttributes","emittedMutations","filteredMutations_2","transformedValue","inputValue","emittedMutation","processAttributesMutations","processMutations","takeRecords","attributeOldValue","characterData","characterDataOldValue","childList","subtree","onFlush","MutationController","flushListener","convertMouseEventToLayoutCoordinates","clientX","clientY","visual","visualViewport","normalised","layoutViewportX","layoutViewportY","visualViewportX","visualViewportY","abs","pageTop","offsetTop","scrollY","pageLeft","offsetLeft","scrollX","isVisualViewportFactoredIn","getVisualViewport","scale","getWindowWidth","innerWidth","getWindowHeight","innerHeight","getScrollX","pageXOffset","getScrollY","pageYOffset","initObservers","o","focusCb","mutationHandler","mutationController","mutationCb","mousemoveHandler","cb","updatePosition","timeOffset","x","y","initMoveObserver","mousemoveCb","mouseInteractionHandler","eventTypeToMouseInteraction","initMouseInteractionObserver","mouseInteractionCb","scrollHandler","initScrollObserver","scrollCb","viewportResizeHandler","updateDimension","initViewportResizeObserver","viewportResizeCb","inputHandler","lastInputStateMap","onElementChange","inputState","isChecked","text","cbWithDedup","lastInputState","stopEventListeners","HTMLTextAreaElement","HTMLSelectElement","instrumentationStoppers","stopper","initInputObserver","inputCb","mediaInteractionHandler","mediaInteractionCb","initMediaInteractionObserver","styleSheetObserver","restoreInsertRule","CSSStyleSheet","ownerNode","restoreDeleteRule","initStyleSheetObserver","styleSheetRuleCb","focusHandler","has_focus","hasFocus","visualViewportResizeHandler","cancelThrottle","removeListener","initVisualViewportResizeObserver","visualViewportResizeCb","statsPerView","assembleIncrementalSnapshot","metadata","rawSegmentSize","formData","FormData","toFormEntries","byteLength","onEntry","prefix","getSegmentsCount","viewId","getOrCreateReplayStats","segments_count","addRecord","records_count","segments_total_raw_size","isFirst_1","_value","deleteOldestStats","workerURL","Segment","worker","creationReason","initialRecord","onWrote","onFlushed","isFlushed","creation_reason","has_full_snapshot","index_in_view","additionalRawSize","rawSize","compressedSize","postMessage","record","startSegmentCollection","getSegmentContext","nextSegmentCreationReason","unsubscribeViewCreated","flushSegment","unsubscribeBeforeUnload","unsubscribeVisibilityChange","segment","expirationTimeoutId","createNewSegment","computeSegmentContext","compressedSegmentSize","doStartSegmentCollection","createDeflateWorker","createObjectURL","workerCodeFn","Worker","zero","buf","len","LITERALS","L_CODES","D_CODES","MAX_BITS","extra_lbits","extra_dbits","extra_blbits","bl_order","static_ltree","static_dtree","_dist_code","_length_code","MAX_MATCH","base_length","static_l_desc","static_d_desc","static_bl_desc","base_dist","StaticTreeDesc","static_tree","extra_bits","extra_base","elems","max_length","has_stree","TreeDesc","dyn_tree","stat_desc","max_code","d_code","dist","put_short","w","pending_buf","pending","send_bits","bi_valid","bi_buf","send_code","c","tree","bi_reverse","res","gen_codes","bl_count","bits","n","next_code","init_block","dyn_ltree","dyn_dtree","bl_tree","END_BLOCK","opt_len","static_len","last_lit","bi_windup","smaller","m","depth","_n2","_m2","pqdownheap","k","v","heap","j","heap_len","compress_block","ltree","dtree","lc","extra","lx","d_buf","l_buf","build_tree","desc","stree","heap_max","h","xbits","overflow","gen_bitlen","scan_tree","curlen","prevlen","nextlen","max_count","min_count","REP_3_6","REPZ_3_10","REPZ_11_138","send_tree","static_init_done","_tr_stored_block","stored_len","last","subarray","copy_block","trees","LENGTH_CODES","tr_static_init","l_desc","d_desc","bl_desc","opt_lenb","static_lenb","max_blindex","level","strm","data_type","black_mask","detect_data_type","BL_CODES","build_bl_tree","lcodes","dcodes","blcodes","rank","send_all_trees","lit_bufsize","STATIC_TREES","bi_flush","adler32_1","adler","pos","s1","s2","crcTable","Uint32Array","table","makeTable","crc32_1","crc","t","constants","Z_NO_FLUSH","Z_PARTIAL_FLUSH","Z_SYNC_FLUSH","Z_FULL_FLUSH","Z_FINISH","Z_BLOCK","Z_TREES","Z_OK","Z_STREAM_END","Z_NEED_DICT","Z_ERRNO","Z_STREAM_ERROR","Z_DATA_ERROR","Z_MEM_ERROR","Z_BUF_ERROR","Z_NO_COMPRESSION","Z_BEST_SPEED","Z_BEST_COMPRESSION","Z_DEFAULT_COMPRESSION","Z_FILTERED","Z_HUFFMAN_ONLY","Z_RLE","Z_FIXED","Z_DEFAULT_STRATEGY","Z_BINARY","Z_TEXT","Z_UNKNOWN","Z_DEFLATED","_tr_init$1","_tr_stored_block$1","_tr_flush_block$1","_tr_tally$1","_tr_align$1","Z_FIXED$1","Z_UNKNOWN$1","MAX_MATCH$1","MIN_LOOKAHEAD","HCRC_STATE","BUSY_STATE","FINISH_STATE","errorCode","zero$1","HASH","prev","hash_shift","hash_mask","flush_pending","avail_out","output","pending_out","next_out","total_out","flush_block_only","block_start","strstart","put_byte","putShortMSB","longest_match","cur_match","chain_length","max_chain_length","scan","best_len","prev_length","nice_match","w_size","_win","wmask","w_mask","strend","scan_end1","scan_end","good_match","lookahead","match_start","fill_window","p","more","_w_size","window_size","hash_size","avail_in","next_in","wrap","total_in","insert","ins_h","deflate_fast","hash_head","bflush","match_length","max_lazy_match","MIN_MATCH$1","deflate_slow","max_insert","prev_match","match_available","Config","good_length","max_lazy","nice_length","max_chain","configuration_table","max_block_size","pending_buf_size","max_start","DeflateState","gzhead","gzindex","last_flush","w_bits","hash_bits","Uint16Array","HEAP_SIZE$1","MAX_BITS$1","deflateResetKeep","deflateReset","ret","deflateInit2","windowBits","memLevel","deflate_1","beg","val","old_flush","hcrc","os","bstate","deflate_huff","deflate_rle","dictionary","dictLength","tmpDict","avail","_utf8len","q","zstream","Z_NO_FLUSH$1","Z_FULL_FLUSH$1","Z_FINISH$1","Z_OK$1","Z_STREAM_END$1","Z_DEFAULT_COMPRESSION$1","Z_DEFAULT_STRATEGY$1","Z_DEFLATED$1","Deflate","chunkSize","opt","raw","gzip","ended","chunks","dict","_dict_set","flush_mode","_flush_mode","onData","chunk","l","_l","flattenChunks","string2buf","c2","m_pos","str_len","buf_len","makePakoDeflate","deflate","pushData","binaryData","reduce","startDeflateWorker","createDeflateWorkerImpl","worker_1","onError","doStartDeflateWorker","Event","existingGlobalVariable","startRecordingImpl","startDeflateWorkerImpl","onRumStart","isRecording","startStrategy","stopStrategy","stopRecording","stopSegmentCollection","emit","takeFullSnapshot","initialOffset","left","top","d","positions","r","flushMutations","unsubscribeViewEnded","makeRecorderApi","datadogRum","startRumImpl","_c","ignoreInitIfSyntheticsWillInjectRum","isAlreadyInitialized","globalContextManager","newContext","getInternalContextStrategy","getInitConfigurationStrategy","bufferApiCalls","addTimingStrategy","startViewStrategy","addActionStrategy","clonedCommonContext","addErrorStrategy","providedError","doStartRum","startRumResults","internalMonitoring","externalContextProvider","telemetryContextProvider","monitoringMessageObservable","telemetryEventObservable","withContext","telemetry","toTelemetryEvent","setExternalContextProvider","provider","setTelemetryContextProvider","startInternalMonitoring","bridge_1","batch_1","endpoint","replicaEndpoint","replicaBatch","primaryBatch","createBatch","startBatchWithReplica","startRumInternalMonitoring","application_id","startRumEventBridge","batch","createRumBatch","unloadCallback","withReplicaApplicationId","makeRumBatch","startRumBatch","hasLitePlan","startRumSessionManagerStub","rawTrackingType","hasValidRumSession","replaySampleRate","startRumSessionManager","onHistoryChange","stopInstrumentingPushState","stopInstrumentingReplaceState","onHashChange","stopHistoryTracking","onLocationChange","stopHashTracking","createLocationChangeObservable","viewContextHistory","buildViewContext","startViewContexts","previousViewUrl","urlContextHistory","viewUrl","buildUrlContext","referrer","changeTime","startUrlContexts","onFocusChange","onBlurChange","stopForegroundTracking","stopBlurTracking","startForegroundContexts","trackInteractions","addAction","startActionCollection","startRumEventCollection","startLongTaskCollection","internalContext","session_id","user_action","startInternalContext","getInternalContext","stub","publicApi","rumPublicApi","overrideInitConfigurationForBridge","testCookieValue","isCookieCorrectlySet","areCookiesAuthorized","canHandleSession","canInitRum","baseConfiguration","validateAndBuildRumConfiguration","beforeInitCalls","addRumGlobalContext","removeRumGlobalContext","getRumGlobalContext","setRumGlobalContext","getInitConfiguration","setUser","newUser","sanitizedUser","email","sanitizeUser","removeUser","startSessionReplayRecording","stopSessionReplayRecording","onReady","enumerable","makeRumPublicApi"],"sourceRoot":""}